def start_fetch(config): """Launch workers and consumer. * Workers : one by url. The worker fetch a url and return fetch time * consumer : Just one. Get datas returned by workers and write them to csv files""" # Create queues result_queue = Queue() # for results stop_process = Value('i', 0) # Integer shared value # Start fetch all urls for url_config in config.get('urls'): # Launch workers : process who fetch website and push result in result_queue Process(target=worker, args=(stop_process, result_queue, config, url_config)).start() # Launch consumer : process that write results from result_queue in csv files consumer_process = Process(target=consumer, args=(stop_process, result_queue, config)) consumer_process.start() # run forever try: consumer_process.join() #while True: # time.sleep(0.5) except KeyboardInterrupt: pass finally: stop_process.value = 1
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)
def add_export(self, export_range, export_dir): if system() == 'Darwin': set_start_method('spawn') logger.debug("Adding new video export process.") should_terminate = Value(c_bool, False) frames_to_export = Value(c_int, 0) current_frame = Value(c_int, 0) rec_dir = self.g_pool.rec_dir user_dir = self.g_pool.user_dir start_frame = export_range.start end_frame = export_range.stop + 1 #end_frame is exclusive frames_to_export.value = end_frame - start_frame # Here we make clones of every plugin that supports it. # So it runs in the current config when we lauch the exporter. plugins = self.g_pool.plugins.get_initializers() out_file_path = verify_out_file_path(self.rec_name, export_dir) process = Export_Process( target=export, args=(should_terminate, frames_to_export, current_frame, rec_dir, user_dir, self.g_pool.min_data_confidence, start_frame, end_frame, plugins, out_file_path)) self.new_export = process
def add_export(self,export_range,export_dir): if system() == 'Darwin': set_start_method('spawn') logger.debug("Adding new video export process.") should_terminate = Value(c_bool,False) frames_to_export = Value(c_int,0) current_frame = Value(c_int,0) rec_dir = self.g_pool.rec_dir user_dir = self.g_pool.user_dir start_frame= export_range.start end_frame= export_range.stop+1 #end_frame is exclusive frames_to_export.value = end_frame-start_frame # Here we make clones of every plugin that supports it. # So it runs in the current config when we lauch the exporter. plugins = self.g_pool.plugins.get_initializers() out_file_path=verify_out_file_path(self.rec_name,export_dir) process = Export_Process(target=export, args=(should_terminate,frames_to_export,current_frame, rec_dir,user_dir,self.g_pool.min_data_confidence,start_frame,end_frame,plugins,out_file_path)) self.new_export = process
p_game = Process(target=game_handler, args=[ shared_data, train_monitor, play_monitor, enough_training_data, stop ]) p_game.start() p_eval = Process(target=evaluation_handler, args=[eval_monitor, play_monitor, stop]) p_eval.start() cmd = None while cmd != 'exit': cmd = input() if cmd == 'start': notify_all(play_monitor) elif cmd == 'exit': print('Inner exit condition') stop.value = True break print('Exit from cmd loop. Waiting for processes to finish.') p_game.join() print('game Process Done') p_nn.join() print('nn Process Done') p_game.join() print('game Process Done')
if args.target_update_mode == 'episodic': hard_update(agent.critic_target, agent.critic) if done_n[0] or terminal: print('train epidoe reward', episode_reward) episode_step = 0 break if not args.fixed_lr: agent.adjust_lr(i_episode) # writer.add_scalar('reward/train', episode_reward, i_episode) rewards.append(episode_reward) # if (i_episode + 1) % 1000 == 0 or ((i_episode + 1) >= args.num_episodes - 50 and (i_episode + 1) % 4 == 0): if (i_episode + 1) % args.eval_freq == 0: tr_log = { 'num_adversary': 0, 'best_good_eval_reward': best_good_eval_reward, 'best_adversary_eval_reward': best_adversary_eval_reward, 'exp_save_dir': exp_save_dir, 'total_numsteps': total_numsteps, 'value_loss': value_loss, 'policy_loss': policy_loss, 'i_episode': i_episode, 'start_time': start_time } copy_actor_policy(agent, eval_agent) test_q.put([eval_agent, tr_log]) env.close() time.sleep(5) done_training.value = True
def train(self): # Convenience env = self.env # Start the async logger finished_training = Value("i", 0) p_log = Process(target=self.logger, args=(self.log_queue, finished_training), daemon=True) p_log.start() self.explore() self.start_time = time.time() print("Training.\n\n\n") while self.T < self.args.t_max: state = env.reset() episode_finished = False self.episode_reward = 0 self.episode_bonus_only_reward = 0 self.episode_steps = 0 self.epsilon = self.epsilon_schedule() new_epsilon = self.epsilon self.start_of_episode() self.print_time() will_save_states = self.args.eval_images and self.T - self.training_video_T > ( self.args.t_max // self.args.eval_images_interval) video_states = [] while not episode_finished: # TODO: Cleanup # new_epsilon = self.epsilon if self.args.count_epsilon: exp_bonus, exp_info = self.exploration_bonus(state, action=0) if self.args.epsilon_decay: new_epsilon *= self.args.decay_rate new_epsilon = max( self.epsilon, self.args.epsilon_scaler * exp_bonus / self.max_exp_bonus, new_epsilon) if self.args.tb and self.T % self.args.tb_interval == 0: self.log_value("Epsilon/Count", new_epsilon, step=self.T) action, action_info = self.select_action(state, new_epsilon) if not self.args.count_epsilon: exp_bonus, exp_info = self.exploration_bonus(state, action) density = 1 if self.args.count: density = exp_info["Density"] if self.args.render or will_save_states: debug_info = {} debug_info.update(action_info) debug_info.update(exp_info) if self.args.render: if self.args.slow_render: time.sleep(0.1) self.env.debug_render(debug_info) if will_save_states: debug_state = self.env.debug_render(debug_info, mode="rgb_array") video_states.append(debug_state) if self.args.visitations: self.visitations() self.visualisations() state_new, reward, episode_finished, env_info = self.env.step( action) self.T += 1 self.episode_steps += 1 # Action State Count stuff if available if "Action_Counts" in env_info: self.Action_State_Counts.append(env_info["Action_Counts"]) # If the environment terminated because it reached a limit, we do not want the agent # to see that transition, since it makes the env non markovian wrt state if "Steps_Termination" in env_info: # HACK self.agent.T += 1 episode_finished = True break self.episode_reward += reward if self.args.no_exploration_bonus: # 0 out the exploration bonus exp_bonus = 0 self.episode_bonus_only_reward += exp_bonus self.agent.experience(state, action, reward, state_new, 1, episode_finished, exp_bonus, density) self.train_agent() state = state_new if not self.args.plain_print: print("\x1b[K_{}_".format(self.T), end="\r") if self.T % 1000 == 0: self.print_time() if self.T - self.eval_T >= self.args.t_max // self.args.eval_interval: self.eval_agent() self.episode += 1 self.Episode_Rewards.append(self.episode_reward) self.Episode_Lengths.append(self.episode_steps) self.Episode_Bonus_Only_Rewards.append( self.episode_bonus_only_reward) self.end_of_episode() self.save_values() if will_save_states: self.save_video( "{}/training/Training_Policy__T_{}__Ep_{}".format( self.args.log_path, self.T, self.episode), video_states) self.training_video_T = self.T self.end_of_training_save() print() print("Environment {:.2} GB".format( asizeof.asizeof(self.env) / 1024.0**3)) print("Player Positions {:.2} GB".format( asizeof.asizeof(self.Player_Positions) / 1024.0**3)) print("Visited state {:.2} GB".format( asizeof.asizeof(self.Visited_States) / 1024.0**3)) print("Trained states {:.2} GB".format( asizeof.asizeof(self.Trained_On_States) / 1024.0**3)) print("Agent {:.2} GB".format(asizeof.asizeof(self.agent) / 1024.0**3)) print("Agent Replay {:.2} GB".format( asizeof.asizeof(self.agent.replay) / 1024.0**3)) if self.args.count: print("Exp Model {:.2} GB".format( asizeof.asizeof(self.exp_model) / 1024.0**3)) if self.args.render: print("\n\nClosing render window") self.env.debug_render(close=True) print("\nEvaluating Last Agent\n") self.eval_agent(last=True) print("Last Evaluation Finished") # Close out the logging queue print("\nClosing queue") finished_training.value = 10 self.log_queue.close() time.sleep(5) print("Waiting for queue to finish") # p_log.join() p_log.join(timeout=1) print("\nFinished\n")
for IO_sector in IO_sectors_list: if IO_sector not in tot_inventory_per_doll: #case where the IO sector does not call any other sector continue for chem in init_classif_conc_dict: if init_classif_conc_dict[chem]['EF_cancer'] == init_classif_conc_dict[chem]['EF_non_cancer'] == 'Null': #case where the chemical does not have positive EF continue else: tasks_to_be_done.put([IO_sector,chem,direct_inventory_per_doll[IO_sector],tot_inventory_per_doll[IO_sector],init_classif_conc_dict[chem],breathing_rate,SF_non_cancer_data,SF_cancer_data]) count_tasks += 1 writen_file.writerow([IO_sector,chem,len(direct_inventory_per_doll[IO_sector]),sum(direct_inventory_per_doll[IO_sector]),len(tot_inventory_per_doll[IO_sector]),sum(tot_inventory_per_doll[IO_sector]),len(init_classif_conc_dict[chem]['conc']),len(init_classif_conc_dict[chem]['EF_cancer']),len(init_classif_conc_dict[chem]['EF_non_cancer']),breathing_rate,len(SF_non_cancer_data),len(SF_cancer_data)]) print str(count_tasks) + " elements added to the main queue" while tasks_to_be_done.qsize() > 0: time_run = time.clock() print str(int(100 * (count_tasks - tasks_to_be_done.qsize()) / count_tasks))," % of main queue processed in ",int(time_run/60),"min",int(time_run)-60*int(time_run/60),"sec",int(1000*(time_run-int(time_run))),"thousandth, ",tasks_to_be_done.qsize()," task to be done",tasks_to_be_written.qsize()," task to be written",task_for_cumul.qsize()," task to be cumulated" print mp.active_children() time.sleep(5) continue kill_switch_processing.value = 1 kill_switch_writing.value = 1 kill_switch_cumul.value = 1 time_run = time.clock() print "main queue processed in ",int(time_run/60),"min",int(time_run)-60*int(time_run/60),"sec and",int(1000*(time_run-int(time_run))),"thousandth" while tasks_to_be_written.qsize() > 0 or task_for_cumul.qsize() > 0: time_run = time.clock() print "writing and aggregating results: ",str(int(100 * (count_tasks - tasks_to_be_written.qsize()) / count_tasks))," % results writene and ",str(int(100 * (count_tasks - task_for_cumul.qsize()) / count_tasks))," % results aggregated in ",int(time_run/60),"min",int(time_run)-60*int(time_run/60),"sec",int(1000*(time_run-int(time_run))),"thousandth" time.sleep(5) while cumulation.is_alive(): print "printing aggregated results" time_run = time.clock() print "calculation done in ",int(time_run/60),"min",int(time_run)-60*int(time_run/60),"sec",int(1000*(time_run-int(time_run))),"thousandth"
def start_distributed_mp(): # Setup # To continue training, give path to state dict state_dict_path = None # Learner specific learner_training_steps = 1000000 learner_learning_rate = 0.00025 learner_policy_update = 50 learner_optimizer = 'Adam' learner_device = 'cuda' learner_job_max_time = 60*60*24 -60*10 #2 hours 58min learner_save_date = datetime.now().strftime("%d_%b_%Y_%H_%M_%S") learner_eval_p_errors = [0.1, 0.2, 0.3] learner_eval_no_episodes = 10 learner_eval_freq = -1 # -1 for no logging # Actor specific actor_max_actions_per_episode = 75 actor_size_local_memory_buffer = 100 actor_no_envs = 16 #number of envs/actor no_cuda_actors = 1 no_cpu_actors = 0 actor_no_actors = no_cuda_actors + no_cpu_actors #epsilon = calculateEpsilon(0.8, 7, actor_no_actors * actor_no_envs) epsilon = calculateEpsilon(0.8, 7, actor_no_envs) epsilon_delta = 0.005 env_p_error_interval_start = 0.1 env_p_error_interval_final = 0.3 env_p_error_interval_increase = 0.00005 env_p_error_strategy = 'random' # either {'random', 'linear'} # Replay Memory specific replay_memory_size = 1000000 replay_memory_alpha = 0.6 replay_memory_beta = 0.4 replay_memory_size_before_sampeling = 5000#replay_memory_size*0.05 replay_memory_batch_in_queue_limit = 10 #number of batches in queue to learner log_priority_dist = True log_write_frequency = 500 log_priority_sample_max = 10 log_priority_sample_interval_size = 0.01 # Shared batch_size = 16 discount_factor = 0.95 env = "toric-code-v0" env_config = { "size":9, "min_qubit_errors": 0, "p_error": 0.1 } model = ResNet18 #model = NN_11 #model = NN_17 model_config = {"system_size": env_config["size"], "number_of_actions": env_config["size"] } if not state_dict_path == None: checkpoint = torch.load(state_dict_path, map_location=learner_device) else: checkpoint = None # Pre-load initial network weights if model == NN_11 or model == NN_17: m = model(model_config["system_size"], model_config["number_of_actions"], learner_device) else: m = model() # load checkpoint params if not state_dict_path == None: m.load_state_dict(checkpoint['model_state_dict']) params = parameters_to_vector(m.parameters()).detach().cpu().numpy() no_params = len(params) #Comm setup actor_io_queue = mp.Queue() learner_io_queue = mp.Queue() io_learner_queue = mp.Queue() shared_mem_weight_id = Value('i') shared_mem_weight_id.value = 0 # Write initial weights to shared memory shared_mem_weights = Array('d', no_params) # Shared memory for weights mem_reader = np.frombuffer(shared_mem_weights.get_obj()) # create memory reader for shared mem np.copyto(mem_reader, params) # Write params to shared mem del m # delete tmp model to load network params to free up mem """ Learner Process """ learner_args = { "train_steps" :learner_training_steps, "batch_size" :batch_size, "learning_rate" :learner_learning_rate, "policy_update" :learner_policy_update, "discount_factor" :discount_factor, "optimizer" :learner_optimizer, "model" :model, "model_config" :model_config, "model_no_params" :no_params, "device" :learner_device, "env" :env, "env_config" :env_config, "job_max_time" :learner_job_max_time, "save_date" :learner_save_date, "learner_io_queue" :learner_io_queue, "io_learner_queue" :io_learner_queue, "shared_mem_weights" :shared_mem_weights, "shared_mem_weight_id" :shared_mem_weight_id, "learner_eval_p_errors" :learner_eval_p_errors, "learner_eval_no_episodes" :learner_eval_no_episodes, "learner_eval_freq" :learner_eval_freq, "learner_checkpoint" :checkpoint } """ Memory Process """ mem_args = { "capacity" :replay_memory_size, "alpha" :replay_memory_alpha, "beta" :replay_memory_beta, "batch_size" :batch_size, "io_learner_queue" :io_learner_queue, "learner_io_queue" :learner_io_queue, "actor_io_queue" :actor_io_queue, "batch_in_queue_limit" :replay_memory_batch_in_queue_limit, "no_actors" :actor_no_actors, "replay_size_before_sampling" :replay_memory_size_before_sampeling if not (replay_memory_size_before_sampeling is None) else min(batch_size, int(replay_memory_size*0.1)), "save_date" :learner_save_date, "log_priority_dist" :log_priority_dist, "log_write_frequency" :log_write_frequency, "log_priority_sample_max" :log_priority_sample_max, "log_priority_sample_interval_size" :log_priority_sample_interval_size, "start_time" :learner_save_date } """ Actor Processes """ actor_args = { "max_actions_per_episode" :actor_max_actions_per_episode, "size_local_memory_buffer" :actor_size_local_memory_buffer, "env_config" :env_config, "model" :model, "model_config" :model_config, "model_no_params" :no_params, "env" :env, "discount_factor" :discount_factor, "no_envs" :actor_no_envs, "actor_io_queue" :actor_io_queue, "shared_mem_weights" :shared_mem_weights, "shared_mem_weight_id" :shared_mem_weight_id, "epsilon_delta" :epsilon_delta, "env_p_error_start" :env_p_error_interval_start, "env_p_error_final" :env_p_error_interval_final, "env_p_error_delta" :env_p_error_interval_increase, "env_p_error_strategy" :env_p_error_strategy, "no_cuda_actors" :no_cuda_actors, "no_cpu_actors" :no_cpu_actors, "log_actor" :log_priority_dist } # log header to tensorboard if could_import_tb: log("runs/{}/RunInfo/".format(learner_save_date), actor_args, learner_args, mem_args, state_dict_path) io_process = mp.Process(target=io, args=(mem_args,)) actor_process = [] for i in range(actor_no_actors): if i < no_cuda_actors : actor_args["device"] = 'cuda' else: actor_args["device"] = 'cpu' actor_args["id"] = i #actor_args["epsilon_final"] = epsilon[i * actor_no_envs : i * actor_no_envs + actor_no_envs] actor_args["epsilon_final"] = epsilon actor_process.append(mp.Process(target=actor, args=(actor_args,))) actor_process[i].start() io_process.start() try: learner(learner_args) except: tb = SummaryWriter("runs/{}/RunInfo/".format(learner_save_date)) tb.add_text("RunInfo/Error_Message", sys.exc_info()[0]) tb.close() time.sleep(2) print("Training done.") for i in range(actor_no_actors): actor_process[i].terminate() io_process.terminate() print("Script complete.")
if len(sys.argv) != 2 and len(sys.argv) != 3: print("... <num_of_parallel_procs> [<iterations>(default: 2000)]") sys.exit(0) if len(sys.argv) == 3: iterations = int(sys.argv[2]) else: iterations = 2000 num_parallel_procs = int(sys.argv[1]) for i in range(num_parallel_procs): if num_procs.value < num_parallel_procs: p = Process(target=do, args=(lock, num_procs, terminate, iterations, requests)) p.start() procs.append(p) time.sleep(1) start = time.perf_counter() r1 = requests.value time.sleep(4) end = time.perf_counter() r2 = requests.value rate = (r2 - r1) / (end - start) terminate.value = 1 with lock: print("*** procs: %2i rate: %0.1f ***" % (num_procs.value, rate)) finish()
metadata = dict(feed, id=id) if type(feed) is dict else dict( source_feed=source_feed, id=id) specs = ','.join( '%s=%s' % item for item in sorted(metadata.items(), key=lambda item: item[0])) logger.info('Adding feed #%i: %s %s' % (i, id, specs)) # create job root = os.path.join(args.data_dir, id) kwargs = dict(ext='ts', parallel_downloads=args.parallel_downloads, chunk_size=args.chunk_size) job = Process(target=pull_worker, args=(source_feed, root, chunk_metadata_endpoint, metadata, kwargs, stop)) jobs.append(job) for job in jobs: job.start() serve_chunks(args.data_dir, args.host, args.port, args.prefix, args.full_path) # TODO: not implemented, add signal handler stop.value = 1 for job in jobs: job.join() logger.info('All stopped!')