Upload 5 files

cnn_tumor_model.ipynb

@@ -0,0 +1,444 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### TUMOR DETECTION USING CNN - MODEL BUILDING"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import cv2\n",
+    "import os\n",
+    "import tensorflow as tf\n",
+    "from PIL import Image\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import classification_report\n",
+    "from tqdm import tqdm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image_dir = r'D:\\STUDY\\Sem3\\deeplearning\\Multitasking_app\\tumordata'\n",
+    "no_tumor_images = os.listdir(image_dir + '/no')\n",
+    "yes_tumor_images = os.listdir(image_dir + '/yes')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The length of NO Tumor images is 1500\n",
+      "The length of Tumor images is 1500\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('The length of NO Tumor images is',len(no_tumor_images))\n",
+    "print('The length of Tumor images is',len(yes_tumor_images))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "No Tumor: 1500it [00:21, 68.61it/s]\n",
+      "Tumor: 1500it [00:22, 67.90it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "dataset=[]\n",
+    "label=[]\n",
+    "img_siz=(128,128)\n",
+    "\n",
+    "\n",
+    "for i , image_name in tqdm(enumerate(no_tumor_images),desc=\"No Tumor\"):\n",
+    "    if(image_name.split('.')[1]=='jpg'):\n",
+    "        image=cv2.imread(image_dir+'/no/'+image_name)\n",
+    "        image=Image.fromarray(image,'RGB')\n",
+    "        image=image.resize(img_siz)\n",
+    "        dataset.append(np.array(image))\n",
+    "        label.append(0)\n",
+    "        \n",
+    "        \n",
+    "for i ,image_name in tqdm(enumerate(yes_tumor_images),desc=\"Tumor\"):\n",
+    "    if(image_name.split('.')[1]=='jpg'):\n",
+    "        image=cv2.imread(image_dir+'/yes/'+image_name)\n",
+    "        image=Image.fromarray(image,'RGB')\n",
+    "        image=image.resize(img_siz)\n",
+    "        dataset.append(np.array(image))\n",
+    "        label.append(1)\n",
+    "        \n",
+    "        \n",
+    "dataset=np.array(dataset)\n",
+    "label = np.array(label)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dataset Length:  3000\n",
+      "Label Length:  3000\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('Dataset Length: ',len(dataset))\n",
+    "print('Label Length: ',len(label))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train-Test Split\n",
+      "Normalising the Dataset.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Training the model\n",
+    "print(\"Train-Test Split\")\n",
+    "x_train, x_test, y_train, y_test = train_test_split(dataset, label, test_size=0.2, random_state=42)\n",
+    "\n",
+    "# Normalizing the dataset\n",
+    "print(\"Normalising the Dataset.\\n\")\n",
+    "x_train = tf.keras.utils.normalize(x_train, axis=1)\n",
+    "x_test = tf.keras.utils.normalize(x_test, axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"sequential\"\n",
+      "_________________________________________________________________\n",
+      " Layer (type)                Output Shape              Param #   \n",
+      "=================================================================\n",
+      " conv2d (Conv2D)             (None, 126, 126, 32)      896       \n",
+      "                                                                 \n",
+      " max_pooling2d (MaxPooling2  (None, 63, 63, 32)        0         \n",
+      " D)                                                              \n",
+      "                                                                 \n",
+      " flatten (Flatten)           (None, 127008)            0         \n",
+      "                                                                 \n",
+      " dense (Dense)               (None, 256)               32514304  \n",
+      "                                                                 \n",
+      " dropout (Dropout)           (None, 256)               0         \n",
+      "                                                                 \n",
+      " dense_1 (Dense)             (None, 512)               131584    \n",
+      "                                                                 \n",
+      " dense_2 (Dense)             (None, 1)                 513       \n",
+      "                                                                 \n",
+      "=================================================================\n",
+      "Total params: 32647297 (124.54 MB)\n",
+      "Trainable params: 32647297 (124.54 MB)\n",
+      "Non-trainable params: 0 (0.00 Byte)\n",
+      "_________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Define the model\n",
+    "model = tf.keras.models.Sequential([\n",
+    "    tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(128, 128, 3)),\n",
+    "    tf.keras.layers.MaxPooling2D((2, 2)),\n",
+    "    tf.keras.layers.Flatten(),\n",
+    "    tf.keras.layers.Dense(256, activation='relu'),\n",
+    "    tf.keras.layers.Dropout(0.5),\n",
+    "    tf.keras.layers.Dense(512, activation='relu'),\n",
+    "    tf.keras.layers.Dense(1, activation='sigmoid')\n",
+    "])\n",
+    "model.summary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training Started.\n",
+      "\n",
+      "Epoch 1/5\n",
+      "17/17 [==============================] - 19s 1s/step - loss: 0.7715 - accuracy: 0.6310 - val_loss: 0.5245 - val_accuracy: 0.7458\n",
+      "Epoch 2/5\n",
+      "17/17 [==============================] - 17s 999ms/step - loss: 0.4956 - accuracy: 0.7745 - val_loss: 0.4522 - val_accuracy: 0.7750\n",
+      "Epoch 3/5\n",
+      "17/17 [==============================] - 16s 964ms/step - loss: 0.3770 - accuracy: 0.8394 - val_loss: 0.3363 - val_accuracy: 0.8625\n",
+      "Epoch 4/5\n",
+      "17/17 [==============================] - 17s 988ms/step - loss: 0.2672 - accuracy: 0.8894 - val_loss: 0.3017 - val_accuracy: 0.8750\n",
+      "Epoch 5/5\n",
+      "17/17 [==============================] - 16s 960ms/step - loss: 0.1681 - accuracy: 0.9398 - val_loss: 0.1631 - val_accuracy: 0.9417\n",
+      "Training Finished.\n",
+      "\n"
+     ]
+    },
+    {
+     "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"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model Saved.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Compile the model\n",
+    "model.compile(optimizer='adam',\n",
+    "              loss='binary_crossentropy',\n",
+    "              metrics=['accuracy'])\n",
+    "\n",
+    "# Train the model\n",
+    "print(\"Training Started.\\n\")\n",
+    "history = model.fit(x_train, y_train, epochs=5, batch_size=128, validation_split=0.1)\n",
+    "print(\"Training Finished.\\n\")\n",
+    "\n",
+    "# Save the trained model\n",
+    "model.save('cnn_tumor_model.h5')\n",
+    "print(\"Model Saved.\\n\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot and save accuracy\n",
+    "plt.plot(history.epoch,history.history['accuracy'], label='accuracy')\n",
+    "plt.plot(history.epoch,history.history['val_accuracy'], label = 'val_accuracy')\n",
+    "plt.xlabel('Epoch')\n",
+    "plt.ylabel('Accuracy')\n",
+    "plt.ylim([0, 1])\n",
+    "plt.legend(loc='lower right')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot and save loss\n",
+    "plt.plot(history.epoch,history.history['loss'], label='loss')\n",
+    "plt.plot(history.epoch,history.history['val_loss'], label = 'val_loss')\n",
+    "plt.xlabel('Epoch')\n",
+    "plt.ylabel('Loss')\n",
+    "plt.legend(loc='upper right')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model Evalutaion Phase.\n",
+      "\n",
+      "19/19 [==============================] - 1s 54ms/step - loss: 0.1471 - accuracy: 0.9483\n",
+      "Accuracy: 94.83\n",
+      "19/19 [==============================] - 1s 50ms/step\n",
+      "classification Report\n",
+      "               precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.96      0.94      0.95       313\n",
+      "           1       0.94      0.96      0.95       287\n",
+      "\n",
+      "    accuracy                           0.95       600\n",
+      "   macro avg       0.95      0.95      0.95       600\n",
+      "weighted avg       0.95      0.95      0.95       600\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Model evaluation\n",
+    "print(\"Model Evalutaion Phase.\\n\")\n",
+    "loss,accuracy=model.evaluate(x_test,y_test)\n",
+    "print(f'Accuracy: {round(accuracy*100,2)}')\n",
+    "y_pred=model.predict(x_test)\n",
+    "y_pred = (y_pred > 0.5).astype(int)\n",
+    "print('classification Report\\n',classification_report(y_test,y_pred))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model Prediction.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Model prediction function\n",
+    "print(\"Model Prediction.\\n\")\n",
+    "\n",
+    "def make_prediction(img,model):\n",
+    "    img=cv2.imread(img)\n",
+    "    img=Image.fromarray(img)\n",
+    "    img=img.resize((128,128))\n",
+    "    img=np.array(img)\n",
+    "    input_img = np.expand_dims(img, axis=0)\n",
+    "    res = model.predict(input_img)\n",
+    "    if res:\n",
+    "        print(\"Tumor Detected\")\n",
+    "    else:\n",
+    "        print(\"No Tumor\")\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1/1 [==============================] - 0s 65ms/step\n",
+      "Tumor Detected\n",
+      "--------------------------------------\n",
+      "\n",
+      "1/1 [==============================] - 0s 33ms/step\n",
+      "No Tumor\n",
+      "--------------------------------------\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "\n",
+    "make_prediction(r'D:\\STUDY\\Sem3\\deeplearning\\Multitasking_app\\tumordata\\yes\\y6.jpg',model)\n",
+    "print(\"--------------------------------------\\n\")\n",
+    "make_prediction(r'D:\\STUDY\\Sem3\\deeplearning\\Multitasking_app\\tumordata\\no\\no1.jpg',model)\n",
+    "print(\"--------------------------------------\\n\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the saved model in your Streamlit app using this code\n",
+    "from tensorflow.keras.models import load_model\n",
+    "\n",
+    "loaded_model = load_model('cnn_tumor_model.h5')\n"
+   ]
+  },
+  {
+   "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
+}

rnn_smsspam_model.h5

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

rnn_smsspam_model.ipynb

@@ -0,0 +1,486 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### SMS SPAM DETECTION USING RNN"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "import tensorflow as tf\n",
+    "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score\n",
+    "import pickle"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Downloading Dataset\n",
+    "dataset = pd.read_csv(r'SMSSpamCollection.txt', sep='\\t', names=['label', 'message'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  label                                            message\n",
+      "0   ham  Go until jurong point, crazy.. Available only ...\n",
+      "1   ham                      Ok lar... Joking wif u oni...\n",
+      "2  spam  Free entry in 2 a wkly comp to win FA Cup fina...\n",
+      "3   ham  U dun say so early hor... U c already then say...\n",
+      "4   ham  Nah I don't think he goes to usf, he lives aro...\n",
+      "----------------------  -------------------------\n",
+      "      message                                                               \n",
+      "        count unique                                                top freq\n",
+      "label                                                                       \n",
+      "ham      4825   4516                             Sorry, I'll call later   30\n",
+      "spam      747    653  Please call our customer service representativ...    4\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(dataset.head())\n",
+    "print(\"----------------------  -------------------------\")\n",
+    "print(dataset.groupby('label').describe())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Preprocessing\n",
+    "dataset['label'] = dataset['label'].map({'spam': 1, 'ham': 0})\n",
+    "X = dataset['message'].values\n",
+    "y = dataset['label'].values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[387, 245, 325, 450, 917, 432, 1, 1323, 169, 2377], [19, 4, 1021, 112, 93, 6, 40, 358]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Train Test Split\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
+    "\n",
+    "tokeniser = tf.keras.preprocessing.text.Tokenizer()\n",
+    "tokeniser.fit_on_texts(X_train)\n",
+    "\n",
+    "# Save the tokenizer using pickle\n",
+    "with open('rnn_smsspam_tokenizer.pickle', 'wb') as handle:\n",
+    "    pickle.dump(tokeniser, handle, protocol=pickle.HIGHEST_PROTOCOL)\n",
+    "\n",
+    "encoded_train = tokeniser.texts_to_sequences(X_train)\n",
+    "encoded_test = tokeniser.texts_to_sequences(X_test)\n",
+    "print(encoded_train[0:2])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[  14   61  388  540 3557   23 3558    0    0    0    0    0    0    0\n",
+      "     0    0    0    0    0    0]\n",
+      " [ 474   59   35   10   61   22   63   75   76    0    0    0    0    0\n",
+      "     0    0    0    0    0    0]\n",
+      " [  36  727  180   26 3559 2396  452   41    9 1850    0    0    0    0\n",
+      "     0    0    0    0    0    0]\n",
+      " [ 518 2397  158   73  243   10   48   92    0    0    0    0    0    0\n",
+      "     0    0    0    0    0    0]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Padding\n",
+    "max_length = 20\n",
+    "padded_train = tf.keras.preprocessing.sequence.pad_sequences(encoded_train, maxlen=max_length, padding='post')\n",
+    "padded_test = tf.keras.preprocessing.sequence.pad_sequences(encoded_test, maxlen=max_length, padding='post')\n",
+    "print(padded_train[30:34])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vocab_size = len(tokeniser.word_index) + 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Model definition\n",
+    "model=tf.keras.models.Sequential([\n",
+    "   tf.keras.layers.Embedding(input_dim=vocab_size,output_dim= 24, input_length=max_length),\n",
+    "   tf.keras.layers.SimpleRNN(24, return_sequences=False),\n",
+    "   tf.keras.layers.Dense(64, activation='relu'),\n",
+    "   tf.keras.layers.Dense(32, activation='relu'),\n",
+    "   tf.keras.layers.Dense(1, activation='sigmoid')\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"sequential\"\n",
+      "_________________________________________________________________\n",
+      " Layer (type)                Output Shape              Param #   \n",
+      "=================================================================\n",
+      " embedding (Embedding)       (None, 20, 24)            180048    \n",
+      "                                                                 \n",
+      " simple_rnn (SimpleRNN)      (None, 24)                1176      \n",
+      "                                                                 \n",
+      " dense (Dense)               (None, 64)                1600      \n",
+      "                                                                 \n",
+      " dense_1 (Dense)             (None, 32)                2080      \n",
+      "                                                                 \n",
+      " dense_2 (Dense)             (None, 1)                 33        \n",
+      "                                                                 \n",
+      "=================================================================\n",
+      "Total params: 184937 (722.41 KB)\n",
+      "Trainable params: 184937 (722.41 KB)\n",
+      "Non-trainable params: 0 (0.00 Byte)\n",
+      "_________________________________________________________________\n",
+      "None\n"
+     ]
+    }
+   ],
+   "source": [
+    "# compile the model\n",
+    "model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])\n",
+    "\n",
+    "# summarize the model\n",
+    "print(model.summary())\n",
+    "\n",
+    "# Early stopping callback\n",
+    "early_stop = tf.keras.callbacks.EarlyStopping(monitor='accuracy', mode='min', patience=10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/50\n",
+      "122/122 [==============================] - 2s 6ms/step - loss: 0.3228 - accuracy: 0.8815 - val_loss: 0.1136 - val_accuracy: 0.9689\n",
+      "Epoch 2/50\n",
+      "122/122 [==============================] - 1s 4ms/step - loss: 0.0584 - accuracy: 0.9851 - val_loss: 0.0625 - val_accuracy: 0.9803\n",
+      "Epoch 3/50\n",
+      "122/122 [==============================] - 1s 5ms/step - loss: 0.0212 - accuracy: 0.9951 - val_loss: 0.0749 - val_accuracy: 0.9833\n",
+      "Epoch 4/50\n",
+      "122/122 [==============================] - 1s 5ms/step - loss: 0.0110 - accuracy: 0.9974 - val_loss: 0.0591 - val_accuracy: 0.9850\n",
+      "Epoch 5/50\n",
+      "122/122 [==============================] - 1s 5ms/step - loss: 0.0090 - accuracy: 0.9974 - val_loss: 0.0606 - val_accuracy: 0.9862\n",
+      "Epoch 6/50\n",
+      "122/122 [==============================] - 1s 5ms/step - loss: 0.0059 - accuracy: 0.9985 - val_loss: 0.0905 - val_accuracy: 0.9827\n",
+      "Epoch 7/50\n",
+      "122/122 [==============================] - 1s 5ms/step - loss: 0.0021 - accuracy: 0.9995 - val_loss: 0.0832 - val_accuracy: 0.9809\n",
+      "Epoch 8/50\n",
+      "122/122 [==============================] - 1s 5ms/step - loss: 0.0016 - accuracy: 0.9995 - val_loss: 0.0882 - val_accuracy: 0.9773\n",
+      "Epoch 9/50\n",
+      "122/122 [==============================] - 1s 5ms/step - loss: 6.3037e-04 - accuracy: 1.0000 - val_loss: 0.0881 - val_accuracy: 0.9839\n",
+      "Epoch 10/50\n",
+      "122/122 [==============================] - 1s 5ms/step - loss: 5.9414e-05 - accuracy: 1.0000 - val_loss: 0.1063 - val_accuracy: 0.9809\n",
+      "Epoch 11/50\n",
+      "122/122 [==============================] - 1s 5ms/step - loss: 3.9679e-05 - accuracy: 1.0000 - val_loss: 0.1138 - val_accuracy: 0.9803\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<keras.src.callbacks.History at 0x1ff2a08e410>"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Model training\n",
+    "model.fit(x=padded_train,\n",
+    "         y=y_train,\n",
+    "         epochs=50,\n",
+    "         validation_data=(padded_test, y_test),\n",
+    "         callbacks=[early_stop]\n",
+    "         )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "53/53 [==============================] - 0s 1ms/step\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Generate predictions after model training\n",
+    "preds = (model.predict(padded_test) > 0.5).astype(\"int32\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Classification Report\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.99      0.99      0.99      1448\n",
+      "           1       0.94      0.91      0.92       224\n",
+      "\n",
+      "    accuracy                           0.98      1672\n",
+      "   macro avg       0.96      0.95      0.96      1672\n",
+      "weighted avg       0.98      0.98      0.98      1672\n",
+      "\n",
+      "Accuracy : 98.03\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Classification report\n",
+    "print(\"Classification Report\")\n",
+    "print(classification_report(y_test, preds))\n",
+    "\n",
+    "# Accuracy score\n",
+    "acc_sc = accuracy_score(y_test, preds)\n",
+    "print(f\"Accuracy : {round(acc_sc * 100, 2)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Confusion matrix plotting\n",
+    "mtx = confusion_matrix(y_test, preds)\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()  # Display the plot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "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 trained model\n",
+    "model.save(\"rnn_smsspam_model.h5\")\n",
+    "rnn_smsspam_model = tf.keras.models.load_model('rnn_smsspam_model.h5')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def predict_message(input_text):\n",
+    "    # Process input text similarly to training data\n",
+    "    encoded_input = tokeniser.texts_to_sequences([input_text])\n",
+    "    padded_input = tf.keras.preprocessing.sequence.pad_sequences(encoded_input, maxlen=max_length, padding='post')\n",
+    "    \n",
+    "    # Get the probabilities of being classified as \"Spam\" for each input\n",
+    "    predictions = rnn_smsspam_model.predict(padded_input)\n",
+    "    \n",
+    "    # Define a threshold (e.g., 0.5) for classification\n",
+    "    threshold = 0.5\n",
+    "\n",
+    "    # Make the predictions based on the threshold for each input\n",
+    "    results = []\n",
+    "    for prediction in predictions:\n",
+    "        if prediction > threshold:\n",
+    "            results.append(\"Spam\")\n",
+    "        else:\n",
+    "            results.append(\"Not spam\")\n",
+    "    \n",
+    "    return results\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1/1 [==============================] - 0s 149ms/step\n",
+      "Message: Your free ringtone is waiting to be collected. Simply text the password \"MIX\" to 85069 to verify. Get Usher and Britney. FML, PO Box 5249, MK17 92H. 450Ppw 16 haWatching telugu movie..wat abt u? \n",
+      "The message is classified as: ['Spam']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Take user input for prediction\n",
+    "user_input =('Your free ringtone is waiting to be collected. Simply text the password \"MIX\" to 85069 to verify. Get Usher and Britney. FML, PO Box 5249, MK17 92H. 450Ppw 16 haWatching telugu movie..wat abt u?')\n",
+    "prediction_result = predict_message(user_input)\n",
+    "print(f\"Message: {user_input} \\nThe message is classified as: {prediction_result}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1/1 [==============================] - 0s 20ms/step\n",
+      "Message: XXXMobileMovieClub: To use your credit, click the WAP link in the next txt message or click here>> http://wap. xxxmobilemovieclub.com?n=QJKGIGHJJGCBL \n",
+      "The message is classified as: ['Spam']\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "user_input_1 = ('XXXMobileMovieClub: To use your credit, click the WAP link in the next txt message or click here>> http://wap. xxxmobilemovieclub.com?n=QJKGIGHJJGCBL')\n",
+    "\n",
+    "\n",
+    "prediction_result_1 = predict_message(user_input_1)\n",
+    "print(f\"Message: {user_input_1} \\nThe message is classified as: {prediction_result_1}\")\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1/1 [==============================] - 0s 20ms/step\n",
+      "Message: Hi i want to speak to you \n",
+      "The message is classified as: ['Not spam']\n"
+     ]
+    }
+   ],
+   "source": [
+    "user_input= ('Hi i want to speak to you')\n",
+    "\n",
+    "\n",
+    "prediction_result= predict_message(user_input)\n",
+    "print(f\"Message: {user_input} \\nThe message is classified as: {prediction_result}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "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
+}

rnn_smsspam_tokenizer.pickle

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