def signal_script_fail(return_code: int, msg="", die=False): if return_code: err_msg = "Failed to ".format(msg) if msg else "Fail" print(clr(err_msg, 'red')) if die: exit(return_code)
def end_train_task(self, model, optimizer, train_loader): optimizer.zero_grad() for _batch_idx, (data, target) in enumerate(train_loader): output = model(data) loss = functional.cross_entropy(output, target) loss.backward() grad = dict({}) crt_mode = dict({}) if self.merge_elasticities and self.constraints: # Add to previous matrices if in `merge` mode elasticity = self.constraints[0].elasticity else: elasticity = dict({}) for name, param in model.named_parameters(): if param.grad is not None: crt_mode[name] = param.detach().clone().view(-1) grad[name] = param.grad.detach().pow(2).clone().view(-1) if name in elasticity: elasticity[name].add_(grad[name]).view(-1) else: elasticity[name] = grad[name].clone().view(-1) new_constraint = Constraint(crt_mode, elasticity) if self.merge_elasticities: # Remove old constraints if in `merge` mode self.constraints.clear() self.constraints.append(new_constraint) print( clr(f"There are {len(self.constraints):d} elastic constraints!", attrs=["bold"]))
def run_here(opts): """ If there's a single run in the experiment we run it in this process by calling run in the script. """ prep_args = [opts.config_path, "--do"] if opts.copy_to_clipboard: prep_args.append("--cc") prepare_opts = prepare_parse_options(prep_args) # prepare_opts.args = opts.args prepare_opts.__dict__.update(vars(opts)) # Fast_check if cfg file is already prepared with open(opts.config_path) as handler: dummy_config = yaml.load(handler, Loader=yaml.SafeLoader) if "out_dir" in dummy_config and os.path.isdir(dummy_config["out_dir"]): opts.experiment_path = dummy_config["out_dir"] run_path = dummy_config["out_dir"] leaf_path = os.path.join(run_path, ".__leaf") cfg_path = os.path.join(run_path, "cfg.yaml") if os.path.isfile(leaf_path): with open(cfg_path) as handler: cfg = yaml.load(handler, Loader=yaml.SafeLoader) args = dict_to_namespace(cfg) print(clr("\nStarting\n", attrs=["bold"])) get_function(opts)(args) else: # Virgin cfg opts.experiment_path = prepare_experiment(prepare_opts) with os.scandir(opts.experiment_path) as fit: for entry in fit: if entry.name.startswith(".") or not entry.is_dir(): continue with os.scandir(entry.path) as fit2: for entry2 in fit2: if entry2.name.startswith(".") or not entry2.is_dir(): continue run_path = entry2.path leaf_path = os.path.join(run_path, ".__leaf") cfg_path = os.path.join(run_path, "cfg.yaml") if os.path.isfile(leaf_path): with open(cfg_path) as handler: cfg = yaml.load(handler, Loader=yaml.SafeLoader) args = dict_to_namespace(cfg) print(clr("\nStarting\n", attrs=["bold"])) get_function(opts)(args)
def launch_experiment(opts): resources = LiftoffResources(opts) active_pids = [] pid_path = os.path.join(opts.experiment_path, f".__{opts.session_id}") with open(pid_path, "a") as handler: handler.write(f"{os.getpid():d}\n") while True: available, next_gpu = resources.is_free() while not available: still_active_pids = [] do_sleep = True for info in active_pids: pid, gpu, title, cmd, lock_path = info if still_active(pid, cmd): still_active_pids.append(info) else: print(f"> {title} seems to be over.") os.remove(lock_path) resources.free(gpu=gpu) do_sleep = False active_pids = still_active_pids if do_sleep: time.sleep(1) available, next_gpu = resources.is_free() run_path = some_run_path(opts.experiment_path) if run_path is None: print("Nothing more to run here.") break lock_path = os.path.join(run_path, ".__lock") if lock_file(lock_path, opts.session_id): info = launch_run(run_path, opts.script, opts.session_id, gpu=next_gpu) active_pids.append(info + (lock_path, )) resources.allocate(gpu=next_gpu) while active_pids: still_active_pids = [] do_sleep = True for info in active_pids: pid, gpu, title, cmd, lock_path = info if still_active(pid, cmd): still_active_pids.append(info) else: print(f"> {title} seems to be over.") os.remove(lock_path) resources.free(gpu=gpu) do_sleep = False active_pids = still_active_pids if do_sleep: time.sleep(1) print(clr(f"Experiment {opts.experiment_path} ended.", attrs=["bold"])) os.remove(pid_path)
def _update_plot(self): mean_rw = self.total_rw / self.ep_cnt max_mean_rw = self.max_mean_rw bg_color = 'on_blue' bg_color = 'on_magenta' if mean_rw > max_mean_rw else bg_color self.max_mean_rw = mean_rw if mean_rw > max_mean_rw else max_mean_rw if self.cmdl.display_plots: self.vis.line( X=np.array([self.crt_step]), Y=np.array([mean_rw]), win=self.plot, update='append' ) print(clr("[Evaluator] done in %5d steps. " % self.step_cnt, 'grey', 'on_white') + clr(" rw/ep=%3.2f " % mean_rw, 'white', bg_color))
def display_board(self, structure): for i in range(0, 42): for j in range(0, 84): if structure[i][j] == '#': print(clr(structure[i][j], "cyan"), end="") elif structure[i][j] == 'B': print(clr(structure[i][j], "green"), end="") elif structure[i][j] == 'E': print(clr(structure[i][j], "red"), end="") elif structure[i][j] == '^': print(clr(structure[i][j], "yellow"), end="") elif structure[i][j] == '/': print(clr(structure[i][j], "magenta"), end="") else: print(structure[i][j], end="") print()
def __make_line(*args, **kwargs): args = [str(a) for a in args] kwargs = [ f"{v['name']} = {clr(v['value'], *v.get('colors', ['red']))}" for _, v in kwargs.items() ] line = clr(" | ", "yellow").join(args + kwargs) return line
def idx2seq(x, ii, pp=None): seq = [] for kk, vv in enumerate(x): if vv == 0: break if vv in worddicts_r[ii]: word = worddicts_r[ii][vv] if pp is None: if vv > model_options['voc_sizes'][ii]: seq.append(clr(word, 'green')) else: seq.append(word) else: if pp[kk] == 0: seq.append(clr(word, 'red')) elif (pp[kk] > 0) and (pp[kk] <= 0.25): seq.append(clr(word, 'yellow')) elif (pp[kk] > 0.25) and (pp[kk] <= 0.5): seq.append(clr(word, 'green')) elif (pp[kk] > 0.5) and (pp[kk] <= 0.75): seq.append(clr(word, 'cyan')) else: seq.append(clr(word, 'blue')) else: seq.append(clr('UNK', 'white')) return ' '.join(seq)
def check_stop_fuzzing(self, n: int) -> bool: if self.verification.stop_fuzzing(): print( clr("#### Finished fuzzing after {} iterations".format(n), 'green', attrs=['bold'])) return True return False
def discord_run(_token, v=''): _token = [x for x in _token.split(_ssy) if x] print( clr('Token "%s********************" Started' % _token[0][:39], 'white', 'on_blue')) _discord['file'] += "\nclient.run('" + _token[0] + "')" v = open('comm/DIS.py', 'w') v.write(_discord['file']) v.close() system('start comm/dis.py')
def run_alien(shared_objects, cfg): assert len(cfg.envs.minecraft.ports) >= 2, \ clr('Not enough clients (need at least 2)', 'white', 'on_red') # builder = PigChaseTopDownStateBuilder() env = PigChaseEnvironment( parse_clients_args(cfg.envs.minecraft.ports), PigChaseSymbolicStateBuilder(), role=cfg.alien.role, randomize_positions=cfg.envs.minecraft.randomize_positions) agent = PigChaseChallengeAgent(cfg.alien.name) agent_type = PigChaseEnvironment.AGENT_TYPE_1 print( clr( "[ %s ] type=%s, role=%d. Agent started." % (cfg.alien.name, agent_type, cfg.alien.role), 'blue')) obs = env.reset(agent_type) reward = 0 ep_cnt = 0 viz_rewards = [] is_terminal = False while True: # select an action action = agent.act(obs, reward, is_terminal, is_training=True) # reset if needed if env.done: obs = env.reset(agent_type) ep_cnt += 1 if ep_cnt % cfg.general.report_freq == 0: print("[A*?] Ep: %d | Rw: %d" % (ep_cnt, sum(viz_rewards) / cfg.general.report_freq)) viz_rewards.clear() # take a step obs, reward, is_terminal = env.do(action) viz_rewards.append(reward)
def config_to_string(cfg: Namespace, indent: int = 0, color: bool = True, verbose: bool = False) -> str: """Creates a multi-line string with the contents of @cfg.""" text = "" for key, value in cfg.__dict__.items(): if key.startswith("__") and not verbose: # censor some fields pass else: ckey = clr(key, "yellow", attrs=["bold"]) if color else key text += " " * indent + ckey + ": " if isinstance(value, Namespace): text += "\n" + config_to_string(value, indent + 2, color=color) else: cvalue = clr(str(value), "white") if color else str(value) text += cvalue + "\n" return text
def fuzz(self): for n, state in enumerate(self.search_plan): print( clr("State {}/{}: {}".format(n, self.search_stats["total"], state), 'green', attrs=['bold'])) print( clr("#### Executing state transition", 'cyan', attrs=['bold'])) self.transition.perform_state_transition(state) print(clr("#### Verifying properties", 'cyan', attrs=['bold'])) self.verification.verify_fib_properties(state) if self.check_stop_fuzzing(n): break print("===================================")
def print_fancy_err(err, issue=None, fix=None): _, _, exc_tb = sys.exc_info() tb = traceback.extract_tb(exc_tb) stack = traceback.extract_stack() what = "what: {}: {}".format( type(err).__name__, clr(str(err), attrs=["bold"])) fpath, line_no, _, code = tuple(tb[-1]) where = 'where: "{0}", line {1}\n\n\t| {1} > {2}'.format( fpath, line_no, code) fpath, line_no, _, code = tuple(stack[1]) entry_point = 'from: "{0}", line {1}\n\n\t| {1} > {2}'.format( fpath, line_no, code) msg = "\n\t{}\n\t{}\n\n\t{}\n".format(what, where, entry_point) if issue is not None: msg += "\n\tCause: {}.".format(clr(issue, "red")) if fix is not None: hint = clr("Hint", attrs=["underline"]) msg += "\n\t{}: {}.".format(hint, clr(fix, "green")) msg += "\n" print(msg)
def _debug_states(self, state_batch, next_state_batch, mask): for i in range(24): for j in range(24): px = state_batch[0, 0, i, j] if px < 0.90: print(clr("%.2f " % px, 'magenta'), end="") else: print(("%.2f " % px), end="") print() for i in range(24): for j in range(24): px = next_state_batch[0, 0, i, j] if px < 0.90: print(clr("%.2f " % px, 'magenta'), end="") else: print(clr("%.2f " % px, 'white'), end="") print() if mask[0] == 0: print(clr("Done batch ............", 'magenta')) else: print(".......................")
def _debug_states(self, state_batch, next_state_batch, mask): for i in range(24): for j in range(24): px = state_batch[0, 0, i, j] if px < 0.90: print(clr("%.2f " % px, 'magenta'), end="") else: print(("%.2f " % px), end="") print() for i in range(24): for j in range(24): px = next_state_batch[0, 0, i, j] if px < 0.90: print(clr("%.2f " % px, 'magenta'), end="") else: print(clr("%.2f " % px, 'white'), end="") print() if mask[0] == 0: print(clr("Done batch ............", 'magenta')) else: print(".......................")
def get_best_agent(results, verbose=True): """ Receives a list of trials and returns the best model it finds across trials and time-steps. `results` is of the form [(`experiment_path`, [*.yaml, *.pth, ...]), ...] """ if verbose: exp_no = len(results) models_no = exp_no * 50 print(f"Searching through {exp_no} experiments, ~{models_no} models.") best_score = -float("inf") best_agent = None for i, (exp_path, file_names) in enumerate(results): exp_path = Path(exp_path) cfg = yaml.safe_load(open(exp_path / "cfg.yaml", "r")) for file in file_names: file_path = exp_path / file if file_path.suffix == ".pth": model = torch.load(file_path) rw_per_ep = model["rw_per_ep"] print("x", end="", flush=True) if rw_per_ep > best_score: best_agent = (cfg, model) best_score = rw_per_ep print("X", end="") if verbose: cfg, model = best_agent msg = ( f"\n\nBest agent on game {cfg['game']}" + f" with rw/ep={model['rw_per_ep']:5.2f} @ step={model['step']}:") print(clr(msg, "green")) for k, v in cfg.items(): if k in ("game", "double", "prioritized", "_experiment_parameters"): print(clr(k, "yellow"), ": ", v) return best_agent
def interpret_verification_results(ping_results: dict): all_successful: bool = True for property_id, ver_res in ping_results.items(): if ver_res["status"] == 0: continue else: all_successful = False pretty_print_failure(property_id, ver_res) if all_successful: print(clr("All properties HOLD", 'green'))
def env_factory(cmdl, mode): # Undo the default logger and configure a new one. gym.undo_logger_setup() logger = logging.getLogger() logger.setLevel(logging.WARNING) print(clr("[Main] Constructing %s environment." % mode, attrs=['bold'])) env = gym.make(cmdl.env_name) if hasattr(cmdl, 'rescale_dims'): state_dims = (cmdl.rescale_dims, cmdl.rescale_dims) else: state_dims = env.observation_space.shape[0:2] env_class, hist_len, cuda = cmdl.env_class, cmdl.hist_len, cmdl.cuda if mode == "training": env = PreprocessFrames(env, env_class, hist_len, state_dims, cuda) if hasattr(cmdl, 'reward_clamp') and cmdl.reward_clamp: env = SqueezeRewards(env) if hasattr(cmdl, 'done_after_lost_life') and cmdl.done_after_lost_life: env = DoneAfterLostLife(env) print('-' * 50) return env elif mode == "evaluation": if cmdl.eval_env_name != cmdl.env_name: print( clr("[%s] Warning! evaluating on a different env: %s" % ("Main", cmdl.eval_env_name), 'red', attrs=['bold'])) env = gym.make(cmdl.eval_env_name) env = PreprocessFrames(env, env_class, hist_len, state_dims, cuda) env = EvaluationMonitor(env, cmdl) print('-' * 50) return env
def config_to_string(cfg: Namespace, indent: int = 0, color: bool = True) -> str: """Creates a multi-line string with the contents of @cfg.""" text = "" for key, value in cfg.__dict__.items(): ckey = clr(key, "green", attrs=["bold"]) if color else key text += " " * indent + ckey + ": " if isinstance(value, Namespace): text += "\n" + config_to_string(value, indent + 2, color=color) else: text += str(value) + "\n" return text
def _end_train_task(self): if self.crt_task_idx > 1 and self.first_task_only: return train_loader, _ = self.crt_data_loaders assert hasattr(train_loader, "__len__") self._optimizer.zero_grad() model = self._model for _batch_idx, (data, targets, head_idx) in enumerate(train_loader): outputs = model(data, head_idx=head_idx) loss = torch.tensor(0., device=self.device) for output, target in zip(outputs, targets): loss += functional.cross_entropy(output, target) loss.backward() grad = dict({}) crt_mode = dict({}) if self.merge_elasticities and self.constraints: # Add to previous matrices if in `merge` mode diag_hessian = self.constraints[0].diag_hessian gradient = self.constraints[0].gradient else: diag_hessian = dict({}) gradient = dict({}) for name, param in model.named_parameters(): if param.requires_grad: crt_mode[name] = param.detach().clone().view(-1) grad[name] = param.grad.clone().detach().view(-1) grad[name].requires_grad = False if name in gradient: gradient[name].add_(grad[name]) diag_hessian[name].add_(grad[name] * grad[name]) else: gradient[name] = grad[name] diag_hessian[name] = grad[name] * grad[name] new_constraint = FullConstraint(self.crt_task_idx, self.crt_task_epoch, crt_mode, gradient, diag_hessian) if self.merge_elasticities: # Remove old constraints if in `merge` mode self.constraints.clear() self.constraints.append(new_constraint) print( clr(f"There are {len(self.constraints):d} elastic constraints!", attrs=["bold"]))
def _seqs2words(caps, idict, actions=None, target=0): capsw = [] colors = ['cyan', 'green', 'yellow', 'red', 'magenta'] for kk, cc in enumerate(caps): ww = [] pos = 0 iss = 0 flag = False for w in cc: if w == 0: break word = idict[w] if actions is not None: while True: if iss == len(actions[kk]): word = clr(word, 'white') break if actions[kk][iss] == target: word = clr(word, colors[pos % len(colors)]) iss += 1 flag = True break else: if flag: pos += 1 flag = False iss += 1 ww.append(word) capsw.append(' '.join(ww)) return capsw
def __init__(self, env): super(DoneAfterLostLife, self).__init__(env) self.no_more_lives = True self.crt_live = env.unwrapped.ale.lives() self.has_many_lives = self.crt_live != 0 if self.has_many_lives: self._step = self._many_lives_step else: self._step = self._one_live_step not_a = clr("not a", attrs=['bold']) print("[DoneAfterLostLife Wrapper] %s is %s many lives game." % (env.env.spec.id, "a" if self.has_many_lives else not_a))
def test(model, test_loader, name="Test", device=None): model.eval() total_no, correct_no = 0, 0 with torch.no_grad(): for data, target in test_loader: if device: data, target = data.to(device), target.to(device) output = model(data) correct_no += (output.argmax(dim=1) == target).sum() total_no += output.size(0) acc = float(correct_no) / float(total_no) correct_no, total_no = 0, 0 sys.stdout.write( clr(f" | [Eval - {name:s}] Acc: {acc*100:2.2f}%\n", attrs=['bold'])) model.train()
def get_item(_i, _o, _p): if _i != _o: el = f'{_vocab.itos[_i]}/{_vocab.itos[_o]}' else: el = _vocab.itos[_i] if _p > 0.75: p_color = None elif _p > 0.5: p_color = 'blue' elif _p > 0.25: p_color = 'yellow' else: p_color = 'red' return clr(el, p_color)
def train_agent(shared_objects, cfg): env = PigChaseEnvironment( parse_clients_args(cfg.envs.minecraft.ports), PigChaseTopDownStateBuilder(), role=cfg.agent.role, randomize_positions=cfg.envs.minecraft.randomize_positions) agent = get_agent(cfg.agent.type)(cfg.agent.name, ENV_ACTIONS) print( clr( "[ %s ] type=%s, role=%d. Agent started." % (cfg.agent.name, cfg.agent.type, cfg.agent.role), 'cyan')) obs = env.reset() reward = 0 is_terminal = False viz_rewards = [] ep_cnt = 0 start_time = time.time() print("No of epochs: %d. Max no of steps/epoch: %d" % (cfg.training.episodes_no, cfg.training.max_step_no)) training_steps = cfg.training.episodes_no * cfg.training.max_step_no for step in range(1, training_steps + 1): # check if env needs reset if env.done: obs = env.reset() ep_cnt += 1 if ep_cnt % cfg.general.report_freq == 0: print("[DQN] Ep: %d | Rw: %d" % (ep_cnt, sum(viz_rewards) / cfg.general.report_freq)) viz_rewards.clear() # select an action action = agent.act(obs, reward, is_terminal, is_training=True) # take a step obs, reward, is_terminal = env.do(action) viz_rewards.append(reward) elapsed_time = time.time() - start_time print("Finished in %.2f seconds at %.2ffps." % (elapsed_time, training_steps / elapsed_time))
def double_check_violations(failed_properties: dict, fib: Fib, fuzz_data, failed_nets) -> dict: print( clr( "## Giving network {} seconds to converge before double checking". format(const.CONV_TIME), 'cyan')) time.sleep(const.CONV_TIME) property_failures = dict() for prop_id, prop in failed_properties.items(): print("Double checking property {}".format(prop_id)) reachability_res = verify_fib_property(prop, fib, fuzz_data, failed_nets) if reachability_res["status"] != 0: property_failures.update({prop_id: reachability_res}) return property_failures
def run(opt): """ Run experiment. This function is being launched by liftoff. """ U.configure_logger(opt) # set seed opt.seed = (opt.run_id + 1) * opt.base_seed torch.manual_seed(opt.seed) # configure env env = ActionWrapper(TorchWrapper(gym.make(opt.env_name))) env.seed(opt.seed) # build estimator estimator = ActorCriticEstimator( env.observation_space.shape[0], env.action_space, hidden_size=opt.hidden_size, ) # load checkpoint and reset rlog.info("Loading model from %s", opt.model_state) estimator.load_state_dict(torch.load(opt.model_state)["policy"]) estimator.reset_policy() rlog.info("Policy reset.") if opt.freeze_critic: estimator.freeze_critic() rlog.info("Freezed feature extractor and critic.") # build the agent policy_improvement, policy_evaluation = build_agent( opt, env, estimator=estimator ) # log rlog.info(f"\n{U.config_to_string(opt)}") rlog.info(policy_improvement) # train try: train(env, policy_improvement, policy_evaluation, opt) except Exception as err: rlog.error(clr(str(err), "red", attrs=["bold"])) raise err
def play(opt, env, policy_evaluation): print(clr("Start playing!", "red")) ep_cnt, done = 0, True while True: if done: state, reward, done = env.reset(), 0, False ep_rw = 0 with torch.no_grad(): pi = policy_evaluation(state) state, reward, done, _ = env.step(pi.action) env.render() ep_rw += reward if done: print(f"Episode {ep_cnt:3d} done. Total return: {ep_rw:5.2f}.") ep_cnt += 1
def get_anomaly_lines(_vocab, _input, _output, _probs, _device): from termcolor import colored as clr def get_item(_i, _o, _p): if _i != _o: el = f'{_vocab.itos[_i]}/{_vocab.itos[_o]}' else: el = _vocab.itos[_i] if _p > 0.75: p_color = None elif _p > 0.5: p_color = 'blue' elif _p > 0.25: p_color = 'yellow' else: p_color = 'red' return clr(el, p_color) b_anomalies = 0 for line_no, (i_line, o_line, p_line) in enumerate(zip(_input, _output, _probs)): o_line = torch.cat( [_input[line_no:line_no + 1, 0], o_line.argmax(dim=1)]) p_line = torch.cat([torch.as_tensor([1.0]).to(_device), p_line]) if (i_line != o_line).sum() != 0: b_anomalies += 1 l_elems = [] l_elems.append( f'{get_item(i_line[0], o_line[0] , p_line[0])}@{get_item(i_line[1], o_line[1] , p_line[1])}' ) #src_user l_elems.append( f'{get_item(i_line[2], o_line[2] , p_line[2])}@{get_item(i_line[3], o_line[3] , p_line[3])}' ) #dst_user for i in range(4, 11): l_elems.append(get_item(i_line[i], o_line[i], p_line[i])) l_elems.append(clr(f'{p_line.prod() * 100:.4f}%', attrs=['bold'])) print(",".join(l_elems)) return b_anomalies
def display_setup(self, env, config): emph = [ "env_name", "agent_type", "label", "batch_size", "lr", "hist_len" ] print("-------------------------------------------------") for k in config.__dict__: if config.__dict__[k] is not None: v = config.__dict__[k] space = "." * (32 - len(k)) config_line = "%s: %s %s" % (k, space, v) for e in emph: if k == e: config_line = clr(config_line, attrs=['bold']) print(config_line) print("-------------------------------------------------") custom = {"no_of_actions": self.action_no} for k, v in custom.items(): space = "." * (32 - len(k)) print("%s: %s %s" % (k, space, v)) print("-------------------------------------------------")
def lock_experiment(opts, unlock=False): """ Clean a specific argument """ info = defaultdict(int) experiment_path = opts.experiment_path timestamp = f"{datetime.now():{opts.timestamp_fmt:s}}" prefix = f"[{timestamp:s}][{opts.session_id}]" with os.scandir(experiment_path) as fit: for entry in fit: if entry.name.startswith(".") or not entry.is_dir(): continue with os.scandir(entry.path) as fit2: for entry2 in fit2: if entry2.name.startswith(".") or not entry2.is_dir(): continue try: run_id = int(entry2.name) if run_id in opts.runs: if unlock: unlock_run(entry2.path, info, prefix, opts) else: lock_run(entry2.path, info, prefix, opts) except ValueError: pass if unlock: print(f"{info['nlocks']:d} .__lock files deleted") print(f"{info['nstrange']:d} strange folders") else: print(f"{info['nlocks']:d} .__lock files added") print(f"{info['nraced']:d} times just lost the .__lock to some other process") print(f"{info['nstarted']:d} runs were already started") print(f"{info['nstrange']:d} strange folders") if not opts.do: print( "\nThis was just a simultation. Rerun with", clr("--do", attrs=["bold"]), "to lock/unlock the experiment for real.", )
def display_stats(self, start_time): fps = self.step_cnt / (time.time() - start_time) print(clr("[%s] step=%7d, fps=%.2f " % (self.name, self.step_cnt, fps), 'grey', 'on_white')) self.ep_reward.clear()
def not_implemented(obj): import inspect method_name = inspect.stack()[1][3] raise RuntimeError( clr(("%s.%s not implemented nor delegated." % (obj.name, method_name)), 'white', 'on_red'))
def display_final_report(self, ep_cnt, step_cnt, elapsed_time): fps = step_cnt / elapsed_time print(clr("[ %s ] finished after %d eps, %d steps." % ("Main", ep_cnt, step_cnt), 'white', 'on_magenta')) print(clr("[ %s ] finished after %.2fs, %.2ffps." % ("Main", elapsed_time, fps), 'white', 'on_magenta'))