Logistic Regression Application.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import pylab as pl\n",
    "import numpy as np\n",
    "import scipy.optimize as opt\n",
    "from sklearn import preprocessing\n",
    "%matplotlib inline \n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/mammographic-masses/mammographic_masses.data', sep = \",\", header=None, names=['BI-RADS', 'Age', 'Shape', 'Margin', 'Density', 'Severity'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Severity</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>961.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>0.463059</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>0.498893</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Severity\n",
       "count  961.000000\n",
       "mean     0.463059\n",
       "std      0.498893\n",
       "min      0.000000\n",
       "25%      0.000000\n",
       "50%      0.000000\n",
       "75%      1.000000\n",
       "max      1.000000"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Cleaning stage\n",
    "for k in df.columns:\n",
    "    df[k] = df[k].replace('?', np.nan)\n",
    "df = df.dropna(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Severity</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>830.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>0.485542</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>0.500092</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Severity\n",
       "count  830.000000\n",
       "mean     0.485542\n",
       "std      0.500092\n",
       "min      0.000000\n",
       "25%      0.000000\n",
       "50%      0.000000\n",
       "75%      1.000000\n",
       "max      1.000000"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.astype('float')\n",
    "df['Severity'] = df['Severity'].astype('int')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "del df['BI-RADS']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "features = df.loc[:, df.columns != 'Severity']\n",
    "label = df['Severity']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.asarray(features)\n",
    "Y = np.asarray(label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\PCMASTER\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\validation.py:595: DataConversionWarning: Data with input dtype object was converted to float64 by StandardScaler.\n",
      "  warnings.warn(msg, DataConversionWarning)\n",
      "C:\\Users\\PCMASTER\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\validation.py:595: DataConversionWarning: Data with input dtype object was converted to float64 by StandardScaler.\n",
      "  warnings.warn(msg, DataConversionWarning)\n"
     ]
    }
   ],
   "source": [
    "from sklearn import preprocessing\n",
    "X = preprocessing.StandardScaler().fit(X).transform(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train set: (664, 4) (664,)\n",
      "Test set: (166, 4) (166,)\n"
     ]
    }
   ],
   "source": [
    "#SPLITTING SUFFLE DATASETS\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split( X, Y, test_size=0.2, random_state=14)\n",
    "print ('Train set:', X_train.shape,  y_train.shape)\n",
    "print ('Test set:', X_test.shape,  y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(C=1, class_weight=None, dual=False, fit_intercept=True,\n",
       "          intercept_scaling=1, max_iter=100, multi_class='warn',\n",
       "          n_jobs=None, penalty='l2', random_state=None, solver='liblinear',\n",
       "          tol=0.0001, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import confusion_matrix\n",
    "model= LogisticRegression(C=1, solver='liblinear').fit(X_train,y_train)\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8373493975903614"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import jaccard_similarity_score\n",
    "yhat = model.predict(X_test)\n",
    "jaccard_similarity_score(y_test, yhat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "C_param_range = [0.000001,0.01,0.1,1,10,100000]\n",
    "y_hat_1 =[]\n",
    "results = []\n",
    "for k in C_param_range:\n",
    "    y_hat_1 = LogisticRegression(C=k, solver='liblinear').fit(X_train,y_train).predict(X_test)\n",
    "    results.append(jaccard_similarity_score(y_test, y_hat_1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.8253012048192772,\n",
       " 0.8373493975903614,\n",
       " 0.8373493975903614,\n",
       " 0.8373493975903614,\n",
       " 0.8373493975903614,\n",
       " 0.8373493975903614]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "yhat_prob = model.predict_proba(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.41091506841370407"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import log_loss\n",
    "log_loss(y_test, yhat_prob)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[69 12]\n",
      " [15 70]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report, confusion_matrix\n",
    "import itertools\n",
    "def plot_confusion_matrix(cm, classes,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "        print(\"Normalized confusion matrix\")\n",
    "    else:\n",
    "        print('Confusion matrix, without normalization')\n",
    "\n",
    "    print(cm)\n",
    "\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, rotation=45)\n",
    "    plt.yticks(tick_marks, classes)\n",
    "\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        plt.text(j, i, format(cm[i, j], fmt),\n",
    "                 horizontalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.ylabel('True label')\n",
    "    plt.xlabel('Predicted label')\n",
    "print(confusion_matrix(y_test, yhat, labels=[1,0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix, without normalization\n",
      "[[69 12]\n",
      " [15 70]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compute confusion matrix\n",
    "cnf_matrix = confusion_matrix(y_test, yhat, labels=[1,0])\n",
    "np.set_printoptions(precision=2)\n",
    "\n",
    "\n",
    "# Plot non-normalized confusion matrix\n",
    "plt.figure()\n",
    "plot_confusion_matrix(cnf_matrix, classes=['malignant=1','benign=0'],normalize= False,  title='Confusion matrix')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.85      0.82      0.84        85\n",
      "           1       0.82      0.85      0.84        81\n",
      "\n",
      "   micro avg       0.84      0.84      0.84       166\n",
      "   macro avg       0.84      0.84      0.84       166\n",
      "weighted avg       0.84      0.84      0.84       166\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print (classification_report(y_test, yhat))"
   ]
  }
 ],
 "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
}