generator/14.transformer-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 = 100\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": [
       "(44612, 100)"
      ]
     },
     "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 self_attention(inputs, is_training, num_units, num_heads = 8, activation=None):\n",
    "    T_q = T_k = tf.shape(inputs)[1]\n",
    "    Q_K_V = tf.layers.dense(inputs, 3*num_units, activation)\n",
    "    Q, K, V = tf.split(Q_K_V, 3, -1)\n",
    "    Q_ = tf.concat(tf.split(Q, num_heads, axis=2), 0)\n",
    "    K_ = tf.concat(tf.split(K, num_heads, axis=2), 0)\n",
    "    V_ = tf.concat(tf.split(V, num_heads, axis=2), 0)\n",
    "    align = tf.matmul(Q_, K_, transpose_b=True)\n",
    "    align *= tf.rsqrt(tf.to_float(K_.get_shape()[-1].value))\n",
    "    paddings = tf.fill(tf.shape(align), float('-inf'))\n",
    "    lower_tri = tf.ones([T_q, T_k])\n",
    "    lower_tri = tf.linalg.LinearOperatorLowerTriangular(lower_tri).to_dense()\n",
    "    masks = tf.tile(tf.expand_dims(lower_tri,0), [tf.shape(align)[0],1,1])\n",
    "    align = tf.where(tf.equal(masks, 0), paddings, align)\n",
    "    align = tf.nn.softmax(align)\n",
    "    align = tf.layers.dropout(align, 0.1, training=is_training) \n",
    "    x = tf.matmul(align, V_)\n",
    "    x = tf.concat(tf.split(x, num_heads, axis=0), 2)\n",
    "    x += inputs\n",
    "    x = layer_norm(x)\n",
    "    return x\n",
    "\n",
    "def ffn(inputs, hidden_dim, activation=tf.nn.relu):\n",
    "    x = tf.layers.conv1d(inputs, 4* hidden_dim, 1, activation=activation) \n",
    "    x = tf.layers.conv1d(x, hidden_dim, 1, activation=None)\n",
    "    x += inputs\n",
    "    x = layer_norm(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",
    "            with tf.variable_scope('attn_%d'%i,reuse=tf.AUTO_REUSE):\n",
    "                x = self_attention(x, self.training, self.size_layer)\n",
    "            with tf.variable_scope('ffn_%d'%i, reuse=tf.AUTO_REUSE):\n",
    "                x = ffn(x, self.size_layer)\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.009, 5.353285]"
      ]
     },
     "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%|██████████| 1395/1395 [01:26<00:00, 16.14it/s, accuracy=0.403, cost=1.95]\n",
      "minibatch loop:   0%|          | 2/1395 [00:00<01:26, 16.06it/s, accuracy=0.391, cost=2.07]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 1, average cost 2.299564, average accuracy 0.343030\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1395/1395 [01:26<00:00, 16.19it/s, accuracy=0.48, cost=1.7]  \n",
      "minibatch loop:   0%|          | 2/1395 [00:00<01:24, 16.40it/s, accuracy=0.476, cost=1.81]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 2, average cost 1.756041, average accuracy 0.477325\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1395/1395 [01:26<00:00, 16.17it/s, accuracy=0.482, cost=1.6] \n",
      "minibatch loop:   0%|          | 2/1395 [00:00<01:25, 16.27it/s, accuracy=0.519, cost=1.66]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 3, average cost 1.602468, average accuracy 0.517561\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1395/1395 [01:26<00:00, 16.18it/s, accuracy=0.522, cost=1.51]\n",
      "minibatch loop:   0%|          | 2/1395 [00:00<01:24, 16.55it/s, accuracy=0.529, cost=1.58]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 4, average cost 1.523173, average accuracy 0.538126\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1395/1395 [01:26<00:00, 16.20it/s, accuracy=0.54, cost=1.47] \n",
      "minibatch loop:   0%|          | 2/1395 [00:00<01:25, 16.24it/s, accuracy=0.544, cost=1.53]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 5, average cost 1.472919, average accuracy 0.550870\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1395/1395 [01:26<00:00, 16.20it/s, accuracy=0.558, cost=1.4] \n",
      "minibatch loop:   0%|          | 2/1395 [00:00<01:23, 16.61it/s, accuracy=0.549, cost=1.5] "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 6, average cost 1.438337, average accuracy 0.559827\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1395/1395 [01:26<00:00, 16.22it/s, accuracy=0.575, cost=1.35]\n",
      "minibatch loop:   0%|          | 2/1395 [00:00<01:24, 16.41it/s, accuracy=0.558, cost=1.46]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 7, average cost 1.411766, average accuracy 0.566631\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1395/1395 [01:26<00:00, 16.22it/s, accuracy=0.58, cost=1.3]  \n",
      "minibatch loop:   0%|          | 2/1395 [00:00<01:24, 16.50it/s, accuracy=0.564, cost=1.44]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 8, average cost 1.390999, average accuracy 0.572155\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1395/1395 [01:25<00:00, 16.23it/s, accuracy=0.587, cost=1.25]\n",
      "minibatch loop:   0%|          | 2/1395 [00:00<01:24, 16.43it/s, accuracy=0.564, cost=1.43]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 9, average cost 1.373868, average accuracy 0.576607\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "minibatch loop: 100%|██████████| 1395/1395 [01:26<00:00, 16.21it/s, accuracy=0.603, cost=1.23]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 10, average cost 1.360007, average accuracy 0.579969\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],\n",
    "                                     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> and thence.\n",
      "\n",
      "ANTONIO:\n",
      "What is the world?\n",
      "\n",
      "SEBASTIAN:\n",
      "What is the marriage?\n",
      "\n",
      "SEBASTIAN:\n",
      "What is the <end>\n"
     ]
    }
   ],
   "source": [
    "print(''.join([idx2char[i] for i in sess.run(model.generate,feed_dict={model.training:False})]))"
   ]
  },
  {
   "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
}