text minning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b1e2dd3e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: nltk in c:\\users\\91630\\anaconda3\\lib\\site-packages (3.7)\n",
      "Requirement already satisfied: joblib in c:\\users\\91630\\anaconda3\\lib\\site-packages (from nltk) (1.1.0)\n",
      "Requirement already satisfied: regex>=2021.8.3 in c:\\users\\91630\\anaconda3\\lib\\site-packages (from nltk) (2022.7.9)\n",
      "Requirement already satisfied: click in c:\\users\\91630\\anaconda3\\lib\\site-packages (from nltk) (8.0.4)\n",
      "Requirement already satisfied: tqdm in c:\\users\\91630\\anaconda3\\lib\\site-packages (from nltk) (4.64.1)\n",
      "Requirement already satisfied: colorama in c:\\users\\91630\\anaconda3\\lib\\site-packages (from click->nltk) (0.4.5)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install nltk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "05dc4fa6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "showing info https://raw.githubusercontent.com/nltk/nltk_data/gh-pages/index.xml\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import nltk\n",
    "nltk.download()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b6e8f65c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package punkt to\n",
      "[nltk_data]     C:\\Users\\91630\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Unzipping tokenizers\\punkt.zip.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import nltk\n",
    "nltk.download('punkt')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7620276",
   "metadata": {},
   "source": [
    "# Stemming Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60b10160",
   "metadata": {},
   "source": [
    "Snowball Stemmer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "76884287",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Natural becomes natur\n",
      "language becomes languag\n",
      "processing becomes process\n",
      "is becomes is\n",
      "a becomes a\n",
      "field becomes field\n",
      "of becomes of\n",
      "artificial becomes artifici\n",
      "intelligence becomes intellig\n",
      "that becomes that\n",
      "focuses becomes focus\n",
      "on becomes on\n",
      "the becomes the\n",
      "interaction becomes interact\n",
      "between becomes between\n",
      "computers becomes comput\n",
      "and becomes and\n",
      "humans becomes human\n",
      "using becomes use\n",
      "natural becomes natur\n",
      "language becomes languag\n",
      ". becomes .\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package punkt to\n",
      "[nltk_data]     C:\\Users\\91630\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n"
     ]
    }
   ],
   "source": [
    "import nltk\n",
    "from nltk.stem import SnowballStemmer\n",
    "\n",
    "nltk.download('punkt')\n",
    "\n",
    "def snowball_stemming(paragraph):\n",
    "    stemmer = SnowballStemmer(\"english\")\n",
    "    words = nltk.word_tokenize(paragraph)\n",
    "    for word in words:\n",
    "        stemmed_word = stemmer.stem(word)\n",
    "        print(f\"{word} becomes {stemmed_word}\")\n",
    "\n",
    "p1 = \"Natural language processing is a field of artificial intelligence that focuses on the interaction between computers and humans using natural language.\"\n",
    "\n",
    "snowball_stemming(p1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c93cfae3",
   "metadata": {},
   "source": [
    "PorterStemmer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "207212cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Natural becomes natur\n",
      "language becomes languag\n",
      "processing becomes process\n",
      "is becomes is\n",
      "a becomes a\n",
      "field becomes field\n",
      "of becomes of\n",
      "artificial becomes artifici\n",
      "intelligence becomes intellig\n",
      "that becomes that\n",
      "focuses becomes focus\n",
      "on becomes on\n",
      "the becomes the\n",
      "interaction becomes interact\n",
      "between becomes between\n",
      "computers becomes comput\n",
      "and becomes and\n",
      "humans becomes human\n",
      "using becomes use\n",
      "natural becomes natur\n",
      "language becomes languag\n",
      ". becomes .\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package punkt to\n",
      "[nltk_data]     C:\\Users\\91630\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n"
     ]
    }
   ],
   "source": [
    "import nltk\n",
    "from nltk.stem import PorterStemmer\n",
    "\n",
    "nltk.download('punkt')\n",
    "\n",
    "def porter_stemming(paragraph):\n",
    "    stemmer = PorterStemmer()\n",
    "    words = nltk.word_tokenize(paragraph)\n",
    "    for word in words:\n",
    "        stemmed_word = stemmer.stem(word)\n",
    "        print(f\"{word} becomes {stemmed_word}\")\n",
    "\n",
    "p1 = \"Natural language processing is a field of artificial intelligence that focuses on the interaction between computers and humans using natural language.\"\n",
    "\n",
    "porter_stemming(p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8221efeb",
   "metadata": {},
   "source": [
    "LancasterStemmer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "55f1a368",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Natural becomes nat\n",
      "language becomes langu\n",
      "processing becomes process\n",
      "is becomes is\n",
      "a becomes a\n",
      "field becomes field\n",
      "of becomes of\n",
      "artificial becomes art\n",
      "intelligence becomes intellig\n",
      "that becomes that\n",
      "focuses becomes focus\n",
      "on becomes on\n",
      "the becomes the\n",
      "interaction becomes interact\n",
      "between becomes between\n",
      "computers becomes comput\n",
      "and becomes and\n",
      "humans becomes hum\n",
      "using becomes us\n",
      "natural becomes nat\n",
      "language becomes langu\n",
      ". becomes .\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package punkt to\n",
      "[nltk_data]     C:\\Users\\91630\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n"
     ]
    }
   ],
   "source": [
    "import nltk\n",
    "from nltk.stem import LancasterStemmer\n",
    "\n",
    "nltk.download('punkt')\n",
    "\n",
    "def lancaster_stemming(paragraph):\n",
    "    stemmer = LancasterStemmer()\n",
    "    words = nltk.word_tokenize(paragraph)\n",
    "    for word in words:\n",
    "        stemmed_word = stemmer.stem(word)\n",
    "        print(f\"{word} becomes {stemmed_word}\")\n",
    "\n",
    "p1 = \"Natural language processing is a field of artificial intelligence that focuses on the interaction between computers and humans using natural language.\"\n",
    "\n",
    "lancaster_stemming(p1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "02ea846d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: scipy in c:\\users\\91630\\anaconda3\\lib\\site-packages (1.9.1)Note: you may need to restart the kernel to use updated packages.\n",
      "\n",
      "Requirement already satisfied: numpy<1.25.0,>=1.18.5 in c:\\users\\91630\\anaconda3\\lib\\site-packages (from scipy) (1.21.5)\n"
     ]
    }
   ],
   "source": [
    "pip  install scipy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "f2f456fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package stopwords to\n",
      "[nltk_data]     C:\\Users\\91630\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Unzipping corpora\\stopwords.zip.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nltk.download('stopwords')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c92f778",
   "metadata": {},
   "source": [
    "# Logistic Regression(Snowball Stemming) Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "69484821",
   "metadata": {},
   "outputs": [],
   "source": [
    "import nltk\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import accuracy_score, classification_report\n",
    "from nltk.stem import SnowballStemmer\n",
    "from nltk.corpus import twitter_samples\n",
    "from nltk.tokenize import word_tokenize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "32d468b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package twitter_samples to\n",
      "[nltk_data]     C:\\Users\\91630\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package twitter_samples is already up-to-date!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nltk.download('twitter_samples')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "39bac963",
   "metadata": {},
   "outputs": [],
   "source": [
    "positive_tweets = twitter_samples.strings('positive_tweets.json')\n",
    "negative_tweets = twitter_samples.strings('negative_tweets.json')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1dd248a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_positive = pd.DataFrame({\"Sentiment\": \"Positive\", \"Tweet\": positive_tweets})\n",
    "df_negative = pd.DataFrame({\"Sentiment\": \"Negative\", \"Tweet\": negative_tweets})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "1f3f2fb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.concat([df_positive, df_negative])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b2095ced",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Sentiment                                              Tweet\n",
      "0  Positive  #FollowFriday @France_Inte @PKuchly57 @Milipol...\n",
      "1  Positive  @Lamb2ja Hey James! How odd :/ Please call our...\n",
      "2  Positive  @DespiteOfficial we had a listen last night :)...\n",
      "3  Positive                               @97sides CONGRATS :)\n",
      "4  Positive  yeaaaah yippppy!!!  my accnt verified rqst has...\n",
      "5  Positive  @BhaktisBanter @PallaviRuhail This one is irre...\n",
      "6  Positive  We don't like to keep our lovely customers wai...\n",
      "7  Positive  @Impatientraider On second thought, there’s ju...\n",
      "8  Positive            Jgh , but we have to go to Bayan :D bye\n",
      "9  Positive  As an act of mischievousness, am calling the E...\n"
     ]
    }
   ],
   "source": [
    "print(df.head(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "1fc57f93",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package stopwords to\n",
      "[nltk_data]     C:\\Users\\91630\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nltk.download('stopwords')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "517f5da5",
   "metadata": {},
   "outputs": [],
   "source": [
    "tweets = positive_tweets + negative_tweets\n",
    "labels = np.append(np.ones(len(positive_tweets)), np.zeros(len(negative_tweets)))\n",
    "df = pd.DataFrame({'tweets': tweets, 'labels': labels}).sample(frac=1, random_state=42).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "304f01da",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Snowball Stemming and Text Preprocessing\n",
    "stemmer = SnowballStemmer('english')\n",
    "stop_words = set(stopwords.words('english'))\n",
    "\n",
    "def preprocess_text(text):\n",
    "    tokens = word_tokenize(text)\n",
    "    stemmed_tokens = [stemmer.stem(token) for token in tokens if token.isalnum()]\n",
    "    return ' '.join(stemmed_tokens)\n",
    "\n",
    "df['processed_tweets'] = df['tweets'].apply(preprocess_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "f6237982",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Processed Tweets:\n",
      "0     i love you how but you taecyeon2pm8 did you fe...\n",
      "1        mayusushita sonalp2591 armansushita8 thank guy\n",
      "2       your love o lord is better than life lt 3 https\n",
      "3     yasminyasir96 yeah but it will be better if we...\n",
      "4     ok good night i wish troy was ugli and i met h...\n",
      "5     scottybev i not surpris that sound hellish whi...\n",
      "6     dri hot scorch summer ff infocffm mediationmk ...\n",
      "7                                hanbin sad pray for me\n",
      "8                                         popol day too\n",
      "9     my song of the week is ducktail surreal exposu...\n",
      "10        i have no interest in speak to you ever again\n",
      "11    caylahhhh lmfao serious i ca rememb if i did h...\n",
      "12    should have taken a pic befor mrs wong confisc...\n",
      "13      kianeganwl aarww i wish i could be there too xx\n",
      "14    theprincesszooz but i see what you go at yes s...\n",
      "Name: processed_tweets, dtype: object\n"
     ]
    }
   ],
   "source": [
    "print(\"\\nProcessed Tweets:\")\n",
    "print(df['processed_tweets'].head(15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "edace141",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(df['processed_tweets'], df['labels'], test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "26af1396",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Sizes of Training and Testing Sets:\n",
      "Training set size: 8000\n",
      "Testing set size: 2000\n"
     ]
    }
   ],
   "source": [
    "print(\"\\nSizes of Training and Testing Sets:\")\n",
    "print(f\"Training set size: {len(X_train)}\")\n",
    "print(f\"Testing set size: {len(X_test)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "e37ea203",
   "metadata": {},
   "outputs": [],
   "source": [
    "vectorizer = TfidfVectorizer(max_features=5000)\n",
    "X_train_tfidf = vectorizer.fit_transform(X_train)\n",
    "X_test_tfidf = vectorizer.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "3b04abe5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Shape of TF-IDF Matrices:\n",
      "Training set shape: (8000, 5000)\n",
      "Testing set shape: (2000, 5000)\n"
     ]
    }
   ],
   "source": [
    "print(\"\\nShape of TF-IDF Matrices:\")\n",
    "print(f\"Training set shape: {X_train_tfidf.shape}\")\n",
    "print(f\"Testing set shape: {X_test_tfidf.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "35a65c3f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(random_state=42)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = LogisticRegression(random_state=42)\n",
    "model.fit(X_train_tfidf, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "9435c67f",
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = model.predict(X_test_tfidf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "9a9b36b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "accuracy = accuracy_score(y_test, predictions)\n",
    "report = classification_report(y_test, predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "766a44e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.7735\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(f\"Accuracy: {accuracy:.4f}\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "23857402",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.75      0.81      0.78       987\n",
      "         1.0       0.80      0.74      0.77      1013\n",
      "\n",
      "    accuracy                           0.77      2000\n",
      "   macro avg       0.78      0.77      0.77      2000\n",
      "weighted avg       0.78      0.77      0.77      2000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"Classification Report:\")\n",
    "print(report)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "ae47e063",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import confusion_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "96a18d54",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "conf_mat = confusion_matrix(y_test, predictions)\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(conf_mat, annot=True, fmt='d', cmap='Blues', xticklabels=['Negative', 'Positive'], yticklabels=['Negative', 'Positive'])\n",
    "plt.title('Confusion Matrix (Logistic Regression)')\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('Actual')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29ca46da",
   "metadata": {},
   "source": [
    "# Naive Bayes (Snowball Stemming) Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "49d48e45",
   "metadata": {},
   "outputs": [],
   "source": [
    "import nltk\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.metrics import accuracy_score, classification_report\n",
    "from nltk.stem import SnowballStemmer\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.tokenize import word_tokenize\n",
    "from nltk import FreqDist\n",
    "from nltk.corpus import twitter_samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b3df43c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package twitter_samples to\n",
      "[nltk_data]     C:\\Users\\91630\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package twitter_samples is already up-to-date!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nltk.download('twitter_samples')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "85db4ded",
   "metadata": {},
   "outputs": [],
   "source": [
    "positive_tweets = twitter_samples.strings('positive_tweets.json')\n",
    "negative_tweets = twitter_samples.strings('negative_tweets.json')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "73b8be5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "tweets = positive_tweets + negative_tweets\n",
    "labels = np.append(np.ones(len(positive_tweets)), np.zeros(len(negative_tweets)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7d248c48",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame({'tweets': tweets, 'labels': labels})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e305d7be",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.sample(frac=1, random_state=42).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c53cc6b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "stemmer = SnowballStemmer('english')\n",
    "stop_words = set(stopwords.words('english'))\n",
    "\n",
    "def preprocess_text(text):\n",
    "    tokens = word_tokenize(text)\n",
    "    stemmed_tokens = [stemmer.stem(token) for token in tokens if token.isalnum()]\n",
    "    return ' '.join(stemmed_tokens)\n",
    "\n",
    "df['processed_tweets'] = df['tweets'].apply(preprocess_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "38bd14c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Processed Tweets:\n",
      "0     i love you how but you taecyeon2pm8 did you fe...\n",
      "1        mayusushita sonalp2591 armansushita8 thank guy\n",
      "2       your love o lord is better than life lt 3 https\n",
      "3     yasminyasir96 yeah but it will be better if we...\n",
      "4     ok good night i wish troy was ugli and i met h...\n",
      "5     scottybev i not surpris that sound hellish whi...\n",
      "6     dri hot scorch summer ff infocffm mediationmk ...\n",
      "7                                hanbin sad pray for me\n",
      "8                                         popol day too\n",
      "9     my song of the week is ducktail surreal exposu...\n",
      "10        i have no interest in speak to you ever again\n",
      "11    caylahhhh lmfao serious i ca rememb if i did h...\n",
      "12    should have taken a pic befor mrs wong confisc...\n",
      "13      kianeganwl aarww i wish i could be there too xx\n",
      "14    theprincesszooz but i see what you go at yes s...\n",
      "Name: processed_tweets, dtype: object\n"
     ]
    }
   ],
   "source": [
    "print(\"\\nProcessed Tweets:\")\n",
    "print(df['processed_tweets'].head(15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "74d181ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(df['processed_tweets'], df['labels'], test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e82ec9d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "vectorizer = TfidfVectorizer(max_features=5000)\n",
    "X_train_tfidf = vectorizer.fit_transform(X_train)\n",
    "X_test_tfidf = vectorizer.transform(X_test)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b0af2b77",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MultinomialNB()"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nb_model = MultinomialNB()\n",
    "nb_model.fit(X_train_tfidf, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "94833562",
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_predictions = nb_model.predict(X_test_tfidf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "309dfe1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_accuracy = accuracy_score(y_test, nb_predictions)\n",
    "nb_report = classification_report(y_test, nb_predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b746dc99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy (Naive Bayes): 0.7610\n",
      "\n",
      "Classification Report (Naive Bayes):\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.73      0.81      0.77       987\n",
      "         1.0       0.80      0.71      0.75      1013\n",
      "\n",
      "    accuracy                           0.76      2000\n",
      "   macro avg       0.76      0.76      0.76      2000\n",
      "weighted avg       0.76      0.76      0.76      2000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(f\"Accuracy (Naive Bayes): {nb_accuracy:.4f}\\n\")\n",
    "print(\"Classification Report (Naive Bayes):\")\n",
    "print(nb_report)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "bd0de0ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import confusion_matrix, roc_curve, auc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "eac37245",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#confusion matrix\n",
    "conf_mat_nb = confusion_matrix(y_test, nb_predictions)\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(conf_mat_nb, annot=True, fmt='d', cmap='Blues', xticklabels=['Negative', 'Positive'], yticklabels=['Negative', 'Positive'])\n",
    "plt.title('Confusion Matrix (Naive Bayes)')\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('Actual')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c98c725e",
   "metadata": {},
   "source": [
    "# Random Forest Classifier(Snowball Stemming) Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "ccb7cc63",
   "metadata": {},
   "outputs": [],
   "source": [
    "import nltk\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import accuracy_score, classification_report\n",
    "from nltk.stem import SnowballStemmer\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.tokenize import word_tokenize\n",
    "from nltk import FreqDist\n",
    "from nltk.corpus import twitter_samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "ce1d0281",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package twitter_samples to\n",
      "[nltk_data]     C:\\Users\\91630\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package twitter_samples is already up-to-date!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nltk.download('twitter_samples')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "8297275f",
   "metadata": {},
   "outputs": [],
   "source": [
    "positive_tweets = twitter_samples.strings('positive_tweets.json')\n",
    "negative_tweets = twitter_samples.strings('negative_tweets.json')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "b5db84c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "tweets = positive_tweets + negative_tweets\n",
    "labels = np.append(np.ones(len(positive_tweets)), np.zeros(len(negative_tweets)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "af135891",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame({'tweets': tweets, 'labels': labels})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "0e2c2c00",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.sample(frac=1, random_state=42).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "65fd08c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "stemmer = SnowballStemmer('english')\n",
    "stop_words = set(stopwords.words('english'))\n",
    "\n",
    "def preprocess_text(text):\n",
    "    tokens = word_tokenize(text)\n",
    "    stemmed_tokens = [stemmer.stem(token) for token in tokens if token.isalnum()]\n",
    "    return ' '.join(stemmed_tokens)\n",
    "\n",
    "df['processed_tweets'] = df['tweets'].apply(preprocess_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "87a9469b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Processed Tweets:\n",
      "0     i love you how but you taecyeon2pm8 did you fe...\n",
      "1        mayusushita sonalp2591 armansushita8 thank guy\n",
      "2       your love o lord is better than life lt 3 https\n",
      "3     yasminyasir96 yeah but it will be better if we...\n",
      "4     ok good night i wish troy was ugli and i met h...\n",
      "5     scottybev i not surpris that sound hellish whi...\n",
      "6     dri hot scorch summer ff infocffm mediationmk ...\n",
      "7                                hanbin sad pray for me\n",
      "8                                         popol day too\n",
      "9     my song of the week is ducktail surreal exposu...\n",
      "10        i have no interest in speak to you ever again\n",
      "11    caylahhhh lmfao serious i ca rememb if i did h...\n",
      "12    should have taken a pic befor mrs wong confisc...\n",
      "13      kianeganwl aarww i wish i could be there too xx\n",
      "14    theprincesszooz but i see what you go at yes s...\n",
      "Name: processed_tweets, dtype: object\n"
     ]
    }
   ],
   "source": [
    "print(\"\\nProcessed Tweets:\")\n",
    "print(df['processed_tweets'].head(15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "b142907f",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(df['processed_tweets'], df['labels'], test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "cf05ba4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "vectorizer = TfidfVectorizer(max_features=5000)\n",
    "X_train_tfidf = vectorizer.fit_transform(X_train)\n",
    "X_test_tfidf = vectorizer.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "54a10abe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(random_state=42)"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf_model = RandomForestClassifier(random_state=42)\n",
    "rf_model.fit(X_train_tfidf, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "9796e302",
   "metadata": {},
   "outputs": [],
   "source": [
    "rf_predictions = rf_model.predict(X_test_tfidf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "b09da2e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "rf_accuracy = accuracy_score(y_test, rf_predictions)\n",
    "rf_report = classification_report(y_test, rf_predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "9c8b73ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy (Random Forest): 0.7625\n",
      "\n",
      "Classification Report (Random Forest):\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.74      0.81      0.77       987\n",
      "         1.0       0.79      0.72      0.75      1013\n",
      "\n",
      "    accuracy                           0.76      2000\n",
      "   macro avg       0.77      0.76      0.76      2000\n",
      "weighted avg       0.77      0.76      0.76      2000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(f\"Accuracy (Random Forest): {rf_accuracy:.4f}\\n\")\n",
    "print(\"Classification Report (Random Forest):\")\n",
    "print(rf_report)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "3b25e3ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import confusion_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "fdabe679",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "conf_mat_rf = confusion_matrix(y_test, rf_predictions)\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(conf_mat_rf, annot=True, fmt='d', cmap='Blues', xticklabels=['Negative', 'Positive'], yticklabels=['Negative', 'Positive'])\n",
    "plt.title('Confusion Matrix (Random Forest)')\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('Actual')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d26ea937",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}