ex12_PG.ipynb

{"cells":[{"cell_type":"markdown","id":"39250c4d","metadata":{"id":"39250c4d"},"source":["# Policy Gradient\n","\n","In reinforcement learning, the goal is to find a policy that maximizes the expected cumulative reward over time. Policy Gradient (PG) methods are a class of algorithms for finding such policies in which the policy is represented by a parameterized function, such as a neural network. The key idea behind PG methods is to adjust the parameters of the policy in the direction that increases the expected reward. This is done by computing the gradient of the expected reward with respect to the policy parameters and updating the parameters in the direction of the gradient.\n","\n","Unfortunately, calculating exact policy gradient requires iterating over the entire state-action space, which is unfeasible in most problems. As such, we estimate the gradient with a sample of recent transitions, which were sampled according to the policy. In its simplest form, PG is equal to:\n","\n","$$\n","\\nabla_{\\theta} J = \\underset{s \\sim p^{\\pi}_{*}}{\\mathbb{E}} ~ \\underset{a \\sim \\pi}{\\mathbb{E}} ~ Q^{\\pi} (s, a) ~ \\nabla_{\\theta} \\log \\pi_{\\theta} (a | s)\n","$$\n","\n","Where $p^{\\pi}_{*}$ is the discounted stationary distribution, $\\pi_{\\theta}(a|s)$ is the policy and $Q^{\\pi} (s, a)$ denotes the Q-value under policy. Some of the popular policy gradient algorithm are Actor-Critic and PPO. These algorithm use different techniques to estimate the gradient and update the policy.\n","\n","Tasks:\n","\n","1. Run the **PolicyGradient** agent. Plot mean+std of rewards during the training.\n","2. Implement the *update* method for **BaselinedPolicyGradient** class. Run the agent, plot mean+std of rewards during the training.\n","3. Implement the *update* method for **ActorCritic** class. Run the agent, plot mean+std of rewards during the training."]},{"cell_type":"markdown","id":"0acf50b2","metadata":{"id":"0acf50b2"},"source":["We import required modules and fix hyperparamters:"]},{"cell_type":"code","execution_count":1,"id":"8ceeec92","metadata":{"id":"8ceeec92","executionInfo":{"status":"ok","timestamp":1674562321347,"user_tz":-60,"elapsed":4906,"user":{"displayName":"Michał Janik","userId":"10483929333441523386"}}},"outputs":[],"source":["import torch\n","import torch.nn as nn\n","import torch.optim as optim\n","import gym\n","import time\n","import numpy as np"]},{"cell_type":"code","execution_count":2,"id":"6f47d27a","metadata":{"id":"6f47d27a","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1674562321829,"user_tz":-60,"elapsed":485,"user":{"displayName":"Michał Janik","userId":"10483929333441523386"}},"outputId":"fdc9d902-d0c1-40e2-e78f-42474be73f37"},"outputs":[{"output_type":"stream","name":"stderr","text":["/usr/local/lib/python3.8/dist-packages/gym/envs/registration.py:593: UserWarning: \u001b[33mWARN: The environment CartPole-v0 is out of date. You should consider upgrading to version `v1`.\u001b[0m\n","  logger.warn(\n","/usr/local/lib/python3.8/dist-packages/gym/core.py:317: DeprecationWarning: \u001b[33mWARN: Initializing wrapper in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\u001b[0m\n","  deprecation(\n","/usr/local/lib/python3.8/dist-packages/gym/wrappers/step_api_compatibility.py:39: DeprecationWarning: \u001b[33mWARN: Initializing environment in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\u001b[0m\n","  deprecation(\n"]}],"source":["# do not change!\n","class parse_args:\n","    def __init__(self):\n","        self.gym_id = \"CartPole-v0\"\n","        self.batch_size = 32\n","        self.hidden_dim = 32\n","        self.learning_rate = 5e-3\n","        self.discount = 0.99\n","        self.timesteps = 10000\n","        self.repeats = 10\n","        self.eval_steps = 500\n","        self.cuda = True\n","        env = gym.make(self.gym_id)\n","        self.state_size = env.observation_space.shape[0]\n","        self.action_size = env.action_space.n\n","        self.device = torch.device(\"cuda\" if torch.cuda.is_available() and self.cuda else \"cpu\")\n","\n","args = parse_args()"]},{"cell_type":"markdown","id":"d6a2a605","metadata":{"id":"d6a2a605"},"source":["We define a policy network (**ActorNetwork**) and a value network (**CriticNetwork**). Value network has multiple uses, but we will initially use it to bootstrap Q-values of unfinished episodes.\n","\n","Why do we need such bootstrap? Our environment can run up to 200 steps before termination. Given batch size of 32, we will never be able to get entire episode in one batch. As PG requires Q-values of all state-actions in the batch, we have to find a way of calculating the Q-values past our batch."]},{"cell_type":"code","execution_count":3,"id":"8d97a2b8","metadata":{"id":"8d97a2b8","executionInfo":{"status":"ok","timestamp":1674562346206,"user_tz":-60,"elapsed":377,"user":{"displayName":"Michał Janik","userId":"10483929333441523386"}}},"outputs":[],"source":["class ActorNetwork(nn.Module):\n","    def __init__(self, args):\n","        super(ActorNetwork, self).__init__()\n","        self.layers = nn.Sequential(\n","            nn.Linear(args.state_size, args.hidden_dim), nn.ReLU(),\n","            nn.Linear(args.hidden_dim, args.action_size))\n","        \n","    def forward(self, x):\n","        return nn.Softmax(1)(self.layers(x))\n","    \n","class CriticNetwork(nn.Module):\n","    def __init__(self, args):\n","        super(CriticNetwork, self).__init__()\n","        self.layers = nn.Sequential(\n","            nn.Linear(args.state_size, args.hidden_dim), nn.ReLU(),\n","            nn.Linear(args.hidden_dim, 1))\n","        \n","    def forward(self, x):\n","        return self.layers(x)"]},{"cell_type":"markdown","id":"183095c8","metadata":{"id":"183095c8"},"source":["Below, we implement the PG agent. There are two important methods here:\n","\n","1. *get_qvalues* - calculate Q-values for the batch. If final state is not terminating, use value network to estimate value of past final state.\n","2. *update* - update actor and citic networks. "]},{"cell_type":"code","execution_count":4,"id":"585f0e73","metadata":{"id":"585f0e73","executionInfo":{"status":"ok","timestamp":1674563018490,"user_tz":-60,"elapsed":411,"user":{"displayName":"Michał Janik","userId":"10483929333441523386"}}},"outputs":[],"source":["class PolicyGradient(nn.Module):\n","    def __init__(self, args):\n","        super(PolicyGradient, self).__init__()\n","        self.args = args\n","        self.init_networks()\n","        \n","    def reset(self):\n","        self.logprobs = torch.zeros(self.args.batch_size)\n","        self.values = torch.zeros(self.args.batch_size)\n","        self.rewards = torch.zeros(self.args.batch_size)\n","        self.terminals = torch.zeros(self.args.batch_size)\n","        self.idx = 0\n","        \n","    def init_networks(self):\n","        self.actor = ActorNetwork(self.args)\n","        self.critic = CriticNetwork(self.args)\n","        self.optimizer = optim.Adam(list(self.actor.parameters()) + list(self.critic.parameters()), lr=self.args.learning_rate)\n","        self.reset()\n","\n","    def add(self, logprob, value, reward, terminal):\n","        self.logprobs[self.idx] = logprob\n","        self.values[self.idx] = value\n","        self.rewards[self.idx] = reward\n","        self.terminals[self.idx] = terminal\n","        self.idx += 1\n","\n","    def get_action_and_value(self, x):\n","        probs = self.actor(x)\n","        dist = torch.distributions.Categorical(probs)\n","        action = dist.sample()\n","        return action.item(), dist.log_prob(action), self.critic(x)\n","\n","    def get_qvalues(self, final_state):\n","        with torch.no_grad():\n","            final_state_value = self.critic(final_state)\n","        q_values = torch.zeros_like(self.rewards).to(self.args.device)\n","        for timestep in reversed(range(self.args.batch_size)):\n","            next_value = final_state_value if timestep == (self.args.batch_size - 1) else q_values[timestep + 1]\n","            q_values[timestep] = self.rewards[timestep] + self.args.discount * (1 - self.terminals[timestep]) * next_value\n","        return q_values\n","    \n","    def update(self, q_values):\n","        policy_loss = -(self.logprobs * q_values).mean()\n","        value_loss = (self.values - q_values).pow(2).mean()\n","        loss = (policy_loss + 0.5*value_loss)\n","        self.optimizer.zero_grad()  \n","        loss.backward()\n","        self.optimizer.step()\n","        self.reset()\n","        \n","    def evaluate(self, samples):\n","        with torch.no_grad():\n","            env_test = gym.make(self.args.gym_id)\n","            eval_reward = 0\n","            for i in range(samples):\n","                state = env_test.reset()\n","                episode_reward = 0\n","                while True:\n","                    action, _, _ = self.get_action_and_value(torch.tensor(state).unsqueeze(0))\n","                    next_state, reward, terminal, _ = env_test.step(action)\n","                    episode_reward += reward\n","                    state = next_state\n","                    if terminal:\n","                        eval_reward += episode_reward/samples\n","                        break\n","        return eval_reward"]},{"cell_type":"markdown","id":"90597872","metadata":{"id":"90597872"},"source":["Finally, a function to train the agent:"]},{"cell_type":"code","execution_count":5,"id":"cc0d5af3","metadata":{"id":"cc0d5af3","executionInfo":{"status":"ok","timestamp":1674563098791,"user_tz":-60,"elapsed":359,"user":{"displayName":"Michał Janik","userId":"10483929333441523386"}}},"outputs":[],"source":["def train(args, agent):\n","    rewards = np.zeros((args.timesteps//args.eval_steps, args.repeats))\n","    for seed in range(args.repeats):\n","        env = gym.make(args.gym_id)\n","        agent.init_networks()\n","        state = env.reset()\n","        start_time = time.time()\n","        for step in range(args.timesteps):\n","            action, logprob, value = agent.get_action_and_value(torch.tensor(state).unsqueeze(0))\n","            next_state, reward, terminal, _ = env.step(action)\n","            agent.add(logprob, value, reward, terminal)\n","            state = next_state\n","            if agent.idx == args.batch_size:\n","                q_values = agent.get_qvalues(torch.tensor(state).unsqueeze(0))\n","                agent.update(q_values)\n","            if (step+1) % args.eval_steps == 0:\n","                eval_rewards = agent.evaluate(5)\n","                rewards[step//args.eval_steps, seed] = eval_rewards\n","                if (step+1) % (10 * args.eval_steps) == 0:\n","                    print(f\"step={step+1}, eval_return={np.round(eval_rewards, 1)}, samples_per_sec={int(step / (time.time() - start_time))}\")\n","            if terminal:\n","                state = env.reset()\n","                episode_reward = 0\n","    return rewards"]},{"cell_type":"code","execution_count":6,"id":"7e625e47","metadata":{"id":"7e625e47","outputId":"c8909aee-5c24-4f42-f367-4665e3043587","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1674563237931,"user_tz":-60,"elapsed":117595,"user":{"displayName":"Michał Janik","userId":"10483929333441523386"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["step=5000, eval_return=54.8, samples_per_sec=912\n","step=10000, eval_return=126.2, samples_per_sec=840\n","step=5000, eval_return=62.6, samples_per_sec=946\n","step=10000, eval_return=179.6, samples_per_sec=852\n","step=5000, eval_return=58.2, samples_per_sec=963\n","step=10000, eval_return=112.8, samples_per_sec=890\n","step=5000, eval_return=56.8, samples_per_sec=977\n","step=10000, eval_return=134.4, samples_per_sec=901\n","step=5000, eval_return=30.6, samples_per_sec=993\n","step=10000, eval_return=158.0, samples_per_sec=860\n","step=5000, eval_return=80.2, samples_per_sec=938\n","step=10000, eval_return=127.0, samples_per_sec=831\n","step=5000, eval_return=61.4, samples_per_sec=1006\n","step=10000, eval_return=127.6, samples_per_sec=864\n","step=5000, eval_return=82.2, samples_per_sec=952\n","step=10000, eval_return=134.8, samples_per_sec=874\n","step=5000, eval_return=93.6, samples_per_sec=971\n","step=10000, eval_return=194.8, samples_per_sec=851\n","step=5000, eval_return=63.0, samples_per_sec=880\n","step=10000, eval_return=156.2, samples_per_sec=775\n"]}],"source":["agent = PolicyGradient(args).to(args.device)\n","rewards = train(args, agent)"]},{"cell_type":"code","execution_count":39,"id":"17abad69","metadata":{"id":"17abad69","colab":{"base_uri":"https://localhost:8080/","height":295},"executionInfo":{"status":"ok","timestamp":1674564628560,"user_tz":-60,"elapsed":4,"user":{"displayName":"Michał Janik","userId":"10483929333441523386"}},"outputId":"04437df7-e5f4-4b42-ba4e-10f86e47c089"},"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 432x288 with 1 Axes>"],"image/png":"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\n"},"metadata":{"needs_background":"light"}}],"source":["# GRAPH RESULTS HERE (MEAN + STD)\n","from matplotlib import pyplot as plt\n","\n","def plot_rewards(rewards, name, color='b'):\n","  x = range(len(rewards))\n","  y = rewards.mean(axis=1)\n","  std = rewards.std(axis=1)\n","  plt.plot(x, y, f'{color}-', label=name)\n","  plt.fill_between(x, y-std, y+std, color=color, alpha=0.2)\n","  plt.title(f'Mean reward +- std for {name}')\n","  plt.xlabel('Eval step')\n","  plt.ylabel('Reward')\n","\n","plot_rewards(rewards, 'Vanilla PolicyGradient')"]},{"cell_type":"markdown","id":"c0f33e74","metadata":{"id":"c0f33e74"},"source":["PG estimate has big variance - the estimate will vary a lot depending on the states and actions sampled. This variance is known to impact the sample efficiency and final performance of the agent. Although there are many strategies fo PG variance reduction, there is one trick that became indispensable in modern implementations of PG - baseline trick. But before we get to this, lets have one more look at the standard PG estimate:\n","\n","$$\n","\\nabla_{\\theta} J = \\underset{s \\sim p^{\\pi}_{*}}{\\mathbb{E}} ~ \\underset{a \\sim \\pi}{\\mathbb{E}} ~ Q^{\\pi} (s, a) ~ \\nabla_{\\theta} \\log \\pi_{\\theta} (a | s)\n","$$\n","\n","As mentioned in the lecture, PG nature is quite simple - increase the probability of good actions and decrease the probability of bad ones. 'Good' and 'bad' refer to Q-values associated with given actions. But what if all Q-values are positive? The gradient update will try to increase the probabilities of all sampled actions, with the increase being proportional to the Q-value (as stems from the equation above). As such, given positive Q-values, the probabilities of bad actions are also increased - just by a smaller amount that probabilities of actions with bigger Q-values. \n","\n","Baseline variance reduction tackles exactly that. The idea is to subtract a \"baseline\" from the Q-values, which does not affect the optimal policy, but reduces the variance of the gradients. It is proven that as long as the baseline does not depend on the action, its value will not bias the PG (however, inadequate baseline can actually increase the variance :)). So, what is a good baseline?\n","\n","The simplest version subtracts batch average of Q-values from each Q-value:\n","\n","$$\n","\\nabla_{\\theta} J = \\sum_{i=1}^{B} \\frac{1}{B} \\bigl( Q^{\\pi} (s_i, a_i) - \\frac{\\sum Q^{\\pi} (s_i, a_i)}{B} \\bigr) \\nabla_{\\theta} \\log \\pi_{\\theta} (a_i | s_i)\n","$$\n","\n","Where B is the batch size and $\\frac{\\sum Q^{\\pi} (s_i, a_i)}{B}$ is the average Q-value in the batch."]},{"cell_type":"code","execution_count":27,"id":"4a145a52","metadata":{"id":"4a145a52","executionInfo":{"status":"ok","timestamp":1674564259292,"user_tz":-60,"elapsed":432,"user":{"displayName":"Michał Janik","userId":"10483929333441523386"}}},"outputs":[],"source":["class BaselinedPolicyGradient(PolicyGradient):\n","    \n","    def __init__(self, args):\n","        super(BaselinedPolicyGradient, self).__init__(args)\n","        \n","    def update(self, q_values):\n","        q_batch_mean = q_values.mean().detach()\n","        policy_loss = -(self.logprobs * (q_values - q_batch_mean)).mean()\n","        value_loss = (self.values - q_values).pow(2).mean()\n","        loss = (policy_loss + 0.5*value_loss)\n","        self.optimizer.zero_grad()  \n","        loss.backward()\n","        self.optimizer.step()\n","        self.reset()"]},{"cell_type":"code","execution_count":28,"id":"0bf6d9f9","metadata":{"id":"0bf6d9f9","outputId":"9e407f71-e7b2-4b86-e2fa-6d882e02e7bc","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1674564393344,"user_tz":-60,"elapsed":133675,"user":{"displayName":"Michał Janik","userId":"10483929333441523386"}}},"outputs":[{"output_type":"stream","name":"stderr","text":["/usr/local/lib/python3.8/dist-packages/gym/envs/registration.py:593: UserWarning: \u001b[33mWARN: The environment CartPole-v0 is out of date. You should consider upgrading to version `v1`.\u001b[0m\n","  logger.warn(\n","/usr/local/lib/python3.8/dist-packages/gym/core.py:317: DeprecationWarning: \u001b[33mWARN: Initializing wrapper in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\u001b[0m\n","  deprecation(\n","/usr/local/lib/python3.8/dist-packages/gym/wrappers/step_api_compatibility.py:39: DeprecationWarning: \u001b[33mWARN: Initializing environment in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\u001b[0m\n","  deprecation(\n"]},{"output_type":"stream","name":"stdout","text":["step=5000, eval_return=58.4, samples_per_sec=845\n","step=10000, eval_return=88.4, samples_per_sec=756\n","step=5000, eval_return=114.0, samples_per_sec=872\n","step=10000, eval_return=109.2, samples_per_sec=775\n","step=5000, eval_return=60.2, samples_per_sec=863\n","step=10000, eval_return=119.2, samples_per_sec=766\n","step=5000, eval_return=54.2, samples_per_sec=891\n","step=10000, eval_return=184.8, samples_per_sec=715\n","step=5000, eval_return=65.8, samples_per_sec=912\n","step=10000, eval_return=160.4, samples_per_sec=813\n","step=5000, eval_return=61.4, samples_per_sec=911\n","step=10000, eval_return=116.2, samples_per_sec=781\n","step=5000, eval_return=63.0, samples_per_sec=850\n","step=10000, eval_return=185.0, samples_per_sec=704\n","step=5000, eval_return=76.4, samples_per_sec=888\n","step=10000, eval_return=200.0, samples_per_sec=742\n","step=5000, eval_return=64.6, samples_per_sec=835\n","step=10000, eval_return=187.0, samples_per_sec=742\n","step=5000, eval_return=101.0, samples_per_sec=872\n","step=10000, eval_return=153.2, samples_per_sec=696\n"]}],"source":["agent = BaselinedPolicyGradient(args).to(args.device)\n","rewards2 = train(args, agent)"]},{"cell_type":"code","execution_count":26,"id":"f9811dd8","metadata":{"id":"f9811dd8","colab":{"base_uri":"https://localhost:8080/","height":295},"executionInfo":{"status":"ok","timestamp":1674564115442,"user_tz":-60,"elapsed":20,"user":{"displayName":"Michał Janik","userId":"10483929333441523386"}},"outputId":"00a88ee9-a58d-4e50-ce26-49d67c815670"},"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 432x288 with 1 Axes>"],"image/png":"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\n"},"metadata":{"needs_background":"light"}}],"source":["# GRAPH RESULTS HERE (MEAN + STD)\n","plot_rewards(rewards2, 'BaselinedPolicyGradient')"]},{"cell_type":"markdown","id":"729f5f80","metadata":{"id":"729f5f80"},"source":["The most popular approach is to use state value as the baseline. Then, the gradient is well centered - probability of actions with Q-values smaller than state value will be decreased and probability of actions with Q-values bigger than state value will be increased. Obviously, we do not know the values associated with each state. To this end, we leverage a **CriticNetwork**. This network outputs value of a state and is trained using MSE using Q-values as targets. Traditionally, PG algorithm that uses value network for baseline variance reduction is called Actor-Critic. Actor Critic update is calculated with:\n","\n","$$\n","\\nabla_{\\theta} J = \\sum_{i=1}^{B} \\frac{1}{B} \\bigl( Q^{\\pi} (s_i, a_i) - V_{\\phi}(s) \\bigr) \\nabla_{\\theta} \\log \\pi_{\\theta} (a_i | s_i)\n","$$\n","\n","Where $\\bigl( Q^{\\pi} (s_i, a_i) - V_{\\phi}(s) \\bigr)$ is referred to as **advantage**."]},{"cell_type":"code","execution_count":43,"id":"261d7dfc","metadata":{"id":"261d7dfc","executionInfo":{"status":"ok","timestamp":1674564717336,"user_tz":-60,"elapsed":591,"user":{"displayName":"Michał Janik","userId":"10483929333441523386"}}},"outputs":[],"source":["class ActorCritic(PolicyGradient):\n","    \n","    def __init__(self, args):\n","        super(ActorCritic, self).__init__(args)\n","        \n","    def update(self, q_values):\n","        policy_loss = -(self.logprobs * (q_values - self.values).detach()).mean()\n","        value_loss = (self.values - q_values).pow(2).mean()\n","        loss = (policy_loss + 0.5*value_loss)\n","        self.optimizer.zero_grad()  \n","        loss.backward()\n","        self.optimizer.step()\n","        self.reset()"]},{"cell_type":"code","execution_count":46,"id":"4df0c7c4","metadata":{"id":"4df0c7c4","outputId":"0e03ac8d-9b41-4351-af51-cda28480432e","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1674565095771,"user_tz":-60,"elapsed":140070,"user":{"displayName":"Michał Janik","userId":"10483929333441523386"}}},"outputs":[{"output_type":"stream","name":"stderr","text":["/usr/local/lib/python3.8/dist-packages/gym/envs/registration.py:593: UserWarning: \u001b[33mWARN: The environment CartPole-v0 is out of date. You should consider upgrading to version `v1`.\u001b[0m\n","  logger.warn(\n","/usr/local/lib/python3.8/dist-packages/gym/core.py:317: DeprecationWarning: \u001b[33mWARN: Initializing wrapper in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\u001b[0m\n","  deprecation(\n","/usr/local/lib/python3.8/dist-packages/gym/wrappers/step_api_compatibility.py:39: DeprecationWarning: \u001b[33mWARN: Initializing environment in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\u001b[0m\n","  deprecation(\n"]},{"output_type":"stream","name":"stdout","text":["step=5000, eval_return=68.6, samples_per_sec=849\n","step=10000, eval_return=189.6, samples_per_sec=718\n","step=5000, eval_return=100.0, samples_per_sec=832\n","step=10000, eval_return=200.0, samples_per_sec=692\n","step=5000, eval_return=151.8, samples_per_sec=793\n","step=10000, eval_return=200.0, samples_per_sec=691\n","step=5000, eval_return=60.2, samples_per_sec=881\n","step=10000, eval_return=200.0, samples_per_sec=727\n","step=5000, eval_return=101.2, samples_per_sec=855\n","step=10000, eval_return=169.0, samples_per_sec=705\n","step=5000, eval_return=171.0, samples_per_sec=849\n","step=10000, eval_return=175.4, samples_per_sec=719\n","step=5000, eval_return=103.8, samples_per_sec=860\n","step=10000, eval_return=156.2, samples_per_sec=708\n","step=5000, eval_return=179.0, samples_per_sec=774\n","step=10000, eval_return=182.2, samples_per_sec=709\n","step=5000, eval_return=57.2, samples_per_sec=890\n","step=10000, eval_return=197.6, samples_per_sec=786\n","step=5000, eval_return=179.8, samples_per_sec=820\n","step=10000, eval_return=157.2, samples_per_sec=704\n"]}],"source":["agent = ActorCritic(args).to(args.device)\n","rewards3 = train(args, agent)"]},{"cell_type":"code","execution_count":33,"id":"a75d648a","metadata":{"id":"a75d648a","colab":{"base_uri":"https://localhost:8080/","height":295},"executionInfo":{"status":"ok","timestamp":1674564578856,"user_tz":-60,"elapsed":585,"user":{"displayName":"Michał Janik","userId":"10483929333441523386"}},"outputId":"4cea649e-eaa9-46ae-cd03-ef942bd4e215"},"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 432x288 with 1 Axes>"],"image/png":"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\n"},"metadata":{"needs_background":"light"}}],"source":["# GRAPH RESULTS HERE (MEAN + STD)\n","plot_rewards(rewards3, 'ActorCritic')"]},{"cell_type":"code","execution_count":45,"id":"19ea6a74","metadata":{"id":"19ea6a74","colab":{"base_uri":"https://localhost:8080/","height":295},"executionInfo":{"status":"ok","timestamp":1674564886785,"user_tz":-60,"elapsed":512,"user":{"displayName":"Michał Janik","userId":"10483929333441523386"}},"outputId":"490ceca2-5473-4a76-efd8-3ad19e00c29d"},"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 432x288 with 1 Axes>"],"image/png":"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\n"},"metadata":{"needs_background":"light"}}],"source":["# GRAPH ALL RESULTS HERE (MEAN + STD)\n","plot_rewards(rewards, 'Vanilla PolicyGradient', color='b')\n","plot_rewards(rewards2, 'BaselinedPolicyGradient', color='r')\n","plot_rewards(rewards3, 'ActorCritic', color='g')\n","plt.legend()\n","plt.show()"]},{"cell_type":"code","source":[],"metadata":{"id":"n4teDhW_0ujh"},"id":"n4teDhW_0ujh","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"display_name":"Python 3 (ipykernel)","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.8.15"},"colab":{"provenance":[{"file_id":"https://github.com/mim-uw/dnn-2022-23/blob/master/released/DNN-Lab-12-PG-student-version.ipynb","timestamp":1674562299257}]}},"nbformat":4,"nbformat_minor":5}