第11章-TRPO算法.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "executionInfo": {
     "elapsed": 3,
     "status": "ok",
     "timestamp": 1649955728342,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "X-ulV3eB_Sk_"
   },
   "outputs": [],
   "source": [
    "def compute_advantage(gamma, lmbda, td_delta):\n",
    "    td_delta = td_delta.detach().numpy()\n",
    "    advantage_list = []\n",
    "    advantage = 0.0\n",
    "    for delta in td_delta[::-1]:\n",
    "        advantage = gamma * lmbda * advantage + delta\n",
    "        advantage_list.append(advantage)\n",
    "    advantage_list.reverse()\n",
    "    return torch.tensor(advantage_list, dtype=torch.float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "executionInfo": {
     "elapsed": 7736,
     "status": "ok",
     "timestamp": 1649955738062,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "pJ6Z1jfP_SlD"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import torch.nn.functional as F\n",
    "import rl_utils\n",
    "import copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "executionInfo": {
     "elapsed": 410,
     "status": "ok",
     "timestamp": 1649955894771,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "4zmEubV8_SlD"
   },
   "outputs": [],
   "source": [
    "class PolicyNet(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(PolicyNet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, action_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return F.softmax(self.fc2(x), dim=1)\n",
    "\n",
    "\n",
    "class ValueNet(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim):\n",
    "        super(ValueNet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return self.fc2(x)\n",
    "\n",
    "\n",
    "class TRPO:\n",
    "    \"\"\" TRPO算法 \"\"\"\n",
    "    def __init__(self, hidden_dim, state_space, action_space, lmbda,\n",
    "                 kl_constraint, alpha, critic_lr, gamma, device):\n",
    "        state_dim = state_space.shape[0]\n",
    "        action_dim = action_space.n\n",
    "        # 策略网络参数不需要优化器更新\n",
    "        self.actor = PolicyNet(state_dim, hidden_dim, action_dim).to(device)\n",
    "        self.critic = ValueNet(state_dim, hidden_dim).to(device)\n",
    "        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(),\n",
    "                                                 lr=critic_lr)\n",
    "        self.gamma = gamma\n",
    "        self.lmbda = lmbda  # GAE参数\n",
    "        self.kl_constraint = kl_constraint  # KL距离最大限制\n",
    "        self.alpha = alpha  # 线性搜索参数\n",
    "        self.device = device\n",
    "\n",
    "    def take_action(self, state):\n",
    "        state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
    "        probs = self.actor(state)\n",
    "        action_dist = torch.distributions.Categorical(probs)\n",
    "        action = action_dist.sample()\n",
    "        return action.item()\n",
    "\n",
    "    def hessian_matrix_vector_product(self, states, old_action_dists, vector):\n",
    "        # 计算黑塞矩阵和一个向量的乘积\n",
    "        new_action_dists = torch.distributions.Categorical(self.actor(states))\n",
    "        kl = torch.mean(\n",
    "            torch.distributions.kl.kl_divergence(old_action_dists,\n",
    "                                                 new_action_dists))  # 计算平均KL距离\n",
    "        kl_grad = torch.autograd.grad(kl,\n",
    "                                      self.actor.parameters(),\n",
    "                                      create_graph=True)\n",
    "        kl_grad_vector = torch.cat([grad.view(-1) for grad in kl_grad])\n",
    "        # KL距离的梯度先和向量进行点积运算\n",
    "        kl_grad_vector_product = torch.dot(kl_grad_vector, vector)\n",
    "        grad2 = torch.autograd.grad(kl_grad_vector_product,\n",
    "                                    self.actor.parameters())\n",
    "        grad2_vector = torch.cat([grad.view(-1) for grad in grad2])\n",
    "        return grad2_vector\n",
    "\n",
    "    def conjugate_gradient(self, grad, states, old_action_dists):  # 共轭梯度法求解方程\n",
    "        x = torch.zeros_like(grad)\n",
    "        r = grad.clone()\n",
    "        p = grad.clone()\n",
    "        rdotr = torch.dot(r, r)\n",
    "        for i in range(10):  # 共轭梯度主循环\n",
    "            Hp = self.hessian_matrix_vector_product(states, old_action_dists,\n",
    "                                                    p)\n",
    "            alpha = rdotr / torch.dot(p, Hp)\n",
    "            x += alpha * p\n",
    "            r -= alpha * Hp\n",
    "            new_rdotr = torch.dot(r, r)\n",
    "            if new_rdotr < 1e-10:\n",
    "                break\n",
    "            beta = new_rdotr / rdotr\n",
    "            p = r + beta * p\n",
    "            rdotr = new_rdotr\n",
    "        return x\n",
    "\n",
    "    def compute_surrogate_obj(self, states, actions, advantage, old_log_probs,\n",
    "                              actor):  # 计算策略目标\n",
    "        log_probs = torch.log(actor(states).gather(1, actions))\n",
    "        ratio = torch.exp(log_probs - old_log_probs)\n",
    "        return torch.mean(ratio * advantage)\n",
    "\n",
    "    def line_search(self, states, actions, advantage, old_log_probs,\n",
    "                    old_action_dists, max_vec):  # 线性搜索\n",
    "        old_para = torch.nn.utils.convert_parameters.parameters_to_vector(\n",
    "            self.actor.parameters())\n",
    "        old_obj = self.compute_surrogate_obj(states, actions, advantage,\n",
    "                                             old_log_probs, self.actor)\n",
    "        for i in range(15):  # 线性搜索主循环\n",
    "            coef = self.alpha**i\n",
    "            new_para = old_para + coef * max_vec\n",
    "            new_actor = copy.deepcopy(self.actor)\n",
    "            torch.nn.utils.convert_parameters.vector_to_parameters(\n",
    "                new_para, new_actor.parameters())\n",
    "            new_action_dists = torch.distributions.Categorical(\n",
    "                new_actor(states))\n",
    "            kl_div = torch.mean(\n",
    "                torch.distributions.kl.kl_divergence(old_action_dists,\n",
    "                                                     new_action_dists))\n",
    "            new_obj = self.compute_surrogate_obj(states, actions, advantage,\n",
    "                                                 old_log_probs, new_actor)\n",
    "            if new_obj > old_obj and kl_div < self.kl_constraint:\n",
    "                return new_para\n",
    "        return old_para\n",
    "\n",
    "    def policy_learn(self, states, actions, old_action_dists, old_log_probs,\n",
    "                     advantage):  # 更新策略函数\n",
    "        surrogate_obj = self.compute_surrogate_obj(states, actions, advantage,\n",
    "                                                   old_log_probs, self.actor)\n",
    "        grads = torch.autograd.grad(surrogate_obj, self.actor.parameters())\n",
    "        obj_grad = torch.cat([grad.view(-1) for grad in grads]).detach()\n",
    "        # 用共轭梯度法计算x = H^(-1)g\n",
    "        descent_direction = self.conjugate_gradient(obj_grad, states,\n",
    "                                                    old_action_dists)\n",
    "\n",
    "        Hd = self.hessian_matrix_vector_product(states, old_action_dists,\n",
    "                                                descent_direction)\n",
    "        max_coef = torch.sqrt(2 * self.kl_constraint /\n",
    "                              (torch.dot(descent_direction, Hd) + 1e-8))\n",
    "        new_para = self.line_search(states, actions, advantage, old_log_probs,\n",
    "                                    old_action_dists,\n",
    "                                    descent_direction * max_coef)  # 线性搜索\n",
    "        torch.nn.utils.convert_parameters.vector_to_parameters(\n",
    "            new_para, self.actor.parameters())  # 用线性搜索后的参数更新策略\n",
    "\n",
    "    def update(self, transition_dict):\n",
    "        states = torch.tensor(transition_dict['states'],\n",
    "                              dtype=torch.float).to(self.device)\n",
    "        actions = torch.tensor(transition_dict['actions']).view(-1, 1).to(\n",
    "            self.device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'],\n",
    "                               dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'],\n",
    "                                   dtype=torch.float).to(self.device)\n",
    "        dones = torch.tensor(transition_dict['dones'],\n",
    "                             dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        td_target = rewards + self.gamma * self.critic(next_states) * (1 -\n",
    "                                                                       dones)\n",
    "        td_delta = td_target - self.critic(states)\n",
    "        advantage = compute_advantage(self.gamma, self.lmbda,\n",
    "                                      td_delta.cpu()).to(self.device)\n",
    "        old_log_probs = torch.log(self.actor(states).gather(1,\n",
    "                                                            actions)).detach()\n",
    "        old_action_dists = torch.distributions.Categorical(\n",
    "            self.actor(states).detach())\n",
    "        critic_loss = torch.mean(\n",
    "            F.mse_loss(self.critic(states), td_target.detach()))\n",
    "        self.critic_optimizer.zero_grad()\n",
    "        critic_loss.backward()\n",
    "        self.critic_optimizer.step()  # 更新价值函数\n",
    "        # 更新策略函数\n",
    "        self.policy_learn(states, actions, old_action_dists, old_log_probs,\n",
    "                          advantage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 784
    },
    "executionInfo": {
     "elapsed": 48952,
     "status": "ok",
     "timestamp": 1649955953447,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "qH-NM0TS_SlJ",
    "outputId": "21bcec63-0738-434a-9b73-ff4936755d98"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0:   0%|          | 0/50 [00:00<?, ?it/s]/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:38: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at  ../torch/csrc/utils/tensor_new.cpp:201.)\n",
      "Iteration 0: 100%|██████████| 50/50 [00:03<00:00, 15.71it/s, episode=50, return=139.200]\n",
      "Iteration 1: 100%|██████████| 50/50 [00:03<00:00, 13.08it/s, episode=100, return=150.500]\n",
      "Iteration 2: 100%|██████████| 50/50 [00:04<00:00, 11.57it/s, episode=150, return=184.000]\n",
      "Iteration 3: 100%|██████████| 50/50 [00:06<00:00,  7.60it/s, episode=200, return=183.600]\n",
      "Iteration 4: 100%|██████████| 50/50 [00:06<00:00,  7.17it/s, episode=250, return=183.500]\n",
      "Iteration 5: 100%|██████████| 50/50 [00:04<00:00, 10.91it/s, episode=300, return=193.700]\n",
      "Iteration 6: 100%|██████████| 50/50 [00:04<00:00, 10.70it/s, episode=350, return=199.500]\n",
      "Iteration 7: 100%|██████████| 50/50 [00:04<00:00, 10.89it/s, episode=400, return=200.000]\n",
      "Iteration 8: 100%|██████████| 50/50 [00:04<00:00, 10.80it/s, episode=450, return=200.000]\n",
      "Iteration 9: 100%|██████████| 50/50 [00:04<00:00, 11.09it/s, episode=500, return=200.000]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_episodes = 500\n",
    "hidden_dim = 128\n",
    "gamma = 0.98\n",
    "lmbda = 0.95\n",
    "critic_lr = 1e-2\n",
    "kl_constraint = 0.0005\n",
    "alpha = 0.5\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\n",
    "    \"cpu\")\n",
    "\n",
    "env_name = 'CartPole-v0'\n",
    "env = gym.make(env_name)\n",
    "env.seed(0)\n",
    "torch.manual_seed(0)\n",
    "agent = TRPO(hidden_dim, env.observation_space, env.action_space, lmbda,\n",
    "             kl_constraint, alpha, critic_lr, gamma, device)\n",
    "return_list = rl_utils.train_on_policy_agent(env, agent, num_episodes)\n",
    "\n",
    "episodes_list = list(range(len(return_list)))\n",
    "plt.plot(episodes_list, return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('TRPO on {}'.format(env_name))\n",
    "plt.show()\n",
    "\n",
    "mv_return = rl_utils.moving_average(return_list, 9)\n",
    "plt.plot(episodes_list, mv_return)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('TRPO on {}'.format(env_name))\n",
    "plt.show()\n",
    "\n",
    "# Iteration 0: 100%|██████████| 50/50 [00:02<00:00, 16.85it/s, episode=50,\n",
    "# return=139.200]\n",
    "# Iteration 1: 100%|██████████| 50/50 [00:03<00:00, 16.55it/s, episode=100,\n",
    "# return=150.500]\n",
    "# Iteration 2: 100%|██████████| 50/50 [00:03<00:00, 14.21it/s, episode=150,\n",
    "# return=184.000]\n",
    "# Iteration 3: 100%|██████████| 50/50 [00:03<00:00, 14.15it/s, episode=200,\n",
    "# return=183.600]\n",
    "# Iteration 4: 100%|██████████| 50/50 [00:03<00:00, 13.96it/s, episode=250,\n",
    "# return=183.500]\n",
    "# Iteration 5: 100%|██████████| 50/50 [00:03<00:00, 13.29it/s, episode=300,\n",
    "# return=193.700]\n",
    "# Iteration 6: 100%|██████████| 50/50 [00:03<00:00, 14.08it/s, episode=350,\n",
    "# return=199.500]\n",
    "# Iteration 7: 100%|██████████| 50/50 [00:03<00:00, 13.36it/s, episode=400,\n",
    "# return=200.000]\n",
    "# Iteration 8: 100%|██████████| 50/50 [00:03<00:00, 13.33it/s, episode=450,\n",
    "# return=200.000]\n",
    "# Iteration 9: 100%|██████████| 50/50 [00:03<00:00, 13.08it/s, episode=500,\n",
    "# return=200.000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "executionInfo": {
     "elapsed": 465,
     "status": "ok",
     "timestamp": 1649956066886,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "PNG1FiQf_SlK"
   },
   "outputs": [],
   "source": [
    "class PolicyNetContinuous(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(PolicyNetContinuous, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc_mu = torch.nn.Linear(hidden_dim, action_dim)\n",
    "        self.fc_std = torch.nn.Linear(hidden_dim, action_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        mu = 2.0 * torch.tanh(self.fc_mu(x))\n",
    "        std = F.softplus(self.fc_std(x))\n",
    "        return mu, std  # 高斯分布的均值和标准差\n",
    "\n",
    "\n",
    "class TRPOContinuous:\n",
    "    \"\"\" 处理连续动作的TRPO算法 \"\"\"\n",
    "    def __init__(self, hidden_dim, state_space, action_space, lmbda,\n",
    "                 kl_constraint, alpha, critic_lr, gamma, device):\n",
    "        state_dim = state_space.shape[0]\n",
    "        action_dim = action_space.shape[0]\n",
    "        self.actor = PolicyNetContinuous(state_dim, hidden_dim,\n",
    "                                         action_dim).to(device)\n",
    "        self.critic = ValueNet(state_dim, hidden_dim).to(device)\n",
    "        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(),\n",
    "                                                 lr=critic_lr)\n",
    "        self.gamma = gamma\n",
    "        self.lmbda = lmbda\n",
    "        self.kl_constraint = kl_constraint\n",
    "        self.alpha = alpha\n",
    "        self.device = device\n",
    "\n",
    "    def take_action(self, state):\n",
    "        state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
    "        mu, std = self.actor(state)\n",
    "        action_dist = torch.distributions.Normal(mu, std)\n",
    "        action = action_dist.sample()\n",
    "        return [action.item()]\n",
    "\n",
    "    def hessian_matrix_vector_product(self,\n",
    "                                      states,\n",
    "                                      old_action_dists,\n",
    "                                      vector,\n",
    "                                      damping=0.1):\n",
    "        mu, std = self.actor(states)\n",
    "        new_action_dists = torch.distributions.Normal(mu, std)\n",
    "        kl = torch.mean(\n",
    "            torch.distributions.kl.kl_divergence(old_action_dists,\n",
    "                                                 new_action_dists))\n",
    "        kl_grad = torch.autograd.grad(kl,\n",
    "                                      self.actor.parameters(),\n",
    "                                      create_graph=True)\n",
    "        kl_grad_vector = torch.cat([grad.view(-1) for grad in kl_grad])\n",
    "        kl_grad_vector_product = torch.dot(kl_grad_vector, vector)\n",
    "        grad2 = torch.autograd.grad(kl_grad_vector_product,\n",
    "                                    self.actor.parameters())\n",
    "        grad2_vector = torch.cat(\n",
    "            [grad.contiguous().view(-1) for grad in grad2])\n",
    "        return grad2_vector + damping * vector\n",
    "\n",
    "    def conjugate_gradient(self, grad, states, old_action_dists):\n",
    "        x = torch.zeros_like(grad)\n",
    "        r = grad.clone()\n",
    "        p = grad.clone()\n",
    "        rdotr = torch.dot(r, r)\n",
    "        for i in range(10):\n",
    "            Hp = self.hessian_matrix_vector_product(states, old_action_dists,\n",
    "                                                    p)\n",
    "            alpha = rdotr / torch.dot(p, Hp)\n",
    "            x += alpha * p\n",
    "            r -= alpha * Hp\n",
    "            new_rdotr = torch.dot(r, r)\n",
    "            if new_rdotr < 1e-10:\n",
    "                break\n",
    "            beta = new_rdotr / rdotr\n",
    "            p = r + beta * p\n",
    "            rdotr = new_rdotr\n",
    "        return x\n",
    "\n",
    "    def compute_surrogate_obj(self, states, actions, advantage, old_log_probs,\n",
    "                              actor):\n",
    "        mu, std = actor(states)\n",
    "        action_dists = torch.distributions.Normal(mu, std)\n",
    "        log_probs = action_dists.log_prob(actions)\n",
    "        ratio = torch.exp(log_probs - old_log_probs)\n",
    "        return torch.mean(ratio * advantage)\n",
    "\n",
    "    def line_search(self, states, actions, advantage, old_log_probs,\n",
    "                    old_action_dists, max_vec):\n",
    "        old_para = torch.nn.utils.convert_parameters.parameters_to_vector(\n",
    "            self.actor.parameters())\n",
    "        old_obj = self.compute_surrogate_obj(states, actions, advantage,\n",
    "                                             old_log_probs, self.actor)\n",
    "        for i in range(15):\n",
    "            coef = self.alpha**i\n",
    "            new_para = old_para + coef * max_vec\n",
    "            new_actor = copy.deepcopy(self.actor)\n",
    "            torch.nn.utils.convert_parameters.vector_to_parameters(\n",
    "                new_para, new_actor.parameters())\n",
    "            mu, std = new_actor(states)\n",
    "            new_action_dists = torch.distributions.Normal(mu, std)\n",
    "            kl_div = torch.mean(\n",
    "                torch.distributions.kl.kl_divergence(old_action_dists,\n",
    "                                                     new_action_dists))\n",
    "            new_obj = self.compute_surrogate_obj(states, actions, advantage,\n",
    "                                                 old_log_probs, new_actor)\n",
    "            if new_obj > old_obj and kl_div < self.kl_constraint:\n",
    "                return new_para\n",
    "        return old_para\n",
    "\n",
    "    def policy_learn(self, states, actions, old_action_dists, old_log_probs,\n",
    "                     advantage):\n",
    "        surrogate_obj = self.compute_surrogate_obj(states, actions, advantage,\n",
    "                                                   old_log_probs, self.actor)\n",
    "        grads = torch.autograd.grad(surrogate_obj, self.actor.parameters())\n",
    "        obj_grad = torch.cat([grad.view(-1) for grad in grads]).detach()\n",
    "        descent_direction = self.conjugate_gradient(obj_grad, states,\n",
    "                                                    old_action_dists)\n",
    "        Hd = self.hessian_matrix_vector_product(states, old_action_dists,\n",
    "                                                descent_direction)\n",
    "        max_coef = torch.sqrt(2 * self.kl_constraint /\n",
    "                              (torch.dot(descent_direction, Hd) + 1e-8))\n",
    "        new_para = self.line_search(states, actions, advantage, old_log_probs,\n",
    "                                    old_action_dists,\n",
    "                                    descent_direction * max_coef)\n",
    "        torch.nn.utils.convert_parameters.vector_to_parameters(\n",
    "            new_para, self.actor.parameters())\n",
    "\n",
    "    def update(self, transition_dict):\n",
    "        states = torch.tensor(transition_dict['states'],\n",
    "                              dtype=torch.float).to(self.device)\n",
    "        actions = torch.tensor(transition_dict['actions'],\n",
    "                               dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'],\n",
    "                               dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'],\n",
    "                                   dtype=torch.float).to(self.device)\n",
    "        dones = torch.tensor(transition_dict['dones'],\n",
    "                             dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        rewards = (rewards + 8.0) / 8.0  # 对奖励进行修改,方便训练\n",
    "        td_target = rewards + self.gamma * self.critic(next_states) * (1 -\n",
    "                                                                       dones)\n",
    "        td_delta = td_target - self.critic(states)\n",
    "        advantage = compute_advantage(self.gamma, self.lmbda,\n",
    "                                      td_delta.cpu()).to(self.device)\n",
    "        mu, std = self.actor(states)\n",
    "        old_action_dists = torch.distributions.Normal(mu.detach(),\n",
    "                                                      std.detach())\n",
    "        old_log_probs = old_action_dists.log_prob(actions)\n",
    "        critic_loss = torch.mean(\n",
    "            F.mse_loss(self.critic(states), td_target.detach()))\n",
    "        self.critic_optimizer.zero_grad()\n",
    "        critic_loss.backward()\n",
    "        self.critic_optimizer.step()\n",
    "        self.policy_learn(states, actions, old_action_dists, old_log_probs,\n",
    "                          advantage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 747
    },
    "executionInfo": {
     "elapsed": 233402,
     "status": "ok",
     "timestamp": 1649956314084,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "e0qF7lu0_SlM",
    "outputId": "f29a86f6-6f69-4dad-ea9a-979189c0f253"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0: 100%|██████████| 200/200 [00:23<00:00,  8.63it/s, episode=200, return=-1181.390]\n",
      "Iteration 1: 100%|██████████| 200/200 [00:23<00:00,  8.68it/s, episode=400, return=-994.876]\n",
      "Iteration 2: 100%|██████████| 200/200 [00:23<00:00,  8.39it/s, episode=600, return=-888.498]\n",
      "Iteration 3: 100%|██████████| 200/200 [00:23<00:00,  8.69it/s, episode=800, return=-848.329]\n",
      "Iteration 4: 100%|██████████| 200/200 [00:23<00:00,  8.68it/s, episode=1000, return=-772.392]\n",
      "Iteration 5: 100%|██████████| 200/200 [00:22<00:00,  8.72it/s, episode=1200, return=-611.870]\n",
      "Iteration 6: 100%|██████████| 200/200 [00:23<00:00,  8.62it/s, episode=1400, return=-397.705]\n",
      "Iteration 7: 100%|██████████| 200/200 [00:23<00:00,  8.68it/s, episode=1600, return=-268.498]\n",
      "Iteration 8: 100%|██████████| 200/200 [00:23<00:00,  8.61it/s, episode=1800, return=-408.976]\n",
      "Iteration 9: 100%|██████████| 200/200 [00:23<00:00,  8.49it/s, episode=2000, return=-296.363]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_episodes = 2000\n",
    "hidden_dim = 128\n",
    "gamma = 0.9\n",
    "lmbda = 0.9\n",
    "critic_lr = 1e-2\n",
    "kl_constraint = 0.00005\n",
    "alpha = 0.5\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\n",
    "    \"cpu\")\n",
    "\n",
    "env_name = 'Pendulum-v0'\n",
    "env = gym.make(env_name)\n",
    "env.seed(0)\n",
    "torch.manual_seed(0)\n",
    "agent = TRPOContinuous(hidden_dim, env.observation_space, env.action_space,\n",
    "                       lmbda, kl_constraint, alpha, critic_lr, gamma, device)\n",
    "return_list = rl_utils.train_on_policy_agent(env, agent, num_episodes)\n",
    "\n",
    "episodes_list = list(range(len(return_list)))\n",
    "plt.plot(episodes_list, return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('TRPO on {}'.format(env_name))\n",
    "plt.show()\n",
    "\n",
    "mv_return = rl_utils.moving_average(return_list, 9)\n",
    "plt.plot(episodes_list, mv_return)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('TRPO on {}'.format(env_name))\n",
    "plt.show()\n",
    "\n",
    "# Iteration 0: 100%|██████████| 200/200 [00:19<00:00, 10.00it/s, episode=200,\n",
    "# return=-1181.390]\n",
    "# Iteration 1: 100%|██████████| 200/200 [00:20<00:00,  9.98it/s, episode=400,\n",
    "# return=-994.876]\n",
    "# Iteration 2: 100%|██████████| 200/200 [00:20<00:00,  9.86it/s, episode=600,\n",
    "# return=-888.498]\n",
    "# Iteration 3: 100%|██████████| 200/200 [00:20<00:00,  9.94it/s, episode=800,\n",
    "# return=-848.329]\n",
    "# Iteration 4: 100%|██████████| 200/200 [00:20<00:00,  9.87it/s, episode=1000,\n",
    "# return=-772.392]\n",
    "# Iteration 5: 100%|██████████| 200/200 [00:20<00:00,  9.91it/s, episode=1200,\n",
    "# return=-611.870]\n",
    "# Iteration 6: 100%|██████████| 200/200 [00:20<00:00,  9.89it/s, episode=1400,\n",
    "# return=-397.705]\n",
    "# Iteration 7: 100%|██████████| 200/200 [00:20<00:00,  9.95it/s, episode=1600,\n",
    "# return=-268.498]\n",
    "# Iteration 8: 100%|██████████| 200/200 [00:20<00:00,  9.87it/s, episode=1800,\n",
    "# return=-408.976]\n",
    "# Iteration 9: 100%|██████████| 200/200 [00:19<00:00, 10.08it/s, episode=2000,\n",
    "# return=-296.363]"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "第11章-TRPO算法.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}