Hello, does anyone here know the timescale thermal effects tend to happen on? I heard the other day there existed one, and that there also existed light matter interactions which happen on timescales shorter than thermal effects.
I was wanting to know this timescale, so I can quantitatively say when an effect is no longer considered thermal.
@user400188 Perhaps a place to start is that thermal information can propagate no faster than the speed of sound, and that any equilibriation must allow phonons to cross your volume of interest many times.
@ACuriousMind I still teach basic graphical analysis in lab, and I still rig the requested graphs so that the functions are lines in case someone is hand graphing them. But I accept and encourage the use of computers to create the graphs. Next semester I'm going to request lab submissions via the learning management system, so computerized graphs become required.
The impossibility of intelligence explosion / Chollet see also aaronson https://www.scottaaronson.com/blog/?p=3553 and barak https://windowsontheory.org/2017/12/09/on-the-impossiblity-of-intelligence-explosion/
'Since the Poincaré group (or more precisely its 2-cover) has a semidirect product structure by an Abelian group N, one can used a special case of the general theory of induced representations, known as Wigner's little group method' hmm
@Kaumudi.H even though I use a laptop (very like yours in fact) I use an external keyboard and mouse. I find it easier to work with given that I spend hours a day at the keyboard.
I'd say you might want to start by looking up a tutorial on Python's multiprocessing and running through it quickly to get a general sense of how it works
You might be able to get away with basic usage of the Process class
Yeah, that's talking about loading the data using several processes at once. But it doesn't seem to say anything about actually running computations in parallel.
If you pass num_workers to the DataLoader() constructor it will use that many extra processes to load the data, but again, that's just loading, not actually calculating.
I can't say for sure without knowing exactly what you're doing (i.e. seeing code), but I think you might need to create two functions, one to do your CPU tasks and one to do your GPU tasks, pass each one to a torch.multiprocessing.Process constructor (so you have two Process objects), and start() them
I only know about reactor cooling system corrosion rates. As long as my cooling systems don't fail I'm not that fussed what goes on inside the core :-)
The thing I'm doing is basically just 2 things 1. grab a minibatch from a hdf5 file 2. train a neural network on that mini-batch
what I'd like to do is 1. grab 10 minibatches from a hdf5 file and send it into a que using the CPU, 2. train on those mini batches sequentially using the GPU 3. while the GPU is training, continue to grab minibatches using the CPU and send those minibatches to the que
this way the que is populated (roughly) as fast as the GPU is training on them and I'll save a lot of time
right now it's like CPU grabs a minibatch GPU trains CPU grabs a minibatch GPU trains
keras has that method above which does exactly what I wanna do
specifically: "The generator is run in parallel to the model, for efficiency. For instance, this allows you to do real-time data augmentation on images on CPU in parallel to training your model on GPU."
I think you could use a Queue (in your case, torch.multiprocessing.Queue) which is shared between a "loader" Process and a "trainer" Process. Have the "loader" load minibatches from files, maybe using a for loop, and once each one is loaded, push it to the Queue.
In the other process, you just pop minibatches from the Queue and use them to train the network. Again you can do this using a for loop.
@enumaris Concurrent programming (like multiprocessing) takes a certain way of thinking. It's not easy, exactly, but once you get a good mental model it doesn't seem so complicated anymore. From the way you're talking about it I wonder if you might not be there yet.
@enumaris here's an outline, at least. I don't expect that you can literally just copy this and fill in the blanks to get something runnable, but in broad strokes this is how you'd implement the concurrent producer-consumer model I mentioned above.
i.e. there might be errors or something, I haven't tried to use this
@enumaris No, it loads one at a time. After a minibatch is loaded, the loader process places it in a queue and goes on to loading the next minibatch, while the trainer process takes the former one out of the queue and starts using it to train the NN.
This is written assuming you have a total of 10 minibatches. If you have more, change the number accordingly.
I think there should be no problem with raising the maxsize if you like. It just means more memory might be used, since you might have more than two minibatches loaded into memory at once.
@enumaris Shouldn't be a problem. As long as you only access the GPU from the trainer thread, you will never have more than one minibatch loaded into GPU memory at once.
@enumaris No, sorry. FWIW I think the way to learn how to use the multiprocessing module is to learn about concurrent programming in general. Regardless of which language you're working in, it's all based on the same few fundamental structures.
What really helped me learn about this was taking an operating systems class in which I had to implement a mutex (the most fundamental concurrent programming structure) for an assignment.
If you want to implement mutexes for yourself, great, but in practice it's a bit of a time sink :-P
It can be used to lock a resource to one thread so that other threads can't access it at the same time
(or equivalently with processes)
Pretty much everything in the Python threading module (or multiprocessing) is based on mutexes at some level. They're probably not implemented in Python, though, they're a facility provided by the operating system.
I'm trying to think of which way is better...to do that and keep the loop in the loader...or...to just write some code to figure out exactly how many steps I need to be taking...
oh wait, I already did the second part when I did this model in keras lol
I guess if I mess up and have the loader load fewer batches than the trainer is expecting...at some point...my program will break...
that's kinda worrisome since it takes me like 3 hours to do one epoch...and if I set it to train for 100 epochs I'd hate the program to break after 300 hours of training lol
@enumaris Well, yes, if the trainer is programmed to expect a specific number of batches and the loader doesn't load that many, it will break. (Or rather, the trainer process will hang.) But it seems fairly straightforward to write your code in a way that that doesn't happen.
You can use the technique I mentioned of passing None, and/or you can call q.get() with a timeout parameter so it doesn't wait forever.
But again, you can just push None or something to indicate that there are no more minibatches. That way it's totally safe - the trainer knows exactly when it's done.
What does the if __name__ == "__main__": do?
# Threading example
import time, thread
def myfunction(string, sleeptime, lock, *args):
while 1:
lock.acquire()
time.sleep(sleeptime)
lock.release()
time.sleep(sleeptime)
if __name__ == "__main__":
lock = threa...
@Slereah you don't know much about renormalization group. I consider you know much about it. I have written an mail to a profeesor in that field asking for PhD opportunity, but he doesn't reply me.
I am not sure if I really want to work on renormalization group. I know too little about it. But I see quite a few professors work on asymptotic safe gravity.
What does the if __name__ == "__main__": do?
# Threading example
import time, thread
def myfunction(string, sleeptime, lock, *args):
while 1:
lock.acquire()
time.sleep(sleeptime)
lock.release()
time.sleep(sleeptime)
if __name__ == "__main__":
lock = threa...
