Upload 2 files

.gitattributes

@@ -34,3 +34,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 s2s/variables/variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+transliteration.csv filter=lfs diff=lfs merge=lfs -text

Transliteration(2_LSTM)_final.ipynb

@@ -0,0 +1,1199 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "i32AdA77t1eH"
+   },
+   "outputs": [],
+   "source": [
+    "#import libraries\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import tensorflow as tf\n",
+    "from tensorflow import keras\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 17529,
+     "status": "ok",
+     "timestamp": 1691416966013,
+     "user": {
+      "displayName": "JOBANPREET SINGH",
+      "userId": "15968293240343091979"
+     },
+     "user_tz": -330
+    },
+    "id": "mCo1sSvgTmMt",
+    "outputId": "a984f6b4-a0f7-4ef7-8e7e-c453915b31d3"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mounted at /content/drive\n"
+     ]
+    }
+   ],
+   "source": [
+    "from google.colab import drive\n",
+    "drive.mount('/content/drive')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 206
+    },
+    "id": "TCF-yZlauZ41",
+    "outputId": "38d1e397-00dc-4f12-d038-d9de685fd0cd"
+   },
+   "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>Punjabi</th>\n",
+       "      <th>English</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>ਅੱਜਕੱਲ੍ਹ</td>\n",
+       "      <td>ajjkallh</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>ਕੁੱਕਰੀ</td>\n",
+       "      <td>kookerii</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>ਧਮਨੀਆਂ</td>\n",
+       "      <td>dhamniyan</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>ਖ਼ੁਦਗ਼ਰਜ਼ੀ</td>\n",
+       "      <td>khudgarzi</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>ਅਗਲੇਰਾ</td>\n",
+       "      <td>aglera</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      Punjabi    English\n",
+       "0    ਅੱਜਕੱਲ੍ਹ   ajjkallh\n",
+       "1      ਕੁੱਕਰੀ   kookerii\n",
+       "2      ਧਮਨੀਆਂ  dhamniyan\n",
+       "3  ਖ਼ੁਦਗ਼ਰਜ਼ੀ  khudgarzi\n",
+       "4      ਅਗਲੇਰਾ     aglera"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# read dataset\n",
+    "df=pd.read_csv(\"transliteration.csv\")\n",
+    "\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "sQJDIFoouski",
+    "outputId": "7aa0b1b6-29b8-40bf-f69f-3269ab738bfa"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Punjabi    0\n",
+       "English    2\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#check null values\n",
+    "df.isnull().sum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "63J_12A9uzDR",
+    "outputId": "3668f1c6-eb6e-4adb-ac7e-68aa27cfad0e"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(514722, 2)"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#drop null values\n",
+    "df.dropna(inplace=True)\n",
+    "df.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "xzPeje92u8YF"
+   },
+   "outputs": [],
+   "source": [
+    "#creaing list source text and target text\n",
+    "input_texts=list(df['English'])\n",
+    "input_texts=[item.lower() for item in input_texts] # converting to lowercase all elements of input_texts\n",
+    "target_texts=list(df['Punjabi'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "4rsG9aYQvUXX"
+   },
+   "outputs": [],
+   "source": [
+    "target_texts = ['\\t' + item + '\\n' for item in target_texts] # adding \\t and \\n at the start and end of each element of target_texts"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "NUhp1DyOvhie"
+   },
+   "outputs": [],
+   "source": [
+    "#getting unique characters in both the languages\n",
+    "input_characters = set()\n",
+    "target_characters = set()\n",
+    "for char in input_texts:\n",
+    "  for i in char:\n",
+    "        if i not in input_characters:\n",
+    "            input_characters.add(i)\n",
+    "for char in target_texts:\n",
+    "  for j in char:\n",
+    "    if j not in target_characters:\n",
+    "        target_characters.add(j)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "ho2APRJrvtyb",
+    "outputId": "45721760-bb46-44d0-8425-4e97d9b8ec55"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of samples: 514722\n",
+      "Max sequence length for inputs: 27\n",
+      "Max sequence length for outputs: 24\n"
+     ]
+    }
+   ],
+   "source": [
+    "input_characters = sorted(list(input_characters))\n",
+    "target_characters = sorted(list(target_characters))\n",
+    "max_encoder_seq_length = max([len(txt) for txt in input_texts])\n",
+    "max_decoder_seq_length = max([len(txt) for txt in target_texts])\n",
+    "\n",
+    "\n",
+    "print(\"Number of samples:\", len(input_texts))\n",
+    "print(\"Max sequence length for inputs:\", max_encoder_seq_length)\n",
+    "print(\"Max sequence length for outputs:\", max_decoder_seq_length)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "7Sszy5eYwHMS"
+   },
+   "outputs": [],
+   "source": [
+    "# assigning indexes to each characters of source and target language\n",
+    "input_token_index={' ':0,\n",
+    " 'a': 1,\n",
+    " 'b': 2,\n",
+    " 'c': 3,\n",
+    " 'd': 4,\n",
+    " 'e': 5,\n",
+    " 'f': 6,\n",
+    " 'g': 7,\n",
+    " 'h': 8,\n",
+    " 'i': 9,\n",
+    " 'j': 10,\n",
+    " 'k': 11,\n",
+    " 'l': 12,\n",
+    " 'm': 13,\n",
+    " 'n': 14,\n",
+    " 'o': 15,\n",
+    " 'p': 16,\n",
+    " 'q': 17,\n",
+    " 'r': 18,\n",
+    " 's': 19,\n",
+    " 't': 20,\n",
+    " 'u': 21,\n",
+    " 'v': 22,\n",
+    " 'w': 23,\n",
+    " 'x': 24,\n",
+    " 'y': 25,\n",
+    " 'z': 26}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "WAa6pR1-wHY6"
+   },
+   "outputs": [],
+   "source": [
+    "target_token_index={'\\t': 0,\n",
+    " '\\n': 1,\n",
+    " ' ': 2,\n",
+    " 'ਅ': 3,\n",
+    " 'ਆ': 4,\n",
+    " 'ਇ': 5,\n",
+    " 'ਈ': 6,\n",
+    " 'ਉ': 7,\n",
+    " 'ਊ': 8,\n",
+    " 'ਏ': 9,\n",
+    " 'ਐ': 10,\n",
+    " 'ਓ': 11,\n",
+    " 'ਔ': 12,\n",
+    " 'ਕ': 13,\n",
+    " 'ਖ': 14,\n",
+    " 'ਗ': 15,\n",
+    " 'ਘ': 16,\n",
+    " 'ਙ': 17,\n",
+    " 'ਚ': 18,\n",
+    " 'ਛ': 19,\n",
+    " 'ਜ': 20,\n",
+    " 'ਝ': 21,\n",
+    " 'ਞ': 22,\n",
+    " 'ਟ': 23,\n",
+    " 'ਠ': 24,\n",
+    " 'ਡ': 25,\n",
+    " 'ਢ': 26,\n",
+    " 'ਣ': 27,\n",
+    " 'ਤ': 28,\n",
+    " 'ਥ': 29,\n",
+    " 'ਦ': 30,\n",
+    " 'ਧ': 31,\n",
+    " 'ਨ': 32,\n",
+    " 'ਪ': 33,\n",
+    " 'ਫ': 34,\n",
+    " 'ਬ': 35,\n",
+    " 'ਭ': 36,\n",
+    " 'ਮ': 37,\n",
+    " 'ਯ': 38,\n",
+    " 'ਰ': 39,\n",
+    " 'ਲ': 40,\n",
+    " 'ਵ': 41,\n",
+    " 'ਸ': 42,\n",
+    " 'ਹ': 43,\n",
+    " '਼': 44,\n",
+    " 'ਾ': 45,\n",
+    " 'ਿ': 46,\n",
+    " 'ੀ': 47,\n",
+    " 'ੁ': 48,\n",
+    " 'ੂ': 49,\n",
+    " 'ੇ': 50,\n",
+    " 'ੈ': 51,\n",
+    " 'ੋ': 52,\n",
+    " 'ੌ': 53,\n",
+    " '੍': 54,\n",
+    " 'ੜ': 55,\n",
+    " 'ੰ': 56,\n",
+    " 'ੱ': 57,\n",
+    " 'ਂ': 58,\n",
+    "'ੲ':59}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "bCqPdrq-TkQx"
+   },
+   "outputs": [],
+   "source": [
+    "import pickle\n",
+    "with open(\"input_token_index.pkl\",'wb') as file:\n",
+    "    pickle.dump(input_token_index,file)\n",
+    "\n",
+    "with open(\"target_token_index.pkl\",'wb') as file:\n",
+    "    pickle.dump(target_token_index,file)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "HAWXGYejTkQy"
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "pKlLsEReyuwE",
+    "outputId": "9ec6f048-76be-43cd-cd0f-3aff94b628b0"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of unique input tokens: 27\n",
+      "Number of unique output tokens: 60\n"
+     ]
+    }
+   ],
+   "source": [
+    "num_encoder_tokens=len(input_token_index)\n",
+    "num_decoder_tokens=len(target_token_index)\n",
+    "print(\"Number of unique input tokens:\", num_encoder_tokens)\n",
+    "print(\"Number of unique output tokens:\", num_decoder_tokens)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "KRiDLofETkQz"
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "gFDq5lqWv0NW"
+   },
+   "outputs": [],
+   "source": [
+    "# 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)])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Qks23AHEwBxL"
+   },
+   "outputs": [],
+   "source": [
+    "# Data preparation for model training\n",
+    "encoder_input_data = np.zeros(\n",
+    "    (len(input_texts), max_encoder_seq_length, num_encoder_tokens), dtype=\"float32\"\n",
+    ")\n",
+    "decoder_input_data = np.zeros(\n",
+    "    (len(input_texts), max_decoder_seq_length,num_decoder_tokens), dtype=\"float32\"\n",
+    ")\n",
+    "decoder_target_data = np.zeros(\n",
+    "    (len(input_texts), max_decoder_seq_length,num_decoder_tokens), dtype=\"float32\"\n",
+    ")\n",
+    "\n",
+    "for i, (input_text, target_text) in enumerate(zip(input_texts, target_texts)):\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"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "KUO0JORIogdi",
+    "outputId": "fb6fc006-a073-4426-9683-0f9da633777a"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2023-08-06 14:10:30.193063: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1960] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.\n",
+      "Skipping registering GPU devices...\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"model\"\n",
+      "__________________________________________________________________________________________________\n",
+      " Layer (type)                Output Shape                 Param #   Connected to                  \n",
+      "==================================================================================================\n",
+      " encoder_inputs (InputLayer  [(None, None, 27)]           0         []                            \n",
+      " )                                                                                                \n",
+      "                                                                                                  \n",
+      " decoder_inputs (InputLayer  [(None, None, 60)]           0         []                            \n",
+      " )                                                                                                \n",
+      "                                                                                                  \n",
+      " encoder_lstm1 (LSTM)        [(None, None, 256),          290816    ['encoder_inputs[0][0]']      \n",
+      "                              (None, 256),                                                        \n",
+      "                              (None, 256)]                                                        \n",
+      "                                                                                                  \n",
+      " decoder_lstm1 (LSTM)        [(None, None, 256),          324608    ['decoder_inputs[0][0]',      \n",
+      "                              (None, 256),                           'encoder_lstm1[0][1]',       \n",
+      "                              (None, 256)]                           'encoder_lstm1[0][2]']       \n",
+      "                                                                                                  \n",
+      " encoder_lstm2 (LSTM)        [(None, 256),                525312    ['encoder_lstm1[0][0]']       \n",
+      "                              (None, 256),                                                        \n",
+      "                              (None, 256)]                                                        \n",
+      "                                                                                                  \n",
+      " decoder_lstm2 (LSTM)        [(None, None, 256),          525312    ['decoder_lstm1[0][0]',       \n",
+      "                              (None, 256),                           'encoder_lstm2[0][1]',       \n",
+      "                              (None, 256)]                           'encoder_lstm2[0][2]']       \n",
+      "                                                                                                  \n",
+      " decoder_dense (Dense)       (None, None, 60)             15420     ['decoder_lstm2[0][0]']       \n",
+      "                                                                                                  \n",
+      "==================================================================================================\n",
+      "Total params: 1681468 (6.41 MB)\n",
+      "Trainable params: 1681468 (6.41 MB)\n",
+      "Non-trainable params: 0 (0.00 Byte)\n",
+      "__________________________________________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "from keras.models import Model\n",
+    "from keras.layers import Input, LSTM, Dense, RNN\n",
+    "layers = [256,128] # we loop LSTMCells then wrap them in an RNN layer\n",
+    "latent_dim = 256\n",
+    "\n",
+    "encoder_inputs = Input(shape=(None, num_encoder_tokens), name='encoder_inputs')\n",
+    "\n",
+    "e_outputs, h1, c1 = LSTM(latent_dim, return_state=True, return_sequences=True, name='encoder_lstm1')(encoder_inputs)\n",
+    "_, h2, c2 = LSTM(latent_dim, return_state=True, name='encoder_lstm2')(e_outputs)\n",
+    "encoder_states = [h1, c1, h2, c2]\n",
+    "\n",
+    "decoder_inputs = Input(shape=(None, num_decoder_tokens), name='decoder_inputs')\n",
+    "\n",
+    "out_layer1 = LSTM(latent_dim, return_sequences=True, return_state=True, name='decoder_lstm1')\n",
+    "d_outputs, dh1, dc1 = out_layer1(decoder_inputs, initial_state=[h1, c1])\n",
+    "\n",
+    "out_layer2 = LSTM(latent_dim, return_sequences=True, return_state=True, name='decoder_lstm2')\n",
+    "final, dh2, dc2 = out_layer2(d_outputs, initial_state=[h2, c2])\n",
+    "\n",
+    "decoder_dense = Dense(num_decoder_tokens, activation='softmax', name='decoder_dense')\n",
+    "decoder_outputs = decoder_dense(final)\n",
+    "\n",
+    "model = Model([encoder_inputs, decoder_inputs], decoder_outputs)\n",
+    "\n",
+    "model.summary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "tVcfVOwioggR",
+    "outputId": "8b0c76e6-8a81-4531-da76-90b0e36f2dda"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/20\n",
+      "6435/6435 [==============================] - 916s 142ms/step - loss: 0.5904 - accuracy: 0.8316 - val_loss: 0.3925 - val_accuracy: 0.8818\n",
+      "Epoch 2/20\n",
+      "6435/6435 [==============================] - 906s 141ms/step - loss: 0.1990 - accuracy: 0.9351 - val_loss: 0.1797 - val_accuracy: 0.9392\n",
+      "Epoch 3/20\n",
+      "6435/6435 [==============================] - 906s 141ms/step - loss: 0.1368 - accuracy: 0.9547 - val_loss: 0.1442 - val_accuracy: 0.9506\n",
+      "Epoch 4/20\n",
+      "6435/6435 [==============================] - 908s 141ms/step - loss: 0.1127 - accuracy: 0.9624 - val_loss: 0.1038 - val_accuracy: 0.9627\n",
+      "Epoch 5/20\n",
+      "6435/6435 [==============================] - 907s 141ms/step - loss: 0.1001 - accuracy: 0.9664 - val_loss: 0.0852 - val_accuracy: 0.9690\n",
+      "Epoch 6/20\n",
+      "6435/6435 [==============================] - 907s 141ms/step - loss: 0.0922 - accuracy: 0.9689 - val_loss: 0.0782 - val_accuracy: 0.9714\n",
+      "Epoch 7/20\n",
+      "6435/6435 [==============================] - 907s 141ms/step - loss: 0.0865 - accuracy: 0.9708 - val_loss: 0.0738 - val_accuracy: 0.9730\n",
+      "Epoch 8/20\n",
+      "6435/6435 [==============================] - 906s 141ms/step - loss: 0.0819 - accuracy: 0.9721 - val_loss: 0.0761 - val_accuracy: 0.9720\n",
+      "Epoch 9/20\n",
+      "6435/6435 [==============================] - 905s 141ms/step - loss: 0.0782 - accuracy: 0.9733 - val_loss: 0.0751 - val_accuracy: 0.9723\n",
+      "Epoch 10/20\n",
+      "6435/6435 [==============================] - 905s 141ms/step - loss: 0.0751 - accuracy: 0.9743 - val_loss: 0.0885 - val_accuracy: 0.9695\n",
+      "Epoch 11/20\n",
+      "6435/6435 [==============================] - 907s 141ms/step - loss: 0.0723 - accuracy: 0.9751 - val_loss: 0.0649 - val_accuracy: 0.9758\n",
+      "Epoch 12/20\n",
+      "6435/6435 [==============================] - 906s 141ms/step - loss: 0.0699 - accuracy: 0.9759 - val_loss: 0.0672 - val_accuracy: 0.9747\n",
+      "Epoch 13/20\n",
+      "6435/6435 [==============================] - 907s 141ms/step - loss: 0.0675 - accuracy: 0.9766 - val_loss: 0.0666 - val_accuracy: 0.9752\n",
+      "Epoch 14/20\n",
+      "6435/6435 [==============================] - 907s 141ms/step - loss: 0.0654 - accuracy: 0.9773 - val_loss: 0.0709 - val_accuracy: 0.9736\n",
+      "Epoch 15/20\n",
+      "6435/6435 [==============================] - 906s 141ms/step - loss: 0.0635 - accuracy: 0.9778 - val_loss: 0.0633 - val_accuracy: 0.9762\n",
+      "Epoch 16/20\n",
+      "6435/6435 [==============================] - 906s 141ms/step - loss: 0.0616 - accuracy: 0.9784 - val_loss: 0.0637 - val_accuracy: 0.9762\n",
+      "Epoch 17/20\n",
+      "6435/6435 [==============================] - 906s 141ms/step - loss: 0.0598 - accuracy: 0.9789 - val_loss: 0.0655 - val_accuracy: 0.9756\n",
+      "Epoch 18/20\n",
+      "6435/6435 [==============================] - 905s 141ms/step - loss: 0.0582 - accuracy: 0.9794 - val_loss: 0.0645 - val_accuracy: 0.9760\n",
+      "Epoch 19/20\n",
+      "6435/6435 [==============================] - 905s 141ms/step - loss: 0.0566 - accuracy: 0.9799 - val_loss: 0.0640 - val_accuracy: 0.9759\n",
+      "Epoch 20/20\n",
+      "6435/6435 [==============================] - 906s 141ms/step - loss: 0.0551 - accuracy: 0.9804 - val_loss: 0.0646 - val_accuracy: 0.9760\n",
+      "INFO:tensorflow:Assets written to: s2s/assets\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:tensorflow:Assets written to: s2s/assets\n"
+     ]
+    }
+   ],
+   "source": [
+    "batch_size = 64  # Batch size for training.\n",
+    "epochs = 20\n",
+    "model.compile(\n",
+    "    optimizer=\"rmsprop\", loss=\"categorical_crossentropy\", metrics=[\"accuracy\"]\n",
+    ")\n",
+    "history=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.2,\n",
+    ")\n",
+    "# Save model\n",
+    "model.save(\"s2s\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "pPg8_FY2Vw1v"
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 447
+    },
+    "id": "PRTb9JtnVw4M",
+    "outputId": "113afba2-b594-41af-f1b7-1061154113a5"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAowElEQVR4nO3deZxU5Z3v8c+vlq7qfYfuZhFwYxOhQ1DHJRhiFE1iTEzEmMVkDNHEJM6dzMRJZhJz83KyXsc4o2GMV+NMNMZr3JJBzYZR4xJAEUFAEFGapqFpoBd6qe6u5/5xqleqoaCX6qr6vl+vetWpc05V/fpQfOvUc87zHHPOISIiqc+X7AJERGRkKNBFRNKEAl1EJE0o0EVE0oQCXUQkTQSS9cZlZWVu2rRpyXp7EZGUtHbt2n3OufJ4y5IW6NOmTWPNmjXJensRkZRkZm8PtUxNLiIiaUKBLiKSJhIKdDO7yMy2mNk2M7txiHUWm9k6M9toZn8e2TJFRORojtqGbmZ+4HbgAqAGWG1mjzvnXu+3ThFwB3CRc+4dM5swSvWKyDjV2dlJTU0N7e3tyS4lLYTDYSZPnkwwGEz4OYkcFF0EbHPObQcwsweAS4HX+63zCeBh59w7AM65vQlXICJpoaamhvz8fKZNm4aZJbuclOaco6GhgZqaGqZPn57w8xJpcpkE7Oz3uCY2r79TgGIze9rM1prZp+O9kJktN7M1Zramvr4+4SJFZPxrb2+ntLRUYT4CzIzS0tJj/rWTSKDH+9cZPERjAHgXcAlwIfAvZnbKYU9y7k7n3ELn3MLy8rinUYpIClOYj5zj2ZaJBHoNMKXf48lAbZx1nnTOHXLO7QOeAU4/5moSsLmuiR8+uZnG1s7ReHkRkZSVSKCvBk42s+lmlgUsAx4ftM5jwLlmFjCzHOAMYNPIlup5u6GVO55+k3f2t47Gy4tIijp48CB33HHHMT/v4osv5uDBgyNfUBIcNdCdc13A9cBTeCH9oHNuo5lda2bXxtbZBDwJrAf+CtzlnNswGgVXFWYDUNvYNhovLyIpaqhA7+7uPuLzVq5cSVFR0ShVNbYS6vrvnFsJrBw0b8Wgxz8CfjRypcVXURgGoK5Rp0aJSJ8bb7yRN998k/nz5xMMBsnLy6OyspJ169bx+uuv8+EPf5idO3fS3t7OV7/6VZYvXw70DUPS0tLC0qVLOeecc3j++eeZNGkSjz32GNnZ2Un+yxKXtLFcjldpbhZBv2kPXWQc+85vNvJ6bdOIvubsqgK+/cE5Qy7//ve/z4YNG1i3bh1PP/00l1xyCRs2bOg97e/uu++mpKSEtrY23v3ud/PRj36U0tLSAa+xdetWfvnLX/Kzn/2Mj3/84/z617/mk5/85Ij+HaMp5QLd5zMqCsPaQxeRI1q0aNGAc7hvu+02HnnkEQB27tzJ1q1bDwv06dOnM3/+fADe9a53sWPHjrEqd0SkXKADVBZks1uBLjJuHWlPeqzk5ub2Tj/99NP84Q9/4IUXXiAnJ4fFixfHPcc7FAr1Tvv9ftraUqslICUH56osCrNbTS4i0k9+fj7Nzc1xlzU2NlJcXExOTg6bN2/mxRdfHOPqxkZK7qFXFIbZ09hBNOrw+dSRQUSgtLSUs88+m7lz55Kdnc3EiRN7l1100UWsWLGCefPmceqpp3LmmWcmsdLRk5KBXlkQJtIdZX9rhLK80NGfICIZ4f777487PxQK8cQTT8Rd1tNOXlZWxoYNfWdbf+1rXxvx+kZbija5eKcR7T6odnQRkR6pGeixc9HVji4i0iclA723c1GT9tBFRHqkZKCX5Ya8zkVqchER6ZWSge7zGRMLwtSpyUVEpFdKBjp4g3TVqnORiEivlA10df8XkeHIy8sDoLa2lssvvzzuOosXL2bNmjVHfJ1bb72V1ta+4byTORxvygZ6ZSzQnRt88SQRkcRVVVXx0EMPHffzBwd6MofjTelAj3RHaTgUSXYpIjIOfP3rXx8wHvpNN93Ed77zHZYsWUJ1dTWnnXYajz322GHP27FjB3PnzgWgra2NZcuWMW/ePK644ooBY7lcd911LFy4kDlz5vDtb38b8Ab8qq2t5fzzz+f8888HvOF49+3bB8Att9zC3LlzmTt3Lrfeemvv+82aNYvPf/7zzJkzh/e///0jNmZMSvYUBaiIXeiirrFdvUVFxpsnboS610b2NStOg6XfH3LxsmXLuOGGG/jiF78IwIMPPsiTTz7J3/3d31FQUMC+ffs488wz+dCHPjTk9Tp/+tOfkpOTw/r161m/fj3V1dW9y26++WZKSkro7u5myZIlrF+/nq985SvccsstrFq1irKysgGvtXbtWu655x5eeuklnHOcccYZvOc976G4uHjUhulN6T10QKMuiggACxYsYO/evdTW1vLqq69SXFxMZWUl3/jGN5g3bx7ve9/72LVrF3v27BnyNZ555pneYJ03bx7z5s3rXfbggw9SXV3NggUL2LhxI6+//voR63nuuee47LLLyM3NJS8vj4985CM8++yzwOgN05uye+iVReotKjJuHWFPejRdfvnlPPTQQ9TV1bFs2TLuu+8+6uvrWbt2LcFgkGnTpsUdNre/eHvvb731Fj/+8Y9ZvXo1xcXFXH311Ud9nSMd3xutYXpTdg+9LDdEwGfaQxeRXsuWLeOBBx7goYce4vLLL6exsZEJEyYQDAZZtWoVb7/99hGff95553HfffcBsGHDBtavXw9AU1MTubm5FBYWsmfPngEDfQ01bO95553Ho48+SmtrK4cOHeKRRx7h3HPPHcG/9nApu4fe07lo90HtoYuIZ86cOTQ3NzNp0iQqKyu56qqr+OAHP8jChQuZP38+M2fOPOLzr7vuOj772c8yb9485s+fz6JFiwA4/fTTWbBgAXPmzGHGjBmcffbZvc9Zvnw5S5cupbKyklWrVvXOr66u5uqrr+59jWuuuYYFCxaM6lWQLFmn/S1cuNAd7fzOo/nYiufxmfGrL5w1QlWJyPHatGkTs2bNSnYZaSXeNjWztc65hfHWT9kmF/DOdNEAXSIinpQO9KrCMLvVuUhEBEjxQK8oDBPpirJfnYtExgXtXI2c49mWKR3oOhddZPwIh8M0NDQo1EeAc46GhgbC4fAxPS9lz3IBqIz1Ft3d2M7cSYVJrkYks02ePJmamhrq6+uTXUpaCIfDTJ48+Ziek+KBHrtykToXiSRdMBhk+vTpyS4joyXU5GJmF5nZFjPbZmY3xlm+2MwazWxd7PatkS/1cKV56lwkItLjqHvoZuYHbgcuAGqA1Wb2uHNu8EAGzzrnPjAKNQ7J39O5SIEuIpLQHvoiYJtzbrtzLgI8AFw6umUlrrIwrPFcRERILNAnATv7Pa6JzRvsLDN71cyeMLM5I1JdAiqLsrWHLiJCYoEeb+DgweclvQyc4Jw7Hfh34NG4L2S23MzWmNmakToSXqnORSIiQGKBXgNM6fd4MlDbfwXnXJNzriU2vRIImtnA0d69ZXc65xY65xaWl5cPo+w+FQVe56IDrZ0j8noiIqkqkUBfDZxsZtPNLAtYBjzefwUzq7DYIMJmtij2ug0jXWw8VbFx0Ws16qKIZLijnuXinOsys+uBpwA/cLdzbqOZXRtbvgK4HLjOzLqANmCZG6M2kP6XolPnIhHJZAl1LIo1o6wcNG9Fv+n/AP5jZEtLTG/3f426KCIZLqXHcgEo6+lcpCYXEclwKR/oPZ2L6nTqoohkuJQPdOg7dVFEJJOlRaBXqLeoiEh6BLo6F4mIpE2gZ9OhzkUikuHSJNB7rlykZhcRyVxpEegVvRe60IFREclcaRHoVUVeb9FaBbqIZLC0CPSyvBB+n+lSdCKS0dIi0P0+Y2J+SOeii0hGS4tAh9iFLg4q0EUkc6VNoFcUhqnTAF0iksHSJtCrYr1F1blIRDJV2gR6RWE27Z1RDqpzkYhkqLQJ9L7ORWp2EZHMlIaBrlMXRSQzpVGge52LtIcuIpkqbQK9PL+nc5ECXUQyU9oEek/nolo1uYhIhkqbQIfYuejaQxeRDJVWgV5ZlK1AF5GMlV6BXhCmVp2LRCRDpVWgVxSGae+M0timzkUiknnSKtB7xkXXqYsikonSKtAr1LlIRDJYWgW6uv+LSCZLq0CfkB/G7zONiy4iGSmhQDezi8xsi5ltM7Mbj7Deu82s28wuH7kSE+f3GRN05SIRyVBHDXQz8wO3A0uB2cCVZjZ7iPV+ADw10kUeC+9CF2pDF5HMk8ge+iJgm3Nuu3MuAjwAXBpnvS8Dvwb2jmB9x6yqUJeiE5HMlEigTwJ29ntcE5vXy8wmAZcBK0autONTURhmd2O7OheJSMZJJNAtzrzBaXkr8HXnXPcRX8hsuZmtMbM19fX1CZZ4bCoLw7R1dtPU1jUqry8iMl4lEug1wJR+jycDtYPWWQg8YGY7gMuBO8zsw4NfyDl3p3NuoXNuYXl5+fFVfGAHvHAHdMZvVukZF12jLopIpkkk0FcDJ5vZdDPLApYBj/dfwTk33Tk3zTk3DXgI+KJz7tGRLhaAutfgqX+CPRviLu7pXKRBukQk0xw10J1zXcD1eGevbAIedM5tNLNrzeza0S7wMFULvPvaV+IvLlLnIhHJTIFEVnLOrQRWDpoX9wCoc+7q4Zd1BAWTILd8yEAvzwvhM3X/F5HMk3o9Rc2gqnrIQA/4fUzID2sPXUQyTuoFOnjNLvWbIXIo7uLKorD20EUk46RuoLso7F4fd3FlofbQRSTzpGigz/fuh2h2qSz0LkWnzkUikklSM9DzKyC/6giBHqY1os5FIpJZUjPQASYNfWC090IXGqRLRDJI6gZ61Xxo2ArtTYct6uktqnZ0EckkKRzosQ5Gu9cdtqj3ykUadVFEMkjqBnrl0D1GJ+R7nYvqdOqiiGSQ1A303FIomho30NW5SEQyUeoGOnjNLkc4MKpAF5FMkuKBXu0Np9u6//BF6i0qIhkmxQN96Hb0ioJsXblIRDJKagd65enefZxA7+1c1K7ORSKSGVI70LOLoOTE+IFepAtdiEhmSe1Ah9iB0XWHze45F12XohORTJH6gT6pGppqoGXvgNkVsd6i2kMXkUyR+oE+xIHRns5FOnVRRDJF6gd6xTzADgv0oN9HeX6I3QfV5CIimSH1Az2UB+Wnxj91sTCbuibtoYtIZkj9QIe+HqODzjmvKgxTqz10EckQaRLo1dCyB5p3D5jd0/1fnYtEJBOkSaDHPzBaVZhNa6Sb5g51LhKR9JcegV4xF8wPu14eOFvjootIBkmPQA9mw4TZh+2h917oQp2LRCQDpEegg3dJukEHRiuL1LlIRDJH+gT6pGpo2w8H3+mdNSE/hBnUKtBFJAOkT6DHOTAa9PsozwvpUnQikhESCnQzu8jMtpjZNjO7Mc7yS81svZmtM7M1ZnbOyJd6FBNmgz8LagceGK0sylb3fxHJCEcNdDPzA7cDS4HZwJVmNnvQan8ETnfOzQc+B9w1wnUeXSAEE+ccfmC0QJeiE5HMkMge+iJgm3Nuu3MuAjwAXNp/Bedci+vrvZMLJKcnT9UCqH0VotHeWZVFYR0UFZGMkEigTwJ29ntcE5s3gJldZmabgf/B20s/jJktjzXJrKmvrz+eeo+sqho6GuHAW72zKgvDtHR00dTeOfLvJyIyjiQS6BZn3mF74M65R5xzM4EPA9+N90LOuTudcwudcwvLy8uPqdCExDkwqnHRRSRTJBLoNcCUfo8nA7VDreycewY40czKhlnbsSufCYHwgB6jVb2dixToIpLeEgn01cDJZjbdzLKAZcDj/Vcws5PMzGLT1UAW0DDSxR6VP+CNjz5gD72n+79OXRSR9BY42grOuS4zux54CvADdzvnNprZtbHlK4CPAp82s06gDbjCJWuIw6oF8MovINoNPj8TC8KYrlwkIhngqIEO4JxbCawcNG9Fv+kfAD8Y2dKO06Rq+Ot/wr6tMGFmv85FCnQRSW/p01O0R5wDo5WFYWrVW1RE0lz6BXrpSZCVN6DHaEWhzkUXkfSXfoHu80Pl6YP20LMV6CKS9tIv0MFrdql7Dbq9zkSVhWGaO7poVuciEUlj6RvoXe1QvxnQuOgikhnSN9Cht9ml58pFGhddRNJZegZ6yQwIFfb2GK0o8AJd46KLSDpLz0A367skHahzkYhkhPQMdPCaXfZshK4OsgI+yvJC7D6oQBeR9JW+gT6pGqKdXqjjtaPvblKgi0j6St9Aj3NgVG3oIpLO0jfQC6dATmlvj9HKwmw1uYhIWkvfQDeLXZJuHaDORSKS/tI30MEL9L2bINLaOy76HrWji0iaSvNArwbXDXs2UBm7FF2tml1EJE2leaD3HRjt6S2q7v8ikq7SO9ALKiGvAna9zMSCnu7/OtNFRNJTegc6xA6MvtLbuUh76CKSrjIj0Pe9AR3NVBWF1f1fRNJW+gf6pGrAwe71VBSE2a0mFxFJU+kf6JXzvfvaV6gqytYeuoikrfQP9Lxyr9do7StUFIZpbu+ipaMr2VWJiIy49A90iA2l+3K/UxfV7CIi6SdDAn0B7N/O5HAE0LjoIpKeMifQgSkdbwAKdBFJTxkV6CWN3tjoGnVRRNJRZgR6djEUTydQt87rXNSkNnQRST+ZEejg7aXv8sZ00QBdIpKOEgp0M7vIzLaY2TYzuzHO8qvMbH3s9ryZnT7ypQ5T1QJofIeT8trV/V9E0tJRA93M/MDtwFJgNnClmc0etNpbwHucc/OA7wJ3jnShwxZrR68O7FBvURFJS4nsoS8CtjnntjvnIsADwKX9V3DOPe+cOxB7+CIweWTLHAGVpwPGKd1v0tTexSF1LhKRNJNIoE8CdvZ7XBObN5S/BZ6It8DMlpvZGjNbU19fn3iVIyFcAGUnM7V9MwCb65rG9v1FREZZIoFucea5uCuanY8X6F+Pt9w5d6dzbqFzbmF5eXniVY6UqgVMbHmdsrwQ33xkAx1d3WNfg4jIKEkk0GuAKf0eTwZqB69kZvOAu4BLnXMNI1PeCKtagK+ljlsvmcDmumZu+d0bya5IRGTEJBLoq4GTzWy6mWUBy4DH+69gZlOBh4FPOefGb0rGDoyek7OLq86Yyp3PbufF7ePzu0dE5FgdNdCdc13A9cBTwCbgQefcRjO71syuja32LaAUuMPM1pnZmlGreDgq5oH5oPYVvnnJLKaV5vL3D75KU3tnsisTERm2hM5Dd86tdM6d4pw70Tl3c2zeCufcitj0Nc65Yufc/Nht4WgWfdyycqB8FtS+Qk5WgH+7Yj51Te18+7GNya5MRGTYMqenaI+qBbDrZXCO+VOK+PJ7T+KRV3bx2/WHHRYQEUkpGRjo86F1H+x4DoDrzz+J+VOK+OYjG9SDVERSWuYF+qwPQfE0+MVHYN39BPw+/u2K+US6ovzDQ68SjcY9I1NEZNzLvEDPnwifXwVTz4RHr4Onvsn04hD//IFZPLt1H/e+sCPZFYqIHJfMC3SAnBL45MOw6Avwwn/A/R/jE6cVsGTmBL7/xGa27mlOdoUiIscsMwMdwB+Ei38IH7wN3noWu2sJP1qcTW4owA2/WkekK5rsCkVEjknmBnqPd30GPvMb6Gii5JdLueus/WysbeLWP4zf/lEiIvEo0AFOOMtrVy8+gernvsDt055jxZ+3sXrH/mRXJiKSMAV6j6Ip8LmnYPalXFJ3Bz/NuZOvP/BXmtWLVERShAK9v6xc+NjP4b3/zIXdf+aW1m9w68PPJLsqEZGEKNAHM4Pz/gGuuI/Zgd0s3/I5XnjmqWRXJSJyVAr0ocz6AHbN73D+ENV/uorGF3+R7IpERI5IgX4EwarTaP3M73klegqFT34J97t/gaguiiEi45MC/ShmnHACb7z/Xu7tugB7/ja4/wpob0x2WSIih1GgJ+BTZ5/EH2f8I9+KXoPbvgp+tgQO7Eh2WSIiAyjQE2Bm/OjyeTweuJBv5N+MO1QPd18EezcluzQRkV4K9ARNLAjzr5edxi/3TOG/Zv4UnIN7lkLN2mSXJiICKNCPycWnVfKR6kl85yXH7SfeQXeoEO79IGx/OtmliYgo0I/V/750Lh+pnsyP/9rOhY3fYH+oCnffx2DTb5JdmohkOAX6McoLBfjxx07nt18+h4mTTmDxvn9go5uO+9WncS//d7LLE5EMpkA/TnOqCvnF357BT64+n3/K/S7Pds/BHr+eXU/8ONmliUiGUqAPg5lx/swJPHLDBdQu/Tm/t7OY9NJ3efK2L7Gz4VCyyxORDKNAHwEBv49lf3MSZ/3jY6yfcCkX7f8Fz9x6Nd/7n400tmm0RhEZGwr0EZSXHWLedffSsvBLXOX/HbNf/BpLfvh77vnLW7oCkoiMukCyC0g7ZuR94F+hqJxL/3ATU7O6uPI313Hv8zu4celMLpxTgZklu0oRSUPaQx8t5/wdfPAnzO9YzYuTb6fQ18q1v3iZj//nC7zyzoFkVyciacicc0l544ULF7o1a9Yk5b3H1IaH4eHluPKZPDznNr73TAP7WiLMKMvl/JkTOP/UCbx7ejGhgD/ZlYpICjCztc65hXGXKdDHwLY/wK8+BfmVHFr2ax7aZvxx815e3N5ApCtKbpafs08q4/yZE1h8ajmVhdnJrlhExqlhB7qZXQT8BPADdznnvj9o+UzgHqAa+KZz7qgnY2dUoAO88xLc/zEI5sKnH4XyU2mNdPH8tgZWbdnLqs17qW1sB2BWZQHnn1rOe2dOYP6UIgJ+tYyJiGdYgW5mfuAN4AKgBlgNXOmce73fOhOAE4APAwcU6EOo2wD/fRlEO+Gc/wXVn4LsYgCcc7yxp4VVW/byp817Wfv2AbqjjsLsIOedUs57Z5Zz3snllOaFkvxHiEgyDTfQzwJucs5dGHv8TwDOue/FWfcmoEWBfgQNb8LjX4G3n4NgDsy7As74AkyYNWC1xrZOntu6jz9t3suf39jLvpYIZjB/ShHvOaWc0ycXMauygIkFIZ01I5JBjhToiZy2OAnY2e9xDXDGcRayHFgOMHXq1ON5idRXeiJ89n+g7jV4aQWsux/W3gMzFsMZ18LJ7wefn8LsIJfMq+SSeZVEo47XdjV6TTNb6vnJH7fS8z1ckpvFrMp8ZlUUMKvSu500IY+sgJppRDJNInvoHwMudM5dE3v8KWCRc+7Lcda9Ce2hH5tDDfDyz+Gvd0FzLRRPg0XLYf5VkF0U9ymNbZ1s3t3Ept1NbNrdzKa6JrbUNdMR67wU9Bsnlucxu7KA2VV9QV+SmzVmf5aIjI7h7qHXAFP6PZ4M1I5EYQLklsK5fw9/8xXY/Ft46T/hqW/An26G+Z/wwr38lAFPKcwOcsaMUs6YUdo7r6s7yo6GQ7y+uzkW9E385c19PPzKrt51JhaEmFVZwMyKAqaV5jC1JIcpJTlUFoZ14FUkDSSyhx7AOyi6BNiFd1D0E865jXHWvQntoQ9f7Tov2Dc8BN0ROHGJ1xxz0vvAd2zB29DS4e3Fx0L+9d1NvFnfQmd337+732dMKspmSkk2U0tymFzcF/ZTS3IozgmmTzu9c9DaADmlkC5/k2SUkTht8WLgVrzTFu92zt1sZtcCOOdWmFkFsAYoAKJACzDbOdc01Gsq0BPQUg9rfw6r74KWOig50TuAevqVEC447pft6o6yu7GdnQda2bm/lZ3723hnfyvv7G+l5kAr+1oiA9bPzfIzpV/ATynOpqIwm4rCMBMLQpTnhcb3Hn60G955Ebas9G77t8OUM+CC78LU4zocJJI06liU6roisOlx7yBqzWrv7JgJs6H8VO9WdqrXLFN0AviG3+P0UEcXNQf6Qn5nz+2A97i9c+BAYz6DsrxQLODDVBSEe6cnFoSoKAgzsTBMfigwdnv6kUPw5p9g80p440lo2w/+LJh+HlRVw8v3QssemPkBWPLtw5q1RMYrBXo6qVkLrz0Ie1+H+i1eKPUIhKH0ZC+cymdC2Sle4JecCIGROSDqnGNfS4Q9Te3UNbZT19TeO72nuYM9sXnxhg3OyfJ74V4QpjQvi7K8EKW5WZTkZVGaG6I0L4vS3CxK80IUhI8j/Fv2wpYnvL3w7U9DVzuEi+CUC+HUi+GkJRDK99aNHIIX7oC/3AqdbVD9aVh8I+RXDHcTiYwqBXo6azsA+7ZC/WYv4Pe94U0ffKdvHfNDyYzY3nws5AuqIL/SC7CekBvJsiLd7OkJ+97Q7+id13AoQkNLB03tXXGfH/QbJbkDg76k33RRThbF2QEmRN6hfNcfyNnxO3w1awAHRVPh1Etg5sUw9SzwB4cutKUenvkhrLnb24M/63o4+yujsk1ERoICPRNFWqFhqxfy9VtgX+x+/3aIDgrRrDwv2PMqvPv8ir6w7z+dlTv0+0Wj0HkIOpqho8W7jzTHfxxp9ZqG/EG6CdAa9dPabbR0+mjpMpojRlOn0RiBgxHjYLtjfwfsb3M0d/rIsi7O9a3nAt9aZvjqAFgfnc7TvJvVoTNpyD2ZotwsinOyKMwJUpwTpCg7i6KcoPdFkBOkIDtIYewWCviw/dvhT9+FjY9ATpm3t/6uq4/8ZSCSBAp06dMVgYNvQ1Ot11zTvBua6/rdx6a72g9/bqgA8iZCbrm3PNLSF9iRFiCBz5Iv4H0xOOedwdMdAXfsF/+I+oI0TjyTmgmL2Vp8LrXREg62dnKgtZPGtggHWjs52BrhYGsnB9s66Y4OXVuW30dBdpCC7AALA9v5bOs9zOpYz76syfxl2hepq7qQwpwsCrP7vgjyQgHywwHywgGNlCljSoEux8Y5aG/sC/fBwX+oAYJhb88+lN93G/JxnvdlkJUHgdDhpwtGu6G7Mxbwnd5YNz3TvfedfV8AOKhaAOHCBP8cR3NHF42tnRyIhXxjWydN7bH7tq7ex01tnTS1RpjV8iLXdNzLSezklehJfK/zSv7qZsV9/ayAj/x+AZ8fCnr34UBsft/jvFCAgtjj3Ky+ebmhwMj27nUO2g9C8x7vDKn+94fqvSa3iXO8g+tlp4zYMRYZfQp0keMR7catux+36mZ8zbtpnvo+3pr/NepC02np6KK5vYuWji6a2ju96fYumts7e5c1t3fR1t6G62ghx7WRZ23k0k6ueb9+uvERxUe389GND5/fTzgrSCgri1AwSDgUJJyVRXYoi3AoSHYoRHYoi5xQgBKaKYrup6CrgfzOfeR07CPcXk+wbS/+1r1Yyx4s3q+sYK7Xma1pt/fFCd6vptKTYeJsL+B7gr5oqs7VH4cU6CLD0dkGL/4UnrvVOw4wbxkUnxBrbmoe1PTUPLAZKl6ojoJGl8NeV8xeV8ReithHMQf8JbQEymjJKqMtVEYkuxx/uMD7RRB0TI7uYnJkB5Udb1Le+iYlLVvJbevrBN4dzCNSOpNo+WxswmwCVXMJVs7FcoqPv1DnvF9kXe3Q2eqdbdTZNmj6kHecZcB07NYzbT7vIHYgy7v3Z3nHO/xZcW795vesb36vk575veM5vkDftPli9/5B9/3m47xjUdHu2K3Lu7nuI8zr6rsvPQkq5h7XJlSgi4yE1v3wzI9h9c+8pp9grtec1L+pqX8zU1asqWnAOrFp8P5z9/xnd93egeUBj7u94wv9Hnd1d9ER6aQ9WMShYBmNwVIafSW0RAO0dHRzqMP71XCoo4vWSHfv9OB5rZFuWiNdh/UpyKOVU6yGmb6dnGrvxO53UmSHetfZ44rpsBABc/jN4SeKnyi+2LT3u8Phc1GMKD7XjeGw2P2xM6/vRVYOBLO9aeegu2NgU1zP9OCD/uPR2TfABd85rqcq0EVGUlcktleX+gdDo1FHW2c3rZFu2iLdtHZ29U3HQr+towuad5Pb+Ab5jVsoPLQd64oQcUZn1IhEjc4oRKJGpBs6YveRqPU2K0WJTcealzoI0kaIVheijb6bC2QTDeZCMIwFcyGUSyCYTXYoQHaWn+ygn5wsP+Ggd8sO+gkHfWQH/WRn+QkF/GQHINsfJcffTbYvStjXTdjXRci6CFs3Add52Bdl35700b9Ucd2xvfXAwD38wXv6/ef5An3P8QUgtwzyJhzXv9lwB+cSkf7S6ACiz2fkxg7KHtkJwJnH9No9XxaHIl0DviB6vjDaOvu+OHqme75c2jtjXyadUdoiXextbvfmR7pp7fSWD/51kaig3wgH/ISCfrKzfIQDfsLBIOFgqPeLwvuy8A14HA72rBub9vfNCwV9hPot86a95wfHcFgMBbqIjIrEvyyOTzTq6OiK0t4Z+0LoDXov7Hu+IAbMG7BetN8yb35zexf1zR19y7uG9+UB3uB34YCPUNBPOOCF/CfOmMo1584Ywa3hUaCLSEry+cxrhsnyM4zDtAlxbuCXR3tnlI6ugV8KPcs7Yl8EHT3L+q3Xs07ZKF1KUoEuInIUZtbb9FKU7GKOYByPeSoiIsdCgS4ikiYU6CIiaUKBLiKSJhToIiJpQoEuIpImFOgiImlCgS4ikiaSNjiXmdUDbx/n08uAfSNYzkgb7/XB+K9R9Q2P6hue8VzfCc658ngLkhbow2Fma4YabWw8GO/1wfivUfUNj+obnvFe31DU5CIikiYU6CIiaSJVA/3OZBdwFOO9Phj/Naq+4VF9wzPe64srJdvQRUTkcKm6hy4iIoMo0EVE0sS4DnQzu8jMtpjZNjO7Mc5yM7PbYsvXm1n1GNY2xcxWmdkmM9toZl+Ns85iM2s0s3Wx27fGqr7Y++8ws9di733YFbmTvP1O7bdd1plZk5ndMGidMd9+Zna3me01sw395pWY2e/NbGvsPu4Fco72eR3F+n5kZptj/4aPmFnREM894udhFOu7ycx29ft3vHiI5yZr+/2qX207zGzdEM8d9e03bM65cXkD/MCbwAwgC3gVmD1onYuBJwDDu4LtS2NYXyVQHZvOB96IU99i4LdJ3IY7gLIjLE/a9ovzb12H12EiqdsPOA+oBjb0m/dD4MbY9I3AD4b4G474eR3F+t4PBGLTP4hXXyKfh1Gs7ybgawl8BpKy/QYt/z/At5K1/YZ7G8976IuAbc657c65CPAAcOmgdS4F/st5XgSKzKxyLIpzzu12zr0cm24GNgGTxuK9R1DStt8gS4A3nXPH23N4xDjnngH2D5p9KXBvbPpe4MNxnprI53VU6nPO/c451xV7+CIweaTfN1FDbL9EJG379TAzAz4O/HKk33esjOdAnwTs7Pe4hsMDM5F1Rp2ZTQMWAC/FWXyWmb1qZk+Y2ZyxrQwH/M7M1prZ8jjLx8X2A5Yx9H+iZG6/HhOdc7vB+yIHJsRZZ7xsy8/h/eqK52ifh9F0faxJ6O4hmqzGw/Y7F9jjnNs6xPJkbr+EjOdAtzjzBp9jmcg6o8rM8oBfAzc455oGLX4ZrxnhdODfgUfHsjbgbOdcNbAU+JKZnTdo+XjYflnAh4D/F2dxsrffsRgP2/KbQBdw3xCrHO3zMFp+CpwIzAd24zVrDJb07QdcyZH3zpO1/RI2ngO9BpjS7/FkoPY41hk1ZhbEC/P7nHMPD17unGtyzrXEplcCQTMrG6v6nHO1sfu9wCN4P2v7S+r2i1kKvOyc2zN4QbK3Xz97epqiYvd746yT7M/iZ4APAFe5WIPvYAl8HkaFc26Pc67bORcFfjbE+yZ7+wWAjwC/GmqdZG2/YzGeA301cLKZTY/txS0DHh+0zuPAp2Nna5wJNPb8NB5tsfa2/wtscs7dMsQ6FbH1MLNFeNu7YYzqyzWz/J5pvANnGwatlrTt18+Qe0XJ3H6DPA58Jjb9GeCxOOsk8nkdFWZ2EfB14EPOudYh1knk8zBa9fU/LnPZEO+btO0X8z5gs3OuJt7CZG6/Y5Lso7JHuuGdhfEG3tHvb8bmXQtcG5s24PbY8teAhWNY2zl4PwnXA+tit4sH1Xc9sBHviP2LwN+MYX0zYu/7aqyGcbX9Yu+fgxfQhf3mJXX74X257AY68fYa/xYoBf4IbI3dl8TWrQJWHunzOkb1bcNrf+75HK4YXN9Qn4cxqu+/Y5+v9XghXTmetl9s/s97Pnf91h3z7Tfcm7r+i4ikifHc5CIiIsdAgS4ikiYU6CIiaUKBLiKSJhToIiJpQoEuIpImFOgiImni/wOuKQJw+r4cZwAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 432x288 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "plt.plot(history.history['loss'])\n",
+    "plt.plot(history.history['val_loss'])\n",
+    "plt.legend(['train','validation'])\n",
+    "plt.show()\n",
+    "plt.savefig('trai_validation_loss')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 489
+    },
+    "id": "uaEwY_b0V93S",
+    "outputId": "7cc3860b-a274-462a-8a9c-360b4330ddf0"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 432x288 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "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', 'val'], loc='upper left')\n",
+    "plt.show()\n",
+    "plt.savefig('trai_validation_accuracy')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "5ejPmkDseEn0"
+   },
+   "source": [
+    "# Prediction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 16181,
+     "status": "ok",
+     "timestamp": 1691417034020,
+     "user": {
+      "displayName": "JOBANPREET SINGH",
+      "userId": "15968293240343091979"
+     },
+     "user_tz": -330
+    },
+    "id": "up50mntoTtsG"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2023-10-01 17:08:48.123898: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:894] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n",
+      "2023-10-01 17:08:48.124943: W tensorflow/core/common_runtime/gpu/gpu_device.cc:2211] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.\n",
+      "Skipping registering GPU devices...\n"
+     ]
+    }
+   ],
+   "source": [
+    "from keras.models import Model\n",
+    "from keras.layers import Input, LSTM, Dense, RNN\n",
+    "from tensorflow import keras\n",
+    "import numpy as np\n",
+    "import pickle\n",
+    "\n",
+    "model = keras.models.load_model(\"s2s\")\n",
+    "\n",
+    "with open(\"input_token_index.pkl\", \"rb\") as file:\n",
+    "    input_token_index = pickle.load(file)\n",
+    "\n",
+    "with open(\"target_token_index.pkl\", \"rb\") as file:\n",
+    "    target_token_index = pickle.load(file)\n",
+    "\n",
+    "num_encoder_tokens=len(input_token_index)\n",
+    "num_decoder_tokens=len(target_token_index)\n",
+    "latent_dim=256\n",
+    "max_encoder_seq_length=25\n",
+    "max_decoder_seq_length=24"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 15,
+     "status": "ok",
+     "timestamp": 1691417035680,
+     "user": {
+      "displayName": "JOBANPREET SINGH",
+      "userId": "15968293240343091979"
+     },
+     "user_tz": -330
+    },
+    "id": "9_9kU2VU6cA7",
+    "outputId": "79b2fa7f-fc0e-46b4-9f3c-0f8209621ae6"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"model\"\n",
+      "__________________________________________________________________________________________________\n",
+      " Layer (type)                Output Shape                 Param #   Connected to                  \n",
+      "==================================================================================================\n",
+      " encoder_inputs (InputLayer  [(None, None, 27)]           0         []                            \n",
+      " )                                                                                                \n",
+      "                                                                                                  \n",
+      " decoder_inputs (InputLayer  [(None, None, 60)]           0         []                            \n",
+      " )                                                                                                \n",
+      "                                                                                                  \n",
+      " encoder_lstm1 (LSTM)        [(None, None, 256),          290816    ['encoder_inputs[0][0]']      \n",
+      "                              (None, 256),                                                        \n",
+      "                              (None, 256)]                                                        \n",
+      "                                                                                                  \n",
+      " decoder_lstm1 (LSTM)        [(None, None, 256),          324608    ['decoder_inputs[0][0]',      \n",
+      "                              (None, 256),                           'encoder_lstm1[0][1]',       \n",
+      "                              (None, 256)]                           'encoder_lstm1[0][2]']       \n",
+      "                                                                                                  \n",
+      " encoder_lstm2 (LSTM)        [(None, 256),                525312    ['encoder_lstm1[0][0]']       \n",
+      "                              (None, 256),                                                        \n",
+      "                              (None, 256)]                                                        \n",
+      "                                                                                                  \n",
+      " decoder_lstm2 (LSTM)        [(None, None, 256),          525312    ['decoder_lstm1[0][0]',       \n",
+      "                              (None, 256),                           'encoder_lstm2[0][1]',       \n",
+      "                              (None, 256)]                           'encoder_lstm2[0][2]']       \n",
+      "                                                                                                  \n",
+      " decoder_dense (Dense)       (None, None, 60)             15420     ['decoder_lstm2[0][0]']       \n",
+      "                                                                                                  \n",
+      "==================================================================================================\n",
+      "Total params: 1681468 (6.41 MB)\n",
+      "Trainable params: 1681468 (6.41 MB)\n",
+      "Non-trainable params: 0 (0.00 Byte)\n",
+      "__________________________________________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.summary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 417,
+     "status": "ok",
+     "timestamp": 1691417038313,
+     "user": {
+      "displayName": "JOBANPREET SINGH",
+      "userId": "15968293240343091979"
+     },
+     "user_tz": -330
+    },
+    "id": "HcGQ2zw76cM8",
+    "outputId": "8c645685-813f-4cdd-d9ab-7655d20ad8a8"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<keras.src.engine.input_layer.InputLayer at 0x7fe97008fc10>,\n",
+       " <keras.src.engine.input_layer.InputLayer at 0x7fe969479e10>,\n",
+       " <keras.src.layers.rnn.lstm.LSTM at 0x7fe9694a1c10>,\n",
+       " <keras.src.layers.rnn.lstm.LSTM at 0x7fe96addda90>,\n",
+       " <keras.src.layers.rnn.lstm.LSTM at 0x7fe968d83fd0>,\n",
+       " <keras.src.layers.rnn.lstm.LSTM at 0x7fe968d92ad0>,\n",
+       " <keras.src.layers.core.dense.Dense at 0x7fe969e64c50>]"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.layers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "b3RguYBW7xKR",
+    "outputId": "1fc1a7d3-e784-4dcb-f802-a9248286cf0d"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<KerasTensor: shape=(None, None, 27) dtype=float32 (created by layer 'encoder_inputs')>,\n",
+       " <KerasTensor: shape=(None, None, 60) dtype=float32 (created by layer 'decoder_inputs')>]"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.input"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 928,
+     "status": "ok",
+     "timestamp": 1691417039973,
+     "user": {
+      "displayName": "JOBANPREET SINGH",
+      "userId": "15968293240343091979"
+     },
+     "user_tz": -330
+    },
+    "id": "87egvtLMTtwo"
+   },
+   "outputs": [],
+   "source": [
+    "encoder_inputs = model.input[0]  # input_1\n",
+    "encoder_lstm_1 = model.layers[2]\n",
+    "encoder_outputs_1, h1, c1 = encoder_lstm_1(encoder_inputs)\n",
+    "encoder_lstm_2 = model.layers[4]\n",
+    "encoder_outputs, h2, c2 = encoder_lstm_2(encoder_outputs_1)\n",
+    "encoder_states = [h1, c1, h2, c2]\n",
+    "decoder_inputs=model.input[1]\n",
+    "\n",
+    "out_layer1 = model.layers[3]\n",
+    "out_layer2 = model.layers[5]\n",
+    "\n",
+    "\n",
+    "decoder_dense = model.layers[6]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 1125,
+     "status": "ok",
+     "timestamp": 1691417043147,
+     "user": {
+      "displayName": "JOBANPREET SINGH",
+      "userId": "15968293240343091979"
+     },
+     "user_tz": -330
+    },
+    "id": "R5jt4ZFqogoT"
+   },
+   "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())\n",
+    "\n",
+    "\n",
+    "encoder_model = Model(encoder_inputs, encoder_states)\n",
+    "\n",
+    "decoder_state_input_h = Input(shape=(latent_dim,))\n",
+    "decoder_state_input_c = Input(shape=(latent_dim,))\n",
+    "decoder_state_input_h1 = Input(shape=(latent_dim,))\n",
+    "decoder_state_input_c1 = Input(shape=(latent_dim,))\n",
+    "decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c,\n",
+    "                         decoder_state_input_h1, decoder_state_input_c1]\n",
+    "d_o, state_h, state_c = out_layer1(\n",
+    "    decoder_inputs, initial_state=decoder_states_inputs[:2])\n",
+    "d_o, state_h1, state_c1 = out_layer2(\n",
+    "    d_o, initial_state=decoder_states_inputs[-2:])\n",
+    "decoder_states = [state_h, state_c, state_h1, state_c1]\n",
+    "decoder_outputs = decoder_dense(d_o)\n",
+    "decoder_model = Model(\n",
+    "    [decoder_inputs] + decoder_states_inputs,\n",
+    "    [decoder_outputs] + decoder_states)\n",
+    "\n",
+    "\n",
+    "def decode_sequence(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.\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, h1, c1 = decoder_model.predict(\n",
+    "            [target_seq] + states_value) #######NOTICE THE ADDITIONAL HIDDEN STATES\n",
+    "\n",
+    "        # Sample a token\n",
+    "        sampled_token_index = np.argmax(output_tokens[0, -1, :])\n",
+    "\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\n",
+    "           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.\n",
+    "\n",
+    "        # Update states\n",
+    "        states_value = [h, c, h1, c1]\n",
+    "\n",
+    "    return decoded_sentence"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 2670,
+     "status": "ok",
+     "timestamp": 1691417217198,
+     "user": {
+      "displayName": "JOBANPREET SINGH",
+      "userId": "15968293240343091979"
+     },
+     "user_tz": -330
+    },
+    "id": "xHrMZD5AwpNT",
+    "outputId": "8c32457e-7a4d-4474-e267-85c622434aef"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(3, 25, 27)\n",
+      "1/1 [==============================] - 0s 25ms/step\n",
+      "1/1 [==============================] - 0s 20ms/step\n",
+      "1/1 [==============================] - 0s 19ms/step\n",
+      "1/1 [==============================] - 0s 22ms/step\n",
+      "1/1 [==============================] - 0s 21ms/step\n",
+      "1/1 [==============================] - 0s 20ms/step\n",
+      "1/1 [==============================] - 0s 21ms/step\n",
+      "1/1 [==============================] - 0s 19ms/step\n",
+      "1/1 [==============================] - 0s 19ms/step\n",
+      "1/1 [==============================] - 0s 21ms/step\n",
+      "1/1 [==============================] - 0s 21ms/step\n",
+      "1/1 [==============================] - 0s 20ms/step\n",
+      "1/1 [==============================] - 0s 20ms/step\n",
+      "1/1 [==============================] - 0s 27ms/step\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "['ਤੁਸੀ\\n', 'ਵੇ\\n', 'ਜਾ\\n']"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "s = [\"tusi\",'ve','ja']\n",
+    "\n",
+    "encoder_input_data = np.zeros(\n",
+    "    (len(s), max_encoder_seq_length, num_encoder_tokens), dtype=\"float32\"\n",
+    ")\n",
+    "\n",
+    "print(encoder_input_data.shape)\n",
+    "\n",
+    "for i, input_text in enumerate(s):\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",
+    "\n",
+    "decoded_sentences = []\n",
+    "for input_data in encoder_input_data:\n",
+    "    decoded_sentence = decode_sequence(input_data[np.newaxis, :, :])\n",
+    "    decoded_sentences.append(decoded_sentence)\n",
+    "decoded_sentences\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "loiYIxj6wpS0",
+    "outputId": "f17c8474-2202-4536-f10d-c962ff88c9a2"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2.13.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "import tensorflow as tf\n",
+    "print(tf.__version__)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "j0YUpIcxLfbb"
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "T4",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

transliteration.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad0a5556d4fe7c6cf4ca1bbde4369aafd9e1edd176529fcaee1b503ecb3f75f8
+size 16052186