awarebayes/RecNN

View on GitHub
examples/99.To be released, but working/2. BCQ/1. BCQ PyTorch .ipynb

Summary

Maintainability
Test Coverage
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# BCQ DDPG \n",
    "\n",
    "### Off-Policy Deep Reinforcement Learning without Exploration\n",
    "\n",
    "I used some code from https://github.com/sfujim/BCQ\n",
    "\n",
    "Arxiv: https://arxiv.org/abs/1812.02900"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "import torch_optimizer as optim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from tqdm.auto import tqdm\n",
    "import pickle\n",
    "import gc\n",
    "import json\n",
    "import h5py\n",
    "\n",
    "from IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\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",
    "tqdm.pandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0b2533b798894aec91e08d5dac319696",
       "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": "f43ab096b19b426d8d3d05b9d05f47af",
       "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": "5032093d25a14782b5fd15af1659afe4",
       "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",
    "env = recnn.data.env.FrameEnv('../../data/embeddings/ml20_pca128.pkl',\n",
    "                         '../../data/ml-20m/ratings.csv', frame_size, batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from jupyterthemes import jtplot\n",
    "jtplot.style(theme='grade3')\n",
    "\n",
    "def run_tests():\n",
    "    test_batch = next(iter(env.test_dataloader))\n",
    "    losses = bcq_update(test_batch, params, writer, debug, learn=False, step=step)\n",
    "    \n",
    "    gen_actions = debug['perturbed_actions']\n",
    "    true_actions = env.embeddings.detach().cpu().numpy()\n",
    "    \n",
    "    f = plotter.kde_reconstruction_error(ad, gen_actions, true_actions, cuda)\n",
    "    writer.add_figure('rec_error',f, losses['step'])\n",
    "    \n",
    "    return losses\n",
    "\n",
    "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",
    "            )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Technically, the authors call it variational autoencoder\n",
    "# But instead of learning to encode/sample state\n",
    "# It gets state + action as an input\n",
    "# And generates action\n",
    "# So it is a stochastic generative model for sampling actions\n",
    "class Generator(nn.Module):\n",
    "    def __init__(self, input_dim, action_dim, latent_dim):\n",
    "        super(Generator, self).__init__()\n",
    "        #encoder\n",
    "        self.e1 = nn.Linear(input_dim + action_dim, 750)\n",
    "        self.e2 = nn.Linear(750, 750)\n",
    "\n",
    "        self.mean = nn.Linear(750, latent_dim)\n",
    "        self.log_std = nn.Linear(750, latent_dim)\n",
    "        \n",
    "        #decoder\n",
    "        self.d1 = nn.Linear(input_dim + latent_dim, 750)\n",
    "        self.d2 = nn.Linear(750, 750)\n",
    "        self.d3 = nn.Linear(750, action_dim)\n",
    "        \n",
    "        #self.d3.weight.data.uniform_(-init_w, init_w)\n",
    "        #self.d3.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "        self.latent_dim = latent_dim\n",
    "        self.normal = torch.distributions.Normal(0, 1)\n",
    "\n",
    "\n",
    "    def forward(self, state, action):\n",
    "        # z is encoded state + action\n",
    "        z = F.relu(self.e1(torch.cat([state, action], 1)))\n",
    "        z = F.relu(self.e2(z))\n",
    "\n",
    "        mean = self.mean(z)\n",
    "        # Clamped for numerical stability \n",
    "        log_std = self.log_std(z).clamp(-4, 15)\n",
    "        std = torch.exp(log_std)\n",
    "        z = mean + std * self.normal.sample(std.size()).to(cuda)\n",
    "\n",
    "        # u is decoded action\n",
    "        u = self.decode(state, z)\n",
    "\n",
    "        return u, mean, std\n",
    "    \n",
    "    def decode(self, state, z=None):\n",
    "        # When sampling from the VAE, the latent vector is clipped to [-0.5, 0.5]\n",
    "        if z is None:\n",
    "            z = self.normal.sample([state.size(0), self.latent_dim])\n",
    "            z = z.clamp(-0.5, 0.5).to(cuda)\n",
    "\n",
    "        a = F.relu(self.d1(torch.cat([state, z], 1)))\n",
    "        a = F.relu(self.d2(a))\n",
    "        return self.d3(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# P.S. This is not a usual Actor.\n",
    "# It is a peturbative network that takes an input from the Generator\n",
    "# And adjusts (perturbates) it to look like normal action\n",
    "\n",
    "class Perturbator(nn.Module):\n",
    "    def __init__(self, input_dim, action_dim, hidden_size, init_w=3e-1):\n",
    "        super(Perturbator, self).__init__()\n",
    "        \n",
    "        self.drop_layer = nn.Dropout(p=0.5)\n",
    "        \n",
    "        self.linear1 = nn.Linear(input_dim + action_dim, hidden_size)\n",
    "        self.linear2 = nn.Linear(hidden_size, hidden_size)\n",
    "        self.linear3 = nn.Linear(hidden_size, action_dim)\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",
    "        a = torch.cat([state, action], 1)\n",
    "        a = F.relu(self.linear1(a))\n",
    "        a = self.drop_layer(a)\n",
    "        a = F.relu(self.linear2(a))\n",
    "        a = self.drop_layer(a)\n",
    "        a = self.linear3(a) \n",
    "        return a + action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bcq_update(batch, params, writer, debug, learn=True, step=-1):\n",
    "    \n",
    "    state, action, reward, next_state, done = recnn.data.get_base_batch(batch)\n",
    "    batch_size = done.size(0)\n",
    "    \n",
    "    # --------------------------------------------------------#\n",
    "    # Variational Auto-Encoder Learning\n",
    "    recon, mean, std = generator_net(state, action)\n",
    "    recon_loss = F.mse_loss(recon, action)\n",
    "    KL_loss\t= -0.5 * (1 + torch.log(std.pow(2)) - mean.pow(2) - std.pow(2)).mean()\n",
    "    generator_loss = recon_loss + 0.5 * KL_loss\n",
    "    \n",
    "    if not learn:\n",
    "        writer.add_histogram('generator_mean', mean,step)\n",
    "        writer.add_histogram('generator_std', std, step)\n",
    "        debug['recon'] = recon\n",
    "        writer.add_figure('reconstructed',\n",
    "                          recnn.utils.pairwise_distances_fig(recon[:50]), step)\n",
    "        \n",
    "    if learn:\n",
    "        generator_optimizer.zero_grad()\n",
    "        generator_loss.backward()\n",
    "        generator_optimizer.step()\n",
    "    # --------------------------------------------------------#\n",
    "    # Value Learning\n",
    "    with torch.no_grad():\n",
    "        # p.s. repeat_interleave was added in torch 1.1\n",
    "        # if an error pops up, run 'conda update pytorch'\n",
    "        state_rep = torch.repeat_interleave(next_state, params['n_generator_samples'], 0)\n",
    "        sampled_action = generator_net.decode(state_rep)\n",
    "        perturbed_action = target_perturbator_net(state_rep, sampled_action)\n",
    "        target_Q1 = target_value_net1(state_rep, perturbed_action)\n",
    "        target_Q2 = target_value_net1(state_rep, perturbed_action)\n",
    "        target_value = 0.75 * torch.min(target_Q1, target_Q2) # value soft update\n",
    "        target_value+= 0.25 * torch.max(target_Q1, target_Q2) #\n",
    "        target_value = target_value.view(batch_size, -1).max(1)[0].view(-1, 1)\n",
    "        \n",
    "        expected_value = reward + (1.0 - done) * params['gamma'] * target_value\n",
    "\n",
    "    value = value_net1(state, action)\n",
    "    value_loss = torch.pow(value - expected_value.detach(), 2).mean()\n",
    "    \n",
    "    if learn:\n",
    "        value_optimizer1.zero_grad()\n",
    "        value_optimizer2.zero_grad()\n",
    "        value_loss.backward()\n",
    "        value_optimizer1.step()\n",
    "        value_optimizer2.step()\n",
    "    else:\n",
    "        writer.add_histogram('value', value, step)\n",
    "        writer.add_histogram('target_value', target_value, step)\n",
    "        writer.add_histogram('expected_value', expected_value, step)\n",
    "        writer.close()\n",
    "    \n",
    "    # --------------------------------------------------------#\n",
    "    # Perturbator learning\n",
    "    sampled_actions = generator_net.decode(state)\n",
    "    perturbed_actions= perturbator_net(state, sampled_actions)\n",
    "    perturbator_loss = -value_net1(state, perturbed_actions)\n",
    "    if not learn:\n",
    "        writer.add_histogram('perturbator_loss', perturbator_loss, step)\n",
    "    perturbator_loss = perturbator_loss.mean()\n",
    "    \n",
    "    if learn:\n",
    "        if step % params['perturbator_step']:\n",
    "            perturbator_optimizer.zero_grad()\n",
    "            perturbator_loss.backward()\n",
    "            torch.nn.utils.clip_grad_norm_(perturbator_net.parameters(), -1, 1)\n",
    "            perturbator_optimizer.step()\n",
    "        \n",
    "        soft_update(value_net1, target_value_net1, soft_tau=params['soft_tau'])\n",
    "        soft_update(value_net2, target_value_net2, soft_tau=params['soft_tau'])\n",
    "        soft_update(perturbator_net, target_perturbator_net, soft_tau=params['soft_tau'])\n",
    "    else:\n",
    "        debug['sampled_actions'] = sampled_actions\n",
    "        debug['perturbed_actions'] = perturbed_actions\n",
    "        writer.add_figure('sampled_actions',\n",
    "            recnn.utils.pairwise_distances_fig(sampled_actions[:50]), step)\n",
    "        writer.add_figure('perturbed_actions',\n",
    "            recnn.utils.pairwise_distances_fig(perturbed_actions[:50]), step)\n",
    "        \n",
    "    \n",
    "    # --------------------------------------------------------#\n",
    "\n",
    "    losses = {'value': value_loss.item(),\n",
    "              'perturbator': perturbator_loss.item(),\n",
    "              'generator': generator_loss.item(),\n",
    "              'step': step}\n",
    "    \n",
    "    recnn.utils.write_losses(writer, losses, kind='train' if learn else 'test')\n",
    "    \n",
    "    return losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# === BCQ settings ===\n",
    "params = {\n",
    "    # algorithm parameters\n",
    "    'gamma'              : 0.99,\n",
    "    'soft_tau'           : 0.001,\n",
    "    'n_generator_samples': 3,\n",
    "    'perturbator_step'   : 2,\n",
    "    \n",
    "    # learning rates\n",
    "    'perturbator_lr' : 1e-5,\n",
    "    'value_lr'       : 1e-5,\n",
    "    'generator_lr'   : 1e-3,\n",
    "}\n",
    "# === end ==="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "generator_net = Generator(1290, 128, 512).to(cuda)\n",
    "generator_net.load_state_dict(torch.load(\"../../models/bcq_generator.pt\"))\n",
    "value_net1  = recnn.nn.models.Critic(1290, 128, 256, init_w=8e-1).to(cuda)\n",
    "value_net2  = recnn.nn.models.Critic(1290, 128, 256, init_w=8e-1).to(cuda)\n",
    "perturbator_net = Perturbator(1290, 128, 256, init_w=27e-2).to(cuda)\n",
    "\n",
    "target_value_net1 = recnn.nn.models.Critic(1290, 128, 256).to(cuda)\n",
    "target_value_net2 = recnn.nn.models.Critic(1290, 128, 256).to(cuda)\n",
    "target_perturbator_net = Perturbator(1290, 128, 256).to(cuda)\n",
    "\n",
    "ad = recnn.nn.models.AnomalyDetector().to(cuda)\n",
    "ad.load_state_dict(torch.load('../../models/anomaly.pt'))\n",
    "ad.eval()\n",
    "\n",
    "target_perturbator_net.eval()\n",
    "target_value_net1.eval()\n",
    "target_value_net2.eval()\n",
    "\n",
    "soft_update(value_net1, target_value_net1, soft_tau=1.0)\n",
    "soft_update(value_net2, target_value_net2, soft_tau=1.0)\n",
    "soft_update(perturbator_net, target_perturbator_net, soft_tau=1.0)\n",
    "\n",
    "\n",
    "# optim.Adam can be replaced with RAdam\n",
    "value_optimizer1 = optim.Ranger(value_net1.parameters(), lr=params['value_lr'], k=10)\n",
    "value_optimizer2 = optim.Ranger(value_net2.parameters(), lr=params['perturbator_lr'], k=10)\n",
    "perturbator_optimizer = optim.Ranger(perturbator_net.parameters(), lr=params['value_lr'], weight_decay=1e-3,\n",
    "                                          k=10)\n",
    "\n",
    "generator_optimizer = optim.Ranger(generator_net.parameters(), lr=params['generator_lr'], k=10)\n",
    "# I would advice you not to weight decay generator\n",
    "\n",
    "loss = {\n",
    "    'train': {'value': [], 'perturbator': [], 'generator': [], 'step': []},\n",
    "    'test': {'value': [], 'perturbator': [], 'generator': [], 'step': []},\n",
    "    }\n",
    "\n",
    "writer = SummaryWriter(log_dir='../../runs')\n",
    "plotter = recnn.utils.Plotter(loss, [['generator'], ['value', 'perturbator']],)\n",
    "debug = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 780\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "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-34-0fe54a65e6d0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mscheduler\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      5\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----> 6\u001b[0;31m         \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbcq_update\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[0mwriter\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdebug\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstep\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[0m\n\u001b[0m\u001b[1;32m      7\u001b[0m         \u001b[0mscheduler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbatch_step\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      8\u001b[0m         \u001b[0mplotter\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[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "shelduler_step = 300\n",
    "\n",
    "for epoch in range(n_epochs):\n",
    "    scheduler.step()\n",
    "    for batch in tqdm(env.train_dataloader):\n",
    "        loss = bcq_update(batch, params, writer, debug, step=step)\n",
    "        scheduler.batch_step()\n",
    "        plotter.log_losses(loss)\n",
    "        step += 1\n",
    "        if step % shelduler_step == 0:\n",
    "            scheduler.step()\n",
    "        if step % plot_every == 0:\n",
    "            clear_output(True)\n",
    "            print('step', step)\n",
    "            test_loss = run_tests()\n",
    "            plotter.log_losses(test_loss, test=True)\n",
    "            plotter.plot_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(generator_net.state_dict(), \"../../models/bcq_generator.pt\")\n",
    "torch.save(perturbator_net.state_dict(), \"../../models/bcq_perturbator.pt\")\n",
    "torch.save(value_net1.state_dict(), \"../../models/bcq_value1.pt\")\n",
    "torch.save(value_net2.state_dict(), \"../../models/bcq_value2.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "../../recnn/utils/plot.py:113: UserWarning: Matplotlib is currently using module://ipykernel.pylab.backend_inline, which is a non-GUI backend, so cannot show the figure.\n",
      "  fig.show()\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "gen_actions = debug['perturbed_actions']\n",
    "true_actions = env.embeddings.numpy()\n",
    "\n",
    "\n",
    "ad = recnn.nn.models.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": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "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
}