KNN(Final).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#KNN model\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "df=pd.read_csv('Cancer.csv')\n",
    "df=df.drop(['Unnamed: 32','id'], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['texture_mean']=np.sqrt(np.sqrt(np.sqrt(df['texture_mean'])))\n",
    "df['perimeter_mean']=np.log(np.log(np.log(df['perimeter_mean'])))\n",
    "df['smoothness_mean']=np.sqrt(np.sqrt(np.sqrt(df['smoothness_mean'])))\n",
    "df['compactness_mean']=np.log(df['compactness_mean'])\n",
    "df['symmetry_mean']=np.log(df['symmetry_mean'])\n",
    "df['fractal_dimension_mean']=np.log(np.sqrt(df['fractal_dimension_mean']))\n",
    "df['texture_se']=np.log(df['texture_se'])\n",
    "df['smoothness_se']=np.log(np.sqrt(df['smoothness_se']))\n",
    "df['area_se']=np.log(np.log(np.log(df['area_se'])))\n",
    "df['concave points_se']=np.sqrt(df['concave points_se'])\n",
    "df['symmetry_se']=np.log(np.sqrt(df['symmetry_se']))\n",
    "df['fractal_dimension_se']=np.log(np.sqrt(np.sqrt(df['fractal_dimension_se'])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "f_drop=['radius_worst','texture_worst','perimeter_worst','area_worst','smoothness_worst','compactness_worst',\\\n",
    "        'concavity_worst','concave points_worst','symmetry_worst','fractal_dimension_worst','radius_mean',\\\n",
    "        'concavity_se','perimeter_se','concavity_mean','area_mean','compactness_se','radius_se','concave points_mean']\n",
    "df=df.drop(f_drop,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import LabelEncoder\n",
    "le_diagnosis=LabelEncoder()\n",
    "df['diagnosis_code']=le_diagnosis.fit_transform(df['diagnosis'])\n",
    "df.drop('diagnosis',axis=1,inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import f1_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train Data with 9 Input Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[107  10]\n",
      " [  1  53]]\n"
     ]
    }
   ],
   "source": [
    "x=df.drop(['diagnosis_code','fractal_dimension_se','symmetry_se','texture_se'],axis=1)\n",
    "y=df.diagnosis_code\n",
    "\n",
    "x_train,x_test,y_train,y_test=train_test_split(x,y,random_state=4,test_size=0.3)\n",
    "\n",
    "sc_x=StandardScaler()\n",
    "x_train=sc_x.fit_transform(x_train)\n",
    "x_test=sc_x.fit_transform(x_test)\n",
    "\n",
    "classifier=KNeighborsClassifier(n_neighbors=7,p=2,metric='euclidean')\n",
    "classifier.fit(x_train,y_train)\n",
    "\n",
    "predictions=classifier.predict(x_test)\n",
    "\n",
    "r=confusion_matrix(y_test,predictions)\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy: 93.56725146198829\n",
      "True Positive Rate (TPR) : 99.07407407407408\n",
      "True Negative Rate (TNR) : 84.12698412698413\n",
      "False Negative Rate (FNR) : 0.9259259259259258\n",
      "False Positive Rate (FPR) : 15.873015873015872\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      0.91      0.95       117\n",
      "           1       0.84      0.98      0.91        54\n",
      "\n",
      "   micro avg       0.94      0.94      0.94       171\n",
      "   macro avg       0.92      0.95      0.93       171\n",
      "weighted avg       0.94      0.94      0.94       171\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"accuracy:\",accuracy_score(y_test,predictions)*100)\n",
    "print(\"True Positive Rate (TPR) :\",(r[0][0]/(r[0][0]+r[1][0]))*100)\n",
    "print(\"True Negative Rate (TNR) :\",(r[1][1]/(r[1][1]+r[0][1]))*100)\n",
    "print(\"False Negative Rate (FNR) :\",(r[1][0]/(r[1][0]+r[0][0]))*100)\n",
    "print(\"False Positive Rate (FPR) :\",(r[0][1]/(r[0][1]+r[1][1]))*100)\n",
    "x1=(classification_report(y_test,predictions))\n",
    "print(x1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train Data with 10 Input Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[106  11]\n",
      " [  2  52]]\n"
     ]
    }
   ],
   "source": [
    "x=df.drop(['diagnosis_code','fractal_dimension_se','texture_se',],axis=1)\n",
    "y=df.diagnosis_code\n",
    "\n",
    "x_train,x_test,y_train,y_test=train_test_split(x,y,random_state=4,test_size=0.3)\n",
    "\n",
    "sc_x=StandardScaler()\n",
    "x_train=sc_x.fit_transform(x_train)\n",
    "x_test=sc_x.fit_transform(x_test)\n",
    "\n",
    "classifier=KNeighborsClassifier(n_neighbors=7,p=2,metric='euclidean')\n",
    "classifier.fit(x_train,y_train)\n",
    "\n",
    "predictions=classifier.predict(x_test)\n",
    "\n",
    "r=confusion_matrix(y_test,predictions)\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy: 92.39766081871345\n",
      "True Positive Rate (TPR) : 98.14814814814815\n",
      "True Negative Rate (TNR) : 82.53968253968253\n",
      "False Negative Rate (FNR) : 1.8518518518518516\n",
      "False Positive Rate (FPR) : 17.46031746031746\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      0.91      0.94       117\n",
      "           1       0.83      0.96      0.89        54\n",
      "\n",
      "   micro avg       0.92      0.92      0.92       171\n",
      "   macro avg       0.90      0.93      0.92       171\n",
      "weighted avg       0.93      0.92      0.93       171\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"accuracy:\",accuracy_score(y_test,predictions)*100)\n",
    "print(\"True Positive Rate (TPR) :\",(r[0][0]/(r[0][0]+r[1][0]))*100)\n",
    "print(\"True Negative Rate (TNR) :\",(r[1][1]/(r[1][1]+r[0][1]))*100)\n",
    "print(\"False Negative Rate (FNR) :\",(r[1][0]/(r[1][0]+r[0][0]))*100)\n",
    "print(\"False Positive Rate (FPR) :\",(r[0][1]/(r[0][1]+r[1][1]))*100)\n",
    "x1=(classification_report(y_test,predictions))\n",
    "print(x1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train Data with 11 Input Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[108   9]\n",
      " [  3  51]]\n"
     ]
    }
   ],
   "source": [
    "x=df.drop(['diagnosis_code','fractal_dimension_se'],axis=1)\n",
    "y=df.diagnosis_code\n",
    "\n",
    "x_train,x_test,y_train,y_test=train_test_split(x,y,random_state=4,test_size=0.3)\n",
    "\n",
    "sc_x=StandardScaler()\n",
    "x_train=sc_x.fit_transform(x_train)\n",
    "x_test=sc_x.fit_transform(x_test)\n",
    "\n",
    "classifier=KNeighborsClassifier(n_neighbors=7,p=2,metric='euclidean')\n",
    "classifier.fit(x_train,y_train)\n",
    "\n",
    "predictions=classifier.predict(x_test)\n",
    "\n",
    "r=confusion_matrix(y_test,predictions)\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy: 92.98245614035088\n",
      "True Positive Rate (TPR) : 97.2972972972973\n",
      "True Negative Rate (TNR) : 85.0\n",
      "False Negative Rate (FNR) : 2.7027027027027026\n",
      "False Positive Rate (FPR) : 15.0\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.97      0.92      0.95       117\n",
      "           1       0.85      0.94      0.89        54\n",
      "\n",
      "   micro avg       0.93      0.93      0.93       171\n",
      "   macro avg       0.91      0.93      0.92       171\n",
      "weighted avg       0.93      0.93      0.93       171\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"accuracy:\",accuracy_score(y_test,predictions)*100)\n",
    "print(\"True Positive Rate (TPR) :\",(r[0][0]/(r[0][0]+r[1][0]))*100)\n",
    "print(\"True Negative Rate (TNR) :\",(r[1][1]/(r[1][1]+r[0][1]))*100)\n",
    "print(\"False Negative Rate (FNR) :\",(r[1][0]/(r[1][0]+r[0][0]))*100)\n",
    "print(\"False Positive Rate (FPR) :\",(r[0][1]/(r[0][1]+r[1][1]))*100)\n",
    "x1=(classification_report(y_test,predictions))\n",
    "print(x1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train Data with 12 Input Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[110   7]\n",
      " [  3  51]]\n"
     ]
    }
   ],
   "source": [
    "x=df.drop(['diagnosis_code'],axis=1)\n",
    "y=df.diagnosis_code\n",
    "\n",
    "x_train,x_test,y_train,y_test=train_test_split(x,y,random_state=4,test_size=0.3)\n",
    "\n",
    "sc_x=StandardScaler()\n",
    "x_train=sc_x.fit_transform(x_train)\n",
    "x_test=sc_x.fit_transform(x_test)\n",
    "\n",
    "classifier=KNeighborsClassifier(n_neighbors=7,p=2,metric='euclidean')\n",
    "classifier.fit(x_train,y_train)\n",
    "\n",
    "predictions=classifier.predict(x_test)\n",
    "\n",
    "r=confusion_matrix(y_test,predictions)\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy: 94.15204678362574\n",
      "True Positive Rate (TPR) : 97.34513274336283\n",
      "True Negative Rate (TNR) : 87.93103448275862\n",
      "False Negative Rate (FNR) : 2.6548672566371683\n",
      "False Positive Rate (FPR) : 12.068965517241379\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.97      0.94      0.96       117\n",
      "           1       0.88      0.94      0.91        54\n",
      "\n",
      "   micro avg       0.94      0.94      0.94       171\n",
      "   macro avg       0.93      0.94      0.93       171\n",
      "weighted avg       0.94      0.94      0.94       171\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"accuracy:\",accuracy_score(y_test,predictions)*100)\n",
    "print(\"True Positive Rate (TPR) :\",(r[0][0]/(r[0][0]+r[1][0]))*100)\n",
    "print(\"True Negative Rate (TNR) :\",(r[1][1]/(r[1][1]+r[0][1]))*100)\n",
    "print(\"False Negative Rate (FNR) :\",(r[1][0]/(r[1][0]+r[0][0]))*100)\n",
    "print(\"False Positive Rate (FPR) :\",(r[0][1]/(r[0][1]+r[1][1]))*100)\n",
    "x1=(classification_report(y_test,predictions))\n",
    "print(x1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train Data with 9 Input Features (When n_neighbors=9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[108   9]\n",
      " [  2  52]]\n"
     ]
    }
   ],
   "source": [
    "x=df.drop(['diagnosis_code','fractal_dimension_se','symmetry_se','texture_se'],axis=1)\n",
    "y=df.diagnosis_code\n",
    "\n",
    "x_train,x_test,y_train,y_test=train_test_split(x,y,random_state=4,test_size=0.3)\n",
    "\n",
    "sc_x=StandardScaler()\n",
    "x_train=sc_x.fit_transform(x_train)\n",
    "x_test=sc_x.fit_transform(x_test)\n",
    "\n",
    "classifier=KNeighborsClassifier(n_neighbors=9,p=2,metric='euclidean')\n",
    "classifier.fit(x_train,y_train)\n",
    "\n",
    "predictions=classifier.predict(x_test)\n",
    "\n",
    "r=confusion_matrix(y_test,predictions)\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy: 93.56725146198829\n",
      "True Positive Rate (TPR) : 98.18181818181819\n",
      "True Negative Rate (TNR) : 85.24590163934425\n",
      "False Negative Rate (FNR) : 1.8181818181818181\n",
      "False Positive Rate (FPR) : 14.754098360655737\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      0.92      0.95       117\n",
      "           1       0.85      0.96      0.90        54\n",
      "\n",
      "   micro avg       0.94      0.94      0.94       171\n",
      "   macro avg       0.92      0.94      0.93       171\n",
      "weighted avg       0.94      0.94      0.94       171\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"accuracy:\",accuracy_score(y_test,predictions)*100)\n",
    "print(\"True Positive Rate (TPR) :\",(r[0][0]/(r[0][0]+r[1][0]))*100)\n",
    "print(\"True Negative Rate (TNR) :\",(r[1][1]/(r[1][1]+r[0][1]))*100)\n",
    "print(\"False Negative Rate (FNR) :\",(r[1][0]/(r[1][0]+r[0][0]))*100)\n",
    "print(\"False Positive Rate (FPR) :\",(r[0][1]/(r[0][1]+r[1][1]))*100)\n",
    "x1=(classification_report(y_test,predictions))\n",
    "print(x1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train Data with 9 Input Features (When n_neighbors=11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[110   7]\n",
      " [  0  54]]\n"
     ]
    }
   ],
   "source": [
    "x=df.drop(['diagnosis_code','fractal_dimension_se','symmetry_se','texture_se'],axis=1)\n",
    "y=df.diagnosis_code\n",
    "\n",
    "x_train,x_test,y_train,y_test=train_test_split(x,y,random_state=4,test_size=0.3)\n",
    "\n",
    "sc_x=StandardScaler()\n",
    "x_train=sc_x.fit_transform(x_train)\n",
    "x_test=sc_x.fit_transform(x_test)\n",
    "\n",
    "classifier=KNeighborsClassifier(n_neighbors=11,p=2,metric='euclidean')\n",
    "classifier.fit(x_train,y_train)\n",
    "\n",
    "predictions=classifier.predict(x_test)\n",
    "\n",
    "r=confusion_matrix(y_test,predictions)\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy: 95.90643274853801\n",
      "True Positive Rate (TPR) : 100.0\n",
      "True Negative Rate (TNR) : 88.52459016393442\n",
      "False Negative Rate (FNR) : 0.0\n",
      "False Positive Rate (FPR) : 11.475409836065573\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      0.94      0.97       117\n",
      "           1       0.89      1.00      0.94        54\n",
      "\n",
      "   micro avg       0.96      0.96      0.96       171\n",
      "   macro avg       0.94      0.97      0.95       171\n",
      "weighted avg       0.96      0.96      0.96       171\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"accuracy:\",accuracy_score(y_test,predictions)*100)\n",
    "print(\"True Positive Rate (TPR) :\",(r[0][0]/(r[0][0]+r[1][0]))*100)\n",
    "print(\"True Negative Rate (TNR) :\",(r[1][1]/(r[1][1]+r[0][1]))*100)\n",
    "print(\"False Negative Rate (FNR) :\",(r[1][0]/(r[1][0]+r[0][0]))*100)\n",
    "print(\"False Positive Rate (FPR) :\",(r[0][1]/(r[0][1]+r[1][1]))*100)\n",
    "x1=(classification_report(y_test,predictions))\n",
    "print(x1)"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}