{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Classification metrics\n", "Author: Geraldine Klarenberg\n", "\n", "Based on the Google Machine Learning Crash Course" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "## Tresholds\n", "In previous lessons, we have talked about using regression models to predict values. But sometimes we are interested in **classifying** things: \"spam\" vs \"not spam\", \"bark\" vs \"not barking\", etc. \n", "\n", "Logistic regression is a great tool to use in ML classification models. We can use the outputs from these models by defining **classification thresholds**. For instance, if our model tells us there's a probability of 0.8 that an email is spam (based on some characteristics), the model classifies it as such. If the probability estimate is less than 0.8, the model classifies it as \"not spam\". The threshold allows us to map a logistic regression value to a binary category (the prediction).\n", "\n", "Tresholds are problem-dependent, so they will have to be tuned for the specific problem you are dealing with.\n", "\n", "In this lesson we will look at metrics you can use to evaluate a classification model's predictions, and what changing the threshold does to your model and predictions." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## True, false, positive, negative...\n", "\n", "Now, we could simply look at \"accuracy\": the ratio of all correct predictions to all predictions. This is simple, intuitive and straightfoward. \n", "\n", "But there are some problems with this approach:\n", "* This approach does not work well if there is (class) imbalance; situations where certain negative or positive values or outcomes are rare; \n", "* and, most importantly: different kind of mistakes can have different costs..." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### The boy who cried wolf...\n", "\n", "We all know the story!\n", "\n", "![Illustration of the boy who cried wolf](../nb-images/wolfpic.jpg)\n", "\n", "For this example, we define \"there actually is a wolf\" as a positive class, and \"there is no wolf\" as a negative class. The predictions that a model makes can be true or false for both classes, generating 4 outcomes:\n", "\n", "![An table showing a confusion matrix based on the story of the boy who cried wolf](../nb-images/confusionmatrix_wolf.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This table is also called a *confusion matrix*.\n", "\n", "There are 2 metrics we can derive from these outcomes: precision and recall.\n", "\n", "## Precision\n", "Precision asks the question what proportion of the positive predictions was actually correct?\n", "\n", "To calculate the precision of your model, take all true positives divided by *all* positive predictions:\n", "$$\\text{Precision} = \\frac{TP}{TP+FP}$$\n", "\n", "Basically: **did the model cry 'wolf' too often or too little?**\n", "\n", "**NB** If your model produces no negative positives, the value of the precision is 1.0. Too many negative positives gives values greater than 1, too few gives values less than 1." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise\n", "Calculate the precision of a model with the following outcomes\n", "\n", "true positives (TP): 1 | false positives (FP): 1 \n", "-------|--------\n", "**false negatives (FN): 8** | **true negatives (TN): 90** " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Recall\n", "Recall tries to answer the question what proportion of actual positives was answered correctly?\n", "\n", "To calculate recall, divide all true positives by the true positives plus the false negatives:\n", "$$\\text{Recall} = \\frac{TP}{TP+FN}$$\n", "\n", "Basically: **how many wolves that tried to get into the village did the model actually get?**\n", "\n", "**NB** If the model produces no false negative, recall equals 1.0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise\n", "For the same confusion matrix as above, calculate the recall." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Balancing precision and recall\n", "To evaluate your model, should look at **both** precision and recall. They are often in tension though: improving one reduces the other.\n", "Lowering the classification treshold improves recall (your model will call wolf at every little sound it hears) but will negatively affect precision (it will call wolf too often)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise\n", "#### Part 1\n", "Look at the outputs of a model that classifies incoming emails as \"spam\" or \"not spam\".\n", "\n", "![Image of outcomes of a spam/not spam classification model](../nb-images/PrecisionVsRecallBase.svg)\n", "\n", "The confusion matrix looks as follows\n", "\n", "true positives (TP): 8 | false positives (FP): 2 \n", "-------|--------\n", "**false negatives (FN): 3** | **true negatives (TN): 17** \n", "\n", "Calculate the precision and recall for this model.\n", "\n", "#### Part 2\n", "Now see what happens to the outcomes (below) if we increase the threshold\n", "\n", "![Image of outcomes of a spam/not spam classification model](../nb-images/PrecisionVsRecallRaiseThreshold.svg)\n", "\n", "The confusion matrix looks as follows\n", "\n", "true positives (TP): 7 | false positives (FP): 4 \n", "-------|--------\n", "**false negatives (FN): 1** | **true negatives (TN): 18** \n", "\n", "Calculate the precision and recall again.\n", "\n", "**Compare the precision and recall from the first and second model. What do you notice?** " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Evaluate model performance\n", "We can evaluate the performance of a classification model at all classification thresholds. For all different thresholds, calculate the *true positive rate* and the *false positive rate*. The true positive rate is synonymous with recall (and sometimes called *sensitivity*) and is thus calculated as\n", "\n", "$ TPR = \\frac{TP} {TP + FN} $\n", "\n", "False positive rate (sometimes called *specificity*) is:\n", "\n", "$ FPR = \\frac{FP} {FP + TN} $\n", "\n", "When you plot the pairs of TPR and FPR for all the different thresholds, you get a Receiver Operating Characteristics (ROC) curve. Below is a typical ROC curve.\n", "\n", "![Image of an ROC curve](../nb-images/ROCCurve.svg)\n", "\n", "To evaluate the model, we look at the area under the curve (AUC). The AUC has a probabilistic interpretation: it represents the probability that a random positive (green) example is positioned to the right of a random negative (red) example.\n", "\n", "![Image with predictions ranked according to logistic regression score](../nb-images/AUCPredictionsRanked.svg)\n", "\n", "So if that AUC is 0.9, that's the probability the pair-wise prediction is correct. Below are a few visualizations of AUC results. On top are the distributions of the outcomes of the negative and positive outcomes at various thresholds. Below is the corresponding ROC.\n", "\n", "![Image with distributions of positive and negative classes - perfect](../nb-images/TowardsDataScienceAUC_perfect.png) \n", "![Image with AUC - perfect](../nb-images/TowardsDataScienceAUC_perfect2.png)\n", "**This AUC suggests a perfect model** (which is suspicious!)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![Image with distributions of positive and negative classes - normal](../nb-images/TowardsDataScienceAUC_normal.png)\n", "![Image with AUC - normal](../nb-images/TowardsDataScienceAUC_normal2.png)\n", "**This is what most AUCs look like**. In this case, AUC = 0.7 means that there is 70% chance the model will be able to distinguish between positive and negative classes." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![Image with distributions of positive and negative classes - worst](../nb-images/TowardsDataScienceAUC_worst.png)\n", "![Image with AUC - worst](../nb-images/TowardsDataScienceAUC_worst2.png)\n", "**This is actually the worst case scenario.** This model has no discrimination capacity at all... " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Prediction bias\n", "Logistic regression should be unbiased, meaning that the average of the predictions should be more or less equal to the average of the observations. **Prediction bias** is the difference between the average of the predictions and the average of the labels in a data set.\n", "\n", "This approach is not perfect, e.g. if your model almost always predicts the average there will not be much bias. However, if there **is** bias (\"significant nonzero bias\"), that means there is something something going on that needs to be checked, specifically that the model is wrong about the frequency of positive labels.\n", "\n", "Possible root causes of prediction bias are:\n", "* Incomplete feature set\n", "* Noisy data set\n", "* Buggy pipeline\n", "* Biased training sample\n", "* Overly strong regularization\n", "\n", "### Buckets and prediction bias\n", "For logistic regression, this process is a bit more involved, as the labels assigned to an examples are either 0 or 1. So you cannot accurately predict the prediction bias based on one example. You need to group data in \"buckets\" and examine the prediction bias on that. Prediction bias for logistic regression only makes sense when grouping enough examples together to be able to compare a predicted value (for example, 0.392) to observed values (for example, 0.394). \n", "\n", "You can create buckets by linearly breaking up the target predictions, or create quantiles. \n", "\n", "The plot below is a calibration plot. Each dot represents a bucket with 1000 values. On the x-axis we have the average value of the predictions for that bucket and on the y-axis the average of the actual observations. Note that the axes are on logarithmic scales.\n", "\n", "![Image of a calibration plot with buckets](../nb-images/BucketingBias.svg)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Coding\n", "Recall the logistic regression model we made in the previous lesson. That was a perfect fit, so not that useful when we look at the metrics we just discussed.\n", "\n", "In the cloud plot with the sepal length and petal width plotted against each other, it is clear that the other two iris species are less separated. Let's use one of these as an example. We'll rework the example so we're classifying irises for being \"virginica\" or \"not virginica\". " ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
sepal_length(cm)sepal_width(cm)petal_length(cm)petal_width(cm)species_idspecies_name
05.13.51.40.20setosa
14.93.01.40.20setosa
24.73.21.30.20setosa
34.63.11.50.20setosa
45.03.61.40.20setosa
\n", "
" ], "text/plain": [ " sepal_length(cm) sepal_width(cm) petal_length(cm) petal_width(cm) \\\n", "0 5.1 3.5 1.4 0.2 \n", "1 4.9 3.0 1.4 0.2 \n", "2 4.7 3.2 1.3 0.2 \n", "3 4.6 3.1 1.5 0.2 \n", "4 5.0 3.6 1.4 0.2 \n", "\n", " species_id species_name \n", "0 0 setosa \n", "1 0 setosa \n", "2 0 setosa \n", "3 0 setosa \n", "4 0 setosa " ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from sklearn.datasets import load_iris\n", "import pandas as pd\n", "\n", "iris = load_iris()\n", "\n", "X = iris.data\n", "y = iris.target\n", "\n", "df = pd.DataFrame(X, \n", " columns = ['sepal_length(cm)',\n", " 'sepal_width(cm)',\n", " 'petal_length(cm)',\n", " 'petal_width(cm)'])\n", "\n", "df['species_id'] = y\n", "\n", "species_map = {0: 'setosa', 1: 'versicolor', 2: 'virginica'}\n", "\n", "df['species_name'] = df['species_id'].map(species_map)\n", "\n", "df.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now extract the data we need and create the necessary dataframes again." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "X = np.c_[X[:,0], X[:,3]]" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "y = []\n", "for i in range(len(X)):\n", " if i > 99:\n", " y.append(1)\n", " else:\n", " y.append(0)\n", "\n", "y = np.array(y)\n", "\n", "plt.scatter(X[:,0], X[:,1], c = y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Create our test and train data, and run a model. The default classification threshold is 0.5. If the predicted probability is > 0.5, the predicted result is 'virgnica'. If it is < 0.5, the predicted result is 'not virginica'." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "random = np.random.permutation(len(X))\n", "x_train = X[random][30:]\n", "x_test = X[random][:30]\n", "\n", "y_train= y[random][30:]\n", "y_test = y[random][:30]" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n", " intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,\n", " penalty='l2', random_state=None, solver='liblinear', tol=0.0001,\n", " verbose=0, warm_start=False)" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sklearn.linear_model import LogisticRegression\n", "\n", "log_reg = LogisticRegression()\n", "log_reg.fit(x_train,y_train)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Instead of looking at the probabilities and the plot, like in the last lesson, let's run some classification metrics on the training dataset. \n", "\n", "If you use \".score\", you get the mean accuracy." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.95" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "log_reg.score(x_train, y_train)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's predict values and see what this ouput means and how we can look at other metrics." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(array([0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0,\n", " 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", " 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1,\n", " 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1,\n", " 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0,\n", " 0, 1, 0, 0, 1, 0, 0, 0, 0, 1]),\n", " array([0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0,\n", " 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,\n", " 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1,\n", " 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1,\n", " 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0,\n", " 0, 1, 0, 0, 1, 0, 0, 0, 0, 1]))" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "predictions = log_reg.predict(x_train)\n", "predictions, y_train" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There is a way to look at the confusion matrix. The output that is generated has the same structure as the confusion matrices we showed earlier:\n", "\n", "true positives (TP) | false positives (FP) \n", "-------|--------\n", "**false negatives (FN)** | **true negatives (TN)** " ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[81, 1],\n", " [ 5, 33]])" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sklearn.metrics import confusion_matrix\n", "confusion_matrix(y_train, predictions)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Indeed, for the accuracy calculation: we predicted 81 + 33 = 114 correct (true positives and true negatives), and 114/120 (remember, our training data had 120 points) = 0.95.\n", "\n", "There is also a function to calculate recall and precision:\n", "\n", "Since we also have a testing data set, let's see what the metrics look like for that." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.868421052631579" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sklearn.metrics import recall_score\n", "recall_score(y_train, predictions)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.9705882352941176" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sklearn.metrics import precision_score\n", "precision_score(y_train, predictions)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And, of course, there are also built-in functions to check the ROC curve and AUC! For these functions, the inputs are the labels of the original dataset and the predicted probabilities (- not the predicted labels -> **why?**). Remember what the two columns mean?" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[0.79088354, 0.20911646],\n", " [0.76441507, 0.23558493],\n", " [0.21376472, 0.78623528],\n", " [0.68298146, 0.31701854],\n", " [0.98434495, 0.01565505],\n", " [0.98202253, 0.01797747],\n", " [0.59645687, 0.40354313],\n", " [0.99162653, 0.00837347],\n", " [0.98955069, 0.01044931],\n", " [0.69536435, 0.30463565]])" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "proba_virginica = log_reg.predict_proba(x_train)\n", "proba_virginica[0:10]" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [], "source": [ "from sklearn.metrics import roc_curve\n", "fpr_model, tpr_model, thresholds_model = roc_curve(y_train, proba_virginica[:,1])" ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0. , 0. , 0. , 0. , 0. ,\n", " 0. , 0. , 0. , 0.01219512, 0.01219512,\n", " 0.03658537, 0.04878049, 0.04878049, 0.07317073, 0.07317073,\n", " 0.1097561 , 0.1097561 , 0.13414634, 0.15853659, 0.17073171,\n", " 0.19512195, 0.19512195, 0.20731707, 0.24390244, 0.35365854,\n", " 0.37804878, 0.41463415, 0.43902439, 0.57317073, 0.6097561 ,\n", " 0.62195122, 0.64634146, 0.68292683, 0.69512195, 0.7195122 ,\n", " 0.75609756, 0.76829268, 0.81707317, 0.84146341, 0.85365854,\n", " 0.87804878, 0.90243902, 0.92682927, 0.96341463, 0.98780488,\n", " 1. ])" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fpr_model" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.02631579, 0.21052632, 0.26315789, 0.42105263, 0.47368421,\n", " 0.5 , 0.55263158, 0.63157895, 0.63157895, 0.86842105,\n", " 0.86842105, 0.86842105, 0.89473684, 0.89473684, 0.92105263,\n", " 0.92105263, 0.94736842, 0.94736842, 0.94736842, 0.97368421,\n", " 0.97368421, 1. , 1. , 1. , 1. ,\n", " 1. , 1. , 1. , 1. , 1. ,\n", " 1. , 1. , 1. , 1. , 1. ,\n", " 1. , 1. , 1. , 1. , 1. ,\n", " 1. , 1. , 1. , 1. , 1. ,\n", " 1. ])" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tpr_model" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.9543821 , 0.88400175, 0.86877788, 0.78623528, 0.76976277,\n", " 0.75242062, 0.74626989, 0.70166775, 0.6840347 , 0.52035581,\n", " 0.49338248, 0.47269031, 0.46453574, 0.45209154, 0.44708893,\n", " 0.37018773, 0.35394216, 0.32247005, 0.31701854, 0.30463565,\n", " 0.30198749, 0.29512957, 0.29252928, 0.28736925, 0.20911646,\n", " 0.20705139, 0.1887098 , 0.18115478, 0.01842535, 0.01797747,\n", " 0.01698478, 0.01584934, 0.01565505, 0.01497238, 0.01460719,\n", " 0.01362849, 0.01346105, 0.0118611 , 0.01106433, 0.01044931,\n", " 0.01032052, 0.00950749, 0.00897822, 0.0088674 , 0.00837347,\n", " 0.00719249])" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "thresholds_model" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Plot the ROC curve as follows" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(fpr_model, tpr_model,label='our model')\n", "plt.plot([0,1],[0,1],label='random')\n", "plt.plot([0,0,1,1],[0,1,1,1],label='perfect')\n", "plt.xlabel('False Positive Rate')\n", "plt.ylabel('True Positive Rate')\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The AUC:" ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.9815468549422336" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sklearn.metrics import roc_auc_score\n", "auc_model = roc_auc_score(y_train, proba_virginica[:,1])\n", "auc_model" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can use the ROC and AUC metric to evaluate competing models. Many people prefer to use these metrics to analyze each model’s performance because it does not require selecting a threshold and helps balance true positive rate and false positive rate." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now let's do the same thing for our test data (but again, this dataset is fairly small, and K-fold cross-validation is recommended)." ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.9333333333333333" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "log_reg.score(x_test, y_test)" ] }, { "cell_type": "code", "execution_count": 55, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(array([0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1,\n", " 0, 1, 1, 1, 0, 1, 0, 0]),\n", " array([0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1,\n", " 0, 1, 1, 0, 0, 1, 0, 0]))" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "predictions = log_reg.predict(x_test)\n", "predictions, y_test" ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[17, 1],\n", " [ 1, 11]])" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "confusion_matrix(y_test, predictions)" ] }, { "cell_type": "code", "execution_count": 57, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.9166666666666666" ] }, "execution_count": 57, "metadata": {}, "output_type": "execute_result" } ], "source": [ "recall_score(y_test, predictions)" ] }, { "cell_type": "code", "execution_count": 59, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.9166666666666666" ] }, "execution_count": 59, "metadata": {}, "output_type": "execute_result" } ], "source": [ "precision_score(y_test, predictions)" ] }, { "cell_type": "code", "execution_count": 60, "metadata": {}, "outputs": [], "source": [ "proba_virginica = log_reg.predict_proba(x_test)\n", "fpr_model, tpr_model, thresholds_model = roc_curve(y_test, proba_virginica[:,1])" ] }, { "cell_type": "code", "execution_count": 61, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(fpr_model, tpr_model,label='our model')\n", "plt.plot([0,1],[0,1],label='random')\n", "plt.plot([0,0,1,1],[0,1,1,1],label='perfect')\n", "plt.xlabel('False Positive Rate')\n", "plt.ylabel('True Positive Rate')\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 62, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.9907407407407408" ] }, "execution_count": 62, "metadata": {}, "output_type": "execute_result" } ], "source": [ "auc_model = roc_auc_score(y_test, proba_virginica[:,1])\n", "auc_model" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Learn more about the logistic regression function and options at https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html" ] } ], "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 }