File size: 3,441 Bytes
6e5cc8b |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 |
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from drqv2 import Actor, Encoder, RandomShiftsAug
import utils
class BCAgent:
def __init__(self, obs_shape, action_shape, device, lr, feature_dim,
hidden_dim, critic_target_tau, num_expl_steps,
update_every_steps, stddev_schedule, stddev_clip, use_tb,
augmentation=RandomShiftsAug(pad=4)):
self.device = device
self.critic_target_tau = critic_target_tau
self.update_every_steps = update_every_steps
self.use_tb = use_tb
self.num_expl_steps = num_expl_steps
self.stddev_schedule = stddev_schedule
self.stddev_clip = stddev_clip
# models
self.encoder = Encoder(obs_shape).to(device)
self.actor = Actor(self.encoder.repr_dim, action_shape, feature_dim,
hidden_dim).to(device)
# optimizers
self.encoder_opt = torch.optim.Adam(self.encoder.parameters(), lr=lr)
self.actor_opt = torch.optim.Adam(self.actor.parameters(), lr=lr)
# data augmentation
self.aug = augmentation
self.train()
def train(self, training=True):
self.training = training
self.encoder.train(training)
self.actor.train(training)
def act(self, obs, step, eval_mode):
obs = torch.as_tensor(obs, device=self.device)
obs = self.encoder(obs.unsqueeze(0))
stddev = utils.schedule(self.stddev_schedule, step)
dist = self.actor(obs, stddev)
if eval_mode:
action = dist.mean
else:
action = dist.sample(clip=None)
if step < self.num_expl_steps:
action.uniform_(-1.0, 1.0)
return action.cpu().numpy()[0]
def update_actor(self, obs, step, behavioural_action=None):
metrics = dict()
stddev = utils.schedule(self.stddev_schedule, step)
dist = self.actor(obs, stddev)
action = dist.sample(clip=self.stddev_clip)
log_prob = dist.log_prob(action).sum(-1, keepdim=True)
# offline BC Loss
actor_loss = F.mse_loss(action, behavioural_action)
# optimize actor and encoder
self.encoder_opt.zero_grad(set_to_none=True)
self.actor_opt.zero_grad(set_to_none=True)
actor_loss.backward()
self.actor_opt.step()
self.encoder_opt.step()
if self.use_tb:
metrics['actor_logprob'] = log_prob.mean().item()
metrics['actor_ent'] = dist.entropy().sum(dim=-1).mean().item()
metrics['actor_bc_loss'] = actor_loss.item()
return metrics
def update(self, replay_buffer, step):
metrics = dict()
if step % self.update_every_steps != 0:
return metrics
batch = next(replay_buffer)
obs, action, reward, _, _ = utils.to_torch(
batch, self.device)
# augment
obs = self.aug(obs.float())
# encode
obs = self.encoder(obs)
if self.use_tb:
metrics['batch_reward'] = reward.mean().item()
# update actor
metrics.update(self.update_actor(obs, step, action.detach()))
return metrics
|