02-classification-metrics.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Classification Metrics\n",
        "\n",
        "In the last notebook we fit binary classifier to predict whether patients were diabetic or not. We used accuracy as a measure of how well the model performed, but accuracy isn't everything. In this notebook, we will look at alternatives to accuracy that can be much more useful in machine learning.\n",
        "\n",
        "## Alternative metrics for binary classifiers\n",
        "\n",
        "Accuracy seems like a sensible metric to evaluate (and to a certain extent it is), but you need to be careful about drawing too many conclusions from the accuracy of a classifier. Remember that it's simply a measure of how many cases were predicted correctly. Suppose only 3% of the population is diabetic. You could create a classifier that always just predicts 0, and it would be 97% accurate - but not terribly helpful in identifying patients with diabetes!\n",
        "\n",
        "Fortunately, there are some other metrics that reveal a little more about how our model is performing. Scikit-Learn includes the ability to create a *classification report* that provides more insight than raw accuracy alone.\n",
        "\n",
        "To get started, run the next cell to load our data and train our model like last time."
      ],
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "from matplotlib import pyplot as plt\n",
        "%matplotlib inline\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import accuracy_score\n",
        "\n",
        "\n",
        "# load the training dataset\n",
        "!wget https://raw.githubusercontent.com/MicrosoftDocs/mslearn-introduction-to-machine-learning/main/Data/ml-basics/diabetes.csv\n",
        "diabetes = pd.read_csv('diabetes.csv')\n",
        "\n",
        "# Separate features and labels\n",
        "features = ['Pregnancies','PlasmaGlucose','DiastolicBloodPressure','TricepsThickness','SerumInsulin','BMI','DiabetesPedigree','Age']\n",
        "label = 'Diabetic'\n",
        "X, y = diabetes[features].values, diabetes[label].values\n",
        "\n",
        "\n",
        "# Split data 70%-30% into training set and test set\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=0)\n",
        "\n",
        "print ('Training cases: %d\\nTest cases: %d' % (X_train.shape[0], X_test.shape[0]))\n",
        "\n",
        "# Train the model\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "\n",
        "# Set regularization rate\n",
        "reg = 0.01\n",
        "\n",
        "# train a logistic regression model on the training set\n",
        "model = LogisticRegression(C=1/reg, solver=\"liblinear\").fit(X_train, y_train)\n",
        "\n",
        "predictions = model.predict(X_test)\n",
        "print('Predicted labels: ', predictions)\n",
        "print('Actual labels:    ' ,y_test)\n",
        "\n",
        "\n",
        "print('Accuracy: ', accuracy_score(y_test, predictions))\n"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "--2023-08-13 20:24:38--  https://raw.githubusercontent.com/MicrosoftDocs/mslearn-introduction-to-machine-learning/main/Data/ml-basics/diabetes.csv\nResolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\nConnecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\nHTTP request sent, awaiting response... 200 OK\nLength: 776415 (758K) [text/plain]\nSaving to: ‘diabetes.csv.1’\n\ndiabetes.csv.1      100%[===================>] 758.22K  --.-KB/s    in 0.03s   \n\n2023-08-13 20:24:38 (25.2 MB/s) - ‘diabetes.csv.1’ saved [776415/776415]\n\nTraining cases: 10500\nTest cases: 4500\nPredicted labels:  [0 0 0 ... 0 1 0]\nActual labels:     [0 0 1 ... 1 1 1]\nAccuracy:  0.7893333333333333\n"
        }
      ],
      "execution_count": 1,
      "metadata": {
        "scrolled": false
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "One of the simplest places to start is a classification report. Run the next cell to see a range of alternatives ways to assess our model"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn. metrics import classification_report\n",
        "\n",
        "print(classification_report(y_test, predictions))"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "              precision    recall  f1-score   support\n\n           0       0.81      0.88      0.85      2986\n           1       0.72      0.60      0.66      1514\n\n    accuracy                           0.79      4500\n   macro avg       0.77      0.74      0.75      4500\nweighted avg       0.78      0.79      0.78      4500\n\n"
        }
      ],
      "execution_count": 2,
      "metadata": {
        "tags": []
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The classification report includes the following metrics for each class  (0 and 1)\n",
        "\n",
        "> note that the header row may not line up with the values!\n",
        "\n",
        "* *Precision*: Of the predictions the model made for this class, what proportion were correct?\n",
        "* *Recall*: Out of all of the instances of this class in the test dataset, how many did the model identify?\n",
        "* *F1-Score*: An average metric that takes both precision and recall into account.\n",
        "* *Support*: How many instances of this class are there in the test dataset?\n",
        "\n",
        "The classification report also includes averages for these metrics, including a weighted average that allows for the imbalance in the number of cases of each class.\n",
        "\n",
        "Because this is a *binary* classification problem, the ***1*** class is considered *positive* and its precision and recall are particularly interesting - these in effect answer the questions:\n",
        "\n",
        "- Of all the patients the model predicted are diabetic, how many are actually diabetic?\n",
        "- Of all the patients that are actually diabetic, how many did the model identify?\n",
        "\n",
        "You can retrieve these values on their own by using the **precision_score** and **recall_score** metrics in scikit-learn (which by default assume a binary classification model)."
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import precision_score, recall_score\n",
        "\n",
        "print(\"Overall Precision:\",precision_score(y_test, predictions))\n",
        "print(\"Overall Recall:\",recall_score(y_test, predictions))"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "Overall Precision: 0.7242472266244057\nOverall Recall: 0.6036988110964333\n"
        }
      ],
      "execution_count": 3,
      "metadata": {
        "tags": []
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The precision and recall metrics are derived from four possible prediction outcomes:\n",
        "* *True Positives*: The predicted label and the actual label are both 1.\n",
        "* *False Positives*: The predicted label is 1, but the actual label is 0.\n",
        "* *False Negatives*: The predicted label is 0, but the actual label is 1.\n",
        "* *True Negatives*: The predicted label and the actual label are both 0.\n",
        "\n",
        "These metrics are generally tabulated for the test set and shown together as a *confusion matrix*, which takes the following form:\n",
        "\n",
        "<table style=\"border: 1px solid black;\">\n",
        "    <tr style=\"border: 1px solid black;\">\n",
        "        <td style=\"border: 1px solid black;color: black;\" bgcolor=\"lightgray\">TN</td><td style=\"border: 1px solid black;color: black;\" bgcolor=\"white\">FP</td>\n",
        "    </tr>\n",
        "    <tr style=\"border: 1px solid black;\">\n",
        "        <td style=\"border: 1px solid black;color: black;\" bgcolor=\"white\">FN</td><td style=\"border: 1px solid black;color: black;\" bgcolor=\"lightgray\">TP</td>\n",
        "    </tr>\n",
        "</table>\n",
        "\n",
        "Note that the correct (*true*) predictions form a diagonal line from top left to bottom right - these figures should be significantly higher than the *false* predictions if the model is any good.\n",
        "\n",
        "In Python, you can use the **sklearn.metrics.confusion_matrix** function to find these values for a trained classifier:"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "\n",
        "# Print the confusion matrix\n",
        "cm = confusion_matrix(y_test, predictions)\n",
        "print (cm)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "[[2638  348]\n [ 600  914]]\n"
        }
      ],
      "execution_count": 4,
      "metadata": {
        "tags": []
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Until now, we've considered the predictions from the model as being either 1 or 0 class labels. Actually, things are a little more complex than that. Statistical machine learning algorithms, like logistic regression, are based on *probability*; so what actually gets predicted by a binary classifier is the probability that the label is true (**P(y)**) and the probability that the label is false (1 - **P(y)**). A threshold value of 0.5 is used to decide whether the predicted label is a 1 (*P(y) > 0.5*) or a 0 (*P(y) <= 0.5*). You can use the **predict_proba** method to see the probability pairs for each case:"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "y_scores = model.predict_proba(X_test)\n",
        "print(y_scores)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "[[0.81657749 0.18342251]\n [0.96303915 0.03696085]\n [0.80873957 0.19126043]\n ...\n [0.60693276 0.39306724]\n [0.1065467  0.8934533 ]\n [0.63858497 0.36141503]]\n"
        }
      ],
      "execution_count": 5,
      "metadata": {
        "tags": []
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The decision to score a prediction as a 1 or a 0 depends on the threshold to which the predicted probabilities are compared. If we were to change the threshold, it would affect the predictions; and therefore change the metrics in the confusion matrix. A common way to evaluate a classifier is to examine the *true positive rate* (which is another name for recall) and the *false positive rate* for a range of possible thresholds. These rates are then plotted against all possible thresholds to form a chart known as a *received operator characteristic (ROC) chart*, like this:"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import roc_curve\n",
        "from sklearn.metrics import confusion_matrix\n",
        "import matplotlib\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "# calculate ROC curve\n",
        "fpr, tpr, thresholds = roc_curve(y_test, y_scores[:,1])\n",
        "\n",
        "# plot ROC curve\n",
        "fig = plt.figure(figsize=(6, 6))\n",
        "# Plot the diagonal 50% line\n",
        "plt.plot([0, 1], [0, 1], 'k--')\n",
        "# Plot the FPR and TPR achieved by our model\n",
        "plt.plot(fpr, tpr)\n",
        "plt.xlabel('False Positive Rate')\n",
        "plt.ylabel('True Positive Rate')\n",
        "plt.title('ROC Curve')\n",
        "plt.show()"
      ],
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 600x600 with 1 Axes>",
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "execution_count": 6,
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": [
        "The ROC chart shows the curve of the true and false positive rates for different threshold values between 0 and 1. A perfect classifier would have a curve that goes straight up the left side and straight across the top. The diagonal line across the chart represents the probability of predicting correctly with a 50/50 random prediction; so you obviously want the curve to be higher than that (or your model is no better than simply guessing!).\n",
        "\n",
        "The area under the curve (AUC) is a value between 0 and 1 that quantifies the overall performance of the model. The closer to 1 this value is, the better the model. Once again, scikit-Learn includes a function to calculate this metric."
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import roc_auc_score\n",
        "\n",
        "auc = roc_auc_score(y_test,y_scores[:,1])\n",
        "print('AUC: ' + str(auc))"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "AUC: 0.8568436056949161\n"
        }
      ],
      "execution_count": 7,
      "metadata": {
        "tags": []
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Perform preprocessing in a pipeline\n",
        "\n",
        "In this case, the ROC curve and its AUC indicate that the model performs better than a random guess which is not bad considering we performed very little preprocessing of the data.\n",
        "\n",
        "In practice, it's common to perform some preprocessing of the data to make it easier for the algorithm to fit a model to it. There's a huge range of preprocessing transformations you can perform to get your data ready for modeling, but we'll limit ourselves to a few common techniques:\n",
        "\n",
        "- Scaling numeric features so they're on the same scale. This prevents features with large values from producing coefficients that disproportionately affect the predictions.\n",
        "- Encoding categorical variables. For example, by using a *one hot encoding* technique you can create individual binary (true/false) features for each possible category value.\n",
        "\n",
        "To apply these preprocessing transformations, we'll make use of a Scikit-Learn feature named *pipelines*. These enable us to define a set of preprocessing steps that end with an algorithm. You can then fit the entire pipeline to the data, so that the model encapsulates all of the preprocessing steps as well as the regression algorithm. This is useful, because when we want to use the model to predict values from new data, we need to apply the same transformations (based on the same statistical distributions and category encodings used with the training data).\n",
        "\n",
        ">**Note**: The term *pipeline* is used extensively in machine learning, often to mean very different things! In this context, we're using it to refer to pipeline objects in Scikit-Learn, but you may see it used elsewhere to mean something else.\n"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "# Train the model\n",
        "from sklearn.compose import ColumnTransformer\n",
        "from sklearn.pipeline import Pipeline\n",
        "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "import numpy as np\n",
        "\n",
        "# Define preprocessing for numeric columns (normalize them so they're on the same scale)\n",
        "numeric_features = [0,1,2,3,4,5,6]\n",
        "numeric_transformer = Pipeline(steps=[\n",
        "    ('scaler', StandardScaler())])\n",
        "\n",
        "# Define preprocessing for categorical features (encode the Age column)\n",
        "categorical_features = [7]\n",
        "categorical_transformer = Pipeline(steps=[\n",
        "    ('onehot', OneHotEncoder(handle_unknown='ignore'))])\n",
        "\n",
        "# Combine preprocessing steps\n",
        "preprocessor = ColumnTransformer(\n",
        "    transformers=[\n",
        "        ('num', numeric_transformer, numeric_features),\n",
        "        ('cat', categorical_transformer, categorical_features)])\n",
        "\n",
        "# Create preprocessing and training pipeline\n",
        "pipeline = Pipeline(steps=[('preprocessor', preprocessor),\n",
        "                           ('logregressor', LogisticRegression(C=1/reg, solver=\"liblinear\"))])\n",
        "\n",
        "\n",
        "# fit the pipeline to train a logistic regression model on the training set\n",
        "model = pipeline.fit(X_train, (y_train))\n",
        "print (model)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "Pipeline(memory=None,\n         steps=[('preprocessor',\n                 ColumnTransformer(n_jobs=None, remainder='drop',\n                                   sparse_threshold=0.3,\n                                   transformer_weights=None,\n                                   transformers=[('num',\n                                                  Pipeline(memory=None,\n                                                           steps=[('scaler',\n                                                                   StandardScaler(copy=True,\n                                                                                  with_mean=True,\n                                                                                  with_std=True))],\n                                                           verbose=False),\n                                                  [0, 1, 2, 3, 4, 5, 6]),\n                                                 ('cat',\n                                                  Pipeline(memory=None,\n                                                           steps=[('onehot',\n                                                                   OneHotEncoder(catego...\n                                                                                 handle_unknown='ignore',\n                                                                                 sparse=True))],\n                                                           verbose=False),\n                                                  [7])],\n                                   verbose=False)),\n                ('logregressor',\n                 LogisticRegression(C=100.0, class_weight=None, dual=False,\n                                    fit_intercept=True, intercept_scaling=1,\n                                    l1_ratio=None, max_iter=100,\n                                    multi_class='auto', n_jobs=None,\n                                    penalty='l2', random_state=None,\n                                    solver='liblinear', tol=0.0001, verbose=0,\n                                    warm_start=False))],\n         verbose=False)\n"
        }
      ],
      "execution_count": 8,
      "metadata": {
        "tags": []
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The pipeline encapsulates the preprocessing steps as well as model training.\n",
        "\n",
        "Let's use the model trained by this pipeline to predict labels for our test set, and compare the performance metrics with the basic model we created previously."
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "# Get predictions from test data\n",
        "predictions = model.predict(X_test)\n",
        "y_scores = model.predict_proba(X_test)\n",
        "\n",
        "# Get evaluation metrics\n",
        "cm = confusion_matrix(y_test, predictions)\n",
        "print ('Confusion Matrix:\\n',cm, '\\n')\n",
        "print('Accuracy:', accuracy_score(y_test, predictions))\n",
        "print(\"Overall Precision:\",precision_score(y_test, predictions))\n",
        "print(\"Overall Recall:\",recall_score(y_test, predictions))\n",
        "auc = roc_auc_score(y_test,y_scores[:,1])\n",
        "print('AUC: ' + str(auc))\n",
        "\n",
        "# calculate ROC curve\n",
        "fpr, tpr, thresholds = roc_curve(y_test, y_scores[:,1])\n",
        "\n",
        "# plot ROC curve\n",
        "fig = plt.figure(figsize=(6, 6))\n",
        "# Plot the diagonal 50% line\n",
        "plt.plot([0, 1], [0, 1], 'k--')\n",
        "# Plot the FPR and TPR achieved by our model\n",
        "plt.plot(fpr, tpr)\n",
        "plt.xlabel('False Positive Rate')\n",
        "plt.ylabel('True Positive Rate')\n",
        "plt.title('ROC Curve')\n",
        "plt.show()\n",
        "\n"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "Confusion Matrix:\n [[2667  319]\n [ 406 1108]] \n\nAccuracy: 0.8388888888888889\nOverall Precision: 0.7764540995094604\nOverall Recall: 0.7318361955085865\nAUC: 0.9202436115345857\n"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 600x600 with 1 Axes>",
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "execution_count": 10,
      "metadata": {
        "tags": []
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The results look a little better, so clearly preprocessing the data has made a difference.\n",
        "\n",
        "### Try a different algorithm\n",
        "\n",
        "Now let's try a different algorithm. Previously we used a logistic regression algorithm, which is a *linear* algorithm. There are many kinds of classification algorithm we could try, including:\n",
        "\n",
        "- **Support Vector Machine algorithms**: Algorithms that define a *hyperplane* that separates classes.\n",
        "- **Tree-based algorithms**: Algorithms that build a decision tree to reach a prediction\n",
        "- **Ensemble algorithms**: Algorithms that combine the outputs of multiple base algorithms to improve generalizability.\n",
        "\n",
        "This time, We'll use the same preprocessing steps as before, but we'll train the model using an *ensemble* algorithm named *Random Forest* that combines the outputs of multiple random decision trees (for more details, see the [Scikit-Learn documentation](https://scikit-learn.org/stable/modules/ensemble.html#forests-of-randomized-trees))."
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "\n",
        "# Create preprocessing and training pipeline\n",
        "pipeline = Pipeline(steps=[('preprocessor', preprocessor),\n",
        "                           ('logregressor', RandomForestClassifier(n_estimators=100))])\n",
        "\n",
        "# fit the pipeline to train a random forest model on the training set\n",
        "model = pipeline.fit(X_train, (y_train))\n",
        "print (model)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "Pipeline(memory=None,\n         steps=[('preprocessor',\n                 ColumnTransformer(n_jobs=None, remainder='drop',\n                                   sparse_threshold=0.3,\n                                   transformer_weights=None,\n                                   transformers=[('num',\n                                                  Pipeline(memory=None,\n                                                           steps=[('scaler',\n                                                                   StandardScaler(copy=True,\n                                                                                  with_mean=True,\n                                                                                  with_std=True))],\n                                                           verbose=False),\n                                                  [0, 1, 2, 3, 4, 5, 6]),\n                                                 ('cat',\n                                                  Pipeline(memory=None,\n                                                           steps=[('onehot',\n                                                                   OneHotEncoder(catego...\n                 RandomForestClassifier(bootstrap=True, ccp_alpha=0.0,\n                                        class_weight=None, criterion='gini',\n                                        max_depth=None, max_features='auto',\n                                        max_leaf_nodes=None, max_samples=None,\n                                        min_impurity_decrease=0.0,\n                                        min_impurity_split=None,\n                                        min_samples_leaf=1, min_samples_split=2,\n                                        min_weight_fraction_leaf=0.0,\n                                        n_estimators=100, n_jobs=None,\n                                        oob_score=False, random_state=None,\n                                        verbose=0, warm_start=False))],\n         verbose=False)\n"
        }
      ],
      "execution_count": 11,
      "metadata": {
        "tags": []
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's look at the performance metrics for the new model."
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "predictions = model.predict(X_test)\n",
        "y_scores = model.predict_proba(X_test)\n",
        "cm = confusion_matrix(y_test, predictions)\n",
        "print ('Confusion Matrix:\\n',cm, '\\n')\n",
        "print('Accuracy:', accuracy_score(y_test, predictions))\n",
        "print(\"Overall Precision:\",precision_score(y_test, predictions))\n",
        "print(\"Overall Recall:\",recall_score(y_test, predictions))\n",
        "auc = roc_auc_score(y_test,y_scores[:,1])\n",
        "print('\\nAUC: ' + str(auc))\n",
        "\n",
        "# calculate ROC curve\n",
        "fpr, tpr, thresholds = roc_curve(y_test, y_scores[:,1])\n",
        "\n",
        "# plot ROC curve\n",
        "fig = plt.figure(figsize=(6, 6))\n",
        "# Plot the diagonal 50% line\n",
        "plt.plot([0, 1], [0, 1], 'k--')\n",
        "# Plot the FPR and TPR achieved by our model\n",
        "plt.plot(fpr, tpr)\n",
        "plt.xlabel('False Positive Rate')\n",
        "plt.ylabel('True Positive Rate')\n",
        "plt.title('ROC Curve')\n",
        "plt.show()"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "Confusion Matrix:\n [[2857  129]\n [ 177 1337]] \n\nAccuracy: 0.932\nOverall Precision: 0.9120054570259208\nOverall Recall: 0.8830911492734478\n\nAUC: 0.9820609342939883\n"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 600x600 with 1 Axes>",
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "execution_count": 12,
      "metadata": {
        "tags": []
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "That looks better!\n",
        "\n",
        "### Use the Model for Inferencing\n",
        "Now that we have a reasonably useful trained model, we can save it for use later to predict labels for new data:"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "import joblib\n",
        "\n",
        "# Save the model as a pickle file\n",
        "filename = './diabetes_model.pkl'\n",
        "joblib.dump(model, filename)"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 13,
          "data": {
            "text/plain": "['./diabetes_model.pkl']"
          },
          "metadata": {}
        }
      ],
      "execution_count": 13,
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": [
        "When we have some new observations for which the label is unknown, we can load the model and use it to predict values for the unknown label:"
      ],
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": [
        "# Load the model from the file\n",
        "model = joblib.load(filename)\n",
        "\n",
        "# predict on a new sample\n",
        "# The model accepts an array of feature arrays (so you can predict the classes of multiple patients in a single call)\n",
        "# We'll create an array with a single array of features, representing one patient\n",
        "X_new = np.array([[2,180,74,24,21,23.9091702,1.488172308,22]])\n",
        "print ('New sample: {}'.format(list(X_new[0])))\n",
        "\n",
        "# Get a prediction\n",
        "pred = model.predict(X_new)\n",
        "\n",
        "# The model returns an array of predictions - one for each set of features submitted\n",
        "# In our case, we only submitted one patient, so our prediction is the first one in the resulting array.\n",
        "print('Predicted class is {}'.format(pred[0]))"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": "New sample: [2.0, 180.0, 74.0, 24.0, 21.0, 23.9091702, 1.488172308, 22.0]\nPredicted class is 1\n"
        }
      ],
      "execution_count": 14,
      "metadata": {
        "tags": []
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Summary\n",
        "\n",
        "In this notebook, we looked at a range of metrics for binary classification and tried a few algorithms beyond logistic regression. We will move onto more complex classification problems in the following notebook."
      ],
      "metadata": {}
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "conda-env-azureml_py38-py",
      "language": "python",
      "display_name": "azureml_py38"
    },
    "language_info": {
      "name": "python",
      "version": "3.8.5",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "kernel_info": {
      "name": "conda-env-azureml_py38-py"
    },
    "nteract": {
      "version": "nteract-front-end@1.0.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}