text stringlengths 1 93.6k |
|---|
real_action = torch.tanh(action)
|
real_log_prob = log_prob - torch.log(1-torch.tanh(action).pow(2) + 1e-7)
|
return real_action, real_log_prob
|
def train_net(self, q1, q2, mini_batch):
|
s, _, _, _, _ = mini_batch
|
a, log_prob = self.forward(s)
|
entropy = -self.log_alpha.exp() * log_prob
|
q1_val, q2_val = q1(s,a), q2(s,a)
|
q1_q2 = torch.cat([q1_val, q2_val], dim=1)
|
min_q = torch.min(q1_q2, 1, keepdim=True)[0]
|
loss = -min_q - entropy # for gradient ascent
|
self.optimizer.zero_grad()
|
loss.mean().backward()
|
self.optimizer.step()
|
self.log_alpha_optimizer.zero_grad()
|
alpha_loss = -(self.log_alpha.exp() * (log_prob + target_entropy).detach()).mean()
|
alpha_loss.backward()
|
self.log_alpha_optimizer.step()
|
class QNet(nn.Module):
|
def __init__(self, learning_rate):
|
super(QNet, self).__init__()
|
self.fc_s = nn.Linear(3, 64)
|
self.fc_a = nn.Linear(1,64)
|
self.fc_cat = nn.Linear(128,32)
|
self.fc_out = nn.Linear(32,1)
|
self.optimizer = optim.Adam(self.parameters(), lr=learning_rate)
|
def forward(self, x, a):
|
h1 = F.relu(self.fc_s(x))
|
h2 = F.relu(self.fc_a(a))
|
cat = torch.cat([h1,h2], dim=1)
|
q = F.relu(self.fc_cat(cat))
|
q = self.fc_out(q)
|
return q
|
def train_net(self, target, mini_batch):
|
s, a, r, s_prime, done = mini_batch
|
loss = F.smooth_l1_loss(self.forward(s, a) , target)
|
self.optimizer.zero_grad()
|
loss.mean().backward()
|
self.optimizer.step()
|
def soft_update(self, net_target):
|
for param_target, param in zip(net_target.parameters(), self.parameters()):
|
param_target.data.copy_(param_target.data * (1.0 - tau) + param.data * tau)
|
def calc_target(pi, q1, q2, mini_batch):
|
s, a, r, s_prime, done = mini_batch
|
with torch.no_grad():
|
a_prime, log_prob= pi(s_prime)
|
entropy = -pi.log_alpha.exp() * log_prob
|
q1_val, q2_val = q1(s_prime,a_prime), q2(s_prime,a_prime)
|
q1_q2 = torch.cat([q1_val, q2_val], dim=1)
|
min_q = torch.min(q1_q2, 1, keepdim=True)[0]
|
target = r + gamma * done * (min_q + entropy)
|
return target
|
def main():
|
env = gym.make('Pendulum-v1')
|
memory = ReplayBuffer()
|
q1, q2, q1_target, q2_target = QNet(lr_q), QNet(lr_q), QNet(lr_q), QNet(lr_q)
|
pi = PolicyNet(lr_pi)
|
q1_target.load_state_dict(q1.state_dict())
|
q2_target.load_state_dict(q2.state_dict())
|
score = 0.0
|
print_interval = 20
|
for n_epi in range(10000):
|
s, _ = env.reset()
|
done = False
|
count = 0
|
while count < 200 and not done:
|
a, log_prob= pi(torch.from_numpy(s).float())
|
s_prime, r, done, truncated, info = env.step([2.0*a.item()])
|
memory.put((s, a.item(), r/10.0, s_prime, done))
|
score +=r
|
s = s_prime
|
count += 1
|
if memory.size()>1000:
|
for i in range(20):
|
mini_batch = memory.sample(batch_size)
|
td_target = calc_target(pi, q1_target, q2_target, mini_batch)
|
q1.train_net(td_target, mini_batch)
|
q2.train_net(td_target, mini_batch)
|
entropy = pi.train_net(q1, q2, mini_batch)
|
q1.soft_update(q1_target)
|
q2.soft_update(q2_target)
|
if n_epi%print_interval==0 and n_epi!=0:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.