def fit_regression_models(expression, expression_indices): pred_expression = expression[:, (0, 1, 2, 3, 4, 5)] resp_expression = expression[:, (0, 1, 2, 3, 4, 5)] shared_index = Value('i', 0) pids = [] with ThreadSafeFile("output_noshift.txt", "w") as ofp: for p_index in xrange(NTHREADS): pid = os.fork() if pid == 0: while True: with shared_index.get_lock(): i = shared_index.value if i >= len(expression): break shared_index.value += 1 alpha, nonzero_coefs = estimate_covariates( pred_expression, resp_expression, i) output_str = "{}\t{}\t{}\n".format( expression_indices[i], alpha, "\t".join( str(expression_indices[x]) for x in nonzero_coefs)) print output_str, ofp.write(output_str) sys._exit() else: pids.append(pid) try: for pid in pids: os.waitpid(pid, 0) except: for pid in pids: os.kill(pid, signal.SIGTERM) raise
def check(token, characters, maxlength): global sharedToken global sharedN global sharedC sharedToken = Value(c_char_p, token.encode()) sharedN = Value('i', 0) sharedC = Value('i', 0) cores = cpu_count() pool = Pool(cores) secretFound = False print("Number of cores in use: " + str(cores)) for n in range(0, maxlength): with sharedN.get_lock(): sharedN.value = n generator = itertools.product(characters, repeat=n) for secret in pool.imap_unordered(checkSecret, generator, 5000): if secret or secret == "": shutDownPool(pool) secretFound = True outputSecret(secret) return secret if (secretFound == False): shutDownPool(pool) outputSecret(secret)
class BankAccount(object): def __init__(self, owner, initial_deposit): self.amount = Value(c_double, initial_deposit) self.owner = owner def __str__(self): return "%s: %s€" % (self.owner, self.amount.value) def virement(self, money): with self.amount.get_lock(): # get current amount current_amount = self.amount.value # network slow time sleep(0.01) # doing computation current_amount += money # hard drive latency sleep(0.01) self.amount.value = current_amount
class Main_System(object): # the Main_System does not need to keep a copy of network # only the copy of network inside TrainDQN class is modified by training, so we pass its state_dict to subprocesses def __init__(self, train, num_of_processes, others=''): self.train = train self.processes = [] self.actor_update_time = 10. self.lr_step = 0 self.pending_training_updates = Value('d', 0., lock=True) # somehow RawValue also needs us to call ".value", otherwise it says the type is c_double or c_int self.episode = RawValue('i', 0) self.t_done = Value('d', 0., lock=True) self.last_achieved_time = RawValue('d', 0.) # set the data going to subprocesses: self.train.memory.start_proxy_process( (self.pending_training_updates, self.episode, self.t_done, self.last_achieved_time), self.train.transitions_storage, (self.train.batch_size, self.train.memory.tree.data_size)) # the following will create threads, which not end and cause error (not exiting) spawn = mp.get_context('spawn') self.manager = spawn.Manager() self.MemoryInputQueue = self.manager.Queue() self.end_event = self.manager.Event() self.pause_event = self.manager.Event() self.learning_in_progress_event = self.manager.Event() # actors self.ActorReceivePipe, self.ActorUpdatePipe = spawn.Pipe( False ) # unidirectional pipe that send message from conn2 to conn1 seed = random.randrange(0, 9999999) self.worker_manager = spawn.Process( target=worker_manager, args=(copy.deepcopy(train.net).cpu(), (self.MemoryInputQueue, self.ActorReceivePipe, self.end_event, self.pause_event), num_of_processes, seed, others)) # store and manage experience (including updating priority and potentially sampling out replays) # all the arguments passed into it are used (**by fork initialization in RL module**). # somehow RawValue also needs us to call ".value" ? Otherwise it says the type is c_double / c_int self.train.memory.set_memory_source( self.MemoryInputQueue, (self.pause_event, self.end_event, self.learning_in_progress_event)) self.backup_period = self.train.backup_period def __call__(self, num_of_episodes): started = False self.worker_manager.start() last_time = time.time() last_idle_time = 0. updates_done = 0. # We assume batch_size is 256 and each experience is learned 8 times in RL.py, and when we change, we use the rescaling factor below to implement. # If we disable training, we use 'inf' instead to make the condition of training always False. downscaling_of_default_num_updates = ( 8. / args.n_times_per_sample) * ( args.batch_size / 256.) if args.train else float('inf') while self.episode.value < num_of_episodes or ( self.episode.value < args.maximum_trails_before_giveup and not self.learning_in_progress_event.is_set()): something_done = False # check whether nothing is done in one event loop remaining_updates = self.pending_training_updates.value - updates_done if remaining_updates >= 1. * downscaling_of_default_num_updates: if remaining_updates >= 150. * downscaling_of_default_num_updates and not self.pause_event.is_set( ): self.pause_event.set() print('Wait for training') loss = self.train() # if we parallelize the training as a separate process, the following block should be deleted if loss != None: updates_done += 1. * downscaling_of_default_num_updates something_done = True # one training step is done if not started: started = True # to reduce the frequency of calling "get_lock()", we only periodically reset the shared data "pending_training_updates" if updates_done >= 200. * downscaling_of_default_num_updates or self.pause_event.is_set( ): with self.pending_training_updates.get_lock(): self.pending_training_updates.value -= updates_done updates_done = 0. if remaining_updates < 50. * downscaling_of_default_num_updates and self.pause_event.is_set( ): self.pause_event.clear() if self.t_done.value >= self.actor_update_time: self.scale_up_actor_update_time( self.last_achieved_time.value) if not self.ActorReceivePipe.poll( ) and started and not args.LQG: self.ActorUpdatePipe.send(self.train.net.state_dict()) with self.t_done.get_lock(): self.t_done.value = 0. something_done = True if something_done: # print out how much time the training process has been idle for if last_idle_time != 0. and time.time() - last_time > 40.: print( 'trainer pending for {:.1f} seconds out of {:.1f}'. format(last_idle_time, time.time() - last_time)) last_idle_time = 0. last_time = time.time() # if nothing is done, wait. if not something_done: time.sleep(0.01) last_idle_time += 0.01 self.adjust_learning_rate() self.end_event.set() self.worker_manager.join() return def scale_up_actor_update_time(self, achieved_time): changed = False if achieved_time > 80. and self.actor_update_time <= 150.: self.actor_update_time = 1000. changed = True elif achieved_time > 20. and self.actor_update_time <= 50.: self.actor_update_time = 150. changed = True elif achieved_time > 10. and self.actor_update_time <= 25.: self.actor_update_time = 50. changed = True elif achieved_time > 5. and self.actor_update_time <= 10.: self.actor_update_time = 25. changed = True if changed and args.train: print('actor_update_time adjusted to {:.1f}'.format( self.actor_update_time)) def adjust_learning_rate(self): # the learning rate schedule is written in "arguments.py" if self.episode.value > args.lr_schedule[self.lr_step][ 0] and self.last_achieved_time.value == t_max: args.lr = min(args.lr_schedule[self.lr_step][1], args.lr) self.lr_step += 1 if args.train: for param_group in self.train.optim.param_groups: param_group['lr'] = args.lr print( colored('learning rate set to {:.2g}'.format(args.lr), attrs=['bold']))