policy-gradient-torch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"\"\" Trains an agent with (stochastic) Policy Gradients on Pong. Uses OpenAI Gym. \"\"\"\n",
    "from collections import namedtuple, deque\n",
    "\n",
    "import numpy as np\n",
    "import gym\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from torch.autograd import Variable\n",
    "import random\n",
    "import roboschool\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "H = 20\n",
    "class PolicyNetwork(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.lin1 = nn.Linear(4, H)\n",
    "        self.lin2 = nn.Linear(H, 2)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.lin1(x))\n",
    "        return F.softmax(self.lin2(x), dim=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def discount_rewards(r):\n",
    "    \"\"\" take 1D float array of rewards and compute discounted reward \"\"\"\n",
    "    discounted_r = np.zeros_like(r)\n",
    "    running_add = 0\n",
    "    for t in reversed(range(0, r.size)):\n",
    "        running_add = running_add * gamma + r[t]\n",
    "        discounted_r[t] = running_add\n",
    "        return discounted_r\n",
    "    \n",
    "def prep_state(s):\n",
    "    return Variable(torch.from_numpy(s).float().unsqueeze(0))\n",
    "\n",
    "def to_tensor(l):\n",
    "    return torch.from_numpy(np.asarray(l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[33mWARN: gym.spaces.Box autodetected dtype as <class 'numpy.float32'>. Please provide explicit dtype.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "env = gym.make(\"CartPole-v0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20.0\n",
      "19.87230682820147\n",
      "30.706320027031104\n",
      "44.862767672507815\n",
      "53.56848809964372\n",
      "59.1156799598485\n",
      "61.712751807070916\n",
      "68.40384503065718\n",
      "68.89491504141591\n",
      "81.85586260613924\n",
      "92.48324674210147\n",
      "107.43526064753243\n",
      "126.20602820238888\n",
      "138.03602394080397\n",
      "149.2794898431134\n",
      "150.7440581732776\n",
      "156.7331639288185\n",
      "160.17184953536886\n",
      "167.14573570079475\n",
      "167.56267901659248\n",
      "176.82796887946247\n",
      "177.69113333139023\n",
      "174.96807455026197\n",
      "176.97359757886252\n",
      "179.25421163208512\n",
      "187.7295318509598\n",
      "190.20355462639836\n",
      "186.804508731765\n",
      "190.2930363604267\n",
      "192.35051513867083\n",
      "190.99088995412345\n",
      "192.35766601696943\n",
      "188.50405027355995\n",
      "188.79077772784794\n",
      "191.79547764696844\n",
      "195.3703882622962\n",
      "196.0128168294378\n",
      "197.18623530285478\n",
      "195.44490223580758\n",
      "191.9558593717315\n",
      "195.09744301944312\n",
      "197.3065224990021\n",
      "194.29927863538353\n",
      "196.61320577944736\n",
      "194.64198207679317\n",
      "196.41647180198888\n",
      "197.23268370297617\n",
      "196.8515932040046\n",
      "197.5268311383301\n",
      "197.72429652591234\n"
     ]
    }
   ],
   "source": [
    "model = PolicyNetwork()\n",
    "optimizer = torch.optim.RMSprop(model.parameters())\n",
    "\n",
    "running_reward = None\n",
    "num_episodes = 5000\n",
    "gamma = 0.99 # discount factor for reward\n",
    "\n",
    "for episode_number in range(num_episodes):\n",
    "    rewards = []\n",
    "    actions = []\n",
    "    outputs = []\n",
    "    done = False\n",
    "    state = env.reset()\n",
    "    reward_sum = 0\n",
    "    \n",
    "    while not done:\n",
    "        if episode_number % 100 == 0:\n",
    "            env.render()\n",
    "        output = model(prep_state(state))\n",
    "        action = 1 if random.random() < output.data[0,1] else 0\n",
    "        state, reward, done, _ = env.step(action)\n",
    "        reward_sum += reward\n",
    "        rewards.append(reward)\n",
    "        actions.append(torch.LongTensor([[action]]))\n",
    "        outputs.append(output)\n",
    "        \n",
    "    running_reward = reward_sum if running_reward is None else running_reward * 0.99 + reward_sum * 0.01\n",
    "    if episode_number % 100 == 0:\n",
    "        print(running_reward)  \n",
    "    \n",
    "    discounted_rewards = Variable(torch.FloatTensor(discount_rewards(np.array(rewards))))\n",
    "    \n",
    "    actions = Variable(torch.cat(actions))\n",
    "    probs = torch.cat(outputs).gather(1, actions)\n",
    "    loss = torch.mean(discounted_rewards * torch.log(probs))\n",
    "    loss.backward()\n",
    "    if episode_number % 32 == 0:\n",
    "        optimizer.step()\n",
    "        optimizer.zero_grad()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class PolicyGradient:\n",
    "    def __init__(self, env, model):\n",
    "        self.model = model\n",
    "        self.env = env\n",
    "        self.gamma = 0.999\n",
    "        self.render = True\n",
    "        \n",
    "    def discount_rewards(self, r):\n",
    "        \"\"\" take 1D float array of rewards and compute discounted reward \"\"\"\n",
    "        discounted_r = np.zeros_like(r)\n",
    "        running_add = 0\n",
    "        for t in reversed(range(0, r.size)):\n",
    "            running_add = running_add * self.gamma + r[t]\n",
    "            discounted_r[t] = running_add\n",
    "            return discounted_r\n",
    "\n",
    "    def prep_state(self, s):\n",
    "        return Variable(torch.from_numpy(s).float().unsqueeze(0))\n",
    "    \n",
    "    def train(self, num_episodes=5000):\n",
    "        optimizer = torch.optim.RMSprop(self.model.parameters())\n",
    "        running_reward = None\n",
    "        gamma = 0.99 # discount factor for reward\n",
    "        reward_sums = []\n",
    "\n",
    "        for episode_number in range(num_episodes):\n",
    "            rewards = []\n",
    "            actions = []\n",
    "            outputs = []\n",
    "            done = False\n",
    "            state = self.env.reset()\n",
    "            reward_sum = 0\n",
    "\n",
    "            while not done:\n",
    "                if episode_number % 100 == 0 and self.render:\n",
    "                    self.env.render()\n",
    "                output = self.model(self.prep_state(state))\n",
    "                action = 1 if random.random() < output.data[0,1] else 0\n",
    "                state, reward, done, _ = self.env.step(action)\n",
    "                reward_sum += reward\n",
    "                rewards.append(reward)\n",
    "                actions.append(torch.LongTensor([[action]]))\n",
    "                outputs.append(output)\n",
    "\n",
    "            reward_sums.append(reward_sum)\n",
    "            running_reward = reward_sum if running_reward is None else running_reward * 0.99 + reward_sum * 0.01\n",
    "            if episode_number % 100 == 0:\n",
    "                print(running_reward)  \n",
    "\n",
    "            discounted_rewards = Variable(torch.FloatTensor(self.discount_rewards(np.array(rewards))))\n",
    "\n",
    "            actions = Variable(torch.cat(actions))\n",
    "            probs = torch.cat(outputs).gather(1, actions)\n",
    "            loss = torch.mean(discounted_rewards * torch.log(probs))\n",
    "            loss.backward()\n",
    "            if episode_number % 32 == 0:\n",
    "                optimizer.step()\n",
    "                optimizer.zero_grad()\n",
    "        return reward_sums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "model = PolicyNetwork()\n",
    "pg = PolicyGradient(env, model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60.0\n",
      "49.53791984098626\n",
      "55.10174386678715\n",
      "63.96510586087324\n",
      "74.52363876049746\n",
      "93.61514412529061\n",
      "125.70817333438852\n",
      "148.65743808543854\n",
      "159.95118884835205\n",
      "174.13174931082315\n",
      "180.47681416474327\n",
      "182.09704132553574\n",
      "181.0012914964994\n",
      "186.09552128670927\n",
      "191.72237379829284\n",
      "195.2466306820776\n",
      "194.21691553952394\n",
      "197.25770051023687\n",
      "195.71709274375218\n",
      "197.477918172532\n"
     ]
    }
   ],
   "source": [
    "rewards = pg.train(2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11d72dba8>]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11c8b1400>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Transition = namedtuple('Transition',\n",
    "                        ('state', 'action', 'reward', 'next_state'))\n",
    "Batch = namedtuple('Batch', ('states', 'actions', 'rewards', 'next_states'))\n",
    "\n",
    "class ReplayMemory:\n",
    "    def __init__(self, capacity):\n",
    "        self.capacity = capacity\n",
    "        self.memory = deque([], maxlen=capacity)\n",
    "    \n",
    "    def add(self, *args):\n",
    "        \"\"\"Saves a transition.\"\"\"\n",
    "        self.memory.append(Transition(*args))\n",
    "    \n",
    "    def sample_batch(self, batch_size):\n",
    "        transitions = random.sample(self.memory, batch_size)\n",
    "        batch = Batch(*zip(*transitions))\n",
    "        states = torch.cat(batch.states)\n",
    "        actions = torch.cat(batch.actions)\n",
    "        rewards = Variable(torch.cat(batch.rewards).unsqueeze(1))\n",
    "        next_states = torch.cat(batch.next_states)\n",
    "        return Batch(states, actions, rewards, next_states)\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.memory)\n",
    "\n",
    "class RandomProcess:\n",
    "    def __init__(self, shape, theta=0.15, sigma=0.2):\n",
    "        self.theta = theta\n",
    "        self.mu = 0\n",
    "        self.sigma = sigma\n",
    "        self.last = 0\n",
    "        self.shape = np.atleast_1d(shape)\n",
    "    \n",
    "    def sample(self):\n",
    "        self.last = self.last + self.theta * (self.mu - self.last) + self.sigma * np.random.randn(*self.shape)\n",
    "        return self.last\n",
    "    \n",
    "    def reset(self):\n",
    "        self.last = 0\n",
    "\n",
    "class DDPG:\n",
    "    def __init__(self, env, actor_model, critic_model):\n",
    "        self.env = env\n",
    "        self.actor = actor_model\n",
    "        self.actor_target = actor_model.clone()\n",
    "        self.critic = critic_model\n",
    "        self.critic_target = critic_model.clone()\n",
    "        self.capacity = 10000\n",
    "        self.memory = ReplayMemory(self.capacity)\n",
    "        self.batch_size = 500\n",
    "        self.gamma = 0.999\n",
    "        self.tau = 0.1\n",
    "        self.random_process = RandomProcess(env.action_space.shape[0])\n",
    "        \n",
    "        self.optim_critic = optim.RMSprop(self.critic.parameters())\n",
    "        self.optim_actor = optim.RMSprop(self.actor.parameters())\n",
    "        self.render = 100\n",
    "        \n",
    "    def update(self, target, source):\n",
    "        zipped = zip(target.parameters(), source.parameters())\n",
    "        for target_param, source_param in zipped:\n",
    "            updated_param = target_param.data * (1 - self.tau) + source_param.data * self.tau\n",
    "            target_param.data.copy_(updated_param)    \n",
    "        \n",
    "    def train_models(self):\n",
    "        if len(self.memory) < self.batch_size:\n",
    "            return None, None\n",
    "        mini_batch = self.memory.sample_batch(self.batch_size)\n",
    "        critic_loss = self.train_critic(mini_batch)\n",
    "        actor_loss = self.train_actor(mini_batch)\n",
    "        self.update(self.actor_target, self.actor)\n",
    "        self.update(self.critic_target, self.critic)\n",
    "        return critic_loss.data[0], actor_loss.data[0]\n",
    "\n",
    "    def mse(self, inputs, targets):\n",
    "        return torch.mean((inputs - targets)**2)\n",
    "        \n",
    "    def train_critic(self, batch):\n",
    "        # forward pass\n",
    "        pred_actions = self.actor_target(batch.next_states)\n",
    "        target_q = batch.rewards + self.critic_target([batch.next_states, pred_actions]) * self.gamma\n",
    "        pred_q = self.critic([batch.states, batch.actions])\n",
    "        target_q = target_q.detach()\n",
    "        #backward pass\n",
    "#         loss = F.smooth_l1_loss(pred_q, target_q)\n",
    "        loss = self.mse(pred_q, target_q)\n",
    "        self.optim_critic.zero_grad()\n",
    "        loss.backward(retain_graph=True)\n",
    "        for param in self.critic.parameters():\n",
    "            param.grad.data.clamp_(-1, 1)\n",
    "        self.optim_critic.step()\n",
    "        return loss\n",
    "\n",
    "    def train_actor(self, batch):        \n",
    "        # forward pass\n",
    "        pred_mu = self.actor(batch.states)\n",
    "        pred_q = self.critic([batch.states, pred_mu])\n",
    "        # backward pass\n",
    "        loss = (pred_q).mean()\n",
    "        self.optim_actor.zero_grad()\n",
    "        loss.backward()\n",
    "        for param in self.actor.parameters():\n",
    "            param.grad.data.clamp_(-1, 1)\n",
    "        self.optim_actor.step()\n",
    "        return loss\n",
    "        \n",
    "    def prep_state(self, s):\n",
    "        return Variable(torch.from_numpy(s).float().unsqueeze(0))\n",
    "        \n",
    "    def select_action(self, state, exploration=True):\n",
    "        action = self.actor(state)\n",
    "        if exploration:\n",
    "            noise = self.random_process.sample()\n",
    "            action = action + Variable(torch.from_numpy(noise).float())\n",
    "        return action\n",
    "    \n",
    "    def train(self, num_episodes):\n",
    "        running_reward = None\n",
    "        reward_sums = []\n",
    "        losses = []\n",
    "\n",
    "        for episode_number in range(num_episodes):\n",
    "            done = False\n",
    "            state = self.prep_state(self.env.reset())\n",
    "            reward_sum = 0\n",
    "            self.random_process.reset()\n",
    "\n",
    "            while not done:\n",
    "                if self.render is not None and episode_number % self.render == 0:\n",
    "                    self.env.render()\n",
    "                action = self.select_action(state)\n",
    "                next_state, reward, done, _ = self.env.step(action.data.numpy()[0])\n",
    "                next_state = self.prep_state(next_state)\n",
    "                reward = torch.FloatTensor([reward])\n",
    "                self.memory.add(state, action, reward, next_state)\n",
    "                state = next_state\n",
    "                reward_sum += reward[0]\n",
    "                losses.append(self.train_models())\n",
    "\n",
    "            reward_sums.append(reward_sum)\n",
    "            running_reward = reward_sum if running_reward is None else running_reward * 0.99 + reward_sum * 0.01\n",
    "            \n",
    "            if episode_number % 100 == 0:\n",
    "                print(running_reward)  \n",
    "            \n",
    "        return reward_sums, losses\n",
    "\n",
    "    def run(self, render=True):\n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        reward_sum = 0\n",
    "        while not done:\n",
    "            if render:\n",
    "                self.env.render()\n",
    "            action = self.select_action(self.prep_state(state), exploration=False)\n",
    "            state, reward, done, _ = self.env.step(action.data[0])\n",
    "            reward_sum += reward\n",
    "        return reward_sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Cloneable:\n",
    "    def clone(self):\n",
    "        assert self.args\n",
    "        model_clone = self.__class__(*self.args)\n",
    "        model_clone.load_state_dict(self.state_dict())\n",
    "        model_clone.train(False)\n",
    "        return model_clone\n",
    "\n",
    "class Actor(nn.Module, Cloneable):\n",
    "    def __init__(self, n_states, n_actions, n_hidden):\n",
    "        super().__init__()\n",
    "        self.args = (n_states, n_actions, n_hidden)\n",
    "        self.lin1 = nn.Linear(n_states, n_hidden)\n",
    "        self.lin2 = nn.Linear(n_hidden, n_hidden)\n",
    "        self.lin3 = nn.Linear(n_hidden, n_actions)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.lin1(x))\n",
    "        x = F.relu(self.lin2(x))\n",
    "        x = F.tanh(self.lin3(x))\n",
    "        return x\n",
    "\n",
    "class Critic(nn.Module, Cloneable):\n",
    "    def __init__(self, n_states, n_actions, n_hidden):\n",
    "        super().__init__()\n",
    "        self.args = (n_states, n_actions, n_hidden)\n",
    "        self.lin_states = nn.Linear(n_states, n_hidden)\n",
    "        self.lin1 = nn.Linear(n_hidden + n_actions, n_hidden)\n",
    "        self.lin2 = nn.Linear(n_hidden, 1)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        s, a = x\n",
    "        states_hidden = F.relu(self.lin_states(s))\n",
    "        x = F.relu(self.lin1(torch.cat([states_hidden, a], 1)))\n",
    "        x = self.lin2(x)\n",
    "        return x\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[33mWARN: gym.spaces.Box autodetected dtype as <class 'numpy.float32'>. Please provide explicit dtype.\u001b[0m\n",
      "\u001b[33mWARN: gym.spaces.Box autodetected dtype as <class 'numpy.float32'>. Please provide explicit dtype.\u001b[0m\n",
      "10.0\n"
     ]
    }
   ],
   "source": [
    "env = gym.make('RoboschoolInvertedPendulum-v1')\n",
    "n_states = env.observation_space.shape[0]\n",
    "n_actions = env.action_space.shape[0]\n",
    "actor = Actor(n_states, n_actions, 40)\n",
    "critic = Critic(n_states, n_actions, 40)\n",
    "try:\n",
    "    ddpg = DDPG(env, actor, critic)\n",
    "    rewards, losses = ddpg.train(100)\n",
    "finally:\n",
    "    env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11ad11b00>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x12399ee10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x124dce5c0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(rewards)\n",
    "plt.title('rewards')\n",
    "plt.show()\n",
    "\n",
    "losses = np.array(losses)\n",
    "plt.plot(losses[:,0],label='critic loss')\n",
    "plt.title('critic loss')\n",
    "plt.show()\n",
    "plt.plot(losses[:,1],label='actor loss')\n",
    "plt.title('actor losses')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = torch.mean(torch.arange(1,10)**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[33mWARN: gym.spaces.Box autodetected dtype as <class 'numpy.float32'>. Please provide explicit dtype.\u001b[0m\n",
      "\u001b[33mWARN: gym.spaces.Box autodetected dtype as <class 'numpy.float32'>. Please provide explicit dtype.\u001b[0m\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'actor_pendulum' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-77ba15837f79>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0menv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgym\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmake\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'RoboschoolInvertedPendulumSwingup-v1'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mddpg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDDPG\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mactor_pendulum\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcritic_pendulum\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'actor_pendulum' is not defined"
     ]
    }
   ],
   "source": [
    "env = gym.make('RoboschoolInvertedPendulumSwingup-v1')\n",
    "ddpg = DDPG(env, actor_pendulum, critic_pendulum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000.0"
      ]
     },
     "execution_count": 260,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ddpg.run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "actor_pendulum = actor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "critic_pendulum = critic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "r = RandomProcess(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x120635518>]"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1201931d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a,b,c = [],[],[]\n",
    "for _ in range(200):\n",
    "    s = r.sample()\n",
    "    a.append(s[0])\n",
    "    b.append(s[1])\n",
    "    c.append(s[2])\n",
    "plt.plot(a)\n",
    "plt.plot(b)\n",
    "plt.plot(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1])"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.atleast_1d((1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "roboschool",
   "language": "python",
   "name": "roboschool"
  },
  "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}