def __init__(self, actor_l, value_l, transition_model, encoder,
observation_model, reward_model, child_conn, results_dir, id):
super(Worker_actor, self).__init__()
self.process_id = id
self.actor_l, self.value_l = actor_l, value_l
self.encoder, self.reward_model, self.transition_model, self.observation_model = encoder, reward_model, transition_model, observation_model
self.child_conn = child_conn
# Get model_modules
self.env_model_modules = get_modules([
self.transition_model, self.encoder, self.observation_model,
self.reward_model
])
self.value_model_l_modules = get_modules([self.value_l])
self.actor_optimizer_l = optim.Adam(
self.actor_l.parameters(),
lr=0
if args.learning_rate_schedule != 0 else args.actor_learning_rate,
eps=args.adam_epsilon)
self.value_optimizer_l = optim.Adam(
self.value_l.parameters(),
lr=0
if args.learning_rate_schedule != 0 else args.value_learning_rate,
eps=args.adam_epsilon)
self.metrics = {'episodes': [], 'actor_loss': [], 'value_loss': []}
self.metrics['episodes'].extend(
[i for i in range(1, args.seed_episodes + 1)])
self.losses = []
self.count = 0
self.results_dir = results_dir
def _validate_definitions():
"""Validates py definitions.
"""
# Set specialization modules.
modules = utils.get_modules(_DIR, _TYPEOF)
# Set validation context.
ctx = utils.DefinitionsValidationContext(modules)
# Validate.
validate_root.validate(ctx)
for module in [i for i in ctx.modules if i != ctx.root]:
validate_topic.validate(ctx, module)
# Set errors.
errors = ctx.get_errors()
# Set report.
report = []
if not errors:
report.append(_REPORT_BREAK)
report.append("{} {} specializations are valid.".format(
_PROJECT.upper(), _TYPEOF))
report.append(_REPORT_BREAK)
else:
error_count = len(reduce(operator.add, errors.values()))
report.append(_REPORT_BREAK)
report.append("SPECIALIZATIONS VALIDATION REPORT")
report.append(_REPORT_BREAK)
report.append("Specialization Type = {}".format(_TYPEOF))
report.append("Generated @ {}".format(datetime.datetime.now()))
report.append("Error count = {}".format(error_count))
report.append(_REPORT_BREAK)
# Set report errors.
for module, errors in sorted(errors.items()):
report.append("{}.py".format(module.__name__))
for idx, err in enumerate(errors):
report.append("Error #{}:\t{}.".format(idx + 1, err))
report.append("")
# Write to stdout.
for l in report:
print "ES-DOC :: {}".format(l)
return len(errors) == 0
def __init__(self, action_size, transition_model, encoder, reward_model,
observation_model):
self.encoder, self.reward_model, self.transition_model, self.observation_model = encoder, reward_model, transition_model, observation_model
self.merge_value_model = ValueModel(
args.belief_size, args.state_size, args.hidden_size,
args.dense_activation_function).to(device=args.device)
self.merge_actor_model = MergeModel(
args.belief_size, args.state_size, args.hidden_size, action_size,
args.pool_len,
args.dense_activation_function).to(device=args.device)
self.merge_actor_model.share_memory()
self.merge_value_model.share_memory()
# set actor, value pool
self.actor_pool = [
ActorModel(args.belief_size, args.state_size, args.hidden_size,
action_size,
args.dense_activation_function).to(device=args.device)
for _ in range(args.pool_len)
]
self.value_pool = [
ValueModel(args.belief_size, args.state_size, args.hidden_size,
args.dense_activation_function).to(device=args.device)
for _ in range(args.pool_len)
]
[actor.share_memory() for actor in self.actor_pool]
[value.share_memory() for value in self.value_pool]
self.env_model_modules = get_modules([
self.transition_model, self.encoder, self.observation_model,
self.reward_model
])
self.actor_pool_modules = get_modules(self.actor_pool)
self.model_modules = self.env_model_modules + self.actor_pool_modules
self.merge_value_model_modules = get_modules([self.merge_value_model])
self.merge_actor_optimizer = optim.Adam(
self.merge_actor_model.parameters(),
lr=0
if args.learning_rate_schedule != 0 else args.actor_learning_rate,
eps=args.adam_epsilon)
self.merge_value_optimizer = optim.Adam(
self.merge_value_model.parameters(),
lr=0
if args.learning_rate_schedule != 0 else args.value_learning_rate,
eps=args.adam_epsilon)
self.actor_pipes = [
Pipe() for i in range(1,
len(self.actor_pool) + 1)
] # Set Multi Pipe
self.workers_actor = [
Worker_actor(actor_l=self.actor_pool[i],
value_l=self.value_pool[i],
transition_model=self.transition_model,
encoder=self.encoder,
observation_model=self.observation_model,
reward_model=self.reward_model,
child_conn=child,
results_dir=args.results_dir,
id=i + 1)
for i, [parent, child] in enumerate(self.actor_pipes)
] # Set Worker_actor Using i'th actor_pipes
[w.start()
for i, w in enumerate(self.workers_actor)] # Start Single Process
self.metrics = {
'episodes': [],
'merge_actor_loss': [],
'merge_value_loss': []
}
self.merge_losses = []
def init(cfg):
plugins = utils.get_modules(cfg, "rules")
rule_plugins.update(plugins)
def import_dir(self, path):
""" import existing directory, using blank masks. """
self.widgets = []
for name in utils.get_modules(path):
self.set_widget(name)
def init(cfg):
global warning_send_thread
warning_send_thread = WarningSendThread(cfg)
warning_send_thread.start()
plugins = utils.get_modules(cfg, "senders")
sender_plugins.update(plugins)
