├── README.md
└── avo-poisson.ipynb


/README.md:
--------------------------------------------------------------------------------
1 | # AVO Pytorch
2 | 
3 | Implementation of [Adversarial Variational Optimization](https://arxiv.org/pdf/1707.07113.pdf) to solve likelihood-free inference problems
4 | 


--------------------------------------------------------------------------------
/avo-poisson.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# AVORIM for a Poisson simulator"
  8 |    ]
  9 |   },
 10 |   {
 11 |    "cell_type": "code",
 12 |    "execution_count": 1,
 13 |    "metadata": {
 14 |     "collapsed": true
 15 |    },
 16 |    "outputs": [],
 17 |    "source": [
 18 |     "import numpy as np\n",
 19 |     "import matplotlib.pyplot as plt\n",
 20 |     "%matplotlib inline\n",
 21 |     "import copy\n",
 22 |     "\n",
 23 |     "import torch\n",
 24 |     "import torch.nn as nn\n",
 25 |     "import torch.nn.functional as F\n",
 26 |     "from torch.nn.parameter import Parameter\n",
 27 |     "import torch.autograd as autograd\n",
 28 |     "\n",
 29 |     "from IPython.display import clear_output\n",
 30 |     "from tqdm import tqdm"
 31 |    ]
 32 |   },
 33 |   {
 34 |    "cell_type": "markdown",
 35 |    "metadata": {},
 36 |    "source": [
 37 |     "## Constants"
 38 |    ]
 39 |   },
 40 |   {
 41 |    "cell_type": "markdown",
 42 |    "metadata": {},
 43 |    "source": [
 44 |     "### Simulator parameters"
 45 |    ]
 46 |   },
 47 |   {
 48 |    "cell_type": "code",
 49 |    "execution_count": 2,
 50 |    "metadata": {
 51 |     "collapsed": true
 52 |    },
 53 |    "outputs": [],
 54 |    "source": [
 55 |     "lambda_poisson = 7\n",
 56 |     "nb_samples = 20000"
 57 |    ]
 58 |   },
 59 |   {
 60 |    "cell_type": "markdown",
 61 |    "metadata": {},
 62 |    "source": [
 63 |     "### Network parameters"
 64 |    ]
 65 |   },
 66 |   {
 67 |    "cell_type": "code",
 68 |    "execution_count": 3,
 69 |    "metadata": {
 70 |     "collapsed": true
 71 |    },
 72 |    "outputs": [],
 73 |    "source": [
 74 |     "batch_size = 64\n",
 75 |     "lambda_gp = 1\n",
 76 |     "gamma_entropy = 100"
 77 |    ]
 78 |   },
 79 |   {
 80 |    "cell_type": "code",
 81 |    "execution_count": 4,
 82 |    "metadata": {
 83 |     "collapsed": true
 84 |    },
 85 |    "outputs": [],
 86 |    "source": [
 87 |     "critic_params = {\"lr\": 1e-3,\n",
 88 |     "                 \"nb_steps\": 1,\n",
 89 |     "                 \"nb_hiddens\": 10\n",
 90 |     "                }"
 91 |    ]
 92 |   },
 93 |   {
 94 |    "cell_type": "code",
 95 |    "execution_count": 5,
 96 |    "metadata": {
 97 |     "collapsed": true
 98 |    },
 99 |    "outputs": [],
100 |    "source": [
101 |     "proposal_params = {\"lr\": 1e-3,\n",
102 |     "                   \"beta1\": 0.5,\n",
103 |     "                   \"beta2\": 0.9\n",
104 |     "                  }"
105 |    ]
106 |   },
107 |   {
108 |    "cell_type": "code",
109 |    "execution_count": 6,
110 |    "metadata": {
111 |     "collapsed": true
112 |    },
113 |    "outputs": [],
114 |    "source": [
115 |     "gen_params = {\"nb_steps\": 1}"
116 |    ]
117 |   },
118 |   {
119 |    "cell_type": "markdown",
120 |    "metadata": {},
121 |    "source": [
122 |     "## Generation of the data"
123 |    ]
124 |   },
125 |   {
126 |    "cell_type": "markdown",
127 |    "metadata": {},
128 |    "source": [
129 |     "### Build the simulator"
130 |    ]
131 |   },
132 |   {
133 |    "cell_type": "code",
134 |    "execution_count": 7,
135 |    "metadata": {
136 |     "collapsed": true
137 |    },
138 |    "outputs": [],
139 |    "source": [
140 |     "def simulator(theta):\n",
141 |     "    # lambda = exp(theta) (for positivity)\n",
142 |     "    return np.random.poisson(np.exp(theta))"
143 |    ]
144 |   },
145 |   {
146 |    "cell_type": "markdown",
147 |    "metadata": {},
148 |    "source": [
149 |     "### Generate the data"
150 |    ]
151 |   },
152 |   {
153 |    "cell_type": "code",
154 |    "execution_count": 8,
155 |    "metadata": {
156 |     "collapsed": true
157 |    },
158 |    "outputs": [],
159 |    "source": [
160 |     "X_obs = simulator([np.log(lambda_poisson) for i in range(nb_samples)])\n",
161 |     "X_obs = X_obs[:,np.newaxis]\n",
162 |     "X_obs = torch.Tensor(X_obs)"
163 |    ]
164 |   },
165 |   {
166 |    "cell_type": "markdown",
167 |    "metadata": {},
168 |    "source": [
169 |     "## Definition of the optimizer"
170 |    ]
171 |   },
172 |   {
173 |    "cell_type": "markdown",
174 |    "metadata": {},
175 |    "source": [
176 |     "### RMSprop"
177 |    ]
178 |   },
179 |   {
180 |    "cell_type": "code",
181 |    "execution_count": 24,
182 |    "metadata": {
183 |     "collapsed": true
184 |    },
185 |    "outputs": [],
186 |    "source": [
187 |     "class RmsPropOptimizer:\n",
188 |     "    def __init__(self, size_input, lr=0.01, gamma=1., eps=10**-8):\n",
189 |     "        self.size_input = size_input\n",
190 |     "        self.lr = lr\n",
191 |     "        self.gamma = gamma\n",
192 |     "        self.eps = eps\n",
193 |     "\n",
194 |     "        self.reset()\n",
195 |     "\n",
196 |     "    def reset(self):\n",
197 |     "        self.avg_sq_grad = torch.ones(self.size_input)\n",
198 |     "\n",
199 |     "    def step(self, grad_approx, num_iters=1):\n",
200 |     "        v = 0\n",
201 |     "        for i in range(num_iters):\n",
202 |     "            self.avg_sq_grad = self.avg_sq_grad * self.gamma + grad_approx**2 * (1 - self.gamma)\n",
203 |     "            v = v + self.lr * grad_approx / torch.sqrt(self.avg_sq_grad + self.eps)\n",
204 |     "        v /= num_iters\n",
205 |     "        print(\"step: \", v)\n",
206 |     "        return v"
207 |    ]
208 |   },
209 |   {
210 |    "cell_type": "code",
211 |    "execution_count": 25,
212 |    "metadata": {
213 |     "collapsed": true
214 |    },
215 |    "outputs": [],
216 |    "source": [
217 |     "rms = RmsPropOptimizer(1, lr=0.1)\n",
218 |     "x = torch.tensor([1.], requires_grad=True)\n",
219 |     "y = x**2"
220 |    ]
221 |   },
222 |   {
223 |    "cell_type": "code",
224 |    "execution_count": 58,
225 |    "metadata": {},
226 |    "outputs": [
227 |     {
228 |      "name": "stdout",
229 |      "output_type": "stream",
230 |      "text": [
231 |       "step:  tensor(1.00000e-03 *\n",
232 |       "       [ 3.6029])\n"
233 |      ]
234 |     },
235 |     {
236 |      "data": {
237 |       "text/plain": [
238 |        "tensor(1.00000e-02 *\n",
239 |        "       [ 1.4412])"
240 |       ]
241 |      },
242 |      "execution_count": 58,
243 |      "metadata": {},
244 |      "output_type": "execute_result"
245 |     }
246 |    ],
247 |    "source": [
248 |     "x.grad = torch.tensor([0.])\n",
249 |     "y.backward(retain_graph=True)\n",
250 |     "x.data.sub_(rms.step(x.grad))"
251 |    ]
252 |   },
253 |   {
254 |    "cell_type": "markdown",
255 |    "metadata": {},
256 |    "source": [
257 |     "## Definition of the proposal distribution $q$"
258 |    ]
259 |   },
260 |   {
261 |    "cell_type": "code",
262 |    "execution_count": 27,
263 |    "metadata": {
264 |     "collapsed": true
265 |    },
266 |    "outputs": [],
267 |    "source": [
268 |     "class Proposal(nn.Module):\n",
269 |     "    def __init__(self, lr=0.01):\n",
270 |     "        super(Proposal, self).__init__()\n",
271 |     "        \n",
272 |     "        self.psi = Parameter(torch.tensor([0., -1.]), requires_grad=True) # mean and log(std)\n",
273 |     "\n",
274 |     "        self.optimizer = RmsPropOptimizer(self.psi.shape[0], lr=lr)\n",
275 |     "        \n",
276 |     "    def forward(self, size):\n",
277 |     "        return self.psi[0] +  torch.exp(self.psi[1]) * torch.normal(torch.zeros((size, 1)), torch.ones((size, 1)))\n",
278 |     "    \n",
279 |     "    def backprop(self, grad_approx):\n",
280 |     "        step = self.optimizer.step(grad_approx)\n",
281 |     "        self.psi[0].data.sub_(step[0])\n",
282 |     "        \n",
283 |     "    def pdf(self, theta):\n",
284 |     "        return 1. / torch.sqrt(2 * np.pi * torch.exp(self.psi[1])**2) * torch.exp(-(torch.exp(theta) - self.psi[0])**2 / (2 * torch.exp(self.psi[1])))"
285 |    ]
286 |   },
287 |   {
288 |    "cell_type": "code",
289 |    "execution_count": 28,
290 |    "metadata": {
291 |     "collapsed": true
292 |    },
293 |    "outputs": [],
294 |    "source": [
295 |     "p = Proposal()"
296 |    ]
297 |   },
298 |   {
299 |    "cell_type": "code",
300 |    "execution_count": 29,
301 |    "metadata": {
302 |     "collapsed": true
303 |    },
304 |    "outputs": [],
305 |    "source": [
306 |     "p.zero_grad()\n",
307 |     "l = torch.log(p.pdf(torch.tensor(0.)))\n",
308 |     "l.backward()"
309 |    ]
310 |   },
311 |   {
312 |    "cell_type": "code",
313 |    "execution_count": 30,
314 |    "metadata": {},
315 |    "outputs": [
316 |     {
317 |      "data": {
318 |       "text/plain": [
319 |        "tensor([ 2.7183,  0.3591])"
320 |       ]
321 |      },
322 |      "execution_count": 30,
323 |      "metadata": {},
324 |      "output_type": "execute_result"
325 |     }
326 |    ],
327 |    "source": [
328 |     "p.psi.grad"
329 |    ]
330 |   },
331 |   {
332 |    "cell_type": "code",
333 |    "execution_count": 31,
334 |    "metadata": {},
335 |    "outputs": [
336 |     {
337 |      "data": {
338 |       "text/plain": [
339 |        "tensor(0.2062)"
340 |       ]
341 |      },
342 |      "execution_count": 31,
343 |      "metadata": {},
344 |      "output_type": "execute_result"
345 |     }
346 |    ],
347 |    "source": [
348 |     "p.pdf(torch.tensor(0.1))"
349 |    ]
350 |   },
351 |   {
352 |    "cell_type": "markdown",
353 |    "metadata": {},
354 |    "source": [
355 |     "## Building the networks"
356 |    ]
357 |   },
358 |   {
359 |    "cell_type": "markdown",
360 |    "metadata": {},
361 |    "source": [
362 |     "### Losses"
363 |    ]
364 |   },
365 |   {
366 |    "cell_type": "code",
367 |    "execution_count": 32,
368 |    "metadata": {
369 |     "collapsed": true
370 |    },
371 |    "outputs": [],
372 |    "source": [
373 |     "def wgan_critic_loss(C_gen, C_real):\n",
374 |     "    return torch.mean(C_gen) - torch.mean(C_real)\n",
375 |     "\n",
376 |     "def wgan_generator_loss(C_gen):\n",
377 |     "    return -torch.mean(C_gen)"
378 |    ]
379 |   },
380 |   {
381 |    "cell_type": "code",
382 |    "execution_count": 33,
383 |    "metadata": {
384 |     "collapsed": true
385 |    },
386 |    "outputs": [],
387 |    "source": [
388 |     "def ogan_critic_loss(C_gen, C_real, eps=1e-8):\n",
389 |     "    return torch.mean(- torch.log(C_real+eps) - torch.log(1 - C_gen+eps))\n",
390 |     "\n",
391 |     "def ogan_generator_loss(C_gen, eps=1e-8):\n",
392 |     "    return -torch.mean(torch.log(C_gen+eps))"
393 |    ]
394 |   },
395 |   {
396 |    "cell_type": "code",
397 |    "execution_count": 34,
398 |    "metadata": {
399 |     "collapsed": true
400 |    },
401 |    "outputs": [],
402 |    "source": [
403 |     "def gradient_penalty(critic, X_real):\n",
404 |     "    X_real.requires_grad_(True)\n",
405 |     "    C_real = critic.forward(X_real)\n",
406 |     "    out_grad = torch.ones(X_real.shape[0], 1) # used to define the size of the grad (grad_C(C) = [1,1,...])\n",
407 |     "    gradients = autograd.grad(outputs=C_real, inputs=X_real,\n",
408 |     "                              grad_outputs=out_grad, create_graph=True, retain_graph=True,\n",
409 |     "                              only_inputs=True)[0]\n",
410 |     "    return ((gradients.norm(2, dim=1))**2).mean()"
411 |    ]
412 |   },
413 |   {
414 |    "cell_type": "markdown",
415 |    "metadata": {},
416 |    "source": [
417 |     "### Critic"
418 |    ]
419 |   },
420 |   {
421 |    "cell_type": "code",
422 |    "execution_count": 35,
423 |    "metadata": {
424 |     "collapsed": true
425 |    },
426 |    "outputs": [],
427 |    "source": [
428 |     "class Critic(nn.Module):\n",
429 |     "    def __init__(self):\n",
430 |     "        super(Critic, self).__init__()\n",
431 |     "        self.fc1 = nn.Linear(1,critic_params[\"nb_hiddens\"])\n",
432 |     "        self.fc2 = nn.Linear(critic_params[\"nb_hiddens\"],critic_params[\"nb_hiddens\"])\n",
433 |     "        self.fc3 = nn.Linear(critic_params[\"nb_hiddens\"],1)\n",
434 |     "        \n",
435 |     "        self.optimizer = torch.optim.RMSprop(self.parameters(), lr=critic_params[\"lr\"])\n",
436 |     "        \n",
437 |     "    def forward(self, x):\n",
438 |     "        out = F.relu(self.fc1(x))\n",
439 |     "        out = F.relu(self.fc2(out))\n",
440 |     "        out = F.sigmoid(self.fc3(out))\n",
441 |     "        \n",
442 |     "        return out\n",
443 |     "    \n",
444 |     "    def loss(self, X_gen, X_real):\n",
445 |     "        C_gen = self.forward(X_gen)\n",
446 |     "        C_real = self.forward(X_real)\n",
447 |     "#         print(\"C_gen\", C_gen)\n",
448 |     "#         print(\"C_real\", C_real)\n",
449 |     "        \n",
450 |     "        return ogan_critic_loss(C_gen, C_real) #+ lambda_gp * gradient_penalty(self, X_real)"
451 |    ]
452 |   },
453 |   {
454 |    "cell_type": "markdown",
455 |    "metadata": {},
456 |    "source": [
457 |     "### Generator"
458 |    ]
459 |   },
460 |   {
461 |    "cell_type": "code",
462 |    "execution_count": 60,
463 |    "metadata": {
464 |     "collapsed": true
465 |    },
466 |    "outputs": [],
467 |    "source": [
468 |     "class Generator(nn.Module):\n",
469 |     "    def __init__(self):\n",
470 |     "        super(Generator, self).__init__()\n",
471 |     "        \n",
472 |     "    def forward(self, theta):\n",
473 |     "        theta_np = theta.detach().numpy()\n",
474 |     "        x_np = simulator(theta_np)\n",
475 |     "        return torch.FloatTensor(x_np)\n",
476 |     "    \n",
477 |     "    def loss(self, C_gen):\n",
478 |     "        return ogan_generator_loss(C_gen)\n",
479 |     "    \n",
480 |     "    def grad_approx(self, proposal, theta, C_gen, eps=1e-8):\n",
481 |     "#         log_q_batch = torch.log(proposal.pdf(theta))\n",
482 |     "        \n",
483 |     "#         proposal.zero_grad()\n",
484 |     "#         log_q_batch = torch.log(proposal.pdf(theta.detach()))\n",
485 |     "#         log_q_batch.backward(-C_gen)\n",
486 |     "#         grad_batch = proposal.psi.grad\n",
487 |     "\n",
488 |     "        grad_u = 0\n",
489 |     "        for i in range(len(theta)):\n",
490 |     "            proposal.zero_grad()\n",
491 |     "            log_q = torch.log(proposal.pdf(theta[i]) + eps)\n",
492 |     "            log_q.backward()\n",
493 |     "            grad_u += - C_gen[i] * proposal.psi.grad\n",
494 |     "        print(\"pdf\", proposal.pdf(theta[i].detach()))\n",
495 |     "\n",
496 |     "        grad_u /= theta.shape[0]\n",
497 |     "            \n",
498 |     "        return grad_u\n",
499 |     "    \n",
500 |     "    def entropy(self, proposal, theta, eps=1e-8):\n",
501 |     "        grad_h = 0\n",
502 |     "        for i in range(len(theta)):\n",
503 |     "            proposal.zero_grad()\n",
504 |     "            q = proposal.pdf(theta[i].detach())\n",
505 |     "            H = q * torch.log(q + eps)\n",
506 |     "            H.backward()\n",
507 |     "            grad_h += proposal.psi.grad\n",
508 |     "\n",
509 |     "        grad_h /= theta.shape[0]\n",
510 |     "            \n",
511 |     "        return grad_h\n",
512 |     "    \n",
513 |     "    def backprop(self, proposal, theta, C_gen):\n",
514 |     "        grad_u = self.grad_approx(proposal, theta.detach(), C_gen)\n",
515 |     "        grad_h = self.entropy(proposal, theta)\n",
516 |     "        print(\"grad_u\", grad_u)\n",
517 |     "        print(\"grad_h\", gamma_entropy * grad_h)\n",
518 |     "        proposal.backprop(grad_u + 0 * grad_h)"
519 |    ]
520 |   },
521 |   {
522 |    "cell_type": "markdown",
523 |    "metadata": {},
524 |    "source": [
525 |     "## Main loop"
526 |    ]
527 |   },
528 |   {
529 |    "cell_type": "code",
530 |    "execution_count": 61,
531 |    "metadata": {
532 |     "collapsed": true
533 |    },
534 |    "outputs": [],
535 |    "source": [
536 |     "i = 0\n",
537 |     "C_loss_list = []\n",
538 |     "G_loss_list = []\n",
539 |     "\n",
540 |     "proposal = Proposal(lr=0.01)\n",
541 |     "critic = Critic()\n",
542 |     "generator = Generator()"
543 |    ]
544 |   },
545 |   {
546 |    "cell_type": "code",
547 |    "execution_count": 62,
548 |    "metadata": {},
549 |    "outputs": [
550 |     {
551 |      "name": "stdout",
552 |      "output_type": "stream",
553 |      "text": [
554 |       "pdf tensor(1.00000e-03 *\n",
555 |       "       [ 1.2718])\n",
556 |       "grad_u tensor([-0.4120, -0.5302])\n",
557 |       "grad_h tensor([-0.8154, -0.5042])\n",
558 |       "step:  tensor(1.00000e-03 *\n",
559 |       "       [-4.1201, -5.3018])\n",
560 |       "Psi:  Parameter containing:\n",
561 |       "tensor([ 2.1869, -1.0000])\n"
562 |      ]
563 |     },
564 |     {
565 |      "ename": "KeyboardInterrupt",
566 |      "evalue": "",
567 |      "output_type": "error",
568 |      "traceback": [
569 |       "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
570 |       "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
571 |       "\u001b[0;32m<ipython-input-62-87c407f16aa9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     28\u001b[0m         \u001b[0mC_gen\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcritic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgenerator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtheta_sample\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdetach\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     29\u001b[0m         \u001b[0mG_loss_list\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgenerator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mC_gen\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 30\u001b[0;31m         \u001b[0msleep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     31\u001b[0m         \u001b[0mclear_output\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     32\u001b[0m         \u001b[0mgenerator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackprop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mproposal\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtheta_sample\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mC_gen\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
572 |       "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
573 |      ]
574 |     }
575 |    ],
576 |    "source": [
577 |     "from time import sleep\n",
578 |     "# print(proposal.psi)\n",
579 |     "critic_params[\"nb_steps\"] = 5\n",
580 |     "gen_params[\"nb_steps\"] = 2\n",
581 |     "\n",
582 |     "nb_iter = 100\n",
583 |     "for i in range(i,i+nb_iter):\n",
584 |     "    critic.optimizer.zero_grad()\n",
585 |     "    \n",
586 |     "    for i_critic in range(critic_params[\"nb_steps\"]):\n",
587 |     "        X_real_sample = X_obs[np.random.choice(len(X_obs), batch_size)]\n",
588 |     "        theta_sample = proposal.forward(batch_size)\n",
589 |     "        X_gen_sample = torch.FloatTensor(simulator(theta_sample.detach().numpy()))\n",
590 |     "        \n",
591 |     "        C_loss = critic.loss(X_gen_sample, X_real_sample)\n",
592 |     "        C_loss.backward()\n",
593 |     "        critic.optimizer.step()\n",
594 |     "    \n",
595 |     "    # validation\n",
596 |     "    X_real_sample = X_obs[np.random.choice(len(X_obs), batch_size)]\n",
597 |     "    theta_sample = proposal.forward(batch_size)\n",
598 |     "    X_gen_sample = torch.FloatTensor(simulator(theta_sample.detach().numpy()))\n",
599 |     "    C_loss = critic.loss(X_gen_sample, X_real_sample)   \n",
600 |     "    C_loss_list.append(C_loss)\n",
601 |     "        \n",
602 |     "    for i_gen in range(gen_params[\"nb_steps\"]):\n",
603 |     "        theta_sample = proposal.forward(batch_size)\n",
604 |     "        C_gen = critic(generator.forward(theta_sample.detach()))\n",
605 |     "        G_loss_list.append(generator.loss(C_gen))\n",
606 |     "        sleep(0.1)\n",
607 |     "        clear_output(wait=True)\n",
608 |     "        generator.backprop(proposal, theta_sample, C_gen)\n",
609 |     "        print(\"Psi: \", proposal.psi)\n",
610 |     "\n",
611 |     "print(\"Critic Loss: \", C_loss)"
612 |    ]
613 |   },
614 |   {
615 |    "cell_type": "code",
616 |    "execution_count": 59,
617 |    "metadata": {},
618 |    "outputs": [
619 |     {
620 |      "data": {
621 |       "text/plain": [
622 |        "Text(0,0.5,'Generator loss')"
623 |       ]
624 |      },
625 |      "execution_count": 59,
626 |      "metadata": {},
627 |      "output_type": "execute_result"
628 |     },
629 |     {
630 |      "data": {
631 |       "image/png": "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\n",
632 |       "text/plain": [
633 |        "<Figure size 1440x504 with 2 Axes>"
634 |       ]
635 |      },
636 |      "metadata": {},
637 |      "output_type": "display_data"
638 |     }
639 |    ],
640 |    "source": [
641 |     "plt.rcParams[\"figure.figsize\"] = (20,7)\n",
642 |     "\n",
643 |     "plt.subplot(1,2,1)\n",
644 |     "\n",
645 |     "plt.plot(C_loss_list)\n",
646 |     "plt.xlabel(\"Number of iterations\", size=15)\n",
647 |     "plt.ylabel(\"Critic loss\", size=15)\n",
648 |     "\n",
649 |     "plt.subplot(1,2,2)\n",
650 |     "\n",
651 |     "plt.plot(G_loss_list)\n",
652 |     "plt.xlabel(\"Number of iterations\", size=15)\n",
653 |     "plt.ylabel(\"Generator loss\", size=15)"
654 |    ]
655 |   },
656 |   {
657 |    "cell_type": "markdown",
658 |    "metadata": {},
659 |    "source": [
660 |     "## Visualization"
661 |    ]
662 |   },
663 |   {
664 |    "cell_type": "code",
665 |    "execution_count": 459,
666 |    "metadata": {},
667 |    "outputs": [
668 |     {
669 |      "data": {
670 |       "text/plain": [
671 |        "<matplotlib.legend.Legend at 0x7fc62ca314e0>"
672 |       ]
673 |      },
674 |      "execution_count": 459,
675 |      "metadata": {},
676 |      "output_type": "execute_result"
677 |     },
678 |     {
679 |      "data": {
680 |       "image/png": "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\n",
681 |       "text/plain": [
682 |        "<Figure size 1440x504 with 2 Axes>"
683 |       ]
684 |      },
685 |      "metadata": {},
686 |      "output_type": "display_data"
687 |     }
688 |    ],
689 |    "source": [
690 |     "theta_sample = proposal.forward(20000)\n",
691 |     "X_gen_sample = torch.FloatTensor(simulator(theta_sample.detach().numpy()))\n",
692 |     "\n",
693 |     "hist1 = plt.hist(X_gen_sample[:,0], label=\"Generate distribution\", density=True, alpha=0.8)\n",
694 |     "hist2 = plt.hist(X_obs[:,0], label=\"Real distribution\", density=True, alpha=0.8)\n",
695 |     "\n",
696 |     "cm = plt.cm.coolwarm\n",
697 |     "\n",
698 |     "x_min, x_max = 0, 25\n",
699 |     "y_min, y_max = 0, 0.6\n",
700 |     "h = .1\n",
701 |     "xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n",
702 |     "levels = np.linspace(0,1,100)\n",
703 |     "eps = 1\n",
704 |     "Z = critic.forward(torch.FloatTensor(xx.reshape(xx.shape[0]*xx.shape[1], 1))).detach()\n",
705 |     "Z = Z.reshape(xx.shape[0], xx.shape[1])\n",
706 |     "plt.contourf(xx, yy, Z, levels, cmap=cm, alpha=0.8)\n",
707 |     "\n",
708 |     "plt.xlim(0,25)\n",
709 |     "plt.ylim(0, 0.5)\n",
710 |     "plt.colorbar()\n",
711 |     "plt.legend()"
712 |    ]
713 |   },
714 |   {
715 |    "cell_type": "code",
716 |    "execution_count": 118,
717 |    "metadata": {},
718 |    "outputs": [
719 |     {
720 |      "data": {
721 |       "text/plain": [
722 |        "array([4505])"
723 |       ]
724 |      },
725 |      "execution_count": 118,
726 |      "metadata": {},
727 |      "output_type": "execute_result"
728 |     }
729 |    ],
730 |    "source": [
731 |     "simulator(max(theta_sample.detach()))"
732 |    ]
733 |   },
734 |   {
735 |    "cell_type": "code",
736 |    "execution_count": 119,
737 |    "metadata": {},
738 |    "outputs": [
739 |     {
740 |      "data": {
741 |       "text/plain": [
742 |        "tensor([ 8.3894])"
743 |       ]
744 |      },
745 |      "execution_count": 119,
746 |      "metadata": {},
747 |      "output_type": "execute_result"
748 |     }
749 |    ],
750 |    "source": [
751 |     "max(theta_sample.detach())"
752 |    ]
753 |   },
754 |   {
755 |    "cell_type": "code",
756 |    "execution_count": null,
757 |    "metadata": {
758 |     "collapsed": true
759 |    },
760 |    "outputs": [],
761 |    "source": [
762 |     "xx.reshape(xx.shape[0]*xx.shape[1], 1)"
763 |    ]
764 |   },
765 |   {
766 |    "cell_type": "code",
767 |    "execution_count": null,
768 |    "metadata": {
769 |     "collapsed": true
770 |    },
771 |    "outputs": [],
772 |    "source": [
773 |     "np.log(xx.reshape(xx.shape[0]*xx.shape[1], 1) + eps)"
774 |    ]
775 |   },
776 |   {
777 |    "cell_type": "code",
778 |    "execution_count": null,
779 |    "metadata": {
780 |     "collapsed": true
781 |    },
782 |    "outputs": [],
783 |    "source": [
784 |     "np.log(xx.reshape(xx.shape[0]*xx.shape[1], 1) + eps)"
785 |    ]
786 |   },
787 |   {
788 |    "cell_type": "code",
789 |    "execution_count": 104,
790 |    "metadata": {},
791 |    "outputs": [
792 |     {
793 |      "data": {
794 |       "text/plain": [
795 |        "403.4287934927351"
796 |       ]
797 |      },
798 |      "execution_count": 104,
799 |      "metadata": {},
800 |      "output_type": "execute_result"
801 |     }
802 |    ],
803 |    "source": [
804 |     "np.exp(6)"
805 |    ]
806 |   },
807 |   {
808 |    "cell_type": "code",
809 |    "execution_count": null,
810 |    "metadata": {
811 |     "collapsed": true
812 |    },
813 |    "outputs": [],
814 |    "source": []
815 |   }
816 |  ],
817 |  "metadata": {
818 |   "kernelspec": {
819 |    "display_name": "Python [conda env:rim-avo]",
820 |    "language": "python",
821 |    "name": "conda-env-rim-avo-py"
822 |   },
823 |   "language_info": {
824 |    "codemirror_mode": {
825 |     "name": "ipython",
826 |     "version": 3
827 |    },
828 |    "file_extension": ".py",
829 |    "mimetype": "text/x-python",
830 |    "name": "python",
831 |    "nbconvert_exporter": "python",
832 |    "pygments_lexer": "ipython3",
833 |    "version": "3.6.5"
834 |   }
835 |  },
836 |  "nbformat": 4,
837 |  "nbformat_minor": 2
838 | }
839 | 


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