seq2seq_att.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from __future__ import print_function\n",
    "\n",
    "import sys\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "from keras.layers import Input, Embedding, LSTM, TimeDistributed, Dense\n",
    "from keras.models import Model, load_model\n",
    "\n",
    "from models import encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "LEARNING_RATE=0.5\n",
    "BATCH_SIZE = 64\n",
    "HIDDEN_NODES = 128\n",
    "NUMBER_OF_LAYERS = 2\n",
    "EMB_SIZE=100\n",
    "EPOCHS=30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tjaweb تجاوب\n",
      "arb3a2 اربعاء\n",
      "training size 12899\n",
      "validation size 2150\n"
     ]
    }
   ],
   "source": [
    "data = pd.read_excel('Arabizi-Arabic Parallel corpora.xlsx', header=None, skiprows=1)\n",
    "data = data.sample(frac=1, random_state=0)\n",
    "\n",
    "data_input = [str(s).strip().lower() for s in data[0]]\n",
    "data_output = [str(s).strip() for s in data[1]]\n",
    "print(data_input[0], data_output[0])\n",
    "print(data_input[5], data_output[5])\n",
    "\n",
    "data_size = len(data)\n",
    "\n",
    "# We will use the first 0-60th %-tile (60%) of data for the training\n",
    "range_of_train = int(data_size*60/100)\n",
    "\n",
    "training_input  = data_input[0: range_of_train ]\n",
    "training_output = data_output[0: range_of_train ]\n",
    "\n",
    "# We will use the first 60-70th %-tile (10%) of data for the training\n",
    "range_of_train = int(data_size*60/100)\n",
    "range_of_val = int(data_size*70/100)\n",
    "\n",
    "validation_input = data_input[range_of_train:range_of_val]\n",
    "validation_output = data_output[range_of_train: range_of_val]\n",
    "\n",
    "print('training size', len(training_input))\n",
    "print('validation size', len(validation_input))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max input len= 19 \n",
      "max output len= 12\n"
     ]
    }
   ],
   "source": [
    "INPUT_LENGTH=0\n",
    "OUTPUT_LENGTH=0\n",
    "for i in data_input:\n",
    "    if len(i)>INPUT_LENGTH:\n",
    "        INPUT_LENGTH=len(i)\n",
    "for i in data_output:\n",
    "    if len(i)>OUTPUT_LENGTH:\n",
    "        OUTPUT_LENGTH=len(i)\n",
    "print(\"max input len=\", INPUT_LENGTH,\"\\nmax output len=\",OUTPUT_LENGTH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transform data into Numpy arrays\n",
    "We transform the sequences of characters into sequences of integer IDs. This will be done by using pre-written functions in encoding module.\n",
    "\n",
    "First, encoding.build_characters_encoding will build encoding/decoding dictionary from the data.\n",
    "Then, encoding.transform will transform the data into numpy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "English character dict size: 52\n",
      "Katakana character dict size: 41\n",
      "encoded_training_input (12899, 19)\n",
      "encoded_training_output (12899, 12)\n",
      "encoded_validation_input (2150, 19)\n",
      "encoded_validation_output (2150, 12)\n"
     ]
    }
   ],
   "source": [
    "input_encoding, input_decoding, input_dict_size = encoding.build_characters_encoding(data_input)\n",
    "output_encoding, output_decoding, output_dict_size = encoding.build_characters_encoding(data_output)\n",
    "\n",
    "print('English character dict size:', input_dict_size)\n",
    "print('Arabic character dict size:', output_dict_size)\n",
    "\n",
    "encoded_training_input = encoding.transform(\n",
    "    input_encoding, training_input, vector_size=INPUT_LENGTH)\n",
    "encoded_training_output = encoding.transform(\n",
    "    output_encoding, training_output, vector_size=OUTPUT_LENGTH)\n",
    "\n",
    "print('encoded_training_input', encoded_training_input.shape)\n",
    "print('encoded_training_output', encoded_training_output.shape)\n",
    "\n",
    "encoded_validation_input = encoding.transform(\n",
    "    input_encoding, validation_input, vector_size=INPUT_LENGTH)\n",
    "encoded_validation_output = encoding.transform(\n",
    "    output_encoding, validation_output, vector_size=OUTPUT_LENGTH)\n",
    "\n",
    "print('encoded_validation_input', encoded_validation_input.shape)\n",
    "print('encoded_validation_output', encoded_validation_output.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sequence-to-Sequence in Keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoder_input = Input(shape=(INPUT_LENGTH,))\n",
    "decoder_input = Input(shape=(OUTPUT_LENGTH,))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Encoder / Decoder\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "encoder Tensor(\"lstm_1/transpose_2:0\", shape=(?, 19, 128), dtype=float32)\n",
      "encoder_last Tensor(\"strided_slice:0\", shape=(?, 128), dtype=float32)\n",
      "decoder Tensor(\"lstm_2/transpose_2:0\", shape=(?, 12, 128), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "from keras.layers import SimpleRNN\n",
    "\n",
    "encoder = Embedding(input_dict_size, EMB_SIZE, input_length=INPUT_LENGTH, mask_zero=True)(encoder_input)\n",
    "encoder = LSTM(HIDDEN_NODES, return_sequences=True, unroll=True)(encoder)\n",
    "encoder_last = encoder[:,-1,:]\n",
    "\n",
    "print('encoder', encoder)\n",
    "print('encoder_last', encoder_last)\n",
    "\n",
    "decoder = Embedding(output_dict_size, EMB_SIZE, input_length=OUTPUT_LENGTH, mask_zero=True)(decoder_input)\n",
    "decoder = LSTM(HIDDEN_NODES, return_sequences=True, unroll=True)(decoder, initial_state=[encoder_last, encoder_last])\n",
    "\n",
    "print('decoder', decoder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Attention Mechanism\n",
    "Reference: <a href=\"https://arxiv.org/pdf/1508.04025.pdf\">Effective Approaches to Attention-based Neural Machine Translation</a>'s Global Attention with Dot-based scoring function (Section 3, 3.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "attention Tensor(\"attention/truediv:0\", shape=(?, 12, 19), dtype=float32)\n",
      "context Tensor(\"dot_2/MatMul:0\", shape=(?, 12, 128), dtype=float32)\n",
      "decoder_combined_context Tensor(\"concatenate_1/concat:0\", shape=(?, 12, 256), dtype=float32)\n",
      "output Tensor(\"time_distributed_2/Reshape_1:0\", shape=(?, 12, 41), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "from keras.layers import Activation, dot, concatenate\n",
    "\n",
    "# Equation (7) with 'dot' score from Section 3.1 in the paper.\n",
    "# Note that we reuse Softmax-activation layer instead of writing tensor calculation\n",
    "attention = dot([decoder, encoder], axes=[2, 2])\n",
    "attention = Activation('softmax', name='attention')(attention)\n",
    "print('attention', attention)\n",
    "\n",
    "context = dot([attention, encoder], axes=[2,1])\n",
    "print('context', context)\n",
    "\n",
    "decoder_combined_context = concatenate([context, decoder])\n",
    "print('decoder_combined_context', decoder_combined_context)\n",
    "\n",
    "# Has another weight + tanh layer as described in equation (5) of the paper\n",
    "output = TimeDistributed(Dense(HIDDEN_NODES, activation=\"tanh\"))(decoder_combined_context)\n",
    "output = TimeDistributed(Dense(output_dict_size, activation=\"softmax\"))(output)\n",
    "print('output', output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Model(inputs=[encoder_input, decoder_input], outputs=[output])\n",
    "model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_encoder_input = encoded_training_input\n",
    "training_decoder_input = np.zeros_like(encoded_training_output)\n",
    "training_decoder_input[:, 1:] = encoded_training_output[:,:-1]\n",
    "training_decoder_input[:, 0] = encoding.CHAR_CODE_START\n",
    "training_decoder_output = np.eye(output_dict_size)[encoded_training_output.astype('int')]\n",
    "\n",
    "validation_encoder_input = encoded_validation_input\n",
    "validation_decoder_input = np.zeros_like(encoded_validation_output)\n",
    "validation_decoder_input[:, 1:] = encoded_validation_output[:,:-1]\n",
    "validation_decoder_input[:, 0] = encoding.CHAR_CODE_START\n",
    "validation_decoder_output = np.eye(output_dict_size)[encoded_validation_output.astype('int')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 12899 samples, validate on 2150 samples\n",
      "Epoch 1/30\n",
      " - 15s - loss: 0.0641 - acc: 0.9809 - val_loss: 0.4048 - val_acc: 0.9055\n",
      "Epoch 2/30\n",
      " - 8s - loss: 0.0550 - acc: 0.9835 - val_loss: 0.4426 - val_acc: 0.8943\n",
      "Epoch 3/30\n",
      " - 8s - loss: 0.0506 - acc: 0.9847 - val_loss: 0.3994 - val_acc: 0.9069\n",
      "Epoch 4/30\n",
      " - 8s - loss: 0.0482 - acc: 0.9858 - val_loss: 0.4510 - val_acc: 0.8976\n",
      "Epoch 5/30\n",
      " - 8s - loss: 0.0447 - acc: 0.9870 - val_loss: 0.4232 - val_acc: 0.9053\n",
      "Epoch 6/30\n",
      " - 8s - loss: 0.0408 - acc: 0.9883 - val_loss: 0.4258 - val_acc: 0.9022\n",
      "Epoch 7/30\n",
      " - 8s - loss: 0.0398 - acc: 0.9886 - val_loss: 0.4371 - val_acc: 0.9055\n",
      "Epoch 8/30\n",
      " - 8s - loss: 0.0371 - acc: 0.9893 - val_loss: 0.4293 - val_acc: 0.9064\n",
      "Epoch 9/30\n",
      " - 8s - loss: 0.0335 - acc: 0.9906 - val_loss: 0.4285 - val_acc: 0.9080\n",
      "Epoch 10/30\n",
      " - 8s - loss: 0.0322 - acc: 0.9911 - val_loss: 0.4551 - val_acc: 0.9028\n",
      "Epoch 11/30\n",
      " - 8s - loss: 0.0306 - acc: 0.9917 - val_loss: 0.4523 - val_acc: 0.9067\n",
      "Epoch 12/30\n",
      " - 8s - loss: 0.0299 - acc: 0.9919 - val_loss: 0.4515 - val_acc: 0.9065\n",
      "Epoch 13/30\n",
      " - 8s - loss: 0.0275 - acc: 0.9926 - val_loss: 0.4447 - val_acc: 0.9072\n",
      "Epoch 14/30\n",
      " - 8s - loss: 0.0263 - acc: 0.9928 - val_loss: 0.4439 - val_acc: 0.9054\n",
      "Epoch 15/30\n",
      " - 8s - loss: 0.0252 - acc: 0.9934 - val_loss: 0.4676 - val_acc: 0.9097\n",
      "Epoch 16/30\n",
      " - 8s - loss: 0.0228 - acc: 0.9942 - val_loss: 0.4653 - val_acc: 0.9081\n",
      "Epoch 17/30\n",
      " - 8s - loss: 0.0234 - acc: 0.9943 - val_loss: 0.4810 - val_acc: 0.9063\n",
      "Epoch 18/30\n",
      " - 8s - loss: 0.0216 - acc: 0.9947 - val_loss: 0.4998 - val_acc: 0.9042\n",
      "Epoch 19/30\n",
      " - 8s - loss: 0.0207 - acc: 0.9943 - val_loss: 0.4859 - val_acc: 0.9060\n",
      "Epoch 20/30\n",
      " - 8s - loss: 0.0199 - acc: 0.9950 - val_loss: 0.4928 - val_acc: 0.9050\n",
      "Epoch 21/30\n",
      " - 8s - loss: 0.0193 - acc: 0.9949 - val_loss: 0.4869 - val_acc: 0.9092\n",
      "Epoch 22/30\n",
      " - 8s - loss: 0.0193 - acc: 0.9950 - val_loss: 0.5155 - val_acc: 0.9004\n",
      "Epoch 23/30\n",
      " - 8s - loss: 0.0180 - acc: 0.9953 - val_loss: 0.5188 - val_acc: 0.9039\n",
      "Epoch 24/30\n",
      " - 8s - loss: 0.0176 - acc: 0.9953 - val_loss: 0.5356 - val_acc: 0.9021\n",
      "Epoch 25/30\n",
      " - 8s - loss: 0.0169 - acc: 0.9957 - val_loss: 0.5169 - val_acc: 0.9049\n",
      "Epoch 26/30\n",
      " - 8s - loss: 0.0168 - acc: 0.9957 - val_loss: 0.5137 - val_acc: 0.9068\n",
      "Epoch 27/30\n",
      " - 8s - loss: 0.0167 - acc: 0.9957 - val_loss: 0.5156 - val_acc: 0.9082\n",
      "Epoch 28/30\n",
      " - 8s - loss: 0.0164 - acc: 0.9957 - val_loss: 0.5111 - val_acc: 0.9061\n",
      "Epoch 29/30\n",
      " - 8s - loss: 0.0155 - acc: 0.9959 - val_loss: 0.5178 - val_acc: 0.9104\n",
      "Epoch 30/30\n",
      " - 8s - loss: 0.0159 - acc: 0.9959 - val_loss: 0.5235 - val_acc: 0.9097\n",
      "Train on 12899 samples, validate on 2150 samples\n",
      "Epoch 1/5\n",
      " - 8s - loss: 0.0143 - acc: 0.9963 - val_loss: 0.5201 - val_acc: 0.9085\n",
      "Epoch 2/5\n",
      " - 8s - loss: 0.0139 - acc: 0.9967 - val_loss: 0.5240 - val_acc: 0.9094\n",
      "Epoch 3/5\n",
      " - 8s - loss: 0.0143 - acc: 0.9963 - val_loss: 0.5209 - val_acc: 0.9103\n",
      "Epoch 4/5\n",
      " - 8s - loss: 0.0145 - acc: 0.9962 - val_loss: 0.5641 - val_acc: 0.9019\n",
      "Epoch 5/5\n",
      " - 8s - loss: 0.0147 - acc: 0.9958 - val_loss: 0.5503 - val_acc: 0.9060\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ub05user/virt_env/lib/python3.5/site-packages/Keras-2.2.0-py3.5.egg/keras/engine/network.py:888: UserWarning: Layer lstm_2 was passed non-serializable keyword arguments: {'initial_state': [<tf.Tensor 'strided_slice:0' shape=(?, 128) dtype=float32>, <tf.Tensor 'strided_slice:0' shape=(?, 128) dtype=float32>]}. They will not be included in the serialized model (and thus will be missing at deserialization time).\n",
      "  '. They will not be included '\n"
     ]
    }
   ],
   "source": [
    "history = None\n",
    "if os.path.isfile('model.h5'):\n",
    "    model = load_model('model.h5')\n",
    "else:\n",
    "    history = model.fit(x=[training_encoder_input, training_decoder_input], y=[training_decoder_output],\n",
    "          validation_data=([validation_encoder_input, validation_decoder_input], [validation_decoder_output]),\n",
    "          verbose=2, batch_size=BATCH_SIZE, epochs=EPOCHS)\n",
    "\n",
    "model.fit(x=[training_encoder_input, training_decoder_input], y=[training_decoder_output],\n",
    "          validation_data=([validation_encoder_input, validation_decoder_input], [validation_decoder_output]),\n",
    "          verbose=2, batch_size=BATCH_SIZE, epochs=5)\n",
    "\n",
    "model.save('model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['val_loss', 'val_acc', 'acc', 'loss'])\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ub05user/virt_env/lib/python3.5/site-packages/matplotlib/font_manager.py:1328: UserWarning: findfont: Font family ['Osaka'] not found. Falling back to DejaVu Sans\n",
      "  (prop.get_family(), self.defaultFamily[fontext]))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline  \n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn\n",
    "\n",
    "print(history.history.keys())\n",
    "# summarize history for accuracy\n",
    "plt.plot(history.history['acc'])\n",
    "plt.plot(history.history['val_acc'])\n",
    "plt.title('model accuracy')\n",
    "plt.ylabel('accuracy')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='upper left')\n",
    "plt.show()\n",
    "# summarize history for loss\n",
    "plt.plot(history.history['loss'])\n",
    "plt.plot(history.history['val_loss'])\n",
    "plt.title('model loss')\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing the model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "zalameh زلمه\n",
      "m7mad محمد\n",
      "a5bark اخبارك\n",
      "7elo حلو\n",
      "kefak كيفك\n",
      "tamam تمام\n"
     ]
    }
   ],
   "source": [
    "def generate(text):\n",
    "    encoder_input = encoding.transform(input_encoding, [text.lower()], INPUT_LENGTH)\n",
    "    decoder_input = np.zeros(shape=(len(encoder_input), OUTPUT_LENGTH))\n",
    "    decoder_input[:,0] = encoding.CHAR_CODE_START\n",
    "    for i in range(1, OUTPUT_LENGTH):\n",
    "        output = model.predict([encoder_input, decoder_input]).argmax(axis=2)\n",
    "        decoder_input[:,i] = output[:,i]\n",
    "    return decoder_input[:,1:]\n",
    "\n",
    "def decode(decoding, sequence):\n",
    "    text = ''\n",
    "    for i in sequence:\n",
    "        if i == 0:\n",
    "            break\n",
    "        text += output_decoding[i]\n",
    "    return text\n",
    "\n",
    "def to_arabic(text):\n",
    "    decoder_output = generate(text)\n",
    "    return decode(output_decoding, decoder_output[0])\n",
    "\n",
    "\n",
    "common_american_names = ['zalameh', 'm7mad', 'a5bark', '7elo', 'kefak', 'tamam']\n",
    "for name in common_american_names:\n",
    "    print(name, to_arabic(name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "صلام\n",
      "بيتاربكر\n",
      "جننيدو\n"
     ]
    }
   ],
   "source": [
    "print(to_arabic('salam'))\n",
    "print(to_arabic('Peter Parker'))\n",
    "print(to_arabic('Jonny Snow'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "testing size 1000\n"
     ]
    }
   ],
   "source": [
    "testing_input = data_input[range_of_val:range_of_val+1000]\n",
    "testing_output = data_output[range_of_val:range_of_val+1000]\n",
    "print('testing size', len(testing_input))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a s d'"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\" \".join(\"asd\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 \n",
      "Accuracy= 0.594\n"
     ]
    }
   ],
   "source": [
    "ref = open(\"ref.txt\", \"w\")\n",
    "pred = open(\"pred.txt\", \"w\")\n",
    "\n",
    "import sys\n",
    "sum_of_trues=0\n",
    "\n",
    "i=0\n",
    "for s,t in zip(testing_input,testing_output):\n",
    "    sys.stdout.write(str(i)+' ')\n",
    "    ref.write(\" \".join(t)+\"\\n\")\n",
    "    i+=1\n",
    "    p = to_arabic(s)\n",
    "    pred.write(\" \".join(p)+\"\\n\")\n",
    "   # print(s,\"=>\",to_arabic(s), (to_arabic(s) == t))\n",
    "    if p == t:\n",
    "        sum_of_trues+=1\n",
    "        \n",
    "print(\"\\nAccuracy=\",sum_of_trues/(len(testing_input)))\n",
    "ref.close()\n",
    "pred.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "74.14"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from bleu import moses_multi_bleu\n",
    "ref_arr = [i.strip() for i in open(\"ref.txt\").readlines()]\n",
    "pred_arr = [i.strip() for i in open(\"pred.txt\").readlines()]\n",
    "\n",
    "moses_multi_bleu(ref_arr, pred_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualize Attention"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next step is visualizing the attention values of the medel during the translation.\n",
    "\n",
    "To do that, the first step is to locate \"attention\" layer of the model. The attention layer is the 7th layers of the model (model.layers[7]), which is the softmax activation-layer after dot-score. Or we can also simply call model.get_layer('attention') as we previously name the layer as \"attention\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<keras.engine.input_layer.InputLayer object at 0x7f09f0758b38>\tname:input_2\n",
      "<keras.engine.input_layer.InputLayer object at 0x7f09f0758e48>\tname:input_1\n",
      "<keras.layers.embeddings.Embedding object at 0x7f09efe50cf8>\tname:embedding_2\n",
      "<keras.layers.embeddings.Embedding object at 0x7f09efe50780>\tname:embedding_1\n",
      "<keras.layers.recurrent.LSTM object at 0x7f09efe55a90>\tname:lstm_2\n",
      "<keras.layers.recurrent.LSTM object at 0x7f09efe50748>\tname:lstm_1\n",
      "<keras.layers.merge.Dot object at 0x7f09ec615ef0>\tname:dot_1\n",
      "<keras.layers.core.Activation object at 0x7f09ec615f28>\tname:attention\n",
      "<keras.layers.merge.Dot object at 0x7f09ec615fd0>\tname:dot_2\n",
      "<keras.layers.merge.Concatenate object at 0x7f09ec626c50>\tname:concatenate_1\n",
      "<keras.layers.wrappers.TimeDistributed object at 0x7f09ec62bf28>\tname:time_distributed_1\n",
      "<keras.layers.wrappers.TimeDistributed object at 0x7f09ec5d17f0>\tname:time_distributed_2\n"
     ]
    }
   ],
   "source": [
    "layers = model.layers\n",
    "for l in layers:\n",
    "    print('%s\\tname:%s' % (str(l), l.name))\n",
    "    \n",
    "assert(model.layers[7] == model.get_layer('attention'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<keras.engine.training.Model object at 0x7f09e4bcab38>\n",
      "[(None, 12, 41), (None, 12, 19)]\n"
     ]
    }
   ],
   "source": [
    "attention_layer = model.get_layer('attention') # or model.layers[7]\n",
    "attention_model = Model(inputs=model.inputs, outputs=model.outputs + [attention_layer.output])\n",
    "\n",
    "print(attention_model)\n",
    "print(attention_model.output_shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline  \n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn\n",
    "\n",
    "seaborn.set(font=['Osaka'], font_scale=3)\n",
    "\n",
    "def attent_and_generate(text):\n",
    "    encoder_input = encoding.transform(input_encoding, [text.lower()], INPUT_LENGTH)\n",
    "    decoder_input = np.zeros(shape=(len(encoder_input), OUTPUT_LENGTH))\n",
    "    decoder_input[:,0] = encoding.CHAR_CODE_START\n",
    "    \n",
    "    for i in range(1, OUTPUT_LENGTH):\n",
    "        output, attention = attention_model.predict([encoder_input, decoder_input])\n",
    "        decoder_input[:,i] = output.argmax(axis=2)[:,i]\n",
    "        attention_density = attention[0]\n",
    "        decoded_output = decode(output_decoding, decoder_input[0][1:])\n",
    "        \n",
    "    return attention_density, decoded_output\n",
    "\n",
    "\n",
    "def visualize(text):\n",
    "    attention_density, arabic = attent_and_generate(text)\n",
    "\n",
    "    plt.clf()\n",
    "    plt.figure(figsize=(28,12))\n",
    "    \n",
    "    ax = seaborn.heatmap(attention_density[:len(arabic) , : len(text) ],\n",
    "        xticklabels=[w for w in text],\n",
    "        yticklabels=[w for w in arabic])\n",
    "\n",
    "    ax.invert_yaxis()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ub05user/virt_env/lib/python3.5/site-packages/matplotlib/font_manager.py:1328: UserWarning: findfont: Font family ['Osaka'] not found. Falling back to DejaVu Sans\n",
      "  (prop.get_family(), self.defaultFamily[fontext]))\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2016x864 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "visualize('kefak')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Tensorflow_Last",
   "language": "python",
   "name": "tensorflow_last"
  },
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}