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!')
