def pool_runner(config, group_dir, seed): print("***************************************************") exp_dir = os.path.join(group_dir, 'exp_' + str(seed)) if os.path.exists(exp_dir): print("Skipping experiment dir: ", exp_dir) # TODO: resume if necessary? return print("Starting experiment in dir: ", exp_dir) run_experiment( #run_task, lambda sc, *args: run_task( sc, *args, env_params=config['env_params'], algo=config['algo'], algo_params=config['algo_params'], epochs=config['epochs'], batch_size=config['batch_size'], policy_hidden_sizes=config['policy_hidden_sizes'], embed_state=config['use_state_embedding'], model_dir=config['model_dir'], augment_embedded_state=config['augment_embedded_state']), exp_prefix='trpo_reacher_embedded', log_dir=exp_dir, snapshot_mode='last', seed=seed, )
def main(latent_policy_pkl): def run_task(*_): sess = tf.Session() sess.__enter__() with LocalRunner(sess=sess) as runner: inner_env = SimpleReacherEnv( goal_position=(0.5, 0, 0.15), control_method="position_control", completion_bonus=2., action_scale=0.04, ) latent_policy = joblib.load(latent_policy_pkl)["policy"] env = TfEnv(EmbeddedPolicyEnv(inner_env, latent_policy)) action_noise = OUStrategy(env, sigma=0.2) policy = ContinuousMLPPolicy( env_spec=env.spec, name="Actor", hidden_sizes=[64, 32], hidden_nonlinearity=tf.nn.relu, ) qf = ContinuousMLPQFunction(env_spec=env, name="Critic", hidden_sizes=[64, 32], hidden_nonlinearity=tf.nn.relu) replay_buffer = SimpleReplayBuffer(env_spec=env.spec, size_in_transitions=int(1e6), time_horizon=100) algo = DDPG(env, policy=policy, policy_lr=1e-4, qf_lr=1e-3, qf=qf, plot=True, target_update_tau=1e-2, n_epochs=500, n_train_steps=50, discount=0.9, replay_buffer=replay_buffer, min_buffer_size=int(1e3), exploration_strategy=action_noise, policy_optimizer=tf.train.AdamOptimizer, qf_optimizer=tf.train.AdamOptimizer) runner.setup(algo, env) runner.train(n_epochs=500, plot=False, n_epoch_cycles=10) run_experiment( run_task, exp_prefix='ddpg_sawyer_compose', n_parallel=1, seed=1, plot=True, )
def main(latent_policy_pkl): def run_task(*_): sess = tf.Session() sess.__enter__() latent_policy = joblib.load(latent_policy_pkl)["policy"] with LocalRunner(sess=sess) as runner: inner_env = PointEnv(goal=(1.4, 1.4), completion_bonus=100) env = TfEnv(EmbeddedPolicyEnv(inner_env, latent_policy)) action_noise = OUStrategy(env, sigma=0.2) policy = ContinuousMLPPolicy(env_spec=env, name="Actor", hidden_sizes=[64, 64], hidden_nonlinearity=tf.nn.relu, output_nonlinearity=tf.nn.tanh) qf = ContinuousMLPQFunction(env_spec=env, name="Critic", hidden_sizes=[64, 64], hidden_nonlinearity=tf.nn.relu) replay_buffer = SimpleReplayBuffer(env_spec=env.spec, size_in_transitions=int(1e6), time_horizon=100) algo = DDPG(env, policy=policy, policy_lr=1e-4, qf_lr=1e-3, qf=qf, plot=False, target_update_tau=1e-2, replay_buffer=replay_buffer, n_train_steps=50, discount=0.9, min_buffer_size=int(1e3), exploration_strategy=action_noise, policy_optimizer=tf.train.AdamOptimizer, qf_optimizer=tf.train.AdamOptimizer) runner.setup(algo, env) runner.train(n_epochs=500, plot=False, n_epoch_cycles=10) run_experiment( run_task, n_parallel=1, exp_prefix="ddpg_point_compose", seed=1, plot=False, )
def _launch_ec2(func, exp_prefix, exp_name, params, run_experiment_kwargs): print("Launching task", exp_name) kwargs = dict(n_parallel=1, snapshot_mode="last", seed=params.get("seed", None), mode="ec2") kwargs.update(run_experiment_kwargs) kwargs.update( dict(exp_prefix=exp_prefix, exp_name=exp_name, variant=params, confirm_remote=False)) run_experiment(func, **kwargs)
def pool_runner(run_task, group_dir, i): print("***************************************************") exp_dir = os.path.join(group_dir, 'exp_') + str(i) if os.path.exists(exp_dir): print("Skipping experiment dir: ", exp_dir) # TODO: resume if necessary? return print("Starting experiment in dir: ", exp_dir) run_experiment( run_task, log_dir=exp_dir, snapshot_mode='last', seed=i, )
def test_benchmark_gaussian_mlp_baseline(self): bench_envs = [ 'HalfCheetah-v2', 'Reacher-v2', 'Walker2d-v2', 'Hopper-v2', 'Swimmer-v2', 'InvertedPendulum-v2', 'InvertedDoublePendulum-v2' ] seeds = np.random.choice(100, size=(len(bench_envs), 3)) for env_num in range(len(bench_envs)): self._env = bench_envs[env_num] for seed in seeds[env_num]: self._seed = seed deterministic.set_seed(self._seed) name = '{}_seed_{}_garage'.format(self._env, self._seed) run_experiment(self.run_task, snapshot_mode='last', seed=self._seed, n_parallel=12, exp_name=name)
def main(latent_policy_pkl): def run_task(*_): sess = tf.Session() sess.__enter__() latent_policy = joblib.load(latent_policy_pkl)["policy"] with LocalRunner(sess=sess) as runner: inner_env = PointEnv(goal=(1.4, 1.4), completion_bonus=100) env = TfEnv(EmbeddedPolicyEnv(inner_env, latent_policy)) policy = GaussianMLPPolicy(name="composer", env_spec=env.spec, hidden_sizes=(64, 64), init_std=20, std_share_network=False, adaptive_std=True) baseline = GaussianMLPBaseline(env_spec=env) algo = PPO( env=env, policy=policy, baseline=baseline, batch_size=1024, # 4096 max_path_length=50, n_itr=1500, discount=0.99, step_size=0.2, policy_ent_coeff=1e-6, plot=True, use_mpc_es=True, ) runner.setup(algo, env) runner.train(n_epochs=600, plot=False, batch_size=1024) run_experiment( run_task, n_parallel=1, exp_prefix="ppo_point_compose", seed=2, plot=False, )
def cmaes_obj_fcn(l_init, exp_prefix): global l_pre_init l_pre_init = params.inv_sigmoid(l_init, params.l_lb, params.l_ub) now = datetime.now() exp_name = now.strftime("%Y_%m_%d_%H_%M_%S") run_experiment(run_task, exp_prefix=exp_prefix, exp_name=exp_name, snapshot_mode='last', seed=args.seed, force_cpu=True) csv_path = os.path.join(os.environ['PROJECTDIR'], 'data/local', exp_prefix.replace('_', '-'), exp_name, 'progress.csv') csv_df = pd.read_csv(csv_path) final_avg_discounted_return = np.mean( csv_df['AverageDiscountedReturn'] [-params.ppo_inner_final_average_discounted_return_window_size:]) return -final_avg_discounted_return
from garage.tf.policies import CategoricalMLPPolicy def run_task(*_): env = TfEnv(normalize(gym.make('MountainCar-v0'))) policy = CategoricalMLPPolicy(env_spec=env.spec, hidden_sizes=(32, 32)) baseline = LinearFeatureBaseline(env_spec=env.spec) algo = TRPO( env=env, policy=policy, baseline=baseline, batch_size=4000, max_path_length=env.max_episode_steps, n_itr=150, discount=0.99, step_size=0.1, plot=True, ) algo.train() run_experiment( run_task, n_parallel=1, snapshot_mode='last', plot=True, )
max_path_length=100, n_itr=40, discount=0.99, step_size=v["step_size"], # Uncomment both lines (this and the plot parameter below) to enable # plotting plot=True, ) algo.train() for step_size in [0.01, 0.05, 0.1]: for seed in [1, 11, 21, 31, 41]: run_experiment( run_task, exp_prefix="first_exp", # Number of parallel workers for sampling n_parallel=1, # Only keep the snapshot parameters for the last iteration snapshot_mode="last", # Specifies the seed for the experiment. If this is not provided, a # random seed will be used seed=seed, # mode="local", mode="ec2", variant=dict(step_size=step_size, seed=seed) # plot=True, # terminate_machine=False, ) sys.exit()
#!/usr/bin/env python3 """This is an example to resume training programmatically.""" from garage.experiment import run_experiment from garage.tf.experiment import LocalTFRunner def run_task(snapshot_config, *_): """Run task.""" with LocalTFRunner(snapshot_config=snapshot_config) as runner: runner.restore(from_dir='dir/', from_epoch=2) runner.resume() run_experiment( run_task, log_dir='new_dir/', snapshot_mode='last', seed=1, )
algo = JoleDQN(env_spec=env.spec, policy=policy, qf=qf, obs_model=obs_model, reward_model=reward_model, terminal_model=terminal_model, exploration_strategy=epilson_greedy_strategy, replay_buffer=replay_buffer, qf_lr=1e-3, discount=0.99, min_buffer_size=int(1e3), double_q=False, n_train_steps=50, n_epoch_cycles=n_epoch_cycles, target_network_update_freq=100, buffer_batch_size=64, env_name=env_name) runner.setup(algo, env) runner.train(n_epochs=n_epochs, n_epoch_cycles=n_epoch_cycles, batch_size=sampler_batch_size) for i in range(1, 2): run_experiment(run_task, snapshot_mode='none', seed=i, log_dir="data/type_dqn/{}/jole_dqn/{}/".format(env_name, i))
# baseline = GaussianMLPBaseline( # env_spec=env.spec, # regressor_args=dict( # hidden_sizes=params.baseline_network_size, # hidden_nonlinearity=tf.nn.tanh, # use_trust_region=True, # ), # ) baseline = LinearFeatureBaseline(env_spec=env.spec) algo = CMAES(env_spec=env.spec, policy=policy, baseline=baseline, **params.cmaes_algo_kwargs) runner.setup(algo, env) runner.train(**params.cmaes_train_kwargs) if __name__=='__main__': now = datetime.now() parser = argparse.ArgumentParser() parser.add_argument('--seed', default=int(now.timestamp()), type=int, help='seed') parser.add_argument('--exp_id', default=now.strftime("%Y_%m_%d_%H_%M_%S"), help='experiment id (suffix to data directory name)') args = parser.parse_args() run_experiment(run_task, exp_prefix='cmaes_opt_l_hw_as_action_{}_'.format(args.exp_id) + str(params.n_segments)+'_params', snapshot_mode='last', seed=args.seed, force_cpu=True)
import gym from garage.baselines import LinearFeatureBaseline from garage.experiment import run_experiment from garage.tf.algos import TRPO from garage.tf.envs import TfEnv from garage.tf.policies import CategoricalMLPPolicy # Need to wrap in a tf environment and force_reset to true # see https://github.com/openai/rllab/issues/87#issuecomment-282519288 env = TfEnv(gym.make("CartPole-v0")) policy = CategoricalMLPPolicy(name="policy", env_spec=env.spec, hidden_sizes=(32, 32)) baseline = LinearFeatureBaseline(env_spec=env.spec) algo = TRPO( env=env, policy=policy, baseline=baseline, batch_size=4000, max_path_length=200, n_itr=120, discount=0.99, max_kl_step=0.01, ) run_experiment(algo.train(), n_parallel=1, snapshot_mode="last", seed=1)
def run_task(snapshot_config, *_): """Run task.""" with LocalTFRunner(snapshot_config=snapshot_config) as runner: env = TfEnv(env_name='Pusher3DOF-v1') policy = GaussianMLPPolicy(name='policy', env_spec=env.spec, hidden_sizes=(32, 32), init_std=10) baseline = LinearFeatureBaseline(env_spec=env.spec) algo = TRPO(env_spec=env.spec, policy=policy, baseline=baseline, max_path_length=100, discount=0.99, max_kl_step=0.01) runner.setup(algo, env) runner.train(n_epochs=200, batch_size=50*250) run_experiment( run_task, exp_prefix="trpo_pusher_200_0524", snapshot_mode='last', seed=1, )
runner.train( n_epochs=40, batch_size=4000, # Uncomment to enable plotting # plot=True ) variants = VG().variants() for v in variants: run_experiment( run_task, exp_prefix='first_exp', # Number of parallel workers for sampling n_parallel=1, # Only keep the snapshot parameters for the last iteration snapshot_mode='last', # Specifies the seed for the experiment. If this is not provided, a # random seed will be used seed=v['seed'], # mode="local", mode='ec2', variant=v, # plot=True, # terminate_machine=False, ) sys.exit()
) runner.setup(algo, env, batch_size=v.batch_size, max_path_length=v.max_path_length) runner.train(n_epochs=2000, plot=False) config = dict( tasks=TASKS, latent_length=3, inference_window=6, batch_size=4096 * len(TASKS), policy_ent_coeff=5e-3, # 1e-2 embedding_ent_coeff=1e-3, # 1e-3 inference_ce_coeff=5e-3, # 1e-4 max_path_length=200, embedding_init_std=1.0, embedding_max_std=2.0, policy_init_std=1.0, ) run_experiment( run_task, exp_prefix='sawyer_reach_embed_8goal', n_parallel=1, seed=1, variant=config, plot=False, )
def run_task(*_): env = normalize(gym.make("Pendulum-v0")) policy = DummyPolicy(env_spec=env) baseline = LinearFeatureBaseline(env_spec=env) algo = InstrumentedNOP(env=env, policy=policy, baseline=baseline, batch_size=4000, max_path_length=100, n_itr=4, discount=0.99, step_size=0.01, plot=True) algo.train() env.close() run_experiment( run_task, # Number of parallel workers for sampling n_parallel=6, # Only keep the snapshot parameters for the last iteration snapshot_mode="last", # Specifies the seed for the experiment. If this is not provided, a random # seed will be used seed=1, plot=True, )
from garage.tf.policies import CategoricalMLPPolicy def run_task(*_): with LocalRunner() as runner: env = TfEnv(env_name='CartPole-v1') policy = CategoricalMLPPolicy(name="policy", env_spec=env.spec, hidden_sizes=(32, 32)) baseline = LinearFeatureBaseline(env_spec=env.spec) algo = VPG( env=env, policy=policy, baseline=baseline, max_path_length=100, discount=0.99, optimizer_args=dict(tf_optimizer_args=dict(learning_rate=0.01, ))) runner.setup(algo, env) runner.train(n_epochs=100, batch_size=10000) run_experiment( run_task, snapshot_mode="last", seed=1, )
policy = GaussianMLPPolicy(env.spec, hidden_sizes=[32, 32], hidden_nonlinearity=torch.tanh, output_nonlinearity=None) baseline = LinearFeatureBaseline(env_spec=env.spec) algo = TRPO(env_spec=env.spec, policy=policy, baseline=baseline, max_path_length=49, discount=0.99, center_adv=False, max_kl_step=0.005, **copyparams) #runner.setup(algo, env) #runner.train(n_epochs=100, batch_size=50*250) runner.restore( "/home/dell/garage/data/local/pusher/pusher_2020_06_01_23_45_24_0001") runner.resume(n_epochs=800) run_experiment( run_task, exp_prefix="pusher", snapshot_mode='last', seed=1, )
import joblib from garage.experiment import run_experiment from garage.envs import normalize from garage.experiment.deterministic import set_seed from garage.tf.algos import PPO from garage.tf.baselines import GaussianMLPBaseline from garage.tf.envs import TfEnv from garage.tf.experiment import LocalTFRunner from garage.tf.policies import GaussianMLPPolicy def run_task(snapshot_config, *_): """Run task.""" with LocalTFRunner(snapshot_config=snapshot_config, max_cpus=16) as runner: data = joblib.load('/data/yxjin/robot/rotation/data/local/experiment/experiment_2020_05_07_06_54_13_0001/itr_2100.pkl') algo = data['algo'] env = data['env'] runner.setup(algo, env) runner.train(n_epochs=40000, batch_size=2048) run_experiment( run_task, snapshot_mode='gap', snapshot_gap=1, seed=1, )
ddpg = DDPG( env, actor=actor_net, actor_lr=1e-4, critic_lr=1e-3, critic=critic_net, plot=False, target_update_tau=1e-2, n_epochs=500, n_epoch_cycles=100, n_rollout_steps=50, n_train_steps=50, discount=0.9, replay_buffer_size=int(1e6), min_buffer_size=int(1e4), exploration_strategy=es, actor_optimizer=tf.train.AdamOptimizer, critic_optimizer=tf.train.AdamOptimizer, ) ddpg.train(sess=sess) run_experiment( run_task, n_parallel=2, exp_prefix="ddpg_point_compose_seq", seed=1, plot=True, )
algo = CMAES(env_spec=env.spec, policy=policy, baseline=baseline, **params.cmaes_algo_kwargs) runner.setup(algo, env) runner.train(**params.cmaes_train_kwargs) if __name__ == '__main__': now = datetime.now() parser = argparse.ArgumentParser() parser.add_argument('--seed', default=int(now.timestamp()), type=int, help='seed') parser.add_argument('--exp_id', default=now.strftime("%Y_%m_%d_%H_%M_%S"), help='experiment id (suffix to data directory name)') args = parser.parse_args() run_experiment( run_task, exp_prefix='cmaes_opt_k_hw_as_policy_{}_'.format(args.exp_id) + str(params.n_springs) + '_params', snapshot_mode='last', seed=args.seed, force_cpu=True)
decay_ratio=0.1) algo = DQN(env_spec=env.spec, policy=policy, qf=qf, exploration_strategy=epilson_greedy_strategy, replay_buffer=replay_buffer, qf_lr=1e-4, discount=0.99, min_buffer_size=int(1e4), double_q=False, n_train_steps=500, n_epoch_cycles=n_epoch_cycles, target_network_update_freq=2, buffer_batch_size=32) runner.setup(algo, env) runner.train(n_epochs=n_epochs, n_epoch_cycles=n_epoch_cycles, batch_size=sampler_batch_size) env_name = "PongNoFrameskip-v4" run_experiment(run_task, n_parallel=1, snapshot_mode='none', seed=1, plot=False, log_dir="data/type_ddpg/{}/normal_ddpg_test/{}".format( env_name, 1))
def run_task(*_): """Wrap ERWR training task in the run_task function.""" env = TfEnv(env_name="CartPole-v1") policy = CategoricalMLPPolicy(name="policy", env_spec=env.spec, hidden_sizes=(32, 32)) baseline = LinearFeatureBaseline(env_spec=env.spec) algo = ERWR(env=env, policy=policy, baseline=baseline, batch_size=10000, max_path_length=100, n_itr=100, plot=True, discount=0.99) algo.train() run_experiment( run_task, n_parallel=1, snapshot_mode="last", seed=1, plot=True, )
inference_ce_coeff=v.inference_ce_coeff, #optimizer_args=dict(max_grad_norm=0.5) ) runner.setup(algo, env, batch_size=v.batch_size, max_path_length=v.max_path_length) runner.train(n_epochs=1000, plot=False) config = dict( tasks=TASKS, latent_length=3, # 3 inference_window=6, # 6 batch_size=4096 * len(TASKS), # 4096 * len(TASKS) policy_ent_coeff=1e-5, # 1e-2 # embedding_ent_coeff=3e-4, # 1e-3 inference_ce_coeff=2e-5, # 1e-4 max_path_length=100, # 100 embedding_init_std=1.0, # 1.0 embedding_max_std=2.0, # 2.0 policy_init_std=0.1, # 1.0 policy_max_std=0.2, # 2.0 ) run_experiment( run_task, exp_prefix='sawyer_reach_multiworld_torque', n_parallel=2, seed=1, variant=config, plot=False, )
algo = DQN( env_spec=env.spec, policy=policy, qf=qf, exploration_strategy=epilson_greedy_strategy, replay_buffer=replay_buffer, qf_lr=1e-4, discount=0.99, min_buffer_size=int(1e4), double_q=False, n_train_steps=500, n_epoch_cycles=n_epoch_cycles, target_network_update_freq=2, buffer_batch_size=32) runner.setup(algo, env) runner.train( n_epochs=n_epochs, n_epoch_cycles=n_epoch_cycles, batch_size=sampler_batch_size) run_experiment( run_task, n_parallel=1, snapshot_mode='last', seed=1, plot=False, )
plot=False, ) runner.setup(algo, env) runner.train(n_epochs=1200, batch_size=2048, plot=False) experiment_dir = os.path.abspath("train_ctrler_experiment") experiment_path = os.path.join( experiment_dir, "b{}_{}_{}_s{}_{}".format( args.beta, args.int, args.name if args.loadrnn else "nornn", args.seed, "{}-{}-{}_{}:{}:{}".format(now.year, now.month, now.day, now.hour, now.minute, now.second, now.microsecond))) run_experiment(run_task, snapshot_mode="last", log_dir=experiment_path, seed=args.seed) #from env import WallAvoidingAgent #total_frames = 0 #env = ControllerEnv(vae_load=vision_load_path, rnn_load=memory_load_path) #try: # recording_obs = [] # recording_action = [] # # pixel_obs = env.reset() # pixel_obs = env.obs # agent = WallAvoidingAgent(env.model.env) # # # random policy # # more diverse random policy, works slightly better:
policy = CategoricalLSTMPolicy( name='policy', env_spec=env.spec, lstm_layer_cls=L.TfBasicLSTMLayer, # gru_layer_cls=L.GRULayer, ) baseline = LinearFeatureBaseline(env_spec=env.spec) algo = TRPO( env_spec=env.spec, policy=policy, baseline=baseline, max_path_length=100, discount=0.99, max_kl_step=0.01, optimizer=ConjugateGradientOptimizer, optimizer_args=dict( hvp_approach=FiniteDifferenceHvp(base_eps=1e-5))) runner.setup(algo, env) runner.train(n_epochs=100, batch_size=4000) run_experiment( run_task, snapshot_mode='last', seed=1, )
def runner( ga_type=None, env_args=None, run_experiment_args=None, sim_args=None, reward_args=None, spaces_args=None, policy_args=None, algo_args=None, runner_args=None, bpq_args=None, # log_dir='.', ): if ga_type is None: pass if env_args is None: env_args = {} if run_experiment_args is None: run_experiment_args = {} if sim_args is None: sim_args = {} if reward_args is None: reward_args = {} if spaces_args is None: spaces_args = {} if policy_args is None: policy_args = {} if algo_args is None: algo_args = {} if runner_args is None: runner_args = {} if bpq_args is None: bpq_args = {} if 'n_parallel' in run_experiment_args: n_parallel = run_experiment_args['n_parallel'] else: n_parallel = 1 run_experiment_args['n_parallel'] = n_parallel if 'max_path_length' in sim_args: max_path_length = sim_args['max_path_length'] else: max_path_length = 50 sim_args['max_path_length'] = max_path_length if 'batch_size' in runner_args: batch_size = runner_args['batch_size'] else: batch_size = max_path_length * n_parallel runner_args['batch_size'] = batch_size def run_task(snapshot_config, *_): seed = 0 # top_k = 10 np.random.seed(seed) config = tf.ConfigProto() config.gpu_options.allow_growth = True with tf.Session(config=config) as sess: with tf.variable_scope('AST', reuse=tf.AUTO_REUSE): with LocalTFRunner(snapshot_config=snapshot_config, max_cpus=4, sess=sess) as local_runner: # Instantiate the example classes sim = ExampleAVSimulator(**sim_args) reward_function = ExampleAVReward(**reward_args) spaces = ExampleAVSpaces(**spaces_args) # Create the environment if 'id' in env_args: env_args.pop('id') env = ASTEnv(simulator=sim, reward_function=reward_function, spaces=spaces, **env_args) env = TfEnv(env) policy = ContinuousMLPPolicy(name='ast_agent', env_spec=env.spec, **policy_args) params = policy.get_params() sess.run(tf.variables_initializer(params)) # Instantiate the garage objects baseline = ZeroBaseline(env_spec=env.spec) top_paths = BPQ.BoundedPriorityQueue(**bpq_args) sampler_cls = ASTVectorizedSampler sampler_args = { "open_loop": False, "sim": sim, "reward_function": reward_function, "n_envs": n_parallel } if ga_type == 'ga': print('ga') algo = GA(env_spec=env.spec, policy=policy, baseline=baseline, top_paths=top_paths, **algo_args) elif ga_type == 'gasm': print('gasm') algo = GASM(env_spec=env.spec, policy=policy, baseline=baseline, top_paths=top_paths, **algo_args) else: raise NotImplementedError local_runner.setup(algo=algo, env=env, sampler_cls=sampler_cls, sampler_args=sampler_args) # Run the experiment local_runner.train(**runner_args) # from garage.experiment.experiment import AttrDict # import os # tabular_log_file = os.path.join("./", "test.csv") # from dowel import logger, tabular # import dowel # logger.add_output(dowel.CsvOutput(tabular_log_file)) # run_task(AttrDict(run_experiment_args)) run_experiment( run_task, **run_experiment_args, )