def find_failure_case(env, domain, sym_cutoff=-1): while True: print("trying..") problem = domain.random_problem_instance() env.reset() env.load_blocks(problem.thing_below) am = make_abstract_machine(env, domain) am_results = run_machine(am, problem.goal_thing_below, {"jnt": "rest"}) ticks, running_time, sym_reward, spa_reward = am_results if sym_reward <= sym_cutoff: break # print(sym_reward) env.reset() return problem, sym_reward
def find_failure_case(num_bases, num_blocks, max_levels): while True: # print("trying..") env = BlocksWorldEnv(show=False) thing_below, goal_thing_below = random_problem_instance( env, num_blocks, max_levels, num_bases) am = make_abstract_machine(env, num_bases, max_levels) am_results = run_machine(am, goal_thing_below, {"jnt": "rest"}) env.close() ticks, running_time, sym_reward, spa_reward = am_results if sym_reward <= -2: break # print(sym_reward) return thing_below, goal_thing_below, sym_reward
def run_trial(num_bases, num_blocks, max_levels): env = BlocksWorldEnv(show=False) # rejection sample non-trivial instance thing_below, goal_thing_below = random_problem_instance( env, num_blocks, max_levels, num_bases) am = make_abstract_machine(env, num_bases, max_levels) nvm = virtualize(am) am_results = run_machine(am, goal_thing_below, {"jnt": "rest"}) env.reset() env.load_blocks(thing_below, num_bases) nvm_results = run_machine(nvm, goal_thing_below, {"jnt": tr.tensor(am.ik["rest"]).float()}) env.close() return am_results, nvm_results, nvm.size(), thing_below, goal_thing_below
def reset(self): self.mp = [] self.sym = [] def step_hook(self, env, action): self.mp.append(env.movement_penalty()) self.sym.append( compute_symbolic_reward(env, self.goal_thing_below)) # load tracker = Tracker(goal_thing_below) env = BlocksWorldEnv(show=False, step_hook=tracker.step_hook) env.load_blocks(thing_below) # run rvm rvm = make_abstract_machine(env, num_bases, max_levels, gen_regs=["r0", "r1"]) nvm = virtualize(rvm, nv.default_activator) # run goal_thing_above = env.invert(goal_thing_below) for key, val in goal_thing_above.items(): if val == "none": goal_thing_above[key] = "nil" memorize_env(rvm, goal_thing_above) rvm.reset({"jnt": "rest"}) rvm.mount("main") while True: done = rvm.tick() if done: break # run_machine(rvm, goal_thing_below, reset_dict={"jnt": "rest"}) num_time_steps = rvm.tick_counter env.close()
for rep in range(num_repetitions): for learning_rate in learning_rates: print("Starting lr=%f" % learning_rate) results = lr_results[learning_rate] start_rep = time.perf_counter() results.append([]) if prob_freq != "once": problem = domain.random_problem_instance() env = BlocksWorldEnv(show=False, step_hook=penalty_tracker.step_hook) env.load_blocks(problem.thing_below) # set up rvm and virtualize rvm = make_abstract_machine(env, domain) rvm.reset({"jnt": "rest"}) rvm.mount("main") nvm = virtualize(rvm, σ=nv.default_activator, detach_gates=detach_gates) nvm.mount("main") W_init = { name: { 0: nvm.net.batchify_weights(conn.W) } for name, conn in nvm.connections.items() } v_init = { name: {
lr_results = {lr: list() for lr in learning_rates} for rep in range(num_repetitions): for learning_rate in learning_rates: print("Starting lr=%f" % learning_rate) results = lr_results[learning_rate] start_rep = time.perf_counter() results.append([]) env = BlocksWorldEnv(show=False, step_hook=penalty_tracker.step_hook) env.load_blocks(thing_below) # set up rvm and virtualize rvm = make_abstract_machine(env, num_bases, max_levels) rvm.reset({"jnt": "rest"}) rvm.mount("main") nvm = virtualize(rvm, σ=nv.default_activator, detach_gates=detach_gates) nvm.mount("main") W_init = { name: { 0: nvm.net.batchify_weights(conn.W) } for name, conn in nvm.connections.items() } v_init = { name: {
def run_trial(domain): env = BlocksWorldEnv(show=False) # rejection sample non-trivial instance problem = domain.random_problem_instance() env.reset() env.load_blocks(problem.thing_below, num_bases=domain.num_bases) # set up rvm and virtualize rvm = make_abstract_machine(env, domain) memorize_problem(rvm, problem) rvm.reset({"jnt": "rest"}) rvm.mount("main") nvm = virtualize(rvm, σ=nv.default_activator, detach_gates=True) nvm.mount("main") W_init = { name: { 0: nvm.net.batchify_weights(conn.W) } for name, conn in nvm.connections.items() } v_init = { name: { 0: nvm.net.batchify_activities(reg.content) } for name, reg in nvm.registers.items() } v_init["jnt"][0] = nvm.net.batchify_activities( tr.tensor(rvm.ik["rest"]).float()) # rvm_results = run_machine(rvm, problem.goal_thing_below, {"jnt": "rest"}) start = time.perf_counter() tar_changed = False while True: done = rvm.tick() if tar_changed: position = rvm.ik[rvm.registers["jnt"].content] env.goto_position(position, speed=1.5) if done: break tar_changed = (rvm.registers["tar"].content != rvm.registers["tar"].old_content) rvm_ticks = rvm.tick_counter rvm_runtime = time.perf_counter() - start rvm_sym = compute_symbolic_reward(env, problem.goal_thing_below) rvm_spa = compute_spatial_reward(env, problem.goal_thing_below) rvm_results = rvm_ticks, rvm_runtime, rvm_sym, rvm_spa # nvm_results = run_machine(nvm, problem.goal_thing_below, {"jnt": tr.tensor(rvm.ik["rest"]).float()}) env.reset() env.load_blocks(problem.thing_below, num_bases=domain.num_bases) start = time.perf_counter() while True: t = nvm.net.tick_counter if t > 0 and nvm.decode("ipt", t, 0) == nvm.decode("ipt", t - 1, 0): break nvm.net.tick(W_init, v_init) nvm.pullback(t) if t > 1 and nvm.decode("tar", t - 2, 0) != nvm.decode( "tar", t - 1, 0): position = nvm.net.activities["jnt"][t][0, :, 0].detach().numpy() env.goto_position(position, speed=1.5) nvm_ticks = nvm.net.tick_counter nvm_runtime = time.perf_counter() - start nvm_sym = compute_symbolic_reward(env, problem.goal_thing_below) nvm_spa = compute_spatial_reward(env, problem.goal_thing_below) nvm_results = nvm_ticks, nvm_runtime, nvm_sym, nvm_spa env.close() return rvm_results, nvm_results, nvm.size(), problem