English to Hindi.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "NxN3SAgJG5Wb"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import gc\n",
        "import time\n",
        "import re\n",
        "import unicodedata\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras import backend as K\n",
        "from keras.preprocessing.text import Tokenizer\n",
        "from keras.preprocessing.sequence import pad_sequences"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "UPBMauL4HUfU"
      },
      "outputs": [],
      "source": [
        "root_folder='.'\n",
        "train_filename='hind.txt'\n",
        "DATA_PATH = os.path.abspath(os.path.join(root_folder))\n",
        "train_filenamepath = os.path.abspath(os.path.join(DATA_PATH, train_filename))\n",
        "train_path = DATA_PATH\n",
        "test_path = DATA_PATH"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "id": "vSPiAh_xHuLi"
      },
      "outputs": [],
      "source": [
        "INPUT_COLUMN = 'input'\n",
        "TARGET_COLUMN = 'target'\n",
        "TARGET_FOR_INPUT = 'target_for_input'\n",
        "NUM_SAMPLES = 20000 \n",
        "MAX_VOCAB_SIZE = 20000\n",
        "EMBEDDING_DIM = 128\n",
        "HIDDEN_DIM = 1024 \n",
        "BATCH_SIZE = 8 \n",
        "EPOCHS = 20  \n",
        "ATTENTION_FUNC='general'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "id": "P0fuXyX_HxPX"
      },
      "outputs": [],
      "source": [
        "def unicode_to_ascii(s):\n",
        "    return ''.join(c for c in unicodedata.normalize('NFD', s)\n",
        "        if unicodedata.category(c) != 'Mn')\n",
        "\n",
        "def preprocess_sentence(w):\n",
        "    w = unicode_to_ascii(w.lower().strip())\n",
        "    w = re.sub(r\"([?.!,¿])\", r\" \\1 \", w)\n",
        "    w = re.sub(r'[\" \"]+', \" \", w)\n",
        "    w = w.strip()\n",
        "\n",
        "    return w"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CLJRWTigIRfw",
        "outputId": "3e3608eb-b19d-4697-b52e-54182b29787f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "awesome !\n",
            "बहत बढिया ! <eos>\n",
            "<sos> बहत बढिया !\n"
          ]
        }
      ],
      "source": [
        "df=pd.read_csv(train_filenamepath, sep=\"\\t\", header=None, names=[INPUT_COLUMN,TARGET_COLUMN], usecols=[0,1], nrows=NUM_SAMPLES)\n",
        "input_data=df[INPUT_COLUMN].apply(lambda x : preprocess_sentence(x)).tolist()\n",
        "target_data=df[TARGET_COLUMN].apply(lambda x : preprocess_sentence(x)+ ' <eos>').tolist()\n",
        "target_input_data=df[TARGET_COLUMN].apply(lambda x : '<sos> '+ preprocess_sentence(x)).tolist()\n",
        "\n",
        "print(input_data[15])\n",
        "print(target_data[15])\n",
        "print(target_input_data[15])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>input</th>\n",
              "      <th>target</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>Wow!</td>\n",
              "      <td>वाह!</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>Duck!</td>\n",
              "      <td>झुको!</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>Duck!</td>\n",
              "      <td>बतख़!</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>Help!</td>\n",
              "      <td>बचाओ!</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>Jump.</td>\n",
              "      <td>उछलो.</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2944</th>\n",
              "      <td>If you go to that supermarket, you can buy mos...</td>\n",
              "      <td>उस सूपरमार्केट में तुम लगभग कोई भी रोजाने में ...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2945</th>\n",
              "      <td>The passengers who were injured in the acciden...</td>\n",
              "      <td>जिन यात्रियों को दुर्घटना मे चोट आई थी उन्हे अ...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2946</th>\n",
              "      <td>Democracy is the worst form of government, exc...</td>\n",
              "      <td>लोकतंत्र सरकार का सबसे घिनौना रूप है, अगर बाकी...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2947</th>\n",
              "      <td>If my boy had not been killed in the traffic a...</td>\n",
              "      <td>अगर मेरा बेटा ट्रेफ़िक हादसे में नहीं मारा गया...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2948</th>\n",
              "      <td>When I was a kid, touching bugs didn't bother ...</td>\n",
              "      <td>जब मैं बच्चा था, मुझे कीड़ों को छूने से कोई पर...</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>2949 rows × 2 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "                                                  input  \\\n",
              "0                                                  Wow!   \n",
              "1                                                 Duck!   \n",
              "2                                                 Duck!   \n",
              "3                                                 Help!   \n",
              "4                                                 Jump.   \n",
              "...                                                 ...   \n",
              "2944  If you go to that supermarket, you can buy mos...   \n",
              "2945  The passengers who were injured in the acciden...   \n",
              "2946  Democracy is the worst form of government, exc...   \n",
              "2947  If my boy had not been killed in the traffic a...   \n",
              "2948  When I was a kid, touching bugs didn't bother ...   \n",
              "\n",
              "                                                 target  \n",
              "0                                                  वाह!  \n",
              "1                                                 झुको!  \n",
              "2                                                 बतख़!  \n",
              "3                                                 बचाओ!  \n",
              "4                                                 उछलो.  \n",
              "...                                                 ...  \n",
              "2944  उस सूपरमार्केट में तुम लगभग कोई भी रोजाने में ...  \n",
              "2945  जिन यात्रियों को दुर्घटना मे चोट आई थी उन्हे अ...  \n",
              "2946  लोकतंत्र सरकार का सबसे घिनौना रूप है, अगर बाकी...  \n",
              "2947  अगर मेरा बेटा ट्रेफ़िक हादसे में नहीं मारा गया...  \n",
              "2948  जब मैं बच्चा था, मुझे कीड़ों को छूने से कोई पर...  \n",
              "\n",
              "[2949 rows x 2 columns]"
            ]
          },
          "execution_count": 29,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "df"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5UCS81Q2Jkhz",
        "outputId": "a082105a-5524-4e50-9d35-27ebdfe5d571"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[[1, 2, 3]]"
            ]
          },
          "execution_count": 30,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "dummy=['I am Raj .']\n",
        "t=Tokenizer()\n",
        "t.fit_on_texts(dummy)\n",
        "t.texts_to_sequences(dummy)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D_ARdGKTI9bR",
        "outputId": "59c605f3-c6c0-41ac-ac4b-1d4ddc2d2e35"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Max Input Length:  25\n",
            "awesome !\n",
            "[1305, 60]\n"
          ]
        }
      ],
      "source": [
        "tokenizer_inputs = Tokenizer(num_words=MAX_VOCAB_SIZE, filters='')\n",
        "tokenizer_inputs.fit_on_texts(input_data)\n",
        "input_sequences = tokenizer_inputs.texts_to_sequences(input_data)\n",
        "input_max_len = max(len(s) for s in input_sequences)\n",
        "\n",
        "print('Max Input Length: ', input_max_len)\n",
        "print(input_data[15])\n",
        "print(input_sequences[15])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1zc4QD8DKU_S",
        "outputId": "4c3ce4b9-22c3-4b8d-ce5f-92acfc98f925"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Max Target Length:  28\n",
            "बहत बढिया ! <eos>\n",
            "[16, 1454, 70, 1]\n",
            "<sos> बहत बढिया !\n",
            "[2, 16, 1454, 70]\n"
          ]
        }
      ],
      "source": [
        "tokenizer_outputs = Tokenizer(num_words=MAX_VOCAB_SIZE, filters='')\n",
        "tokenizer_outputs.fit_on_texts(target_data)\n",
        "tokenizer_outputs.fit_on_texts(target_input_data)\n",
        "target_sequences = tokenizer_outputs.texts_to_sequences(target_data)\n",
        "target_sequences_inputs = tokenizer_outputs.texts_to_sequences(target_input_data)\n",
        "target_max_len = max(len(s) for s in target_sequences)\n",
        "\n",
        "print('Max Target Length: ', target_max_len)\n",
        "print(target_data[15])\n",
        "print(target_sequences[15])\n",
        "print(target_input_data[15])\n",
        "print(target_sequences_inputs[15])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JE1VVwXMKp4a",
        "outputId": "1dca3f5d-b57d-40e3-b7db-333aa223963c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Found 2444 unique input tokens.\n",
            "Found 2823 unique output tokens.\n"
          ]
        }
      ],
      "source": [
        "word2idx_inputs = tokenizer_inputs.word_index\n",
        "word2idx_outputs = tokenizer_outputs.word_index\n",
        "num_words_output = len(word2idx_outputs) + 1\n",
        "num_words_inputs = len(word2idx_inputs) + 1\n",
        "idx2word_inputs = {v:k for k, v in word2idx_inputs.items()}\n",
        "idx2word_outputs = {v:k for k, v in word2idx_outputs.items()}\n",
        "\n",
        "print('Found %s unique input tokens.' % len(word2idx_inputs))\n",
        "print('Found %s unique output tokens.' % len(word2idx_outputs))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Er_amVJOLO_8",
        "outputId": "1c8e5cb2-1ee9-4fe5-fb45-9edb2779ff21"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "encoder_inputs.shape: (2949, 25)\n",
            "encoder_inputs[0]: [1303   60    0    0    0    0    0    0    0    0    0    0    0    0\n",
            "    0    0    0    0    0    0    0    0    0    0    0]\n",
            "decoder_inputs[0]: [   2 1443   70    0    0    0    0    0    0    0    0    0    0    0\n",
            "    0    0    0    0    0    0    0    0    0    0    0    0    0    0]\n",
            "decoder_inputs.shape: (2949, 28)\n"
          ]
        }
      ],
      "source": [
        "encoder_inputs = pad_sequences(input_sequences, maxlen=input_max_len, padding='post')\n",
        "print(\"encoder_inputs.shape:\", encoder_inputs.shape)\n",
        "print(\"encoder_inputs[0]:\", encoder_inputs[0])\n",
        "decoder_inputs = pad_sequences(target_sequences_inputs, maxlen=target_max_len, padding='post')\n",
        "print(\"decoder_inputs[0]:\", decoder_inputs[0])\n",
        "print(\"decoder_inputs.shape:\", decoder_inputs.shape)\n",
        "decoder_targets = pad_sequences(target_sequences, maxlen=target_max_len, padding='post')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X0YjwUzkLznb",
        "outputId": "a0b99cec-b3e9-40bb-9f90-bd86e3006620"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 35,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "len(input_data)==len(target_data)==len(target_input_data)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ClN7A3KnMEfI",
        "outputId": "a1a99faa-4252-4212-b6f1-3214c322112f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(<tf.Tensor: shape=(25,), dtype=int32, numpy=\n",
            "array([1303,   60,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "          0,    0,    0])>, <tf.Tensor: shape=(28,), dtype=int32, numpy=\n",
            "array([   2, 1443,   70,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "          0,    0,    0,    0,    0,    0])>, <tf.Tensor: shape=(28,), dtype=int32, numpy=\n",
            "array([1443,   70,    1,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n",
            "          0,    0,    0,    0,    0,    0])>)\n",
            "3\n",
            "<class 'tensorflow.python.framework.ops.EagerTensor'>\n",
            "<class 'tensorflow.python.framework.ops.EagerTensor'>\n",
            "<class 'tensorflow.python.framework.ops.EagerTensor'>\n"
          ]
        }
      ],
      "source": [
        "dataset = tf.data.Dataset.from_tensor_slices((encoder_inputs, decoder_inputs, decoder_targets))\n",
        "for element in dataset:\n",
        "  print(element)\n",
        "  print(len(element))\n",
        "  print(type(element[0]))\n",
        "  print(type(element[1]))\n",
        "  print(type(element[2]))\n",
        "  break"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "id": "CPxzPMpILn5T"
      },
      "outputs": [],
      "source": [
        "dataset = dataset.shuffle(len(input_data)).batch(BATCH_SIZE, drop_remainder=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "id": "UjQ83-BcRhON"
      },
      "outputs": [],
      "source": [
        "class Encoder(tf.keras.Model):\n",
        "  def __init__(self,vocab_size,embedding_dim,hidden_dim):\n",
        "    super(Encoder, self).__init__()\n",
        "    self.hidden_dim = hidden_dim\n",
        "    self.embedding = tf.keras.layers.Embedding(vocab_size, embedding_dim)\n",
        "    self.lstm=tf.keras.layers.LSTM(hidden_dim,return_sequences=True,return_state=True)\n",
        "\n",
        "  def call(self,input_sequence,states):\n",
        "    embed=self.embedding(input_sequence) \n",
        "    output, state_h, state_c = self.lstm(embed, initial_state=states)\n",
        "    return output, state_h, state_c\n",
        "\n",
        "  def init_states(self, batch_size):\n",
        "    return (tf.zeros([batch_size, self.hidden_dim]),tf.zeros([batch_size, self.hidden_dim]))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {
        "id": "qSkwfRnSVFqb"
      },
      "outputs": [],
      "source": [
        "class Decoder(tf.keras.Model):\n",
        "  def __init__(self,vocab_size,embedding_dim,hidden_dim):\n",
        "    super(Decoder,self).__init__()\n",
        "    self.hidden_dim=hidden_dim\n",
        "    self.embedding=tf.keras.layers.Embedding(vocab_size,embedding_dim)\n",
        "    self.lstm=tf.keras.layers.LSTM(hidden_dim,return_sequences=True,return_state=True)\n",
        "    self.dense=tf.keras.layers.Dense(vocab_size)\n",
        "\n",
        "  def call(self,input_sequence,state_tuple):\n",
        "    embed=self.embedding(input_sequence)\n",
        "    lstm_out,state_h,state_c=self.lstm(embed, initial_state=state_tuple)\n",
        "    logits=self.dense(lstm_out)\n",
        "    return logits, state_h, state_c"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qgIm2gQhY03u",
        "outputId": "2eb87aaf-fdd2-4fd1-c2e9-848ea07557f1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Embedding dimension 128\n",
            "Hidden dimension 1024\n",
            "Batch Size 8\n"
          ]
        }
      ],
      "source": [
        "print(\"Embedding dimension \"+str(EMBEDDING_DIM))\n",
        "print(\"Hidden dimension \"+str(HIDDEN_DIM))\n",
        "print(\"Batch Size \"+str(BATCH_SIZE))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L1npsOPqX-Fh",
        "outputId": "45298ae1-a3d8-4314-a336-8e7d072d3161"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(1, 8, 2824), dtype=float32, numpy=\n",
              " array([[[ 9.2315080e-05,  8.2776317e-04, -1.5103396e-03, ...,\n",
              "           3.4174835e-04, -4.4967886e-03, -4.2192920e-04],\n",
              "         [ 1.2263848e-03, -9.7028259e-04, -1.0620474e-03, ...,\n",
              "          -8.7562250e-05, -2.9944144e-03, -1.5900625e-03],\n",
              "         [ 1.6452132e-03, -2.1186019e-03, -8.1597478e-04, ...,\n",
              "           1.6904059e-03, -1.3592783e-03, -2.7263323e-03],\n",
              "         ...,\n",
              "         [ 1.4884277e-03,  2.2038845e-03, -4.2629568e-03, ...,\n",
              "           1.9867714e-03,  4.3509359e-04, -7.2634076e-03],\n",
              "         [ 5.0800183e-04,  4.1320738e-03, -5.0357073e-03, ...,\n",
              "           2.9886062e-03,  1.0172580e-03, -9.4689541e-03],\n",
              "         [-2.9061362e-04,  5.7774219e-03, -5.6430628e-03, ...,\n",
              "           3.9409446e-03,  1.3738361e-03, -1.1137882e-02]]], dtype=float32)>,\n",
              " <tf.Tensor: shape=(1, 1024), dtype=float32, numpy=\n",
              " array([[ 0.00317925, -0.00346166,  0.00850463, ..., -0.00272204,\n",
              "         -0.00107026, -0.00230592]], dtype=float32)>,\n",
              " <tf.Tensor: shape=(1, 1024), dtype=float32, numpy=\n",
              " array([[ 0.00639268, -0.00690431,  0.01698002, ..., -0.00544793,\n",
              "         -0.00214305, -0.00464994]], dtype=float32)>)"
            ]
          },
          "execution_count": 41,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "num_words_inputs = len(word2idx_inputs) + 1\n",
        "num_words_outputs = len(word2idx_outputs) + 1\n",
        "\n",
        "encoder=Encoder(num_words_inputs,EMBEDDING_DIM,HIDDEN_DIM)\n",
        "\n",
        "initial_states = encoder.init_states(1)\n",
        "\n",
        "test_encoder_output = encoder(tf.constant([[1, 23, 4, 5, 0, 0]]), initial_states) \n",
        "\n",
        "decoder=Decoder(num_words_outputs,EMBEDDING_DIM,HIDDEN_DIM)\n",
        "\n",
        "de_initial_state = test_encoder_output[1:]\n",
        "\n",
        "test_decoder_output= decoder(tf.constant([[1, 3, 5, 7, 9, 0, 0, 0]]), de_initial_state)\n",
        "\n",
        "test_decoder_output"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "id": "yw4PBnJfnK0w"
      },
      "outputs": [],
      "source": [
        "def loss_func(targets,logits):\n",
        "  crossentropy=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)\n",
        "  mask = tf.math.logical_not(tf.math.equal(targets, 0))\n",
        "  mask = tf.cast(mask, dtype=tf.int64) #Convert boolean to int\n",
        "  loss = crossentropy(targets, logits, sample_weight=mask)\n",
        "  return loss\n",
        "\n",
        "def accuracy_fn(y_true, y_pred):\n",
        "    pred_values = K.cast(K.argmax(y_pred, axis=-1), dtype='int32') \n",
        "    correct = K.cast(K.equal(y_true, pred_values), dtype='float32')\n",
        "\n",
        "\n",
        "    mask = K.cast(K.greater(y_true, 0), dtype='float32') \n",
        "    n_correct = K.sum(mask * correct) \n",
        "    n_total = K.sum(mask) \n",
        "\n",
        "    return n_correct / n_total\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {
        "id": "PaiIopOxsB14"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "\n",
        "def train_step(input_seq, target_seq_in, target_seq_out, en_initial_states, optimizer):\n",
        "    with tf.GradientTape() as tape:\n",
        "        en_outputs = encoder(input_seq, en_initial_states)\n",
        "        de_states = en_outputs[1:]\n",
        "        de_outputs = decoder(target_seq_in, de_states)\n",
        "        logits = de_outputs[0]\n",
        "        loss = loss_func(target_seq_out, logits)\n",
        "        acc = accuracy_fn(target_seq_out, logits)\n",
        "\n",
        "    variables = encoder.trainable_variables + decoder.trainable_variables\n",
        "    gradients = tape.gradient(loss, variables)\n",
        "    optimizer.apply_gradients(zip(gradients, variables))\n",
        "\n",
        "    return loss, acc"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8WtnwAhxuwFW",
        "outputId": "4bc02752-2437-4fa0-c716-1bbf09dc25be"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<TakeDataset shapes: ((8, 25), (8, 28), (8, 28)), types: (tf.int32, tf.int32, tf.int32)>"
            ]
          },
          "execution_count": 44,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "dataset.take(-1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {
        "id": "7hFQbHmAt-6T"
      },
      "outputs": [],
      "source": [
        "def main_train(encoder, decoder, dataset, n_epochs, batch_size, optimizer, checkpoint, checkpoint_prefix):\n",
        "    losses = []\n",
        "    accuracies = []\n",
        "\n",
        "    for e in range(n_epochs):\n",
        "        start = time.time()\n",
        "        en_initial_states = encoder.init_states(batch_size)\n",
        "        for batch, (input_seq, target_seq_in, target_seq_out) in enumerate(dataset.take(-1)):\n",
        "            loss, accuracy = train_step(input_seq, target_seq_in, target_seq_out, en_initial_states, optimizer)\n",
        "        \n",
        "            if batch % 100 == 0:\n",
        "                losses.append(loss)\n",
        "                accuracies.append(accuracy)\n",
        "                print('Epoch {} Batch {} Loss {:.4f} Acc:{:.4f}'.format(e + 1, batch, loss.numpy(), accuracy.numpy()))\n",
        "        if (e + 1) % 2 == 0:\n",
        "            checkpoint.save(file_prefix = checkpoint_prefix)\n",
        "    \n",
        "        print('Time taken for 1 epoch {:.4f} sec\\n'.format(time.time() - start))\n",
        "        \n",
        "    return losses, accuracies"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0Dm9ckXrwfeh",
        "outputId": "94d74b6f-1e60-48d9-d8c0-994c91e0c67b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1 Batch 0 Loss 2.1993 Acc:0.0000\n",
            "Epoch 1 Batch 100 Loss 2.1483 Acc:0.1519\n",
            "Epoch 1 Batch 200 Loss 1.4734 Acc:0.1379\n",
            "Epoch 1 Batch 300 Loss 1.3007 Acc:0.1667\n",
            "Time taken for 1 epoch 53.4832 sec\n",
            "\n",
            "Epoch 2 Batch 0 Loss 1.2978 Acc:0.2222\n",
            "Epoch 2 Batch 100 Loss 1.2065 Acc:0.2264\n",
            "Epoch 2 Batch 200 Loss 1.1391 Acc:0.2456\n",
            "Epoch 2 Batch 300 Loss 1.6162 Acc:0.2297\n",
            "Time taken for 1 epoch 51.6168 sec\n",
            "\n",
            "Epoch 3 Batch 0 Loss 1.3839 Acc:0.2361\n",
            "Epoch 3 Batch 100 Loss 1.2399 Acc:0.2639\n",
            "Epoch 3 Batch 200 Loss 1.1314 Acc:0.2500\n",
            "Epoch 3 Batch 300 Loss 1.1556 Acc:0.3175\n",
            "Time taken for 1 epoch 49.9654 sec\n",
            "\n",
            "Epoch 4 Batch 0 Loss 0.8904 Acc:0.3750\n",
            "Epoch 4 Batch 100 Loss 1.0086 Acc:0.3115\n",
            "Epoch 4 Batch 200 Loss 1.0696 Acc:0.3016\n",
            "Epoch 4 Batch 300 Loss 1.0648 Acc:0.2545\n",
            "Time taken for 1 epoch 51.7049 sec\n",
            "\n",
            "Epoch 5 Batch 0 Loss 1.0596 Acc:0.2941\n",
            "Epoch 5 Batch 100 Loss 0.8958 Acc:0.3750\n",
            "Epoch 5 Batch 200 Loss 1.3016 Acc:0.2785\n",
            "Epoch 5 Batch 300 Loss 1.0973 Acc:0.2769\n",
            "Time taken for 1 epoch 49.8239 sec\n",
            "\n",
            "Epoch 6 Batch 0 Loss 0.7056 Acc:0.5000\n",
            "Epoch 6 Batch 100 Loss 0.7184 Acc:0.4483\n",
            "Epoch 6 Batch 200 Loss 0.8659 Acc:0.3731\n",
            "Epoch 6 Batch 300 Loss 0.7073 Acc:0.4138\n",
            "Time taken for 1 epoch 51.6503 sec\n",
            "\n",
            "Epoch 7 Batch 0 Loss 0.6234 Acc:0.5902\n",
            "Epoch 7 Batch 100 Loss 0.7191 Acc:0.4697\n",
            "Epoch 7 Batch 200 Loss 0.7053 Acc:0.5278\n",
            "Epoch 7 Batch 300 Loss 0.8094 Acc:0.4865\n",
            "Time taken for 1 epoch 49.7695 sec\n",
            "\n",
            "Epoch 8 Batch 0 Loss 0.5507 Acc:0.5333\n",
            "Epoch 8 Batch 100 Loss 0.5081 Acc:0.6364\n",
            "Epoch 8 Batch 200 Loss 0.6105 Acc:0.5455\n",
            "Epoch 8 Batch 300 Loss 0.5277 Acc:0.6462\n",
            "Time taken for 1 epoch 51.7141 sec\n",
            "\n",
            "Epoch 9 Batch 0 Loss 0.4664 Acc:0.6667\n",
            "Epoch 9 Batch 100 Loss 0.5045 Acc:0.5882\n",
            "Epoch 9 Batch 200 Loss 0.4890 Acc:0.6324\n",
            "Epoch 9 Batch 300 Loss 0.4712 Acc:0.6721\n",
            "Time taken for 1 epoch 49.9997 sec\n",
            "\n",
            "Epoch 10 Batch 0 Loss 0.4031 Acc:0.7042\n",
            "Epoch 10 Batch 100 Loss 0.4059 Acc:0.6885\n",
            "Epoch 10 Batch 200 Loss 0.4656 Acc:0.7179\n",
            "Epoch 10 Batch 300 Loss 0.4613 Acc:0.6349\n",
            "Time taken for 1 epoch 52.3027 sec\n",
            "\n",
            "Epoch 11 Batch 0 Loss 0.3982 Acc:0.6500\n",
            "Epoch 11 Batch 100 Loss 0.4136 Acc:0.7143\n",
            "Epoch 11 Batch 200 Loss 0.3868 Acc:0.6207\n",
            "Epoch 11 Batch 300 Loss 0.4568 Acc:0.5769\n",
            "Time taken for 1 epoch 50.0211 sec\n",
            "\n",
            "Epoch 12 Batch 0 Loss 0.4086 Acc:0.7391\n",
            "Epoch 12 Batch 100 Loss 0.4375 Acc:0.7222\n",
            "Epoch 12 Batch 200 Loss 0.4532 Acc:0.6909\n",
            "Epoch 12 Batch 300 Loss 0.4294 Acc:0.6721\n",
            "Time taken for 1 epoch 52.3689 sec\n",
            "\n",
            "Epoch 13 Batch 0 Loss 0.3506 Acc:0.6949\n",
            "Epoch 13 Batch 100 Loss 0.3576 Acc:0.7647\n",
            "Epoch 13 Batch 200 Loss 0.3362 Acc:0.7500\n",
            "Epoch 13 Batch 300 Loss 0.3556 Acc:0.7460\n",
            "Time taken for 1 epoch 50.1060 sec\n",
            "\n",
            "Epoch 14 Batch 0 Loss 0.3138 Acc:0.7667\n",
            "Epoch 14 Batch 100 Loss 0.3500 Acc:0.7705\n",
            "Epoch 14 Batch 200 Loss 0.3200 Acc:0.6875\n",
            "Epoch 14 Batch 300 Loss 0.3226 Acc:0.7000\n",
            "Time taken for 1 epoch 52.1505 sec\n",
            "\n",
            "Epoch 15 Batch 0 Loss 0.2978 Acc:0.7333\n",
            "Epoch 15 Batch 100 Loss 0.3266 Acc:0.6786\n",
            "Epoch 15 Batch 200 Loss 0.2998 Acc:0.7463\n",
            "Epoch 15 Batch 300 Loss 0.3376 Acc:0.7667\n",
            "Time taken for 1 epoch 49.6879 sec\n",
            "\n",
            "Epoch 16 Batch 0 Loss 0.2794 Acc:0.8154\n",
            "Epoch 16 Batch 100 Loss 0.2939 Acc:0.8000\n",
            "Epoch 16 Batch 200 Loss 0.3391 Acc:0.7500\n",
            "Epoch 16 Batch 300 Loss 0.3633 Acc:0.6721\n",
            "Time taken for 1 epoch 51.4260 sec\n",
            "\n",
            "Epoch 17 Batch 0 Loss 0.2532 Acc:0.8116\n",
            "Epoch 17 Batch 100 Loss 0.2916 Acc:0.7458\n",
            "Epoch 17 Batch 200 Loss 0.2860 Acc:0.8281\n",
            "Epoch 17 Batch 300 Loss 0.3129 Acc:0.7541\n",
            "Time taken for 1 epoch 50.0817 sec\n",
            "\n",
            "Epoch 18 Batch 0 Loss 0.2875 Acc:0.7460\n",
            "Epoch 18 Batch 100 Loss 0.2742 Acc:0.7937\n",
            "Epoch 18 Batch 200 Loss 0.2640 Acc:0.8056\n",
            "Epoch 18 Batch 300 Loss 0.2891 Acc:0.7547\n",
            "Time taken for 1 epoch 52.2087 sec\n",
            "\n",
            "Epoch 19 Batch 0 Loss 0.2199 Acc:0.7544\n",
            "Epoch 19 Batch 100 Loss 0.2309 Acc:0.7797\n",
            "Epoch 19 Batch 200 Loss 0.2821 Acc:0.7344\n",
            "Epoch 19 Batch 300 Loss 0.2850 Acc:0.7333\n",
            "Time taken for 1 epoch 49.9885 sec\n",
            "\n",
            "Epoch 20 Batch 0 Loss 0.2477 Acc:0.8400\n",
            "Epoch 20 Batch 100 Loss 0.2792 Acc:0.8235\n",
            "Epoch 20 Batch 200 Loss 0.2344 Acc:0.8226\n",
            "Epoch 20 Batch 300 Loss 0.2386 Acc:0.8308\n",
            "Time taken for 1 epoch 51.7058 sec\n",
            "\n"
          ]
        }
      ],
      "source": [
        "optimizer = tf.keras.optimizers.Adam(clipnorm=5.0)\n",
        "checkpoint_dir = './training_ckpt_seq2seq'\n",
        "checkpoint_prefix = os.path.join(checkpoint_dir, \"ckpt\")\n",
        "checkpoint = tf.train.Checkpoint(optimizer=optimizer,\n",
        "                                 encoder=encoder,\n",
        "                                 decoder=decoder)\n",
        "losses, accuracies = main_train(encoder, decoder, dataset, EPOCHS, BATCH_SIZE, optimizer, checkpoint, checkpoint_prefix)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 336
        },
        "id": "RSi9wczP2MOT",
        "outputId": "b1a6e76a-9ecd-407c-9381-056884bd700f"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1080x360 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15,5))\n",
        "# plot some data\n",
        "ax1.plot(losses, label='loss')\n",
        "#plt.plot(results.history['val_loss'], label='val_loss')\n",
        "ax1.set_title('Training Loss')\n",
        "ax1.legend()\n",
        "# accuracies\n",
        "ax2.plot(accuracies, label='acc')\n",
        "#plt.plot(results.history['val_accuracy_fn'], label='val_acc')\n",
        "ax2.set_title('Training Accuracy')\n",
        "ax2.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "authorship_tag": "ABX9TyM4qTIQ1iggKyGCKa9DDf9w",
      "collapsed_sections": [],
      "name": "Intro-seq2seq-Encoder-Decoder-ENG-SPA-translator-tf2.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.9.5"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}