Atari Environment

├── .ipynb_checkpoints
    └── 2.double dqn-checkpoint.ipynb
├── 1.dqn.ipynb
├── 2.double dqn.ipynb
├── 3.dueling dqn.ipynb
├── 4.prioritized dqn.ipynb
├── 5.noisy dqn.ipynb
├── 6.categorical dqn.ipynb
├── 7.rainbow dqn.ipynb
├── 8.quantile regression dqn.ipynb
├── 9.hierarchical dqn.ipynb
├── README.md
└── common
    ├── __init__.py
    ├── layers.py
    ├── replay_buffer.py
    └── wrappers.py


/8.quantile regression dqn.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 13,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "import math, random\n",
 10 |     "\n",
 11 |     "import gym\n",
 12 |     "import numpy as np\n",
 13 |     "\n",
 14 |     "import torch\n",
 15 |     "import torch.nn as nn\n",
 16 |     "import torch.optim as optim\n",
 17 |     "import torch.autograd as autograd \n",
 18 |     "import torch.nn.functional as F\n",
 19 |     "\n",
 20 |     "from common.layers import NoisyLinear\n",
 21 |     "from common.replay_buffer import ReplayBuffer"
 22 |    ]
 23 |   },
 24 |   {
 25 |    "cell_type": "code",
 26 |    "execution_count": 57,
 27 |    "metadata": {},
 28 |    "outputs": [],
 29 |    "source": [
 30 |     "from IPython.display import clear_output\n",
 31 |     "import matplotlib.pyplot as plt\n",
 32 |     "%matplotlib inline"
 33 |    ]
 34 |   },
 35 |   {
 36 |    "cell_type": "markdown",
 37 |    "metadata": {},
 38 |    "source": [
 39 |     "<h3>Use Cuda</h3>"
 40 |    ]
 41 |   },
 42 |   {
 43 |    "cell_type": "code",
 44 |    "execution_count": 102,
 45 |    "metadata": {},
 46 |    "outputs": [],
 47 |    "source": [
 48 |     "USE_CUDA = torch.cuda.is_available()\n",
 49 |     "Variable = lambda *args, **kwargs: autograd.Variable(*args, **kwargs).cuda() if USE_CUDA else autograd.Variable(*args, **kwargs)"
 50 |    ]
 51 |   },
 52 |   {
 53 |    "cell_type": "markdown",
 54 |    "metadata": {},
 55 |    "source": [
 56 |     "<h2>Cart Pole Environment</h2>"
 57 |    ]
 58 |   },
 59 |   {
 60 |    "cell_type": "code",
 61 |    "execution_count": 103,
 62 |    "metadata": {},
 63 |    "outputs": [
 64 |     {
 65 |      "name": "stdout",
 66 |      "output_type": "stream",
 67 |      "text": [
 68 |       "\u001b[33mWARN: gym.spaces.Box autodetected dtype as <type 'numpy.float32'>. Please provide explicit dtype.\u001b[0m\n"
 69 |      ]
 70 |     }
 71 |    ],
 72 |    "source": [
 73 |     "env_id = \"CartPole-v0\"\n",
 74 |     "env = gym.make(env_id)"
 75 |    ]
 76 |   },
 77 |   {
 78 |    "cell_type": "markdown",
 79 |    "metadata": {},
 80 |    "source": [
 81 |     "<h2>Distributional Reinforcement Learning with Quantile Regression</h2>"
 82 |    ]
 83 |   },
 84 |   {
 85 |    "cell_type": "code",
 86 |    "execution_count": 104,
 87 |    "metadata": {},
 88 |    "outputs": [],
 89 |    "source": [
 90 |     "class QRDQN(nn.Module):\n",
 91 |     "    def __init__(self, num_inputs, num_actions, num_quants):\n",
 92 |     "        super(QRDQN, self).__init__()\n",
 93 |     "        \n",
 94 |     "        self.num_inputs  = num_inputs\n",
 95 |     "        self.num_actions = num_actions\n",
 96 |     "        self.num_quants  = num_quants\n",
 97 |     "        \n",
 98 |     "        self.features = nn.Sequential(\n",
 99 |     "            nn.Linear(num_inputs, 32),\n",
100 |     "            nn.ReLU(),\n",
101 |     "            nn.Linear(32, 64),\n",
102 |     "            nn.ReLU(),\n",
103 |     "            nn.Linear(64, 128),\n",
104 |     "            nn.ReLU(),\n",
105 |     "            nn.Linear(128, self.num_actions * self.num_quants)\n",
106 |     "        )\n",
107 |     "        \n",
108 |     "        #self.noisy_value1 = NoisyLinear(64, 128, use_cuda=USE_CUDA)\n",
109 |     "        #self.noisy_value2 = NoisyLinear(128, self.num_actions * self.num_quants, use_cuda=USE_CUDA)\n",
110 |     "        \n",
111 |     "    def forward(self, x):\n",
112 |     "        batch_size = x.size(0)\n",
113 |     "\n",
114 |     "        x = self.features(x)\n",
115 |     "        \n",
116 |     "        #x = self.noisy_value1(x)\n",
117 |     "        #x = F.relu(x)\n",
118 |     "        #x = self.noisy_value2(x)\n",
119 |     "        x = x.view(batch_size, self.num_actions, self.num_quants)\n",
120 |     "        \n",
121 |     "        return x\n",
122 |     "    \n",
123 |     "    def q_values(self, x):\n",
124 |     "        x = self.forward(x)\n",
125 |     "        return x.mean(2)\n",
126 |     "    \n",
127 |     "    def reset_noise(self):\n",
128 |     "        self.noisy_value1.reset_noise()\n",
129 |     "        self.noisy_value2.reset_noise() \n",
130 |     "        \n",
131 |     "    def act(self, state, epsilon):\n",
132 |     "        if random.random() > epsilon:\n",
133 |     "            state = Variable(torch.FloatTensor(np.array(state, dtype=np.float32)).unsqueeze(0), volatile=True)\n",
134 |     "            qvalues = self.forward(state).mean(2)\n",
135 |     "            action  = qvalues.max(1)[1]\n",
136 |     "            action  = action.data.cpu().numpy()[0]\n",
137 |     "        else:\n",
138 |     "            action = random.randrange(self.num_actions)\n",
139 |     "        return action"
140 |    ]
141 |   },
142 |   {
143 |    "cell_type": "code",
144 |    "execution_count": 105,
145 |    "metadata": {},
146 |    "outputs": [],
147 |    "source": [
148 |     "def projection_distribution(dist, next_state, reward, done):\n",
149 |     "    next_dist = target_model(next_state)\n",
150 |     "    next_action = next_dist.mean(2).max(1)[1]\n",
151 |     "    next_action = next_action.unsqueeze(1).unsqueeze(1).expand(batch_size, 1, num_quant)\n",
152 |     "    next_dist = next_dist.gather(1, next_action).squeeze(1).cpu().data\n",
153 |     "\n",
154 |     "    expected_quant = reward.unsqueeze(1) + 0.99 * next_dist * (1 - done.unsqueeze(1))\n",
155 |     "    expected_quant = Variable(expected_quant)\n",
156 |     "\n",
157 |     "    quant_idx = torch.sort(dist, 1, descending=False)[1]\n",
158 |     "\n",
159 |     "    tau_hat = torch.linspace(0.0, 1.0 - 1./num_quant, num_quant) + 0.5 / num_quant\n",
160 |     "    tau_hat = tau_hat.unsqueeze(0).repeat(batch_size, 1)\n",
161 |     "    quant_idx = quant_idx.cpu().data\n",
162 |     "    batch_idx = np.arange(batch_size)\n",
163 |     "    tau = tau_hat[:, quant_idx][batch_idx, batch_idx]\n",
164 |     "        \n",
165 |     "    return tau, expected_quant"
166 |    ]
167 |   },
168 |   {
169 |    "cell_type": "code",
170 |    "execution_count": 106,
171 |    "metadata": {},
172 |    "outputs": [],
173 |    "source": [
174 |     "num_quant = 51\n",
175 |     "Vmin = -10\n",
176 |     "Vmax = 10\n",
177 |     "\n",
178 |     "current_model = QRDQN(env.observation_space.shape[0], env.action_space.n, num_quant)\n",
179 |     "target_model  = QRDQN(env.observation_space.shape[0], env.action_space.n, num_quant)\n",
180 |     "\n",
181 |     "if USE_CUDA:\n",
182 |     "    current_model = current_model.cuda()\n",
183 |     "    target_model  = target_model.cuda()\n",
184 |     "    \n",
185 |     "optimizer = optim.Adam(current_model.parameters())\n",
186 |     "\n",
187 |     "replay_buffer = ReplayBuffer(10000)"
188 |    ]
189 |   },
190 |   {
191 |    "cell_type": "code",
192 |    "execution_count": 107,
193 |    "metadata": {},
194 |    "outputs": [],
195 |    "source": [
196 |     "def update_target(current_model, target_model):\n",
197 |     "    target_model.load_state_dict(current_model.state_dict())\n",
198 |     "    \n",
199 |     "update_target(current_model, target_model)"
200 |    ]
201 |   },
202 |   {
203 |    "cell_type": "markdown",
204 |    "metadata": {},
205 |    "source": [
206 |     "<h2>Computing Temporal Difference Loss</h2>"
207 |    ]
208 |   },
209 |   {
210 |    "cell_type": "code",
211 |    "execution_count": 119,
212 |    "metadata": {},
213 |    "outputs": [],
214 |    "source": [
215 |     "def compute_td_loss(batch_size):\n",
216 |     "    state, action, reward, next_state, done = replay_buffer.sample(batch_size) \n",
217 |     "\n",
218 |     "    state      = Variable(torch.FloatTensor(np.float32(state)))\n",
219 |     "    next_state = Variable(torch.FloatTensor(np.float32(next_state)), volatile=True)\n",
220 |     "    action     = Variable(torch.LongTensor(action))\n",
221 |     "    reward     = torch.FloatTensor(reward)\n",
222 |     "    done       = torch.FloatTensor(np.float32(done))\n",
223 |     "\n",
224 |     "    dist = current_model(state)\n",
225 |     "    action = action.unsqueeze(1).unsqueeze(1).expand(batch_size, 1, num_quant)\n",
226 |     "    dist = dist.gather(1, action).squeeze(1)\n",
227 |     "    \n",
228 |     "    tau, expected_quant = projection_distribution(dist, next_state, reward, done)\n",
229 |     "    k = 1\n",
230 |     "    \n",
231 |     "    huber_loss = 0.5 * u.abs().clamp(min=0.0, max=k).pow(2)\n",
232 |     "    huber_loss += k * (u.abs() -  u.abs().clamp(min=0.0, max=k))\n",
233 |     "    quantile_loss = (tau - (u < 0).float()).abs() * huber_loss\n",
234 |     "    loss = quantile_loss.sum() / num_quant\n",
235 |     "        \n",
236 |     "    optimizer.zero_grad()\n",
237 |     "    loss.backward()\n",
238 |     "    nn.utils.clip_grad_norm(current_model.parameters(), 0.5)\n",
239 |     "    optimizer.step()\n",
240 |     "    \n",
241 |     "    return loss"
242 |    ]
243 |   },
244 |   {
245 |    "cell_type": "code",
246 |    "execution_count": 109,
247 |    "metadata": {},
248 |    "outputs": [],
249 |    "source": [
250 |     "def plot(frame_idx, rewards, losses):\n",
251 |     "    clear_output(True)\n",
252 |     "    plt.figure(figsize=(20,5))\n",
253 |     "    plt.subplot(131)\n",
254 |     "    plt.title('frame %s. reward: %s' % (frame_idx, np.mean(rewards[-10:])))\n",
255 |     "    plt.plot(rewards)\n",
256 |     "    plt.subplot(132)\n",
257 |     "    plt.title('loss')\n",
258 |     "    plt.plot(losses)\n",
259 |     "    plt.show()"
260 |    ]
261 |   },
262 |   {
263 |    "cell_type": "markdown",
264 |    "metadata": {},
265 |    "source": [
266 |     "<h2>Training</h2>"
267 |    ]
268 |   },
269 |   {
270 |    "cell_type": "code",
271 |    "execution_count": 110,
272 |    "metadata": {},
273 |    "outputs": [],
274 |    "source": [
275 |     "epsilon_start = 1.0\n",
276 |     "epsilon_final = 0.01\n",
277 |     "epsilon_decay = 500\n",
278 |     "\n",
279 |     "epsilon_by_frame = lambda frame_idx: epsilon_final + (epsilon_start - epsilon_final) * math.exp(-1. * frame_idx / epsilon_decay)"
280 |    ]
281 |   },
282 |   {
283 |    "cell_type": "code",
284 |    "execution_count": 111,
285 |    "metadata": {},
286 |    "outputs": [],
287 |    "source": [
288 |     "num_frames = 10000\n",
289 |     "batch_size = 32\n",
290 |     "gamma      = 0.99\n",
291 |     "\n",
292 |     "losses = []\n",
293 |     "all_rewards = []\n",
294 |     "episode_reward = 0"
295 |    ]
296 |   },
297 |   {
298 |    "cell_type": "code",
299 |    "execution_count": 112,
300 |    "metadata": {},
301 |    "outputs": [
302 |     {
303 |      "data": {
304 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAv4AAAE/CAYAAAA+Occ1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSUVORK5CYII=\n",
305 |       "text/plain": [
306 |        "<matplotlib.figure.Figure at 0x7f42c32e2b10>"
307 |       ]
308 |      },
309 |      "metadata": {},
310 |      "output_type": "display_data"
311 |     }
312 |    ],
313 |    "source": [
314 |     "state = env.reset()\n",
315 |     "for frame_idx in range(1, num_frames + 1):\n",
316 |     "    action = current_model.act(state, epsilon_by_frame(frame_idx))\n",
317 |     "    \n",
318 |     "    next_state, reward, done, _ = env.step(action)\n",
319 |     "    replay_buffer.push(state, action, reward, next_state, done)\n",
320 |     "    \n",
321 |     "    state = next_state\n",
322 |     "    episode_reward += reward\n",
323 |     "    \n",
324 |     "    if done:\n",
325 |     "        state = env.reset()\n",
326 |     "        all_rewards.append(episode_reward)\n",
327 |     "        episode_reward = 0\n",
328 |     "        \n",
329 |     "    if len(replay_buffer) > batch_size:\n",
330 |     "        loss = compute_td_loss(batch_size)\n",
331 |     "        losses.append(loss.data[0])\n",
332 |     "        \n",
333 |     "    if frame_idx % 200 == 0:\n",
334 |     "        plot(frame_idx, all_rewards, losses)\n",
335 |     "        \n",
336 |     "    if frame_idx % 1000 == 0:\n",
337 |     "        update_target(current_model, target_model)"
338 |    ]
339 |   },
340 |   {
341 |    "cell_type": "markdown",
342 |    "metadata": {},
343 |    "source": [
344 |     "<p><hr></p>"
345 |    ]
346 |   },
347 |   {
348 |    "cell_type": "markdown",
349 |    "metadata": {},
350 |    "source": [
351 |     "<h1>Atari Environment</h1>"
352 |    ]
353 |   },
354 |   {
355 |    "cell_type": "code",
356 |    "execution_count": 120,
357 |    "metadata": {},
358 |    "outputs": [],
359 |    "source": [
360 |     "from common.wrappers import make_atari, wrap_deepmind, wrap_pytorch"
361 |    ]
362 |   },
363 |   {
364 |    "cell_type": "code",
365 |    "execution_count": 121,
366 |    "metadata": {},
367 |    "outputs": [],
368 |    "source": [
369 |     "env_id = \"PongNoFrameskip-v4\"\n",
370 |     "env    = make_atari(env_id)\n",
371 |     "env    = wrap_deepmind(env)\n",
372 |     "env    = wrap_pytorch(env)"
373 |    ]
374 |   },
375 |   {
376 |    "cell_type": "code",
377 |    "execution_count": 122,
378 |    "metadata": {},
379 |    "outputs": [],
380 |    "source": [
381 |     "class QRCnnDQN(nn.Module):\n",
382 |     "    def __init__(self, input_shape, num_actions, num_quants):\n",
383 |     "        super(QRCnnDQN, self).__init__()\n",
384 |     "        \n",
385 |     "        self.input_shape = input_shape\n",
386 |     "        self.num_actions = num_actions\n",
387 |     "        self.num_quants  = num_quants\n",
388 |     "        \n",
389 |     "        self.features = nn.Sequential(\n",
390 |     "            nn.Conv2d(input_shape[0], 32, kernel_size=8, stride=4),\n",
391 |     "            nn.ReLU(),\n",
392 |     "            nn.Conv2d(32, 64, kernel_size=4, stride=2),\n",
393 |     "            nn.ReLU(),\n",
394 |     "            nn.Conv2d(64, 64, kernel_size=3, stride=1),\n",
395 |     "            nn.ReLU()\n",
396 |     "        )\n",
397 |     "        \n",
398 |     "        self.value = nn.Sequential(\n",
399 |     "            nn.Linear(self.feature_size(), 512),\n",
400 |     "            nn.ReLU(),\n",
401 |     "            nn.Linear(512, self.num_actions * self.num_quants)\n",
402 |     "        )\n",
403 |     "        \n",
404 |     "    def forward(self, x):\n",
405 |     "        batch_size = x.size(0)\n",
406 |     "        \n",
407 |     "        x = self.features(x)\n",
408 |     "        x = x.view(batch_size, -1)\n",
409 |     "        \n",
410 |     "        x = self.value(x)\n",
411 |     "        x = x.view(batch_size, self.num_actions, self.num_quants)\n",
412 |     "        \n",
413 |     "        return x\n",
414 |     "    \n",
415 |     "    def q_values(self, x):\n",
416 |     "        x = self.forward(x)\n",
417 |     "        return x.mean(2)\n",
418 |     "        \n",
419 |     "    def feature_size(self):\n",
420 |     "        return self.features(autograd.Variable(torch.zeros(1, *self.input_shape))).view(1, -1).size(1)\n",
421 |     "        \n",
422 |     "    def act(self, state, epsilon):\n",
423 |     "        if random.random() > epsilon:\n",
424 |     "            state = Variable(torch.FloatTensor(np.array(state, dtype=np.float32)).unsqueeze(0), volatile=True)\n",
425 |     "            qvalues = self.forward(state).mean(2)\n",
426 |     "            action  = qvalues.max(1)[1]\n",
427 |     "            action  = action.data.cpu().numpy()[0]\n",
428 |     "        else:\n",
429 |     "            action = random.randrange(self.num_actions)\n",
430 |     "        return action"
431 |    ]
432 |   },
433 |   {
434 |    "cell_type": "code",
435 |    "execution_count": 123,
436 |    "metadata": {},
437 |    "outputs": [],
438 |    "source": [
439 |     "num_quant = 51\n",
440 |     "Vmin = -10\n",
441 |     "Vmax = 10\n",
442 |     "\n",
443 |     "current_model = QRCnnDQN(env.observation_space.shape, env.action_space.n, num_quant)\n",
444 |     "target_model  = QRCnnDQN(env.observation_space.shape, env.action_space.n, num_quant)\n",
445 |     "\n",
446 |     "if USE_CUDA:\n",
447 |     "    current_model = current_model.cuda()\n",
448 |     "    target_model  = target_model.cuda()\n",
449 |     "    \n",
450 |     "update_target(current_model, target_model)\n",
451 |     "    \n",
452 |     "optimizer = optim.Adam(current_model.parameters(), lr=5e-5)\n",
453 |     "\n",
454 |     "replay_initial = 10000\n",
455 |     "replay_buffer  = ReplayBuffer(100000)"
456 |    ]
457 |   },
458 |   {
459 |    "cell_type": "code",
460 |    "execution_count": 124,
461 |    "metadata": {},
462 |    "outputs": [],
463 |    "source": [
464 |     "epsilon_start = 1.0\n",
465 |     "epsilon_final = 0.01\n",
466 |     "epsilon_decay = 30000\n",
467 |     "\n",
468 |     "epsilon_by_frame = lambda frame_idx: epsilon_final + (epsilon_start - epsilon_final) * math.exp(-1. * frame_idx / epsilon_decay)"
469 |    ]
470 |   },
471 |   {
472 |    "cell_type": "code",
473 |    "execution_count": null,
474 |    "metadata": {},
475 |    "outputs": [],
476 |    "source": [
477 |     "num_frames = 1000000\n",
478 |     "batch_size = 32\n",
479 |     "gamma      = 0.99\n",
480 |     "\n",
481 |     "losses = []\n",
482 |     "all_rewards = []\n",
483 |     "episode_reward = 0\n",
484 |     "\n",
485 |     "state = env.reset()\n",
486 |     "for frame_idx in range(1, num_frames + 1):\n",
487 |     "    action = current_model.act(state, epsilon_by_frame(frame_idx))\n",
488 |     "    \n",
489 |     "    next_state, reward, done, _ = env.step(action)\n",
490 |     "    replay_buffer.push(state, action, reward, next_state, done)\n",
491 |     "    \n",
492 |     "    state = next_state\n",
493 |     "    episode_reward += reward\n",
494 |     "    \n",
495 |     "    if done:\n",
496 |     "        state = env.reset()\n",
497 |     "        all_rewards.append(episode_reward)\n",
498 |     "        episode_reward = 0\n",
499 |     "        \n",
500 |     "    if len(replay_buffer) > replay_initial:\n",
501 |     "        loss = compute_td_loss(batch_size)\n",
502 |     "        losses.append(loss.data[0])\n",
503 |     "        \n",
504 |     "    if frame_idx % 10000 == 0:\n",
505 |     "        plot(frame_idx, all_rewards, losses)\n",
506 |     "        \n",
507 |     "    if frame_idx % 1000 == 0:\n",
508 |     "        update_target(current_model, target_model)"
509 |    ]
510 |   }
511 |  ],
512 |  "metadata": {
513 |   "kernelspec": {
514 |    "display_name": "Python 2",
515 |    "language": "python",
516 |    "name": "python2"
517 |   },
518 |   "language_info": {
519 |    "codemirror_mode": {
520 |     "name": "ipython",
521 |     "version": 2
522 |    },
523 |    "file_extension": ".py",
524 |    "mimetype": "text/x-python",
525 |    "name": "python",
526 |    "nbconvert_exporter": "python",
527 |    "pygments_lexer": "ipython2",
528 |    "version": "2.7.13"
529 |   }
530 |  },
531 |  "nbformat": 4,
532 |  "nbformat_minor": 2
533 | }
534 | 


--------------------------------------------------------------------------------
/9.hierarchical dqn.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 2,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "import math\n",
 10 |     "import random\n",
 11 |     "from collections import namedtuple, deque\n",
 12 |     "\n",
 13 |     "import gym\n",
 14 |     "import numpy as np\n",
 15 |     "\n",
 16 |     "import torch\n",
 17 |     "import torch.nn as nn\n",
 18 |     "import torch.optim as optim\n",
 19 |     "import torch.nn.functional as F\n",
 20 |     "import torch.autograd as autograd"
 21 |    ]
 22 |   },
 23 |   {
 24 |    "cell_type": "code",
 25 |    "execution_count": 3,
 26 |    "metadata": {},
 27 |    "outputs": [],
 28 |    "source": [
 29 |     "from IPython.display import clear_output\n",
 30 |     "import matplotlib.pyplot as plt\n",
 31 |     "%matplotlib inline"
 32 |    ]
 33 |   },
 34 |   {
 35 |    "cell_type": "code",
 36 |    "execution_count": 4,
 37 |    "metadata": {},
 38 |    "outputs": [],
 39 |    "source": [
 40 |     "USE_CUDA = torch.cuda.is_available()\n",
 41 |     "Variable = lambda *args, **kwargs: autograd.Variable(*args, **kwargs).cuda() if USE_CUDA else autograd.Variable(*args, **kwargs)"
 42 |    ]
 43 |   },
 44 |   {
 45 |    "cell_type": "code",
 46 |    "execution_count": 5,
 47 |    "metadata": {},
 48 |    "outputs": [],
 49 |    "source": [
 50 |     "class StochasticMDP:\n",
 51 |     "    def __init__(self):\n",
 52 |     "        self.end           = False\n",
 53 |     "        self.current_state = 2\n",
 54 |     "        self.num_actions   = 2\n",
 55 |     "        self.num_states    = 6\n",
 56 |     "        self.p_right       = 0.5\n",
 57 |     "\n",
 58 |     "    def reset(self):\n",
 59 |     "        self.end = False\n",
 60 |     "        self.current_state = 2\n",
 61 |     "        state = np.zeros(self.num_states)\n",
 62 |     "        state[self.current_state - 1] = 1.\n",
 63 |     "        return state\n",
 64 |     "\n",
 65 |     "    def step(self, action):\n",
 66 |     "        if self.current_state != 1:\n",
 67 |     "            if action == 1:\n",
 68 |     "                if random.random() < self.p_right and self.current_state < self.num_states:\n",
 69 |     "                    self.current_state += 1\n",
 70 |     "                else:\n",
 71 |     "                    self.current_state -= 1\n",
 72 |     "                    \n",
 73 |     "            if action == 0:\n",
 74 |     "                self.current_state -= 1\n",
 75 |     "                \n",
 76 |     "            if self.current_state == self.num_states:\n",
 77 |     "                self.end = True\n",
 78 |     "        \n",
 79 |     "        state = np.zeros(self.num_states)\n",
 80 |     "        state[self.current_state - 1] = 1.\n",
 81 |     "        \n",
 82 |     "        if self.current_state == 1:\n",
 83 |     "            if self.end:\n",
 84 |     "                return state, 1.00, True, {}\n",
 85 |     "            else:\n",
 86 |     "                return state, 1.00/100.00, True, {}\n",
 87 |     "        else:\n",
 88 |     "            return state, 0.0, False, {}"
 89 |    ]
 90 |   },
 91 |   {
 92 |    "cell_type": "code",
 93 |    "execution_count": 6,
 94 |    "metadata": {},
 95 |    "outputs": [],
 96 |    "source": [
 97 |     "class ReplayBuffer(object):\n",
 98 |     "    def __init__(self, capacity):\n",
 99 |     "        self.capacity = capacity\n",
100 |     "        self.buffer   = deque(maxlen=capacity)\n",
101 |     "    \n",
102 |     "    def push(self, state, action, reward, next_state, done):\n",
103 |     "        state      = np.expand_dims(state, 0)\n",
104 |     "        next_state = np.expand_dims(next_state, 0)\n",
105 |     "        self.buffer.append((state, action, reward, next_state, done))\n",
106 |     "    \n",
107 |     "    def sample(self, batch_size):\n",
108 |     "        state, action, reward, next_state, done = zip(*random.sample(self.buffer, batch_size))\n",
109 |     "        return np.concatenate(state), action, reward, np.concatenate(next_state), done\n",
110 |     "    \n",
111 |     "    def __len__(self):\n",
112 |     "        return len(self.buffer)"
113 |    ]
114 |   },
115 |   {
116 |    "cell_type": "code",
117 |    "execution_count": 9,
118 |    "metadata": {},
119 |    "outputs": [],
120 |    "source": [
121 |     "class Net(nn.Module):\n",
122 |     "    def __init__(self, num_inputs, num_outputs):\n",
123 |     "        super(Net, self).__init__()\n",
124 |     "        \n",
125 |     "        self.layers = nn.Sequential(\n",
126 |     "            nn.Linear(num_inputs, 256),\n",
127 |     "            nn.ReLU(),\n",
128 |     "            nn.Linear(256, num_outputs)\n",
129 |     "        )\n",
130 |     "    \n",
131 |     "    def forward(self, x):\n",
132 |     "        return self.layers(x)\n",
133 |     "    \n",
134 |     "    def act(self, state, epsilon):\n",
135 |     "        if random.random() > epsilon:\n",
136 |     "            state  = torch.FloatTensor(state).unsqueeze(0)\n",
137 |     "            action = self.forward(Variable(state, volatile=True)).max(1)[1]\n",
138 |     "            return action.data[0]\n",
139 |     "        else:\n",
140 |     "            return random.randrange(num_actions)"
141 |    ]
142 |   },
143 |   {
144 |    "cell_type": "code",
145 |    "execution_count": 11,
146 |    "metadata": {},
147 |    "outputs": [],
148 |    "source": [
149 |     "env = StochasticMDP()"
150 |    ]
151 |   },
152 |   {
153 |    "cell_type": "code",
154 |    "execution_count": 18,
155 |    "metadata": {},
156 |    "outputs": [],
157 |    "source": [
158 |     "num_goals    = env.num_states\n",
159 |     "num_actions  = env.num_actions\n",
160 |     "\n",
161 |     "model        = Net(2*num_goals, num_actions)\n",
162 |     "target_model = Net(2*num_goals, num_actions)\n",
163 |     "\n",
164 |     "meta_model        = Net(num_goals, num_goals)\n",
165 |     "target_meta_model = Net(num_goals, num_goals)\n",
166 |     "\n",
167 |     "if USE_CUDA:\n",
168 |     "    model             = model.cuda()\n",
169 |     "    target_model      = target_model.cuda()\n",
170 |     "    meta_model        = meta_model.cuda()\n",
171 |     "    target_meta_model = target_meta_model.cuda()\n",
172 |     "\n",
173 |     "optimizer      = optim.Adam(model.parameters())\n",
174 |     "meta_optimizer = optim.Adam(meta_model.parameters())\n",
175 |     "\n",
176 |     "replay_buffer      = ReplayBuffer(10000)\n",
177 |     "meta_replay_buffer = ReplayBuffer(10000)"
178 |    ]
179 |   },
180 |   {
181 |    "cell_type": "code",
182 |    "execution_count": 19,
183 |    "metadata": {},
184 |    "outputs": [],
185 |    "source": [
186 |     "def to_onehot(x):\n",
187 |     "    oh = np.zeros(6)\n",
188 |     "    oh[x - 1] = 1.\n",
189 |     "    return oh"
190 |    ]
191 |   },
192 |   {
193 |    "cell_type": "code",
194 |    "execution_count": 20,
195 |    "metadata": {},
196 |    "outputs": [],
197 |    "source": [
198 |     "def update(model, optimizer, replay_buffer, batch_size):\n",
199 |     "    if batch_size > len(replay_buffer):\n",
200 |     "        return\n",
201 |     "    state, action, reward, next_state, done = replay_buffer.sample(batch_size)\n",
202 |     "    \n",
203 |     "    state      = Variable(torch.FloatTensor(state))\n",
204 |     "    next_state = Variable(torch.FloatTensor(next_state), volatile=True)\n",
205 |     "    action     = Variable(torch.LongTensor(action))\n",
206 |     "    reward     = Variable(torch.FloatTensor(reward))\n",
207 |     "    done       = Variable(torch.FloatTensor(done))\n",
208 |     "    \n",
209 |     "    q_value = model(state)\n",
210 |     "    q_value = q_value.gather(1, action.unsqueeze(1)).squeeze(1)\n",
211 |     "    \n",
212 |     "    next_q_value     = model(next_state).max(1)[0]\n",
213 |     "    expected_q_value = reward + 0.99 * next_q_value * (1 - done)\n",
214 |     "   \n",
215 |     "    loss = (q_value - Variable(expected_q_value.data)).pow(2).mean()\n",
216 |     "    \n",
217 |     "    optimizer.zero_grad()\n",
218 |     "    loss.backward()\n",
219 |     "    optimizer.step()"
220 |    ]
221 |   },
222 |   {
223 |    "cell_type": "code",
224 |    "execution_count": 21,
225 |    "metadata": {},
226 |    "outputs": [],
227 |    "source": [
228 |     "epsilon_start = 1.0\n",
229 |     "epsilon_final = 0.01\n",
230 |     "epsilon_decay = 500\n",
231 |     "\n",
232 |     "epsilon_by_frame = lambda frame_idx: epsilon_final + (epsilon_start - epsilon_final) * math.exp(-1. * frame_idx / epsilon_decay)"
233 |    ]
234 |   },
235 |   {
236 |    "cell_type": "code",
237 |    "execution_count": 22,
238 |    "metadata": {},
239 |    "outputs": [
240 |     {
241 |      "data": {
242 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAABIsAAAE/CAYAAADG7EOqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIiIiIiLV/wdFDcTqqW9bnwAAAABJRU5ErkJggg==\n",
243 |       "text/plain": [
244 |        "<matplotlib.figure.Figure at 0x7f72647ec110>"
245 |       ]
246 |      },
247 |      "metadata": {},
248 |      "output_type": "display_data"
249 |     }
250 |    ],
251 |    "source": [
252 |     "num_frames = 100000\n",
253 |     "frame_idx  = 1\n",
254 |     "\n",
255 |     "state = env.reset()\n",
256 |     "done = False\n",
257 |     "all_rewards = []\n",
258 |     "episode_reward = 0\n",
259 |     "\n",
260 |     "while frame_idx < num_frames:\n",
261 |     "    goal = meta_model.act(state, epsilon_by_frame(frame_idx))\n",
262 |     "    onehot_goal  = to_onehot(goal)\n",
263 |     "    \n",
264 |     "    meta_state = state\n",
265 |     "    extrinsic_reward = 0\n",
266 |     "    \n",
267 |     "    while not done and goal != np.argmax(state):\n",
268 |     "        goal_state  = np.concatenate([state, onehot_goal])\n",
269 |     "        action = model.act(goal_state, epsilon_by_frame(frame_idx))\n",
270 |     "        next_state, reward, done, _ = env.step(action)\n",
271 |     "\n",
272 |     "        episode_reward   += reward\n",
273 |     "        extrinsic_reward += reward\n",
274 |     "        intrinsic_reward = 1.0 if goal == np.argmax(next_state) else 0.0\n",
275 |     "\n",
276 |     "        replay_buffer.push(goal_state, action, intrinsic_reward, np.concatenate([next_state, onehot_goal]), done)\n",
277 |     "        state = next_state\n",
278 |     "        \n",
279 |     "        update(model, optimizer, replay_buffer, 32)\n",
280 |     "        update(meta_model, meta_optimizer, meta_replay_buffer, 32)\n",
281 |     "        frame_idx += 1\n",
282 |     "        \n",
283 |     "        if frame_idx % 1000 == 0:\n",
284 |     "            clear_output(True)\n",
285 |     "            n = 100 #mean reward of last 100 episodes\n",
286 |     "            plt.figure(figsize=(20,5))\n",
287 |     "            plt.title(frame_idx)\n",
288 |     "            plt.plot([np.mean(all_rewards[i:i + n]) for i in range(0, len(all_rewards), n)])\n",
289 |     "            plt.show()\n",
290 |     "\n",
291 |     "    meta_replay_buffer.push(meta_state, goal, extrinsic_reward, state, done)\n",
292 |     "        \n",
293 |     "    if done:\n",
294 |     "        state = env.reset()\n",
295 |     "        done  = False\n",
296 |     "        all_rewards.append(episode_reward)\n",
297 |     "        episode_reward = 0"
298 |    ]
299 |   },
300 |   {
301 |    "cell_type": "code",
302 |    "execution_count": null,
303 |    "metadata": {},
304 |    "outputs": [],
305 |    "source": []
306 |   }
307 |  ],
308 |  "metadata": {
309 |   "kernelspec": {
310 |    "display_name": "Python 2",
311 |    "language": "python",
312 |    "name": "python2"
313 |   },
314 |   "language_info": {
315 |    "codemirror_mode": {
316 |     "name": "ipython",
317 |     "version": 2
318 |    },
319 |    "file_extension": ".py",
320 |    "mimetype": "text/x-python",
321 |    "name": "python",
322 |    "nbconvert_exporter": "python",
323 |    "pygments_lexer": "ipython2",
324 |    "version": "2.7.13"
325 |   }
326 |  },
327 |  "nbformat": 4,
328 |  "nbformat_minor": 2
329 | }
330 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # DQN Adventure: from Zero to State of the Art
 2 | 
 3 | 
 4 | <img width="160px" height="22px" href="https://github.com/pytorch/pytorch" src="https://pp.userapi.com/c847120/v847120960/82b4/xGBK9pXAkw8.jpg">
 5 | 
 6 | This is easy-to-follow step-by-step Deep Q Learning tutorial with clean readable code.
 7 | 
 8 | The deep reinforcement learning community has made several independent improvements to the DQN algorithm. This tutorial presents latest extensions to the DQN algorithm in the following order: 
 9 | 
10 |   1. Playing Atari with Deep Reinforcement Learning [[arxiv]](https://www.cs.toronto.edu/~vmnih/docs/dqn.pdf) [[code]](https://github.com/higgsfield/RL-Adventure/blob/master/1.dqn.ipynb)
11 |   2. Deep Reinforcement Learning with Double Q-learning [[arxiv]](https://arxiv.org/abs/1509.06461) [[code]](https://github.com/higgsfield/RL-Adventure/blob/master/2.double%20dqn.ipynb)
12 |   3. Dueling Network Architectures for Deep Reinforcement Learning [[arxiv]](https://arxiv.org/abs/1511.06581) [[code]](https://github.com/higgsfield/RL-Adventure/blob/master/3.dueling%20dqn.ipynb)
13 |   4. Prioritized Experience Replay [[arxiv]](https://arxiv.org/abs/1511.05952) [[code]](https://github.com/higgsfield/RL-Adventure/blob/master/4.prioritized%20dqn.ipynb)
14 |   5. Noisy Networks for Exploration [[arxiv]](https://arxiv.org/abs/1706.10295) [[code]](https://github.com/higgsfield/RL-Adventure/blob/master/5.noisy%20dqn.ipynb)
15 |   6. A Distributional Perspective on Reinforcement Learning [[arxiv]](https://arxiv.org/pdf/1707.06887.pdf) [[code]](https://github.com/higgsfield/RL-Adventure/blob/master/6.categorical%20dqn.ipynb)
16 |   7. Rainbow: Combining Improvements in Deep Reinforcement Learning [[arxiv]](https://arxiv.org/abs/1710.02298) [[code]](https://github.com/higgsfield/RL-Adventure/blob/master/7.rainbow%20dqn.ipynb)
17 |   8. Distributional Reinforcement Learning with Quantile Regression [[arxiv]](https://arxiv.org/pdf/1710.10044.pdf) [[code]](https://github.com/higgsfield/RL-Adventure/blob/master/8.quantile%20regression%20dqn.ipynb)
18 |   9. Hierarchical Deep Reinforcement Learning: Integrating Temporal Abstraction and Intrinsic Motivation  [[arxiv]](https://arxiv.org/abs/1604.06057) [[code]](https://github.com/higgsfield/RL-Adventure/blob/master/9.hierarchical%20dqn.ipynb)
19 |   10. Neural Episodic Control [[arxiv]](https://arxiv.org/pdf/1703.01988.pdf) [[code]](#)
20 | 
21 | # Environments
22 | First, I recommend to use small test problems to run experiments quickly. Then, you can continue on environments with large observation space. 
23 | 
24 |   - **CartPole** - classic RL environment can be solved on a single cpu
25 |   - **Atari Pong** - the easiest atari environment, only takes ~ 1 million frames to converge, comparing with other atari games that take > 40 millions
26 |   - **Atari others** - change hyperparameters, target network update frequency=10K, replay buffer size=1M
27 | 
28 | # If you get stuck… 
29 | - Remember you are not stuck unless you have spent more than a week on a single algorithm. It is perfectly normal if you do not have all the required knowledge of mathematics and CS. For example, you will need knowledge of the fundamentals of measure theory and statistics, especially the [Wasserstein metric](https://en.wikipedia.org/wiki/Wasserstein_metric) and [quantile regression](https://en.wikipedia.org/wiki/Quantile_regression). Statistical inference: [importance sampling](https://en.wikipedia.org/wiki/Importance_sampling). Data structures: [Segment Tree](https://leetcode.com/tag/segment-tree/) and [K-dimensional Tree](https://en.wikipedia.org/wiki/K-d_tree).
30 | - Carefully go through the paper. Try to see what is the problem the authors are solving. Understand a high-level idea of the approach, then read the code (skipping the proofs), and after go over the mathematical details and proofs.
31 | 
32 | # Best RL courses
33 | - David Silver's course [link](http://www0.cs.ucl.ac.uk/staff/d.silver/web/Teaching.html)
34 | - Berkeley deep RL [link](http://rll.berkeley.edu/deeprlcourse/)
35 | - Practical RL [link](https://github.com/yandexdataschool/Practical_RL)
36 | 


--------------------------------------------------------------------------------
/common/__init__.py:
--------------------------------------------------------------------------------
1 | import layers
2 | import wrappers
3 | import replay_buffer


--------------------------------------------------------------------------------
/common/layers.py:
--------------------------------------------------------------------------------
 1 | import math
 2 | import torch
 3 | import torch.nn as nn
 4 | import torch.nn.functional as F
 5 | from torch.autograd import Variable
 6 | 
 7 | class NoisyLinear(nn.Module):
 8 |     def __init__(self, in_features, out_features, use_cuda, std_init=0.4):
 9 |         super(NoisyLinear, self).__init__()
10 |         
11 |         self.use_cuda     = use_cuda
12 |         self.in_features  = in_features
13 |         self.out_features = out_features
14 |         self.std_init     = std_init
15 |         
16 |         self.weight_mu    = nn.Parameter(torch.FloatTensor(out_features, in_features))
17 |         self.weight_sigma = nn.Parameter(torch.FloatTensor(out_features, in_features))
18 |         self.register_buffer('weight_epsilon', torch.FloatTensor(out_features, in_features))
19 |         
20 |         self.bias_mu    = nn.Parameter(torch.FloatTensor(out_features))
21 |         self.bias_sigma = nn.Parameter(torch.FloatTensor(out_features))
22 |         self.register_buffer('bias_epsilon', torch.FloatTensor(out_features))
23 |         
24 |         self.reset_parameters()
25 |         self.reset_noise()
26 |     
27 |     def forward(self, x):
28 |         if self.use_cuda:
29 |             weight_epsilon = self.weight_epsilon.cuda()
30 |             bias_epsilon   = self.bias_epsilon.cuda()
31 |         else:
32 |             weight_epsilon = self.weight_epsilon
33 |             bias_epsilon   = self.bias_epsilon
34 |             
35 |         if self.training: 
36 |             weight = self.weight_mu + self.weight_sigma.mul(Variable(weight_epsilon))
37 |             bias   = self.bias_mu   + self.bias_sigma.mul(Variable(bias_epsilon))
38 |         else:
39 |             weight = self.weight_mu
40 |             bias   = self.bias_mu
41 |         
42 |         return F.linear(x, weight, bias)
43 |     
44 |     def reset_parameters(self):
45 |         mu_range = 1 / math.sqrt(self.weight_mu.size(1))
46 |         
47 |         self.weight_mu.data.uniform_(-mu_range, mu_range)
48 |         self.weight_sigma.data.fill_(self.std_init / math.sqrt(self.weight_sigma.size(1)))
49 |         
50 |         self.bias_mu.data.uniform_(-mu_range, mu_range)
51 |         self.bias_sigma.data.fill_(self.std_init / math.sqrt(self.bias_sigma.size(0)))
52 |     
53 |     def reset_noise(self):
54 |         epsilon_in  = self._scale_noise(self.in_features)
55 |         epsilon_out = self._scale_noise(self.out_features)
56 |         
57 |         self.weight_epsilon.copy_(epsilon_out.ger(epsilon_in))
58 |         self.bias_epsilon.copy_(self._scale_noise(self.out_features))
59 |     
60 |     def _scale_noise(self, size):
61 |         x = torch.randn(size)
62 |         x = x.sign().mul(x.abs().sqrt())
63 |         return x


--------------------------------------------------------------------------------
/common/replay_buffer.py:
--------------------------------------------------------------------------------
  1 | #code from openai
  2 | #https://github.com/openai/baselines/blob/master/baselines/deepq/replay_buffer.py
  3 | 
  4 | import numpy as np
  5 | import random
  6 | 
  7 | import operator
  8 | 
  9 | 
 10 | class SegmentTree(object):
 11 |     def __init__(self, capacity, operation, neutral_element):
 12 |         """Build a Segment Tree data structure.
 13 |         https://en.wikipedia.org/wiki/Segment_tree
 14 |         Can be used as regular array, but with two
 15 |         important differences:
 16 |             a) setting item's value is slightly slower.
 17 |                It is O(lg capacity) instead of O(1).
 18 |             b) user has access to an efficient `reduce`
 19 |                operation which reduces `operation` over
 20 |                a contiguous subsequence of items in the
 21 |                array.
 22 |         Paramters
 23 |         ---------
 24 |         capacity: int
 25 |             Total size of the array - must be a power of two.
 26 |         operation: lambda obj, obj -> obj
 27 |             and operation for combining elements (eg. sum, max)
 28 |             must for a mathematical group together with the set of
 29 |             possible values for array elements.
 30 |         neutral_element: obj
 31 |             neutral element for the operation above. eg. float('-inf')
 32 |             for max and 0 for sum.
 33 |         """
 34 |         assert capacity > 0 and capacity & (capacity - 1) == 0, "capacity must be positive and a power of 2."
 35 |         self._capacity = capacity
 36 |         self._value = [neutral_element for _ in range(2 * capacity)]
 37 |         self._operation = operation
 38 | 
 39 |     def _reduce_helper(self, start, end, node, node_start, node_end):
 40 |         if start == node_start and end == node_end:
 41 |             return self._value[node]
 42 |         mid = (node_start + node_end) // 2
 43 |         if end <= mid:
 44 |             return self._reduce_helper(start, end, 2 * node, node_start, mid)
 45 |         else:
 46 |             if mid + 1 <= start:
 47 |                 return self._reduce_helper(start, end, 2 * node + 1, mid + 1, node_end)
 48 |             else:
 49 |                 return self._operation(
 50 |                     self._reduce_helper(start, mid, 2 * node, node_start, mid),
 51 |                     self._reduce_helper(mid + 1, end, 2 * node + 1, mid + 1, node_end)
 52 |                 )
 53 | 
 54 |     def reduce(self, start=0, end=None):
 55 |         """Returns result of applying `self.operation`
 56 |         to a contiguous subsequence of the array.
 57 |             self.operation(arr[start], operation(arr[start+1], operation(... arr[end])))
 58 |         Parameters
 59 |         ----------
 60 |         start: int
 61 |             beginning of the subsequence
 62 |         end: int
 63 |             end of the subsequences
 64 |         Returns
 65 |         -------
 66 |         reduced: obj
 67 |             result of reducing self.operation over the specified range of array elements.
 68 |         """
 69 |         if end is None:
 70 |             end = self._capacity
 71 |         if end < 0:
 72 |             end += self._capacity
 73 |         end -= 1
 74 |         return self._reduce_helper(start, end, 1, 0, self._capacity - 1)
 75 | 
 76 |     def __setitem__(self, idx, val):
 77 |         # index of the leaf
 78 |         idx += self._capacity
 79 |         self._value[idx] = val
 80 |         idx //= 2
 81 |         while idx >= 1:
 82 |             self._value[idx] = self._operation(
 83 |                 self._value[2 * idx],
 84 |                 self._value[2 * idx + 1]
 85 |             )
 86 |             idx //= 2
 87 | 
 88 |     def __getitem__(self, idx):
 89 |         assert 0 <= idx < self._capacity
 90 |         return self._value[self._capacity + idx]
 91 | 
 92 | 
 93 | class SumSegmentTree(SegmentTree):
 94 |     def __init__(self, capacity):
 95 |         super(SumSegmentTree, self).__init__(
 96 |             capacity=capacity,
 97 |             operation=operator.add,
 98 |             neutral_element=0.0
 99 |         )
100 | 
101 |     def sum(self, start=0, end=None):
102 |         """Returns arr[start] + ... + arr[end]"""
103 |         return super(SumSegmentTree, self).reduce(start, end)
104 | 
105 |     def find_prefixsum_idx(self, prefixsum):
106 |         """Find the highest index `i` in the array such that
107 |             sum(arr[0] + arr[1] + ... + arr[i - i]) <= prefixsum
108 |         if array values are probabilities, this function
109 |         allows to sample indexes according to the discrete
110 |         probability efficiently.
111 |         Parameters
112 |         ----------
113 |         perfixsum: float
114 |             upperbound on the sum of array prefix
115 |         Returns
116 |         -------
117 |         idx: int
118 |             highest index satisfying the prefixsum constraint
119 |         """
120 |         assert 0 <= prefixsum <= self.sum() + 1e-5
121 |         idx = 1
122 |         while idx < self._capacity:  # while non-leaf
123 |             if self._value[2 * idx] > prefixsum:
124 |                 idx = 2 * idx
125 |             else:
126 |                 prefixsum -= self._value[2 * idx]
127 |                 idx = 2 * idx + 1
128 |         return idx - self._capacity
129 | 
130 | 
131 | class MinSegmentTree(SegmentTree):
132 |     def __init__(self, capacity):
133 |         super(MinSegmentTree, self).__init__(
134 |             capacity=capacity,
135 |             operation=min,
136 |             neutral_element=float('inf')
137 |         )
138 | 
139 |     def min(self, start=0, end=None):
140 |         """Returns min(arr[start], ...,  arr[end])"""
141 | 
142 |         return super(MinSegmentTree, self).reduce(start, end)
143 | 
144 | 
145 | class ReplayBuffer(object):
146 |     def __init__(self, size):
147 |         """Create Replay buffer.
148 |         Parameters
149 |         ----------
150 |         size: int
151 |             Max number of transitions to store in the buffer. When the buffer
152 |             overflows the old memories are dropped.
153 |         """
154 |         self._storage = []
155 |         self._maxsize = size
156 |         self._next_idx = 0
157 | 
158 |     def __len__(self):
159 |         return len(self._storage)
160 | 
161 |     def push(self, state, action, reward, next_state, done):
162 |         data = (state, action, reward, next_state, done)
163 | 
164 |         if self._next_idx >= len(self._storage):
165 |             self._storage.append(data)
166 |         else:
167 |             self._storage[self._next_idx] = data
168 |         self._next_idx = (self._next_idx + 1) % self._maxsize
169 | 
170 |     def _encode_sample(self, idxes):
171 |         obses_t, actions, rewards, obses_tp1, dones = [], [], [], [], []
172 |         for i in idxes:
173 |             data = self._storage[i]
174 |             obs_t, action, reward, obs_tp1, done = data
175 |             obses_t.append(np.array(obs_t, copy=False))
176 |             actions.append(np.array(action, copy=False))
177 |             rewards.append(reward)
178 |             obses_tp1.append(np.array(obs_tp1, copy=False))
179 |             dones.append(done)
180 |         return np.array(obses_t), np.array(actions), np.array(rewards), np.array(obses_tp1), np.array(dones)
181 | 
182 |     def sample(self, batch_size):
183 |         """Sample a batch of experiences.
184 |         Parameters
185 |         ----------
186 |         batch_size: int
187 |             How many transitions to sample.
188 |         Returns
189 |         -------
190 |         obs_batch: np.array
191 |             batch of observations
192 |         act_batch: np.array
193 |             batch of actions executed given obs_batch
194 |         rew_batch: np.array
195 |             rewards received as results of executing act_batch
196 |         next_obs_batch: np.array
197 |             next set of observations seen after executing act_batch
198 |         done_mask: np.array
199 |             done_mask[i] = 1 if executing act_batch[i] resulted in
200 |             the end of an episode and 0 otherwise.
201 |         """
202 |         idxes = [random.randint(0, len(self._storage) - 1) for _ in range(batch_size)]
203 |         return self._encode_sample(idxes)
204 | 
205 | 
206 | class PrioritizedReplayBuffer(ReplayBuffer):
207 |     def __init__(self, size, alpha):
208 |         """Create Prioritized Replay buffer.
209 |         Parameters
210 |         ----------
211 |         size: int
212 |             Max number of transitions to store in the buffer. When the buffer
213 |             overflows the old memories are dropped.
214 |         alpha: float
215 |             how much prioritization is used
216 |             (0 - no prioritization, 1 - full prioritization)
217 |         See Also
218 |         --------
219 |         ReplayBuffer.__init__
220 |         """
221 |         super(PrioritizedReplayBuffer, self).__init__(size)
222 |         assert alpha > 0
223 |         self._alpha = alpha
224 | 
225 |         it_capacity = 1
226 |         while it_capacity < size:
227 |             it_capacity *= 2
228 | 
229 |         self._it_sum = SumSegmentTree(it_capacity)
230 |         self._it_min = MinSegmentTree(it_capacity)
231 |         self._max_priority = 1.0
232 | 
233 |     def push(self, *args, **kwargs):
234 |         """See ReplayBuffer.store_effect"""
235 |         idx = self._next_idx
236 |         super(PrioritizedReplayBuffer, self).push(*args, **kwargs)
237 |         self._it_sum[idx] = self._max_priority ** self._alpha
238 |         self._it_min[idx] = self._max_priority ** self._alpha
239 | 
240 |     def _sample_proportional(self, batch_size):
241 |         res = []
242 |         for _ in range(batch_size):
243 |             # TODO(szymon): should we ensure no repeats?
244 |             mass = random.random() * self._it_sum.sum(0, len(self._storage) - 1)
245 |             idx = self._it_sum.find_prefixsum_idx(mass)
246 |             res.append(idx)
247 |         return res
248 | 
249 |     def sample(self, batch_size, beta):
250 |         """Sample a batch of experiences.
251 |         compared to ReplayBuffer.sample
252 |         it also returns importance weights and idxes
253 |         of sampled experiences.
254 |         Parameters
255 |         ----------
256 |         batch_size: int
257 |             How many transitions to sample.
258 |         beta: float
259 |             To what degree to use importance weights
260 |             (0 - no corrections, 1 - full correction)
261 |         Returns
262 |         -------
263 |         obs_batch: np.array
264 |             batch of observations
265 |         act_batch: np.array
266 |             batch of actions executed given obs_batch
267 |         rew_batch: np.array
268 |             rewards received as results of executing act_batch
269 |         next_obs_batch: np.array
270 |             next set of observations seen after executing act_batch
271 |         done_mask: np.array
272 |             done_mask[i] = 1 if executing act_batch[i] resulted in
273 |             the end of an episode and 0 otherwise.
274 |         weights: np.array
275 |             Array of shape (batch_size,) and dtype np.float32
276 |             denoting importance weight of each sampled transition
277 |         idxes: np.array
278 |             Array of shape (batch_size,) and dtype np.int32
279 |             idexes in buffer of sampled experiences
280 |         """
281 |         assert beta > 0
282 | 
283 |         idxes = self._sample_proportional(batch_size)
284 | 
285 |         weights = []
286 |         p_min = self._it_min.min() / self._it_sum.sum()
287 |         max_weight = (p_min * len(self._storage)) ** (-beta)
288 | 
289 |         for idx in idxes:
290 |             p_sample = self._it_sum[idx] / self._it_sum.sum()
291 |             weight = (p_sample * len(self._storage)) ** (-beta)
292 |             weights.append(weight / max_weight)
293 |         weights = np.array(weights)
294 |         encoded_sample = self._encode_sample(idxes)
295 |         return tuple(list(encoded_sample) + [weights, idxes])
296 | 
297 |     def update_priorities(self, idxes, priorities):
298 |         """Update priorities of sampled transitions.
299 |         sets priority of transition at index idxes[i] in buffer
300 |         to priorities[i].
301 |         Parameters
302 |         ----------
303 |         idxes: [int]
304 |             List of idxes of sampled transitions
305 |         priorities: [float]
306 |             List of updated priorities corresponding to
307 |             transitions at the sampled idxes denoted by
308 |             variable `idxes`.
309 |         """
310 |         assert len(idxes) == len(priorities)
311 |         for idx, priority in zip(idxes, priorities):
312 |             assert priority > 0
313 |             assert 0 <= idx < len(self._storage)
314 |             self._it_sum[idx] = priority ** self._alpha
315 |             self._it_min[idx] = priority ** self._alpha
316 | 
317 |             self._max_priority = max(self._max_priority, priority)


--------------------------------------------------------------------------------
/common/wrappers.py:
--------------------------------------------------------------------------------
  1 | import numpy as np
  2 | from collections import deque
  3 | import gym
  4 | from gym import spaces
  5 | import cv2
  6 | cv2.ocl.setUseOpenCL(False)
  7 | 
  8 | class NoopResetEnv(gym.Wrapper):
  9 |     def __init__(self, env, noop_max=30):
 10 |         """Sample initial states by taking random number of no-ops on reset.
 11 |         No-op is assumed to be action 0.
 12 |         """
 13 |         gym.Wrapper.__init__(self, env)
 14 |         self.noop_max = noop_max
 15 |         self.override_num_noops = None
 16 |         self.noop_action = 0
 17 |         assert env.unwrapped.get_action_meanings()[0] == 'NOOP'
 18 | 
 19 |     def reset(self, **kwargs):
 20 |         """ Do no-op action for a number of steps in [1, noop_max]."""
 21 |         self.env.reset(**kwargs)
 22 |         if self.override_num_noops is not None:
 23 |             noops = self.override_num_noops
 24 |         else:
 25 |             noops = self.unwrapped.np_random.randint(1, self.noop_max + 1) #pylint: disable=E1101
 26 |         assert noops > 0
 27 |         obs = None
 28 |         for _ in range(noops):
 29 |             obs, _, done, _ = self.env.step(self.noop_action)
 30 |             if done:
 31 |                 obs = self.env.reset(**kwargs)
 32 |         return obs
 33 | 
 34 |     def step(self, ac):
 35 |         return self.env.step(ac)
 36 | 
 37 | class FireResetEnv(gym.Wrapper):
 38 |     def __init__(self, env):
 39 |         """Take action on reset for environments that are fixed until firing."""
 40 |         gym.Wrapper.__init__(self, env)
 41 |         assert env.unwrapped.get_action_meanings()[1] == 'FIRE'
 42 |         assert len(env.unwrapped.get_action_meanings()) >= 3
 43 | 
 44 |     def reset(self, **kwargs):
 45 |         self.env.reset(**kwargs)
 46 |         obs, _, done, _ = self.env.step(1)
 47 |         if done:
 48 |             self.env.reset(**kwargs)
 49 |         obs, _, done, _ = self.env.step(2)
 50 |         if done:
 51 |             self.env.reset(**kwargs)
 52 |         return obs
 53 | 
 54 |     def step(self, ac):
 55 |         return self.env.step(ac)
 56 | 
 57 | class EpisodicLifeEnv(gym.Wrapper):
 58 |     def __init__(self, env):
 59 |         """Make end-of-life == end-of-episode, but only reset on true game over.
 60 |         Done by DeepMind for the DQN and co. since it helps value estimation.
 61 |         """
 62 |         gym.Wrapper.__init__(self, env)
 63 |         self.lives = 0
 64 |         self.was_real_done  = True
 65 | 
 66 |     def step(self, action):
 67 |         obs, reward, done, info = self.env.step(action)
 68 |         self.was_real_done = done
 69 |         # check current lives, make loss of life terminal,
 70 |         # then update lives to handle bonus lives
 71 |         lives = self.env.unwrapped.ale.lives()
 72 |         if lives < self.lives and lives > 0:
 73 |             # for Qbert sometimes we stay in lives == 0 condtion for a few frames
 74 |             # so its important to keep lives > 0, so that we only reset once
 75 |             # the environment advertises done.
 76 |             done = True
 77 |         self.lives = lives
 78 |         return obs, reward, done, info
 79 | 
 80 |     def reset(self, **kwargs):
 81 |         """Reset only when lives are exhausted.
 82 |         This way all states are still reachable even though lives are episodic,
 83 |         and the learner need not know about any of this behind-the-scenes.
 84 |         """
 85 |         if self.was_real_done:
 86 |             obs = self.env.reset(**kwargs)
 87 |         else:
 88 |             # no-op step to advance from terminal/lost life state
 89 |             obs, _, _, _ = self.env.step(0)
 90 |         self.lives = self.env.unwrapped.ale.lives()
 91 |         return obs
 92 | 
 93 | class MaxAndSkipEnv(gym.Wrapper):
 94 |     def __init__(self, env, skip=4):
 95 |         """Return only every `skip`-th frame"""
 96 |         gym.Wrapper.__init__(self, env)
 97 |         # most recent raw observations (for max pooling across time steps)
 98 |         self._obs_buffer = np.zeros((2,)+env.observation_space.shape, dtype=np.uint8)
 99 |         self._skip       = skip
100 | 
101 |     def reset(self):
102 |         return self.env.reset()
103 | 
104 |     def step(self, action):
105 |         """Repeat action, sum reward, and max over last observations."""
106 |         total_reward = 0.0
107 |         done = None
108 |         for i in range(self._skip):
109 |             obs, reward, done, info = self.env.step(action)
110 |             if i == self._skip - 2: self._obs_buffer[0] = obs
111 |             if i == self._skip - 1: self._obs_buffer[1] = obs
112 |             total_reward += reward
113 |             if done:
114 |                 break
115 |         # Note that the observation on the done=True frame
116 |         # doesn't matter
117 |         max_frame = self._obs_buffer.max(axis=0)
118 | 
119 |         return max_frame, total_reward, done, info
120 | 
121 |     def reset(self, **kwargs):
122 |         return self.env.reset(**kwargs)
123 | 
124 | class ClipRewardEnv(gym.RewardWrapper):
125 |     def __init__(self, env):
126 |         gym.RewardWrapper.__init__(self, env)
127 | 
128 |     def reward(self, reward):
129 |         """Bin reward to {+1, 0, -1} by its sign."""
130 |         return np.sign(reward)
131 | 
132 | class WarpFrame(gym.ObservationWrapper):
133 |     def __init__(self, env):
134 |         """Warp frames to 84x84 as done in the Nature paper and later work."""
135 |         gym.ObservationWrapper.__init__(self, env)
136 |         self.width = 84
137 |         self.height = 84
138 |         self.observation_space = spaces.Box(low=0, high=255,
139 |             shape=(self.height, self.width, 1), dtype=np.uint8)
140 | 
141 |     def observation(self, frame):
142 |         frame = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
143 |         frame = cv2.resize(frame, (self.width, self.height), interpolation=cv2.INTER_AREA)
144 |         return frame[:, :, None]
145 | 
146 | class FrameStack(gym.Wrapper):
147 |     def __init__(self, env, k):
148 |         """Stack k last frames.
149 |         Returns lazy array, which is much more memory efficient.
150 |         See Also
151 |         --------
152 |         baselines.common.atari_wrappers.LazyFrames
153 |         """
154 |         gym.Wrapper.__init__(self, env)
155 |         self.k = k
156 |         self.frames = deque([], maxlen=k)
157 |         shp = env.observation_space.shape
158 |         self.observation_space = spaces.Box(low=0, high=255, shape=(shp[0], shp[1], shp[2] * k), dtype=np.uint8)
159 | 
160 |     def reset(self):
161 |         ob = self.env.reset()
162 |         for _ in range(self.k):
163 |             self.frames.append(ob)
164 |         return self._get_ob()
165 | 
166 |     def step(self, action):
167 |         ob, reward, done, info = self.env.step(action)
168 |         self.frames.append(ob)
169 |         return self._get_ob(), reward, done, info
170 | 
171 |     def _get_ob(self):
172 |         assert len(self.frames) == self.k
173 |         return LazyFrames(list(self.frames))
174 | 
175 | class ScaledFloatFrame(gym.ObservationWrapper):
176 |     def __init__(self, env):
177 |         gym.ObservationWrapper.__init__(self, env)
178 | 
179 |     def observation(self, observation):
180 |         # careful! This undoes the memory optimization, use
181 |         # with smaller replay buffers only.
182 |         return np.array(observation).astype(np.float32) / 255.0
183 | 
184 | class LazyFrames(object):
185 |     def __init__(self, frames):
186 |         """This object ensures that common frames between the observations are only stored once.
187 |         It exists purely to optimize memory usage which can be huge for DQN's 1M frames replay
188 |         buffers.
189 |         This object should only be converted to numpy array before being passed to the model.
190 |         You'd not believe how complex the previous solution was."""
191 |         self._frames = frames
192 |         self._out = None
193 | 
194 |     def _force(self):
195 |         if self._out is None:
196 |             self._out = np.concatenate(self._frames, axis=2)
197 |             self._frames = None
198 |         return self._out
199 | 
200 |     def __array__(self, dtype=None):
201 |         out = self._force()
202 |         if dtype is not None:
203 |             out = out.astype(dtype)
204 |         return out
205 | 
206 |     def __len__(self):
207 |         return len(self._force())
208 | 
209 |     def __getitem__(self, i):
210 |         return self._force()[i]
211 | 
212 | def make_atari(env_id):
213 |     env = gym.make(env_id)
214 |     assert 'NoFrameskip' in env.spec.id
215 |     env = NoopResetEnv(env, noop_max=30)
216 |     env = MaxAndSkipEnv(env, skip=4)
217 |     return env
218 | 
219 | def wrap_deepmind(env, episode_life=True, clip_rewards=True, frame_stack=False, scale=False):
220 |     """Configure environment for DeepMind-style Atari.
221 |     """
222 |     if episode_life:
223 |         env = EpisodicLifeEnv(env)
224 |     if 'FIRE' in env.unwrapped.get_action_meanings():
225 |         env = FireResetEnv(env)
226 |     env = WarpFrame(env)
227 |     if scale:
228 |         env = ScaledFloatFrame(env)
229 |     if clip_rewards:
230 |         env = ClipRewardEnv(env)
231 |     if frame_stack:
232 |         env = FrameStack(env, 4)
233 |     return env
234 | 
235 | 
236 | 
237 | class ImageToPyTorch(gym.ObservationWrapper):
238 |     """
239 |     Image shape to num_channels x weight x height
240 |     """
241 |     def __init__(self, env):
242 |         super(ImageToPyTorch, self).__init__(env)
243 |         old_shape = self.observation_space.shape
244 |         self.observation_space = gym.spaces.Box(low=0.0, high=1.0, shape=(old_shape[-1], old_shape[0], old_shape[1]), dtype=np.uint8)
245 | 
246 |     def observation(self, observation):
247 |         return np.swapaxes(observation, 2, 0)
248 |     
249 | 
250 | def wrap_pytorch(env):
251 |     return ImageToPyTorch(env)


--------------------------------------------------------------------------------