REVE TASK.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import keras\n",
    "from keras.models import Model\n",
    "from keras.layers import Input, LSTM, Dense,Dropout\n",
    "from sklearn.utils import shuffle\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import preprocessing\n",
    "from keras.preprocessing.sequence import pad_sequences\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.metrics import accuracy_score\n",
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'REVE TASK.ipynb'   base_form.txt      inflected_form.txt\r\n",
      " STEMMER.csv\t    decisiontree.sav   support_vector_machine.sav\r\n"
     ]
    }
   ],
   "source": [
    "!ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#loading ans shuffle the dataset\n",
    "df = pd.read_csv('STEMMER.csv')\n",
    "for i in range(5):\n",
    "    df = shuffle(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14500\n"
     ]
    }
   ],
   "source": [
    "print(len(df))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "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>inflected_form</th>\n",
       "      <th>base_form</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>10867</th>\n",
       "      <td>বাঁচতে থাকবই</td>\n",
       "      <td>বাঁচ</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3770</th>\n",
       "      <td>ঘুমাচ্ছি</td>\n",
       "      <td>ঘুমা</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13378</th>\n",
       "      <td>লিখেছিলামও</td>\n",
       "      <td>লিখ</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9612</th>\n",
       "      <td>পৌঁছলামই</td>\n",
       "      <td>পৌঁছ</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12884</th>\n",
       "      <td>রাখছিলেও</td>\n",
       "      <td>রাখ</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7093</th>\n",
       "      <td>তুললে</td>\n",
       "      <td>তুল</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10172</th>\n",
       "      <td>ফেলব</td>\n",
       "      <td>ফেল</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13103</th>\n",
       "      <td>লাগাতেনই</td>\n",
       "      <td>লাগা</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5633</th>\n",
       "      <td>জাগারও</td>\n",
       "      <td>জাগ</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12021</th>\n",
       "      <td>ভালবাসছিসই</td>\n",
       "      <td>ভালবাস</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      inflected_form base_form\n",
       "10867   বাঁচতে থাকবই      বাঁচ\n",
       "3770        ঘুমাচ্ছি      ঘুমা\n",
       "13378     লিখেছিলামও       লিখ\n",
       "9612        পৌঁছলামই      পৌঁছ\n",
       "12884       রাখছিলেও       রাখ\n",
       "7093           তুললে       তুল\n",
       "10172           ফেলব       ফেল\n",
       "13103       লাগাতেনই      লাগা\n",
       "5633          জাগারও       জাগ\n",
       "12021     ভালবাসছিসই    ভালবাস"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "bengali_alphabets_maping = {\"অ\":0,\"আ\":1,\"ই\":2,\"ঈ\":3,\"উ\":4,\"ঊ\":5,\"ঋ\":6,\"ঌ\":7,\"এ\":8,\"ঐ\":9,\"ও\":10,\"ঔ\":11,\n",
    "                            \"ক\":12,\"খ\":13,\"গ\":14,\"ঘ\":15,\"ঙ\":16,\"চ\":17,\"ছ\":18,\"জ\":19,\"ঝ\":20,\"ঞ\":21,\"ট\":22,\n",
    "                           \"ঠ\":23,\"ড\":24,\"ঢ\":25,\"ণ\":26,\"ত\":27,\"থ\":28,\"দ\":29,\"ধ\":30,\"ন\":31,\"প\":32,\"ফ\":33,\"ব\":34,\n",
    "                            \"ভ\":35,\"ম\":36,\"য\":37,\"র\":38,\"ল\":39,\"শ\":40,\"ষ\":41,\"স\":42,\"হ\":43,\"ড়\":44,\"ঢ়\":45,\"য়\":46,\n",
    "                           \"ঁ\":47,\"ং\":48,\"ঃ\":49,\"়\":50,\"া\":51,\"ি\":52,\"ী\":53,\"ু\":54,\"ূ\":55,\"ৃ\":56,\"ৄ\":57,\"ে\":58,\"ৈ\":59,\n",
    "                           \"ো\":60,\"ৌ\":61,\"্\":62,\"ৎ\":63,\"ৗ\":64,\" \":65,\"\\t\":66,\"\\n\":67}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "indexToChar = dict((indx,char) for char,indx in bengali_alphabets_maping.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'অ',\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: 'ৈ',\n",
       " 60: 'ো',\n",
       " 61: 'ৌ',\n",
       " 62: '্',\n",
       " 63: 'ৎ',\n",
       " 64: 'ৗ',\n",
       " 65: ' ',\n",
       " 66: '\\t',\n",
       " 67: '\\n'}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indexToChar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Seq2Seq model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "inflected_form = list(df.inflected_form)\n",
    "base_form = list(df.base_form)\n",
    "input_texts = []\n",
    "target_texts = []\n",
    "for i,text in enumerate(inflected_form):\n",
    "    input_texts.append('\\t'+text+'\\n')\n",
    "    target_texts.append(base_form[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['\\tবাঁচিও\\n',\n",
       " '\\tহাটতামও\\n',\n",
       " '\\tথাকেনই\\n',\n",
       " '\\tকাঁদবেন\\n',\n",
       " '\\tরচ্ছিলেন\\n',\n",
       " '\\tশুনবেনও\\n',\n",
       " '\\tআঁকছেন\\n',\n",
       " '\\tকচলায়ই\\n',\n",
       " '\\tদেখেছিলে\\n',\n",
       " '\\tকরাসই\\n']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_texts[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['বাঁচ', 'হাট', 'থাক', 'কাঁদ', 'র', 'শুন', 'আঁক', 'কচলা', 'দেখা', 'করা']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target_texts[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_encoder_tokens = len(bengali_alphabets_maping)\n",
    "num_decoder_tokens = len(bengali_alphabets_maping)\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])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of samples: 14500\n",
      "Number of unique input tokens: 68\n",
      "Number of unique output tokens: 68\n",
      "Max sequence length for inputs: 18\n",
      "Max sequence length for outputs: 6\n"
     ]
    }
   ],
   "source": [
    "print('Number of samples:', len(input_texts))\n",
    "print('Number of unique input tokens:', num_encoder_tokens)\n",
    "print('Number of unique output tokens:', num_decoder_tokens)\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": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#preparing inputs\n",
    "encoder_input_data = np.zeros(\n",
    "    (len(input_texts), max_encoder_seq_length, num_encoder_tokens),\n",
    "    dtype='float32')\n",
    "decoder_input_data = np.zeros(\n",
    "    (len(input_texts), max_decoder_seq_length, num_decoder_tokens),\n",
    "    dtype='float32')\n",
    "decoder_target_data = np.zeros(\n",
    "    (len(input_texts), max_decoder_seq_length, num_decoder_tokens),\n",
    "    dtype='float32')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(14500, 6, 68)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decoder_target_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#one-hot encoding of texts\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, bengali_alphabets_maping[char]] = 1.\n",
    "    encoder_input_data[i, t + 1:, bengali_alphabets_maping[' ']] = 1.\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, bengali_alphabets_maping[char]] = 1.\n",
    "        if t > 0:\n",
    "            decoder_target_data[i, t - 1, bengali_alphabets_maping[char]] = 1.\n",
    "    decoder_input_data[i, t + 1:, bengali_alphabets_maping[' ']] = 1.\n",
    "    decoder_target_data[i, t:, bengali_alphabets_maping[' ']] = 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['\\t', 'আ', 'ঁ', 'ক', 'ছ', 'ে', 'ন', '\\n']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(input_texts[6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 64  \n",
    "epochs = 10  \n",
    "latent_dim = 512  # Latent dimensionality of the encoding space.\n",
    "num_samples = 14500  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoder_inputs = Input(shape=(None, num_encoder_tokens))\n",
    "encoder = LSTM(latent_dim, return_state=True)\n",
    "encoder_outputs, state_h, state_c = encoder(encoder_inputs)\n",
    "# We only need the states (state_h, state_c).\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(latent_dim, return_sequences=True, return_state=True)\n",
    "decoder_outputs, _, _ = decoder_lstm(decoder_inputs,\n",
    "                                     initial_state=encoder_states)\n",
    "#using dropout as a regulizer\n",
    "decoder_outputs = Dropout(rate=0.5)(decoder_outputs)\n",
    "decoder_dense = Dense(num_decoder_tokens, activation='softmax')\n",
    "decoder_outputs = decoder_dense(decoder_outputs)\n",
    "\n",
    "# Define the model that will take\n",
    "# `encoder_input_data` & `decoder_input_data` as input\n",
    "model = Model([encoder_inputs, decoder_inputs], decoder_outputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_4\"\n",
      "__________________________________________________________________________________________________\n",
      "Layer (type)                    Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      "input_5 (InputLayer)            (None, None, 68)     0                                            \n",
      "__________________________________________________________________________________________________\n",
      "input_6 (InputLayer)            (None, None, 68)     0                                            \n",
      "__________________________________________________________________________________________________\n",
      "lstm_3 (LSTM)                   [(None, 512), (None, 1189888     input_5[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "lstm_4 (LSTM)                   [(None, None, 512),  1189888     input_6[0][0]                    \n",
      "                                                                 lstm_3[0][1]                     \n",
      "                                                                 lstm_3[0][2]                     \n",
      "__________________________________________________________________________________________________\n",
      "dropout_2 (Dropout)             (None, None, 512)    0           lstm_4[0][0]                     \n",
      "__________________________________________________________________________________________________\n",
      "dense_2 (Dense)                 (None, None, 68)     34884       dropout_2[0][0]                  \n",
      "==================================================================================================\n",
      "Total params: 2,414,660\n",
      "Trainable params: 2,414,660\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run training\n",
    "# Default Learning Rate 0.001 is used\n",
    "\n",
    "model.compile(optimizer='rmsprop', loss='categorical_crossentropy',\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 10150 samples, validate on 4350 samples\n",
      "Epoch 1/10\n",
      "10150/10150 [==============================] - 2s 205us/step - loss: 1.2348 - accuracy: 0.6715 - val_loss: 0.8324 - val_accuracy: 0.7578\n",
      "Epoch 2/10\n",
      "10150/10150 [==============================] - 2s 164us/step - loss: 0.6052 - accuracy: 0.8082 - val_loss: 0.3327 - val_accuracy: 0.8767\n",
      "Epoch 3/10\n",
      "10150/10150 [==============================] - 2s 184us/step - loss: 0.2067 - accuracy: 0.9330 - val_loss: 0.1210 - val_accuracy: 0.9626\n",
      "Epoch 4/10\n",
      "10150/10150 [==============================] - 2s 173us/step - loss: 0.0878 - accuracy: 0.9744 - val_loss: 0.0910 - val_accuracy: 0.9766\n",
      "Epoch 5/10\n",
      "10150/10150 [==============================] - 2s 163us/step - loss: 0.0515 - accuracy: 0.9852 - val_loss: 0.0358 - val_accuracy: 0.9892\n",
      "Epoch 6/10\n",
      "10150/10150 [==============================] - 2s 180us/step - loss: 0.0410 - accuracy: 0.9888 - val_loss: 0.0417 - val_accuracy: 0.9863\n",
      "Epoch 7/10\n",
      "10150/10150 [==============================] - 2s 171us/step - loss: 0.0296 - accuracy: 0.9920 - val_loss: 0.0048 - val_accuracy: 0.9988\n",
      "Epoch 8/10\n",
      "10150/10150 [==============================] - 2s 214us/step - loss: 0.0201 - accuracy: 0.9946 - val_loss: 0.0048 - val_accuracy: 0.9987\n",
      "Epoch 9/10\n",
      "10150/10150 [==============================] - 2s 161us/step - loss: 0.0178 - accuracy: 0.9953 - val_loss: 0.0024 - val_accuracy: 0.9996\n",
      "Epoch 10/10\n",
      "10150/10150 [==============================] - 2s 178us/step - loss: 0.0153 - accuracy: 0.9964 - val_loss: 0.0058 - val_accuracy: 0.9982\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.callbacks.History at 0x7f51cdf9dcf8>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit([encoder_input_data, decoder_input_data], decoder_target_data,\n",
    "          batch_size=batch_size,\n",
    "          epochs=epochs,\n",
    "          validation_split=0.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "#inference setup\n",
    "#making decoder model for sampling.\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_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",
    "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_6\"\n",
      "__________________________________________________________________________________________________\n",
      "Layer (type)                    Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      "input_6 (InputLayer)            (None, None, 68)     0                                            \n",
      "__________________________________________________________________________________________________\n",
      "input_7 (InputLayer)            (None, 512)          0                                            \n",
      "__________________________________________________________________________________________________\n",
      "input_8 (InputLayer)            (None, 512)          0                                            \n",
      "__________________________________________________________________________________________________\n",
      "lstm_4 (LSTM)                   [(None, None, 512),  1189888     input_6[0][0]                    \n",
      "                                                                 input_7[0][0]                    \n",
      "                                                                 input_8[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "dense_2 (Dense)                 (None, None, 68)     34884       lstm_4[1][0]                     \n",
      "==================================================================================================\n",
      "Total params: 1,224,772\n",
      "Trainable params: 1,224,772\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "decoder_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decode_sequence(input_text,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, bengali_alphabets_maping['\\t']] = 1.\n",
    "\n",
    "    # Sampling loop for a batch (==1) of sequences\n",
    "   \n",
    "    stop_condition = False\n",
    "    decoded_sentence = ''\n",
    "    while not stop_condition:\n",
    "        output_tokens, h, c = decoder_model.predict(\n",
    "            [target_seq] + states_value)\n",
    "\n",
    "        # Sample a token\n",
    "        sampled_token_index = np.argmax(output_tokens[0, -1, :])\n",
    "#         print(sampled_token_index)\n",
    "        sampled_char = indexToChar[sampled_token_index]\n",
    "#         print(sampled_char)\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.\n",
    "\n",
    "        # Update states\n",
    "        states_value = [h, c]\n",
    "\n",
    "    return list(input_text)[0]+decoded_sentence\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inflected Form: বাঁচি\n",
      "Base Form: বাঁচ    \n",
      "-------------------------------------\n",
      "Inflected Form: হাটতাম\n",
      "Base Form: হাট     \n",
      "-------------------------------------\n",
      "Inflected Form: থাকেন\n",
      "Base Form: থাক     \n",
      "-------------------------------------\n",
      "Inflected Form: কাঁদবে\n",
      "Base Form: কাঁদ    \n",
      "-------------------------------------\n",
      "Inflected Form: রচ্ছিলে\n",
      "Base Form: রর      \n",
      "-------------------------------------\n",
      "Inflected Form: শুনবেন\n",
      "Base Form: শুন     \n",
      "-------------------------------------\n",
      "Inflected Form: আঁকছে\n",
      "Base Form: আঁক     \n",
      "-------------------------------------\n",
      "Inflected Form: কচলায়\n",
      "Base Form: কচলা    \n",
      "-------------------------------------\n",
      "Inflected Form: দেখেছিল\n",
      "Base Form: দেখ     \n",
      "-------------------------------------\n",
      "Inflected Form: করাস\n",
      "Base Form: করা     \n",
      "-------------------------------------\n",
      "Inflected Form: গলাচ্ছে\n",
      "Base Form: গলা     \n",
      "-------------------------------------\n",
      "Inflected Form: এঁকেছিল\n",
      "Base Form: এঁকে    \n",
      "-------------------------------------\n",
      "Inflected Form: উড়ছিলেন\n",
      "Base Form: উড়      \n",
      "-------------------------------------\n",
      "Inflected Form: লাফাবেন\n",
      "Base Form: লাফা    \n",
      "-------------------------------------\n",
      "Inflected Form: ঘুরত\n",
      "Base Form: ঘুর     \n",
      "-------------------------------------\n",
      "Inflected Form: হারালেন\n",
      "Base Form: হার     \n",
      "-------------------------------------\n",
      "Inflected Form: ফেলব\n",
      "Base Form: ফেল     \n",
      "-------------------------------------\n",
      "Inflected Form: ঢোকায়\n",
      "Base Form: ঢোটা    \n",
      "-------------------------------------\n",
      "Inflected Form: জানাতে\n",
      "Base Form: জানা    \n",
      "-------------------------------------\n",
      "Inflected Form: পড়তে থাকবেন\n",
      "Base Form: পড়      \n",
      "-------------------------------------\n",
      "Inflected Form: ঝালাবি\n",
      "Base Form: ঝালা    \n",
      "-------------------------------------\n",
      "Inflected Form: পোড়ে\n",
      "Base Form: পোড়     \n",
      "-------------------------------------\n",
      "Inflected Form: ঘুমিয়েছিল\n",
      "Base Form: ঘুমা    \n",
      "-------------------------------------\n",
      "Inflected Form: জানত\n",
      "Base Form: জা      \n",
      "-------------------------------------\n",
      "Inflected Form: নাড়াব\n",
      "Base Form: নাড়া    \n",
      "-------------------------------------\n",
      "Inflected Form: পড়লেন\n",
      "Base Form: পড়      \n",
      "-------------------------------------\n",
      "Inflected Form: আনাও\n",
      "Base Form: আনা     \n",
      "-------------------------------------\n",
      "Inflected Form: দেখাতে থাক\n",
      "Base Form: দেখা    \n",
      "-------------------------------------\n",
      "Inflected Form: হারাস\n",
      "Base Form: হার     \n",
      "-------------------------------------\n",
      "Inflected Form: পৌঁছলাম\n",
      "Base Form: পৌঁছ    \n",
      "-------------------------------------\n",
      "Inflected Form: কাঁদু\n",
      "Base Form: কাঁদ    \n",
      "-------------------------------------\n",
      "Inflected Form: বাধ\n",
      "Base Form: বা      \n",
      "-------------------------------------\n",
      "Inflected Form: খেলবেন\n",
      "Base Form: খেল     \n",
      "-------------------------------------\n",
      "Inflected Form: ঘুমাচ্ছি\n",
      "Base Form: ঘুমা    \n",
      "-------------------------------------\n",
      "Inflected Form: কাঁদছে\n",
      "Base Form: কাঁদ    \n",
      "-------------------------------------\n",
      "Inflected Form: লিখ\n",
      "Base Form: লল      \n",
      "-------------------------------------\n",
      "Inflected Form: পালা\n",
      "Base Form: পালা    \n",
      "-------------------------------------\n",
      "Inflected Form: নাড়ালে\n",
      "Base Form: নাড়া    \n",
      "-------------------------------------\n",
      "Inflected Form: বুনছিলি\n",
      "Base Form: বুন     \n",
      "-------------------------------------\n",
      "Inflected Form: ঘিরল\n",
      "Base Form: ঘির     \n",
      "-------------------------------------\n",
      "Inflected Form: কাটল\n",
      "Base Form: কাট     \n",
      "-------------------------------------\n",
      "Inflected Form: পালাও\n",
      "Base Form: পালা    \n",
      "-------------------------------------\n",
      "Inflected Form: ছুট\n",
      "Base Form: ছুট     \n",
      "-------------------------------------\n",
      "Inflected Form: হাঁটছি\n",
      "Base Form: হাঁট    \n",
      "-------------------------------------\n",
      "Inflected Form: কাটা\n",
      "Base Form: কাটা    \n",
      "-------------------------------------\n",
      "Inflected Form: ঠকাব\n",
      "Base Form: ঠকা     \n",
      "-------------------------------------\n",
      "Inflected Form: ঝোলাচ্ছেন\n",
      "Base Form: ঝোলা    \n",
      "-------------------------------------\n",
      "Inflected Form: কচলা\n",
      "Base Form: কচলা    \n",
      "-------------------------------------\n",
      "Inflected Form: জড়ানো\n",
      "Base Form: জড়া     \n",
      "-------------------------------------\n",
      "Inflected Form: কাঁদতে থাকবে\n",
      "Base Form: কাঁদ    \n",
      "-------------------------------------\n",
      "Inflected Form: আঁকতে থাকবে\n",
      "Base Form: আঁক     \n",
      "-------------------------------------\n",
      "Inflected Form: চাপিয়েছি\n",
      "Base Form: চাপা    \n",
      "-------------------------------------\n",
      "Inflected Form: জানিয়েছি\n",
      "Base Form: জানা    \n",
      "-------------------------------------\n",
      "Inflected Form: মানাচ্ছিল\n",
      "Base Form: মানা    \n",
      "-------------------------------------\n",
      "Inflected Form: করছিল\n",
      "Base Form: কর      \n",
      "-------------------------------------\n",
      "Inflected Form: জানাতে\n",
      "Base Form: জানা    \n",
      "-------------------------------------\n",
      "Inflected Form: গ\n",
      "Base Form: গড়      \n",
      "-------------------------------------\n",
      "Inflected Form: ঝোলালেন\n",
      "Base Form: ঝোলা    \n",
      "-------------------------------------\n",
      "Inflected Form: পারছিলাম\n",
      "Base Form: পার     \n",
      "-------------------------------------\n",
      "Inflected Form: ফলাচ্ছিলেন\n",
      "Base Form: ফলা     \n",
      "-------------------------------------\n",
      "Inflected Form: চেঁচিয়ে\n",
      "Base Form: চেঁচা   \n",
      "-------------------------------------\n",
      "Inflected Form: চিবিয়েছিল\n",
      "Base Form: চিবা    \n",
      "-------------------------------------\n",
      "Inflected Form: বাঁকাচ্ছ\n",
      "Base Form: বাঁকা   \n",
      "-------------------------------------\n",
      "Inflected Form: চেঁচাও\n",
      "Base Form: চেঁচা   \n",
      "-------------------------------------\n",
      "Inflected Form: গোছাতা\n",
      "Base Form: গোছা    \n",
      "-------------------------------------\n",
      "Inflected Form: ভাবতেন\n",
      "Base Form: ভাব     \n",
      "-------------------------------------\n",
      "Inflected Form: জানিয়\n",
      "Base Form: জানা    \n",
      "-------------------------------------\n",
      "Inflected Form: খেলল\n",
      "Base Form: খেল     \n",
      "-------------------------------------\n",
      "Inflected Form: কচলালেন\n",
      "Base Form: কচলা    \n",
      "-------------------------------------\n",
      "Inflected Form: ওঠ\n",
      "Base Form: ওঠ      \n",
      "-------------------------------------\n",
      "Inflected Form: নাড়া\n",
      "Base Form: নাড়া    \n",
      "-------------------------------------\n",
      "Inflected Form: সরাক\n",
      "Base Form: সরা     \n",
      "-------------------------------------\n",
      "Inflected Form: চাপাচ্ছিলে\n",
      "Base Form: চাপা    \n",
      "-------------------------------------\n",
      "Inflected Form: হারালেন\n",
      "Base Form: হার     \n",
      "-------------------------------------\n",
      "Inflected Form: লাগাচ্ছিলে\n",
      "Base Form: লাগা    \n",
      "-------------------------------------\n",
      "Inflected Form: ঘিরেন\n",
      "Base Form: ঘির     \n",
      "-------------------------------------\n",
      "Inflected Form: শুনলে\n",
      "Base Form: শুন     \n",
      "-------------------------------------\n",
      "Inflected Form: পাড়তাম\n",
      "Base Form: পাড়     \n",
      "-------------------------------------\n",
      "Inflected Form: ঝালিয়েছি\n",
      "Base Form: ঝালা    \n",
      "-------------------------------------\n",
      "Inflected Form: ঘুমাব\n",
      "Base Form: ঘুমা    \n",
      "-------------------------------------\n",
      "Inflected Form: কমিয়েছিলে\n",
      "Base Form: কমা     \n",
      "-------------------------------------\n",
      "Inflected Form: ঠকাত\n",
      "Base Form: ঠকা     \n",
      "-------------------------------------\n",
      "Inflected Form: চুষতে থাকবেন\n",
      "Base Form: চুষ     \n",
      "-------------------------------------\n",
      "Inflected Form: খুলেন\n",
      "Base Form: খুল     \n",
      "-------------------------------------\n",
      "Inflected Form: এঁকেছিস\n",
      "Base Form: এঁকে    \n",
      "-------------------------------------\n",
      "Inflected Form: দেখিস\n",
      "Base Form: দেখ     \n",
      "-------------------------------------\n",
      "Inflected Form: এনেছি\n",
      "Base Form: এনে     \n",
      "-------------------------------------\n",
      "Inflected Form: হাসছ\n",
      "Base Form: হাস     \n",
      "-------------------------------------\n",
      "Inflected Form: কাটি\n",
      "Base Form: কাট     \n",
      "-------------------------------------\n",
      "Inflected Form: গলিয়েছি\n",
      "Base Form: গলা     \n",
      "-------------------------------------\n",
      "Inflected Form: চাপাই\n",
      "Base Form: চাপা    \n",
      "-------------------------------------\n",
      "Inflected Form: দেখাচ্ছিলাম\n",
      "Base Form: দেখা    \n",
      "-------------------------------------\n",
      "Inflected Form: দেখাচ্ছি\n",
      "Base Form: দেখা    \n",
      "-------------------------------------\n",
      "Inflected Form: আনছিল\n",
      "Base Form: আছ      \n",
      "-------------------------------------\n",
      "Inflected Form: বস\n",
      "Base Form: বস      \n",
      "-------------------------------------\n",
      "Inflected Form: পাঠিয়েছি\n",
      "Base Form: পাঠা    \n",
      "-------------------------------------\n",
      "Inflected Form: ঘুরলে\n",
      "Base Form: ঘুর     \n",
      "-------------------------------------\n",
      "Inflected Form: হাসব\n",
      "Base Form: হাস     \n",
      "-------------------------------------\n",
      "Inflected Form: শোনাত\n",
      "Base Form: শোনা    \n",
      "-------------------------------------\n",
      "Inflected Form: যাচ্ছ\n",
      "Base Form: যা      \n",
      "-------------------------------------\n",
      "Inflected Form: শোনানো\n",
      "Base Form: শোনা    \n",
      "-------------------------------------\n",
      "Inflected Form: ছুটতেন\n",
      "Base Form: ছুট     \n",
      "-------------------------------------\n",
      "Inflected Form: পাড়তে থাকবে\n",
      "Base Form: পাড়     \n",
      "-------------------------------------\n",
      "Inflected Form: বাঁচলাম\n",
      "Base Form: বাঁচ    \n",
      "-------------------------------------\n",
      "Inflected Form: চেঁচাচ্ছি\n",
      "Base Form: চেঁচা   \n",
      "-------------------------------------\n",
      "Inflected Form: বুঝতা\n",
      "Base Form: বুঝ     \n",
      "-------------------------------------\n",
      "Inflected Form: ঢোকা\n",
      "Base Form: ঢোটা    \n",
      "-------------------------------------\n",
      "Inflected Form: রটাতে\n",
      "Base Form: রটা     \n",
      "-------------------------------------\n",
      "Inflected Form: দৌড়িয়েছ\n",
      "Base Form: দৌড়া    \n",
      "-------------------------------------\n",
      "Inflected Form: মরলাম\n",
      "Base Form: মর      \n",
      "-------------------------------------\n",
      "Inflected Form: কাটাত\n",
      "Base Form: কাট     \n",
      "-------------------------------------\n",
      "Inflected Form: ঝোলাচ্ছ\n",
      "Base Form: ঝোলা    \n",
      "-------------------------------------\n",
      "Inflected Form: চল\n",
      "Base Form: চল      \n",
      "-------------------------------------\n",
      "Inflected Form: বলছে\n",
      "Base Form: বল      \n",
      "-------------------------------------\n",
      "Inflected Form: দেখত\n",
      "Base Form: দেখ     \n",
      "-------------------------------------\n",
      "Inflected Form: নাড়াল\n",
      "Base Form: নাড়া    \n",
      "-------------------------------------\n",
      "Inflected Form: আনিয়েছে\n",
      "Base Form: আনা     \n",
      "-------------------------------------\n",
      "Inflected Form: শুনা\n",
      "Base Form: শুন     \n",
      "-------------------------------------\n",
      "Inflected Form: গোছা\n",
      "Base Form: গোছা    \n",
      "-------------------------------------\n",
      "Inflected Form: থামিস\n",
      "Base Form: থাম     \n",
      "-------------------------------------\n",
      "Inflected Form: ভুগবি\n",
      "Base Form: ভুগ     \n",
      "-------------------------------------\n",
      "Inflected Form: দেখাতে থাকবে\n",
      "Base Form: দেখা    \n",
      "-------------------------------------\n",
      "Inflected Form: ঘিরছিল\n",
      "Base Form: ঘির     \n",
      "-------------------------------------\n",
      "Inflected Form: দেখতে থাকব\n",
      "Base Form: দেখ     \n",
      "-------------------------------------\n",
      "Inflected Form: তোলাল\n",
      "Base Form: তোলা    \n",
      "-------------------------------------\n",
      "Inflected Form: জানলে\n",
      "Base Form: জা      \n",
      "-------------------------------------\n",
      "Inflected Form: এসেছিল\n",
      "Base Form: এসে     \n",
      "-------------------------------------\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inflected Form: কামড়ায়\n",
      "Base Form: কামড়া   \n",
      "-------------------------------------\n",
      "Inflected Form: আগান\n",
      "Base Form: আগা     \n",
      "-------------------------------------\n",
      "Inflected Form: খাচ্ছি\n",
      "Base Form: খা      \n",
      "-------------------------------------\n",
      "Inflected Form: করলা\n",
      "Base Form: কর      \n",
      "-------------------------------------\n",
      "Inflected Form: হাঁটছিলেন\n",
      "Base Form: হাঁট    \n",
      "-------------------------------------\n",
      "Inflected Form: জানছে\n",
      "Base Form: জা      \n",
      "-------------------------------------\n",
      "Inflected Form: ফিরাব\n",
      "Base Form: ফিরা    \n",
      "-------------------------------------\n",
      "Inflected Form: ফিরালেন\n",
      "Base Form: ফিরা    \n",
      "-------------------------------------\n",
      "Inflected Form: কাটছিল\n",
      "Base Form: কাট     \n",
      "-------------------------------------\n",
      "Inflected Form: খুঁজেছিলা\n",
      "Base Form: খুঁজ    \n",
      "-------------------------------------\n",
      "Inflected Form: পাকিয়েছিলি\n",
      "Base Form: পাকা    \n",
      "-------------------------------------\n",
      "Inflected Form: পাড়তে থাকবি\n",
      "Base Form: পাড়     \n",
      "-------------------------------------\n",
      "Inflected Form: পাড়ছিল\n",
      "Base Form: পাড়     \n",
      "-------------------------------------\n",
      "Inflected Form: গড়ছি\n",
      "Base Form: গড়      \n",
      "-------------------------------------\n",
      "Inflected Form: ঘুমা\n",
      "Base Form: ঘুমা    \n",
      "-------------------------------------\n",
      "Inflected Form: ঢুকছিলি\n",
      "Base Form: ঢুল     \n",
      "-------------------------------------\n",
      "Inflected Form: কিনেছিলে\n",
      "Base Form: কিন     \n",
      "-------------------------------------\n",
      "Inflected Form: হাসতা\n",
      "Base Form: হাস     \n",
      "-------------------------------------\n",
      "Inflected Form: বেরাতে থাকবেন\n",
      "Base Form: বের     \n",
      "-------------------------------------\n",
      "Inflected Form: লিখেছ\n",
      "Base Form: লিখ     \n",
      "-------------------------------------\n",
      "Inflected Form: রাখছিলাম\n",
      "Base Form: রার     \n",
      "-------------------------------------\n",
      "Inflected Form: লাগাত\n",
      "Base Form: লাগা    \n",
      "-------------------------------------\n",
      "Inflected Form: লাগাক\n",
      "Base Form: লাগা    \n",
      "-------------------------------------\n",
      "Inflected Form: কমিয়েছিল\n",
      "Base Form: কমা     \n",
      "-------------------------------------\n",
      "Inflected Form: জড়\n",
      "Base Form: জড়      \n",
      "-------------------------------------\n",
      "Inflected Form: পিছিয়েছি\n",
      "Base Form: পিছা    \n",
      "-------------------------------------\n",
      "Inflected Form: চেঁচা\n",
      "Base Form: চেঁচা   \n",
      "-------------------------------------\n",
      "Inflected Form: দাঁড়াতে থাক\n",
      "Base Form: দাঁড়া   \n",
      "-------------------------------------\n",
      "Inflected Form: রাখতে থাকবি\n",
      "Base Form: রার     \n",
      "-------------------------------------\n",
      "Inflected Form: উঠেছিলেন\n",
      "Base Form: উঠ      \n",
      "-------------------------------------\n",
      "Inflected Form: করাত\n",
      "Base Form: করা     \n",
      "-------------------------------------\n",
      "Inflected Form: পাকিয়েছিলে\n",
      "Base Form: পাকা    \n",
      "-------------------------------------\n",
      "Inflected Form: তুলিয়েছি\n",
      "Base Form: তুগ     \n",
      "-------------------------------------\n",
      "Inflected Form: সাঁটতে থাকবি\n",
      "Base Form: সাঁট    \n",
      "-------------------------------------\n",
      "Inflected Form: ফেলছিলি\n",
      "Base Form: ফেল     \n",
      "-------------------------------------\n",
      "Inflected Form: ফোটাচ্ছে\n",
      "Base Form: ফোটা    \n",
      "-------------------------------------\n",
      "Inflected Form: পাড়\n",
      "Base Form: পাড়     \n",
      "-------------------------------------\n",
      "Inflected Form: কাটত\n",
      "Base Form: কাট     \n",
      "-------------------------------------\n",
      "Inflected Form: আসত\n",
      "Base Form: আস      \n",
      "-------------------------------------\n",
      "Inflected Form: পাঠাবেন\n",
      "Base Form: পাঠা    \n",
      "-------------------------------------\n",
      "Inflected Form: ভাসছি\n",
      "Base Form: ভাস     \n",
      "-------------------------------------\n",
      "Inflected Form: হাটুন\n",
      "Base Form: হাট     \n",
      "-------------------------------------\n",
      "Inflected Form: বেড়াচ্ছে\n",
      "Base Form: বেড়া    \n",
      "-------------------------------------\n",
      "Inflected Form: পাঠাতে থাকব\n",
      "Base Form: পাঠা    \n",
      "-------------------------------------\n",
      "Inflected Form: আনে\n",
      "Base Form: আন      \n",
      "-------------------------------------\n",
      "Inflected Form: থামলি\n",
      "Base Form: থাম     \n",
      "-------------------------------------\n",
      "Inflected Form: ঘটতে থাকবে\n",
      "Base Form: ঘট      \n",
      "-------------------------------------\n",
      "Inflected Form: শুনলে\n",
      "Base Form: শুন     \n",
      "-------------------------------------\n",
      "Inflected Form: আসছিলাম\n",
      "Base Form: আস      \n",
      "-------------------------------------\n",
      "Inflected Form: চিবাবি\n",
      "Base Form: চিবা    \n",
      "-------------------------------------\n",
      "Inflected Form: চিবিয়েছিলাম\n",
      "Base Form: চিবা    \n",
      "-------------------------------------\n",
      "Inflected Form: জাগিস\n",
      "Base Form: জাস     \n",
      "-------------------------------------\n",
      "Inflected Form: ছাড়তি\n",
      "Base Form: ছাড়     \n",
      "-------------------------------------\n",
      "Inflected Form: গড়েছিলি\n",
      "Base Form: গড়      \n",
      "-------------------------------------\n",
      "Inflected Form: ছাড়ল\n",
      "Base Form: ছা      \n",
      "-------------------------------------\n",
      "Inflected Form: চলার\n",
      "Base Form: চল      \n",
      "-------------------------------------\n",
      "Inflected Form: দৌড়াত\n",
      "Base Form: দৌড়া    \n",
      "-------------------------------------\n",
      "Inflected Form: দৌড়া\n",
      "Base Form: দৌড়া    \n",
      "-------------------------------------\n",
      "Inflected Form: ভাঙ্গাচ্ছে\n",
      "Base Form: ভাঙ্গা  \n",
      "-------------------------------------\n",
      "Inflected Form: ছড়াচ্ছিস\n",
      "Base Form: ছড়া     \n",
      "-------------------------------------\n",
      "Inflected Form: হারাল\n",
      "Base Form: হার     \n",
      "-------------------------------------\n",
      "Inflected Form: পাঠায়\n",
      "Base Form: পাঠা    \n",
      "-------------------------------------\n",
      "Inflected Form: বসব\n",
      "Base Form: বস      \n",
      "-------------------------------------\n",
      "Inflected Form: কামড়ালে\n",
      "Base Form: কামড়া   \n",
      "-------------------------------------\n",
      "Inflected Form: খাবি\n",
      "Base Form: খা      \n",
      "-------------------------------------\n",
      "Inflected Form: আস\n",
      "Base Form: আস      \n",
      "-------------------------------------\n",
      "Inflected Form: মারলি\n",
      "Base Form: মার     \n",
      "-------------------------------------\n",
      "Inflected Form: ঝোলাতে থাকবি\n",
      "Base Form: ঝোলা    \n",
      "-------------------------------------\n",
      "Inflected Form: আনালি\n",
      "Base Form: আান     \n",
      "-------------------------------------\n",
      "Inflected Form: কমানো\n",
      "Base Form: কমা     \n",
      "-------------------------------------\n",
      "Inflected Form: মারলাম\n",
      "Base Form: মার     \n",
      "-------------------------------------\n",
      "Inflected Form: খাব\n",
      "Base Form: খা      \n",
      "-------------------------------------\n",
      "Inflected Form: খেলবি\n",
      "Base Form: খেল     \n",
      "-------------------------------------\n"
     ]
    }
   ],
   "source": [
    "#check first 200 sample and see how this model worked\n",
    "for seq_index in range(200):\n",
    "    # Take few sequence (part of the training set)\n",
    "    # for trying out decoding.\n",
    "    input_seq = encoder_input_data[seq_index: seq_index + 1]\n",
    "    decoded_sentence = decode_sequence(input_texts[seq_index][1:-2],input_seq)\n",
    "    print('Inflected Form:', input_texts[seq_index][1:-2])\n",
    "    print('Base Form:', decoded_sentence)\n",
    "    print(\"-------------------------------------\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CustomFunctionToPredict(input_text):\n",
    "    input_seq = np.zeros((1, max_encoder_seq_length, num_encoder_tokens),dtype='float32')\n",
    "    input_text = '\\t'+input_text+'\\n'\n",
    "    for i,char in enumerate(input_text):\n",
    "        input_seq[0,i,bengali_alphabets_maping[char]] = 1.\n",
    "    input_seq[0,i+1:,bengali_alphabets_maping[' ']] = 1.\n",
    "    decoded_sentence = decode_sequence(input_text[1:-2],input_seq)\n",
    "    print(\"-------------------------------------\")\n",
    "    print('Inflected Form:', input_text[1:-2])\n",
    "    print('Base Form:', decoded_sentence)\n",
    "    print(\"-------------------------------------\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------\n",
      "Inflected Form: শোনাচ্ছিল\n",
      "Base Form: শোনা    \n",
      "-------------------------------------\n"
     ]
    }
   ],
   "source": [
    "CustomFunctionToPredict(\"শোনাচ্ছিলি\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decision Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Text Preprocessing and encoding. which is same for the DTC and SVM\n",
    "inflected_form = list(df.inflected_form)\n",
    "base_form = list(df.base_form)\n",
    "#encoding the classes \n",
    "le = preprocessing.LabelEncoder()\n",
    "target_class = le.fit_transform(base_form)\n",
    "\n",
    "#encoding the characters to it's mapped value\n",
    "input_texts = []\n",
    "for i,text in enumerate(inflected_form):\n",
    "    temp_seq = []\n",
    "    for j,char in enumerate(text):\n",
    "        temp_seq.append(bengali_alphabets_maping[char]+1)\n",
    "    input_texts.append(temp_seq)\n",
    "    \n",
    "#padding the sequence to length 20 with 0\n",
    "input_texts_seq = pad_sequences(input_texts,20,padding='post',value=0)\n",
    "\n",
    "#Spliting the dataset for training and testing\n",
    "X_train,X_test,y_train,y_test = train_test_split(input_texts_seq,target_class,test_size = 0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "#defining the Decision Tree classifier\n",
    "dtc = DecisionTreeClassifier(criterion=\"entropy\",max_depth=8,class_weight=\"balanced\",random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeClassifier(class_weight='balanced', criterion='entropy',\n",
       "                       max_depth=8, max_features=None, max_leaf_nodes=None,\n",
       "                       min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                       min_samples_leaf=1, min_samples_split=2,\n",
       "                       min_weight_fraction_leaf=0.0, presort=False,\n",
       "                       random_state=0, splitter='best')"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#fitting the data to the classifier\n",
    "dtc.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.99401993, 0.99323867, 0.99378882, 0.99225897, 0.99498567])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cross_val_score(dtc,X_train,y_train,cv=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9951724137931034"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicted = dtc.predict(X_test)\n",
    "accuracy_score(predicted,y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [],
   "source": [
    "#model saving\n",
    "pickle.dump(dtc,open('decisiontree.sav','wb'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Support Vector Machine "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#prepossesing has done in the previous approach we will use the train test splitted data in this algorithm \n",
    "#as the encoding method is same for both of the algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Defining the SVC Classifier with polynomial kernel and degree value of 3.\n",
    "clf = SVC(C=10,gamma='auto',class_weight=\"balanced\",kernel='poly',verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LibSVM]"
     ]
    },
    {
     "data": {
      "text/plain": [
       "SVC(C=10, cache_size=200, class_weight='balanced', coef0=0.0,\n",
       "    decision_function_shape='ovr', degree=3, gamma='auto', kernel='poly',\n",
       "    max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
       "    tol=0.001, verbose=True)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9915862068965517"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicted = clf.predict(X_test)\n",
    "accuracy_score(y_test,predicted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [],
   "source": [
    "#model saving\n",
    "pickle.dump(clf,open('support_vector_machine.sav','wb'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Custom Function To Inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def customInferencing(classifier,input_sentence):\n",
    "    \"\"\"\n",
    "        This function takes two parameter. And prints the base_form of the given input_sentence.\n",
    "        where 'classifier' is a trained model object which has the 'predict' method.\n",
    "        And 'input_sentence' is the inflected form of a sentence. Which should be a single string.\n",
    "    \"\"\"\n",
    "    #Encode the data to the vector space the shape would be [n_samples,n_features]\n",
    "    input_seq = []\n",
    "    temp = [bengali_alphabets_maping[char]+1 for _,char in enumerate(input_sentence)] #+1 is used to increase the index value by 1 as we used 0 as a padding value\n",
    "    input_seq.append(temp)\n",
    "    #now pad the sequence with length 20\n",
    "    input_seq = pad_sequences(input_seq,20,padding='post',value=0)\n",
    "    \n",
    "    #Now predict the sentence using\n",
    "    pred = classifier.predict(input_seq)\n",
    "    #reverse the prediction class to it's actual value and print it\n",
    "    print(\"-------------------------------------\")\n",
    "    print(\"Inflected form: \"+input_sentence)\n",
    "    print(\"Base form: \"+le.inverse_transform(pred)[0])\n",
    "    print(\"-------------------------------------\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------\n",
      "Inflected form: ঢোকায়\n",
      "Base form: ঢোকা\n",
      "-------------------------------------\n"
     ]
    }
   ],
   "source": [
    "#loading the saved model\n",
    "dtc_mod = pickle.load(open(\"decisiontree.sav\",\"rb\"))\n",
    "#inference using Decision Tree Classifier which we trained before\n",
    "customInferencing(dtc_mod,\"ঢোকায়\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------\n",
      "Inflected form: ঢোকায়\n",
      "Base form: ঢোকা\n",
      "-------------------------------------\n"
     ]
    }
   ],
   "source": [
    "#loading the saved model\n",
    "svm_mod = pickle.load(open(\"support_vector_machine.sav\",\"rb\"))\n",
    "#inference using Support Vector Machine Classifier which we trained before\n",
    "customInferencing(svm_mod,\"ঢোকায়\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}