From c16aa4d2bd6d45c804a626285fac959ebac5b3d5 Mon Sep 17 00:00:00 2001 From: unnatijain99 <55913108+unnatijain99@users.noreply.github.com> Date: Thu, 1 Oct 2020 12:46:29 +0530 Subject: [PATCH 1/3] Create HeapSort.cpp --- HeapSort.cpp | 75 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 HeapSort.cpp diff --git a/HeapSort.cpp b/HeapSort.cpp new file mode 100644 index 0000000..d3a0a8a --- /dev/null +++ b/HeapSort.cpp @@ -0,0 +1,75 @@ +#include +#include +#include +#include +using namespace std; +void heapify(int arr[], int n, int i) +{ + int largest = i; // Initialize largest as root + int l = 2*i + 1; // left = 2*i + 1 + int r = 2*i + 2; // right = 2*i + 2 + + // If left child is larger than root + if (l < n && arr[l] > arr[largest]) + largest = l; + + // If right child is larger than largest so far + if (r < n && arr[r] > arr[largest]) + largest = r; + + // If largest is not root + if (largest != i) { + swap(arr[i], arr[largest]); + + // Recursively heapify the affected sub-tree + heapify(arr, n, largest); + } +} + +// main function to do heap sort +void heapSort(int arr[], int n) +{ + // Build heap (rearrange array) + for (int i = n / 2 - 1; i >= 0; i--) + heapify(arr, n, i); + + // One by one extract an element from heap + for (int i=n-1; i>0; i--) + { + // Move current root to end + swap(arr[0], arr[i]); + + // call max heapify on the reduced heap + heapify(arr, i, 0); + } +} + +int main() { + int a[10000], size=10000, ch, i; + cout<<"Quick Sort\nEnter your Choice:\n1. Best Case\n2. Worst Case\n3. Average Case\n4. Exit\t"; + cin>>ch; + switch(ch) { + case 1: for(i=0; i<10000; i++) { + a[i] = i+1; + } + break; + case 2: for(i=10000; i>0; i--) { + a[10000-i] = i; + } + break; + case 3: srand(time(NULL)); + for(i=0; i<10000; i++) { + a[i] = rand() % 10000 + 1; + } + break; + case 4: exit(0); + break; + default: cout<<"Wrong Choice!"; + break; + } + clock_t start, end; + start = clock(); + heapSort(a, size); + end = clock(); + cout<<"Time Taken: "<<(double)(end-start)/CLK_TCK; +} From 7ef3cd8cb93780d5f904a9f5452b29926b5192cd Mon Sep 17 00:00:00 2001 From: unnatijain99 <55913108+unnatijain99@users.noreply.github.com> Date: Thu, 13 Jan 2022 19:19:43 +0530 Subject: [PATCH 2/3] Created using Colaboratory --- SMS_NLP.ipynb | 1478 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1478 insertions(+) create mode 100644 SMS_NLP.ipynb diff --git a/SMS_NLP.ipynb b/SMS_NLP.ipynb new file mode 100644 index 0000000..52573df --- /dev/null +++ b/SMS_NLP.ipynb @@ -0,0 +1,1478 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "SMS_NLP.ipynb", + "provenance": [], + "collapsed_sections": [ + "ZyfgcS5HJNxC", + "aP-zL4WhJaBO", + "70YyNR8bJ_M1", + "dL2xwaU6LJtn", + "CXR289E5L01q", + "ST328lvTMDwz" + ], + "toc_visible": true, + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "x6Mfv7WfBbhk" + }, + "source": [ + "# Importing Libraries\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "XcsDB-hbBDpG" + }, + "source": [ + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import numpy as np \n", + "import pandas as pd\n", + "import re\n", + "import nltk\n", + "from nltk.corpus import stopwords\n", + "from nltk.stem.porter import PorterStemmer\n", + "from nltk.stem import WordNetLemmatizer\n", + "from sklearn.feature_extraction.text import TfidfVectorizer\n", + "from sklearn.preprocessing import LabelEncoder\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.pipeline import Pipeline \n", + "from sklearn.naive_bayes import MultinomialNB\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.neighbors import KNeighborsClassifier\n", + "from sklearn.svm import SVC\n", + "from sklearn.model_selection import cross_val_score\n", + "from matplotlib.colors import ListedColormap\n", + "from sklearn.metrics import confusion_matrix, plot_confusion_matrix, classification_report, accuracy_score\n", + "from sklearn import metrics\n", + "from sklearn.naive_bayes import GaussianNB\n", + "from sklearn.tree import DecisionTreeClassifier\n", + "from sklearn.svm import SVC" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "idbLgo6qUGVi", + "outputId": "71d836fb-a9b3-4e28-86d2-a2eaec2c4327" + }, + "source": [ + "nltk.download('punkt')\n", + "nltk.download('stopwords')\n", + "nltk.download('wordnet')" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[nltk_data] Downloading package punkt to /root/nltk_data...\n", + "[nltk_data] Unzipping tokenizers/punkt.zip.\n", + "[nltk_data] Downloading package stopwords to /root/nltk_data...\n", + "[nltk_data] Unzipping corpora/stopwords.zip.\n", + "[nltk_data] Downloading package wordnet to /root/nltk_data...\n", + "[nltk_data] Unzipping corpora/wordnet.zip.\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "True" + ] + }, + "metadata": {}, + "execution_count": 2 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uH5xgUdFC1MO" + }, + "source": [ + "# Dataset Importing" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Aw8rBnwe9Bp1", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "a224ae70-8e08-4743-bf57-accbe12257d4" + }, + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "C-HPQUtmBuWH", + "outputId": "7567131c-d48c-4c3f-c0ec-ae5abcc26f69" + }, + "source": [ + "data = pd.read_csv(\"/content/drive/MyDrive/SMS_Dataset/SMS_Dataset.csv\",encoding='latin-1')\n", + "data.rename(columns = {\"v1\":\"Target\", \"v2\":\"Text\"}, inplace = True)\n", + "data.info()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "RangeIndex: 5572 entries, 0 to 5571\n", + "Data columns (total 2 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 Target 5572 non-null object\n", + " 1 Text 5572 non-null object\n", + "dtypes: object(2)\n", + "memory usage: 87.2+ KB\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Pk-Ei9-SDJT0" + }, + "source": [ + "# Data Visualisation " + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 535 + }, + "id": "YUIeOEJZDNGT", + "outputId": "58e20dc3-5550-4525-cb80-bd5750c4b44a" + }, + "source": [ + "sns.set_theme(style=\"darkgrid\")\n", + "plt.figure(figsize=(12,8))\n", + "fg = sns.countplot(x= data[\"Target\"])\n", + "fg.set_title(\"Count Plot of Classes\")\n", + "fg.set_xlabel(\"Classes\")\n", + "fg.set_ylabel(\"Number of Data points\")" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Text(0, 0.5, 'Number of Data points')" + ] + }, + "metadata": {}, + "execution_count": 15 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 297 + }, + "id": "1eU5ZyuzE954", + "outputId": "0cde6093-ebac-4d06-9ffb-7bfd1839e599" + }, + "source": [ + "data[\"No_of_Characters\"] = data[\"Text\"].apply(len)\n", + "data[\"No_of_Words\"]=data.apply(lambda row: nltk.word_tokenize(row[\"Text\"]), axis=1).apply(len)\n", + "data[\"No_of_sentence\"]=data.apply(lambda row: nltk.sent_tokenize(row[\"Text\"]), axis=1).apply(len)\n", + "data.describe()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
No_of_CharactersNo_of_WordsNo_of_sentence
count5572.0000005572.0000005572.000000
mean80.33237618.5026921.993001
std59.83902713.6383721.503584
min2.0000001.0000001.000000
25%36.0000009.0000001.000000
50%61.00000015.0000002.000000
75%122.00000027.0000002.000000
max910.000000219.00000038.000000
\n", + "
" + ], + "text/plain": [ + " No_of_Characters No_of_Words No_of_sentence\n", + "count 5572.000000 5572.000000 5572.000000\n", + "mean 80.332376 18.502692 1.993001\n", + "std 59.839027 13.638372 1.503584\n", + "min 2.000000 1.000000 1.000000\n", + "25% 36.000000 9.000000 1.000000\n", + "50% 61.000000 15.000000 2.000000\n", + "75% 122.000000 27.000000 2.000000\n", + "max 910.000000 219.000000 38.000000" + ] + }, + "metadata": {}, + "execution_count": 16 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "JFQxvMwUFtq5", + "outputId": "845f6999-59e7-4da8-a678-bb9ae320bb56" + }, + "source": [ + "data = data[(data[\"No_of_Characters\"]<350)]\n", + "data.shape" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(5548, 5)" + ] + }, + "metadata": {}, + "execution_count": 17 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 565 + }, + "id": "hogDhPJiFcKJ", + "outputId": "03f8bcfb-c338-4cca-e59b-ce15b7e75d99" + }, + "source": [ + "plt.figure(figsize=(12,8))\n", + "sns.set_theme(style=\"darkgrid\")\n", + "fg = sns.pairplot(data=data, hue=\"Target\")\n", + "plt.show(fg)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rlpXJu31JxJw" + }, + "source": [ + "# Data Preprocessing" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NgV6Pd5cNKMx" + }, + "source": [ + "Cleaning Data" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "yohWmfHLJ16M" + }, + "source": [ + "def Clean(Text):\n", + " sms = re.sub('[^a-zA-Z]', ' ', Text) \n", + " sms = sms.lower() \n", + " sms = sms.split()\n", + " sms = ' '.join(sms)\n", + " return sms\n", + "data[\"Clean_Text\"] = data[\"Text\"].apply(Clean)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eGu1L-zYNO0y" + }, + "source": [ + "Tokenizing Data" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "IRugM6lTKWKG" + }, + "source": [ + "data[\"Tokenize_Text\"]=data.apply(lambda row: nltk.word_tokenize(row[\"Clean_Text\"]), axis=1)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CRNx9oWGNS59" + }, + "source": [ + "Removing Stop Words" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "yUTBCbZmLW4r" + }, + "source": [ + "def remove_stopwords(text):\n", + " stop_words = set(stopwords.words(\"english\"))\n", + " filtered_text = [word for word in text if word not in stop_words]\n", + " #filtered_text = filtered_text.split()\n", + " filtered_text = ' '.join(filtered_text)\n", + " return filtered_text\n", + "data[\"Nostopword_Text\"] = data[\"Tokenize_Text\"].apply(remove_stopwords)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "s4aamfBiNYte" + }, + "source": [ + "Stemming " + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "4K_OPiMeLe1I" + }, + "source": [ + "lemmatizer = WordNetLemmatizer()\n", + "def lemmatize_word(text):\n", + " lemmas = [lemmatizer.lemmatize(word, pos ='v') for word in text]\n", + " #lemmas = lemmas.split()\n", + " lemmas = ''.join(lemmas)\n", + " return lemmas\n", + "\n", + "data[\"Lemmatized_Text\"] = data[\"Nostopword_Text\"].apply(lemmatize_word)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 666 + }, + "id": "oJ5XlMhDLouu", + "outputId": "1979e822-978b-4742-98ca-5b77dbcc0633" + }, + "source": [ + "data.head()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "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", + " \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", + "
TargetTextNo_of_CharactersNo_of_WordsNo_of_sentenceClean_TextTokenize_TextNostopword_TextLemmatized_Text
0hamGo until jurong point, crazy.. Available only ...111232go until jurong point crazy available only in ...[go, until, jurong, point, crazy, available, o...go jurong point crazy available bugis n great ...go jurong point crazy available bugis n great ...
1hamOk lar... Joking wif u oni...2982ok lar joking wif u oni[ok, lar, joking, wif, u, oni]ok lar joking wif u oniok lar joking wif u oni
2spamFree entry in 2 a wkly comp to win FA Cup fina...155372free entry in a wkly comp to win fa cup final ...[free, entry, in, a, wkly, comp, to, win, fa, ...free entry wkly comp win fa cup final tkts st ...free entry wkly comp win fa cup final tkts st ...
3hamU dun say so early hor... U c already then say...49131u dun say so early hor u c already then say[u, dun, say, so, early, hor, u, c, already, t...u dun say early hor u c already sayu dun say early hor u c already say
4hamNah I don't think he goes to usf, he lives aro...61151nah i don t think he goes to usf he lives arou...[nah, i, don, t, think, he, goes, to, usf, he,...nah think goes usf lives around thoughnah think goes usf lives around though
\n", + "
" + ], + "text/plain": [ + " Target ... Lemmatized_Text\n", + "0 ham ... go jurong point crazy available bugis n great ...\n", + "1 ham ... ok lar joking wif u oni\n", + "2 spam ... free entry wkly comp win fa cup final tkts st ...\n", + "3 ham ... u dun say early hor u c already say\n", + "4 ham ... nah think goes usf lives around though\n", + "\n", + "[5 rows x 9 columns]" + ] + }, + "metadata": {}, + "execution_count": 13 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "N0hkIeFK-qL7" + }, + "source": [ + "corpus=data[\"Lemmatized_Text\"]" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "paOhXUp89XfC" + }, + "source": [ + "# Classification " + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "vFgmkwVn-5Ew" + }, + "source": [ + "y = data.replace(['ham','spam'],[0, 1])['Target']" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "gvLf95T9-955", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "5b400905-04d4-4203-98cd-86282bf661ed" + }, + "source": [ + "y.value_counts()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0 4801\n", + "1 747\n", + "Name: Target, dtype: int64" + ] + }, + "metadata": {}, + "execution_count": 16 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "AQ0X_7si-_eE" + }, + "source": [ + "from sklearn.feature_extraction.text import CountVectorizer\n", + "cv = CountVectorizer()\n", + "x = cv.fit_transform(data['Lemmatized_Text']).toarray()" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "F_M06CJkDhyG" + }, + "source": [ + "xtrain, xtest, ytrain, ytest = train_test_split(x, y,test_size= 0.30, random_state = 0)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZyfgcS5HJNxC" + }, + "source": [ + "###**Naive Bayes**\n", + "####Naive Bayes classifiers are a collection of classification algorithms based on Bayes’ Theorem. It is not a single algorithm but a family of algorithms where all of them share a common principle, i.e. every pair of features being classified is independent of each other." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "-Czq2babDjtj", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 297 + }, + "outputId": "e9f6bb6b-672a-4547-c86d-fe160b21029d" + }, + "source": [ + "classifier = GaussianNB()\n", + "classifier.fit(xtrain, ytrain)\n", + "\n", + "y_pred = classifier.predict(xtest)\n", + "\n", + "conf_matrix = metrics.confusion_matrix(ytest, y_pred)\n", + "sns.heatmap(conf_matrix, annot = True, fmt = \".3f\", square = True, cmap = plt.cm.Blues)\n", + "plt.ylabel('Actual')\n", + "plt.xlabel('Predicted')\n", + "plt.title('Confusion matrix')\n", + "plt.tight_layout()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ehn5hmMBE4AG" + }, + "source": [ + "classifiers =[]\n", + "accuracy = []\n", + "error = []\n", + "precision =[]\n", + "recall = []\n", + "F1_score = []\n", + "j=0" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "YaMyIgE9Dm8h", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "98ec60a9-8c5c-4305-a78e-8902c1b832a0" + }, + "source": [ + "conf = confusion_matrix(ytest, y_pred)\n", + "TP = conf[1, 1]\n", + "TN = conf[0, 0]\n", + "FP = conf[0, 1]\n", + "FN = conf[1, 0]\n", + "classifiers.append('Naive Bayes')\n", + "b=round(accuracy_score(ytest, y_pred),4)\n", + "accuracy.append(b)\n", + "error.append(1-b)\n", + "precision.append(TP / float(FP + TP))\n", + "recall.append(TP / float(FN + TP))\n", + "F1_score.append(2 * (precision[j] * recall[j]) / (precision[j] +recall[j]))\n", + "print([classifiers[j] ,accuracy[j], error[j], precision[j], recall[j], F1_score[j]])\n", + "j+=1" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['Naive Bayes', 0.8811, 0.1189, 0.5283018867924528, 0.8949771689497716, 0.6644067796610169]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aP-zL4WhJaBO" + }, + "source": [ + "###**Decision Tree**\n", + "####Decision tree uses information gain to distinguish between feature subsets and ultimately classifying the instances using their leaf nodes. We have used entropy in this project." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "eMDVeqfFJZjN", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 297 + }, + "outputId": "cd0de469-3a2e-42f9-f545-7811a219b908" + }, + "source": [ + "classifier = DecisionTreeClassifier(random_state=0)\n", + "classifier.fit(xtrain, ytrain)\n", + "\n", + "y_pred = classifier.predict(xtest)\n", + "\n", + "conf_matrix = metrics.confusion_matrix(ytest, y_pred)\n", + "sns.heatmap(conf_matrix, annot = True, fmt = \".3f\", square = True, cmap = plt.cm.Blues)\n", + "plt.ylabel('Actual')\n", + "plt.xlabel('Predicted')\n", + "plt.title('Confusion matrix')\n", + "plt.tight_layout()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "OuZY_5UHGRQz", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "6a30a589-6916-48e0-8692-a690fa43de27" + }, + "source": [ + "conf = confusion_matrix(ytest, y_pred)\n", + "TP = conf[1, 1]\n", + "TN = conf[0, 0]\n", + "FP = conf[0, 1]\n", + "FN = conf[1, 0]\n", + "classifiers.append('Decision Tree')\n", + "b=round(accuracy_score(ytest, y_pred),4)\n", + "accuracy.append(b)\n", + "error.append(1-b)\n", + "precision.append(TP / float(FP + TP))\n", + "recall.append(TP / float(FN + TP))\n", + "F1_score.append(2 * (precision[j] * recall[j]) / (precision[j] +recall[j]))\n", + "print([classifiers[j] ,accuracy[j], error[j], precision[j], recall[j], F1_score[j]])\n", + "j+=1" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['Decision Tree', 0.9658, 0.03420000000000001, 0.9175257731958762, 0.8127853881278538, 0.8619854721549636]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "70YyNR8bJ_M1" + }, + "source": [ + "###**Support Vector Machine(SVM)**\n", + "####SVM discriminatively distinguishes between multiple classes in the dataset. We have used a linear kernel to classify our dataset.\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "HkfOHhbDKMMj", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 297 + }, + "outputId": "91a6068f-2150-49a9-ec2f-4c1046be50dc" + }, + "source": [ + "classifier = SVC(kernel = 'linear') \n", + "classifier.fit(xtrain, ytrain)\n", + "\n", + "y_pred = classifier.predict(xtest)\n", + "\n", + "conf_matrix = metrics.confusion_matrix(ytest, y_pred)\n", + "sns.heatmap(conf_matrix, annot = True, fmt = \".3f\", square = True, cmap = plt.cm.Blues)\n", + "plt.ylabel('Actual')\n", + "plt.xlabel('Predicted')\n", + "plt.title('Confusion matrix')\n", + "plt.tight_layout()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "RhL2Rn_XKPOJ", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "089af394-3333-41dc-eede-68d2a292a10b" + }, + "source": [ + "conf = confusion_matrix(ytest, y_pred)\n", + "TP = conf[1, 1]\n", + "TN = conf[0, 0]\n", + "FP = conf[0, 1]\n", + "FN = conf[1, 0]\n", + "classifiers.append('SVM')\n", + "b=round(accuracy_score(ytest, y_pred),4)\n", + "accuracy.append(b)\n", + "error.append(1-b)\n", + "precision.append(TP / float(FP + TP))\n", + "recall.append(TP / float(FN + TP))\n", + "F1_score.append(2 * (precision[j] * recall[j]) / (precision[j] +recall[j]))\n", + "print([classifiers[j] ,accuracy[j], error[j], precision[j], recall[j], F1_score[j]])\n", + "j+=1" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['SVM', 0.9838, 0.016199999999999992, 0.9948453608247423, 0.8812785388127854, 0.9346246973365617]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3PkUD37kKgYF" + }, + "source": [ + "#**Classification TFIDF**\n", + "####TF-IDF means Term Frequency - Inverse Document Frequency. This is a statistic that is based on the frequency of a word in the corpus but it also provides a numerical representation of how important a word is for statistical analysis.\n", + "\n", + "####TF-IDF is better than Count Vectorizers because it not only focuses on the frequency of words present in the corpus but also provides the importance of the words. We can then remove the words that are less important for analysis, hence making the model building less complex by reducing the input dimensions." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Zf8Gqw0GKsip" + }, + "source": [ + "vec = TfidfVectorizer()\n", + "x = vec.fit_transform(data['Lemmatized_Text']).toarray()\n", + "xtrain, xtest, ytrain, ytest = train_test_split(x, y,test_size= 0.30, random_state = 0)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dL2xwaU6LJtn" + }, + "source": [ + "###**Naive Bayes**" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "7a2PxNrSLLGr", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 297 + }, + "outputId": "2a9c81b2-f565-495a-a779-50eecac99f27" + }, + "source": [ + "classifier = GaussianNB()\n", + "classifier.fit(xtrain, ytrain)\n", + "\n", + "y_pred = classifier.predict(xtest)\n", + "\n", + "conf_matrix = metrics.confusion_matrix(ytest, y_pred)\n", + "sns.heatmap(conf_matrix, annot = True, fmt = \".3f\", square = True, cmap = plt.cm.Blues)\n", + "plt.ylabel('Actual')\n", + "plt.xlabel('Predicted')\n", + "plt.title('Confusion matrix')\n", + "plt.tight_layout()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "yJJUq4x0Lozm", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "5efaf540-0c6f-47a9-f982-5a0dacb6e725" + }, + "source": [ + "conf = confusion_matrix(ytest, y_pred)\n", + "TP = conf[1, 1]\n", + "TN = conf[0, 0]\n", + "FP = conf[0, 1]\n", + "FN = conf[1, 0]\n", + "classifiers.append('TFIDF Naive Bayes')\n", + "b=round(accuracy_score(ytest, y_pred),4)\n", + "accuracy.append(b)\n", + "error.append(1-b)\n", + "precision.append(TP / float(FP + TP))\n", + "recall.append(TP / float(FN + TP))\n", + "F1_score.append(2 * (precision[j] * recall[j]) / (precision[j] +recall[j]))\n", + "print([classifiers[j] ,accuracy[j], error[j], precision[j], recall[j], F1_score[j]])\n", + "j+=1" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['TFIDF Naive Bayes', 0.8787, 0.12129999999999996, 0.5235457063711911, 0.863013698630137, 0.6517241379310345]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CXR289E5L01q" + }, + "source": [ + "###**Decision Tree**\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "F8Bu2jCzL3em", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 297 + }, + "outputId": "618cade4-e4d3-4a0b-c72a-f8d0854d309e" + }, + "source": [ + "classifier = DecisionTreeClassifier(random_state=0, criterion='entropy')\n", + "classifier.fit(xtrain, ytrain)\n", + "\n", + "y_pred = classifier.predict(xtest)\n", + "\n", + "conf_matrix = metrics.confusion_matrix(ytest, y_pred)\n", + "sns.heatmap(conf_matrix, annot = True, fmt = \".3f\", square = True, cmap = plt.cm.Blues)\n", + "plt.ylabel('Actual')\n", + "plt.xlabel('Predicted')\n", + "plt.title('Confusion matrix')\n", + "plt.tight_layout()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Q3Ji6-x4L8G2", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "7e332c59-8c01-4120-acb1-dcd7a5552473" + }, + "source": [ + "conf = confusion_matrix(ytest, y_pred)\n", + "TP = conf[1, 1]\n", + "TN = conf[0, 0]\n", + "FP = conf[0, 1]\n", + "FN = conf[1, 0]\n", + "classifiers.append('TFIDF Decision Tree')\n", + "b=round(accuracy_score(ytest, y_pred),4)\n", + "accuracy.append(b)\n", + "error.append(1-b)\n", + "precision.append(TP / float(FP + TP))\n", + "recall.append(TP / float(FN + TP))\n", + "F1_score.append(2 * (precision[j] * recall[j]) / (precision[j] +recall[j]))\n", + "print([classifiers[j] ,accuracy[j], error[j], precision[j], recall[j], F1_score[j]])\n", + "j+=1" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['TFIDF Decision Tree', 0.9604, 0.03959999999999997, 0.8963730569948186, 0.7899543378995434, 0.8398058252427184]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ST328lvTMDwz" + }, + "source": [ + "###**Support Vector Machine(SVM)**" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "LMQvr5KgMsA3", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 297 + }, + "outputId": "4a86ad29-9eab-4946-fc8f-800b79f110f6" + }, + "source": [ + "classifier = SVC(kernel = 'linear') \n", + "classifier.fit(xtrain, ytrain)\n", + "\n", + "y_pred = classifier.predict(xtest)\n", + "\n", + "conf_matrix = metrics.confusion_matrix(ytest, y_pred)\n", + "sns.heatmap(conf_matrix, annot = True, fmt = \".3f\", square = True, cmap = plt.cm.Blues)\n", + "plt.ylabel('Actual')\n", + "plt.xlabel('Predicted')\n", + "plt.title('Confusion matrix')\n", + "plt.tight_layout()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "p_pytiB_MkdT", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "cc915e0c-abd3-4ac5-d2e1-4a9ee153b12d" + }, + "source": [ + "conf = confusion_matrix(ytest, y_pred)\n", + "TP = conf[1, 1]\n", + "TN = conf[0, 0]\n", + "FP = conf[0, 1]\n", + "FN = conf[1, 0]\n", + "classifiers.append('TFIDF SVM')\n", + "b=round(accuracy_score(ytest, y_pred),4)\n", + "accuracy.append(b)\n", + "error.append(1-b)\n", + "precision.append(TP / float(FP + TP))\n", + "recall.append(TP / float(FN + TP))\n", + "F1_score.append(2 * (precision[j] * recall[j]) / (precision[j] +recall[j]))\n", + "print([classifiers[j] ,accuracy[j], error[j], precision[j], recall[j], F1_score[j]])\n", + "j+=1" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['TFIDF SVM', 0.9784, 0.021599999999999953, 0.9945945945945946, 0.8401826484018264, 0.9108910891089109]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TEayGiJUNJ-j" + }, + "source": [ + "# Results" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "0qQQSL7ONUsc", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 235 + }, + "outputId": "bd1e1bf9-91b1-4cdc-d372-7cebc4f6f826" + }, + "source": [ + "data1 = pd.DataFrame({'Classifier':classifiers, 'Accuracy':accuracy,'Error':error, 'Precison':precision,'Recall':recall,'F1_Measure':F1_score})\n", + "data1.head(7)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ClassifierAccuracyErrorPrecisonRecallF1_Measure
0Naive Bayes0.88110.11890.5283020.8949770.664407
1Decision Tree0.96580.03420.9175260.8127850.861985
2SVM0.98380.01620.9948450.8812790.934625
3TFIDF Naive Bayes0.87870.12130.5235460.8630140.651724
4TFIDF Decision Tree0.96040.03960.8963730.7899540.839806
5TFIDF SVM0.97840.02160.9945950.8401830.910891
\n", + "
" + ], + "text/plain": [ + " Classifier Accuracy Error Precison Recall F1_Measure\n", + "0 Naive Bayes 0.8811 0.1189 0.528302 0.894977 0.664407\n", + "1 Decision Tree 0.9658 0.0342 0.917526 0.812785 0.861985\n", + "2 SVM 0.9838 0.0162 0.994845 0.881279 0.934625\n", + "3 TFIDF Naive Bayes 0.8787 0.1213 0.523546 0.863014 0.651724\n", + "4 TFIDF Decision Tree 0.9604 0.0396 0.896373 0.789954 0.839806\n", + "5 TFIDF SVM 0.9784 0.0216 0.994595 0.840183 0.910891" + ] + }, + "metadata": {}, + "execution_count": 48 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "icAEU9jvPrj4", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 396 + }, + "outputId": "d0543e1a-fe1f-4f55-c1e1-8be4ba12f8e0" + }, + "source": [ + "plt.figure(figsize=(40,15))\n", + "plt.subplot(2, 3, 1)\n", + "s=sns.barplot(x=data1.Accuracy,y=data1.Classifier)\n", + "plt.title('Accuracy',fontsize = 21, fontweight ='bold')\n", + "plt.xlabel(\"Accuracy\",fontsize = 12, fontweight ='bold')\n", + "plt.xlim(0.8,1.0)\n", + "plt.grid(axis='x')\n", + "plt.subplot(2, 3, 2)\n", + "s=sns.barplot(x=data1.Error,y=data1.Classifier)\n", + "plt.title('Error',fontsize = 21, fontweight ='bold')\n", + "plt.xlabel(\"Error\",fontsize = 12, fontweight ='bold')\n", + "plt.xlim(0.0,0.2)\n", + "plt.grid(axis='x')\n", + "plt.subplot(2, 3, 3)\n", + "s=sns.barplot(x=data1.Precison,y=data1.Classifier)\n", + "plt.title('Precison',fontsize = 21, fontweight ='bold')\n", + "plt.xlabel(\"Precison\",fontsize = 12, fontweight ='bold')\n", + "plt.xlim(0.5,1.0)\n", + "plt.grid(axis='x')\n", + "plt.subplot(2, 3, 4)\n", + "s=sns.barplot(x=data1.Recall,y=data1.Classifier)\n", + "plt.title('Recall',fontsize = 21, fontweight ='bold')\n", + "plt.xlabel(\"Recall\",fontsize = 12, fontweight ='bold')\n", + "plt.xlim(0.7,1.0)\n", + "plt.grid(axis='x')\n", + "plt.subplot(2, 3, 6)\n", + "s=sns.barplot(x=data1.F1_Measure,y=data1.Classifier)\n", + "plt.title('F1 Score',fontsize = 21, fontweight ='bold')\n", + "plt.xlabel(\"F1 Score\",fontsize = 12, fontweight ='bold')\n", + "plt.xlim(0.6,1.0)\n", + "plt.grid(axis='x')" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ] + } + ] +} \ No newline at end of file From e8f049a940d37aa5c7c673362a035a18c75c3ade Mon Sep 17 00:00:00 2001 From: unnatijain99 <55913108+unnatijain99@users.noreply.github.com> Date: Thu, 13 Jan 2022 19:20:56 +0530 Subject: [PATCH 3/3] Delete SMS_NLP.ipynb --- SMS_NLP.ipynb | 1478 ------------------------------------------------- 1 file changed, 1478 deletions(-) delete mode 100644 SMS_NLP.ipynb diff --git a/SMS_NLP.ipynb b/SMS_NLP.ipynb deleted file mode 100644 index 52573df..0000000 --- a/SMS_NLP.ipynb +++ /dev/null @@ -1,1478 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "name": "SMS_NLP.ipynb", - "provenance": [], - "collapsed_sections": [ - "ZyfgcS5HJNxC", - "aP-zL4WhJaBO", - "70YyNR8bJ_M1", - "dL2xwaU6LJtn", - "CXR289E5L01q", - "ST328lvTMDwz" - ], - "toc_visible": true, - "include_colab_link": true - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "x6Mfv7WfBbhk" - }, - "source": [ - "# Importing Libraries\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "XcsDB-hbBDpG" - }, - "source": [ - "import warnings\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "import numpy as np \n", - "import pandas as pd\n", - "import re\n", - "import nltk\n", - "from nltk.corpus import stopwords\n", - "from nltk.stem.porter import PorterStemmer\n", - "from nltk.stem import WordNetLemmatizer\n", - "from sklearn.feature_extraction.text import TfidfVectorizer\n", - "from sklearn.preprocessing import LabelEncoder\n", - "from sklearn.model_selection import train_test_split\n", - "from sklearn.pipeline import Pipeline \n", - "from sklearn.naive_bayes import MultinomialNB\n", - "from sklearn.ensemble import RandomForestClassifier\n", - "from sklearn.neighbors import KNeighborsClassifier\n", - "from sklearn.svm import SVC\n", - "from sklearn.model_selection import cross_val_score\n", - "from matplotlib.colors import ListedColormap\n", - "from sklearn.metrics import confusion_matrix, plot_confusion_matrix, classification_report, accuracy_score\n", - "from sklearn import metrics\n", - "from sklearn.naive_bayes import GaussianNB\n", - "from sklearn.tree import DecisionTreeClassifier\n", - "from sklearn.svm import SVC" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "idbLgo6qUGVi", - "outputId": "71d836fb-a9b3-4e28-86d2-a2eaec2c4327" - }, - "source": [ - "nltk.download('punkt')\n", - "nltk.download('stopwords')\n", - "nltk.download('wordnet')" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[nltk_data] Downloading package punkt to /root/nltk_data...\n", - "[nltk_data] Unzipping tokenizers/punkt.zip.\n", - "[nltk_data] Downloading package stopwords to /root/nltk_data...\n", - "[nltk_data] Unzipping corpora/stopwords.zip.\n", - "[nltk_data] Downloading package wordnet to /root/nltk_data...\n", - "[nltk_data] Unzipping corpora/wordnet.zip.\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "True" - ] - }, - "metadata": {}, - "execution_count": 2 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "uH5xgUdFC1MO" - }, - "source": [ - "# Dataset Importing" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "Aw8rBnwe9Bp1", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "a224ae70-8e08-4743-bf57-accbe12257d4" - }, - "source": [ - "from google.colab import drive\n", - "drive.mount('/content/drive')" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Mounted at /content/drive\n" - ] - } - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "C-HPQUtmBuWH", - "outputId": "7567131c-d48c-4c3f-c0ec-ae5abcc26f69" - }, - "source": [ - "data = pd.read_csv(\"/content/drive/MyDrive/SMS_Dataset/SMS_Dataset.csv\",encoding='latin-1')\n", - "data.rename(columns = {\"v1\":\"Target\", \"v2\":\"Text\"}, inplace = True)\n", - "data.info()" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\n", - "RangeIndex: 5572 entries, 0 to 5571\n", - "Data columns (total 2 columns):\n", - " # Column Non-Null Count Dtype \n", - "--- ------ -------------- ----- \n", - " 0 Target 5572 non-null object\n", - " 1 Text 5572 non-null object\n", - "dtypes: object(2)\n", - "memory usage: 87.2+ KB\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Pk-Ei9-SDJT0" - }, - "source": [ - "# Data Visualisation " - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 535 - }, - "id": "YUIeOEJZDNGT", - "outputId": "58e20dc3-5550-4525-cb80-bd5750c4b44a" - }, - "source": [ - "sns.set_theme(style=\"darkgrid\")\n", - "plt.figure(figsize=(12,8))\n", - "fg = sns.countplot(x= data[\"Target\"])\n", - "fg.set_title(\"Count Plot of Classes\")\n", - "fg.set_xlabel(\"Classes\")\n", - "fg.set_ylabel(\"Number of Data points\")" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "Text(0, 0.5, 'Number of Data points')" - ] - }, - "metadata": {}, - "execution_count": 15 - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 297 - }, - "id": "1eU5ZyuzE954", - "outputId": "0cde6093-ebac-4d06-9ffb-7bfd1839e599" - }, - "source": [ - "data[\"No_of_Characters\"] = data[\"Text\"].apply(len)\n", - "data[\"No_of_Words\"]=data.apply(lambda row: nltk.word_tokenize(row[\"Text\"]), axis=1).apply(len)\n", - "data[\"No_of_sentence\"]=data.apply(lambda row: nltk.sent_tokenize(row[\"Text\"]), axis=1).apply(len)\n", - "data.describe()" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
No_of_CharactersNo_of_WordsNo_of_sentence
count5572.0000005572.0000005572.000000
mean80.33237618.5026921.993001
std59.83902713.6383721.503584
min2.0000001.0000001.000000
25%36.0000009.0000001.000000
50%61.00000015.0000002.000000
75%122.00000027.0000002.000000
max910.000000219.00000038.000000
\n", - "
" - ], - "text/plain": [ - " No_of_Characters No_of_Words No_of_sentence\n", - "count 5572.000000 5572.000000 5572.000000\n", - "mean 80.332376 18.502692 1.993001\n", - "std 59.839027 13.638372 1.503584\n", - "min 2.000000 1.000000 1.000000\n", - "25% 36.000000 9.000000 1.000000\n", - "50% 61.000000 15.000000 2.000000\n", - "75% 122.000000 27.000000 2.000000\n", - "max 910.000000 219.000000 38.000000" - ] - }, - "metadata": {}, - "execution_count": 16 - } - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "JFQxvMwUFtq5", - "outputId": "845f6999-59e7-4da8-a678-bb9ae320bb56" - }, - "source": [ - "data = data[(data[\"No_of_Characters\"]<350)]\n", - "data.shape" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "(5548, 5)" - ] - }, - "metadata": {}, - "execution_count": 17 - } - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 565 - }, - "id": "hogDhPJiFcKJ", - "outputId": "03f8bcfb-c338-4cca-e59b-ce15b7e75d99" - }, - "source": [ - "plt.figure(figsize=(12,8))\n", - "sns.set_theme(style=\"darkgrid\")\n", - "fg = sns.pairplot(data=data, hue=\"Target\")\n", - "plt.show(fg)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ] - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {} - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "rlpXJu31JxJw" - }, - "source": [ - "# Data Preprocessing" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "NgV6Pd5cNKMx" - }, - "source": [ - "Cleaning Data" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "yohWmfHLJ16M" - }, - "source": [ - "def Clean(Text):\n", - " sms = re.sub('[^a-zA-Z]', ' ', Text) \n", - " sms = sms.lower() \n", - " sms = sms.split()\n", - " sms = ' '.join(sms)\n", - " return sms\n", - "data[\"Clean_Text\"] = data[\"Text\"].apply(Clean)" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "eGu1L-zYNO0y" - }, - "source": [ - "Tokenizing Data" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "IRugM6lTKWKG" - }, - "source": [ - "data[\"Tokenize_Text\"]=data.apply(lambda row: nltk.word_tokenize(row[\"Clean_Text\"]), axis=1)" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CRNx9oWGNS59" - }, - "source": [ - "Removing Stop Words" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "yUTBCbZmLW4r" - }, - "source": [ - "def remove_stopwords(text):\n", - " stop_words = set(stopwords.words(\"english\"))\n", - " filtered_text = [word for word in text if word not in stop_words]\n", - " #filtered_text = filtered_text.split()\n", - " filtered_text = ' '.join(filtered_text)\n", - " return filtered_text\n", - "data[\"Nostopword_Text\"] = data[\"Tokenize_Text\"].apply(remove_stopwords)" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "s4aamfBiNYte" - }, - "source": [ - "Stemming " - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "4K_OPiMeLe1I" - }, - "source": [ - "lemmatizer = WordNetLemmatizer()\n", - "def lemmatize_word(text):\n", - " lemmas = [lemmatizer.lemmatize(word, pos ='v') for word in text]\n", - " #lemmas = lemmas.split()\n", - " lemmas = ''.join(lemmas)\n", - " return lemmas\n", - "\n", - "data[\"Lemmatized_Text\"] = data[\"Nostopword_Text\"].apply(lemmatize_word)" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 666 - }, - "id": "oJ5XlMhDLouu", - "outputId": "1979e822-978b-4742-98ca-5b77dbcc0633" - }, - "source": [ - "data.head()" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "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", - " \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", - "
TargetTextNo_of_CharactersNo_of_WordsNo_of_sentenceClean_TextTokenize_TextNostopword_TextLemmatized_Text
0hamGo until jurong point, crazy.. Available only ...111232go until jurong point crazy available only in ...[go, until, jurong, point, crazy, available, o...go jurong point crazy available bugis n great ...go jurong point crazy available bugis n great ...
1hamOk lar... Joking wif u oni...2982ok lar joking wif u oni[ok, lar, joking, wif, u, oni]ok lar joking wif u oniok lar joking wif u oni
2spamFree entry in 2 a wkly comp to win FA Cup fina...155372free entry in a wkly comp to win fa cup final ...[free, entry, in, a, wkly, comp, to, win, fa, ...free entry wkly comp win fa cup final tkts st ...free entry wkly comp win fa cup final tkts st ...
3hamU dun say so early hor... U c already then say...49131u dun say so early hor u c already then say[u, dun, say, so, early, hor, u, c, already, t...u dun say early hor u c already sayu dun say early hor u c already say
4hamNah I don't think he goes to usf, he lives aro...61151nah i don t think he goes to usf he lives arou...[nah, i, don, t, think, he, goes, to, usf, he,...nah think goes usf lives around thoughnah think goes usf lives around though
\n", - "
" - ], - "text/plain": [ - " Target ... Lemmatized_Text\n", - "0 ham ... go jurong point crazy available bugis n great ...\n", - "1 ham ... ok lar joking wif u oni\n", - "2 spam ... free entry wkly comp win fa cup final tkts st ...\n", - "3 ham ... u dun say early hor u c already say\n", - "4 ham ... nah think goes usf lives around though\n", - "\n", - "[5 rows x 9 columns]" - ] - }, - "metadata": {}, - "execution_count": 13 - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "N0hkIeFK-qL7" - }, - "source": [ - "corpus=data[\"Lemmatized_Text\"]" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "paOhXUp89XfC" - }, - "source": [ - "# Classification " - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "vFgmkwVn-5Ew" - }, - "source": [ - "y = data.replace(['ham','spam'],[0, 1])['Target']" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "gvLf95T9-955", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "5b400905-04d4-4203-98cd-86282bf661ed" - }, - "source": [ - "y.value_counts()" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "0 4801\n", - "1 747\n", - "Name: Target, dtype: int64" - ] - }, - "metadata": {}, - "execution_count": 16 - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "AQ0X_7si-_eE" - }, - "source": [ - "from sklearn.feature_extraction.text import CountVectorizer\n", - "cv = CountVectorizer()\n", - "x = cv.fit_transform(data['Lemmatized_Text']).toarray()" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "F_M06CJkDhyG" - }, - "source": [ - "xtrain, xtest, ytrain, ytest = train_test_split(x, y,test_size= 0.30, random_state = 0)" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ZyfgcS5HJNxC" - }, - "source": [ - "###**Naive Bayes**\n", - "####Naive Bayes classifiers are a collection of classification algorithms based on Bayes’ Theorem. It is not a single algorithm but a family of algorithms where all of them share a common principle, i.e. every pair of features being classified is independent of each other." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "-Czq2babDjtj", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 297 - }, - "outputId": "e9f6bb6b-672a-4547-c86d-fe160b21029d" - }, - "source": [ - "classifier = GaussianNB()\n", - "classifier.fit(xtrain, ytrain)\n", - "\n", - "y_pred = classifier.predict(xtest)\n", - "\n", - "conf_matrix = metrics.confusion_matrix(ytest, y_pred)\n", - "sns.heatmap(conf_matrix, annot = True, fmt = \".3f\", square = True, cmap = plt.cm.Blues)\n", - "plt.ylabel('Actual')\n", - "plt.xlabel('Predicted')\n", - "plt.title('Confusion matrix')\n", - "plt.tight_layout()" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "ehn5hmMBE4AG" - }, - "source": [ - "classifiers =[]\n", - "accuracy = []\n", - "error = []\n", - "precision =[]\n", - "recall = []\n", - "F1_score = []\n", - "j=0" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "YaMyIgE9Dm8h", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "98ec60a9-8c5c-4305-a78e-8902c1b832a0" - }, - "source": [ - "conf = confusion_matrix(ytest, y_pred)\n", - "TP = conf[1, 1]\n", - "TN = conf[0, 0]\n", - "FP = conf[0, 1]\n", - "FN = conf[1, 0]\n", - "classifiers.append('Naive Bayes')\n", - "b=round(accuracy_score(ytest, y_pred),4)\n", - "accuracy.append(b)\n", - "error.append(1-b)\n", - "precision.append(TP / float(FP + TP))\n", - "recall.append(TP / float(FN + TP))\n", - "F1_score.append(2 * (precision[j] * recall[j]) / (precision[j] +recall[j]))\n", - "print([classifiers[j] ,accuracy[j], error[j], precision[j], recall[j], F1_score[j]])\n", - "j+=1" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "['Naive Bayes', 0.8811, 0.1189, 0.5283018867924528, 0.8949771689497716, 0.6644067796610169]\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "aP-zL4WhJaBO" - }, - "source": [ - "###**Decision Tree**\n", - "####Decision tree uses information gain to distinguish between feature subsets and ultimately classifying the instances using their leaf nodes. We have used entropy in this project." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "eMDVeqfFJZjN", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 297 - }, - "outputId": "cd0de469-3a2e-42f9-f545-7811a219b908" - }, - "source": [ - "classifier = DecisionTreeClassifier(random_state=0)\n", - "classifier.fit(xtrain, ytrain)\n", - "\n", - "y_pred = classifier.predict(xtest)\n", - "\n", - "conf_matrix = metrics.confusion_matrix(ytest, y_pred)\n", - "sns.heatmap(conf_matrix, annot = True, fmt = \".3f\", square = True, cmap = plt.cm.Blues)\n", - "plt.ylabel('Actual')\n", - "plt.xlabel('Predicted')\n", - "plt.title('Confusion matrix')\n", - "plt.tight_layout()" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "OuZY_5UHGRQz", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "6a30a589-6916-48e0-8692-a690fa43de27" - }, - "source": [ - "conf = confusion_matrix(ytest, y_pred)\n", - "TP = conf[1, 1]\n", - "TN = conf[0, 0]\n", - "FP = conf[0, 1]\n", - "FN = conf[1, 0]\n", - "classifiers.append('Decision Tree')\n", - "b=round(accuracy_score(ytest, y_pred),4)\n", - "accuracy.append(b)\n", - "error.append(1-b)\n", - "precision.append(TP / float(FP + TP))\n", - "recall.append(TP / float(FN + TP))\n", - "F1_score.append(2 * (precision[j] * recall[j]) / (precision[j] +recall[j]))\n", - "print([classifiers[j] ,accuracy[j], error[j], precision[j], recall[j], F1_score[j]])\n", - "j+=1" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "['Decision Tree', 0.9658, 0.03420000000000001, 0.9175257731958762, 0.8127853881278538, 0.8619854721549636]\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "70YyNR8bJ_M1" - }, - "source": [ - "###**Support Vector Machine(SVM)**\n", - "####SVM discriminatively distinguishes between multiple classes in the dataset. We have used a linear kernel to classify our dataset.\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "HkfOHhbDKMMj", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 297 - }, - "outputId": "91a6068f-2150-49a9-ec2f-4c1046be50dc" - }, - "source": [ - "classifier = SVC(kernel = 'linear') \n", - "classifier.fit(xtrain, ytrain)\n", - "\n", - "y_pred = classifier.predict(xtest)\n", - "\n", - "conf_matrix = metrics.confusion_matrix(ytest, y_pred)\n", - "sns.heatmap(conf_matrix, annot = True, fmt = \".3f\", square = True, cmap = plt.cm.Blues)\n", - "plt.ylabel('Actual')\n", - "plt.xlabel('Predicted')\n", - "plt.title('Confusion matrix')\n", - "plt.tight_layout()" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "RhL2Rn_XKPOJ", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "089af394-3333-41dc-eede-68d2a292a10b" - }, - "source": [ - "conf = confusion_matrix(ytest, y_pred)\n", - "TP = conf[1, 1]\n", - "TN = conf[0, 0]\n", - "FP = conf[0, 1]\n", - "FN = conf[1, 0]\n", - "classifiers.append('SVM')\n", - "b=round(accuracy_score(ytest, y_pred),4)\n", - "accuracy.append(b)\n", - "error.append(1-b)\n", - "precision.append(TP / float(FP + TP))\n", - "recall.append(TP / float(FN + TP))\n", - "F1_score.append(2 * (precision[j] * recall[j]) / (precision[j] +recall[j]))\n", - "print([classifiers[j] ,accuracy[j], error[j], precision[j], recall[j], F1_score[j]])\n", - "j+=1" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "['SVM', 0.9838, 0.016199999999999992, 0.9948453608247423, 0.8812785388127854, 0.9346246973365617]\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "3PkUD37kKgYF" - }, - "source": [ - "#**Classification TFIDF**\n", - "####TF-IDF means Term Frequency - Inverse Document Frequency. This is a statistic that is based on the frequency of a word in the corpus but it also provides a numerical representation of how important a word is for statistical analysis.\n", - "\n", - "####TF-IDF is better than Count Vectorizers because it not only focuses on the frequency of words present in the corpus but also provides the importance of the words. We can then remove the words that are less important for analysis, hence making the model building less complex by reducing the input dimensions." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "Zf8Gqw0GKsip" - }, - "source": [ - "vec = TfidfVectorizer()\n", - "x = vec.fit_transform(data['Lemmatized_Text']).toarray()\n", - "xtrain, xtest, ytrain, ytest = train_test_split(x, y,test_size= 0.30, random_state = 0)" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "dL2xwaU6LJtn" - }, - "source": [ - "###**Naive Bayes**" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "7a2PxNrSLLGr", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 297 - }, - "outputId": "2a9c81b2-f565-495a-a779-50eecac99f27" - }, - "source": [ - "classifier = GaussianNB()\n", - "classifier.fit(xtrain, ytrain)\n", - "\n", - "y_pred = classifier.predict(xtest)\n", - "\n", - "conf_matrix = metrics.confusion_matrix(ytest, y_pred)\n", - "sns.heatmap(conf_matrix, annot = True, fmt = \".3f\", square = True, cmap = plt.cm.Blues)\n", - "plt.ylabel('Actual')\n", - "plt.xlabel('Predicted')\n", - "plt.title('Confusion matrix')\n", - "plt.tight_layout()" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "yJJUq4x0Lozm", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "5efaf540-0c6f-47a9-f982-5a0dacb6e725" - }, - "source": [ - "conf = confusion_matrix(ytest, y_pred)\n", - "TP = conf[1, 1]\n", - "TN = conf[0, 0]\n", - "FP = conf[0, 1]\n", - "FN = conf[1, 0]\n", - "classifiers.append('TFIDF Naive Bayes')\n", - "b=round(accuracy_score(ytest, y_pred),4)\n", - "accuracy.append(b)\n", - "error.append(1-b)\n", - "precision.append(TP / float(FP + TP))\n", - "recall.append(TP / float(FN + TP))\n", - "F1_score.append(2 * (precision[j] * recall[j]) / (precision[j] +recall[j]))\n", - "print([classifiers[j] ,accuracy[j], error[j], precision[j], recall[j], F1_score[j]])\n", - "j+=1" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "['TFIDF Naive Bayes', 0.8787, 0.12129999999999996, 0.5235457063711911, 0.863013698630137, 0.6517241379310345]\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CXR289E5L01q" - }, - "source": [ - "###**Decision Tree**\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "F8Bu2jCzL3em", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 297 - }, - "outputId": "618cade4-e4d3-4a0b-c72a-f8d0854d309e" - }, - "source": [ - "classifier = DecisionTreeClassifier(random_state=0, criterion='entropy')\n", - "classifier.fit(xtrain, ytrain)\n", - "\n", - "y_pred = classifier.predict(xtest)\n", - "\n", - "conf_matrix = metrics.confusion_matrix(ytest, y_pred)\n", - "sns.heatmap(conf_matrix, annot = True, fmt = \".3f\", square = True, cmap = plt.cm.Blues)\n", - "plt.ylabel('Actual')\n", - "plt.xlabel('Predicted')\n", - "plt.title('Confusion matrix')\n", - "plt.tight_layout()" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "Q3Ji6-x4L8G2", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "7e332c59-8c01-4120-acb1-dcd7a5552473" - }, - "source": [ - "conf = confusion_matrix(ytest, y_pred)\n", - "TP = conf[1, 1]\n", - "TN = conf[0, 0]\n", - "FP = conf[0, 1]\n", - "FN = conf[1, 0]\n", - "classifiers.append('TFIDF Decision Tree')\n", - "b=round(accuracy_score(ytest, y_pred),4)\n", - "accuracy.append(b)\n", - "error.append(1-b)\n", - "precision.append(TP / float(FP + TP))\n", - "recall.append(TP / float(FN + TP))\n", - "F1_score.append(2 * (precision[j] * recall[j]) / (precision[j] +recall[j]))\n", - "print([classifiers[j] ,accuracy[j], error[j], precision[j], recall[j], F1_score[j]])\n", - "j+=1" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "['TFIDF Decision Tree', 0.9604, 0.03959999999999997, 0.8963730569948186, 0.7899543378995434, 0.8398058252427184]\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ST328lvTMDwz" - }, - "source": [ - "###**Support Vector Machine(SVM)**" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "LMQvr5KgMsA3", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 297 - }, - "outputId": "4a86ad29-9eab-4946-fc8f-800b79f110f6" - }, - "source": [ - "classifier = SVC(kernel = 'linear') \n", - "classifier.fit(xtrain, ytrain)\n", - "\n", - "y_pred = classifier.predict(xtest)\n", - "\n", - "conf_matrix = metrics.confusion_matrix(ytest, y_pred)\n", - "sns.heatmap(conf_matrix, annot = True, fmt = \".3f\", square = True, cmap = plt.cm.Blues)\n", - "plt.ylabel('Actual')\n", - "plt.xlabel('Predicted')\n", - "plt.title('Confusion matrix')\n", - "plt.tight_layout()" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "p_pytiB_MkdT", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "cc915e0c-abd3-4ac5-d2e1-4a9ee153b12d" - }, - "source": [ - "conf = confusion_matrix(ytest, y_pred)\n", - "TP = conf[1, 1]\n", - "TN = conf[0, 0]\n", - "FP = conf[0, 1]\n", - "FN = conf[1, 0]\n", - "classifiers.append('TFIDF SVM')\n", - "b=round(accuracy_score(ytest, y_pred),4)\n", - "accuracy.append(b)\n", - "error.append(1-b)\n", - "precision.append(TP / float(FP + TP))\n", - "recall.append(TP / float(FN + TP))\n", - "F1_score.append(2 * (precision[j] * recall[j]) / (precision[j] +recall[j]))\n", - "print([classifiers[j] ,accuracy[j], error[j], precision[j], recall[j], F1_score[j]])\n", - "j+=1" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "['TFIDF SVM', 0.9784, 0.021599999999999953, 0.9945945945945946, 0.8401826484018264, 0.9108910891089109]\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "TEayGiJUNJ-j" - }, - "source": [ - "# Results" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "0qQQSL7ONUsc", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 235 - }, - "outputId": "bd1e1bf9-91b1-4cdc-d372-7cebc4f6f826" - }, - "source": [ - "data1 = pd.DataFrame({'Classifier':classifiers, 'Accuracy':accuracy,'Error':error, 'Precison':precision,'Recall':recall,'F1_Measure':F1_score})\n", - "data1.head(7)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ClassifierAccuracyErrorPrecisonRecallF1_Measure
0Naive Bayes0.88110.11890.5283020.8949770.664407
1Decision Tree0.96580.03420.9175260.8127850.861985
2SVM0.98380.01620.9948450.8812790.934625
3TFIDF Naive Bayes0.87870.12130.5235460.8630140.651724
4TFIDF Decision Tree0.96040.03960.8963730.7899540.839806
5TFIDF SVM0.97840.02160.9945950.8401830.910891
\n", - "
" - ], - "text/plain": [ - " Classifier Accuracy Error Precison Recall F1_Measure\n", - "0 Naive Bayes 0.8811 0.1189 0.528302 0.894977 0.664407\n", - "1 Decision Tree 0.9658 0.0342 0.917526 0.812785 0.861985\n", - "2 SVM 0.9838 0.0162 0.994845 0.881279 0.934625\n", - "3 TFIDF Naive Bayes 0.8787 0.1213 0.523546 0.863014 0.651724\n", - "4 TFIDF Decision Tree 0.9604 0.0396 0.896373 0.789954 0.839806\n", - "5 TFIDF SVM 0.9784 0.0216 0.994595 0.840183 0.910891" - ] - }, - "metadata": {}, - "execution_count": 48 - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "icAEU9jvPrj4", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 396 - }, - "outputId": "d0543e1a-fe1f-4f55-c1e1-8be4ba12f8e0" - }, - "source": [ - "plt.figure(figsize=(40,15))\n", - "plt.subplot(2, 3, 1)\n", - "s=sns.barplot(x=data1.Accuracy,y=data1.Classifier)\n", - "plt.title('Accuracy',fontsize = 21, fontweight ='bold')\n", - "plt.xlabel(\"Accuracy\",fontsize = 12, fontweight ='bold')\n", - "plt.xlim(0.8,1.0)\n", - "plt.grid(axis='x')\n", - "plt.subplot(2, 3, 2)\n", - "s=sns.barplot(x=data1.Error,y=data1.Classifier)\n", - "plt.title('Error',fontsize = 21, fontweight ='bold')\n", - "plt.xlabel(\"Error\",fontsize = 12, fontweight ='bold')\n", - "plt.xlim(0.0,0.2)\n", - "plt.grid(axis='x')\n", - "plt.subplot(2, 3, 3)\n", - "s=sns.barplot(x=data1.Precison,y=data1.Classifier)\n", - "plt.title('Precison',fontsize = 21, fontweight ='bold')\n", - "plt.xlabel(\"Precison\",fontsize = 12, fontweight ='bold')\n", - "plt.xlim(0.5,1.0)\n", - "plt.grid(axis='x')\n", - "plt.subplot(2, 3, 4)\n", - "s=sns.barplot(x=data1.Recall,y=data1.Classifier)\n", - "plt.title('Recall',fontsize = 21, fontweight ='bold')\n", - "plt.xlabel(\"Recall\",fontsize = 12, fontweight ='bold')\n", - "plt.xlim(0.7,1.0)\n", - "plt.grid(axis='x')\n", - "plt.subplot(2, 3, 6)\n", - "s=sns.barplot(x=data1.F1_Measure,y=data1.Classifier)\n", - "plt.title('F1 Score',fontsize = 21, fontweight ='bold')\n", - "plt.xlabel(\"F1 Score\",fontsize = 12, fontweight ='bold')\n", - "plt.xlim(0.6,1.0)\n", - "plt.grid(axis='x')" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - } - } - ] - } - ] -} \ No newline at end of file