awarebayes/RecNN

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Soft Actor Critic\n",
    "inspiration: [higgsfield/RL Adventure 2](https://github.com/higgsfield/RL-Adventure-2/blob/master/7.soft%20actor-critic.ipynb)\n",
    "\n",
    "paper https://arxiv.org/abs/1801.01290\n",
    "\n",
    "### Notice is doesnt work good and I havent kept up with the development of this module for too long. I am just afraid to run it at this point due to the code here being too depreceted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Note on this tutorials:**\n",
    "**They mostly contain low level implementations explaining what is going on inside the library.**\n",
    "\n",
    "**Most of the stuff explained here is already available out of the box for your usage.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from tqdm.auto import tqdm\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "import torch.nn.functional as F\n",
    "import torch_optimizer as optim\n",
    "\n",
    "from IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "# comment out if you are not using themes\n",
    "from jupyterthemes import jtplot\n",
    "jtplot.style(theme='grade3')\n",
    "\n",
    "# == recnn ==\n",
    "import sys\n",
    "sys.path.append(\"../../\")\n",
    "import recnn\n",
    "\n",
    "cuda = torch.device('cuda')\n",
    "\n",
    "# ---\n",
    "frame_size = 10\n",
    "batch_size = 25\n",
    "n_epochs   = 100\n",
    "plot_every = 30\n",
    "step       = 0\n",
    "# --- \n",
    "\n",
    "\n",
    "tqdm.pandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7f8d90b9e8214d8aa6986f45628d6d68",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=20000263), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "19409b3356934d378074819563ac0484",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=20000263), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7725f391e0554753889ca1a6063c695a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=138493), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# embeddgings: https://drive.google.com/open?id=1EQ_zXBR3DKpmJR3jBgLvt-xoOvArGMsL\n",
    "dirs = recnn.data.env.DataPath(\n",
    "    base=\"../../../data/\",\n",
    "    embeddings=\"embeddings/ml20_pca128.pkl\",\n",
    "    ratings=\"ml-20m/ratings.csv\",\n",
    "    cache=\"cache/frame_env.pkl\", # cache will generate after you run\n",
    "    use_cache=True\n",
    ")\n",
    "env = recnn.data.env.FrameEnv(dirs, frame_size, batch_size)\n",
    "\n",
    "# optional: apply tanh -1 1 to actions\n",
    "with torch.no_grad():\n",
    "    env.base.embeddings = torch.tanh(env.base.embeddings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def soft_update(net, target_net, soft_tau=1e-2):\n",
    "    for target_param, param in zip(target_net.parameters(), net.parameters()):\n",
    "            target_param.data.copy_(\n",
    "                target_param.data * (1.0 - soft_tau) + param.data * soft_tau\n",
    "            )\n",
    "\n",
    "ad = recnn.models.AnomalyDetector().to(cuda)\n",
    "ad.load_state_dict(torch.load('../../models/anomaly.pt'))\n",
    "ad.eval()\n",
    "\n",
    "def run_tests():\n",
    "    test_batch = next(iter(env.test_dataloader))\n",
    "    losses = soft_q_update(step, test_batch, params, learn=False)\n",
    "    \n",
    "    gen_actions = debugger.debug_dict['mat']['next_action']\n",
    "    gen_test_actions = debugger.debug_dict['mat']['test next_action']\n",
    "    true_actions = np.stack(env.embeddings.detach().cpu().numpy())\n",
    "    f = plotter.kde_reconstruction_error(ad, gen_actions, gen_test_actions, true_actions, cuda)\n",
    "    writer.add_figure('rec error', f, losses['step'])\n",
    "    return losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "class StateCritic(nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim, init_w=3e-3):\n",
    "        super(StateCritic, self).__init__()\n",
    "        \n",
    "        self.linear1 = nn.Linear(state_dim, hidden_dim)\n",
    "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.linear3 = nn.Linear(hidden_dim, 1)\n",
    "        \n",
    "        self.linear3.weight.data.uniform_(-init_w, init_w)\n",
    "        self.linear3.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "    def forward(self, state):\n",
    "        x = F.relu(self.linear1(state))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = self.linear3(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SoftQ(nn.Module):\n",
    "    def __init__(self, input_dim, action_dim, hidden_dim, init_w=3e-3):\n",
    "        super(SoftQ, self).__init__()\n",
    "        \n",
    "        self.linear1 = nn.Linear(input_dim + action_dim, hidden_dim)\n",
    "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.linear3 = nn.Linear(hidden_dim, 1)\n",
    "        \n",
    "        self.linear3.weight.data.uniform_(-init_w, init_w)\n",
    "        self.linear3.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "    def forward(self, state, action):\n",
    "        x = torch.cat([state, action], 1)\n",
    "        x = F.relu(self.linear1(x))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = self.linear3(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "class StochasticActor(nn.Module):\n",
    "    def __init__(self, input_dim, action_dim, hidden_size, params):\n",
    "        super(StochasticActor, self).__init__()\n",
    "        \n",
    "        self.log_std_min = params['log_std_min']\n",
    "        self.log_std_max = params['log_std_max']\n",
    "        self.drop_layer = nn.Dropout(p=0.5)\n",
    "        self.normal_dist = torch.distributions.Normal(0, 1)\n",
    "        \n",
    "        self.linear1 = nn.Linear(input_dim, hidden_size)\n",
    "        self.linear2 = nn.Linear(hidden_size, hidden_size)\n",
    "        \n",
    "        self.mean_linear = nn.Linear(hidden_size, action_dim)\n",
    "        self.mean_linear.weight.data.uniform_(-params['mean_initw'],\n",
    "                                              params['mean_initw'])\n",
    "        self.mean_linear.bias.data.uniform_(-params['mean_initw'],\n",
    "                                            params['mean_initw'])\n",
    "        \n",
    "        self.log_std_linear = nn.Linear(hidden_size, action_dim)\n",
    "        self.log_std_linear.weight.data.uniform_(-params['std_initw'],\n",
    "                                                  params['std_initw'])\n",
    "        self.log_std_linear.bias.data.uniform_(-params['std_initw'],\n",
    "                                                params['std_initw'])\n",
    "\n",
    "    def forward(self, state):\n",
    "        x = F.relu(self.linear1(state))\n",
    "        x = self.drop_layer(x)\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = self.drop_layer(x)\n",
    "        mean    = self.mean_linear(x)\n",
    "        log_std = self.log_std_linear(x)\n",
    "        log_std = torch.clamp(log_std, self.log_std_min, self.log_std_max)\n",
    "        \n",
    "        return mean, log_std\n",
    "    \n",
    "    def evaluate(self, state, epsilon=1e-6):\n",
    "        mean, log_std = self.forward(state)\n",
    "        \n",
    "        std = log_std.exp()\n",
    "        z = self.normal_dist.sample().to(cuda)\n",
    "    \n",
    "        action = torch.tanh(mean + z * std)\n",
    "        log_prob = torch.distributions.Normal(mean, std).log_prob(action)\n",
    "        log_prob -= torch.log(1 - action.pow(2) + epsilon)\n",
    "        # log_prob = log_prob.sum(-1, keepdim=True)\n",
    "        \n",
    "        return action, log_prob, z, mean, log_std"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def soft_q_update(step, batch, params, learn=True):\n",
    "    state, action, reward, next_state, done = recnn.data.get_base_batch(batch)\n",
    "    \n",
    "    # --------------------------------------------------------#\n",
    "    # SoftQ Learning\n",
    "    expected_softq_value = soft_q_net(state, action)\n",
    "    expected_value   = value_net(state)\n",
    "    next_action, log_prob, z, mean, log_std = policy_net.evaluate(state)\n",
    "    \n",
    "    target_value = target_value_net(next_state)\n",
    "    next_q_value = reward + (1 - done) * params['gamma'] * target_value\n",
    "    q_value_loss = soft_q_criterion(expected_softq_value, next_q_value.detach())\n",
    "    if learn:\n",
    "        soft_q_optimizer.zero_grad()\n",
    "        q_value_loss.backward()\n",
    "        soft_q_optimizer.step()\n",
    "        \n",
    "    # --------------------------------------------------------#\n",
    "    # StateValue Learning\n",
    "    expected_next_softq_value = soft_q_net(state, next_action)\n",
    "    next_value = expected_next_softq_value - log_prob\n",
    "    value_loss = value_criterion(expected_value, next_value.detach())\n",
    "    \n",
    "    if learn:\n",
    "        value_optimizer.zero_grad()\n",
    "        value_loss.backward()\n",
    "        value_optimizer.step()\n",
    "        soft_update(value_net, target_value_net, params['soft_tau'])\n",
    "    # --------------------------------------------------------#\n",
    "    # Policy Learning\n",
    "    log_prob_target = expected_next_softq_value - expected_value\n",
    "    policy_loss = (log_prob * (log_prob - log_prob_target).detach()).mean()\n",
    "\n",
    "    mean_loss = params['mean_lambda'] * mean.pow(2).mean()\n",
    "    std_loss  = params['std_lambda']  * log_std.pow(2).mean()\n",
    "    z_loss    = params['z_lambda']    * z.pow(2).sum(0).mean()\n",
    "\n",
    "    policy_loss += mean_loss + std_loss + z_loss\n",
    "    \n",
    "    if learn:\n",
    "        debugger.log_object('next_action', next_action)\n",
    "        policy_optimizer.zero_grad()\n",
    "        policy_loss.backward()\n",
    "        policy_optimizer.step()\n",
    "    \n",
    "    if not learn:\n",
    "        debugger.log_object('test next_action', next_action)\n",
    "        writer.add_figure('next_action',\n",
    "                          recnn.plot.pairwise_distances_fig(next_action[:50]), step)\n",
    "        writer.add_histogram('expected_softq_value', expected_softq_value, step)\n",
    "        writer.add_histogram('expected_value', expected_value, step)\n",
    "        writer.add_histogram('log_prob', log_prob, step)\n",
    "        writer.add_histogram('z', z, step)\n",
    "        writer.add_histogram('mean', mean, step)\n",
    "        writer.add_histogram('log_std', log_std, step)\n",
    "        writer.add_histogram('target_value', target_value, step)\n",
    "        writer.add_histogram('next_q_value', next_q_value, step)\n",
    "        writer.add_histogram('expected_next_softq_value', expected_next_softq_value, step)\n",
    "        writer.add_histogram('next_value', next_value, step)\n",
    "        writer.add_histogram('log_prob_target', log_prob_target, step)\n",
    "        writer.add_histogram('mean_loss', mean_loss, step)\n",
    "        writer.add_histogram('std_loss', std_loss, step)\n",
    "        writer.add_histogram('z_loss', z_loss, step)\n",
    "        writer.close()\n",
    "\n",
    "    losses = {'value': value_loss.item(),\n",
    "              'softq': q_value_loss.item(),\n",
    "              'policy': policy_loss.item(),\n",
    "              'step'  : step}\n",
    "    return losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "params = {\n",
    "    'gamma': 0.99,\n",
    "    'soft_tau': 0.001,\n",
    "    'policy_lr': 1e-5,\n",
    "    'value_lr': 1e-5,\n",
    "    'soft_qvalue_lr': 1e-5,\n",
    "    \n",
    "    'critic_weight_init': 1e-1,\n",
    "    'soft_critic_weight_init': 2e-1,\n",
    "    'mean_lambda':1e-3,\n",
    "    'std_lambda':1e-3,\n",
    "    'z_lambda': 1e-10,\n",
    "}\n",
    "\n",
    "stochastic_actor_params = {\n",
    "    'mean_initw': 1e-1,\n",
    "    'std_initw': 6e-1,\n",
    "    'log_std_min':-2,\n",
    "    'log_std_max':2\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch.autograd.anomaly_mode.set_detect_anomaly at 0x7f49edb70828>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "value_net  = StateCritic(1290, 256, params['critic_weight_init']).to(cuda)\n",
    "target_value_net = StateCritic(1290, 256).to(cuda)\n",
    "\n",
    "soft_q_net = SoftQ(1290, 128, 256, params['soft_critic_weight_init']).to(cuda)\n",
    "policy_net = StochasticActor(1290, 128, 256, stochastic_actor_params).to(cuda)\n",
    "\n",
    "soft_update(value_net, target_value_net, soft_tau=1.0)\n",
    "\n",
    "value_criterion  = nn.MSELoss()\n",
    "soft_q_criterion = nn.MSELoss()\n",
    "\n",
    "value_optimizer = optim.RAdam(value_net.parameters(), lr=params['value_lr'])\n",
    "soft_q_optimizer = optim.RAdam(soft_q_net.parameters(), lr=params['soft_qvalue_lr'])\n",
    "policy_optimizer = optim.RAdam(policy_net.parameters(), lr=params['policy_lr'])\n",
    "\n",
    "\n",
    "layout = {\n",
    "    'train': {'value': [], 'softq': [], 'policy': [], 'step': []},\n",
    "    'test': {'value': [], 'softq': [], 'policy': [], 'step': []}\n",
    "    }\n",
    "\n",
    "writer = SummaryWriter(log_dir='../../runs')\n",
    "debugger = recnn.Debugger(layout, run_tests, writer)\n",
    "plotter = recnn.Plotter(debugger, [['policy'], ['value', 'softq']],)\n",
    "torch.autograd.set_detect_anomaly(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 150\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-35-651adf7232a7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mepoch\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_epochs\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      2\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mbatch\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtqdm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain_dataloader\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[0;32m----> 3\u001b[0;31m         \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msoft_q_update\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m         \u001b[0mdebugger\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog_losses\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m         \u001b[0mstep\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-32-c0b50579c38e>\u001b[0m in \u001b[0;36msoft_q_update\u001b[0;34m(step, batch, params, learn)\u001b[0m\n\u001b[1;32m     42\u001b[0m         \u001b[0mdebugger\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog_object\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'next_action'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnext_action\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     43\u001b[0m         \u001b[0mpolicy_optimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_grad\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[0;32m---> 44\u001b[0;31m         \u001b[0mpolicy_loss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\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[0m\u001b[1;32m     45\u001b[0m         \u001b[0mpolicy_optimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\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     46\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/torch/tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph)\u001b[0m\n\u001b[1;32m    116\u001b[0m                 \u001b[0mproducts\u001b[0m\u001b[0;34m.\u001b[0m \u001b[0mDefaults\u001b[0m \u001b[0mto\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    117\u001b[0m         \"\"\"\n\u001b[0;32m--> 118\u001b[0;31m         \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    119\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    120\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhook\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[0;32m~/anaconda3/lib/python3.7/site-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables)\u001b[0m\n\u001b[1;32m     91\u001b[0m     Variable._execution_engine.run_backward(\n\u001b[1;32m     92\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_tensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 93\u001b[0;31m         allow_unreachable=True)  # allow_unreachable flag\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     95\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "for epoch in range(n_epochs):\n",
    "    for batch in tqdm(env.train_dataloader):\n",
    "        loss = soft_q_update(step, batch, params)\n",
    "        debugger.log_losses(loss)\n",
    "        step += 1\n",
    "        debugger.log_step(step)\n",
    "        if step % plot_every == 0:\n",
    "            clear_output(True)\n",
    "            print('step', step)\n",
    "            debugger.test()\n",
    "            plotter.plot_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gen_actions = debug['next_action']\n",
    "true_actions = env.embeddings.numpy()\n",
    "\n",
    "\n",
    "ad = recnn.nn.AnomalyDetector().to(cuda)\n",
    "ad.load_state_dict(torch.load('../../models/anomaly.pt'))\n",
    "ad.eval()\n",
    "\n",
    "plotter.plot_kde_reconstruction_error(ad, gen_actions, true_actions, cuda)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}