classification-benchmarks/Hindi_Classification_Model_IITP_Product.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastai.text import *\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "import pickle\n",
    "import sentencepiece as spm\n",
    "import re\n",
    "import pdb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('1.0.61', '1.0.0')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import fastai, torch\n",
    "fastai.__version__ , torch.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.set_device(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_seed(seed_value, use_cuda):\n",
    "    np.random.seed(seed_value)  \n",
    "    torch.manual_seed(seed_value)  \n",
    "    random.seed(seed_value)\n",
    "    if use_cuda:\n",
    "        torch.cuda.manual_seed(seed_value)\n",
    "        torch.cuda.manual_seed_all(seed_value)  \n",
    "        torch.backends.cudnn.deterministic = True\n",
    "        torch.backends.cudnn.benchmark = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_seed(42, True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = Path('./')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/data/home/ubuntu/gaurav/in/nlp-for-hindi/classification-bbc-news\r\n"
     ]
    }
   ],
   "source": [
    "!pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>negative</td>\n",
       "      <td>एंडराॅयड के मामले में यह थोड़ा पीछे है ।</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>neutral</td>\n",
       "      <td>यह एस्पेक्ट रेशो का ईश्यू है और हम आशा करते है...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>positive</td>\n",
       "      <td>लेकिन इस तरह के एक मॉडल के एक घर कंप्यूटर के ल...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>positive</td>\n",
       "      <td>गिर वन राष्ट्रीय उद्यान बाघ संरक्षित क्षेत्र ह...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>neutral</td>\n",
       "      <td>और हां , इस फिल्म में हर किरदार भारद्वाज को भर...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0                                                  1\n",
       "0  negative           एंडराॅयड के मामले में यह थोड़ा पीछे है ।\n",
       "1   neutral  यह एस्पेक्ट रेशो का ईश्यू है और हम आशा करते है...\n",
       "2  positive  लेकिन इस तरह के एक मॉडल के एक घर कंप्यूटर के ल...\n",
       "3  positive  गिर वन राष्ट्रीय उद्यान बाघ संरक्षित क्षेत्र ह...\n",
       "4   neutral  और हां , इस फिल्म में हर किरदार भारद्वाज को भर..."
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_train = pd.read_csv(path/'../../classification_public_datasets/iitp-product-reviews/hi/hi-train.csv', header=None)\n",
    "df_train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>positive</td>\n",
       "      <td>एक ऐसा भी जानवर है , जिसे आप पसंद तो करते होंग...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>neutral</td>\n",
       "      <td>इतना नहीं बल्कि यहां पर कंपनी अपना पहला फाइव स...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>neutral</td>\n",
       "      <td>डिजिफलीप प्रो XT811 , 1200 x 800 P और 8 इंच डि...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>positive</td>\n",
       "      <td>निकोन डी810 कैमरे की सबसे खास बात ये है कि इसम...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>positive</td>\n",
       "      <td>इसमें विंडोज 8 64-बिट ऑपरेटिंग सिस्टम है , लेक...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0                                                  1\n",
       "0  positive  एक ऐसा भी जानवर है , जिसे आप पसंद तो करते होंग...\n",
       "1   neutral  इतना नहीं बल्कि यहां पर कंपनी अपना पहला फाइव स...\n",
       "2   neutral  डिजिफलीप प्रो XT811 , 1200 x 800 P और 8 इंच डि...\n",
       "3  positive  निकोन डी810 कैमरे की सबसे खास बात ये है कि इसम...\n",
       "4  positive  इसमें विंडोज 8 64-बिट ऑपरेटिंग सिस्टम है , लेक..."
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_valid = pd.read_csv(path/'../../classification_public_datasets/iitp-product-reviews/hi/hi-valid.csv', header=None)\n",
    "df_valid.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>neutral</td>\n",
       "      <td>मगर , इस तरफ कोई ध्यान नहीं दिया जा रहा ।</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>negative</td>\n",
       "      <td>गेम कई बार मुश्किल मालूम देता है ।</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>negative</td>\n",
       "      <td>मल्टीप्लेयर में छोटी स्टोरीलाइन है ।</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>positive</td>\n",
       "      <td>हाई - एंड एचपी नोटबुक्स की लुक्स हमेशा बेहतरीन...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>positive</td>\n",
       "      <td>कैमरे बनाने वाली कंपनी निकोन अपनी 1 सीरीज कैमर...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0                                                  1\n",
       "0   neutral          मगर , इस तरफ कोई ध्यान नहीं दिया जा रहा ।\n",
       "1  negative                 गेम कई बार मुश्किल मालूम देता है ।\n",
       "2  negative               मल्टीप्लेयर में छोटी स्टोरीलाइन है ।\n",
       "3  positive  हाई - एंड एचपी नोटबुक्स की लुक्स हमेशा बेहतरीन...\n",
       "4  positive  कैमरे बनाने वाली कंपनी निकोन अपनी 1 सीरीज कैमर..."
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_test = pd.read_csv(path/'../../classification_public_datasets/iitp-product-reviews/hi/hi-test.csv', header=None)\n",
    "df_test.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((4182, 2), (523, 2), (523, 2))"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_train.shape, df_valid.shape, df_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [0, 1]\n",
       "Index: []"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_train[df_train[1].isnull()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# df_train = df_train.dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [0, 1]\n",
       "Index: []"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_test[df_test[1].isnull()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# df_test = df_test.dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_cols = [0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HindiTokenizer(BaseTokenizer):\n",
    "    def __init__(self, lang:str):\n",
    "        self.lang = lang\n",
    "        self.sp = spm.SentencePieceProcessor()\n",
    "        self.sp.Load(str('./../../models/hindi/tokenizer/Created from Hindi Wikipedia Articles - 172k/hindi_lm_large.model'))\n",
    "        \n",
    "    def tokenizer(self, t:str) -> List[str]:\n",
    "        return self.sp.EncodeAsPieces(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp = spm.SentencePieceProcessor()\n",
    "sp.Load('./../../models/hindi/tokenizer/Created from Hindi Wikipedia Articles - 172k/hindi_lm_large.model')\n",
    "itos = [sp.IdToPiece(int(i)) for i in range(30000)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['<unk>', '<s>', '</s>', '▁के', '।', '▁में', '▁है', ',', '▁की', '▁']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "itos[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 30,000 is the vocab size that we chose in sentencepiece\n",
    "hindi_vocab = Vocab(itos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "tokenizer = Tokenizer(tok_func=HindiTokenizer, lang='hi')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['xxunk',\n",
       " 'xxpad',\n",
       " 'xxbos',\n",
       " 'xxeos',\n",
       " 'xxfld',\n",
       " 'xxmaj',\n",
       " 'xxup',\n",
       " 'xxrep',\n",
       " 'xxwrep']"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokenizer.special_cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_lm = TextLMDataBunch.from_df(path=path, train_df=df_train, valid_df=df_valid, test_df=df_test, tokenizer=tokenizer, vocab=hindi_vocab, bs=32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>idx</th>\n",
       "      <th>text</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>▁ । ▁x x bo s ▁गिर ▁वन ▁राष्ट्रीय ▁उद्यान ▁बाघ ▁संरक्षित ▁क्षेत्र ▁है ▁जो ▁एशियाई ▁बब्बर ▁शेर ▁के ▁लिए ▁विश्व ▁प्रसिद्ध ▁है ▁ । ▁x x bo s ▁और ▁हां ▁ , ▁इस ▁फिल्म ▁में ▁हर ▁किरदार ▁भारद्वाज ▁को ▁भरद्वाज ▁क्यों ▁बुला ता ▁है ▁? ▁x x bo s ▁फोन ▁उपयोग ▁में ▁बेहद ▁ही ▁आसान ▁है ▁और ▁टच ▁रि स्प ॉर न्स ▁उतना ▁ही ▁बेहतर ▁ । ▁x x</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>▁के ▁कारण ▁ , ▁स्क्रीन ▁आँख ो ▁के ▁लिए ▁सुख कारक ▁है ▁जो ▁पढ़ने ▁और ▁वी डी यो ▁देखने ▁के ▁लिए ▁बहुत ▁अच्छी ▁है ▁ । ▁x x bo s ▁इस ▁फै ब लेट ▁में ▁बड़ा ▁बैटरी ▁भी ▁लगा ▁है ▁जो ▁बिना ▁बैटरी ▁से विंग ▁मोड ▁को ▁ एक्टिव ▁किए ▁ही ▁एक ▁दिन ▁चल ▁सकता ▁है ▁ । ▁x x bo s ▁अब ▁तक ▁ , ▁इस ▁बजट ▁में ▁खरीदने</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>▁इनमें ▁अंतर ▁एंड्रॉइड ▁वर्जन ▁और ▁स्क्रीन ▁साइ ज ▁का ▁है ▁ । ▁x x bo s ▁गर्म ▁होने ▁की ▁समस्या ▁है ▁ । ▁x x bo s ▁जस ी डीह ▁जंक्शन ▁भारत ▁के ▁सभी ▁प्रमुख ▁भागों ▁से ▁जुड़ा ▁है ▁ । ▁x x bo s ▁मुंबई ▁के ▁माहौल ▁में ▁अंडरवर्ल्ड ▁और ▁एन काउंट र ▁अब ▁सुर्खियों ▁के ▁शब्द ▁नहीं ▁हैं ▁ । ▁x x bo s ▁मेरी ▁12 ▁महीने ▁की</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>▁देने ▁वाला ▁प्रतीत ▁होता ▁है ▁ । ▁x x bo s ▁साइन ो जन ▁ओएस ▁की ▁यह ▁खास ▁बात ▁है ▁कि ▁अप ीय रेंस ▁के ▁कस्टम ाइजेशन ▁के ▁मामले ▁में ▁आप ▁इसमें ▁कई ▁फेरबदल ▁कर ▁सकते ▁हैं ▁ । ▁x x bo s ▁कंपनी ▁का ▁कहना ▁है ▁कि ▁खाना ▁बनाने ▁के ▁लिए ▁तैयार ▁होकर ▁उसका ▁मैसेज ▁करने ▁वाले ▁इस ▁प्रेशर ▁कू कर ▁में ▁स्मार्टफोन ▁एप ▁का ▁इस्तेमाल ▁किया ▁गया ▁है</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>प्स ▁को ▁बहुत ▁पीछे ▁छोड़ ▁छोड़ ▁देते ▁हैं ▁ । ▁x x bo s ▁रेलमार्ग ▁- ▁निकटतम ▁रेलवे ▁स्टेशन ▁बै द्य नाथ ▁धाम ▁है ▁ । ▁x x bo s ▁यह ▁खास ▁तौर ▁से ▁एक ▁छोटे ▁स्मार्टफोन ▁के ▁स्क्रीन ▁पर ▁हा र्इ ▁क्वालिटी ▁ए प्प ▁की ▁तरह ▁नहीं ▁लगता ▁है ▁x x bo s ▁यहां ▁पर ▁प्लांट ▁की ▁2 29 ▁ , ▁मै मल ▁की ▁31 ▁ , ▁बर्ड ▁की</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_lm.show_batch()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = language_model_learner(data_lm, AWD_LSTM, drop_mult=0.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LanguageLearner(data=TextLMDataBunch;\n",
       "\n",
       "Train: LabelList (4182 items)\n",
       "x: LMTextList\n",
       "▁x x bo s ▁एंड र ाॅय ड ▁के ▁मामले ▁में ▁यह ▁थोड़ा ▁पीछे ▁है ▁ ।,▁x x bo s ▁यह ▁ए स्पेक्ट ▁रे शो ▁का ▁ई श ्यू ▁है ▁और ▁हम ▁आशा ▁करते ▁हैं ▁कि ▁यह ▁आने ▁वाले ▁अपडेट ▁में ▁फिक्स ▁कर ▁दिया ▁जाएगा ▁ ।,▁x x bo s ▁लेकिन ▁इस ▁तरह ▁के ▁एक ▁मॉडल ▁के ▁एक ▁घर ▁कंप्यूटर ▁के ▁लिए ▁एक ▁शानदार ▁विकल्प ▁हो ▁सकता ▁है ▁ ।,▁x x bo s ▁गिर ▁वन ▁राष्ट्रीय ▁उद्यान ▁बाघ ▁संरक्षित ▁क्षेत्र ▁है ▁जो ▁एशियाई ▁बब्बर ▁शेर ▁के ▁लिए ▁विश्व ▁प्रसिद्ध ▁है ▁ ।,▁x x bo s ▁और ▁हां ▁ , ▁इस ▁फिल्म ▁में ▁हर ▁किरदार ▁भारद्वाज ▁को ▁भरद्वाज ▁क्यों ▁बुला ता ▁है ▁?\n",
       "y: LMLabelList\n",
       ",,,,\n",
       "Path: .;\n",
       "\n",
       "Valid: LabelList (523 items)\n",
       "x: LMTextList\n",
       "▁x x bo s ▁एक ▁ऐसा ▁भी ▁जानवर ▁है ▁ , ▁जिसे ▁आप ▁पसंद ▁तो ▁करते ▁होंगे ▁ , ▁लेकिन ▁उसे ▁घर ▁में ▁रखने ▁का ▁ख्याल ▁तक ▁मन ▁में ▁नहीं ▁ला ▁सकते ▁ , ▁जैसे ▁कि ▁हाथी ▁ ।,▁x x bo s ▁इतना ▁नहीं ▁बल्कि ▁यहां ▁पर ▁कंपनी ▁अपना ▁पहला ▁फाइव ▁स्टार ▁रेटिंग ▁फ्रि ज ▁भी ▁लेकर ▁आई ▁है ▁जो ▁जल्द ▁ही ▁बाजार ▁में ▁मिलने ▁लगेगा ▁ ।,▁x x bo s ▁डि जि फल ी प ▁प्रो ▁ <unk> <unk> 8 11 ▁ , ▁1200 ▁x ▁800 <unk> ▁p ▁और ▁8 ▁इंच ▁डिस्प्ले ▁के ▁साथ ▁आता ▁है ▁ ।,▁x x bo s ▁नि कोन ▁डी 81 0 ▁कैमरे ▁की ▁सबसे ▁खास ▁बात ▁ये ▁है ▁कि ▁इसमें ▁फुल ▁फ्रेम ▁3 6.3 ▁मेगा प िक्स ल ▁सीम ॉस ▁सेंसर ▁और ▁आईएसओ ▁रेंज ▁दिया ▁गया ▁है ▁ ।,▁x x bo s ▁इसमें ▁विंडोज ▁8 ▁64 - बिट ▁ऑपरेटिंग ▁सिस्टम ▁है ▁ , ▁लेकिन ▁अच्छी ▁बात ▁ये ▁है ▁कि ▁इसमें ▁बहुत ▁सीमित ▁प्री लो डेड ▁सॉफ्टवेर ▁दिए ▁गए ▁हैं ▁जिससे ▁मशीन ▁बोझ िल ▁नहीं ▁होती ▁ ।\n",
       "y: LMLabelList\n",
       ",,,,\n",
       "Path: .;\n",
       "\n",
       "Test: LabelList (523 items)\n",
       "x: LMTextList\n",
       "▁x x bo s ▁मगर ▁ , ▁इस ▁तरफ ▁कोई ▁ध्यान ▁नहीं ▁दिया ▁जा ▁रहा ▁ ।,▁x x bo s ▁गेम ▁कई ▁बार ▁मुश्किल ▁मालूम ▁देता ▁है ▁ ।,▁x x bo s ▁मल्टी प्ले यर ▁में ▁छोटी ▁स्टोरी लाइन ▁है ▁ ।,▁x x bo s ▁हाई ▁- ▁एंड ▁एच पी ▁नोटबुक ्स ▁की ▁लुक ्स ▁हमेशा ▁बेहतरीन ▁होती ▁है ▁– ▁अत्याधुनिक ▁और ▁ए ग्रे सिव ▁लुक ▁जो ▁हर ▁किसी ▁को ▁भा ते ▁हैं ▁ ।,▁x x bo s ▁कैमरे ▁बनाने ▁वाली ▁कंपनी ▁नि कोन ▁अपनी ▁1 ▁सीरीज ▁कैमरों ▁में ▁इजाफा ▁करते ▁हुए ▁इस ▁सीरीज ▁का ▁सबसे ▁शानदार ▁कैमरा ▁लेकर ▁आई ▁है ▁ ।\n",
       "y: EmptyLabelList\n",
       ",,,,\n",
       "Path: ., model=SequentialRNN(\n",
       "  (0): AWD_LSTM(\n",
       "    (encoder): Embedding(30000, 400, padding_idx=1)\n",
       "    (encoder_dp): EmbeddingDropout(\n",
       "      (emb): Embedding(30000, 400, padding_idx=1)\n",
       "    )\n",
       "    (rnns): ModuleList(\n",
       "      (0): WeightDropout(\n",
       "        (module): LSTM(400, 1152, batch_first=True)\n",
       "      )\n",
       "      (1): WeightDropout(\n",
       "        (module): LSTM(1152, 1152, batch_first=True)\n",
       "      )\n",
       "      (2): WeightDropout(\n",
       "        (module): LSTM(1152, 400, batch_first=True)\n",
       "      )\n",
       "    )\n",
       "    (input_dp): RNNDropout()\n",
       "    (hidden_dps): ModuleList(\n",
       "      (0): RNNDropout()\n",
       "      (1): RNNDropout()\n",
       "      (2): RNNDropout()\n",
       "    )\n",
       "  )\n",
       "  (1): LinearDecoder(\n",
       "    (decoder): Linear(in_features=400, out_features=30000, bias=True)\n",
       "    (output_dp): RNNDropout()\n",
       "  )\n",
       "), opt_func=functools.partial(<class 'torch.optim.adam.Adam'>, betas=(0.9, 0.99)), loss_func=FlattenedLoss of CrossEntropyLoss(), metrics=[<function accuracy at 0x7f3049472158>], true_wd=True, bn_wd=True, wd=0.01, train_bn=True, path=PosixPath('.'), model_dir='models', callback_fns=[functools.partial(<class 'fastai.basic_train.Recorder'>, add_time=True, silent=False)], callbacks=[RNNTrainer\n",
       "learn: LanguageLearner(data=TextLMDataBunch;\n",
       "\n",
       "Train: LabelList (4182 items)\n",
       "x: LMTextList\n",
       "▁x x bo s ▁एंड र ाॅय ड ▁के ▁मामले ▁में ▁यह ▁थोड़ा ▁पीछे ▁है ▁ ।,▁x x bo s ▁यह ▁ए स्पेक्ट ▁रे शो ▁का ▁ई श ्यू ▁है ▁और ▁हम ▁आशा ▁करते ▁हैं ▁कि ▁यह ▁आने ▁वाले ▁अपडेट ▁में ▁फिक्स ▁कर ▁दिया ▁जाएगा ▁ ।,▁x x bo s ▁लेकिन ▁इस ▁तरह ▁के ▁एक ▁मॉडल ▁के ▁एक ▁घर ▁कंप्यूटर ▁के ▁लिए ▁एक ▁शानदार ▁विकल्प ▁हो ▁सकता ▁है ▁ ।,▁x x bo s ▁गिर ▁वन ▁राष्ट्रीय ▁उद्यान ▁बाघ ▁संरक्षित ▁क्षेत्र ▁है ▁जो ▁एशियाई ▁बब्बर ▁शेर ▁के ▁लिए ▁विश्व ▁प्रसिद्ध ▁है ▁ ।,▁x x bo s ▁और ▁हां ▁ , ▁इस ▁फिल्म ▁में ▁हर ▁किरदार ▁भारद्वाज ▁को ▁भरद्वाज ▁क्यों ▁बुला ता ▁है ▁?\n",
       "y: LMLabelList\n",
       ",,,,\n",
       "Path: .;\n",
       "\n",
       "Valid: LabelList (523 items)\n",
       "x: LMTextList\n",
       "▁x x bo s ▁एक ▁ऐसा ▁भी ▁जानवर ▁है ▁ , ▁जिसे ▁आप ▁पसंद ▁तो ▁करते ▁होंगे ▁ , ▁लेकिन ▁उसे ▁घर ▁में ▁रखने ▁का ▁ख्याल ▁तक ▁मन ▁में ▁नहीं ▁ला ▁सकते ▁ , ▁जैसे ▁कि ▁हाथी ▁ ।,▁x x bo s ▁इतना ▁नहीं ▁बल्कि ▁यहां ▁पर ▁कंपनी ▁अपना ▁पहला ▁फाइव ▁स्टार ▁रेटिंग ▁फ्रि ज ▁भी ▁लेकर ▁आई ▁है ▁जो ▁जल्द ▁ही ▁बाजार ▁में ▁मिलने ▁लगेगा ▁ ।,▁x x bo s ▁डि जि फल ी प ▁प्रो ▁ <unk> <unk> 8 11 ▁ , ▁1200 ▁x ▁800 <unk> ▁p ▁और ▁8 ▁इंच ▁डिस्प्ले ▁के ▁साथ ▁आता ▁है ▁ ।,▁x x bo s ▁नि कोन ▁डी 81 0 ▁कैमरे ▁की ▁सबसे ▁खास ▁बात ▁ये ▁है ▁कि ▁इसमें ▁फुल ▁फ्रेम ▁3 6.3 ▁मेगा प िक्स ल ▁सीम ॉस ▁सेंसर ▁और ▁आईएसओ ▁रेंज ▁दिया ▁गया ▁है ▁ ।,▁x x bo s ▁इसमें ▁विंडोज ▁8 ▁64 - बिट ▁ऑपरेटिंग ▁सिस्टम ▁है ▁ , ▁लेकिन ▁अच्छी ▁बात ▁ये ▁है ▁कि ▁इसमें ▁बहुत ▁सीमित ▁प्री लो डेड ▁सॉफ्टवेर ▁दिए ▁गए ▁हैं ▁जिससे ▁मशीन ▁बोझ िल ▁नहीं ▁होती ▁ ।\n",
       "y: LMLabelList\n",
       ",,,,\n",
       "Path: .;\n",
       "\n",
       "Test: LabelList (523 items)\n",
       "x: LMTextList\n",
       "▁x x bo s ▁मगर ▁ , ▁इस ▁तरफ ▁कोई ▁ध्यान ▁नहीं ▁दिया ▁जा ▁रहा ▁ ।,▁x x bo s ▁गेम ▁कई ▁बार ▁मुश्किल ▁मालूम ▁देता ▁है ▁ ।,▁x x bo s ▁मल्टी प्ले यर ▁में ▁छोटी ▁स्टोरी लाइन ▁है ▁ ।,▁x x bo s ▁हाई ▁- ▁एंड ▁एच पी ▁नोटबुक ्स ▁की ▁लुक ्स ▁हमेशा ▁बेहतरीन ▁होती ▁है ▁– ▁अत्याधुनिक ▁और ▁ए ग्रे सिव ▁लुक ▁जो ▁हर ▁किसी ▁को ▁भा ते ▁हैं ▁ ।,▁x x bo s ▁कैमरे ▁बनाने ▁वाली ▁कंपनी ▁नि कोन ▁अपनी ▁1 ▁सीरीज ▁कैमरों ▁में ▁इजाफा ▁करते ▁हुए ▁इस ▁सीरीज ▁का ▁सबसे ▁शानदार ▁कैमरा ▁लेकर ▁आई ▁है ▁ ।\n",
       "y: EmptyLabelList\n",
       ",,,,\n",
       "Path: ., model=SequentialRNN(\n",
       "  (0): AWD_LSTM(\n",
       "    (encoder): Embedding(30000, 400, padding_idx=1)\n",
       "    (encoder_dp): EmbeddingDropout(\n",
       "      (emb): Embedding(30000, 400, padding_idx=1)\n",
       "    )\n",
       "    (rnns): ModuleList(\n",
       "      (0): WeightDropout(\n",
       "        (module): LSTM(400, 1152, batch_first=True)\n",
       "      )\n",
       "      (1): WeightDropout(\n",
       "        (module): LSTM(1152, 1152, batch_first=True)\n",
       "      )\n",
       "      (2): WeightDropout(\n",
       "        (module): LSTM(1152, 400, batch_first=True)\n",
       "      )\n",
       "    )\n",
       "    (input_dp): RNNDropout()\n",
       "    (hidden_dps): ModuleList(\n",
       "      (0): RNNDropout()\n",
       "      (1): RNNDropout()\n",
       "      (2): RNNDropout()\n",
       "    )\n",
       "  )\n",
       "  (1): LinearDecoder(\n",
       "    (decoder): Linear(in_features=400, out_features=30000, bias=True)\n",
       "    (output_dp): RNNDropout()\n",
       "  )\n",
       "), opt_func=functools.partial(<class 'torch.optim.adam.Adam'>, betas=(0.9, 0.99)), loss_func=FlattenedLoss of CrossEntropyLoss(), metrics=[<function accuracy at 0x7f3049472158>], true_wd=True, bn_wd=True, wd=0.01, train_bn=True, path=PosixPath('.'), model_dir='models', callback_fns=[functools.partial(<class 'fastai.basic_train.Recorder'>, add_time=True, silent=False)], callbacks=[...], layer_groups=[Sequential(\n",
       "  (0): WeightDropout(\n",
       "    (module): LSTM(400, 1152, batch_first=True)\n",
       "  )\n",
       "  (1): RNNDropout()\n",
       "), Sequential(\n",
       "  (0): WeightDropout(\n",
       "    (module): LSTM(1152, 1152, batch_first=True)\n",
       "  )\n",
       "  (1): RNNDropout()\n",
       "), Sequential(\n",
       "  (0): WeightDropout(\n",
       "    (module): LSTM(1152, 400, batch_first=True)\n",
       "  )\n",
       "  (1): RNNDropout()\n",
       "), Sequential(\n",
       "  (0): Embedding(30000, 400, padding_idx=1)\n",
       "  (1): EmbeddingDropout(\n",
       "    (emb): Embedding(30000, 400, padding_idx=1)\n",
       "  )\n",
       "  (2): LinearDecoder(\n",
       "    (decoder): Linear(in_features=400, out_features=30000, bias=True)\n",
       "    (output_dp): RNNDropout()\n",
       "  )\n",
       ")], add_time=True, silent=False)\n",
       "alpha: 2.0\n",
       "beta: 1.0], layer_groups=[Sequential(\n",
       "  (0): WeightDropout(\n",
       "    (module): LSTM(400, 1152, batch_first=True)\n",
       "  )\n",
       "  (1): RNNDropout()\n",
       "), Sequential(\n",
       "  (0): WeightDropout(\n",
       "    (module): LSTM(1152, 1152, batch_first=True)\n",
       "  )\n",
       "  (1): RNNDropout()\n",
       "), Sequential(\n",
       "  (0): WeightDropout(\n",
       "    (module): LSTM(1152, 400, batch_first=True)\n",
       "  )\n",
       "  (1): RNNDropout()\n",
       "), Sequential(\n",
       "  (0): Embedding(30000, 400, padding_idx=1)\n",
       "  (1): EmbeddingDropout(\n",
       "    (emb): Embedding(30000, 400, padding_idx=1)\n",
       "  )\n",
       "  (2): LinearDecoder(\n",
       "    (decoder): Linear(in_features=400, out_features=30000, bias=True)\n",
       "    (output_dp): RNNDropout()\n",
       "  )\n",
       ")], add_time=True, silent=False)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Loading the pretrained language model on hindi wikipedia\n",
    "learn.load('../../../models/hindi/lm/ULMFiT - Trained on Hindi Wikipedia Articles - 172k/model')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fine tuning the prtrained LM on current dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='1' class='' max='2', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      50.00% [1/2 00:02<00:02]\n",
       "    </div>\n",
       "    \n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>4.691236</td>\n",
       "      <td>#na#</td>\n",
       "      <td>00:02</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table><p>\n",
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='47' class='' max='51', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      92.16% [47/51 00:02<00:00 9.4377]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n"
     ]
    }
   ],
   "source": [
    "learn.lr_find()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.recorder.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.freeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>3.887326</td>\n",
       "      <td>3.609842</td>\n",
       "      <td>0.422258</td>\n",
       "      <td>00:03</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit_one_cycle(1, 1e-2, moms=(0.8,0.7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save('fit_head', with_opt=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.load('fit_head', with_opt=True);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.unfreeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>3.161343</td>\n",
       "      <td>3.373509</td>\n",
       "      <td>0.442793</td>\n",
       "      <td>00:03</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>2.884025</td>\n",
       "      <td>3.340018</td>\n",
       "      <td>0.448151</td>\n",
       "      <td>00:03</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit_one_cycle(2, 1e-3, moms=(0.8,0.7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save('fine_tuned', with_opt=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.load('fine_tuned', with_opt=True);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'▁इस ▁लाइन ▁के ▁चलने ▁से ▁दक्षिणी  ▁भारत ▁में ▁कई ▁ग्रामीण ▁आबादी ▁से ▁पैदा ▁हुए ▁लोगों ▁की'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.predict('▁इस ▁लाइन ▁के ▁चलने ▁से ▁दक्षिणी ',n_words=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save_encoder('fine_tuned_enc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_clas = TextClasDataBunch.from_df(path=path, train_df=df_train, valid_df=df_valid, test_df=df_test, tokenizer=tokenizer, vocab=hindi_vocab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>text</th>\n",
       "      <th>target</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>▁x x bo s ▁नि कॉन ▁कूल ▁पि क् ▁स &lt;unk&gt; ▁s 6 300 &lt;unk&gt; ▁n ik on ▁co ol pi x &lt;unk&gt; ▁s 6 300 ▁कीमत ▁9 , 65 2 ▁रुपए ▁ , ▁कैमरा ▁साइ ज ▁9 3.6 ▁x ▁5 7.7 ▁x ▁36 ▁एम एम ▁ , ▁वे ट ▁: ▁160 ▁ग्राम ▁रेज ् ▁यू लू शन ▁: ▁16 ▁मेगा पि क् ▁सल ▁फो कल ▁ले ंथ ▁: ▁25</td>\n",
       "      <td>positive</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>▁x x bo s ▁एप् ▁पल ▁के ▁प्रो डे क् ▁ट ▁पूरे ▁विश् ▁व ▁में ▁मशहूर ▁हैं ▁फिर ▁चाहें ▁वो ▁स् ▁ मार्ट फोन ▁हो ▁या ▁फिर ▁कोई ▁अन् ▁य ▁एस ेसी रीज ▁ , ▁एप् ▁पल ▁भ विष् ▁य ▁में ▁कुछ ▁अपने ▁गै जेट ों ▁की ▁डिजाइन ▁में ▁काफी ▁बल ाव ▁करने ▁पर ▁विचार ▁कर ▁रहा ▁है ▁इसका ▁जीता ▁जाता ▁उदाहरण ▁है ▁एप् ▁पल ▁आई वॉ च ▁2 ▁इसे</td>\n",
       "      <td>positive</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>▁x x bo s ▁इस ▁बारे ▁में ▁सबसे ▁इर ् म् ▁पो टेंट ▁बात ▁यह ▁है ▁कि ▁अगर ▁आप ▁सैमसंग ▁के ▁अन् ▁य ▁प्रॉ ड क् ▁ ट्स ▁को ▁भी ▁यू ज ▁कर ▁रहे ▁हैं ▁तो ▁यह ▁डिवाइस ▁आपके ▁स् ▁ मार्ट फोन ▁के ▁कॉम् ▁पेट िबल ▁रहेगी ▁लेकिन ▁अगर ▁आप ▁सैमसंग ▁यूजर ▁नही ▁हैं ▁तो ▁आप ▁थोड़ा ▁वे ट ▁कर ▁सकते ▁हैं ▁क् ▁ योंकि ▁मोटोरोला ▁भी ▁अपनी ▁स्</td>\n",
       "      <td>neutral</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>▁x x bo s ▁ये रक ाड ▁या ▁ यर कौ द ▁में ▁ यूँ ▁तो ▁होटलों ▁की ▁कमी ▁नहीं ▁है ▁पर ▁बीस वें ▁हेयर पिन ▁बे ंड ▁के ▁ठीक ▁बाद &lt;unk&gt; ▁g &lt;unk&gt; rt &lt;unk&gt; ▁n ature &lt;unk&gt; il s ▁में ▁अगर ▁ना ▁भी ▁रुक ें ▁तो ▁यहाँ ▁एक ▁बार ▁भोजन ▁करना ▁तो ▁बनता ▁है ▁सिर्फ ▁इसलिए ▁नहीं ▁कि ▁यहाँ ▁के ▁व्यंजन ▁ल जी ज़ ▁हैं ▁बल्कि ▁खास तौर</td>\n",
       "      <td>positive</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>▁x x bo s ▁माइक्रो मैक्स ▁फ न बुक ▁की ▁एक ▁और ▁विशेषता ▁है ▁ , ▁इसमें ▁लगा ▁डू अल ▁कोर ▁400 &lt;unk&gt; ▁का ▁ग्राफिक ▁प्रोसेसर ▁जिससे ▁इस ▁डिवाइस ▁पर ▁फुल &lt;unk&gt; &lt;unk&gt; ▁10 80 p ▁का ▁वीडियो ▁प्लेबैक ▁की ▁सुविधा ▁भी ▁है ▁ , ▁पर ▁एक ▁बार ▁फिर ▁कम ▁डिस प्ले ▁रिज ॉ ल्यू शन ▁हाई ▁डे फिन िशन ▁कॉन् टेंट ▁के ▁म जे ▁को ▁खराब ▁कर ▁देता ▁है</td>\n",
       "      <td>positive</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_clas.show_batch()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = text_classifier_learner(data_clas, AWD_LSTM, drop_mult=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RNNLearner(data=TextClasDataBunch;\n",
       "\n",
       "Train: LabelList (4182 items)\n",
       "x: TextList\n",
       "▁x x bo s ▁एंड र ाॅय ड ▁के ▁मामले ▁में ▁यह ▁थोड़ा ▁पीछे ▁है ▁ ।,▁x x bo s ▁यह ▁ए स्पेक्ट ▁रे शो ▁का ▁ई श ्यू ▁है ▁और ▁हम ▁आशा ▁करते ▁हैं ▁कि ▁यह ▁आने ▁वाले ▁अपडेट ▁में ▁फिक्स ▁कर ▁दिया ▁जाएगा ▁ ।,▁x x bo s ▁लेकिन ▁इस ▁तरह ▁के ▁एक ▁मॉडल ▁के ▁एक ▁घर ▁कंप्यूटर ▁के ▁लिए ▁एक ▁शानदार ▁विकल्प ▁हो ▁सकता ▁है ▁ ।,▁x x bo s ▁गिर ▁वन ▁राष्ट्रीय ▁उद्यान ▁बाघ ▁संरक्षित ▁क्षेत्र ▁है ▁जो ▁एशियाई ▁बब्बर ▁शेर ▁के ▁लिए ▁विश्व ▁प्रसिद्ध ▁है ▁ ।,▁x x bo s ▁और ▁हां ▁ , ▁इस ▁फिल्म ▁में ▁हर ▁किरदार ▁भारद्वाज ▁को ▁भरद्वाज ▁क्यों ▁बुला ता ▁है ▁?\n",
       "y: CategoryList\n",
       "negative,neutral,positive,positive,neutral\n",
       "Path: .;\n",
       "\n",
       "Valid: LabelList (523 items)\n",
       "x: TextList\n",
       "▁x x bo s ▁एक ▁ऐसा ▁भी ▁जानवर ▁है ▁ , ▁जिसे ▁आप ▁पसंद ▁तो ▁करते ▁होंगे ▁ , ▁लेकिन ▁उसे ▁घर ▁में ▁रखने ▁का ▁ख्याल ▁तक ▁मन ▁में ▁नहीं ▁ला ▁सकते ▁ , ▁जैसे ▁कि ▁हाथी ▁ ।,▁x x bo s ▁इतना ▁नहीं ▁बल्कि ▁यहां ▁पर ▁कंपनी ▁अपना ▁पहला ▁फाइव ▁स्टार ▁रेटिंग ▁फ्रि ज ▁भी ▁लेकर ▁आई ▁है ▁जो ▁जल्द ▁ही ▁बाजार ▁में ▁मिलने ▁लगेगा ▁ ।,▁x x bo s ▁डि जि फल ी प ▁प्रो ▁ <unk> <unk> 8 11 ▁ , ▁1200 ▁x ▁800 <unk> ▁p ▁और ▁8 ▁इंच ▁डिस्प्ले ▁के ▁साथ ▁आता ▁है ▁ ।,▁x x bo s ▁नि कोन ▁डी 81 0 ▁कैमरे ▁की ▁सबसे ▁खास ▁बात ▁ये ▁है ▁कि ▁इसमें ▁फुल ▁फ्रेम ▁3 6.3 ▁मेगा प िक्स ल ▁सीम ॉस ▁सेंसर ▁और ▁आईएसओ ▁रेंज ▁दिया ▁गया ▁है ▁ ।,▁x x bo s ▁इसमें ▁विंडोज ▁8 ▁64 - बिट ▁ऑपरेटिंग ▁सिस्टम ▁है ▁ , ▁लेकिन ▁अच्छी ▁बात ▁ये ▁है ▁कि ▁इसमें ▁बहुत ▁सीमित ▁प्री लो डेड ▁सॉफ्टवेर ▁दिए ▁गए ▁हैं ▁जिससे ▁मशीन ▁बोझ िल ▁नहीं ▁होती ▁ ।\n",
       "y: CategoryList\n",
       "positive,neutral,neutral,positive,positive\n",
       "Path: .;\n",
       "\n",
       "Test: LabelList (523 items)\n",
       "x: TextList\n",
       "▁x x bo s ▁मगर ▁ , ▁इस ▁तरफ ▁कोई ▁ध्यान ▁नहीं ▁दिया ▁जा ▁रहा ▁ ।,▁x x bo s ▁गेम ▁कई ▁बार ▁मुश्किल ▁मालूम ▁देता ▁है ▁ ।,▁x x bo s ▁मल्टी प्ले यर ▁में ▁छोटी ▁स्टोरी लाइन ▁है ▁ ।,▁x x bo s ▁हाई ▁- ▁एंड ▁एच पी ▁नोटबुक ्स ▁की ▁लुक ्स ▁हमेशा ▁बेहतरीन ▁होती ▁है ▁– ▁अत्याधुनिक ▁और ▁ए ग्रे सिव ▁लुक ▁जो ▁हर ▁किसी ▁को ▁भा ते ▁हैं ▁ ।,▁x x bo s ▁कैमरे ▁बनाने ▁वाली ▁कंपनी ▁नि कोन ▁अपनी ▁1 ▁सीरीज ▁कैमरों ▁में ▁इजाफा ▁करते ▁हुए ▁इस ▁सीरीज ▁का ▁सबसे ▁शानदार ▁कैमरा ▁लेकर ▁आई ▁है ▁ ।\n",
       "y: EmptyLabelList\n",
       ",,,,\n",
       "Path: ., model=SequentialRNN(\n",
       "  (0): MultiBatchEncoder(\n",
       "    (module): AWD_LSTM(\n",
       "      (encoder): Embedding(30000, 400, padding_idx=1)\n",
       "      (encoder_dp): EmbeddingDropout(\n",
       "        (emb): Embedding(30000, 400, padding_idx=1)\n",
       "      )\n",
       "      (rnns): ModuleList(\n",
       "        (0): WeightDropout(\n",
       "          (module): LSTM(400, 1152, batch_first=True)\n",
       "        )\n",
       "        (1): WeightDropout(\n",
       "          (module): LSTM(1152, 1152, batch_first=True)\n",
       "        )\n",
       "        (2): WeightDropout(\n",
       "          (module): LSTM(1152, 400, batch_first=True)\n",
       "        )\n",
       "      )\n",
       "      (input_dp): RNNDropout()\n",
       "      (hidden_dps): ModuleList(\n",
       "        (0): RNNDropout()\n",
       "        (1): RNNDropout()\n",
       "        (2): RNNDropout()\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (1): PoolingLinearClassifier(\n",
       "    (layers): Sequential(\n",
       "      (0): BatchNorm1d(1200, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (1): Dropout(p=0.2)\n",
       "      (2): Linear(in_features=1200, out_features=50, bias=True)\n",
       "      (3): ReLU(inplace)\n",
       "      (4): BatchNorm1d(50, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (5): Dropout(p=0.1)\n",
       "      (6): Linear(in_features=50, out_features=3, bias=True)\n",
       "    )\n",
       "  )\n",
       "), opt_func=functools.partial(<class 'torch.optim.adam.Adam'>, betas=(0.9, 0.99)), loss_func=FlattenedLoss of CrossEntropyLoss(), metrics=[<function accuracy at 0x7f3049472158>], true_wd=True, bn_wd=True, wd=0.01, train_bn=True, path=PosixPath('.'), model_dir='models', callback_fns=[functools.partial(<class 'fastai.basic_train.Recorder'>, add_time=True, silent=False)], callbacks=[RNNTrainer\n",
       "learn: RNNLearner(data=TextClasDataBunch;\n",
       "\n",
       "Train: LabelList (4182 items)\n",
       "x: TextList\n",
       "▁x x bo s ▁एंड र ाॅय ड ▁के ▁मामले ▁में ▁यह ▁थोड़ा ▁पीछे ▁है ▁ ।,▁x x bo s ▁यह ▁ए स्पेक्ट ▁रे शो ▁का ▁ई श ्यू ▁है ▁और ▁हम ▁आशा ▁करते ▁हैं ▁कि ▁यह ▁आने ▁वाले ▁अपडेट ▁में ▁फिक्स ▁कर ▁दिया ▁जाएगा ▁ ।,▁x x bo s ▁लेकिन ▁इस ▁तरह ▁के ▁एक ▁मॉडल ▁के ▁एक ▁घर ▁कंप्यूटर ▁के ▁लिए ▁एक ▁शानदार ▁विकल्प ▁हो ▁सकता ▁है ▁ ।,▁x x bo s ▁गिर ▁वन ▁राष्ट्रीय ▁उद्यान ▁बाघ ▁संरक्षित ▁क्षेत्र ▁है ▁जो ▁एशियाई ▁बब्बर ▁शेर ▁के ▁लिए ▁विश्व ▁प्रसिद्ध ▁है ▁ ।,▁x x bo s ▁और ▁हां ▁ , ▁इस ▁फिल्म ▁में ▁हर ▁किरदार ▁भारद्वाज ▁को ▁भरद्वाज ▁क्यों ▁बुला ता ▁है ▁?\n",
       "y: CategoryList\n",
       "negative,neutral,positive,positive,neutral\n",
       "Path: .;\n",
       "\n",
       "Valid: LabelList (523 items)\n",
       "x: TextList\n",
       "▁x x bo s ▁एक ▁ऐसा ▁भी ▁जानवर ▁है ▁ , ▁जिसे ▁आप ▁पसंद ▁तो ▁करते ▁होंगे ▁ , ▁लेकिन ▁उसे ▁घर ▁में ▁रखने ▁का ▁ख्याल ▁तक ▁मन ▁में ▁नहीं ▁ला ▁सकते ▁ , ▁जैसे ▁कि ▁हाथी ▁ ।,▁x x bo s ▁इतना ▁नहीं ▁बल्कि ▁यहां ▁पर ▁कंपनी ▁अपना ▁पहला ▁फाइव ▁स्टार ▁रेटिंग ▁फ्रि ज ▁भी ▁लेकर ▁आई ▁है ▁जो ▁जल्द ▁ही ▁बाजार ▁में ▁मिलने ▁लगेगा ▁ ।,▁x x bo s ▁डि जि फल ी प ▁प्रो ▁ <unk> <unk> 8 11 ▁ , ▁1200 ▁x ▁800 <unk> ▁p ▁और ▁8 ▁इंच ▁डिस्प्ले ▁के ▁साथ ▁आता ▁है ▁ ।,▁x x bo s ▁नि कोन ▁डी 81 0 ▁कैमरे ▁की ▁सबसे ▁खास ▁बात ▁ये ▁है ▁कि ▁इसमें ▁फुल ▁फ्रेम ▁3 6.3 ▁मेगा प िक्स ल ▁सीम ॉस ▁सेंसर ▁और ▁आईएसओ ▁रेंज ▁दिया ▁गया ▁है ▁ ।,▁x x bo s ▁इसमें ▁विंडोज ▁8 ▁64 - बिट ▁ऑपरेटिंग ▁सिस्टम ▁है ▁ , ▁लेकिन ▁अच्छी ▁बात ▁ये ▁है ▁कि ▁इसमें ▁बहुत ▁सीमित ▁प्री लो डेड ▁सॉफ्टवेर ▁दिए ▁गए ▁हैं ▁जिससे ▁मशीन ▁बोझ िल ▁नहीं ▁होती ▁ ।\n",
       "y: CategoryList\n",
       "positive,neutral,neutral,positive,positive\n",
       "Path: .;\n",
       "\n",
       "Test: LabelList (523 items)\n",
       "x: TextList\n",
       "▁x x bo s ▁मगर ▁ , ▁इस ▁तरफ ▁कोई ▁ध्यान ▁नहीं ▁दिया ▁जा ▁रहा ▁ ।,▁x x bo s ▁गेम ▁कई ▁बार ▁मुश्किल ▁मालूम ▁देता ▁है ▁ ।,▁x x bo s ▁मल्टी प्ले यर ▁में ▁छोटी ▁स्टोरी लाइन ▁है ▁ ।,▁x x bo s ▁हाई ▁- ▁एंड ▁एच पी ▁नोटबुक ्स ▁की ▁लुक ्स ▁हमेशा ▁बेहतरीन ▁होती ▁है ▁– ▁अत्याधुनिक ▁और ▁ए ग्रे सिव ▁लुक ▁जो ▁हर ▁किसी ▁को ▁भा ते ▁हैं ▁ ।,▁x x bo s ▁कैमरे ▁बनाने ▁वाली ▁कंपनी ▁नि कोन ▁अपनी ▁1 ▁सीरीज ▁कैमरों ▁में ▁इजाफा ▁करते ▁हुए ▁इस ▁सीरीज ▁का ▁सबसे ▁शानदार ▁कैमरा ▁लेकर ▁आई ▁है ▁ ।\n",
       "y: EmptyLabelList\n",
       ",,,,\n",
       "Path: ., model=SequentialRNN(\n",
       "  (0): MultiBatchEncoder(\n",
       "    (module): AWD_LSTM(\n",
       "      (encoder): Embedding(30000, 400, padding_idx=1)\n",
       "      (encoder_dp): EmbeddingDropout(\n",
       "        (emb): Embedding(30000, 400, padding_idx=1)\n",
       "      )\n",
       "      (rnns): ModuleList(\n",
       "        (0): WeightDropout(\n",
       "          (module): LSTM(400, 1152, batch_first=True)\n",
       "        )\n",
       "        (1): WeightDropout(\n",
       "          (module): LSTM(1152, 1152, batch_first=True)\n",
       "        )\n",
       "        (2): WeightDropout(\n",
       "          (module): LSTM(1152, 400, batch_first=True)\n",
       "        )\n",
       "      )\n",
       "      (input_dp): RNNDropout()\n",
       "      (hidden_dps): ModuleList(\n",
       "        (0): RNNDropout()\n",
       "        (1): RNNDropout()\n",
       "        (2): RNNDropout()\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (1): PoolingLinearClassifier(\n",
       "    (layers): Sequential(\n",
       "      (0): BatchNorm1d(1200, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (1): Dropout(p=0.2)\n",
       "      (2): Linear(in_features=1200, out_features=50, bias=True)\n",
       "      (3): ReLU(inplace)\n",
       "      (4): BatchNorm1d(50, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (5): Dropout(p=0.1)\n",
       "      (6): Linear(in_features=50, out_features=3, bias=True)\n",
       "    )\n",
       "  )\n",
       "), opt_func=functools.partial(<class 'torch.optim.adam.Adam'>, betas=(0.9, 0.99)), loss_func=FlattenedLoss of CrossEntropyLoss(), metrics=[<function accuracy at 0x7f3049472158>], true_wd=True, bn_wd=True, wd=0.01, train_bn=True, path=PosixPath('.'), model_dir='models', callback_fns=[functools.partial(<class 'fastai.basic_train.Recorder'>, add_time=True, silent=False)], callbacks=[...], layer_groups=[Sequential(\n",
       "  (0): Embedding(30000, 400, padding_idx=1)\n",
       "  (1): EmbeddingDropout(\n",
       "    (emb): Embedding(30000, 400, padding_idx=1)\n",
       "  )\n",
       "), Sequential(\n",
       "  (0): WeightDropout(\n",
       "    (module): LSTM(400, 1152, batch_first=True)\n",
       "  )\n",
       "  (1): RNNDropout()\n",
       "), Sequential(\n",
       "  (0): WeightDropout(\n",
       "    (module): LSTM(1152, 1152, batch_first=True)\n",
       "  )\n",
       "  (1): RNNDropout()\n",
       "), Sequential(\n",
       "  (0): WeightDropout(\n",
       "    (module): LSTM(1152, 400, batch_first=True)\n",
       "  )\n",
       "  (1): RNNDropout()\n",
       "), Sequential(\n",
       "  (0): PoolingLinearClassifier(\n",
       "    (layers): Sequential(\n",
       "      (0): BatchNorm1d(1200, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (1): Dropout(p=0.2)\n",
       "      (2): Linear(in_features=1200, out_features=50, bias=True)\n",
       "      (3): ReLU(inplace)\n",
       "      (4): BatchNorm1d(50, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (5): Dropout(p=0.1)\n",
       "      (6): Linear(in_features=50, out_features=3, bias=True)\n",
       "    )\n",
       "  )\n",
       ")], add_time=True, silent=False)\n",
       "alpha: 2.0\n",
       "beta: 1.0], layer_groups=[Sequential(\n",
       "  (0): Embedding(30000, 400, padding_idx=1)\n",
       "  (1): EmbeddingDropout(\n",
       "    (emb): Embedding(30000, 400, padding_idx=1)\n",
       "  )\n",
       "), Sequential(\n",
       "  (0): WeightDropout(\n",
       "    (module): LSTM(400, 1152, batch_first=True)\n",
       "  )\n",
       "  (1): RNNDropout()\n",
       "), Sequential(\n",
       "  (0): WeightDropout(\n",
       "    (module): LSTM(1152, 1152, batch_first=True)\n",
       "  )\n",
       "  (1): RNNDropout()\n",
       "), Sequential(\n",
       "  (0): WeightDropout(\n",
       "    (module): LSTM(1152, 400, batch_first=True)\n",
       "  )\n",
       "  (1): RNNDropout()\n",
       "), Sequential(\n",
       "  (0): PoolingLinearClassifier(\n",
       "    (layers): Sequential(\n",
       "      (0): BatchNorm1d(1200, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (1): Dropout(p=0.2)\n",
       "      (2): Linear(in_features=1200, out_features=50, bias=True)\n",
       "      (3): ReLU(inplace)\n",
       "      (4): BatchNorm1d(50, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (5): Dropout(p=0.1)\n",
       "      (6): Linear(in_features=50, out_features=3, bias=True)\n",
       "    )\n",
       "  )\n",
       ")], add_time=True, silent=False)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.load_encoder('fine_tuned_enc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.freeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='1' class='' max='2', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      50.00% [1/2 00:01<00:01]\n",
       "    </div>\n",
       "    \n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.047122</td>\n",
       "      <td>#na#</td>\n",
       "      <td>00:01</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table><p>\n",
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='27' class='' max='65', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      41.54% [27/65 00:00<00:01 1.6618]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n"
     ]
    }
   ],
   "source": [
    "learn.lr_find()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.recorder.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CrossEntropyLoss()"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.loss_func.func"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "mcc = MatthewsCorreff()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.metrics = [mcc, accuracy]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>matthews_correff</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.855938</td>\n",
       "      <td>0.774860</td>\n",
       "      <td>0.389029</td>\n",
       "      <td>0.636711</td>\n",
       "      <td>00:01</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit_one_cycle(1, 1e-1, moms=(0.8,0.7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save('first-full')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.load('first-full');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>matthews_correff</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.755116</td>\n",
       "      <td>0.692089</td>\n",
       "      <td>0.453856</td>\n",
       "      <td>0.673040</td>\n",
       "      <td>00:01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.694784</td>\n",
       "      <td>0.651466</td>\n",
       "      <td>0.479238</td>\n",
       "      <td>0.688336</td>\n",
       "      <td>00:01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.588531</td>\n",
       "      <td>0.619435</td>\n",
       "      <td>0.551255</td>\n",
       "      <td>0.724665</td>\n",
       "      <td>00:01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.472915</td>\n",
       "      <td>0.634819</td>\n",
       "      <td>0.553503</td>\n",
       "      <td>0.722753</td>\n",
       "      <td>00:01</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.freeze_to(-2)\n",
    "learn.fit_one_cycle(4, slice(1e-2/(2.6**4),1e-2), moms=(0.8,0.7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save('second-full')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RNNLearner(data=TextClasDataBunch;\n",
       "\n",
       "Train: LabelList (4182 items)\n",
       "x: TextList\n",
       "▁x x bo s ▁एंड र ाॅय ड ▁के ▁मामले ▁में ▁यह ▁थोड़ा ▁पीछे ▁है ▁ ।,▁x x bo s ▁यह ▁ए स्पेक्ट ▁रे शो ▁का ▁ई श ्यू ▁है ▁और ▁हम ▁आशा ▁करते ▁हैं ▁कि ▁यह ▁आने ▁वाले ▁अपडेट ▁में ▁फिक्स ▁कर ▁दिया ▁जाएगा ▁ ।,▁x x bo s ▁लेकिन ▁इस ▁तरह ▁के ▁एक ▁मॉडल ▁के ▁एक ▁घर ▁कंप्यूटर ▁के ▁लिए ▁एक ▁शानदार ▁विकल्प ▁हो ▁सकता ▁है ▁ ।,▁x x bo s ▁गिर ▁वन ▁राष्ट्रीय ▁उद्यान ▁बाघ ▁संरक्षित ▁क्षेत्र ▁है ▁जो ▁एशियाई ▁बब्बर ▁शेर ▁के ▁लिए ▁विश्व ▁प्रसिद्ध ▁है ▁ ।,▁x x bo s ▁और ▁हां ▁ , ▁इस ▁फिल्म ▁में ▁हर ▁किरदार ▁भारद्वाज ▁को ▁भरद्वाज ▁क्यों ▁बुला ता ▁है ▁?\n",
       "y: CategoryList\n",
       "negative,neutral,positive,positive,neutral\n",
       "Path: .;\n",
       "\n",
       "Valid: LabelList (523 items)\n",
       "x: TextList\n",
       "▁x x bo s ▁एक ▁ऐसा ▁भी ▁जानवर ▁है ▁ , ▁जिसे ▁आप ▁पसंद ▁तो ▁करते ▁होंगे ▁ , ▁लेकिन ▁उसे ▁घर ▁में ▁रखने ▁का ▁ख्याल ▁तक ▁मन ▁में ▁नहीं ▁ला ▁सकते ▁ , ▁जैसे ▁कि ▁हाथी ▁ ।,▁x x bo s ▁इतना ▁नहीं ▁बल्कि ▁यहां ▁पर ▁कंपनी ▁अपना ▁पहला ▁फाइव ▁स्टार ▁रेटिंग ▁फ्रि ज ▁भी ▁लेकर ▁आई ▁है ▁जो ▁जल्द ▁ही ▁बाजार ▁में ▁मिलने ▁लगेगा ▁ ।,▁x x bo s ▁डि जि फल ी प ▁प्रो ▁ <unk> <unk> 8 11 ▁ , ▁1200 ▁x ▁800 <unk> ▁p ▁और ▁8 ▁इंच ▁डिस्प्ले ▁के ▁साथ ▁आता ▁है ▁ ।,▁x x bo s ▁नि कोन ▁डी 81 0 ▁कैमरे ▁की ▁सबसे ▁खास ▁बात ▁ये ▁है ▁कि ▁इसमें ▁फुल ▁फ्रेम ▁3 6.3 ▁मेगा प िक्स ल ▁सीम ॉस ▁सेंसर ▁और ▁आईएसओ ▁रेंज ▁दिया ▁गया ▁है ▁ ।,▁x x bo s ▁इसमें ▁विंडोज ▁8 ▁64 - बिट ▁ऑपरेटिंग ▁सिस्टम ▁है ▁ , ▁लेकिन ▁अच्छी ▁बात ▁ये ▁है ▁कि ▁इसमें ▁बहुत ▁सीमित ▁प्री लो डेड ▁सॉफ्टवेर ▁दिए ▁गए ▁हैं ▁जिससे ▁मशीन ▁बोझ िल ▁नहीं ▁होती ▁ ।\n",
       "y: CategoryList\n",
       "positive,neutral,neutral,positive,positive\n",
       "Path: .;\n",
       "\n",
       "Test: LabelList (523 items)\n",
       "x: TextList\n",
       "▁x x bo s ▁मगर ▁ , ▁इस ▁तरफ ▁कोई ▁ध्यान ▁नहीं ▁दिया ▁जा ▁रहा ▁ ।,▁x x bo s ▁गेम ▁कई ▁बार ▁मुश्किल ▁मालूम ▁देता ▁है ▁ ।,▁x x bo s ▁मल्टी प्ले यर ▁में ▁छोटी ▁स्टोरी लाइन ▁है ▁ ।,▁x x bo s ▁हाई ▁- ▁एंड ▁एच पी ▁नोटबुक ्स ▁की ▁लुक ्स ▁हमेशा ▁बेहतरीन ▁होती ▁है ▁– ▁अत्याधुनिक ▁और ▁ए ग्रे सिव ▁लुक ▁जो ▁हर ▁किसी ▁को ▁भा ते ▁हैं ▁ ।,▁x x bo s ▁कैमरे ▁बनाने ▁वाली ▁कंपनी ▁नि कोन ▁अपनी ▁1 ▁सीरीज ▁कैमरों ▁में ▁इजाफा ▁करते ▁हुए ▁इस ▁सीरीज ▁का ▁सबसे ▁शानदार ▁कैमरा ▁लेकर ▁आई ▁है ▁ ।\n",
       "y: EmptyLabelList\n",
       ",,,,\n",
       "Path: ., model=SequentialRNN(\n",
       "  (0): MultiBatchEncoder(\n",
       "    (module): AWD_LSTM(\n",
       "      (encoder): Embedding(30000, 400, padding_idx=1)\n",
       "      (encoder_dp): EmbeddingDropout(\n",
       "        (emb): Embedding(30000, 400, padding_idx=1)\n",
       "      )\n",
       "      (rnns): ModuleList(\n",
       "        (0): WeightDropout(\n",
       "          (module): LSTM(400, 1152, batch_first=True)\n",
       "        )\n",
       "        (1): WeightDropout(\n",
       "          (module): LSTM(1152, 1152, batch_first=True)\n",
       "        )\n",
       "        (2): WeightDropout(\n",
       "          (module): LSTM(1152, 400, batch_first=True)\n",
       "        )\n",
       "      )\n",
       "      (input_dp): RNNDropout()\n",
       "      (hidden_dps): ModuleList(\n",
       "        (0): RNNDropout()\n",
       "        (1): RNNDropout()\n",
       "        (2): RNNDropout()\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (1): PoolingLinearClassifier(\n",
       "    (layers): Sequential(\n",
       "      (0): BatchNorm1d(1200, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (1): Dropout(p=0.2)\n",
       "      (2): Linear(in_features=1200, out_features=50, bias=True)\n",
       "      (3): ReLU(inplace)\n",
       "      (4): BatchNorm1d(50, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (5): Dropout(p=0.1)\n",
       "      (6): Linear(in_features=50, out_features=3, bias=True)\n",
       "    )\n",
       "  )\n",
       "), opt_func=functools.partial(<class 'torch.optim.adam.Adam'>, betas=(0.9, 0.99)), loss_func=FlattenedLoss of CrossEntropyLoss(), metrics=[MatthewsCorreff(), <function accuracy at 0x7f3049472158>], true_wd=True, bn_wd=True, wd=0.01, train_bn=True, path=PosixPath('.'), model_dir='models', callback_fns=[functools.partial(<class 'fastai.basic_train.Recorder'>, add_time=True, silent=False)], callbacks=[RNNTrainer\n",
       "learn: RNNLearner(data=TextClasDataBunch;\n",
       "\n",
       "Train: LabelList (4182 items)\n",
       "x: TextList\n",
       "▁x x bo s ▁एंड र ाॅय ड ▁के ▁मामले ▁में ▁यह ▁थोड़ा ▁पीछे ▁है ▁ ।,▁x x bo s ▁यह ▁ए स्पेक्ट ▁रे शो ▁का ▁ई श ्यू ▁है ▁और ▁हम ▁आशा ▁करते ▁हैं ▁कि ▁यह ▁आने ▁वाले ▁अपडेट ▁में ▁फिक्स ▁कर ▁दिया ▁जाएगा ▁ ।,▁x x bo s ▁लेकिन ▁इस ▁तरह ▁के ▁एक ▁मॉडल ▁के ▁एक ▁घर ▁कंप्यूटर ▁के ▁लिए ▁एक ▁शानदार ▁विकल्प ▁हो ▁सकता ▁है ▁ ।,▁x x bo s ▁गिर ▁वन ▁राष्ट्रीय ▁उद्यान ▁बाघ ▁संरक्षित ▁क्षेत्र ▁है ▁जो ▁एशियाई ▁बब्बर ▁शेर ▁के ▁लिए ▁विश्व ▁प्रसिद्ध ▁है ▁ ।,▁x x bo s ▁और ▁हां ▁ , ▁इस ▁फिल्म ▁में ▁हर ▁किरदार ▁भारद्वाज ▁को ▁भरद्वाज ▁क्यों ▁बुला ता ▁है ▁?\n",
       "y: CategoryList\n",
       "negative,neutral,positive,positive,neutral\n",
       "Path: .;\n",
       "\n",
       "Valid: LabelList (523 items)\n",
       "x: TextList\n",
       "▁x x bo s ▁एक ▁ऐसा ▁भी ▁जानवर ▁है ▁ , ▁जिसे ▁आप ▁पसंद ▁तो ▁करते ▁होंगे ▁ , ▁लेकिन ▁उसे ▁घर ▁में ▁रखने ▁का ▁ख्याल ▁तक ▁मन ▁में ▁नहीं ▁ला ▁सकते ▁ , ▁जैसे ▁कि ▁हाथी ▁ ।,▁x x bo s ▁इतना ▁नहीं ▁बल्कि ▁यहां ▁पर ▁कंपनी ▁अपना ▁पहला ▁फाइव ▁स्टार ▁रेटिंग ▁फ्रि ज ▁भी ▁लेकर ▁आई ▁है ▁जो ▁जल्द ▁ही ▁बाजार ▁में ▁मिलने ▁लगेगा ▁ ।,▁x x bo s ▁डि जि फल ी प ▁प्रो ▁ <unk> <unk> 8 11 ▁ , ▁1200 ▁x ▁800 <unk> ▁p ▁और ▁8 ▁इंच ▁डिस्प्ले ▁के ▁साथ ▁आता ▁है ▁ ।,▁x x bo s ▁नि कोन ▁डी 81 0 ▁कैमरे ▁की ▁सबसे ▁खास ▁बात ▁ये ▁है ▁कि ▁इसमें ▁फुल ▁फ्रेम ▁3 6.3 ▁मेगा प िक्स ल ▁सीम ॉस ▁सेंसर ▁और ▁आईएसओ ▁रेंज ▁दिया ▁गया ▁है ▁ ।,▁x x bo s ▁इसमें ▁विंडोज ▁8 ▁64 - बिट ▁ऑपरेटिंग ▁सिस्टम ▁है ▁ , ▁लेकिन ▁अच्छी ▁बात ▁ये ▁है ▁कि ▁इसमें ▁बहुत ▁सीमित ▁प्री लो डेड ▁सॉफ्टवेर ▁दिए ▁गए ▁हैं ▁जिससे ▁मशीन ▁बोझ िल ▁नहीं ▁होती ▁ ।\n",
       "y: CategoryList\n",
       "positive,neutral,neutral,positive,positive\n",
       "Path: .;\n",
       "\n",
       "Test: LabelList (523 items)\n",
       "x: TextList\n",
       "▁x x bo s ▁मगर ▁ , ▁इस ▁तरफ ▁कोई ▁ध्यान ▁नहीं ▁दिया ▁जा ▁रहा ▁ ।,▁x x bo s ▁गेम ▁कई ▁बार ▁मुश्किल ▁मालूम ▁देता ▁है ▁ ।,▁x x bo s ▁मल्टी प्ले यर ▁में ▁छोटी ▁स्टोरी लाइन ▁है ▁ ।,▁x x bo s ▁हाई ▁- ▁एंड ▁एच पी ▁नोटबुक ्स ▁की ▁लुक ्स ▁हमेशा ▁बेहतरीन ▁होती ▁है ▁– ▁अत्याधुनिक ▁और ▁ए ग्रे सिव ▁लुक ▁जो ▁हर ▁किसी ▁को ▁भा ते ▁हैं ▁ ।,▁x x bo s ▁कैमरे ▁बनाने ▁वाली ▁कंपनी ▁नि कोन ▁अपनी ▁1 ▁सीरीज ▁कैमरों ▁में ▁इजाफा ▁करते ▁हुए ▁इस ▁सीरीज ▁का ▁सबसे ▁शानदार ▁कैमरा ▁लेकर ▁आई ▁है ▁ ।\n",
       "y: EmptyLabelList\n",
       ",,,,\n",
       "Path: ., model=SequentialRNN(\n",
       "  (0): MultiBatchEncoder(\n",
       "    (module): AWD_LSTM(\n",
       "      (encoder): Embedding(30000, 400, padding_idx=1)\n",
       "      (encoder_dp): EmbeddingDropout(\n",
       "        (emb): Embedding(30000, 400, padding_idx=1)\n",
       "      )\n",
       "      (rnns): ModuleList(\n",
       "        (0): WeightDropout(\n",
       "          (module): LSTM(400, 1152, batch_first=True)\n",
       "        )\n",
       "        (1): WeightDropout(\n",
       "          (module): LSTM(1152, 1152, batch_first=True)\n",
       "        )\n",
       "        (2): WeightDropout(\n",
       "          (module): LSTM(1152, 400, batch_first=True)\n",
       "        )\n",
       "      )\n",
       "      (input_dp): RNNDropout()\n",
       "      (hidden_dps): ModuleList(\n",
       "        (0): RNNDropout()\n",
       "        (1): RNNDropout()\n",
       "        (2): RNNDropout()\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (1): PoolingLinearClassifier(\n",
       "    (layers): Sequential(\n",
       "      (0): BatchNorm1d(1200, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (1): Dropout(p=0.2)\n",
       "      (2): Linear(in_features=1200, out_features=50, bias=True)\n",
       "      (3): ReLU(inplace)\n",
       "      (4): BatchNorm1d(50, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (5): Dropout(p=0.1)\n",
       "      (6): Linear(in_features=50, out_features=3, bias=True)\n",
       "    )\n",
       "  )\n",
       "), opt_func=functools.partial(<class 'torch.optim.adam.Adam'>, betas=(0.9, 0.99)), loss_func=FlattenedLoss of CrossEntropyLoss(), metrics=[MatthewsCorreff(), <function accuracy at 0x7f3049472158>], true_wd=True, bn_wd=True, wd=0.01, train_bn=True, path=PosixPath('.'), model_dir='models', callback_fns=[functools.partial(<class 'fastai.basic_train.Recorder'>, add_time=True, silent=False)], callbacks=[...], layer_groups=[Sequential(\n",
       "  (0): Embedding(30000, 400, padding_idx=1)\n",
       "  (1): EmbeddingDropout(\n",
       "    (emb): Embedding(30000, 400, padding_idx=1)\n",
       "  )\n",
       "), Sequential(\n",
       "  (0): WeightDropout(\n",
       "    (module): LSTM(400, 1152, batch_first=True)\n",
       "  )\n",
       "  (1): RNNDropout()\n",
       "), Sequential(\n",
       "  (0): WeightDropout(\n",
       "    (module): LSTM(1152, 1152, batch_first=True)\n",
       "  )\n",
       "  (1): RNNDropout()\n",
       "), Sequential(\n",
       "  (0): WeightDropout(\n",
       "    (module): LSTM(1152, 400, batch_first=True)\n",
       "  )\n",
       "  (1): RNNDropout()\n",
       "), Sequential(\n",
       "  (0): PoolingLinearClassifier(\n",
       "    (layers): Sequential(\n",
       "      (0): BatchNorm1d(1200, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (1): Dropout(p=0.2)\n",
       "      (2): Linear(in_features=1200, out_features=50, bias=True)\n",
       "      (3): ReLU(inplace)\n",
       "      (4): BatchNorm1d(50, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (5): Dropout(p=0.1)\n",
       "      (6): Linear(in_features=50, out_features=3, bias=True)\n",
       "    )\n",
       "  )\n",
       ")], add_time=True, silent=False)\n",
       "alpha: 2.0\n",
       "beta: 1.0], layer_groups=[Sequential(\n",
       "  (0): Embedding(30000, 400, padding_idx=1)\n",
       "  (1): EmbeddingDropout(\n",
       "    (emb): Embedding(30000, 400, padding_idx=1)\n",
       "  )\n",
       "), Sequential(\n",
       "  (0): WeightDropout(\n",
       "    (module): LSTM(400, 1152, batch_first=True)\n",
       "  )\n",
       "  (1): RNNDropout()\n",
       "), Sequential(\n",
       "  (0): WeightDropout(\n",
       "    (module): LSTM(1152, 1152, batch_first=True)\n",
       "  )\n",
       "  (1): RNNDropout()\n",
       "), Sequential(\n",
       "  (0): WeightDropout(\n",
       "    (module): LSTM(1152, 400, batch_first=True)\n",
       "  )\n",
       "  (1): RNNDropout()\n",
       "), Sequential(\n",
       "  (0): PoolingLinearClassifier(\n",
       "    (layers): Sequential(\n",
       "      (0): BatchNorm1d(1200, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (1): Dropout(p=0.2)\n",
       "      (2): Linear(in_features=1200, out_features=50, bias=True)\n",
       "      (3): ReLU(inplace)\n",
       "      (4): BatchNorm1d(50, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (5): Dropout(p=0.1)\n",
       "      (6): Linear(in_features=50, out_features=3, bias=True)\n",
       "    )\n",
       "  )\n",
       ")], add_time=True, silent=False)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.load('second-full')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>matthews_correff</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.477516</td>\n",
       "      <td>0.652740</td>\n",
       "      <td>0.532421</td>\n",
       "      <td>0.711281</td>\n",
       "      <td>00:03</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.405279</td>\n",
       "      <td>0.717211</td>\n",
       "      <td>0.563376</td>\n",
       "      <td>0.718929</td>\n",
       "      <td>00:03</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.232454</td>\n",
       "      <td>0.703717</td>\n",
       "      <td>0.568024</td>\n",
       "      <td>0.734226</td>\n",
       "      <td>00:03</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.unfreeze()\n",
    "learn.fit_one_cycle(3, slice(1e-2/(2.6**4),1e-2), moms=(0.8,0.7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save('final')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "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>query</th>\n",
       "      <th>actual_label</th>\n",
       "      <th>predicted_label</th>\n",
       "      <th>negative</th>\n",
       "      <th>neutral</th>\n",
       "      <th>positive</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>मगर , इस तरफ कोई ध्यान नहीं दिया जा रहा ।</td>\n",
       "      <td>neutral</td>\n",
       "      <td>neutral</td>\n",
       "      <td>0.31099</td>\n",
       "      <td>0.655697</td>\n",
       "      <td>0.0333129</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>गेम कई बार मुश्किल मालूम देता है ।</td>\n",
       "      <td>negative</td>\n",
       "      <td>negative</td>\n",
       "      <td>0.820817</td>\n",
       "      <td>0.118118</td>\n",
       "      <td>0.061065</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>मल्टीप्लेयर में छोटी स्टोरीलाइन है ।</td>\n",
       "      <td>negative</td>\n",
       "      <td>neutral</td>\n",
       "      <td>0.0787148</td>\n",
       "      <td>0.657412</td>\n",
       "      <td>0.263873</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>हाई - एंड एचपी नोटबुक्स की लुक्स हमेशा बेहतरीन...</td>\n",
       "      <td>positive</td>\n",
       "      <td>positive</td>\n",
       "      <td>6.82234e-05</td>\n",
       "      <td>0.000406989</td>\n",
       "      <td>0.999525</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>कैमरे बनाने वाली कंपनी निकोन अपनी 1 सीरीज कैमर...</td>\n",
       "      <td>positive</td>\n",
       "      <td>positive</td>\n",
       "      <td>0.000679931</td>\n",
       "      <td>0.0035804</td>\n",
       "      <td>0.99574</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                               query actual_label  \\\n",
       "0          मगर , इस तरफ कोई ध्यान नहीं दिया जा रहा ।      neutral   \n",
       "1                 गेम कई बार मुश्किल मालूम देता है ।     negative   \n",
       "2               मल्टीप्लेयर में छोटी स्टोरीलाइन है ।     negative   \n",
       "3  हाई - एंड एचपी नोटबुक्स की लुक्स हमेशा बेहतरीन...     positive   \n",
       "4  कैमरे बनाने वाली कंपनी निकोन अपनी 1 सीरीज कैमर...     positive   \n",
       "\n",
       "  predicted_label     negative      neutral   positive  \n",
       "0         neutral      0.31099     0.655697  0.0333129  \n",
       "1        negative     0.820817     0.118118   0.061065  \n",
       "2         neutral    0.0787148     0.657412   0.263873  \n",
       "3        positive  6.82234e-05  0.000406989   0.999525  \n",
       "4        positive  0.000679931    0.0035804    0.99574  "
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score, matthews_corrcoef\n",
    "df_dict = {'query': list(df_test[1]), 'actual_label': list(df_test[0]), 'predicted_label': ['']*df_test.shape[0]}\n",
    "all_nodes = list(set(df_train[0]))\n",
    "for node in all_nodes:\n",
    "    df_dict[node] = ['']*df_test.shape[0]\n",
    "    \n",
    "i2c = {}\n",
    "for key, value in learn.data.c2i.items():\n",
    "    i2c[value] = key\n",
    "    \n",
    "df_result = pd.DataFrame(df_dict)\n",
    "for index, row in df_result.iterrows():\n",
    "    pred = learn.predict(data_clas.test_ds[index])\n",
    "    for node in all_nodes:\n",
    "        row[node] = pred[2][learn.data.c2i[node]].item()\n",
    "    row['predicted_label'] = i2c[pred[0].data.item()]\n",
    "df_result.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7571701720841301"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(df_result['actual_label'], df_result['predicted_label'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5976115429660378"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matthews_corrcoef(df_result['actual_label'], df_result['predicted_label'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_result.to_csv('iitp_product_result.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "in",
   "language": "python",
   "name": "in"
  },
  "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}