Upload _677_spam_email_classification.ipynb

_677_spam_email_classification.ipynb

@@ -0,0 +1,441 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "id": "oSNBE_Cx9pyl"
+      },
+      "outputs": [],
+      "source": [
+        "import pandas as pd\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "from sklearn.feature_extraction.text import TfidfVectorizer\n",
+        "from sklearn.preprocessing import StandardScaler\n",
+        "from sklearn.ensemble import RandomForestClassifier\n",
+        "from sklearn.metrics import classification_report, confusion_matrix\n",
+        "from imblearn.over_sampling import SMOTE\n",
+        "\n",
+        "import re\n",
+        "import nltk\n",
+        "from nltk.corpus import stopwords\n",
+        "from nltk.tokenize import word_tokenize\n",
+        "from nltk.stem import WordNetLemmatizer\n",
+        "\n",
+        "seed=628"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "nltk.download('punkt')\n",
+        "nltk.download('stopwords')\n",
+        "nltk.download('wordnet')\n",
+        "\n",
+        "lemmatizer = WordNetLemmatizer()\n",
+        "stop_words = set(stopwords.words('english'))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "5XchhmEm-yMt",
+        "outputId": "f69539de-eacf-434f-a9b9-c61a45ecaf11"
+      },
+      "execution_count": 6,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "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"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def load_and_split_data(file_path, test_size=0.2, random_state=seed):\n",
+        "  df = pd.read_csv(file_path)\n",
+        "  X_train, X_test, y_train, y_test = train_test_split(df[['text']], df['spam'], stratify=df['spam'], random_state=random_state)\n",
+        "  return X_train, X_test, y_train, y_test"
+      ],
+      "metadata": {
+        "id": "Ykhpvrye--Fv"
+      },
+      "execution_count": 7,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def preprocess_text(text):\n",
+        "  text = text.lower()\n",
+        "  text = re.sub(r'[^a-zA-Z\\s]', '', text)\n",
+        "  tokens = word_tokenize(text)\n",
+        "\n",
+        "  tokens = [token for token in tokens if token not in stop_words]\n",
+        "  return ' '.join(tokens)\n",
+        "\n",
+        "def extract_text_features(text):\n",
+        "  return {\n",
+        "      'text_length': len(text),\n",
+        "      'word_count': len(text.split()),\n",
+        "      'unique_words': len(set(text.split())),\n",
+        "      'caps_ratio': sum(1 for c in text if c.isupper()) / len(text) if len(text) > 0 else 0,\n",
+        "  }\n",
+        "\n",
+        "  def prepare_features(texts, is_training=True):\n",
+        "    print(f\"Preprocessing text data...\")\n",
+        "    preprocessed_texts = texts['text'].apply(preprocess_text)\n",
+        "    features = pd.json_normalize(preprocessed_texts.apply(extract_text_features))\n",
+        "\n",
+        "\n",
+        "    if is_training:\n",
+        "      q_low = features['text_length'].quantile(0.01)\n",
+        "      q_high = features['text_length'].quantile(0.99)\n",
+        "      features['text_length'] = features['text_length'].clip(q_low, q_high)\n",
+        "\n",
+        "      return preprocessed_texts, features"
+      ],
+      "metadata": {
+        "id": "01PRLOZyBA2Z"
+      },
+      "execution_count": 23,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def create_model(X_test_train, X_features_train, y_train, max_features=5000):\n",
+        "  vectorizer = TfidfVectorizer(max_features=max_features)\n",
+        "  X_text_vectorized = vectorizer.fit_transform(X_text_train)\n",
+        "\n",
+        "  scaler = StandardScaler()\n",
+        "  X_features_scaled = scaler.fit_transform(X_features_train)\n",
+        "  X_combined = np.hstack((X_text_vectorized.toarray(), X_features_scaled))\n",
+        "\n",
+        "  smote = SMOTE(random_state=seed)\n",
+        "def create_model(X_test_train, X_features_train, y_train, max_features=5000):\n",
+        "  vectorizer = TfidfVectorizer(max_features=max_features)\n",
+        "  X_text_vectorized = vectorizer.fit_transform(X_test_train)\n",
+        "\n",
+        "  scaler = StandardScaler()\n",
+        "  X_features_scaled = scaler.fit_transform(X_features_train)\n",
+        "  X_combined = np.hstack((X_text_vectorized.toarray(), X_features_scaled))\n",
+        "\n",
+        "  smote = SMOTE(random_state=seed)\n",
+        "  X_resampled, y_resampled = smote.fit_resample(X_combined, y_train)\n",
+        "\n",
+        "  model = RandomForestClassifier(n_estimators=100, max_depth=20, random_state=seed, n_jobs=-1)\n",
+        "  model.fit(X_resampled, y_resampled)\n",
+        "\n",
+        "  return model, vectorizer, scaler\n",
+        "\n",
+        "def evaluate_model(model, vectorizer, scaler, X_text_test, X_features_test, y_test):\n",
+        "  X_test_vectorized = vectorizer.transform(X_text_test)\n",
+        "  X_features_scaled = scaler.transform(X_features_test)\n",
+        "  X_combined = np.hstack((X_test_vectorized.toarray(), X_features_scaled))\n",
+        "  y_pred = model.predict(X_combined)\n",
+        "\n",
+        "def create_model(X_test_train, X_features_train, y_train, max_features=5000):\n",
+        "  vectorizer = TfidfVectorizer(max_features=max_features)\n",
+        "  X_text_vectorized = vectorizer.fit_transform(X_test_train)\n",
+        "\n",
+        "  scaler = StandardScaler()\n",
+        "  X_features_scaled = scaler.fit_transform(X_features_train)\n",
+        "  X_combined = np.hstack((X_text_vectorized.toarray(), X_features_scaled))\n",
+        "\n",
+        "  smote = SMOTE(random_state=seed)\n",
+        "  X_resampled, y_resampled = smote.fit_resample(X_combined, y_train)\n",
+        "\n",
+        "  model = RandomForestClassifier(n_estimators=100, max_depth=20, random_state=seed, n_jobs=-1)\n",
+        "  model.fit(X_resampled, y_resampled)\n",
+        "\n",
+        "  return model, vectorizer, scaler\n",
+        "\n",
+        "def evaluate_model(model, vectorizer, scaler, X_text_test, X_features_test, y_test):\n",
+        "  X_test_vectorized = vectorizer.transform(X_text_test)\n",
+        "  X_features_scaled = scaler.transform(X_features_test)\n",
+        "  X_combined = np.hstack((X_test_vectorized.toarray(), X_features_scaled))\n",
+        "  y_pred = model.predict(X_combined)\n",
+        "\n",
+        "  print(f\"\\nClassification Report:\\n\")\n",
+        "  print(classification_report(y_test, y_pred))\n",
+        "\n",
+        "  plt.figure(figsize=(8, 6))\n",
+        "  cm = confusion_matrix(y_test, y_pred)\n",
+        "  sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')\n",
+        "  plt.title('Confusion Matrix')\n",
+        "  plt.ylabel('True Label')\n",
+        "  plt.xlabel('Predicted Label')\n",
+        "  plt.show()\n",
+        "\n",
+        "  return y_pred"
+      ],
+      "metadata": {
+        "id": "vkc4iDKQCcvV"
+      },
+      "execution_count": 24,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "X_train, X_test, y_train, y_test = load_and_split_data('/content/emails.csv')\n",
+        "\n",
+        "X_text_train, X_features_train = prepare_features(X_train, is_training=True)\n",
+        "X_text_test, X_features_test = prepare_features(X_test, is_training=False)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 245
+        },
+        "id": "4COAethoEwFU",
+        "outputId": "a6d8e9be-b920-4bda-fc6f-41d0ef98f2d9"
+      },
+      "execution_count": 26,
+      "outputs": [
+        {
+          "output_type": "error",
+          "ename": "NameError",
+          "evalue": "name 'prepare_features' is not defined",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-26-f11781645934>\u001b[0m in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mload_and_split_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'/content/emails.csv'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mX_text_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX_features_train\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprepare_features\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_training\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0mX_text_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX_features_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mprepare_features\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_training\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mNameError\u001b[0m: name 'prepare_features' is not defined"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import pandas as pd\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "from sklearn.feature_extraction.text import TfidfVectorizer\n",
+        "from sklearn.preprocessing import StandardScaler\n",
+        "from sklearn.ensemble import RandomForestClassifier\n",
+        "from sklearn.metrics import classification_report, confusion_matrix\n",
+        "from imblearn.over_sampling import SMOTE\n",
+        "\n",
+        "!pip install nltk\n",
+        "import re\n",
+        "import nltk\n",
+        "from nltk.corpus import stopwords\n",
+        "from nltk.tokenize import word_tokenize\n",
+        "from nltk.stem import WordNetLemmatizer\n",
+        "\n",
+        "seed=628\n",
+        "\n",
+        "\n",
+        "nltk.download('punkt_tab')\n",
+        "nltk.download('stopwords')\n",
+        "nltk.download('wordnet')\n",
+        "\n",
+        "lemmatizer = WordNetLemmatizer()\n",
+        "stop_words = set(stopwords.words('english'))\n",
+        "\n",
+        "def load_and_split_data(file_path, test_size=0.2, random_state=seed):\n",
+        "  df = pd.read_csv(file_path)\n",
+        "  X_train, X_test, y_train, y_test = train_test_split(df[['text']], df['spam'], stratify=df['spam'], random_state=random_state)\n",
+        "  return X_train, X_test, y_train, y_test\n",
+        "\n",
+        "def preprocess_text(text):\n",
+        "  text = text.lower()\n",
+        "  text = re.sub(r'[^a-zA-Z\\s]', '', text)\n",
+        "  tokens = word_tokenize(text)\n",
+        "\n",
+        "  tokens = [token for token in tokens if token not in stop_words]\n",
+        "  return ' '.join(tokens)\n",
+        "\n",
+        "def extract_text_features(text):\n",
+        "  return {\n",
+        "      'text_length': len(text),\n",
+        "      'word_count': len(text.split()),\n",
+        "      'unique_words': len(set(text.split())),\n",
+        "      'caps_ratio': sum(1 for c in text if c.isupper()) / len(text) if len(text) > 0 else 0,\n",
+        "  }\n",
+        "\n",
+        "# Move prepare_features outside of extract_text_features\n",
+        "def prepare_features(texts, is_training=True):\n",
+        "  print(f\"Preprocessing text data...\")\n",
+        "  preprocessed_texts = texts['text'].apply(preprocess_text)\n",
+        "  features = pd.json_normalize(preprocessed_texts.apply(extract_text_features))\n",
+        "\n",
+        "  if is_training:\n",
+        "    q_low = features['text_length'].quantile(0.01)\n",
+        "    q_high = features['text_length'].quantile(0.99)\n",
+        "    features['text_length'] = features['text_length'].clip(q_low, q_high)\n",
+        "\n",
+        "  return preprocessed_texts, features\n",
+        "\n",
+        "def create_model(X_test_train, X_features_train, y_train, max_features=5000):\n",
+        "  vectorizer = TfidfVectorizer(max_features=max_features)\n",
+        "  X_text_vectorized = vectorizer.fit_transform(X_test_train)\n",
+        "\n",
+        "  scaler = StandardScaler()\n",
+        "  X_features_scaled = scaler.fit_transform(X_features_train)\n",
+        "  X_combined = np.hstack((X_text_vectorized.toarray(), X_features_scaled))\n",
+        "\n",
+        "  smote = SMOTE(random_state=seed)\n",
+        "  X_resampled, y_resampled = smote.fit_resample(X_combined, y_train)\n",
+        "\n",
+        "  model = RandomForestClassifier(n_estimators=100, max_depth=20, random_state=seed, n_jobs=-1)\n",
+        "  model.fit(X_resampled, y_resampled)\n",
+        "\n",
+        "  return model, vectorizer, scaler\n",
+        "\n",
+        "def evaluate_model(model, vectorizer, scaler, X_text_test, X_features_test, y_test):\n",
+        "  X_test_vectorized = vectorizer.transform(X_text_test)\n",
+        "  X_features_scaled = scaler.transform(X_features_test)\n",
+        "  X_combined = np.hstack((X_test_vectorized.toarray(), X_features_scaled))\n",
+        "  y_pred = model.predict(X_combined)\n",
+        "\n",
+        "  print(f\"\\nClassification Report:\\n\")\n",
+        "  print(classification_report(y_test, y_pred))\n",
+        "\n",
+        "  plt.figure(figsize=(8, 6))\n",
+        "  cm = confusion_matrix(y_test, y_pred)\n",
+        "  sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')\n",
+        "  plt.title('Confusion Matrix')\n",
+        "  plt.ylabel('True Label')\n",
+        "  plt.xlabel('Predicted Label')\n",
+        "  plt.show()\n",
+        "\n",
+        "  return y_pred\n",
+        "\n",
+        "X_train, X_test, y_train, y_test = load_and_split_data('/content/emails.csv')\n",
+        "\n",
+        "X_text_train, X_features_train = prepare_features(X_train, is_training=True)\n",
+        "X_text_test, X_features_test = prepare_features(X_test, is_training=False) #Fixed typo here, should be X_text_test"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "NkustJoBRevp",
+        "outputId": "4629f489-c9fc-42fb-914b-64028f7981a8"
+      },
+      "execution_count": 34,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Requirement already satisfied: nltk in /usr/local/lib/python3.10/dist-packages (3.9.1)\n",
+            "Requirement already satisfied: click in /usr/local/lib/python3.10/dist-packages (from nltk) (8.1.8)\n",
+            "Requirement already satisfied: joblib in /usr/local/lib/python3.10/dist-packages (from nltk) (1.4.2)\n",
+            "Requirement already satisfied: regex>=2021.8.3 in /usr/local/lib/python3.10/dist-packages (from nltk) (2024.11.6)\n",
+            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from nltk) (4.67.1)\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "[nltk_data] Downloading package punkt_tab to /root/nltk_data...\n",
+            "[nltk_data]   Package punkt_tab is already up-to-date!\n",
+            "[nltk_data] Downloading package stopwords to /root/nltk_data...\n",
+            "[nltk_data]   Package stopwords is already up-to-date!\n",
+            "[nltk_data] Downloading package wordnet to /root/nltk_data...\n",
+            "[nltk_data]   Package wordnet is already up-to-date!\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Preprocessing text data...\n",
+            "Preprocessing text data...\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "model, vectorizer, scaler = create_model(X_text_train, X_features_train, y_train)"
+      ],
+      "metadata": {
+        "id": "bXiw6TyKSGF0"
+      },
+      "execution_count": 35,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "predictions = evaluate_model(model, vectorizer, scaler, X_text_test, X_features_test, y_test)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 748
+        },
+        "id": "DOhLUKowSQFV",
+        "outputId": "44e6dd7c-6dc7-4305-b3d7-1fae09ef52e6"
+      },
+      "execution_count": 36,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "Classification Report:\n",
+            "\n",
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "           0       1.00      0.97      0.98      1090\n",
+            "           1       0.92      0.99      0.95       342\n",
+            "\n",
+            "    accuracy                           0.98      1432\n",
+            "   macro avg       0.96      0.98      0.97      1432\n",
+            "weighted avg       0.98      0.98      0.98      1432\n",
+            "\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 800x600 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    }
+  ]
+}