{ "cells": [ { "cell_type": "code", "execution_count": 150, "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "import numpy as np\n", "import os" ] }, { "cell_type": "code", "execution_count": 153, "metadata": {}, "outputs": [], "source": [ "base_path = './large_dataset/'" ] }, { "cell_type": "code", "execution_count": 188, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['bangla_50000-60000_labeled_fixed.csv',\n", " 'bangla_40000-50000_labeled_fixed.csv',\n", " 'bangla_10000-20000_labeled.csv',\n", " 'bangla_100000-120000-labeled.csv',\n", " 'bangla_20000-30000_labeled.csv',\n", " 'bangla_1-10000-labeled-fixed.csv',\n", " 'bangla_60000-80000-labeled.csv',\n", " 'bangla_30000-40000_labeled_fixed.csv']" ] }, "execution_count": 188, "metadata": {}, "output_type": "execute_result" } ], "source": [ "os.listdir(base_path)" ] }, { "cell_type": "code", "execution_count": 189, "metadata": {}, "outputs": [], "source": [ "dfl = []\n", "for fn in os.listdir(base_path):\n", " dfl.append(pd.read_csv(os.path.join(base_path, fn),\n", " names=['sentence_id', 'sentence', 'ignore', 'label']))" ] }, { "cell_type": "code", "execution_count": 190, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
sentence_idsentenceignorelabel
0301610সময় নষ্ট না করে পেজটি1.0-1
1301611হে মানবজাতি তোমরা কি এখনও বুঝতে পারছনা আমি চা...1.0-1
2301612কয়েক জন মানুষের জন্য এত আবেগ।1.02
3301613আর মায়ানমারে শত শত মানুষ মেরে ফেলা হচ্ছে তার ক...1.0-1
4301614শালারা বিমানে উঠার আগে ড্যান্স পার্টি করে মান...1.0-1
\n", "
" ], "text/plain": [ " sentence_id sentence ignore \\\n", "0 301610 সময় নষ্ট না করে পেজটি 1.0 \n", "1 301611 হে মানবজাতি তোমরা কি এখনও বুঝতে পারছনা আমি চা... 1.0 \n", "2 301612 কয়েক জন মানুষের জন্য এত আবেগ। 1.0 \n", "3 301613 আর মায়ানমারে শত শত মানুষ মেরে ফেলা হচ্ছে তার ক... 1.0 \n", "4 301614 শালারা বিমানে উঠার আগে ড্যান্স পার্টি করে মান... 1.0 \n", "\n", " label \n", "0 -1 \n", "1 -1 \n", "2 2 \n", "3 -1 \n", "4 -1 " ] }, "execution_count": 190, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Merging the dataframes \n", "df = pd.concat(dfl).dropna()\n", "df.head()" ] }, { "cell_type": "code", "execution_count": 191, "metadata": {}, "outputs": [], "source": [ "# pandas drop columns using list of column names\n", "df = df.drop(['ignore'], axis=1)" ] }, { "cell_type": "code", "execution_count": 192, "metadata": {}, "outputs": [], "source": [ "indexNames = df[(df['label'] == 'ss') |\n", " (df['label'] == 's') |\n", " (df['label'] == '.')].index\n", " \n", "# Delete these row indexes from dataFrame\n", "df.drop(indexNames , inplace=True)" ] }, { "cell_type": "code", "execution_count": 274, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
sentence_idsentencelabel
9996291605যারা রোহিঙ্গাদের দেশে জায়গা দেওয়ার পক্ষে তাদে...-1
9997291606রোহিঙ্গাদের গণহত্যার বিরুদে পৃথিবীর বিভিন্ন দ...-1
9998291607এই পৃথিবীর সবছেয়ে অমানবিক অশিক্ষিত মুরখ টি দে...-1
9999291608তাদের ভাব দেখে মনে হচ্ছে ভারত এখন আমেরিকা। নি...-1
10000291609ভারতের কেও ভাত পাই কি পায় না সেটা তোকে দেখতে ...5
\n", "
" ], "text/plain": [ " sentence_id sentence label\n", "9996 291605 যারা রোহিঙ্গাদের দেশে জায়গা দেওয়ার পক্ষে তাদে... -1\n", "9997 291606 রোহিঙ্গাদের গণহত্যার বিরুদে পৃথিবীর বিভিন্ন দ... -1\n", "9998 291607 এই পৃথিবীর সবছেয়ে অমানবিক অশিক্ষিত মুরখ টি দে... -1\n", "9999 291608 তাদের ভাব দেখে মনে হচ্ছে ভারত এখন আমেরিকা। নি... -1\n", "10000 291609 ভারতের কেও ভাত পাই কি পায় না সেটা তোকে দেখতে ... 5" ] }, "execution_count": 274, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df.tail()" ] }, { "cell_type": "code", "execution_count": 275, "metadata": {}, "outputs": [], "source": [ "df['label'] = df['label'].astype(int)" ] }, { "cell_type": "code", "execution_count": 276, "metadata": {}, "outputs": [], "source": [ "label_map = {-9: 0,\n", " -2: 1,\n", " -1: 2,\n", " 0: 3,\n", " 1: 4,\n", " 2: 5,\n", " 5: 6,\n", " }" ] }, { "cell_type": "code", "execution_count": 277, "metadata": {}, "outputs": [], "source": [ "df['label_enc'] = df['label'].map(label_map)" ] }, { "cell_type": "code", "execution_count": 278, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-1 45833\n", " 2 20535\n", " 0 18950\n", " 1 12743\n", "-2 1214\n", " 5 701\n", "-9 2\n", "Name: label, dtype: int64" ] }, "execution_count": 278, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df['label'].value_counts()" ] }, { "cell_type": "code", "execution_count": 279, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2 45833\n", "5 20535\n", "3 18950\n", "4 12743\n", "1 1214\n", "6 701\n", "0 2\n", "Name: label_enc, dtype: int64" ] }, "execution_count": 279, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df['label_enc'].value_counts()" ] }, { "cell_type": "code", "execution_count": 280, "metadata": {}, "outputs": [], "source": [ "docs = df['sentence'].values\n", "y = df['label_enc'].values" ] }, { "cell_type": "code", "execution_count": 281, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array(['সময় নষ্ট না করে পেজটি ',\n", " ' হে মানবজাতি তোমরা কি এখনও বুঝতে পারছনা আমি চাইলে তোমাদের যে কোন মূহুর্তেই মৃত্যুর সাধ গ্রহন করতে হবে।সুতারং সেদিনের কথা স্বরন কর যেদিন তোমাদের কর্ম ছাড়া আর কিছুই কাজে আসবেনা। ',\n", " ' কয়েক জন মানুষের জন্য এত আবেগ। ', ...,\n", " ' এই পৃথিবীর সবছেয়ে অমানবিক অশিক্ষিত মুরখ টি দেশের জনগণ তা হল মায়ানমার এর বৌদ্ধ সম্প্রদায়। ',\n", " ' তাদের ভাব দেখে মনে হচ্ছে ভারত এখন আমেরিকা। নিজের দেশের লোক ভাত পায়না আবার বড় কথা ',\n", " ' ভারতের কেও ভাত পাই কি পায় না সেটা তোকে দেখতে হবে তবে হা কাংলাদেশি তর ভাত দরকার হলে বলিস '],\n", " dtype=object)" ] }, "execution_count": 281, "metadata": {}, "output_type": "execute_result" } ], "source": [ "docs" ] }, { "cell_type": "code", "execution_count": 282, "metadata": {}, "outputs": [], "source": [ "from sklearn.feature_extraction.text import TfidfVectorizer" ] }, { "cell_type": "code", "execution_count": 283, "metadata": {}, "outputs": [], "source": [ "vect = TfidfVectorizer(decode_error='ignore',\n", " max_features=20000)\n", "\n", "X = vect.fit_transform(docs)" ] }, { "cell_type": "code", "execution_count": 284, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "<99978x9685 sparse matrix of type ''\n", "\twith 805960 stored elements in Compressed Sparse Row format>" ] }, "execution_count": 284, "metadata": {}, "output_type": "execute_result" } ], "source": [ "X" ] }, { "cell_type": "code", "execution_count": 285, "metadata": {}, "outputs": [], "source": [ "from sklearn.model_selection import train_test_split\n", "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state=1)" ] }, { "cell_type": "code", "execution_count": 286, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "LogisticRegression(C=10, class_weight=None, dual=False, fit_intercept=True,\n", " intercept_scaling=1, max_iter=100, multi_class='warn',\n", " n_jobs=None, penalty='l2', random_state=None, solver='warn',\n", " tol=0.0001, verbose=0, warm_start=False)" ] }, "execution_count": 286, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# from sklearn.ensemble import RandomForestClassifier\n", "from sklearn.linear_model import LogisticRegression\n", "\n", "model = LogisticRegression(penalty='l2', C=10)\n", "model.fit(X_train, y_train)" ] }, { "cell_type": "code", "execution_count": 287, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.5933213305898491" ] }, "execution_count": 287, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model.score(X_train, y_train)" ] }, { "cell_type": "code", "execution_count": 288, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.5274721610988864" ] }, "execution_count": 288, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model.score(X_test, y_test)" ] }, { "cell_type": "code", "execution_count": 289, "metadata": {}, "outputs": [], "source": [ "from sklearn.metrics import confusion_matrix" ] }, { "cell_type": "code", "execution_count": 290, "metadata": {}, "outputs": [], "source": [ "y_pred = model.predict(X_test)" ] }, { "cell_type": "code", "execution_count": 291, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 61, 243, 24, 2, 31, 0],\n", " [ 30, 11058, 1032, 598, 1065, 2],\n", " [ 5, 3171, 1284, 455, 644, 0],\n", " [ 5, 1780, 426, 1402, 259, 0],\n", " [ 5, 3403, 600, 192, 2015, 3],\n", " [ 1, 157, 8, 17, 15, 1]])" ] }, "execution_count": 291, "metadata": {}, "output_type": "execute_result" } ], "source": [ "confusion_matrix(y_test, y_pred)" ] }, { "cell_type": "code", "execution_count": 292, "metadata": {}, "outputs": [], "source": [ "test_sent = ' ভালবাসার গল্প পড়তে এই পেইজে লাইক দেন বন্ধুত্ব '" ] }, { "cell_type": "code", "execution_count": 293, "metadata": {}, "outputs": [], "source": [ "test_sent_features = vect.transform([test_sent])" ] }, { "cell_type": "code", "execution_count": 294, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([4])" ] }, "execution_count": 294, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model.predict(test_sent_features)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Learning curve" ] }, { "cell_type": "code", "execution_count": 295, "metadata": {}, "outputs": [], "source": [ "from sklearn.model_selection import learning_curve" ] }, { "cell_type": "code", "execution_count": 296, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/ubuntu/miniconda3/lib/python3.7/site-packages/sklearn/model_selection/_split.py:652: Warning: The least populated class in y has only 2 members, which is too few. The minimum number of members in any class cannot be less than n_splits=3.\n", " % (min_groups, self.n_splits)), Warning)\n", "/home/ubuntu/miniconda3/lib/python3.7/site-packages/sklearn/linear_model/logistic.py:433: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n", " FutureWarning)\n", "/home/ubuntu/miniconda3/lib/python3.7/site-packages/sklearn/linear_model/logistic.py:460: FutureWarning: Default multi_class will be changed to 'auto' in 0.22. Specify the multi_class option to silence this warning.\n", " \"this warning.\", FutureWarning)\n" ] } ], "source": [ "tsz = np.linspace(0.1, 1, 10)\n", "train_sizes, train_scores, test_scores = learning_curve(model, X, y, train_sizes=tsz, cv=3)" ] }, { "cell_type": "code", "execution_count": 297, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEICAYAAACktLTqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3XmcFNXZ9//PNRvrADrgxh4hysjOCPrgzxUVMKLGOwZF4z6PKEa9zRNRTESULJrnjjFyJyEuiYqij0ZDXEJu3GJiFFAQBIOisoygwiCLss7M9fvjVA89Mz0zPUzP1nzfr1e/uurU6apT1TNXnzp16pS5OyIikl4ymroAIiKSegruIiJpSMFdRCQNKbiLiKQhBXcRkTSk4C4ikoYU3PczZvaimV3c1OVIR2Y2wcz+to+fXWZmJ6a4SM2e/h4bjqmfe+Mws1XAFe4+r6nL0lDMrAMwDfg2cCDwGfAccKe7b2zKslXWlN+Hmf0BKHL3W+u5nl7AJ8DXUdJG4Lfu/rP6rFfSg2ruacTMsppw2znAS8BRwGigA/C/gGJg+D6sr8n2pQXq5O7tgf8AfmRmp6Z6A/o+Wh4F92bAzL5lZovNbLOZvWFmA+OWTTazj8xsm5ktN7Nz4pZdYmb/NLNfmtkmYGqU9g8z+4WZfWlmn5jZmLjPvGpmV8R9vqa8vc3s79G255nZDDN7tJrd+B7QAzjH3Ze7e5m7f+Hud7j7C9H63Mz6xK3/D2Z2ZzR9opkVmdlNZvYZ8JCZvW9m34rLn2VmG81saDR/THS8NpvZu6lq1jCzK81spZltMrM5ZnZY3LLTzGyFmW0xs/82s9cqH89o2qLv5Yso7xIz629mhcAE4Idm9pWZ/SXKv8rMRkXTmWZ2S9z3/raZda+t3O6+EFgGDI4r72Fm9rSZbYi+3+/HLWtjZn+Mvvv3zeyHZlYUt3xV9H0sAb6Ojn9N6xtuZgvNbKuZfW5m/xWltzazR82sOPquFpjZwdGy+L/HDDO71cxWR8ftYTPrGC3rFf39XGxma6K/gyl1/nL3IwruTSwKVA8C/xvIA34HzDGzVlGWj4D/D+gI3A48amaHxq1iBPAxcBAwPS5tBdAZuAt4wMysmiLUlPcxYH5UrqnARTXsyijgr+7+Ve17Xa1DCM05PYFC4HHg/LjlpwMb3f0dM+sKPA/cGX3mB8DTZtYFyn8Un6trAczsZOCnwHnAocBqYHa0rDPwFHAz4ZisIJydJHIacDzwTaAT8F2g2N1nArOAu9y9vbufmeCz/xnt91jCGdBlwPYkyn4M0B9YGc1nAH8B3gW6AqcA15vZ6dFHbgN6Ad8ATgUuTLDa84Ezon0oq2V9vwJ+5e4dgMOBJ6P0iwl/v90Jx+0qYEeCbV0SvU6KytQeuK9SnuOAI6Jt/9jM+tV0TPZr7q5XI7yAVcCoBOm/Ae6olLYCOKGa9SwGzoqmLwHWVFp+CbAybr4t4MAh0fyrhLbmGvMSauElQNu45Y8Cj1ZTrv8BflbLMXCgT9z8Hwjt8QAnAruB1nHL+wDbYmUgBMUfR9M3AY9UWv9c4OJ6fh8PEAJvbL49sIcQBL8H/CtumQFrKx3Pf0TTJwMfAMcAGZW2Ub7ficoTff9nJbEPvaJjupkQLB34BXuvpY1I8PdxM/BQNP0xcHrcsisI1wLiy3RZ3Hxt6/s7oQLSuVKey4A3gIEJ9iH+7/El4Oq4ZUdExz4rbl+7xS2fD4xPxf9nOr5Uc296PYEbo9PVzWa2mVDDOQzAzL5ne5tsNhNqZp3jPr82wTo/i024e6zG176a7VeX9zBgU1xadduKKSbUdOtjg7vvjCvPSuB94EwzawuMI5xNQDhu36l03I5LQRkOI9TWY2X4irBvXaNla+OWOVBUeQXRspcJtc4ZwOdmNtPCBedkdCecsSWrM+E7+wHhRzI7Su8JHFbpGN0CHBwtr7A/JP5+49NqW9/lhDOVf0dNL7EmtUcIP7yzzWydmd1lZtlUVeHYR9NZceuHuL9XwtlMdX/X+z0F96a3Fpju7p3iXm3d/XEz6wn8HpgE5Ll7J+A9Qo0xpqG6O60HDoyCakxN7b7zgNPNrF0NebYTzg5iDqm0PNG+xJpmzgKWRwEfwnF7pNJxa+f17ymyjhDEAIj2Jw/4lHBMusUts/j5ytz9XncfRrjI/E3g/8QW1VKGtYRmjaS5e6m7/19gJ3B13Ho+qXSMct19bLS8wv6Q+PuNL2uN63P3D939fEIT4c+Bp8ysnbvvcffb3T2f0Iz1LcJZUGUVjj17zx4/r8OhkIiCe+PKji4uxV5ZhOB9lZmNiC7CtTOzM8wsF2hH+OfaAGBmlxJq7g3O3VcDCwkXaXPM7FggUftwzCOEf/6nzezI6OJYXnRhMBZMFgMXRBcMRwMnJFGU2YT264nsrbVDaCI608xOj9bX2sJF2WqDbQKJvo/HgEvNbHB03eMnwFvuvorQxj/AzM6O8l5D1R8oAMzs6Og7zSZ0VdwJlEaLPye0KVfnfuAOM+sb/U0MNLO8JPfpZ4SLta0JzRZbLVwUbRMdp/5mdnSU90ngZjM7ILqGMamWdde4PjO70My6uHsZoakIoNTMTjKzAWaWCWwlNLWUJlj/48ANFi7ktycc+yfcvSTJfZc4Cu6N6wVC22jsNdVDD4crCafwXxIuhl0C4O7Lgf8L/IsQEAYA/2zE8k4AjiU0S9wJPAHsSpTR3XcRLqr+m9D+vpUQDDoDb0XZriP8QGyO1v1sbQVw9/WE/f9f0fZj6WsJtflbCD9+awk14wyA6EflxVpWn+j7eAn4EfA0oWZ7ODA+2uZG4DuEC8/FQD7hBzDRMelA+OH+ktC8UExoD4fQrp8fNW0kOgb/RQi8fyMcxweANrXsS8zz0TavdPdSwvEeTOgPv5Hww9ExyjuN0Kz0CeHM66lq9gUIZwe1rG80sMzMviJcXB0fNbMdEq17K6GZ7TXCj3NlDxIqCX+P1r8TuDbJ/ZZKdBOTJM3MngD+7e63NXVZmoOoN0oRMMHdX2nq8tSXmU0kBORkzqikmVPNXaoVNS0cHjWxjCbUlGutbaezqBmoU9Rkcwvh+sebTVysfWJmh5rZyOj7PQK4EXimqcslqVFrcDezBy3cUPBeNcvNzO61cNPHEotuMJG0cAihq9pXwL3ARHdf1KQlanrHEnqybCQ0UZzt7on6bLcEOYT7KrYBLwN/Bv67SUskKVNrs4yZHU/4537Y3atczIsull1LuOFiBOEmhhENUFYREUlSrTV3d/87sKmGLGcRAr+7+5tAJ6t4B6WIiDSyVAwG1JWKNzoURWnrK2e0MK5GIUC7du2GHXnkkSnYvIjI/uPtt9/e6O5dasuXiuCeaMyShG09HsbVmAlQUFDgCxcuTMHmRUT2H2a2uvZcqektU0TFO9u6Ee40ExGRJpKK4D4H+F7Ua+YYYEt044mIiDSRWptlzOxxwmBEnS2M9Xwb0cBE7v5bwl1+Ywl3Vm4HLm2owoqISHJqDe7RQEA1LXfCGBsikib27NlDUVERO3furD2zNIjWrVvTrVs3srMTDaBZOz06S0SqKCoqIjc3l169emHVPudFGoq7U1xcTFFREb17996ndWj4ARGpYufOneTl5SmwNxEzIy8vr15nTgruIpKQAnvTqu/xV3AXEUlDCu4i0uwUFxczePBgBg8ezCGHHELXrl3L53fv3p3UOi699FJWrFiR9DbXr1/P2LFjGTRoEPn5+YwbN25fi98s6IKqiNTfrFkwZQqsWQM9esD06TBhwj6vLi8vj8WLFwMwdepU2rdvzw9+8IMKecofBJ2RuI760EMP1Wmbt956K2eccQbXXBM6/y1ZsmQfSl5RSUkJWVlNE2ZVcxeR+pk1CwoLYfVqcA/vhYUhPcVWrlxJ//79ueqqqxg6dCjr16+nsLCQgoICjjrqKKZNm1ae97jjjmPx4sWUlJTQqVMnJk+ezKBBgzj22GP54osvqqx7/fr1dOu29ymNAwcOLJ/+yU9+woABAxg0aBBTpkwB4J133mHEiBEMHDiQc889ly1btpRvd8qUKRx//PHcd999fP7553z729+moKCA4cOH8+abYfj/l19+mUGDBjF48GCGDh3K119/ndqDFfv1a+zXsGHDXESap+XLl++due469xNOqP7VqpV7COsVX61aVf+Z665Luiy33Xab33333e7u/uGHH7qZ+fz588uXFxcXu7v7nj17/LjjjvNly5a5u/vIkSN90aJFvmfPHgf8hRdecHf3G264wX/6059W2c7zzz/vHTt29JNOOsmnT5/u69atc3f3OXPm+HHHHefbt2+vsL1+/fr566+/7u7uN998s994443l2500aVL5es877zz/17/+5e7un3zyiR911FHu7j569Gh/88033d1927ZtXlJSUqVMFb6HCLDQk4ixapYRkfrZVc1jV6tLr6fDDz+co48+unz+8ccf54EHHqCkpIR169axfPly8vPzK3ymTZs2jBkzBoBhw4bx+uuvV1nv2LFj+eijj/jrX//Kiy++yJAhQ1i2bBnz5s3jsssuo02b8BjbAw88kOLiYnbu3Mlxxx0HwMUXX8xFF11Uvq7x48eXT8+bN69C2/+XX37Jjh07GDlyJNdffz0XXHAB5557Lu3bt0/B0dlLwV1EanbPPTUv79UrNMVU1rMnvPpqyovTrl278ukPP/yQX/3qV8yfP59OnTpx4YUXJuwbnpOTUz6dmZlJSUlJwnXn5eUxYcIEJkyYwOjRo/nHP/6Bu1fplui1POQovozuzvz58yuUAUIb/7hx43j++ec5+uijefXVV+nbt2+N660LtbmLSP1Mnw5t21ZMa9s2pDewrVu3kpubS4cOHVi/fj1z587d53W99NJL7Nixo3y9n3zyCT169OC0007jgQceKF+2adMmOnfuTJs2bXjjjTcAeOSRRzjhhMTPFR81ahQzZswon49dKP7oo48YOHAgN998M0OGDKlTz55kqOYuIvUT6xWTwt4yyRo6dCj5+fn079+fb3zjG4wcOXKf17VgwQImTZpEdnY2ZWVlTJw4kSFDhjBkyBDeffddCgoKyM7O5swzz+SOO+7gkUceYeLEiezYsYM+ffpU2ztnxowZTJw4kYceeoiSkhJOOukkZsyYwS9+8Qtef/11MjIyGDhwIKeddto+lz2RWp+h2lD0sA6R5uv999+nX79+TV2M/V6i78HM3nb3gto+q2YZEZE0pOAuIpKGkgruZjbazFaY2Uozm5xgeU8ze8nMlpjZq2bWLdF6RESkcdQa3M0sE5gBjAHygfPNLL9Stl8AD7v7QGAa8NNUF1RERJKXTM19OLDS3T92993AbOCsSnnygZei6VcSLBcRkUaUTHDvCqyNmy+K0uK9C5wbTZ8D5JpZXv2LJyIi+yKZ4J5oxPjK/Sd/AJxgZouAE4BPgSq3gJlZoZktNLOFGzZsqHNhRWT/kIohfwEefPBBPvvss4TL/vnPfzJixAgGDx5Mv379uOOOO1JV/GYhmZuYioDucfPdgHXxGdx9HfBtADNrD5zr7lsqr8jdZwIzIfRz38cyi0gzM2vpLKa8NIU1W9bQo2MPpp8ynQkDGnbI32Q8+OCDDB06lEMOOaTKsosvvphnn32W/v37U1pampI7REtLS8nMzKz3elIhmZr7AqCvmfU2sxxgPDAnPoOZdTaz2LpuBh5MbTFFpLmatXQWhX8pZPWW1TjO6i2rKfxLIbOWpn7IX4A//vGPDB8+nMGDB3P11VdTVlZGSUkJF110EQMGDKB///7ce++9PPHEEyxevJjvfve7CWv8GzZsKA/6mZmZ5YONbdu2jYsvvpgBAwYwcOBAnn32WQAeffTR8vXfcsstAOXDCd96660MHz6c+fPns2DBAk444QSGDRvGmDFj+PzzzwH45S9/SX5+PoMGDeLCCy9skGMTr9aau7uXmNkkYC6QCTzo7svMbBph6Mk5wInAT83Mgb8D1zRgmUWkEV3/1+tZ/Nniape/WfQmu0orjgC5fc92Lv/z5fz+7d8n/MzgQwZzz+haBiRL4L333uOZZ57hjTfeICsri8LCQmbPns3hhx/Oxo0bWbp0KQCbN2+mU6dO/PrXv+a+++5j8ODBVffr+uvp27cvJ510EmPGjOF73/serVq1YurUqXTp0oWlS5fi7mzevJmioiJuvfVWFi5cSMeOHRk1ahTPPfcco0ePZsuWLQwdOpQ777yTXbt2cdJJJzFnzhw6d+7MrFmz+NGPfsTMmTO56667WL16NTk5OWzevLnO+15XSY0t4+4vAC9USvtx3PRTwFOpLZqItASVA3tt6fUxb948FixYQEFBuPt+x44ddO/endNPP50VK1Zw3XXXMXbs2KTGabn99tu56KKL+Nvf/sbDDz/ME088wbx585g3b155bd3MOOCAA3j55Zc5+eST6dy5MwAXXHABf//73xk9ejQ5OTmcc845QBguYNmyZYwaNQoIzTSxB4AcddRRXHjhhZx11lmcffbZKT82lWngMBGpUW017F739GL1lqpD/vbs2JNXL3k1pWVxdy677LKEFz+XLFnCiy++yL333svTTz/NzJkza11fnz596NOnD1deeSV5eXls2bKlzkP8tmnTpjy/uzNw4MCE48XPnTuX1157jT//+c/ceeedvPfeew3aPq/hB0SkXqafMp222RWH/G2b3Zbpp6R+yN9Ro0bx5JNPsnHjRiD0qlmzZg0bNmzA3fnOd77D7bffzjvvvANAbm4u27ZtS7iu559/vjxof/DBB7Rq1Yrc3FxOO+007rvvPiAE6y+//JJjjjmGV155heLiYkpKSpg9e3bCIX7z8/P59NNPmT9/PgC7d+9m2bJllJaWUlRUxMknn8zdd9/Nhg0b2L59e8qPTzzV3EWkXmK9YlLZW6Y6AwYM4LbbbmPUqFGUlZWRnZ3Nb3/7WzIzM7n88svLa90///nPAbj00ku54ooraNOmTZUHZvzhD3/ghhtuoG3btmRnZ/PYY4+RkZHBbbfdxtVXX03//v3JzMzkjjvuYNy4cUybNo0TTzwRd+fMM8/kjDPOqPLQj1atWvHUU0/x/e9/n23btlFSUsKNN95Inz59uOCCC9i2bRtlZWXcdNNN5Obmpvz4xNOQvyJShYb8bR405K+IiFSg4C4ikoYU3EUkoaZqspWgvsdfwV1EqmjdujXFxcUK8E3E3SkuLqZ169b7vA71lhGRKrp160ZRUREa4K/ptG7duvwGqH2h4C4iVWRnZ9O7d++mLobUg5plRETSkIK7iEgaUnAXEUlDCu4iImlIwV1EJA0puIuIpKGkgruZjTazFWa20swmJ1jew8xeMbNFZrbEzMamvqgiIpKsWoO7mWUCM4AxQD5wvpnlV8p2K/Ckuw8hPGP1v1NdUBERSV4yNffhwEp3/9jddwOzgbMq5XGgQzTdEViXuiKKiEhdJRPcuwJr4+aLorR4U4ELzayI8KzVaxOtyMwKzWyhmS3Ubc0iIg0nmeBuCdIqjyZ0PvAHd+8GjAUeMbMq63b3me5e4O4FXbp0qXtpZ82CXr0gIyO8z5pV93WIiOwHkhlbpgjoHjffjarNLpcDowHc/V9m1hroDHyRikICIZAXFkLsuYOrV4d5gAmpf5yXiEhLlkzNfQHQ18x6m1kO4YLpnEp51gCnAJhZP6A1kNp2lylT9gb2mO3bQ7qIiFRQa3B39xJgEjAXeJ/QK2aZmU0zs3FRthuBK83sXeBx4BJP9UDQa9YkTl+9Gr5I3QmCiEg6aDkPyO7VKwTyRHJz4aab4PrroV27lJRPRKQ5Sr8HZE+fDm3bVkxr2xbuvhtGjYJbb4W+feH++6GkpGnKKCLSTLSc4D5hAsycCT17gll4nzkTfvAD+NOf4B//CLX7K6+EQYPgL38BPSJMRPZTLSe4Qwjwq1ZBWVl4j+8lM3Ik/POfIdCXlMC4cXDiifDWW01UWBGRptOygnttzOCcc+C99+A3v4F//xuOOQbOOw9Wrmzq0omINJr0Cu4x2dlw1VUhoN92G7zwAvTrB9deq541IrJfSM/gHpObC1OnhiB/xRWhNt+nT7g4+/XXTV06EZEGk97BPeaQQ0JgX7ZMPWtEZL+wfwT3mCOOUM8aEdkv7F/BPUY9a0Qkze2fwR2q9qxZsUI9a0Qkbey/wT0mvmfN1KnqWSMiaUHBPaZ9+9BtUj1rRCQNKLhXpp41IpIGFNyrE9+zpnfvij1r9EQoEWnmknkS0/5t5MgQ4J99FiZPDj1rMjLC+DagJ0KJSLOUVM3dzEab2QozW2lmkxMs/6WZLY5eH5jZ5tQXtQnF96w58MC9gT1m+/YQ+EVEmolaa+5mlgnMAE4lPE91gZnNcfflsTzufkNc/muBIQ1Q1qaXnQ1ffpl4WVFRuAA7YgQMHx5egwdDmzaNW0YREZJrlhkOrHT3jwHMbDZwFrC8mvznA7elpnjNUI8eiZ8I1alTaJN/7TV47LGQlpUV0mLBfvhwOPLI0KwjItKAkgnuXYG1cfNFwIhEGc2sJ9AbeLma5YVAIUCPHj3qVNBmY/r00MYe/7Dutm3hvvv2trl/+iksWBDueJ0/Hx59NPTAgTCY2dFH7w32I0bAYYc1/n6ISFpLJrhbgrTqBmIZDzzl7qWJFrr7TGAmhGeoJlXC5iYWwKdMCQ/t7tEjBPz4i6ldu4bX2WeH+bKycAdsLNjPnw+/+MXerpVdu1YM9sOGQYcOjbtfIpJWkgnuRUD3uPluwLpq8o4HrqlvoZq9CRPq1jMmIyPc9dqvH1xySUjbuRMWLdob7N96C555JiwzC3nj2+8HDAht/vFmzar5R0ZE9lvmtYyGaGZZwAfAKcCnwALgAndfVinfEcBcoLfXtlJCzX3hwoX7Wu70VFwcmnNiwX7+fNi4MSxr3RqGDt0b7D/7LNxgVbl5aOZMBXiRNGZmb7t7Qa35kojDmNlY4B4gE3jQ3aeb2TRgobvPifJMBVq7e1J9AhXck+AenhUb35zz9tuh1l+drl1h7dpQ+xeRtJPS4N4QFNz30Z49ob/90KHV52nXLnTL7Ns3vOKnDz5YgV+kBUs2uOsO1ZYmOxuGDIGePRN3yTzgALjoojAA2rvvhjtr48fEad++YrCPD/4HHaTAL5ImFNxbquq6ZP761xXb3PfsCT8CK1fChx+G18qV4WLun/4EpXEdm3Jzq9b0Y/NdulQf+HVhV6TZUbNMS1bfoLpnT2jTjw/8seC/alXFwN+hQ+JmnnffhRtv1IVdkUaiNnepn927aw78lcfXqay6O3lFpF7U5i71k5MD3/xmeFW2ezd88kkI9N/6VuLPr1kTnks7YsTe/vrdujVokUVkLwV3qbucnDDe/RFHVH9hNzcXduyAe+4JPwYQhlmIBfoRI6CgIOQTkZRTcJf6qe7C7m9+E9rcd+2CxYv33phV+U7c/Py9tfsRI+Coo8KAayJSL2pzl/qr64Xd2J24sZuz3norpEH4YRg2rGJzTvfu6qIpEtEFVWk53OHjjysG+0WLQq0fwnNt45tzjj468cBq6pIp+wEFd2nZdu8O3Szjm3M++CAsiw2sFgv2I0bA0qUwcaK6ZEraU3CX9PPll3ubc2Kv2MBqZuEMoLKDD4aXXgqPRzzwQGjVqnHLLJJiCu6S/uIHVjv//OQ+064d5OXtDfa1TeflhSEdcnKSW7+ahqSBqZ+7pD8z6N07vCZPTtwl86CDwpAMxcWwadPe99j00qV700oTPmMmaN++9h+CpUthxoy91wpWrw49iaDxA7x+ZPZ7qrlLepg1K3GXzGTb3N1h27aqwT/RD0LltNru1jWDQw8Nffpzc8MPRaL3ZJa1bw+ZmQ17LFJJPzIpp5q77F+SefxhTcxCD5wOHcKZQLLKymDr1hDk+/RJ3O7vDqNHhx+Pr74K72vXVpyPD8S1adOm5h+Dp56qur7t2+G668J0dvbeV1ZW4ulk52vqolr5R0ZnMo0q2Yd1jAZ+RXhYx/3u/rMEec4DphKer/quu19Q0zpVc5e006tX4qahnj3DtYGalJbC119XDPiV32taFp/n008bYu8Sy8ysPvB/+mnF4aZjWreGU08N1zFatar5PRV5nn4arrqqeZzJpEDKau5mlgnMAE4lPE91gZnNcfflcXn6AjcDI939SzM7aN+LLtJCVXe37vTptX82M3PvmUN9Vfcjc9hh8MorYTTQ2KukJPF0bfPJ5H344cTl27kznLns3h2uT8S/x6Zruv6RCtu3w+WXwyOP7D0LSvbVoUM4Q8rIqPt2G/EMIplmmeHASnf/GMDMZgNnAcvj8lwJzHD3LwHc/YtUF1Sk2atv01CqVPcjc9ddiQeCayivvVb9mcyiRTV/trS0YrBP9ANQ03v89E03Jd7Grl2he+2aNXvPerZtq/0aSky7dnX7UViyBH7/+0a74J7MA7L/Axjt7ldE8xcBI9x9UlyeZwkP0R5JaLqZ6u5/TbCuQqAQoEePHsNWa0hYkYbRHNqYm8uF3bo0l7mHAe+2bq0Y8Pf1lcy1lGSa7eKk8oJqoismlX8RsoC+wIlAN+B1M+vv7psrfMh9JjATQpt7EtsWkX0xYULTtyc39zOZRM1lZmFZ27Zh2Iv6Ki0N10O2bg1BPFFles2a+m8ngWQajYqA7nHz3YB1CfL82d33uPsnwApCsBeR/dmECXsf7rJqVdP84EyYEM4WevYMwbtnz8Y7e8jMhI4dw+B3PXokzlNdej0lE9wXAH3NrLeZ5QDjgTmV8jwLnARgZp2BbwIfp7KgIiL7rDn8yEyfHs4I4iV7wX0f1Brc3b0EmATMBd4HnnT3ZWY2zczGRdnmAsVmthx4Bfg/7l7cICUWEWmJGvkMQneoioi0IMleUN2HjpoiItLcKbiLiKQhBXcRkTSk4C4ikoYU3EVE0pCCu4hIGlJwFxFJQwruIiJpSMFdRCQNKbiLiKQhBXcRkTSk4C4ikoYU3EUk7c1aOote9/Qi4/YMet3Ti1lLZ6V9ORTcRdLQ/hjMaipD4V8KWb1lNY6zestqCv9S2OhlaexyJPOYPRFJ0qyls5jy0hTWbFlDj449mH7KdCYMaNwHQ8SCyPY94bFysSACNEpZ3J3oKqm6AAAPzklEQVSSshIeXfIo17xwDTtKdpSX48o5V7Lh6w2MO2IcpWWllHkZpV5aYbrMy1K6bPJLk8uPRcz2Pdu59oVr2bR9E2ZVnyRqCZ4uWt98t7x8S8JyTHlpSoN8L0mN525mo4FfER5+fb+7/6zS8kuAu4FPo6T73P3+mtap8dzTR3MIaE1Vjlgg21W6i1lLZnHD3BvKgxlA66zW/PiEHzOmzxjKvKxRXjfNu4lNOzZVKWvHVh35/ojvs6d0D3vK9lR9T5QWve8u3V395yq9l5SVNOgxTzeGUXZbWfL5kxzPvdbgbmaZwAfAqYRnpS4Aznf35XF5LgEK3H1SsgVUcK+/5hBUK9cSAdpmt2XmmTP3uSyxGlhJWQmlHr2XlVY7XVJWwpwP5jDttWnsLNlZvp5Wma2YWDCREd1GsLNkJ7tKdrGrdFf5e7VpcfO15i3ZhVd5Xnzzlp2RTXZmdp3eczJzqs9Tzed+9MqPqi3DH8/+IxmWQaZlhveMzArTqVw24v4RfLrt0ypl6NahG4v+96Iq6YliYqLvuK75jv790QnL0bNjT1ZdvyrhcUoklcH9WGCqu58ezd8cFfincXkuQcG9UVUbVL81k/OOOo/dpbvZVborvJfsSu18XPpfV/61Qk01JjsjmyM6H1EhSFc3XTlgNxbDaJ3VmlZZrWiV2ar8vda0KL11VusKeX4474fVbudP3/0TGZbRKK9j7j8mYRDp0bEHq65blbDZoCH0uqcXq7esrpJe12BWXw1RAWnKciQb3JNpc+8KrI2bLwJGJMh3rpkdT6jl3+DuaytnMLNCoBCgRwM98bsxNHSNeXfpboq3F7Nx+0aKd4T3+FfxjmKeWv5UhVoqhPa7C5+5kAufuTBlZQHKa26tslqF9yig5WTmJAzsAHvK9tD3wL5kZWSV16CyMrLItEwyMxJPV8lbabqmz49/anzCWpNhLLt6WcKAnZWRldJAN2PBjITBrEfHHpx95Nkp205tfn7qzxMGkZ+c8pNGC+wA00+ZnrAc009pmAdCVyf2v9nUZ7mNXY5kau7fAU539yui+YuA4e5+bVyePOArd99lZlcB57n7yTWtt6XW3Ov667undA+bdmxKGKCrS9u6a2u128/NyaVz2858svmTavPccdId5UG4clCu63x2ZjYZVn2nquZSO2sO5WguNcRYWZo6mDWncqSTRm2WqZQ/E9jk7h1rWm9LDe7VBZHcnFzO6XdOeY079tqya0u162qf0568Nnl0btu5withWts88trk0SqrVY3l0Clv05dDwUwaUiqbZRYAfc2sN6E3zHjggkobO9Td10ez44D361jeZqu0rJT3N77P2+veZuG6hQkDKsC23dt4ddWr5cH48AMPrzFw57XNo3VW630ul055m285FMylOUi2K+RY4B5CV8gH3X26mU0DFrr7HDP7KSGolwCbgInu/u+a1tkca+6lZaV8UPwBC9ctZOG6hby9/m0WfbaoPIC2y25X3u2tssauMYNqiSL7o5Q1yzSUpg7uZV7Gh8UfVgjk76x/h6/3fA2EWvCQQ4ZQcFgBww4dRsFhBXwz75vMXja7WZz+i8j+KZXNMi1emZfx0aaPyoP4wnULeWf9O2zbvQ2ANlltGHzIYC4bcll5ID+y85FkZmRWWVdzOf0XEalJi6q5J9MM4e58/OXHFQL52+vfLu+B0jqrNYMOHlShRt6vSz+yMvaL3zkRaeHSruZe3XgZG77eQNfcrhUC+eadmwHIycxh0MGDmDBgQnkgz++ST3ZmdlPuiohIg2sxNffquv7FZGdkM/DggRVq5EcddBQ5mTmpKK6ISLOQdjX3NVvWVLts4ZUL6X9Q//I+4CIi+7sWM557j46Jhyvo2bEnww4bpsAuIhKnxQT36adMp2122wppTXHTjohIS9BigvuEAROYeeZMenbsiWH07NhTfctFRKrRYi6oiohI8hdUW0zNXUREkqfgLiKShhTcRUTSkIK7iEgaUnAXEUlDCu4iImkoqeBuZqPNbIWZrTSzyTXk+w8zczOrtZuOiIg0nFqDe/RM1BnAGCAfON/M8hPkywW+D7yV6kKKiEjdJFNzHw6sdPeP3X03MBs4K0G+O4C7gJ0pLJ+IiOyDZIJ7V2Bt3HxRlFbOzIYA3d39uZpWZGaFZrbQzBZu2LChzoUVEZHkJBPcLUFa+ZgFZpYB/BK4sbYVuftMdy9w94IuXbokX0oREamTZIJ7EdA9br4bsC5uPhfoD7xqZquAY4A5uqgqItJ0kgnuC4C+ZtbbzHKA8cCc2EJ33+Lund29l7v3At4Exrm7RgUTEWkitQZ3dy8BJgFzgfeBJ919mZlNM7NxDV1AERGpu6Qes+fuLwAvVEr7cTV5T6x/sUREpD50h6qISBpScBcRSUMK7iIiaUjBXUQkDSm4i4ikIQV3EZE0pOAuIpKGFNxFRNKQgruISBpScBcRSUMK7iIiaUjBXUQkDSm4i4ikIQV3EZE0pOAuIpKGkgruZjbazFaY2Uozm5xg+VVmttTMFpvZP8wsP/VFFRGRZNUa3M0sE5gBjAHygfMTBO/H3H2Auw8G7gL+K+UlFRGRpCVTcx8OrHT3j919NzAbOCs+g7tvjZttB3jqiigiInWVzGP2ugJr4+aLgBGVM5nZNcB/AjnAyYlWZGaFQCFAjx496lpWERFJUjI1d0uQVqVm7u4z3P1w4Cbg1kQrcveZ7l7g7gVdunSpW0lFRCRpyQT3IqB73Hw3YF0N+WcDZ9enUCIiUj/JBPcFQF8z621mOcB4YE58BjPrGzd7BvBh6oooIiJ1VWubu7uXmNkkYC6QCTzo7svMbBqw0N3nAJPMbBSwB/gSuLghCy0iIjVL5oIq7v4C8EKltB/HTV+X4nKJiEg96A5VEZE0pOAuIpKGFNxFRNKQgruISBpScBcRSUMK7iIiaUjBXUQkDSm4i4ikIQV3EZE0pOAuIpKGFNxFRNKQgruISBpScBcRSUMK7iIiaUjBXUQkDSUV3M1stJmtMLOVZjY5wfL/NLPlZrbEzF4ys56pL6qIiCSr1uBuZpnADGAMkA+cb2b5lbItAgrcfSDwFHBXqgsqIiLJS6bmPhxY6e4fu/tuwgOwz4rP4O6vuPv2aPZNwkO0RUSkiSQT3LsCa+Pmi6K06lwOvFifQomISP0k8wxVS5DmCTOaXQgUACdUs7wQKATo0aNHkkUUEZG6SqbmXgR0j5vvBqyrnMnMRgFTgHHuvivRitx9prsXuHtBly5d9qW8IiKShGSC+wKgr5n1NrMcYDwwJz6DmQ0BfkcI7F+kvpgiIlIXtQZ3dy8BJgFzgfeBJ919mZlNM7NxUba7gfbA/zOzxWY2p5rViYhII0imzR13fwF4oVLaj+OmR6W4XCIiUg+6Q1VEJA0puIuIpCEFdxGRNKTgLiKShhTcRUTSkIK7iEgaUnAXEUlDCu4iImlIwV1EJA0puIuIpCEFdxGRNKTgLiKShhTcRUTSkIK7iEgaUnAXEUlDCu4iImkoqeBuZqPNbIWZrTSzyQmWH29m75hZiZn9R+qLKSIidVFrcDezTGAGMAbIB843s/xK2dYAlwCPpbqAIiJSd8k8Zm84sNLdPwYws9nAWcDyWAZ3XxUtK2uAMoqISB0lE9y7Amvj5ouAEfuyMTMrBAqj2a/MbMW+rCdFOgMbm3D7qaR9aX7SZT9A+9Lc9EwmUzLB3RKked3KEn3IfSYwc18+m2pmttDdC5q6HKmgfWl+0mU/QPvSUiVzQbUI6B433w1Y1zDFERGRVEgmuC8A+ppZbzPLAcYDcxq2WCIiUh+1Bnd3LwEmAXOB94En3X2ZmU0zs3EAZna0mRUB3wF+Z2bLGrLQKdIsmodSRPvS/KTLfoD2pUUy931qPhcRkWZMd6iKiKQhBXcRkTTU4oO7mT1oZl+Y2XtxaQea2f+Y2YfR+wFRupnZvdEwCkvMbGjcZy6O8n9oZhfHpQ8zs6XRZ+41s0RdQ1OxH93N7BUze9/MlpnZdS14X1qb2Xwzezfal9uj9N5m9lZUrieiC/SYWatofmW0vFfcum6O0leY2elx6TUOiZHi/ck0s0Vm9lwL349V0fe/2MwWRmkt7u8r2lYnM3vKzP4d/c8c21L3pcG4e4t+AccDQ4H34tLuAiZH05OBn0fTY4EXCX33jwHeitIPBD6O3g+Ipg+Ils0Hjo0+8yIwpoH241BgaDSdC3xAGO6hJe6LAe2j6WzgraiMTwLjo/TfAhOj6auB30bT44Enoul84F2gFdAb+AjIjF4fAd8AcqI8+Q34N/afhKE1novmW+p+rAI6V0prcX9f0bb+CFwRTecAnVrqvjTYMWrqAqToi+5FxeC+Ajg0mj4UWBFN/w44v3I+4Hzgd3Hpv4vSDgX+HZdeIV8D79OfgVNb+r4AbYF3CHc1bwSyovRjgbnR9Fzg2Gg6K8pnwM3AzXHrmht9rvyzUXqFfCkufzfgJeBk4LmoXC1uP6L1r6JqcG9xf19AB+ATog4hLXlfGvLV4ptlqnGwu68HiN4PitITDaXQtZb0ogTpDSo6nR9CqPG2yH2JmjIWA18A/0OooW720LW28vbLyxwt3wLkUfd9bAj3AD8EYuMm5dEy9wPCneV/M7O3LQwFAi3z7+sbwAbgoai57H4za0fL3JcGk67BvTrVDaVQ1/QGY2btgaeB6919a01ZE6Q1m31x91J3H0yo+Q4H+tWw/Wa5L2b2LeALd387PrmGbTfL/Ygz0t2HEkZ4vcbMjq8hb3PelyxCU+xv3H0I8DWhGaY6zXlfGky6BvfPzexQgOj9iyi9uqEUakrvliC9QZhZNiGwz3L3P0XJLXJfYtx9M/Aqoa2zk5nFxjOK3355maPlHYFN1H0fU20kMM7MVgGzCU0z97TA/QDA3ddF718AzxB+dFvi31cRUOTub0XzTxGCfUvcl4bT1O1CKWqD60XFNve7qXhh5a5o+gwqXliZH6UfSGjDOyB6fQIcGC1bEOWNXVgZ20D7YMDDwD2V0lvivnQBOkXTbYDXgW8B/4+KFyKvjqavoeKFyCej6aOoeCHyY8JFyKxoujd7L0Qe1cB/Yyey94Jqi9sPoB2QGzf9BjC6Jf59Rdt6HTgimp4a7UeL3JcGO0ZNXYAUfMmPA+uBPYRf3MsJ7ZwvAR9G77EvzAgPHvkIWAoUxK3nMmBl9Lo0Lr0AeC/6zH1UuoiTwv04jnDqtwRYHL3GttB9GQgsivblPeDHUfo3CL0QVhICZKsovXU0vzJa/o24dU2JyruCuB4L0bH5IFo2pRH+zk5kb3BvcfsRlfnd6LUstq2W+PcVbWswsDD6G3uWEJxb5L401EvDD4iIpKF0bXMXEdmvKbiLiKQhBXcRkTSk4C4ikoYU3EVE0pCCu4hIGlJwFxFJQ/8/b02i9vf88wQAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "\n", "fig = plt.figure()\n", "plt.plot(train_sizes, train_scores.mean(axis=1), 'ro-', label=\"Train Scores\")\n", "plt.plot(train_sizes, test_scores.mean(axis=1), 'go-', label=\"Test Scores\")\n", "plt.title('Learning Curve: Logistic Regression')\n", "plt.ylim((0.1, 1.0))\n", "plt.legend()\n", "plt.draw()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### চেষ্টা করে দেখি: NLP with deep learning\n", "আমরা Tokenizer ব্যবহার করছি tensorflow.keras থেকে:\n", "১. ভোকাবুলারি তৈরি করা\n", "২. বাক্যকে সংখ্যার সেকোয়েন্স তৈরি\n", "৩. সেকোয়েন্সকে প্যাড দেয়া যাতে সেটা টেন্সরের মতো ব্যবহার করা যায় pad_sequences ফাংশন ব্যবহার করছি tensorflow.keras থেকে" ] }, { "cell_type": "code", "execution_count": 320, "metadata": {}, "outputs": [], "source": [ "from tensorflow.keras.preprocessing.text import Tokenizer" ] }, { "cell_type": "code", "execution_count": 321, "metadata": {}, "outputs": [], "source": [ "tokenizer = Tokenizer(num_words=20000)\n", "\n", "# docs = df['quote']\n", "tokenizer.fit_on_texts(docs)\n", "sequences = tokenizer.texts_to_sequences(docs)" ] }, { "cell_type": "code", "execution_count": 322, "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/plain": [ "[[107, 562, 1, 3, 3452],\n", " [281,\n", " 276,\n", " 2,\n", " 939,\n", " 512,\n", " 18541,\n", " 18,\n", " 526,\n", " 228,\n", " 16,\n", " 11,\n", " 1013,\n", " 10252,\n", " 1014,\n", " 14,\n", " 12536,\n", " 23,\n", " 8379,\n", " 162,\n", " 2324,\n", " 228,\n", " 1951,\n", " 200,\n", " 4,\n", " 212,\n", " 539,\n", " 7218],\n", " [1043, 208, 110, 7, 111],\n", " [4, 610, 666, 666, 28, 331, 1467, 90, 27, 131, 289, 220],\n", " [1274, 3229, 6507, 76, 3694, 3, 256, 6508, 1035, 4525, 291, 132]]" ] }, "execution_count": 322, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sequences[:5]" ] }, { "cell_type": "code", "execution_count": 323, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "20000" ] }, "execution_count": 323, "metadata": {}, "output_type": "execute_result" } ], "source": [ "max_features = max([max(seq) for seq in sequences if len(seq) > 0]) + 1\n", "max_features" ] }, { "cell_type": "code", "execution_count": 324, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "115" ] }, "execution_count": 324, "metadata": {}, "output_type": "execute_result" } ], "source": [ "maxlen = max([len(seq) for seq in sequences])\n", "maxlen" ] }, { "cell_type": "code", "execution_count": 325, "metadata": {}, "outputs": [], "source": [ "from tensorflow.keras.preprocessing.sequence import pad_sequences" ] }, { "cell_type": "code", "execution_count": 352, "metadata": {}, "outputs": [], "source": [ "maxlen=50" ] }, { "cell_type": "code", "execution_count": 353, "metadata": {}, "outputs": [], "source": [ "X = pad_sequences(sequences, maxlen=maxlen)" ] }, { "cell_type": "code", "execution_count": 354, "metadata": {}, "outputs": [], "source": [ "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state=0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### আরেকটা নেটওয়ার্ক: recurrent neural network model\n", "- সেন্টিমেন্টকে ক্লাসিফাই করতে রিকারেন্ট নিউরাল নেটওয়ার্কের ব্যবহার " ] }, { "cell_type": "code", "execution_count": 355, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6])" ] }, "execution_count": 355, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.unique(y_train)" ] }, { "cell_type": "code", "execution_count": 356, "metadata": {}, "outputs": [], "source": [ "from tensorflow.keras.models import Sequential\n", "from tensorflow.keras.layers import Dense, Activation, Embedding\n", "from tensorflow.keras.layers import LSTM, GRU" ] }, { "cell_type": "code", "execution_count": 357, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "W0913 22:42:56.640506 139675016652544 tf_logging.py:161] : Note that this layer is not optimized for performance. Please use tf.keras.layers.CuDNNLSTM for better performance on GPU.\n" ] } ], "source": [ "model1 = Sequential()\n", "model1.add(Embedding(input_dim=max_features,\n", " output_dim=32,\n", " input_length=maxlen))\n", "model1.add(LSTM(64))\n", "model1.add(Dense(7))\n", "model1.add(Activation('softmax'))\n", "\n", "model1.compile(loss='sparse_categorical_crossentropy',\n", " optimizer='adam',\n", " metrics=['accuracy'])" ] }, { "cell_type": "code", "execution_count": 358, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train on 62985 samples, validate on 6999 samples\n", "Epoch 1/4\n", "62985/62985 [==============================] - 13s 204us/sample - loss: 0.9779 - accuracy: 0.6240 - val_loss: 0.8152 - val_accuracy: 0.6961\n", "Epoch 2/4\n", "62985/62985 [==============================] - 12s 198us/sample - loss: 0.6876 - accuracy: 0.7444 - val_loss: 0.7712 - val_accuracy: 0.7007\n", "Epoch 3/4\n", "62985/62985 [==============================] - 13s 200us/sample - loss: 0.5782 - accuracy: 0.7907 - val_loss: 0.8043 - val_accuracy: 0.6922\n", "Epoch 4/4\n", "62985/62985 [==============================] - 13s 200us/sample - loss: 0.5088 - accuracy: 0.8189 - val_loss: 0.8484 - val_accuracy: 0.6901\n" ] } ], "source": [ "h = model1.fit(X_train, y_train, batch_size=64, epochs=4, validation_split=0.1)" ] }, { "cell_type": "code", "execution_count": 359, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "69984/69984 [==============================] - 10s 140us/sample - loss: 0.4572 - accuracy: 0.8457\n" ] }, { "data": { "text/plain": [ "[0.4571943279265485, 0.845679]" ] }, "execution_count": 359, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model1.evaluate(X_train, y_train, batch_size=32)" ] }, { "cell_type": "code", "execution_count": 360, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "29994/29994 [==============================] - 4s 140us/sample - loss: 0.8291 - accuracy: 0.7025\n" ] }, { "data": { "text/plain": [ "0.7024738" ] }, "execution_count": 360, "metadata": {}, "output_type": "execute_result" } ], "source": [ "loss, acc = model1.evaluate(X_test, y_test, batch_size=32)\n", "acc" ] }, { "cell_type": "code", "execution_count": 361, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 361, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "pd.DataFrame(h.history).plot(ylim=(-0.05, 1.05))" ] }, { "cell_type": "code", "execution_count": 362, "metadata": {}, "outputs": [], "source": [ "y_pred = model1.predict_classes(X_test)" ] }, { "cell_type": "code", "execution_count": 363, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 0, 1, 0, 0, 0, 0],\n", " [ 0, 185, 171, 5, 1, 22, 0],\n", " [ 0, 80, 11492, 992, 458, 772, 1],\n", " [ 0, 2, 2101, 2595, 782, 243, 0],\n", " [ 0, 0, 811, 554, 2189, 108, 2],\n", " [ 0, 15, 1205, 283, 114, 4609, 0],\n", " [ 0, 2, 148, 2, 15, 34, 0]])" ] }, "execution_count": 363, "metadata": {}, "output_type": "execute_result" } ], "source": [ "confusion_matrix(y_test, y_pred)" ] }, { "cell_type": "code", "execution_count": 343, "metadata": {}, "outputs": [], "source": [ "y_pred_all = model1.predict_classes(X)" ] }, { "cell_type": "code", "execution_count": 344, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 0, 1, 0, 0, 1, 0],\n", " [ 0, 807, 318, 13, 11, 65, 0],\n", " [ 0, 184, 41195, 1756, 958, 1738, 2],\n", " [ 0, 6, 4523, 12055, 1640, 726, 0],\n", " [ 0, 4, 1522, 1276, 9670, 270, 1],\n", " [ 0, 47, 2757, 502, 240, 16987, 2],\n", " [ 0, 10, 460, 9, 98, 115, 9]])" ] }, "execution_count": 344, "metadata": {}, "output_type": "execute_result" } ], "source": [ "confusion_matrix(y, y_pred_all)" ] }, { "cell_type": "code", "execution_count": 350, "metadata": {}, "outputs": [], "source": [ "# positive (4) labeled as negative (2)\n", "pos_neg_errors_idx = (y == 4) & (y_pred_all == 4)" ] }, { "cell_type": "code", "execution_count": 351, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([' হে মহান ফুটবলারবৃন্দ তোমাদের স্মরণ গাঁথা কাব্য চিরদিন মনে থাকবে।তোমরা শান্তিতে থেকো। ',\n", " ' নিহত সবার পরিবারে প্রতি রইল অন্তরের অন্তস্থল থেকে গভীর সমবেদনা। ',\n", " ' নিহত সবার পরিবারে প্রতি রইল অন্তরের অন্তস্থল থেকে গভীর সমবেদনা জানাই শোকাহত। ',\n", " ...,\n", " ' ঘুরে আসুন এই পেজ বাল লাগবে কাল্পনিক রাজ্য কাল্পনিক রাজ্য কাল্পনিক রাজ্য কাল্পনিক রাজ্য ',\n", " ' অস্থির একটা ফানি পেজ বাটপার বাটপার বাটপার বাটপার মজা নিতে লাইক দিন বাটপার বাটপার বাটপার বাটপার বাটপার বাটপার বাটপার ',\n", " ' জা করার তারাতারি করেন ৷ '], dtype=object)" ] }, "execution_count": 351, "metadata": {}, "output_type": "execute_result" } ], "source": [ "docs[pos_neg_errors_idx]" ] }, { "cell_type": "code", "execution_count": 337, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "' ভালবাসার গল্প পড়তে এই পেইজে লাইক দেন বন্ধুত্ব '" ] }, "execution_count": 337, "metadata": {}, "output_type": "execute_result" } ], "source": [ "test_sent" ] }, { "cell_type": "code", "execution_count": 338, "metadata": {}, "outputs": [], "source": [ "test_sent_numbers = tokenizer.texts_to_sequences([test_sent])" ] }, { "cell_type": "code", "execution_count": 339, "metadata": {}, "outputs": [], "source": [ "test_sent_X = pad_sequences(test_sent_numbers, maxlen=maxlen)" ] }, { "cell_type": "code", "execution_count": 340, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", " 0, 0, 0, 0, 0, 0, 0, 0, 2184, 780, 1426,\n", " 5, 924, 218, 295, 5132]], dtype=int32)" ] }, "execution_count": 340, "metadata": {}, "output_type": "execute_result" } ], "source": [ "test_sent_X" ] }, { "cell_type": "code", "execution_count": 341, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[3.2493996e-04, 1.3393437e-04, 1.4631876e-02, 9.5704895e-01,\n", " 2.3777947e-02, 3.7020321e-03, 3.8020010e-04]], dtype=float32)" ] }, "execution_count": 341, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model1.predict(test_sent_X)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### অন্য কিছু দেখি " ] }, { "cell_type": "code", "execution_count": 130, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "W0912 23:33:49.180243 140230039140096 tf_logging.py:161] : Note that this layer is not optimized for performance. Please use tf.keras.layers.CuDNNLSTM for better performance on GPU.\n", "W0912 23:33:49.333416 140230039140096 tf_logging.py:161] : Note that this layer is not optimized for performance. Please use tf.keras.layers.CuDNNLSTM for better performance on GPU.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Model: \"sequential_5\"\n", "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "embedding_5 (Embedding) (None, 99, 32) 487424 \n", "_________________________________________________________________\n", "unified_lstm_7 (UnifiedLSTM) (None, 99, 16) 3136 \n", "_________________________________________________________________\n", "unified_lstm_8 (UnifiedLSTM) (None, 8) 800 \n", "_________________________________________________________________\n", "dense_5 (Dense) (None, 1) 9 \n", "_________________________________________________________________\n", "activation_5 (Activation) (None, 1) 0 \n", "=================================================================\n", "Total params: 491,369\n", "Trainable params: 491,369\n", "Non-trainable params: 0\n", "_________________________________________________________________\n" ] } ], "source": [ "from tensorflow.keras import regularizers\n", "\n", "model2 = Sequential()\n", "model2.add(Embedding(input_dim=max_features,\n", " output_dim=32,\n", " input_length=maxlen))\n", "model2.add(LSTM(16, return_sequences=True, dropout=0.1))\n", "model2.add(LSTM(8, activity_regularizer=regularizers.l2(0.01), kernel_regularizer=regularizers.l2(0.01)))\n", "model2.add(Dense(1))\n", "model2.add(Activation('sigmoid'))\n", "\n", "model2.compile(loss='binary_crossentropy',\n", " optimizer='adam',\n", " metrics=['accuracy'])\n", "model2.summary()" ] }, { "cell_type": "code", "execution_count": 92, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train on 2520 samples, validate on 280 samples\n", "Epoch 1/4\n", "2520/2520 [==============================] - 2s 838us/sample - loss: 0.8705 - accuracy: 0.5563 - val_loss: 0.8297 - val_accuracy: 0.6107\n", "Epoch 2/4\n", "2520/2520 [==============================] - 1s 540us/sample - loss: 0.7672 - accuracy: 0.6817 - val_loss: 0.7170 - val_accuracy: 0.6714\n", "Epoch 3/4\n", "2520/2520 [==============================] - 1s 535us/sample - loss: 0.5342 - accuracy: 0.8544 - val_loss: 0.5666 - val_accuracy: 0.8036\n", "Epoch 4/4\n", "2520/2520 [==============================] - 1s 536us/sample - loss: 0.3160 - accuracy: 0.9552 - val_loss: 0.5511 - val_accuracy: 0.8000\n" ] } ], "source": [ "from tensorflow.keras import callbacks\n", "h = model.fit(X_train, y_train, batch_size=64, epochs=4, validation_split=0.1, callbacks=[callbacks.EarlyStopping()])" ] }, { "cell_type": "code", "execution_count": 93, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2800/2800 [==============================] - 1s 192us/sample - loss: 0.2718 - accuracy: 0.9650\n" ] }, { "data": { "text/plain": [ "[0.2718334950719561, 0.965]" ] }, "execution_count": 93, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model.evaluate(X_train, y_train, batch_size=64)" ] }, { "cell_type": "code", "execution_count": 94, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1200/1200 [==============================] - 0s 194us/sample - loss: 0.5122 - accuracy: 0.8092\n" ] }, { "data": { "text/plain": [ "0.80916667" ] }, "execution_count": 94, "metadata": {}, "output_type": "execute_result" } ], "source": [ "loss, acc = model.evaluate(X_test, y_test, batch_size=64)\n", "acc" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## ফাস্টটেক্সট ব্যবহার\n", "\n", "ফাস্টটেক্সট এমবেডিং ব্যবহার করি " ] } ], "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.6.8" } }, "nbformat": 4, "nbformat_minor": 2 }