def __init__(self): mgr = SyncManager() mgr.start(signal.signal, (signal.SIGINT, signal.SIG_IGN)) self.ns_default = mgr.Namespace() self.ns_default.error = None self.ns_stats = mgr.Namespace() self.input_queue = mgr.Queue(maxsize=100) self.error_occurred = mgr.Event() self.error_processed = mgr.Event() self.batch_done = mgr.Event() self.mgr = mgr self.stats_lock = mgr.Lock() self.main_lock = mgr.Lock()
def prepare_experiment(env, args): # Manager to share PER between a learner and explorers SyncManager.register('PrioritizedReplayBuffer', PrioritizedReplayBuffer) manager = SyncManager() manager.start() kwargs = get_default_rb_dict(args.replay_buffer_size, env) kwargs["check_for_update"] = True global_rb = manager.PrioritizedReplayBuffer(**kwargs) # queues to share network parameters between a learner and explorers n_queue = 1 if args.n_env > 1 else args.n_explorer n_queue += 1 # for evaluation queues = [manager.Queue() for _ in range(n_queue)] # Event object to share training status. if event is set True, all exolorers stop sampling transitions is_training_done = Event() # Lock lock = manager.Lock() # Shared memory objects to count number of samples and applied gradients trained_steps = Value('i', 0) return global_rb, queues, is_training_done, lock, trained_steps
def main(): config = load_config(extra_args_func=gw_args) init_logger(config) log.info(f'Backend.AI Gateway {__version__}') log.info(f'runtime: {env_info()}') log_config = logging.getLogger('ai.backend.gateway.config') log_config.debug('debug mode enabled.') if config.debug: aiohttp.log.server_logger.setLevel('DEBUG') aiohttp.log.access_logger.setLevel('DEBUG') else: aiohttp.log.server_logger.setLevel('WARNING') aiohttp.log.access_logger.setLevel('WARNING') asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) num_workers = os.cpu_count() manager = SyncManager() manager.start(lambda: signal.signal(signal.SIGINT, signal.SIG_IGN)) shared_states = manager.Namespace() shared_states.lock = manager.Lock() shared_states.barrier = manager.Barrier(num_workers) shared_states.agent_last_seen = manager.dict() try: aiotools.start_server(server_main, num_workers=num_workers, extra_procs=[event_router], args=(config, shared_states)) finally: manager.shutdown() log.info('terminated.')
def _enqueue_parent( manager: SyncManager, task_q: Queue, parent: ChunkTask, parent_children_count_d_shared: Dict, parent_children_count_d_locks: Lock, time_stamp: Optional[datetime] = None, ) -> None: with parent_children_count_d_locks[parent.id]: if not parent.id in parent_children_count_d_shared: # set initial number of child chunks parent_children_count_d_shared[parent.id] = len( parent.children_coords) # decrement child count by 1 parent_children_count_d_shared[parent.id] -= 1 # if zero, all dependents complete -> return parent if parent_children_count_d_shared[parent.id] == 0: del parent_children_count_d_shared[parent.id] parent_children_count_d_locks[ parent.parent_task().id] = manager.Lock() task_q.put(( create_parent_chunk_helper, (parent, None), )) return True return False
def main(args_): if args_.n_explorer is None: n_explorer = multiprocessing.cpu_count() - 1 else: n_explorer = args_.n_explorer assert n_explorer > 0, "[error] number of explorers must be positive integer" env = env_fn() # Manager to share PER between a learner and explorers SyncManager.register('PrioritizedReplayBuffer', PrioritizedReplayBuffer) manager = SyncManager() manager.start() global_rb = manager.PrioritizedReplayBuffer( obs_shape=env.observation_space.shape, act_dim=env.action_space.low.size, size=args_.replay_buffer_size) # queues to share network parameters between a learner and explorers queues = [Queue() for _ in range(n_explorer)] # Event object to share training status. if event is set True, all exolorers stop sampling transitions is_training_done = Event() # Lock lock = manager.Lock() # Shared memory objects to count number of samples and applied gradients trained_steps = Value('i', 0) n_transition = Value('i', 0) tasks = [] # Add explorers for i in range(n_explorer): tasks.append(Process( target=explorer, args=[global_rb, queues[i], trained_steps, n_transition, is_training_done, lock, env_fn, policy_fn, args_.local_buffer_size])) # Add learner tasks.append(Process( target=learner, args=[global_rb, trained_steps, is_training_done, lock, env_fn, policy_fn, args_.max_batch, args_.param_update_freq, *queues])) for task in tasks: task.start() for task in tasks: task.join()
def __init__(self, root: Path, output_dir: Path, mode: Cryptor, manager: SyncManager): """ `root`: The path to the target directory (not including the target) `output_dir`: The path to the output directory `mode`: Encryptor or Decryptor object `manager`: used to generate shared dictionary and lock for building directory """ self._mode = mode self._path_to_target = root self._output_dir = output_dir self._visited_dirs = manager.dict() # Dict[Path, str] self._lock = manager.Lock( ) # since `_visited_dirs` is the only mutated
clip_rewards=True, frame_stack=True, scale=False, ) env.seed(args.seed) env.action_space.seed(args.seed) env.observation_space.seed(args.seed) random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) torch.backends.cudnn.deterministic = args.torch_deterministic assert isinstance(env.action_space, Discrete), "only discrete action space is supported" m = SyncManager() m.start() lock = m.Lock() rb = CustomPrioritizedReplayBuffer(args.buffer_size, args.pr_alpha) q_network = QNetwork(env) target_network = QNetwork(env) target_network.load_state_dict(q_network.state_dict()) learn_q_network = QNetwork(env, device).to(device) learn_q_network.load_state_dict(q_network.state_dict()) learn_target_network = QNetwork(env, device).to(device) learn_target_network.load_state_dict(q_network.state_dict()) optimizer = optim.Adam(learn_q_network.parameters(), lr=args.learning_rate) print(device.__repr__()) print(q_network) global_step = torch.tensor(0)
epsilons = [ pow(0.4, 1 + (i / (n_explorer - 1)) * 7) for i in range(n_explorer) ] # apex paper n_queue = n_explorer n_queue += 1 # for evaluation # n_queue += 1 # for prefetch queues = [manager.Queue() for _ in range(n_queue)] # Event object to share training status. if event is set True, all exolorers stop sampling transitions is_training_done = Event() transitions = Value('i', 0) # Lock lock = manager.Lock() # Shared memory objects to count number of samples and applied gradients trained_steps = Value('i', 0) tasks = [] local_buffer_size = 200 # 100论文数据 episode_max_steps = step_limit for i in range(n_explorer): task = Process(target=explorer, args=[ global_rb, queues[i], trained_steps, is_training_done, lock, local_buffer_size, episode_max_steps, epsilons[i], transitions ])
def __init__(self, manager: SyncManager): self.clusters: List[Cluster] = manager.list( ) # インスタンス変数にサーバプロセスで管理するListを保持 self.lock: Lock = manager.Lock()
def _get_lock(self): manager = SyncManager() manager.start() sia_params_gen_lock = manager.Lock() return sia_params_gen_lock