Pushing the docs to dev/ for branch: master, commit 923b13ceda1d1d26a1013d0e326734a1dc58bd46

Author: sklearn-ci

dev/.buildinfo

@@ -1,4 +1,4 @@
 # Sphinx build info version 1
 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: 26d4fa1243e0e76d5cd0208238c65303
+config: 39d2e4864eb47d9365787dcc7c68a004
 tags: 645f666f9bcd5a90fca523b33c5a78b7

dev/_downloads/3409d9766d352cc9f9b169d4a799a87a/auto_examples_python.zip

@@ -116,7 +116,7 @@
       },
       "outputs": [],
       "source": [
-        "# Sets this image as the thumbnail for sphinx gallery\n# sphinx_gallery_thumbnail_number = 4\nfig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 6))\ntree_disp.plot(ax=[ax1, ax2], line_kw={\"label\": \"Decision Tree\"})\nmlp_disp.plot(ax=[ax1, ax2], line_kw={\"label\": \"Multi-layer Perceptron\",\n                                      \"c\": \"red\"})\nax1.legend()\nax2.legend()"
+        "# Sets this image as the thumbnail for sphinx gallery\nfig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 6))\ntree_disp.plot(ax=[ax1, ax2], line_kw={\"label\": \"Decision Tree\"})\nmlp_disp.plot(ax=[ax1, ax2], line_kw={\"label\": \"Multi-layer Perceptron\",\n                                      \"c\": \"red\"})\nax1.legend()\nax2.legend()"
       ]
     },
     {

dev/_downloads/51a82a09a4aa0f703f69fb5d4f15104f/plot_partial_dependence_visualization_api.ipynb

@@ -0,0 +1,92 @@
+"""
+===================================
+Visualizations with Display Objects
+===================================
+
+.. currentmodule:: sklearn.metrics
+
+In this example, we will construct display objects,
+:class:`ConfusionMatrixDisplay`, :class:`RocCurveDisplay`, and
+:class:`PrecisionRecallDisplay` directly from their respective metrics. This
+is an alternative to using their corresponding plot functions when
+a model's predictions are already computed or expensive to compute. Note that
+this is advanced usage, and in general we recommend using their respective
+plot functions.
+"""
+print(__doc__)
+
+##############################################################################
+# Load Data and train model
+# -------------------------
+# For this example, we load a blood transfusion service center data set from
+# `OpenML <https://www.openml.org/d/1464>`. This is a binary classification
+# problem where the target is whether an individual donated blood. Then the
+# data is split into a train and test dataset and a logistic regression is
+# fitted wtih the train dataset.
+from sklearn.datasets import fetch_openml
+from sklearn.preprocessing import StandardScaler
+from sklearn.pipeline import make_pipeline
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import train_test_split
+
+X, y = fetch_openml(data_id=1464, return_X_y=True)
+X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y)
+
+clf = make_pipeline(StandardScaler(), LogisticRegression(random_state=0))
+clf.fit(X_train, y_train)
+
+##############################################################################
+# Create :class:`ConfusionMatrixDisplay`
+##############################################################################
+# With the fitted model, we compute the predictions of the model on the test
+# dataset. These predictions are used to compute the confustion matrix which
+# is plotted with the :class:`ConfusionMatrixDisplay`
+from sklearn.metrics import confusion_matrix
+from sklearn.metrics import ConfusionMatrixDisplay
+
+y_pred = clf.predict(X_test)
+cm = confusion_matrix(y_test, y_pred)
+
+cm_display = ConfusionMatrixDisplay(cm).plot()
+
+
+##############################################################################
+# Create :class:`RocCurveDisplay`
+##############################################################################
+# The roc curve requires either the probabilities or the non-thresholded
+# decision values from the estimator. Since the logistic regression provides
+# a decision function, we will use it to plot the roc curve:
+from sklearn.metrics import roc_curve
+from sklearn.metrics import RocCurveDisplay
+y_score = clf.decision_function(X_test)
+
+fpr, tpr, _ = roc_curve(y_test, y_score, pos_label=clf.classes_[1])
+roc_display = RocCurveDisplay(fpr=fpr, tpr=tpr).plot()
+
+##############################################################################
+# Create :class:`PrecisionRecallDisplay`
+##############################################################################
+# Similarly, the precision recall curve can be plotted using `y_score` from
+# the prevision sections.
+from sklearn.metrics import precision_recall_curve
+from sklearn.metrics import PrecisionRecallDisplay
+
+prec, recall, _ = precision_recall_curve(y_test, y_score,
+                                         pos_label=clf.classes_[1])
+pr_display = PrecisionRecallDisplay(precision=prec, recall=recall).plot()
+
+##############################################################################
+# Combining the display objects into a single plot
+##############################################################################
+# The display objects store the computed values that were passed as arguments.
+# This allows for the visualizations to be easliy combined using matplotlib's
+# API. In the following example, we place the displays next to each other in a
+# row.
+
+# sphinx_gallery_thumbnail_number = 4
+import matplotlib.pyplot as plt
+fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 8))
+
+roc_display.plot(ax=ax1)
+pr_display.plot(ax=ax2)
+plt.show()

dev/_downloads/6b9502775fe3dcb099461779d414c83f/plot_display_object_visualization.py

@@ -0,0 +1,144 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "%matplotlib inline"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n# Visualizations with Display Objects\n\n\n.. currentmodule:: sklearn.metrics\n\nIn this example, we will construct display objects,\n:class:`ConfusionMatrixDisplay`, :class:`RocCurveDisplay`, and\n:class:`PrecisionRecallDisplay` directly from their respective metrics. This\nis an alternative to using their corresponding plot functions when\na model's predictions are already computed or expensive to compute. Note that\nthis is advanced usage, and in general we recommend using their respective\nplot functions.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "print(__doc__)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Load Data and train model\n-------------------------\nFor this example, we load a blood transfusion service center data set from\n`OpenML <https://www.openml.org/d/1464>`. This is a binary classification\nproblem where the target is whether an individual donated blood. Then the\ndata is split into a train and test dataset and a logistic regression is\nfitted wtih the train dataset.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.datasets import fetch_openml\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.pipeline import make_pipeline\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.model_selection import train_test_split\n\nX, y = fetch_openml(data_id=1464, return_X_y=True)\nX_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y)\n\nclf = make_pipeline(StandardScaler(), LogisticRegression(random_state=0))\nclf.fit(X_train, y_train)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Create :class:`ConfusionMatrixDisplay`\n#############################################################################\n With the fitted model, we compute the predictions of the model on the test\n dataset. These predictions are used to compute the confustion matrix which\n is plotted with the :class:`ConfusionMatrixDisplay`\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.metrics import confusion_matrix\nfrom sklearn.metrics import ConfusionMatrixDisplay\n\ny_pred = clf.predict(X_test)\ncm = confusion_matrix(y_test, y_pred)\n\ncm_display = ConfusionMatrixDisplay(cm).plot()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Create :class:`RocCurveDisplay`\n#############################################################################\n The roc curve requires either the probabilities or the non-thresholded\n decision values from the estimator. Since the logistic regression provides\n a decision function, we will use it to plot the roc curve:\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.metrics import roc_curve\nfrom sklearn.metrics import RocCurveDisplay\ny_score = clf.decision_function(X_test)\n\nfpr, tpr, _ = roc_curve(y_test, y_score, pos_label=clf.classes_[1])\nroc_display = RocCurveDisplay(fpr=fpr, tpr=tpr).plot()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Create :class:`PrecisionRecallDisplay`\n#############################################################################\n Similarly, the precision recall curve can be plotted using `y_score` from\n the prevision sections.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.metrics import precision_recall_curve\nfrom sklearn.metrics import PrecisionRecallDisplay\n\nprec, recall, _ = precision_recall_curve(y_test, y_score,\n                                         pos_label=clf.classes_[1])\npr_display = PrecisionRecallDisplay(precision=prec, recall=recall).plot()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Combining the display objects into a single plot\n#############################################################################\n The display objects store the computed values that were passed as arguments.\n This allows for the visualizations to be easliy combined using matplotlib's\n API. In the following example, we place the displays next to each other in a\n row.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "import matplotlib.pyplot as plt\nfig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 8))\n\nroc_display.plot(ax=ax1)\npr_display.plot(ax=ax2)\nplt.show()"
+      ]
+    }
+  ],
+  "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.2"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}