generator/13.dilated-cnn-beam.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/tensorflow/python/util/tf_inspect.py:75: DeprecationWarning: inspect.getargspec() is deprecated since Python 3.0, use inspect.signature() or inspect.getfullargspec()\n",
      "  return _inspect.getargspec(target)\n",
      "/usr/local/lib/python3.6/dist-packages/tensorflow/python/util/tf_inspect.py:75: DeprecationWarning: inspect.getargspec() is deprecated since Python 3.0, use inspect.signature() or inspect.getfullargspec()\n",
      "  return _inspect.getargspec(target)\n",
      "/usr/local/lib/python3.6/dist-packages/tensorflow/python/util/tf_inspect.py:75: DeprecationWarning: inspect.getargspec() is deprecated since Python 3.0, use inspect.signature() or inspect.getfullargspec()\n",
      "  return _inspect.getargspec(target)\n",
      "/usr/local/lib/python3.6/dist-packages/tensorflow/python/util/tf_inspect.py:75: DeprecationWarning: inspect.getargspec() is deprecated since Python 3.0, use inspect.signature() or inspect.getfullargspec()\n",
      "  return _inspect.getargspec(target)\n",
      "/usr/local/lib/python3.6/dist-packages/tensorflow/python/util/tf_inspect.py:75: DeprecationWarning: inspect.getargspec() is deprecated since Python 3.0, use inspect.signature() or inspect.getfullargspec()\n",
      "  return _inspect.getargspec(target)\n",
      "/usr/local/lib/python3.6/dist-packages/tensorflow/python/util/tf_inspect.py:75: DeprecationWarning: inspect.getargspec() is deprecated since Python 3.0, use inspect.signature() or inspect.getfullargspec()\n",
      "  return _inspect.getargspec(target)\n",
      "/usr/local/lib/python3.6/dist-packages/tensorflow/python/util/tf_inspect.py:75: DeprecationWarning: inspect.getargspec() is deprecated since Python 3.0, use inspect.signature() or inspect.getfullargspec()\n",
      "  return _inspect.getargspec(target)\n",
      "/usr/local/lib/python3.6/dist-packages/tensorflow/python/util/tf_inspect.py:75: DeprecationWarning: inspect.getargspec() is deprecated since Python 3.0, use inspect.signature() or inspect.getfullargspec()\n",
      "  return _inspect.getargspec(target)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import random\n",
    "import time\n",
    "import collections\n",
    "from tqdm import tqdm\n",
    "from tensor2tensor.utils import beam_search\n",
    "sns.set()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('shakespeare.txt') as fopen:\n",
    "    shakespeare = fopen.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "char2idx = {c: i+3 for i, c in enumerate(set(shakespeare))}\n",
    "char2idx['<pad>'] = 0\n",
    "char2idx['<start>'] = 1\n",
    "char2idx['<end>'] = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "idx2char = {v:k for k, v in char2idx.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 32\n",
    "sequence_length = 1000\n",
    "step = 25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1115394"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = [char2idx[char] for char in list(shakespeare)]\n",
    "len(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(44576, 1000)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len_win = sequence_length\n",
    "sequences = []\n",
    "for i in range(0, len(X) - len_win, step):\n",
    "    clip = X[i: i+len_win]\n",
    "    sequences.append(clip)\n",
    "sequences = np.array(sequences)\n",
    "sequences.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def start_sent(x):\n",
    "    _x = tf.fill([tf.shape(x)[0], 1], char2idx['<start>']) \n",
    "    return tf.concat([_x, x], 1)\n",
    "\n",
    "def end_sent(x):\n",
    "    _x = tf.fill([tf.shape(x)[0], 1], char2idx['<end>']) \n",
    "    return tf.concat([x, _x], 1)\n",
    "\n",
    "def embed_seq(x, vocab_sz, embed_dim, name, zero_pad=True): \n",
    "    embedding = tf.get_variable(name, [vocab_sz, embed_dim]) \n",
    "    if zero_pad:\n",
    "        embedding = tf.concat([tf.zeros([1, embed_dim]), embedding[1:, :]], 0) \n",
    "    x = tf.nn.embedding_lookup(embedding, x)\n",
    "    return x\n",
    "\n",
    "def position_encoding(inputs):\n",
    "    T = tf.shape(inputs)[1]\n",
    "    repr_dim = inputs.get_shape()[-1].value\n",
    "    pos = tf.reshape(tf.range(0.0, tf.to_float(T), dtype=tf.float32), [-1, 1])\n",
    "    i = np.arange(0, repr_dim, 2, np.float32)\n",
    "    denom = np.reshape(np.power(10000.0, i / repr_dim), [1, -1])\n",
    "    enc = tf.expand_dims(tf.concat([tf.sin(pos / denom), tf.cos(pos / denom)], 1), 0)\n",
    "    return tf.tile(enc, [tf.shape(inputs)[0], 1, 1])\n",
    "\n",
    "def layer_norm(inputs, epsilon=1e-8):\n",
    "    mean, variance = tf.nn.moments(inputs, [-1], keep_dims=True)\n",
    "    normalized = (inputs - mean) / (tf.sqrt(variance + epsilon))\n",
    "    params_shape = inputs.get_shape()[-1:]\n",
    "    gamma = tf.get_variable('gamma', params_shape, tf.float32, tf.ones_initializer())\n",
    "    beta = tf.get_variable('beta', params_shape, tf.float32, tf.zeros_initializer())\n",
    "    return gamma * normalized + beta\n",
    "\n",
    "\n",
    "def cnn_block(x, dilation_rate, pad_sz, hidden_dim, kernel_size):\n",
    "    x = layer_norm(x)\n",
    "    pad = tf.zeros([tf.shape(x)[0], pad_sz, hidden_dim])\n",
    "    x =  tf.layers.conv1d(inputs = tf.concat([pad, x, pad], 1),\n",
    "                          filters = hidden_dim,\n",
    "                          kernel_size = kernel_size,\n",
    "                          dilation_rate = dilation_rate)\n",
    "    x = x[:, :-pad_sz, :]\n",
    "    x = tf.nn.relu(x)\n",
    "    return x\n",
    "\n",
    "class Generator:\n",
    "    def __init__(self, size_layer, num_layers, embedded_size,\n",
    "                 dict_size, learning_rate, kernel_size = 5):\n",
    "        \n",
    "        self.X = tf.placeholder(tf.int32, [None, None])\n",
    "        self.Y = tf.placeholder(tf.int32, [None, None])\n",
    "        self.X_seq_len = tf.count_nonzero(self.X, 1, dtype=tf.int32)\n",
    "        self.Y_seq_len = tf.count_nonzero(self.Y, 1, dtype=tf.int32)\n",
    "        self.training = tf.placeholder(tf.bool, None)\n",
    "        self.dict_size = dict_size\n",
    "        self.embedded_size = embedded_size\n",
    "        self.size_layer = size_layer\n",
    "        self.kernel_size = kernel_size\n",
    "        self.num_layers = num_layers\n",
    "        batch_size = tf.shape(self.X)[0]\n",
    "        x = start_sent(self.X)\n",
    "        y = end_sent(self.Y)\n",
    "        self.y = y\n",
    "                \n",
    "        logits = self.forward(x)\n",
    "        self.logits = logits\n",
    "        \n",
    "        self.cost = tf.reduce_mean(tf.contrib.seq2seq.sequence_loss(\n",
    "            logits = logits,\n",
    "            targets = y,\n",
    "            weights = tf.to_float(tf.ones_like(y))))\n",
    "        self.optimizer = tf.train.AdamOptimizer(learning_rate).minimize(self.cost)\n",
    "        \n",
    "        masks = tf.sequence_mask(self.Y_seq_len, tf.reduce_max(self.Y_seq_len), dtype=tf.float32)\n",
    "        y_t = tf.argmax(logits,axis=2)\n",
    "        y_t = tf.cast(y_t, tf.int32)\n",
    "        self.prediction = tf.boolean_mask(y_t, masks)\n",
    "        mask_label = tf.boolean_mask(y, masks)\n",
    "        correct_pred = tf.equal(self.prediction, mask_label)\n",
    "        correct_index = tf.cast(correct_pred, tf.float32)\n",
    "        self.accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))\n",
    "        \n",
    "    def forward(self, x):\n",
    "        \n",
    "        with tf.variable_scope('embed', reuse=tf.AUTO_REUSE):\n",
    "            x = embed_seq(x, self.dict_size, self.embedded_size, 'word')\n",
    "        x += position_encoding(x)\n",
    "        \n",
    "        for i in range(self.num_layers): \n",
    "            dilation_rate = 2 ** i\n",
    "            pad_sz = (self.kernel_size - 1) * dilation_rate \n",
    "            with tf.variable_scope('block_%d'%i,reuse=tf.AUTO_REUSE):\n",
    "                x += cnn_block(x, dilation_rate, pad_sz, self.size_layer, self.kernel_size)\n",
    "        \n",
    "        with tf.variable_scope('logits', reuse=tf.AUTO_REUSE):\n",
    "            return tf.layers.dense(x, self.dict_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def beam_search_decoding(length = 1000):\n",
    "    initial_ids = tf.constant(char2idx['<start>'], tf.int32, [1])\n",
    "\n",
    "    def symbols_to_logits(ids):\n",
    "        logits = model.forward(ids)\n",
    "        return logits[:, tf.shape(ids)[1]-1, :]\n",
    "\n",
    "    final_ids, final_probs, _ = beam_search.beam_search(\n",
    "        symbols_to_logits,\n",
    "        initial_ids,\n",
    "        5,\n",
    "        length,\n",
    "        len(char2idx),\n",
    "        0.0,\n",
    "        eos_id = char2idx['<end>'])\n",
    "    \n",
    "    return final_ids[0, 0, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "learning_rate = 0.001\n",
    "epoch = 10\n",
    "num_layers = 4\n",
    "size_layer = 128\n",
    "possible_batch_id = range(len(X) - sequence_length - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/numpy/lib/type_check.py:546: DeprecationWarning: np.asscalar(a) is deprecated since NumPy v1.16, use a.item() instead\n",
      "  'a.item() instead', DeprecationWarning, stacklevel=1)\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "sess = tf.InteractiveSession()\n",
    "model = Generator(size_layer, num_layers, size_layer, len(char2idx), learning_rate)\n",
    "model.generate = beam_search_decoding()\n",
    "sess.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.0182, 6.4250164]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batch_x = sequences[:10]\n",
    "sess.run([model.accuracy, model.cost],feed_dict = {model.X: batch_x,\n",
    "                                                  model.Y: batch_x,\n",
    "                                                  model.training: True})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1393/1393 [02:17<00:00, 10.14it/s, accuracy=0.448, cost=1.89]\n",
      "minibatch loop:   0%|          | 2/1393 [00:00<02:15, 10.25it/s, accuracy=0.396, cost=2.08]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 1, average cost 2.199554, average accuracy 0.379028\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1393/1393 [02:17<00:00, 10.06it/s, accuracy=0.491, cost=1.71]\n",
      "minibatch loop:   0%|          | 2/1393 [00:00<02:18, 10.02it/s, accuracy=0.47, cost=1.81]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 2, average cost 1.796837, average accuracy 0.471840\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1393/1393 [02:18<00:00, 10.05it/s, accuracy=0.509, cost=1.62]\n",
      "minibatch loop:   0%|          | 1/1393 [00:00<02:19,  9.94it/s, accuracy=0.516, cost=1.67]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 3, average cost 1.654398, average accuracy 0.509008\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1393/1393 [02:18<00:00, 10.12it/s, accuracy=0.533, cost=1.56]\n",
      "minibatch loop:   0%|          | 2/1393 [00:00<02:17, 10.13it/s, accuracy=0.526, cost=1.6]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 4, average cost 1.576100, average accuracy 0.529141\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1393/1393 [02:17<00:00, 10.07it/s, accuracy=0.545, cost=1.53]\n",
      "minibatch loop:   0%|          | 2/1393 [00:00<02:16, 10.19it/s, accuracy=0.538, cost=1.56]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 5, average cost 1.526466, average accuracy 0.542057\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1393/1393 [02:17<00:00, 10.11it/s, accuracy=0.555, cost=1.5] \n",
      "minibatch loop:   0%|          | 2/1393 [00:00<02:15, 10.28it/s, accuracy=0.55, cost=1.51]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 6, average cost 1.490850, average accuracy 0.551269\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1393/1393 [02:17<00:00, 10.04it/s, accuracy=0.562, cost=1.47]\n",
      "minibatch loop:   0%|          | 1/1393 [00:00<02:19,  9.95it/s, accuracy=0.559, cost=1.48]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 7, average cost 1.463462, average accuracy 0.558501\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1393/1393 [02:18<00:00, 10.06it/s, accuracy=0.567, cost=1.45]\n",
      "minibatch loop:   0%|          | 2/1393 [00:00<02:17, 10.13it/s, accuracy=0.568, cost=1.45]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 8, average cost 1.441292, average accuracy 0.564195\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1393/1393 [02:18<00:00, 10.20it/s, accuracy=0.567, cost=1.44]\n",
      "minibatch loop:   0%|          | 2/1393 [00:00<02:16, 10.17it/s, accuracy=0.572, cost=1.43]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 9, average cost 1.422928, average accuracy 0.568922\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1393/1393 [02:17<00:00, 10.07it/s, accuracy=0.569, cost=1.43]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 10, average cost 1.407453, average accuracy 0.573069\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "LOST, ACCURACY = [], []\n",
    "for e in range(epoch):\n",
    "    pbar = tqdm(\n",
    "        range(0, len(sequences), batch_size), desc = 'minibatch loop')\n",
    "    total_cost, total_accuracy = 0, 0\n",
    "    for i in pbar:\n",
    "        batch_x = sequences[i : min(i + batch_size, len(sequences))]\n",
    "        _, accuracy, cost = sess.run([model.optimizer, model.accuracy, model.cost],feed_dict = {model.X: batch_x,\n",
    "                                                  model.Y: batch_x,\n",
    "                                                  model.training: True})\n",
    "        total_cost += cost\n",
    "        total_accuracy += accuracy\n",
    "        pbar.set_postfix(cost = cost, accuracy = accuracy)\n",
    "        LOST.append(cost)\n",
    "        ACCURACY.append(accuracy)\n",
    "    total_cost /= (len(sequences) / batch_size)\n",
    "    total_accuracy /= (len(sequences) / batch_size)\n",
    "    print('epoch %d, average cost %f, average accuracy %f'%(e + 1, total_cost, total_accuracy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize = (15, 5))\n",
    "plt.subplot(1, 2, 1)\n",
    "EPOCH = np.arange(len(LOST))\n",
    "plt.plot(EPOCH, LOST)\n",
    "plt.xlabel('epoch'); plt.ylabel('loss')\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(EPOCH, ACCURACY)\n",
    "plt.xlabel('epoch'); plt.ylabel('accuracy')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<start> well.\n",
      "\n",
      "DUKE VINCENTIO:\n",
      "And therefore, you married.\n",
      "\n",
      "ANTONDIO:\n",
      "Welcome, my lord.\n",
      "\n",
      "DUKE VINCENTIO:\n",
      "I' the dukest our father.\n",
      "\n",
      "MARIENSIO:\n",
      "Well, my lord.\n",
      "\n",
      "SEBASNNAND:\n",
      "Sir, thou, sir.\n",
      "\n",
      "DONANDIO:\n",
      "\n",
      "ANTONOONO:\n",
      "No.\n",
      "\n",
      "SONCENSENON:\n",
      "No, sir.\n",
      "\n",
      "NONTENSIO:\n",
      "Now you strange,\n",
      "And with the dukes of the world and therefore.\n",
      "\n",
      "PROSPENO:\n",
      "Thou didst thou dost thou didst thou didst thou dost\n",
      "And here is the duke of your father.\n",
      "\n",
      "PETRUCHIO:\n",
      "No, I'll not thing my father.\n",
      "\n",
      "PETENCEN:\n",
      "Sirrah, with the words of the world and therefore.\n",
      "\n",
      "SEBASTIAN:\n",
      "And therefore didness.\n",
      "\n",
      "LUCENDIO:\n",
      "Thou hast thou dost thou dost thou wouldst thou dost thou dost thou didst thou dost thou dost thou wouldst thou dost thou wouldst thou dost thou dost thou dost thou didst thou dost thou dost thou dost thou dost thou wouldst thou master.\n",
      "\n",
      "SEBASTIAN:\n",
      "What thou dost thou dost thou dost thou didst thou dost thou didst thou dost thou dost thou wouldst thou dost thou dost thou dost thou wouldst thou dost thou wouldst thou dost thou wouldst thou \n"
     ]
    }
   ],
   "source": [
    "print(''.join([idx2char[i] for i in sess.run(model.generate)]))"
   ]
  },
  {
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}