CNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'38'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn import preprocessing\n",
    "import numpy as np\n",
    "def derivative(x):\n",
    "    return(x * (1.0 - x))\n",
    "def sigmoid(x):\n",
    "    return(1.0 / (1.0 + np.exp(-x)))\n",
    "X = []\n",
    "Y = []\n",
    "# read the training data\n",
    "with open('E:\\data\\spam.txt') as f:\n",
    "    for line in f:\n",
    "        curr = line.split(',')\n",
    "        new_curr = []\n",
    "        for item in curr[:len(curr) - 1]:\n",
    "            new_curr.append(float())\n",
    "        X.append(new_curr)\n",
    "        Y.append([float(curr[-1])])\n",
    "item\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.utils import shuffle\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4574"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.array(X)\n",
    "X = preprocessing.scale(X) # feature scaling\n",
    "Y = np.array(Y)\n",
    "len(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., ..., 0., 0., 0.],\n",
       "       [0., 0., 0., ..., 0., 0., 0.],\n",
       "       [0., 0., 0., ..., 0., 0., 0.],\n",
       "       ...,\n",
       "       [0., 0., 0., ..., 0., 0., 0.],\n",
       "       [0., 0., 0., ..., 0., 0., 0.],\n",
       "       [0., 0., 0., ..., 0., 0., 0.]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.],\n",
       "       [1.],\n",
       "       [1.],\n",
       "       ...,\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [0.]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "Xs,Ys = shuffle(X, Y, random_state=1)\n",
    "X_train = Xs[0:3500]\n",
    "Y_train = Ys[0:3500]\n",
    "# the rest 500 emails will serve as testing data\n",
    "X_test = Xs[3500:]\n",
    "y_test = Ys[3500:]\n",
    "X = X_train\n",
    "y = Y_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3500"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(X_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1074"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# we have 3 layers: input layer, hidden layer and output layer\n",
    "# input layer has 57 nodes (1 for each feature)\n",
    "# hidden layer has 4 nodes\n",
    "# output layer has 1 node\n",
    "dim1 = len(X_train[0])\n",
    "dim2 = 4\n",
    "# randomly initialize the weight vectors\n",
    "np.random.seed(1)\n",
    "weight0 = 2 * np.random.random((dim1, dim2)) - 1\n",
    "weight1 = 2 * np.random.random((dim2, 1)) - 1\n",
    "# you can change the number of iterations\n",
    "for j in range(25000):\n",
    "    # first evaluate the output for each training email\n",
    "    layer_0 = X_train\n",
    "    layer_1 = sigmoid(np.dot(layer_0,weight0))\n",
    "    layer_2 = sigmoid(np.dot(layer_1,weight1))\n",
    "    # calculate the error\n",
    "    layer_2_error = Y_train - layer_2\n",
    "    # perform back propagation\n",
    "    layer_2_delta = layer_2_error * derivative(layer_2)\n",
    "    layer_1_error = layer_2_delta.dot(weight1.T)\n",
    "    layer_1_delta = layer_1_error * derivative(layer_1)\n",
    "    # update the weight vectors\n",
    "    weight1 += layer_1.T.dot(layer_2_delta)\n",
    "    weight0 += layer_0.T.dot(layer_1_delta)\n",
    "# evaluation on the testing data\n",
    "layer_0 = X_test\n",
    "layer_1 = sigmoid(np.dot(layer_0,weight0))\n",
    "layer_2 = sigmoid(np.dot(layer_1,weight1))\n",
    "correct = 0\n",
    "# if the output is > 0.5, then label as spam else no spam\n",
    "for i in range(len(layer_2)):\n",
    "    if(layer_2[i][0] > 0.5):\n",
    "        layer_2[i][0] = 1\n",
    "    else:\n",
    "        layer_2[i][0] = 0\n",
    "    if(layer_2[i][0] == y_test[i][0]):\n",
    "        correct += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "correct=0\n",
    "test_labels=[]\n",
    "result=[]\n",
    "tp=0\n",
    "fp=0\n",
    "fn=0\n",
    "for i in range(len(layer_2)):\n",
    "    if(layer_2[i][0] > 0.5):\n",
    "        layer_2[i][0] = 1\n",
    "        test_labels.append(1)\n",
    "    else:\n",
    "        layer_2[i][0] = 0\n",
    "        test_labels.append(0)\n",
    "    result.append(y_test[i][0])\n",
    "    if(layer_2[i][0]==1):\n",
    "        fp+=1\n",
    "    if(layer_2[i][0] == y_test[i][0]):\n",
    "        if(layer_2[i][0]==0):\n",
    "            tp+=1\n",
    "        correct += 1\n",
    "    else:\n",
    "        if(layer_2[i][0]==0):\n",
    "            fp+=1\n",
    "        else:\n",
    "            fn+=1\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "406"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total mails=  1074\n",
      "Correct =  668\n"
     ]
    }
   ],
   "source": [
    "# printing the output\n",
    "print('Total mails= ', len(layer_2))\n",
    "print('Correct = ', correct)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Neural Network- 0.6219739292364991\n"
     ]
    }
   ],
   "source": [
    "print('Neural Network-', correct  / len(layer_2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Neural Network\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       1.00      0.62      0.77      1074\n",
      "         1.0       0.00      0.00      0.00         0\n",
      "\n",
      "   micro avg       0.62      0.62      0.62      1074\n",
      "   macro avg       0.50      0.31      0.38      1074\n",
      "weighted avg       1.00      0.62      0.77      1074\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report,confusion_matrix, accuracy_score\n",
    "print('Neural Network')\n",
    "print(classification_report(test_labels,result))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}