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
