def make_dqn_agent(self, env, q_func, opt, explorer, rbuf, gpu):
return DQN(
q_func,
opt,
rbuf,
gpu=gpu,
gamma=0.9,
explorer=explorer,
replay_start_size=100,
target_update_interval=100,
)
def _objective_core(
# optuna parameters
trial,
# training parameters
env_id,
outdir,
seed,
monitor,
gpu,
steps,
train_max_episode_len,
eval_n_episodes,
eval_interval,
batch_size,
# hyperparameters
hyperparams,
):
# Set a random seed used in PFRL
utils.set_random_seed(seed)
# Set different random seeds for train and test envs.
train_seed = seed
test_seed = 2**31 - 1 - seed
def make_env(test=False):
env = gym.make(env_id)
if not isinstance(env.observation_space, gym.spaces.Box):
raise ValueError(
"Supported only Box observation environments, but given: {}".format(
env.observation_space
)
)
if len(env.observation_space.shape) != 1:
raise ValueError(
"Supported only observation spaces with ndim==1, but given: {}".format(
env.observation_space.shape
)
)
if not isinstance(env.action_space, gym.spaces.Discrete):
raise ValueError(
"Supported only discrete action environments, but given: {}".format(
env.action_space
)
)
env_seed = test_seed if test else train_seed
env.seed(env_seed)
# Cast observations to float32 because our model uses float32
env = pfrl.wrappers.CastObservationToFloat32(env)
if monitor:
env = pfrl.wrappers.Monitor(env, outdir)
if not test:
# Scale rewards (and thus returns) to a reasonable range so that
# training is easier
env = pfrl.wrappers.ScaleReward(env, hyperparams["reward_scale_factor"])
return env
env = make_env(test=False)
obs_space = env.observation_space
obs_size = obs_space.low.size
action_space = env.action_space
n_actions = action_space.n
# create model & q_function
model = MLP(
in_size=obs_size, out_size=n_actions, hidden_sizes=hyperparams["hidden_sizes"]
)
q_func = q_functions.SingleModelStateQFunctionWithDiscreteAction(model=model)
# Use epsilon-greedy for exploration
start_epsilon = 1
explorer = explorers.LinearDecayEpsilonGreedy(
start_epsilon=start_epsilon,
end_epsilon=hyperparams["end_epsilon"],
decay_steps=hyperparams["decay_steps"],
random_action_func=action_space.sample,
)
opt = optim.Adam(
q_func.parameters(), lr=hyperparams["lr"], eps=hyperparams["adam_eps"]
)
rbuf_capacity = steps
rbuf = replay_buffers.ReplayBuffer(rbuf_capacity)
agent = DQN(
q_func,
opt,
rbuf,
gpu=gpu,
gamma=hyperparams["gamma"],
explorer=explorer,
replay_start_size=hyperparams["replay_start_size"],
target_update_interval=hyperparams["target_update_interval"],
update_interval=hyperparams["update_interval"],
minibatch_size=batch_size,
)
eval_env = make_env(test=True)
evaluation_hooks = [OptunaPrunerHook(trial=trial)]
_, eval_stats_history = experiments.train_agent_with_evaluation(
agent=agent,
env=env,
steps=steps,
eval_n_steps=None,
eval_n_episodes=eval_n_episodes,
eval_interval=eval_interval,
outdir=outdir,
eval_env=eval_env,
train_max_episode_len=train_max_episode_len,
evaluation_hooks=evaluation_hooks,
)
score = _get_score_from_eval_stats_history(eval_stats_history)
return score
def main():
import logging
logging.basicConfig(level=logging.INFO)
parser = argparse.ArgumentParser()
parser.add_argument(
"--outdir",
type=str,
default="results",
help=("Directory path to save output files."
" If it does not exist, it will be created."),
)
parser.add_argument("--env", type=str, default="Pendulum-v0")
parser.add_argument("--seed",
type=int,
default=0,
help="Random seed [0, 2 ** 32)")
parser.add_argument("--gpu", type=int, default=0)
parser.add_argument("--final-exploration-steps", type=int, default=10**4)
parser.add_argument("--start-epsilon", type=float, default=1.0)
parser.add_argument("--end-epsilon", type=float, default=0.1)
parser.add_argument("--noisy-net-sigma", type=float, default=None)
parser.add_argument("--demo", action="store_true", default=False)
parser.add_argument("--load", type=str, default=None)
parser.add_argument("--steps", type=int, default=10**5)
parser.add_argument("--prioritized-replay", action="store_true")
parser.add_argument("--replay-start-size", type=int, default=1000)
parser.add_argument("--target-update-interval", type=int, default=10**2)
parser.add_argument("--target-update-method", type=str, default="hard")
parser.add_argument("--soft-update-tau", type=float, default=1e-2)
parser.add_argument("--update-interval", type=int, default=1)
parser.add_argument("--eval-n-runs", type=int, default=100)
parser.add_argument("--eval-interval", type=int, default=10**4)
parser.add_argument("--n-hidden-channels", type=int, default=100)
parser.add_argument("--n-hidden-layers", type=int, default=2)
parser.add_argument("--gamma", type=float, default=0.99)
parser.add_argument("--minibatch-size", type=int, default=None)
parser.add_argument("--render-train", action="store_true")
parser.add_argument("--render-eval", action="store_true")
parser.add_argument("--monitor", action="store_true")
parser.add_argument("--reward-scale-factor", type=float, default=1e-3)
parser.add_argument(
"--actor-learner",
action="store_true",
help="Enable asynchronous sampling with asynchronous actor(s)",
) # NOQA
parser.add_argument(
"--num-envs",
type=int,
default=1,
help=("The number of environments for sampling (only effective with"
" --actor-learner enabled)"),
) # NOQA
args = parser.parse_args()
# Set a random seed used in PFRL
utils.set_random_seed(args.seed)
args.outdir = experiments.prepare_output_dir(args,
args.outdir,
argv=sys.argv)
print("Output files are saved in {}".format(args.outdir))
# Set different random seeds for different subprocesses.
# If seed=0 and processes=4, subprocess seeds are [0, 1, 2, 3].
# If seed=1 and processes=4, subprocess seeds are [4, 5, 6, 7].
process_seeds = np.arange(args.num_envs) + args.seed * args.num_envs
assert process_seeds.max() < 2**32
def clip_action_filter(a):
return np.clip(a, action_space.low, action_space.high)
def make_env(idx=0, test=False):
env = gym.make(args.env)
# Use different random seeds for train and test envs
process_seed = int(process_seeds[idx])
env_seed = 2**32 - 1 - process_seed if test else process_seed
utils.set_random_seed(env_seed)
# Cast observations to float32 because our model uses float32
env = pfrl.wrappers.CastObservationToFloat32(env)
if args.monitor:
env = pfrl.wrappers.Monitor(env, args.outdir)
if isinstance(env.action_space, spaces.Box):
utils.env_modifiers.make_action_filtered(env, clip_action_filter)
if not test:
# Scale rewards (and thus returns) to a reasonable range so that
# training is easier
env = pfrl.wrappers.ScaleReward(env, args.reward_scale_factor)
if (args.render_eval and test) or (args.render_train and not test):
env = pfrl.wrappers.Render(env)
return env
env = make_env(test=False)
timestep_limit = env.spec.max_episode_steps
obs_space = env.observation_space
obs_size = obs_space.low.size
action_space = env.action_space
if isinstance(action_space, spaces.Box):
action_size = action_space.low.size
# Use NAF to apply DQN to continuous action spaces
q_func = q_functions.FCQuadraticStateQFunction(
obs_size,
action_size,
n_hidden_channels=args.n_hidden_channels,
n_hidden_layers=args.n_hidden_layers,
action_space=action_space,
)
# Use the Ornstein-Uhlenbeck process for exploration
ou_sigma = (action_space.high - action_space.low) * 0.2
explorer = explorers.AdditiveOU(sigma=ou_sigma)
else:
n_actions = action_space.n
q_func = q_functions.FCStateQFunctionWithDiscreteAction(
obs_size,
n_actions,
n_hidden_channels=args.n_hidden_channels,
n_hidden_layers=args.n_hidden_layers,
)
# Use epsilon-greedy for exploration
explorer = explorers.LinearDecayEpsilonGreedy(
args.start_epsilon,
args.end_epsilon,
args.final_exploration_steps,
action_space.sample,
)
if args.noisy_net_sigma is not None:
pnn.to_factorized_noisy(q_func, sigma_scale=args.noisy_net_sigma)
# Turn off explorer
explorer = explorers.Greedy()
opt = optim.Adam(q_func.parameters())
rbuf_capacity = 5 * 10**5
if args.minibatch_size is None:
args.minibatch_size = 32
if args.prioritized_replay:
betasteps = (args.steps -
args.replay_start_size) // args.update_interval
rbuf = replay_buffers.PrioritizedReplayBuffer(rbuf_capacity,
betasteps=betasteps)
else:
rbuf = replay_buffers.ReplayBuffer(rbuf_capacity)
agent = DQN(
q_func,
opt,
rbuf,
gpu=args.gpu,
gamma=args.gamma,
explorer=explorer,
replay_start_size=args.replay_start_size,
target_update_interval=args.target_update_interval,
update_interval=args.update_interval,
minibatch_size=args.minibatch_size,
target_update_method=args.target_update_method,
soft_update_tau=args.soft_update_tau,
)
if args.load:
agent.load(args.load)
eval_env = make_env(test=True)
if args.demo:
eval_stats = experiments.eval_performance(
env=eval_env,
agent=agent,
n_steps=None,
n_episodes=args.eval_n_runs,
max_episode_len=timestep_limit,
)
print("n_runs: {} mean: {} median: {} stdev {}".format(
args.eval_n_runs,
eval_stats["mean"],
eval_stats["median"],
eval_stats["stdev"],
))
elif not args.actor_learner:
print(
"WARNING: Since https://github.com/pfnet/pfrl/pull/112 we have started"
" setting `eval_during_episode=True` in this script, which affects the"
" timings of evaluation phases.")
experiments.train_agent_with_evaluation(
agent=agent,
env=env,
steps=args.steps,
eval_n_steps=None,
eval_n_episodes=args.eval_n_runs,
eval_interval=args.eval_interval,
outdir=args.outdir,
eval_env=eval_env,
train_max_episode_len=timestep_limit,
eval_during_episode=True,
)
else:
# using impala mode when given num of envs
# When we use multiple envs, it is critical to ensure each env
# can occupy a CPU core to get the best performance.
# Therefore, we need to prevent potential CPU over-provision caused by
# multi-threading in Openmp and Numpy.
# Disable the multi-threading on Openmp and Numpy.
os.environ["OMP_NUM_THREADS"] = "1" # NOQA
(
make_actor,
learner,
poller,
exception_event,
) = agent.setup_actor_learner_training(args.num_envs)
poller.start()
learner.start()
experiments.train_agent_async(
processes=args.num_envs,
make_agent=make_actor,
make_env=make_env,
steps=args.steps,
eval_n_steps=None,
eval_n_episodes=args.eval_n_runs,
eval_interval=args.eval_interval,
outdir=args.outdir,
stop_event=learner.stop_event,
exception_event=exception_event,
)
poller.stop()
learner.stop()
poller.join()
learner.join()
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"--outdir",
type=str,
default="results",
help=(
"Directory path to save output files."
" If it does not exist, it will be created."
),
)
parser.add_argument(
"--env",
type=str,
default="'DClawTurnFixed-v0'",
help="OpenAI Gym MuJoCo env to perform algorithm on.",
)
parser.add_argument("--seed", type=int, default=0, help="Random seed [0, 2 ** 32)")
parser.add_argument(
"--gpu", type=int, default=-1, help="GPU to use, set to -1 if no GPU."
)
parser.add_argument(
"--load", type=str, default="", help="Directory to load agent from."
)
parser.add_argument(
"--max-steps",
type=int,
default=10 ** 6,
help="Total number of timesteps to train the agent.",
)
parser.add_argument(
"--eval-n-runs",
type=int,
default=10,
help="Number of episodes run for each evaluation.",
)
parser.add_argument(
"--eval-interval",
type=int,
default=5000,
help="Interval in timesteps between evaluations.",
)
parser.add_argument(
"--replay-start-size",
type=int,
default=10000,
help="Minimum replay buffer size before " + "performing gradient updates.",
)
parser.add_argument("--batch-size", type=int, default=64, help="Minibatch size")
parser.add_argument(
"--render", action="store_true", help="Render env states in a GUI window."
)
parser.add_argument(
"--demo", action="store_true", help="Just run evaluation, not training."
)
parser.add_argument("--load-pretrained", action="store_true", default=False)
parser.add_argument(
"--pretrained-type", type=str, default="best", choices=["best", "final"]
)
parser.add_argument(
"--monitor", action="store_true", help="Wrap env with gym.wrappers.Monitor."
)
parser.add_argument(
"--log-level", type=int, default=logging.INFO, help="Level of the root logger."
)
parser.add_argument("--gamma", type=float, default=0.9)
parser.add_argument("--ddpg-training-steps", type=int, default=int(1e3))
parser.add_argument("--adversary-training-steps", type=int,default=int(1e3))
args = parser.parse_args()
logging.basicConfig(level=args.log_level)
args.outdir = './results'
print("Output files are saved in {}".format(args.outdir))
# Set a random seed used in PFRL
utils.set_random_seed(args.seed)
def make_env(test):
env = gym.make('DClawTurnFixed-v0')
# Unwrap TimeLimit wrapper
assert isinstance(env, gym.wrappers.TimeLimit)
env = env.env
# Use different random seeds for train and test envs
env_seed = 2 ** 32 - 1 - args.seed if test else args.seed
env.seed(env_seed)
# Cast observations to float32 because our model uses float32
env = pfrl.wrappers.CastObservationToFloat32(env)
if args.monitor:
env = pfrl.wrappers.Monitor(env, args.outdir)
if args.render and not test:
env = pfrl.wrappers.Render(env)
return env
env = make_env(test=False)
timestep_limit = env.spec.max_episode_steps
obs_space = env.observation_space
action_space = env.action_space
print("Observation space:", obs_space)
print("Action space:", action_space)
obs_size = obs_space.low.size
action_size = action_space.low.size
q_func = nn.Sequential(
ConcatObsAndAction(),
nn.Linear(obs_size + action_size, 256),
nn.ReLU(),
nn.Linear(256, 256),
nn.ReLU(),
nn.Linear(256,256),
nn.ReLU(),
nn.Linear(256, 1),
)
policy = nn.Sequential(
nn.Linear(obs_size, 256),
nn.ReLU(),
nn.Linear(256, 256),
nn.ReLU(),
nn.Linear(256,256),
nn.ReLU(),
nn.Linear(256, action_size),
BoundByTanh(low=action_space.low, high=action_space.high),
DeterministicHead(),
)
ddpg_opt_a = torch.optim.Adam(policy.parameters())
ddpg_opt_c = torch.optim.Adam(q_func.parameters())
ddpg_rbuf = replay_buffers.ReplayBuffer(10 ** 6)
ddpg_explorer = explorers.AdditiveGaussian(
scale=0.1, low=action_space.low, high=action_space.high
)
def ddpg_burnin_action_func():
"""Select random actions until model is updated one or more times."""
return np.random.uniform(action_space.low, action_space.high).astype(np.float32)
# Hyperparameters in http://arxiv.org/abs/1802.09477
ddpg_agent = DDPG(
policy,
q_func,
ddpg_opt_a,
ddpg_opt_c,
ddpg_rbuf,
gamma=args.gamma,
explorer=ddpg_explorer,
replay_start_size=args.replay_start_size,
target_update_method="soft",
target_update_interval=1,
update_interval=1,
soft_update_tau=5e-3,
n_times_update=1,
gpu=args.gpu,
minibatch_size=args.batch_size,
burnin_action_func=ddpg_burnin_action_func,
)
def adversary_random_func():
return np.random.randint(0,9)
# adversary_q = Critic(obs_size, 1, hidden_size=adversary_hidden_size)
# adversary_action_space = gym.spaces.discrete.Discrete(9)
# adversary_q = q_functions.FCQuadraticStateQFunction(
# obs_size, 1, n_hidden_channels = 256, n_hidden_layers = 2,action_space = adversary_action_space
# )
adversary_q = nn.Sequential(
nn.Linear(obs_size, 256),
nn.Linear(256,256),
nn.Linear(256,256),
nn.Linear(256,1),
DiscreteActionValueHead(),
)
adversary_optimizer = torch.optim.Adam(adversary_q.parameters(), lr=1e-3)
adversary_rbuf_capacity = int(1e6)
adversary_rbuf = replay_buffers.ReplayBuffer(adversary_rbuf_capacity)
adversary_explorer = explorers.LinearDecayEpsilonGreedy(
1.0, 0.1, 10**4, adversary_random_func
)
adversary_agent = DQN(
adversary_q,
adversary_optimizer,
adversary_rbuf,
gpu=args.gpu,
gamma=args.gamma,
explorer=adversary_explorer,
replay_start_size=args.replay_start_size,
target_update_interval=1,
minibatch_size=args.batch_size,
target_update_method='soft',
soft_update_tau=5e-3
)
logger = logging.getLogger(__name__)
eval_env = make_env(test=True)
evaluator = Evaluator(
agent=ddpg_agent,
n_steps=None,
n_episodes=args.eval_n_runs,
eval_interval=args.eval_interval,
outdir=args.outdir,
max_episode_len=timestep_limit,
env=eval_env,
step_offset=0,
save_best_so_far_agent=True,
use_tensorboard=True,
logger=logger,
)
episode_reward = 0
ddpg_episode_idx = 0
adversary_episode_idx = 0
# o_0, r_0
current_state = env.reset()
t = 0
ddpg_t = 0
adversary_t = 0
episode_len = 0
try:
while t < args.max_steps:
for i in range(args.ddpg_training_steps):
t += 1
ddpg_t += 1
ddpg_action = ddpg_agent.act(current_state)
adversary_action = adversary_agent.act(current_state)
ddpg_action[adversary_action] = 0
next_state, reward, done, info = env.step(ddpg_action)
episode_reward += reward
episode_len += 1
reset = episode_len == timestep_limit or info.get("needs_reset", False)
ddpg_agent.observe(next_state, reward, done, reset)
current_state = next_state
if done or reset or t == args.max_steps:
logger.info(
"ddpg phase: outdir:%s step:%s episode:%s R:%s",
args.outdir,
ddpg_t,
ddpg_episode_idx,
episode_reward,
)
logger.info("statistics:%s", ddpg_agent.get_statistics())
if evaluator is not None:
evaluator.evaluate_if_necessary(t=t, episodes=ddpg_episode_idx + 1)
if t == args.max_steps:
break
episode_reward = 0
ddpg_episode_idx += 1
episode_len = 0
current_state = env.reset()
episode_reward = 0
episode_len = 0
current_state = env.reset()
print("start adversary training ")
for i in range(args.adversary_training_steps):
t += 1
adversary_t += 1
ddpg_action = ddpg_agent.act(current_state)
adversary_action = adversary_agent.act(current_state)
ddpg_action[adversary_action] = 0
next_state, reward, done, info = env.step(ddpg_action)
reward = -reward
episode_len += 1
reset = episode_len == timestep_limit or info.get("needs_reset", False)
adversary_agent.observe(next_state, reward, done, reset)
current_state = next_state
if done or reset or t == args.max_steps:
if t == args.max_steps:
break
episode_reward = 0
adversary_episode_idx += 1
episode_len = 0
current_state = env.reset()
except (Exception, KeyboardInterrupt):
# Save the current model before being killed
save_agent(ddpg_agent, t, args.outdir, logger, suffix="_ddpg_except")
save_agent(adversary_agent, t, args.outdir, logger, suffix="_adversary_except" )
raise
# Save the final model
save_agent(ddpg_agent, t, args.outdir, logger, suffix="_ddpg_finish")
save_agent(adversary_agent, t, args.outdir, logger, suffix="_adversary_finish" )
# if args.demo:
# eval_env.render()
# eval_stats = experiments.eval_performance(
# env=eval_env,
# agent=ddpg_agent,
# n_steps=None,
# n_episodes=args.eval_n_runbase_envs,
# max_episode_len=timestep_limit,
# )
# print(
# "n_runs: {} mean: {} median: {} stdev {}".format(
# args.eval_n_runs,
# eval_stats["mean"],
# eval_stats["median"],
# eval_stats["stdev"],
# )
# )
# else:
# experiments.train_agent_with_evaluation(
# agent=ddpg_agent,
# env=env,
# steps=args.steps,
# eval_env=eval_env,
# eval_n_steps=None,
# eval_n_episodes=args.eval_n_runs,
# eval_interval=args.eval_interval,
# outdir=args.outdir,
# train_max_episode_len=timestep_limit,
# )
print("finish")