text2log_exp.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "\n",
    "class Config:\n",
    "\n",
    "    PROJECT_DIR = os.environ[\"PWD\"]\n",
    "    DATA_DIR = os.getenv(\"DATA_DIR\", \"dat/\")\n",
    "    RESULTS_DIR = os.getenv(\"RESULTS_DIR\", \"results/\")\n",
    "    MODELS_DIR = os.getenv(\"MODELS_DIR\", \"models/\")\n",
    "    CHECKPOINT_DIR = os.getenv(\"CHECKPOINT_DIR\", \"models/checkpoint/\")\n",
    "    LOGS_DIR = os.getenv(\"LOGS_DIR\", \"logs/\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_stats(X, y, num_s, num_e, ratio):\n",
    "    print('Stats:')\n",
    "    print(\"------------------------\")\n",
    "    print(\"------------------------\")\n",
    "    print(f'N(X) == N(y) == {len(y)}')\n",
    "    print(f'errs: {num_e}')\n",
    "    print(f'Clean data (N = {num_s}) ratio: {ratio}%')\n",
    "    print(\"------------------------\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "config = Config()\n",
    "\n",
    "X_train_dir = f\"{config.DATA_DIR}clean/\"\n",
    "y_train_dir = f\"{config.DATA_DIR}trans/\"\n",
    "X_test_dir = f\"{config.DATA_DIR}test/\"\n",
    "\n",
    "# Will notify if these values change\n",
    "max_encoder_seq_length = 81\n",
    "max_decoder_seq_length = 162"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import string\n",
    "\n",
    "table = str.maketrans(dict.fromkeys(string.punctuation))\n",
    "\n",
    "# All of the characters and substring that would mark lines in the training data as \"faulty\"\n",
    "invalid_chars = set(\n",
    "    [\n",
    "        \":\",\n",
    "        \"+\",\n",
    "        \"#\",\n",
    "        \"@\",\n",
    "        \"Ö\",\n",
    "        \"á\",\n",
    "        \"ä\",\n",
    "        \"é\",\n",
    "        \"í\",\n",
    "        \"ñ\",\n",
    "        \"ó\",\n",
    "        \"ö\",\n",
    "        \"ú\",\n",
    "        \"ā\",\n",
    "        \"Ć\",\n",
    "        \"ć\",\n",
    "        \"ʻ\",\n",
    "        \"́\",\n",
    "        \"е\",\n",
    "        \"н\",\n",
    "        \"о\",\n",
    "        \"п\",\n",
    "        \"у\",\n",
    "        \"ш\",\n",
    "        \"ã\",\n",
    "        \"ï\",\n",
    "        \"ō\",\n",
    "        \"ū\",\n",
    "        \"ί\",\n",
    "        \"α\",\n",
    "        \"δ\",\n",
    "        \"ε\",\n",
    "        \"κ\",\n",
    "        \"ο\",\n",
    "        \"в\",\n",
    "        \"ὐ\",\n",
    "        chr(776),\n",
    "        \"ç\",\n",
    "        \"ē\",\n",
    "        \"D\",\n",
    "        \"O\",\n",
    "        \"T\",\n",
    "    ]\n",
    ")\n",
    "invalid_chars_X = set([\"(\", \")\", \"<\", \">\", \"_\", \",\"])\n",
    "invalid_markers = set([\"\\\\F\", \"TrueP\", \"\\\\x\", \"semantics_error\", \"Prog(\"])\n",
    "files_with_compound_preds = [20, 21, 15]\n",
    "\n",
    "\n",
    "def mark_if_faulty(line, file_idx, X=False):\n",
    "    if X and (\n",
    "        any((c in invalid_chars) for c in line)\n",
    "        or any((c in invalid_chars_X) for c in line)\n",
    "    ):\n",
    "        return \"syntax_error\"\n",
    "    # TODO: Refactor this hacky workaround\n",
    "    if line[0] == \"(\" and file_idx not in files_with_compound_preds:\n",
    "        return \"syntax_error\"\n",
    "    if any((m in line) for m in invalid_markers) or any(\n",
    "        (c in invalid_chars) for c in line\n",
    "    ):\n",
    "        return \"syntax_error\"\n",
    "    # Remove top-level parentheses from lambda expression\n",
    "    if line[0:4] == \"(exi\" and line[-1] == \")\":\n",
    "        line = line[1:-1]\n",
    "    if line[0:4] == \"(all\" and line[-1] == \")\":\n",
    "        line = line[1:-1]\n",
    "\n",
    "    return line\n",
    "\n",
    "\n",
    "def lines_from_file(direc, name, drop_punc=False, lower=True, drop_fullstop=True):\n",
    "    with open(direc + name) as f:\n",
    "        for l in f:\n",
    "            l = l.rstrip()\n",
    "            if drop_punc:\n",
    "                l = l.translate(table)\n",
    "            if lower:\n",
    "                l = l.lower()\n",
    "            if drop_fullstop and not drop_punc:\n",
    "                l = l[0:-1]\n",
    "            yield l\n",
    "\n",
    "\n",
    "def load_and_clean_data(start_idx=1, end_idx=17, skip_idx_list=None):\n",
    "    X, y = [], []\n",
    "\n",
    "    err = lambda x: x == \"syntax_error\"\n",
    "    X_name = lambda i: f\"concordance_{i}_clean.txt\"\n",
    "    y_name = lambda i: f\"concordance_{i}_clean.lam\"\n",
    "\n",
    "    # Load lines from files and mark those that are \"faulty\"\n",
    "    for i in range(start_idx, end_idx + 1):\n",
    "        if i in skip_idx_list:\n",
    "            continue\n",
    "\n",
    "        X = X + [\n",
    "            mark_if_faulty(line, i, True)\n",
    "            for line in lines_from_file(X_train_dir, X_name(i), drop_fullstop=True)\n",
    "        ]\n",
    "        y = y + [\n",
    "            mark_if_faulty(line, i)\n",
    "            for line in lines_from_file(\n",
    "                y_train_dir, y_name(i), lower=False, drop_fullstop=False\n",
    "            )\n",
    "        ]\n",
    "\n",
    "    # Save \"faulty\" line indices\n",
    "    err_idx_X = [i1 for i1 in range(len(X)) if err(X[i1])]\n",
    "    err_idx_y = [j1 for j1 in range(len(X)) if err(y[j1])]\n",
    "\n",
    "    err_idx = set(err_idx_X).union(set(err_idx_y))\n",
    "    num_err = len(err_idx)\n",
    "    num_samples = len(y) - num_err\n",
    "    clean_ratio = 100 - ((num_err / len(y)) * 100)\n",
    "\n",
    "    # Show stats about training data\n",
    "    print_stats(X, y, num_samples, num_err, clean_ratio)\n",
    "\n",
    "    # Remove \"faulty\" lines\n",
    "    for index in sorted(list(err_idx), reverse=True):\n",
    "        del X[index]\n",
    "        del y[index]\n",
    "\n",
    "    return (X, y)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stats:\n",
      "------------------------\n",
      "------------------------\n",
      "N(X) == N(y) == 103847\n",
      "errs: 10599\n",
      "Clean data (N = 93248) ratio: 89.79363871849932%\n",
      "------------------------\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    *load_and_clean_data(1, 23, [8, 6]), test_size=0.25, random_state=4, shuffle=True\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of samples: 69936\n",
      "Number of unique input tokens: 39\n",
      "Number of unique output tokens: 50\n",
      "['\\t', '\\n', ' ', '&', \"'\", '(', ')', ',', '-', '.', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '=', '>', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '|']\n"
     ]
    }
   ],
   "source": [
    "# Vectorize the data.\n",
    "input_characters = set()\n",
    "target_characters = set()\n",
    "\n",
    "for i in range(0, len(X_train)):\n",
    "    # SOS == '\\n'\n",
    "    # EOS == '\\t'\n",
    "    y_train[i] = \"\\t\" + y_train[i] + \"\\n\"\n",
    "\n",
    "    for char in X_train[i]:\n",
    "        if char not in input_characters:\n",
    "            input_characters.add(char)\n",
    "    for char in y_train[i]:\n",
    "        if char not in target_characters:\n",
    "            target_characters.add(char)\n",
    "\n",
    "input_characters = sorted(list(input_characters))\n",
    "target_characters = sorted(list(target_characters))\n",
    "num_encoder_tokens = len(input_characters)\n",
    "num_decoder_tokens = len(target_characters)\n",
    "max_X_len = max([len(txt) for txt in X_train])\n",
    "max_y_len = max([len(txt) for txt in y_train])\n",
    "\n",
    "print(\"Number of samples:\", len(X_train))\n",
    "print(\"Number of unique input tokens:\", num_encoder_tokens)\n",
    "print(\"Number of unique output tokens:\", num_decoder_tokens)\n",
    "\n",
    "if max_X_len > max_encoder_seq_length:\n",
    "    print(\"WARNING: NEW Max sequence length for inputs:\", max_X_len)\n",
    "    print(\"Dataset may be incompatible with older models.\")\n",
    "    max_encoder_seq_length = max_X_len\n",
    "\n",
    "if max_y_len > max_decoder_seq_length:\n",
    "    print(\"WARNING: NEW Max sequence length for outputs:\", max_y_len)\n",
    "    print(\"Dataset may be incompatible with older models.\")\n",
    "    max_decoder_seq_length = max_y_len\n",
    "\n",
    "print(target_characters)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# char to index\n",
    "input_token_index = dict([(char, i) for i, char in enumerate(input_characters)])\n",
    "target_token_index = dict([(char, i) for i, char in enumerate(target_characters)])\n",
    "\n",
    "encoder_input_data = np.zeros(\n",
    "    (len(X_train), max_encoder_seq_length, num_encoder_tokens), dtype=\"float32\"\n",
    ")\n",
    "decoder_input_data = np.zeros(\n",
    "    (len(X_train), max_decoder_seq_length, num_decoder_tokens), dtype=\"float32\"\n",
    ")\n",
    "decoder_target_data = np.zeros(\n",
    "    (len(X_train), max_decoder_seq_length, num_decoder_tokens), dtype=\"float32\"\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., ..., 0., 0., 0.],\n",
       "       [0., 0., 0., ..., 0., 0., 0.],\n",
       "       [0., 0., 0., ..., 0., 0., 0.],\n",
       "       ...,\n",
       "       [1., 0., 0., ..., 0., 0., 0.],\n",
       "       [1., 0., 0., ..., 0., 0., 0.],\n",
       "       [1., 0., 0., ..., 0., 0., 0.]], dtype=float32)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "np.set_printoptions(threshold=10)\n",
    "\n",
    "for i, (input_text, target_text) in enumerate(zip(X_train, y_train)):\n",
    "    for t, char in enumerate(input_text):\n",
    "        encoder_input_data[i, t, input_token_index[char]] = 1.0\n",
    "    encoder_input_data[i, t + 1 :, input_token_index[\" \"]] = 1.0\n",
    "    for t, char in enumerate(target_text):\n",
    "        # decoder_target_data is ahead of decoder_input_data by one timestep\n",
    "        decoder_input_data[i, t, target_token_index[char]] = 1.0\n",
    "        if t > 0:\n",
    "            # decoder_target_data will be ahead by one timestep\n",
    "            # and will not include the start character.\n",
    "            decoder_target_data[i, t - 1, target_token_index[char]] = 1.0\n",
    "    decoder_input_data[i, t + 1 :, target_token_index[\" \"]] = 1.0\n",
    "    decoder_target_data[i, t:, target_token_index[\" \"]] = 1.0\n",
    "\n",
    "encoder_input_data[0]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Write Test Data (Optional)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import datetime\n",
    "\n",
    "# with open(X_test_dir + f\"{datetime.datetime()}_X_test.txt\", 'w+') as f:\n",
    "#     for line in X_test:\n",
    "#         f.write(f\"{line}\\n\")\n",
    "        \n",
    "# with open(X_test_dir + f\"{datetime.datetime()}_y_test.txt\", 'w+') as f:\n",
    "#     for line in y_test:\n",
    "#         f.write(f\"{line}\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ML Pipeline Set-up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from tensorflow.keras.layers import Layer\n",
    "from tensorflow.keras import backend as K\n",
    "\n",
    "\n",
    "class AttentionLayer(Layer):\n",
    "    \"\"\"\n",
    "    This class implements Bahdanau attention (https://arxiv.org/pdf/1409.0473.pdf).\n",
    "    There are three sets of weights introduced W_a, U_a, and V_a\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, **kwargs):\n",
    "        super(AttentionLayer, self).__init__(**kwargs)\n",
    "\n",
    "    def build(self, input_shape):\n",
    "        assert isinstance(input_shape, list)\n",
    "        # Create a trainable weight variable for this layer.\n",
    "\n",
    "        self.W_a = self.add_weight(\n",
    "            name=\"W_a\",\n",
    "            shape=tf.TensorShape((input_shape[0][2], input_shape[0][2])),\n",
    "            initializer=\"uniform\",\n",
    "            trainable=True,\n",
    "        )\n",
    "        self.U_a = self.add_weight(\n",
    "            name=\"U_a\",\n",
    "            shape=tf.TensorShape((input_shape[1][2], input_shape[0][2])),\n",
    "            initializer=\"uniform\",\n",
    "            trainable=True,\n",
    "        )\n",
    "        self.V_a = self.add_weight(\n",
    "            name=\"V_a\",\n",
    "            shape=tf.TensorShape((input_shape[0][2], 1)),\n",
    "            initializer=\"uniform\",\n",
    "            trainable=True,\n",
    "        )\n",
    "\n",
    "        super(AttentionLayer, self).build(\n",
    "            input_shape\n",
    "        )  # Be sure to call this at the end\n",
    "\n",
    "    def call(self, inputs, verbose=False):\n",
    "        \"\"\"\n",
    "        inputs: [encoder_output_sequence, decoder_output_sequence]\n",
    "        \"\"\"\n",
    "        assert type(inputs) == list\n",
    "        encoder_out_seq, decoder_out_seq = inputs\n",
    "        if verbose:\n",
    "            print(\"encoder_out_seq>\", encoder_out_seq.shape)\n",
    "            print(\"decoder_out_seq>\", decoder_out_seq.shape)\n",
    "\n",
    "        def energy_step(inputs, states):\n",
    "            \"\"\"Step function for computing energy for a single decoder state\n",
    "            inputs: (batchsize * 1 * de_in_dim)\n",
    "            states: (batchsize * 1 * de_latent_dim)\n",
    "            \"\"\"\n",
    "\n",
    "            assert_msg = \"States must be an iterable. Got {} of type {}\".format(\n",
    "                states, type(states)\n",
    "            )\n",
    "            assert isinstance(states, list) or isinstance(states, tuple), assert_msg\n",
    "\n",
    "            \"\"\" Some parameters required for shaping tensors\"\"\"\n",
    "            en_seq_len, en_hidden = encoder_out_seq.shape[1], encoder_out_seq.shape[2]\n",
    "            de_hidden = inputs.shape[-1]\n",
    "\n",
    "            \"\"\" Computing S.Wa where S=[s0, s1, ..., si]\"\"\"\n",
    "            # <= batch size * en_seq_len * latent_dim\n",
    "            W_a_dot_s = K.dot(encoder_out_seq, self.W_a)\n",
    "\n",
    "            \"\"\" Computing hj.Ua \"\"\"\n",
    "            U_a_dot_h = K.expand_dims(\n",
    "                K.dot(inputs, self.U_a), 1\n",
    "            )  # <= batch_size, 1, latent_dim\n",
    "            if verbose:\n",
    "                print(\"Ua.h>\", U_a_dot_h.shape)\n",
    "\n",
    "            \"\"\" tanh(S.Wa + hj.Ua) \"\"\"\n",
    "            # <= batch_size*en_seq_len, latent_dim\n",
    "            Ws_plus_Uh = K.tanh(W_a_dot_s + U_a_dot_h)\n",
    "            if verbose:\n",
    "                print(\"Ws+Uh>\", Ws_plus_Uh.shape)\n",
    "\n",
    "            \"\"\" softmax(va.tanh(S.Wa + hj.Ua)) \"\"\"\n",
    "            # <= batch_size, en_seq_len\n",
    "            e_i = K.squeeze(K.dot(Ws_plus_Uh, self.V_a), axis=-1)\n",
    "            # <= batch_size, en_seq_len\n",
    "            e_i = K.softmax(e_i)\n",
    "\n",
    "            if verbose:\n",
    "                print(\"ei>\", e_i.shape)\n",
    "\n",
    "            return e_i, [e_i]\n",
    "\n",
    "        def context_step(inputs, states):\n",
    "            \"\"\" Step function for computing ci using ei \"\"\"\n",
    "\n",
    "            assert_msg = \"States must be an iterable. Got {} of type {}\".format(\n",
    "                states, type(states)\n",
    "            )\n",
    "            assert isinstance(states, list) or isinstance(states, tuple), assert_msg\n",
    "\n",
    "            # <= batch_size, hidden_size\n",
    "            c_i = K.sum(encoder_out_seq * K.expand_dims(inputs, -1), axis=1)\n",
    "            if verbose:\n",
    "                print(\"ci>\", c_i.shape)\n",
    "            return c_i, [c_i]\n",
    "\n",
    "        fake_state_c = K.sum(encoder_out_seq, axis=1)\n",
    "        fake_state_e = K.sum(\n",
    "            encoder_out_seq, axis=2\n",
    "        )  # <= (batch_size, enc_seq_len, latent_dim\n",
    "\n",
    "        \"\"\" Computing energy outputs \"\"\"\n",
    "        # e_outputs => (batch_size, de_seq_len, en_seq_len)\n",
    "        last_out, e_outputs, _ = K.rnn(\n",
    "            energy_step,\n",
    "            decoder_out_seq,\n",
    "            [fake_state_e],\n",
    "        )\n",
    "\n",
    "        \"\"\" Computing context vectors \"\"\"\n",
    "        last_out, c_outputs, _ = K.rnn(\n",
    "            context_step,\n",
    "            e_outputs,\n",
    "            [fake_state_c],\n",
    "        )\n",
    "\n",
    "        return c_outputs, e_outputs\n",
    "\n",
    "    def compute_output_shape(self, input_shape):\n",
    "        \"\"\" Outputs produced by the layer \"\"\"\n",
    "        return [\n",
    "            tf.TensorShape((input_shape[1][0], input_shape[1][1], input_shape[1][2])),\n",
    "            tf.TensorShape((input_shape[1][0], input_shape[1][1], input_shape[0][1])),\n",
    "        ]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.layers import (\n",
    "    Input,\n",
    "    LSTM,\n",
    "    GRU,\n",
    "    Dense,\n",
    "    Concatenate,\n",
    "    TimeDistributed,\n",
    "    Bidirectional,\n",
    ")\n",
    "from tensorflow.keras.models import Model, Sequential\n",
    "from tensorflow.keras.regularizers import L1L2\n",
    "from tensorflow.keras.optimizers.schedules import ExponentialDecay\n",
    "from tensorflow.keras.optimizers import SGD, Adam, RMSprop\n",
    "from tensorflow.keras.callbacks import EarlyStopping, TensorBoard, ModelCheckpoint\n",
    "from tensorflow.keras.preprocessing.text import Tokenizer\n",
    "from livelossplot import PlotLossesKeras\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model Architecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vanilla LSTM (Sutskever et al.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "latent_dim = 256\n",
    "batch_size = 64  # Batch size for training.\n",
    "epochs = 300  # Number of epochs to train for.\n",
    "simple_name = \"lstm\"\n",
    "\n",
    "# Define an input sequence and process it.\n",
    "encoder_inputs = Input(shape=(None, num_encoder_tokens))\n",
    "encoder_lstm = LSTM(\n",
    "    latent_dim, recurrent_dropout=0.1, return_state=True, name=\"encoder\"\n",
    ")\n",
    "encoder_outputs, state_h, state_c = encoder_lstm(encoder_inputs)\n",
    "# We discard `encoder_outputs` and only keep the states.\n",
    "encoder_states = [state_h, state_c]\n",
    "\n",
    "# Set up the decoder, using `encoder_states` as initial state.\n",
    "decoder_inputs = Input(shape=(None, num_decoder_tokens))\n",
    "# We set up our decoder to return full output sequences,\n",
    "# and to return internal states as well. We don't use the\n",
    "# return states in the training model, but we will use them in inference.\n",
    "decoder_lstm = LSTM(\n",
    "    latent_dim,\n",
    "    recurrent_dropout=0.1,\n",
    "    return_sequences=True,\n",
    "    return_state=True,\n",
    "    name=\"decoder\",\n",
    ")\n",
    "decoder_outputs, _, _ = decoder_lstm(decoder_inputs, initial_state=encoder_states)\n",
    "decoder_dense = Dense(num_decoder_tokens, activation=\"softmax\")\n",
    "decoder_pred = decoder_dense(decoder_outputs)\n",
    "\n",
    "# Define the model that will turn\n",
    "# `encoder_input_data` & `decoder_input_data` into `decoder_target_data`\n",
    "full_model = Model(inputs=[encoder_inputs, decoder_inputs], outputs=decoder_pred)\n",
    "\n",
    "full_model.compile(\n",
    "    optimizer=\"rmsprop\", loss=\"categorical_crossentropy\", metrics=[\"accuracy\"]\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple GRU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "latent_dim = 96\n",
    "batch_size = 64  # Batch size for training.\n",
    "epochs = 300  # Number of epochs to train for.\n",
    "\n",
    "# Define an input sequence and process it.\n",
    "encoder_inputs = Input(shape=(None, num_encoder_tokens))\n",
    "encoder = GRU(latent_dim, recurrent_dropout=0.333, return_state=True, name=\"encoder\")\n",
    "encoder_outputs, encoder_state = encoder(encoder_inputs)\n",
    "\n",
    "# Set up the decoder, using `encoder_states` as initial state.\n",
    "decoder_inputs = Input(shape=(None, num_decoder_tokens))\n",
    "# We set up our decoder to return full output sequences,\n",
    "# and to return internal states as well. We don't use the\n",
    "# return states in the training model, but we will use them in inference.\n",
    "decoder_gru = GRU(\n",
    "    latent_dim,\n",
    "    recurrent_dropout=0.2,\n",
    "    return_sequences=True,\n",
    "    return_state=True,\n",
    "    name=\"decoder\",\n",
    ")\n",
    "decoder_outputs, _ = decoder_gru(decoder_inputs, initial_state=encoder_state)\n",
    "decoder_dense = Dense(num_decoder_tokens, activation=\"softmax\")\n",
    "decoder_pred = decoder_dense(decoder_outputs)\n",
    "\n",
    "early_stop = EarlyStopping(patience=3, monitor=\"val_loss\")\n",
    "\n",
    "# Define the model that will turn\n",
    "# `encoder_input_data` & `decoder_input_data` into `decoder_target_data`\n",
    "full_model = Model(inputs=[encoder_inputs, decoder_inputs], outputs=decoder_pred)\n",
    "\n",
    "full_model.compile(\n",
    "    optimizer=\"rmsprop\", loss=\"categorical_crossentropy\", metrics=[\"accuracy\"]\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bidirectional GRU + Attention"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "latent_dim = 48\n",
    "batch_size = 64  # Batch size for training.\n",
    "epochs = 30  # Number of epochs to train for.\n",
    "recurrent_dropout_rate = 0.2\n",
    "dropout_rate = 0.5\n",
    "simple_name = \"bigru\"\n",
    "\n",
    "# Define an input sequence and process it.\n",
    "encoder_inputs = Input(shape=(None, num_encoder_tokens))\n",
    "decoder_inputs = Input(shape=(None, num_decoder_tokens))\n",
    "\n",
    "# Encoder GRU\n",
    "encoder_gru = Bidirectional(\n",
    "    GRU(\n",
    "        latent_dim,\n",
    "        return_sequences=True,\n",
    "        return_state=True,\n",
    "        name=\"encoder_gru\",\n",
    "        recurrent_dropout=recurrent_dropout_rate,\n",
    "    ),\n",
    "    name=\"bidirectional_encoder\",\n",
    ")\n",
    "encoder_out, encoder_fwd_state, encoder_back_state = encoder_gru(encoder_inputs)\n",
    "\n",
    "# Set up the decoder GRU, using `encoder_states` as initial state.\n",
    "decoder_gru = GRU(\n",
    "    latent_dim * 2,\n",
    "    return_sequences=True,\n",
    "    return_state=True,\n",
    "    name=\"decoder_gru\",\n",
    "    recurrent_dropout=recurrent_dropout_rate,\n",
    ")\n",
    "decoder_out, decoder_state = decoder_gru(\n",
    "    decoder_inputs,\n",
    "    initial_state=Concatenate(axis=-1)([encoder_fwd_state, encoder_back_state]),\n",
    ")\n",
    "\n",
    "# Attention layer\n",
    "attn_layer = AttentionLayer(name=\"attention_layer\")\n",
    "attn_out, attn_states = attn_layer([encoder_out, decoder_out])\n",
    "\n",
    "# Concat attention input and decoder GRU output\n",
    "decoder_concat_input = Concatenate(axis=-1, name=\"concat_layer\")(\n",
    "    [decoder_out, attn_out]\n",
    ")\n",
    "\n",
    "# Dense layer\n",
    "dense = Dense(num_decoder_tokens, activation=\"softmax\", name=\"softmax_layer\")\n",
    "decoder_pred = dense(decoder_concat_input)\n",
    "\n",
    "# Optimizer\n",
    "\n",
    "# opt = Adam(\n",
    "#     learning_rate=0.001,\n",
    "#     beta_1=0.9,\n",
    "#     beta_2=0.999,\n",
    "#     epsilon=1e-07,\n",
    "#     amsgrad=True,\n",
    "#     name='Adam'\n",
    "# )\n",
    "\n",
    "opt = tf.keras.optimizers.RMSprop(\n",
    "    learning_rate=0.0015,\n",
    "    rho=0.9,\n",
    "    momentum=0.0,\n",
    "    epsilon=1e-07,\n",
    "    centered=True,\n",
    "    name=\"RMSprop\",\n",
    ")\n",
    "\n",
    "# Full model\n",
    "full_model = Model(inputs=[encoder_inputs, decoder_inputs], outputs=decoder_pred)\n",
    "full_model.compile(optimizer=opt, loss=\"categorical_crossentropy\", metrics=[\"accuracy\"])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bidirectional LSTM + Attention"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "latent_dim = 44\n",
    "batch_size = 48  # Batch size for training.\n",
    "epochs = 30  # Number of epochs to train for.\n",
    "recurrent_dropout_rate = 0.2\n",
    "simple_name = \"bilstm\"\n",
    "\n",
    "# Define an input sequence and process it.\n",
    "encoder_inputs = Input(shape=(None, num_encoder_tokens))\n",
    "decoder_inputs = Input(shape=(None, num_decoder_tokens))\n",
    "\n",
    "# Encoder LSTM\n",
    "encoder_lstm = Bidirectional(\n",
    "    LSTM(\n",
    "        latent_dim,\n",
    "        return_sequences=True,\n",
    "        return_state=True,\n",
    "        name=\"encoder_lstm\",\n",
    "        recurrent_dropout=recurrent_dropout_rate,\n",
    "    ),\n",
    "    name=\"bidirectional_encoder\",\n",
    ")\n",
    "(\n",
    "    encoder_out,\n",
    "    encoder_fwd_state_h,\n",
    "    encoder_fwd_state_c,\n",
    "    encoder_back_state_h,\n",
    "    encoder_back_state_c,\n",
    ") = encoder_lstm(encoder_inputs)\n",
    "\n",
    "# Set up the decoder, using `encoder_states` as initial state.\n",
    "decoder_inputs = Input(shape=(None, num_decoder_tokens))\n",
    "# We set up our decoder to return full output sequences,\n",
    "# and to return internal states as well. We don't use the\n",
    "# return states in the training model, but we will use them in inference.\n",
    "decoder_lstm = LSTM(\n",
    "    latent_dim * 2,\n",
    "    return_sequences=True,\n",
    "    return_state=True,\n",
    "    recurrent_dropout=recurrent_dropout_rate,\n",
    "    name=\"decoder_lstm\",\n",
    ")\n",
    "decoder_out, _, _ = decoder_lstm(\n",
    "    decoder_inputs,\n",
    "    initial_state=[\n",
    "        Concatenate(axis=-1)([encoder_fwd_state_h, encoder_back_state_h]),\n",
    "        Concatenate(axis=-1)([encoder_fwd_state_c, encoder_back_state_c]),\n",
    "    ],\n",
    ")\n",
    "\n",
    "# Attention layer\n",
    "attn_layer = AttentionLayer(name=\"attention_layer\")\n",
    "attn_out, attn_states = attn_layer([encoder_out, decoder_out])\n",
    "\n",
    "# Concat attention input and decoder LSTM output\n",
    "decoder_concat_input = Concatenate(axis=-1, name=\"concat_layer\")(\n",
    "    [decoder_out, attn_out]\n",
    ")\n",
    "\n",
    "# Dense layer\n",
    "dense = Dense(num_decoder_tokens, activation=\"softmax\", name=\"softmax_layer\")\n",
    "decoder_pred = dense(decoder_concat_input)\n",
    "\n",
    "# Optimizer\n",
    "\n",
    "# opt = Adam(\n",
    "#     learning_rate=0.001,\n",
    "#     beta_1=0.9,\n",
    "#     beta_2=0.999,\n",
    "#     epsilon=1e-07,\n",
    "#     amsgrad=True,\n",
    "#     name=\"Adam\",\n",
    "# )\n",
    "\n",
    "opt = tf.keras.optimizers.RMSprop(\n",
    "    learning_rate=0.0015,\n",
    "    rho=0.9,\n",
    "    momentum=0.0,\n",
    "    epsilon=1e-07,\n",
    "    centered=True,\n",
    "    name=\"RMSprop\",\n",
    ")\n",
    "\n",
    "# Full model\n",
    "full_model = Model(inputs=[encoder_inputs, decoder_inputs], outputs=decoder_pred)\n",
    "full_model.compile(optimizer=opt, loss=\"categorical_crossentropy\", metrics=[\"accuracy\"])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "__________________________________________________________________________________________________\n",
      "Layer (type)                    Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      "input_4 (InputLayer)            [(None, None, 39)]   0                                            \n",
      "__________________________________________________________________________________________________\n",
      "bidirectional_encoder (Bidirect [(None, None, 88), ( 29568       input_4[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "input_6 (InputLayer)            [(None, None, 50)]   0                                            \n",
      "__________________________________________________________________________________________________\n",
      "concatenate_2 (Concatenate)     (None, 88)           0           bidirectional_encoder[0][1]      \n",
      "                                                                 bidirectional_encoder[0][3]      \n",
      "__________________________________________________________________________________________________\n",
      "concatenate_3 (Concatenate)     (None, 88)           0           bidirectional_encoder[0][2]      \n",
      "                                                                 bidirectional_encoder[0][4]      \n",
      "__________________________________________________________________________________________________\n",
      "decoder_lstm (LSTM)             [(None, None, 88), ( 48928       input_6[0][0]                    \n",
      "                                                                 concatenate_2[0][0]              \n",
      "                                                                 concatenate_3[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "attention_layer (AttentionLayer ((None, None, 88), ( 15576       bidirectional_encoder[0][0]      \n",
      "                                                                 decoder_lstm[0][0]               \n",
      "__________________________________________________________________________________________________\n",
      "concat_layer (Concatenate)      (None, None, 176)    0           decoder_lstm[0][0]               \n",
      "                                                                 attention_layer[0][0]            \n",
      "__________________________________________________________________________________________________\n",
      "softmax_layer (Dense)           (None, None, 50)     8850        concat_layer[0][0]               \n",
      "==================================================================================================\n",
      "Total params: 102,922\n",
      "Trainable params: 102,922\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "full_model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "\n",
    "\n",
    "log_dir = \"logs/fit/\" + datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",
    "cp_path = f\"{config.CHECKPOINT_DIR}weights-{simple_name}-N({len(X_train)})-{latent_dim}.best.hdf5\"\n",
    "\n",
    "# Load weights, if any from previous run\n",
    "full_model.load_weights(cp_path)\n",
    "\n",
    "# Callbacks\n",
    "tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)\n",
    "early_stop = EarlyStopping(patience=2, monitor=\"val_loss\", mode=\"min\", verbose=1)\n",
    "plot_loss = PlotLossesKeras()\n",
    "checkpoint = ModelCheckpoint(\n",
    "    cp_path, save_weights_only=True, verbose=1, monitor=\"val_loss\", save_best_only=True\n",
    ")\n",
    "\n",
    "# Start Training\n",
    "history = full_model.fit(\n",
    "    [encoder_input_data, decoder_input_data],\n",
    "    decoder_target_data,\n",
    "    batch_size=batch_size,\n",
    "    epochs=epochs,\n",
    "    validation_split=0.1,\n",
    "    shuffle=True,\n",
    "    callbacks=[early_stop, plot_loss, checkpoint],\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext tensorboard\n",
    "%tensorboard --logdir logs/fit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(history.history.keys())\n",
    "# summarize history for accuracy\n",
    "plt.figure(figsize=(12, 8))\n",
    "plt.plot(history.history['accuracy'])\n",
    "plt.plot(history.history['val_accuracy'])\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.figure(figsize=(12, 8))\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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "full_model.save(f\"{config.MODELS_DIR}{simple_name}-N({len(X_train)})-{latent_dim}.best.h5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set-up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reverse-lookup token index to decode sequences back to\n",
    "# something readable.\n",
    "reverse_input_char_index = dict(\n",
    "    (i, char) for char, i in input_token_index.items())\n",
    "reverse_target_char_index = dict(\n",
    "    (i, char) for char, i in target_token_index.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decode_sequence_bigru_attn(\n",
    "    encoder_model, decoder_model, test_X_seq, num_encoder_tokens, num_decoder_tokens\n",
    "):\n",
    "    \"\"\"\n",
    "    Infer logic\n",
    "    :param encoder_model: keras.Model\n",
    "    :param decoder_model: keras.Model\n",
    "    :param test_X_seq: sequence of word ids\n",
    "    :param num_encoder_tokens: int\n",
    "    :param num_decoder_tokens: int\n",
    "    :return:\n",
    "    \"\"\"\n",
    "\n",
    "    # Generate empty target sequence of length 1.\n",
    "    target_seq = np.zeros((1, 1, num_decoder_tokens))\n",
    "    # Populate the first character of target sequence with the start character.\n",
    "    target_seq[0, 0, target_token_index[\"\\t\"]] = 1.0\n",
    "\n",
    "    enc_outs, enc_fwd_state, enc_back_state = encoder_model.predict(test_X_seq)\n",
    "    dec_state = np.concatenate([enc_fwd_state, enc_back_state], axis=-1)\n",
    "\n",
    "    attention_weights = []\n",
    "    stop_condition = False\n",
    "    decoded_sentence = \"\"\n",
    "    while not stop_condition:\n",
    "        dec_out, attention, dec_state = decoder_model.predict(\n",
    "            [enc_outs, dec_state, target_seq]\n",
    "        )\n",
    "\n",
    "        # Sample a token\n",
    "        sampled_token_index = np.argmax(dec_out, axis=-1)[0, 0]\n",
    "        sampled_char = reverse_target_char_index[sampled_token_index]\n",
    "        decoded_sentence += sampled_char\n",
    "\n",
    "        # Exit condition: either hit max length\n",
    "        # or find stop character.\n",
    "        if sampled_char == \"\\n\" or len(decoded_sentence) > max_decoder_seq_length:\n",
    "            stop_condition = True\n",
    "\n",
    "        # Update the target sequence (of length 1).\n",
    "        target_seq = np.zeros((1, 1, num_decoder_tokens))\n",
    "        target_seq[0, 0, sampled_token_index] = 1.0\n",
    "\n",
    "        attention_weights.append((sampled_token_index, attention))\n",
    "\n",
    "    return decoded_sentence, attention_weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decode_sequence_bilstm_attn(\n",
    "    encoder_model, decoder_model, test_X_seq, num_encoder_tokens, num_decoder_tokens\n",
    "):\n",
    "    # Generate empty target sequence of length 1.\n",
    "    target_seq = np.zeros((1, 1, num_decoder_tokens))\n",
    "    # Populate the first character of target sequence with the start character.\n",
    "    target_seq[0, 0, target_token_index[\"\\t\"]] = 1.0\n",
    "\n",
    "    (\n",
    "        enc_outs,\n",
    "        enc_fwd_state_h,\n",
    "        enc_fwd_state_c,\n",
    "        enc_back_state_h,\n",
    "        enc_back_state_c,\n",
    "    ) = encoder_model.predict(test_X_seq)\n",
    "    encoder_state_h = np.concatenate([enc_fwd_state_h, enc_back_state_h], axis=-1)\n",
    "    encoder_state_c = np.concatenate([enc_fwd_state_c, enc_back_state_c], axis=-1)\n",
    "\n",
    "    # The ordering seems significant\n",
    "    # enc_outs, enc_fwd_state_h, enc_fwd_state_c, enc_back_state_h, enc_back_state_c = encoder_model.predict(test_X_seq)\n",
    "\n",
    "    attention_weights = []\n",
    "    stop_condition = False\n",
    "    decoded_sentence = \"\"\n",
    "    while not stop_condition:\n",
    "        dec_out, attention, dec_state_h, dec_state_c = decoder_model.predict(\n",
    "            [enc_outs, encoder_state_h, encoder_state_c, target_seq]\n",
    "        )\n",
    "\n",
    "        # Sample a token\n",
    "        sampled_token_index = np.argmax(dec_out[0, -1, :])\n",
    "        sampled_char = reverse_target_char_index[sampled_token_index]\n",
    "        decoded_sentence += sampled_char\n",
    "\n",
    "        # Exit condition: either hit max length\n",
    "        # or find stop character.\n",
    "        if sampled_char == \"\\n\" or len(decoded_sentence) > max_decoder_seq_length:\n",
    "            stop_condition = True\n",
    "\n",
    "        # Update the target sequence (of length 1).\n",
    "        target_seq = np.zeros((1, 1, num_decoder_tokens))\n",
    "        target_seq[0, 0, sampled_token_index] = 1.0\n",
    "\n",
    "        attention_weights.append((sampled_token_index, attention))\n",
    "\n",
    "        # Update states\n",
    "        encoder_state_h = dec_state_h\n",
    "        encoder_state_c = dec_state_c\n",
    "\n",
    "    return decoded_sentence, attention_weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decode_sequence_lstm(input_seq):\n",
    "    # Encode the input as state vectors.\n",
    "    states_value = encoder_model.predict(input_seq)\n",
    "\n",
    "    # Generate empty target sequence of length 1.\n",
    "    target_seq = np.zeros((1, 1, num_decoder_tokens))\n",
    "    # Populate the first character of target sequence with the start character.\n",
    "    target_seq[0, 0, target_token_index[\"\\t\"]] = 1.0\n",
    "\n",
    "    # Sampling loop for a batch of sequences\n",
    "    # (to simplify, here we assume a batch of size 1).\n",
    "    stop_condition = False\n",
    "    decoded_sentence = \"\"\n",
    "    while not stop_condition:\n",
    "        output_tokens, h, c = decoder_model.predict([target_seq] + states_value)\n",
    "\n",
    "        # Sample a token\n",
    "        sampled_token_index = np.argmax(output_tokens[0, -1, :])\n",
    "        sampled_char = reverse_target_char_index[sampled_token_index]\n",
    "        decoded_sentence += sampled_char\n",
    "\n",
    "        # Exit condition: either hit max length\n",
    "        # or find stop character.\n",
    "        if sampled_char == \"\\n\" or len(decoded_sentence) > max_decoder_seq_length:\n",
    "            stop_condition = True\n",
    "\n",
    "        # Update the target sequence (of length 1).\n",
    "        target_seq = np.zeros((1, 1, num_decoder_tokens))\n",
    "        target_seq[0, 0, sampled_token_index] = 1.0\n",
    "\n",
    "        # Update states\n",
    "        states_value = [h, c]\n",
    "\n",
    "    return decoded_sentence\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_attention_weights(\n",
    "    encoder_inputs, attention_weights, en_id2word, fr_id2word, filename=None\n",
    "):\n",
    "    \"\"\"\n",
    "    Plots attention weights\n",
    "    :param encoder_inputs: Sequence of word ids (list/numpy.ndarray)\n",
    "    :param attention_weights: Sequence of (<word_id_at_decode_step_t>:<attention_weights_at_decode_step_t>)\n",
    "    :param en_id2word: dict\n",
    "    :param fr_id2word: dict\n",
    "    :return:\n",
    "    \"\"\"\n",
    "\n",
    "    if len(attention_weights) == 0:\n",
    "        print(\n",
    "            \"Your attention weights were empty. No attention map saved to the disk. \"\n",
    "            + \"\\nPlease check if the decoder produced  a proper translation\"\n",
    "        )\n",
    "        return\n",
    "\n",
    "    mats = []\n",
    "    dec_inputs = []\n",
    "    for dec_ind, attn in attention_weights:\n",
    "        mats.append(attn.reshape(-1))\n",
    "        dec_inputs.append(dec_ind)\n",
    "    attention_mat = np.transpose(np.array(mats))\n",
    "\n",
    "    fig, ax = plt.subplots(figsize=(32, 32))\n",
    "    ax.imshow(attention_mat)\n",
    "\n",
    "    ax.set_xticks(np.arange(attention_mat.shape[1]))\n",
    "    ax.set_yticks(np.arange(attention_mat.shape[0]))\n",
    "\n",
    "    ax.set_xticklabels([fr_id2word[inp] if inp != 0 else \"<Res>\" for inp in dec_inputs])\n",
    "    y_lab = [\n",
    "        en_id2word[inp] if inp != 0 else \"<Res>\"\n",
    "        for inp in [\n",
    "            np.argmax(np.squeeze(encoder_inputs)[i])\n",
    "            for i in range(0, np.squeeze(encoder_inputs).shape[0])\n",
    "        ]\n",
    "    ]\n",
    "    ax.set_yticklabels(y_lab)\n",
    "\n",
    "    ax.tick_params(labelsize=16)\n",
    "    ax.tick_params(axis=\"x\", labelrotation=90)\n",
    "\n",
    "    if not os.path.exists(config.RESULTS_DIR):\n",
    "        os.mkdir(config.RESULTS_DIR)\n",
    "    if filename is None:\n",
    "        plt.savefig(os.path.join(config.RESULTS_DIR, \"attention.png\"))\n",
    "    else:\n",
    "        plt.savefig(os.path.join(config.RESULTS_DIR, \"{}\".format(filename)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## From Checkpoint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "latent_dim = 44\n",
    "\n",
    "full_model.load_weights(\n",
    "    f\"{config.CHECKPOINT_DIR}weights-{simple_name}-N({len(X_train)})-{latent_dim}.best.hdf5\"\n",
    ")\n",
    "loaded_model = full_model\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LSTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoder_inputs = Input(shape=(None, num_encoder_tokens))\n",
    "encoder_outputs, state_h, state_c = encoder_lstm(encoder_inputs)\n",
    "encoder_model = Model(encoder_inputs, [state_h, state_c])\n",
    "\n",
    "decoder_inputs = Input(shape=(None, num_decoder_tokens))\n",
    "\n",
    "decoder_state_input_h = Input(shape=(latent_dim,))\n",
    "decoder_state_input_c = Input(shape=(latent_dim,))\n",
    "decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c]\n",
    "decoder_outputs, state_h, state_c = decoder_lstm(\n",
    "    decoder_inputs, initial_state=decoder_states_inputs\n",
    ")\n",
    "decoder_states = [state_h, state_c]\n",
    "decoder_outputs = decoder_dense(decoder_outputs)\n",
    "decoder_model = Model(\n",
    "    [decoder_inputs] + decoder_states_inputs, \n",
    "    [decoder_outputs] + decoder_states\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bi-GRU + Attention"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Encoder (Inference) model \"\"\"\n",
    "encoder_inf_inputs = Input(shape=(None, num_encoder_tokens), name=\"encoder_inf_inputs\")\n",
    "encoder_inf_out, encoder_inf_fwd_state, encoder_inf_back_state = encoder_gru(\n",
    "    encoder_inf_inputs\n",
    ")\n",
    "encoder_model = Model(\n",
    "    inputs=encoder_inf_inputs,\n",
    "    outputs=[encoder_inf_out, encoder_inf_fwd_state, encoder_inf_back_state],\n",
    ")\n",
    "\n",
    "\"\"\" Decoder (Inference) model \"\"\"\n",
    "decoder_inf_inputs = Input(shape=(None, num_decoder_tokens), name=\"decoder_inf_inputs\")\n",
    "encoder_inf_states = Input(\n",
    "    batch_shape=(None, None, 2 * latent_dim), name=\"encoder_inf_states\"\n",
    ")\n",
    "decoder_init_state = Input(batch_shape=(None, 2 * latent_dim), name=\"decoder_init\")\n",
    "\n",
    "decoder_inf_out, decoder_inf_state = decoder_gru(\n",
    "    decoder_inf_inputs, initial_state=decoder_init_state\n",
    ")\n",
    "attn_inf_out, attn_inf_states = attn_layer([encoder_inf_states, decoder_inf_out])\n",
    "decoder_inf_concat = Concatenate(axis=-1, name=\"concat\")(\n",
    "    [decoder_inf_out, attn_inf_out]\n",
    ")\n",
    "decoder_inf_pred = TimeDistributed(dense)(decoder_inf_concat)\n",
    "decoder_model = Model(\n",
    "    inputs=[encoder_inf_states, decoder_init_state, decoder_inf_inputs],\n",
    "    outputs=[decoder_inf_pred, attn_inf_states, decoder_inf_state],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bi-LSTM + Attention"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Encoder (Inference) model \"\"\"\n",
    "encoder_inf_inputs = Input(shape=(None, num_encoder_tokens), name=\"encoder_inf_inputs\")\n",
    "(\n",
    "    encoder_inf_out,\n",
    "    encoder_inf_fwd_state_h,\n",
    "    encoder_inf_fwd_state_c,\n",
    "    encoder_inf_back_state_h,\n",
    "    encoder_inf_back_state_c,\n",
    ") = encoder_lstm(encoder_inf_inputs)\n",
    "encoder_model = Model(\n",
    "    inputs=encoder_inf_inputs,\n",
    "    outputs=[\n",
    "        encoder_inf_out,\n",
    "        encoder_inf_fwd_state_h,\n",
    "        encoder_inf_fwd_state_c,\n",
    "        encoder_inf_back_state_h,\n",
    "        encoder_inf_back_state_c,\n",
    "    ],\n",
    ")\n",
    "\n",
    "\"\"\" Decoder (Inference) model \"\"\"\n",
    "decoder_inf_inputs = Input(shape=(None, num_decoder_tokens), name=\"decoder_inf_inputs\")\n",
    "encoder_inf_states = Input(\n",
    "    batch_shape=(None, None, 2 * latent_dim), name=\"encoder_inf_states\"\n",
    ")\n",
    "\n",
    "decoder_state_input_h = Input(batch_shape=(None, 2 * latent_dim))\n",
    "decoder_state_input_c = Input(batch_shape=(None, 2 * latent_dim))\n",
    "\n",
    "decoder_init_state = [decoder_state_input_h, decoder_state_input_c]\n",
    "\n",
    "decoder_inf_out, decoder_inf_state_h, decoder_inf_state_c = decoder_lstm(\n",
    "    decoder_inf_inputs, initial_state=decoder_init_state\n",
    ")\n",
    "\n",
    "attn_inf_out, attn_inf_states = attn_layer([encoder_inf_states, decoder_inf_out])\n",
    "decoder_inf_concat = Concatenate(axis=-1, name=\"concat\")(\n",
    "    [decoder_inf_out, attn_inf_out]\n",
    ")\n",
    "decoder_inf_pred = TimeDistributed(dense)(decoder_inf_concat)\n",
    "\n",
    "decoder_model = Model(\n",
    "    inputs=[encoder_inf_states, decoder_init_state, decoder_inf_inputs],\n",
    "    outputs=[\n",
    "        decoder_inf_pred,\n",
    "        attn_inf_states,\n",
    "        decoder_inf_state_h,\n",
    "        decoder_inf_state_c,\n",
    "    ],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## From Saved HDF5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import load_model\n",
    "\n",
    "# Set these parameters (embedded in file name)\n",
    "latent_dim = 64\n",
    "\n",
    "loaded_model = load_model(\n",
    "    f\"{config.MODELS_DIR}{simple_name}-N({len(X_train)})-{latent_dim}.best.h5\",\n",
    "    custom_objects={\"AttentionLayer\": AttentionLayer},\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(loaded_model.summary())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LSTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoder_inputs = Input(shape=(None, num_encoder_tokens))\n",
    "encoder = loaded_model.layers[2]\n",
    "encoder_outputs, state_h, state_c = encoder(encoder_inputs)\n",
    "encoder_model = Model(encoder_inputs, [state_h, state_c])\n",
    "\n",
    "decoder_inputs = Input(shape=(None, num_decoder_tokens))\n",
    "decoder_dense = loaded_model.layers[4]\n",
    "\n",
    "decoder_state_input_h = Input(shape=(latent_dim,))\n",
    "decoder_state_input_c = Input(shape=(latent_dim,))\n",
    "decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c]\n",
    "decoder_lstm = loaded_model.layers[3]\n",
    "decoder_outputs, state_h, state_c = decoder_lstm(\n",
    "    decoder_inputs, initial_state=decoder_states_inputs\n",
    ")\n",
    "decoder_states = [state_h, state_c]\n",
    "decoder_outputs = decoder_dense(decoder_outputs)\n",
    "decoder_model = Model(\n",
    "    [decoder_inputs] + decoder_states_inputs, \n",
    "    [decoder_outputs] + decoder_states\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bi-GRU + Attention"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoder_inf_inputs = Input(shape=(None, num_encoder_tokens), name=\"encoder_inf_inputs\")\n",
    "encoder = full_model.layers[1]\n",
    "encoder_inf_out, encoder_inf_fwd_state, encoder_inf_back_state = encoder(\n",
    "    encoder_inf_inputs\n",
    ")\n",
    "encoder_model = Model(\n",
    "    inputs=encoder_inf_inputs,\n",
    "    outputs=[encoder_inf_out, encoder_inf_fwd_state, encoder_inf_back_state],\n",
    ")\n",
    "\n",
    "\"\"\" Decoder (Inference) model \"\"\"\n",
    "decoder_inf_inputs = Input(shape=(None, num_decoder_tokens), name=\"decoder_inf_inputs\")\n",
    "encoder_inf_states = Input(\n",
    "    batch_shape=(None, None, 2 * latent_dim), name=\"encoder_inf_states\"\n",
    ")\n",
    "decoder_init_state = Input(batch_shape=(None, 2 * latent_dim), name=\"decoder_init\")\n",
    "\n",
    "decoder = full_model.layers[4]\n",
    "dense = full_model.layers[7]\n",
    "decoder_inf_out, decoder_inf_state = decoder(\n",
    "    decoder_inf_inputs, initial_state=decoder_init_state\n",
    ")\n",
    "attn_layer = full_model.layers[5]\n",
    "attn_inf_out, attn_inf_states = attn_layer([encoder_inf_states, decoder_inf_out])\n",
    "decoder_inf_concat = Concatenate(axis=-1, name=\"concat\")(\n",
    "    [decoder_inf_out, attn_inf_out]\n",
    ")\n",
    "decoder_inf_pred = TimeDistributed(dense)(decoder_inf_concat)\n",
    "decoder_model = Model(\n",
    "    inputs=[encoder_inf_states, decoder_init_state, decoder_inf_inputs],\n",
    "    outputs=[decoder_inf_pred, attn_inf_states, decoder_inf_state],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## On Test Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-\n",
      "Input sentence: she is willing and able\n",
      "Decoded sentence: 'exists x1.(_able(x1) & _willing(x1))'\n",
      "Real sentence: 'exists x1.(_noteworthy(x1) | _unique(x1))'\n",
      "INCORRECT\n",
      "Completed: 100.0%\n",
      "1/1\n",
      "Accuracy:\n",
      "0.0%\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2304x2304 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# X_test = ['he likes cats and dogs']\n",
    "X_test = [\"she is willing and able\"]\n",
    "\n",
    "encoder_test_data = np.zeros(\n",
    "    (len(X_test), max_encoder_seq_length, num_encoder_tokens), dtype=\"float32\"\n",
    ")\n",
    "for i, x in enumerate(X_test):\n",
    "    for t, char in enumerate(x):\n",
    "        encoder_test_data[i, t, input_token_index[char]] = 1.0\n",
    "    encoder_test_data[i, t + 1 :, input_token_index[\" \"]] = 1.0\n",
    "\n",
    "import sys\n",
    "\n",
    "np.set_printoptions(threshold=sys.maxsize)\n",
    "\n",
    "correct = 0\n",
    "checked = 0\n",
    "for seq_index in range(0, len(X_test)):\n",
    "    test_X = X_test[seq_index]\n",
    "    input_seq = encoder_test_data[seq_index : seq_index + 1]\n",
    "\n",
    "    # Bi-LSTM\n",
    "    decoded_sentence, attn_weights = decode_sequence_bilstm_attn(\n",
    "        encoder_model, decoder_model, input_seq, num_encoder_tokens, num_decoder_tokens\n",
    "    )\n",
    "\n",
    "    # LSTM\n",
    "    # decoded_sentence = decode_sequence_lstm(input_seq)\n",
    "    plot_attention_weights(\n",
    "        input_seq,\n",
    "        attn_weights,\n",
    "        reverse_input_char_index,\n",
    "        reverse_target_char_index,\n",
    "        filename=\"attention_{}.png\".format(seq_index),\n",
    "    )\n",
    "    print(\"-\")\n",
    "    print(\"Input sentence:\", X_test[seq_index])\n",
    "    print(\"Decoded sentence:\", repr(decoded_sentence.rstrip()))\n",
    "    print(\"Real sentence:\", repr(y_test[seq_index]))\n",
    "    print(\"CORRECT\" if decoded_sentence.rstrip() == y_test[seq_index] else \"INCORRECT\")\n",
    "    correct += 1 if decoded_sentence.rstrip() == y_test[seq_index] else 0\n",
    "    checked += 1\n",
    "    print(f\"Completed: {(checked / len(X_test)) * 100}%\")\n",
    "    print(f\"{checked}/{len(X_test)}\")\n",
    "    print(\"Accuracy:\")\n",
    "    print(f\"{(correct / checked) * 100}%\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "environment": {
   "name": "tf2-gpu.2-1.m49",
   "type": "gcloud",
   "uri": "gcr.io/deeplearning-platform-release/tf2-gpu.2-1:m49"
  },
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}