Upload 3 files

lstm_smsspam_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d2dcb7b3b2911e84a301b8a74f6ae4af3bfa7878cac61939e3269c02c1f5b8bc
+size 1775224

lstm_smsspam_model.ipynb

@@ -0,0 +1,413 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### SMS spam detection model using LSTM and glove embeddings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "from numpy import asarray\n",
+    "from numpy import zeros\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "import tensorflow as tf\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score\n",
+    "import pickle"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def getGloveEmbeddings(glovefolderpath):\n",
+    "    print(\"---------------------- Getting Glove Embeddings -------------------------\\n\")\n",
+    "    embeddings_dictionary = dict()\n",
+    "    glove_file = open(f\"{glovefolderpath}\", encoding=\"utf8\")\n",
+    "    for line in glove_file:\n",
+    "        records = line.split()\n",
+    "        word = records[0]\n",
+    "        vector_dimensions = asarray(records[1:], dtype='float32')\n",
+    "        embeddings_dictionary [word] = vector_dimensions\n",
+    "    glove_file.close()\n",
+    "    print(\"----------------------  -------------------------\\n\")\n",
+    "    return embeddings_dictionary"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "glove_folder=r'D:/STUDY/Sem3/deeplearning/glove.6B/glove.6B.50d.txt'\n",
+    "maxlen = 50"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset =  pd.read_csv('SMSSpamCollection.txt',sep='\\t',names=['label','message'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset['label'] = dataset['label'].map( {'spam': 1, 'ham': 0} )\n",
+    "X = dataset['message'].values\n",
+    "y = dataset['label'].values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokeniser = tf.keras.preprocessing.text.Tokenizer()\n",
+    "tokeniser.fit_on_texts(X_train)\n",
+    "\n",
+    "# Save the tokenizer using pickle\n",
+    "with open('lstm_smsspam_tokenizer.pickle', 'wb') as handle:\n",
+    "    pickle.dump(tokeniser, handle, protocol=pickle.HIGHEST_PROTOCOL)\n",
+    "\n",
+    "X_train = tokeniser.texts_to_sequences(X_train)\n",
+    "X_test = tokeniser.texts_to_sequences(X_test)\n",
+    "vocab_size = len(tokeniser.word_index) + 1\n",
+    "X_train = tf.keras.preprocessing.sequence.pad_sequences(X_train, padding='post', maxlen=maxlen)\n",
+    "X_test = tf.keras.preprocessing.sequence.pad_sequences(X_test, padding='post', maxlen=maxlen)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "---------------------- Getting Glove Embeddings -------------------------\n",
+      "\n",
+      "----------------------  -------------------------\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "embeddings_dictionary=getGloveEmbeddings(glove_folder)\n",
+    "embedding_matrix = zeros((vocab_size, maxlen))\n",
+    "for word, index in tokeniser.word_index.items():\n",
+    "    embedding_vector = embeddings_dictionary.get(word)\n",
+    "    if embedding_vector is not None:\n",
+    "        embedding_matrix[index] = embedding_vector"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model=tf.keras.models.Sequential([\n",
+    "   tf.keras.layers.Embedding(input_dim=vocab_size,output_dim= maxlen, weights=[embedding_matrix], input_length=maxlen , trainable=False),\n",
+    "   tf.keras.layers.LSTM(maxlen),\n",
+    "   tf.keras.layers.Dense(1, activation='sigmoid')\n",
+    "])  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"sequential\"\n",
+      "_________________________________________________________________\n",
+      " Layer (type)                Output Shape              Param #   \n",
+      "=================================================================\n",
+      " embedding (Embedding)       (None, 50, 50)            375100    \n",
+      "                                                                 \n",
+      " lstm (LSTM)                 (None, 50)                20200     \n",
+      "                                                                 \n",
+      " dense (Dense)               (None, 1)                 51        \n",
+      "                                                                 \n",
+      "=================================================================\n",
+      "Total params: 395351 (1.51 MB)\n",
+      "Trainable params: 20251 (79.11 KB)\n",
+      "Non-trainable params: 375100 (1.43 MB)\n",
+      "_________________________________________________________________\n",
+      "None\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(model.summary())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "early_stop = tf.keras.callbacks.EarlyStopping(monitor='accuracy', mode='min', patience=10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/50\n",
+      "98/98 [==============================] - 4s 18ms/step - loss: 0.4414 - accuracy: 0.8683 - val_loss: 0.4173 - val_accuracy: 0.8538\n",
+      "Epoch 2/50\n",
+      "98/98 [==============================] - 1s 12ms/step - loss: 0.3887 - accuracy: 0.8689 - val_loss: 0.4154 - val_accuracy: 0.8538\n",
+      "Epoch 3/50\n",
+      "98/98 [==============================] - 1s 12ms/step - loss: 0.3772 - accuracy: 0.8689 - val_loss: 0.2920 - val_accuracy: 0.8538\n",
+      "Epoch 4/50\n",
+      "98/98 [==============================] - 1s 12ms/step - loss: 0.1656 - accuracy: 0.9433 - val_loss: 0.1561 - val_accuracy: 0.9526\n",
+      "Epoch 5/50\n",
+      "98/98 [==============================] - 1s 12ms/step - loss: 0.1173 - accuracy: 0.9654 - val_loss: 0.1311 - val_accuracy: 0.9590\n",
+      "Epoch 6/50\n",
+      "98/98 [==============================] - 1s 12ms/step - loss: 0.1005 - accuracy: 0.9657 - val_loss: 0.1243 - val_accuracy: 0.9654\n",
+      "Epoch 7/50\n",
+      "98/98 [==============================] - 1s 12ms/step - loss: 0.0860 - accuracy: 0.9715 - val_loss: 0.1189 - val_accuracy: 0.9679\n",
+      "Epoch 8/50\n",
+      "98/98 [==============================] - 1s 12ms/step - loss: 0.0850 - accuracy: 0.9737 - val_loss: 0.1192 - val_accuracy: 0.9654\n",
+      "Epoch 9/50\n",
+      "98/98 [==============================] - 1s 12ms/step - loss: 0.0748 - accuracy: 0.9760 - val_loss: 0.1159 - val_accuracy: 0.9654\n",
+      "Epoch 10/50\n",
+      "98/98 [==============================] - 1s 12ms/step - loss: 0.0666 - accuracy: 0.9808 - val_loss: 0.1291 - val_accuracy: 0.9667\n",
+      "Epoch 11/50\n",
+      "98/98 [==============================] - 1s 12ms/step - loss: 0.0658 - accuracy: 0.9801 - val_loss: 0.1123 - val_accuracy: 0.9692\n"
+     ]
+    }
+   ],
+   "source": [
+    "history=model.fit(x=X_train,\n",
+    "        y=y_train,\n",
+    "        epochs=50,\n",
+    "        callbacks=[early_stop],\n",
+    "        validation_split=0.2\n",
+    "         )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def c_report(y_true, y_pred):\n",
+    "   print(\"Classification Report\")\n",
+    "   print(classification_report(y_true, y_pred))\n",
+    "   acc_sc = accuracy_score(y_true, y_pred)\n",
+    "   print(f\"Accuracy : {str(round(acc_sc,2)*100)}\")\n",
+    "   return acc_sc\n",
+    "def plot_confusion_matrix(y_true, y_pred):\n",
+    "   mtx = confusion_matrix(y_true, y_pred)\n",
+    "   sns.heatmap(mtx, annot=True, fmt='d', linewidths=.5, cmap=\"Blues\", cbar=False)\n",
+    "   plt.ylabel('True label')\n",
+    "   plt.xlabel('Predicted label')\n",
+    "   plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "53/53 [==============================] - 1s 4ms/step\n",
+      "Classification Report\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.97      1.00      0.99      1448\n",
+      "           1       0.97      0.83      0.90       224\n",
+      "\n",
+      "    accuracy                           0.97      1672\n",
+      "   macro avg       0.97      0.92      0.94      1672\n",
+      "weighted avg       0.97      0.97      0.97      1672\n",
+      "\n",
+      "Accuracy : 97.0\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "preds = (model.predict(X_test) > 0.5).astype(\"int32\")\n",
+    "c_report(y_test, preds)\n",
+    "plot_confusion_matrix(y_test, preds)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "d:\\STUDY\\Sem3\\deeplearning\\DLENV\\lib\\site-packages\\keras\\src\\engine\\training.py:3079: UserWarning: You are saving your model as an HDF5 file via `model.save()`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')`.\n",
+      "  saving_api.save_model(\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Save the model\n",
+    "model.save('lstm_smsspam_model.h5')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lstm_smsspam_model=tf.keras.models.load_model('lstm_smsspam_model.h5')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def predict_sms_sentiment(message):\n",
+    "    sequence = tokeniser.texts_to_sequences([message])\n",
+    "    sequence = tf.keras.preprocessing.sequence.pad_sequences(sequence, padding='post', maxlen=maxlen)\n",
+    "    prediction = lstm_smsspam_model.predict(sequence)[0, 0]\n",
+    "    if prediction > 0.5:\n",
+    "        return 'Spam'\n",
+    "    else:\n",
+    "        return 'Not spam'\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1/1 [==============================] - 0s 499ms/step\n",
+      "The message is classified as: Not spam\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Example usage:\n",
+    "sample_message = \"Check out this amazing offer!\"\n",
+    "result = predict_sms_sentiment(sample_message)\n",
+    "print(f\"The message is classified as: {result}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1/1 [==============================] - 0s 23ms/step\n",
+      "The message is classified as: Spam\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Example usage:\n",
+    "sample_message = \"BangBabes Ur order is on the way. U SHOULD receive a Service Msg 2 download UR content. If U do not, GoTo wap. bangb. tv on UR mobile internet/service menu\"\n",
+    "result = predict_sms_sentiment(sample_message)\n",
+    "print(f\"The message is classified as: {result}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "DLENV",
+   "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.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

lstm_smsspam_tokenizer.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:396cfc85560227160d9b6ee7b9cabd78445fb71d79cb5bfba780b736f3bf5af2
+size 290462