Day_27_Debugging algorithms with learning curves.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2c8254fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7a552676",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 569 entries, 0 to 568\n",
      "Data columns (total 32 columns):\n",
      " #   Column  Non-Null Count  Dtype  \n",
      "---  ------  --------------  -----  \n",
      " 0   0       569 non-null    int64  \n",
      " 1   1       569 non-null    object \n",
      " 2   2       569 non-null    float64\n",
      " 3   3       569 non-null    float64\n",
      " 4   4       569 non-null    float64\n",
      " 5   5       569 non-null    float64\n",
      " 6   6       569 non-null    float64\n",
      " 7   7       569 non-null    float64\n",
      " 8   8       569 non-null    float64\n",
      " 9   9       569 non-null    float64\n",
      " 10  10      569 non-null    float64\n",
      " 11  11      569 non-null    float64\n",
      " 12  12      569 non-null    float64\n",
      " 13  13      569 non-null    float64\n",
      " 14  14      569 non-null    float64\n",
      " 15  15      569 non-null    float64\n",
      " 16  16      569 non-null    float64\n",
      " 17  17      569 non-null    float64\n",
      " 18  18      569 non-null    float64\n",
      " 19  19      569 non-null    float64\n",
      " 20  20      569 non-null    float64\n",
      " 21  21      569 non-null    float64\n",
      " 22  22      569 non-null    float64\n",
      " 23  23      569 non-null    float64\n",
      " 24  24      569 non-null    float64\n",
      " 25  25      569 non-null    float64\n",
      " 26  26      569 non-null    float64\n",
      " 27  27      569 non-null    float64\n",
      " 28  28      569 non-null    float64\n",
      " 29  29      569 non-null    float64\n",
      " 30  30      569 non-null    float64\n",
      " 31  31      569 non-null    float64\n",
      "dtypes: float64(30), int64(1), object(1)\n",
      "memory usage: 142.4+ KB\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/wdbc.data', header=None)\n",
    "print(df.info())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "46ab3ae8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import LabelEncoder\n",
    "X = df.loc[:,2:].values\n",
    "y = df.loc[:,1].values\n",
    "le = LabelEncoder()\n",
    "y =le.fit_transform(y)\n",
    "le.classes_\n",
    "print(type(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "163c7b7c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "le.transform(['M', 'B'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5884dece",
   "metadata": {},
   "outputs": [],
   "source": [
    "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.3, stratify=y, random_state=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "cc9c0b12",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test_accuracy: 0.942\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.pipeline import make_pipeline\n",
    "\n",
    "pipe_lr = make_pipeline(StandardScaler(), PCA(n_components=2), LogisticRegression())\n",
    "pipe_lr.fit(X_train, y_train)\n",
    "y_pred = pipe_lr.predict(X_test)\n",
    "test_acuracy = pipe_lr.score(X_test, y_test)\n",
    "print(f'Test_accuracy: {test_acuracy:.3f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "379b9ab6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fold: 01 Class distr.: [225 133], Acc.: 0.925\n",
      "Fold: 02 Class distr.: [225 133], Acc.: 0.950\n",
      "Fold: 03 Class distr.: [225 133], Acc.: 0.950\n",
      "Fold: 04 Class distr.: [225 133], Acc.: 0.950\n",
      "Fold: 05 Class distr.: [225 133], Acc.: 0.875\n",
      "Fold: 06 Class distr.: [225 133], Acc.: 1.000\n",
      "Fold: 07 Class distr.: [225 133], Acc.: 0.925\n",
      "Fold: 08 Class distr.: [225 133], Acc.: 0.925\n",
      "Fold: 09 Class distr.: [225 134], Acc.: 0.974\n",
      "Fold: 10 Class distr.: [225 134], Acc.: 0.974\n",
      "\n",
      "CV accuracy: 0.945 +/- 0.033\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import StratifiedKFold\n",
    "\n",
    "kfold = StratifiedKFold(n_splits=10).split(X_train, y_train)\n",
    "\n",
    "\n",
    "scores=[]\n",
    "for k, (train, test) in enumerate(kfold):\n",
    "    pipe_lr.fit(X_train[train], y_train[train])\n",
    "    score = pipe_lr.score(X_train[test], y_train[test])\n",
    "    scores.append(score)\n",
    "    \n",
    "    \n",
    "    print(f'Fold: {k+1:02d} '\n",
    "          f'Class distr.: {np.bincount(y_train[train])}, '\n",
    "          f'Acc.: {score:.3f}')\n",
    "    \n",
    "    \n",
    "\n",
    "\n",
    "\n",
    "mean_acc = np.mean(scores)\n",
    "std_acc = np.std(scores)\n",
    "print(f'\\nCV accuracy: {mean_acc:.3f} +/- {std_acc:.3f}')\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "67e7b462",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CV accuracy scores: [0.925      0.95       0.95       0.95       0.875      1.\n",
      " 0.925      0.925      0.97435897 0.97435897]\n",
      "CV accuracy: 0.945 +/- 0.033\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "scores = cross_val_score(estimator=pipe_lr,\n",
    "                         X=X_train,\n",
    "                         y=y_train,\n",
    "                         cv=10,\n",
    "                         n_jobs=1)\n",
    "print(f'CV accuracy scores: {scores}')\n",
    "print(f'CV accuracy: {np.mean(scores):.3f} '\n",
    "      f'+/- {np.std(scores):.3f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "590afef3",
   "metadata": {},
   "source": [
    "### Using Learning curve to evaluate model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "391c6f2a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import learning_curve\n",
    "\n",
    "\n",
    "pipe_lr = make_pipeline(StandardScaler(),\n",
    "                        LogisticRegression(penalty='l2', max_iter=10000))\n",
    "\n",
    "train_sizes, train_scores, test_scores =\\\n",
    "                learning_curve(estimator=pipe_lr,\n",
    "                               X=X_train,\n",
    "                               y=y_train,\n",
    "                               train_sizes=np.linspace(0.1, 1.0, 10),\n",
    "                               cv=10,\n",
    "                               n_jobs=1)\n",
    "\n",
    "train_mean = np.mean(train_scores, axis=1)\n",
    "train_std = np.std(train_scores, axis=1)\n",
    "test_mean = np.mean(test_scores, axis=1)\n",
    "test_std = np.std(test_scores, axis=1)\n",
    "\n",
    "plt.plot(train_sizes, train_mean,\n",
    "         color='blue', marker='o',\n",
    "         markersize=5, label='Training accuracy')\n",
    "\n",
    "plt.fill_between(train_sizes,\n",
    "                 train_mean + train_std,\n",
    "                 train_mean - train_std,\n",
    "                 alpha=0.15, color='blue')\n",
    "\n",
    "plt.plot(train_sizes, test_mean,\n",
    "         color='green', linestyle='--',\n",
    "         marker='s', markersize=5,\n",
    "         label='Validation accuracy')\n",
    "\n",
    "plt.fill_between(train_sizes,\n",
    "                 test_mean + test_std,\n",
    "                 test_mean - test_std,\n",
    "                 alpha=0.15, color='green')\n",
    "\n",
    "plt.grid()\n",
    "plt.xlabel('Number of training examples')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend(loc='lower right')\n",
    "plt.ylim([0.8, 1.03])\n",
    "plt.tight_layout()\n",
    "# plt.savefig('figures/06_05.png', dpi=300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4dbc61ea",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}