Pushing the docs to 1.5/ for branch: 1.5.X, commit 156ef141f3b270edb06c8ae9af37c55253c0aabe

Author: sklearn-ci

1.5/.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: d11dba821463e12eaf4819e95c5fa796
+config: 77a81589eb4374f7aa6937c4aeda73cb
 tags: 645f666f9bcd5a90fca523b33c5a78b7

1.5/_downloads/02fe21a1f5d14bd1ebbe34aa905d9bf6/plot_multilabel.zip

@@ -127,8 +127,8 @@ def plot_gpr_samples(gpr_model, n_samples, ax):
 )
 
 # %%
-# Rational Quadradtic kernel
-# ..........................
+# Rational Quadratic kernel
+# .........................
 from sklearn.gaussian_process.kernels import RationalQuadratic
 
 kernel = 1.0 * RationalQuadratic(length_scale=1.0, alpha=0.1, alpha_bounds=(1e-5, 1e15))
@@ -201,7 +201,7 @@ def plot_gpr_samples(gpr_model, n_samples, ax):
 kernel = ConstantKernel(0.1, (0.01, 10.0)) * (
     DotProduct(sigma_0=1.0, sigma_0_bounds=(0.1, 10.0)) ** 2
 )
-gpr = GaussianProcessRegressor(kernel=kernel, random_state=0)
+gpr = GaussianProcessRegressor(kernel=kernel, random_state=0, normalize_y=True)
 
 fig, axs = plt.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))
 

1.5/_downloads/0358b1921962fd7c6f5a94c5abc91476/plot_hashing_vs_dict_vectorizer.zip

@@ -68,7 +68,8 @@
 #   - ``weighted_n_node_samples[i]``: the weighted number of training samples
 #     reaching node ``i``
 #   - ``value[i, j, k]``: the summary of the training samples that reached node i for
-#     output j and class k (for regression tree, class is set to 1).
+#     output j and class k (for regression tree, class is set to 1). See below
+#     for more information about ``value``.
 #
 # Using the arrays, we can traverse the tree structure to compute various
 # properties. Below, we will compute the depth of each node and whether or not
@@ -108,7 +109,7 @@
     if is_leaves[i]:
         print(
             "{space}node={node} is a leaf node with value={value}.".format(
-                space=node_depth[i] * "\t", node=i, value=values[i]
+                space=node_depth[i] * "\t", node=i, value=np.around(values[i], 3)
             )
         )
     else:
@@ -122,24 +123,36 @@
                 feature=feature[i],
                 threshold=threshold[i],
                 right=children_right[i],
-                value=values[i],
+                value=np.around(values[i], 3),
             )
         )
 
 # %%
 # What is the values array used here?
 # -----------------------------------
 # The `tree_.value` array is a 3D array of shape
-# [``n_nodes``, ``n_classes``, ``n_outputs``] which provides the count of samples
-# reaching a node for each class and for each output. Each node has a ``value``
-# array which is the number of weighted samples reaching this
-# node for each output and class.
+# [``n_nodes``, ``n_classes``, ``n_outputs``] which provides the proportion of samples
+# reaching a node for each class and for each output.
+# Each node has a ``value`` array which is the proportion of weighted samples reaching
+# this node for each output and class with respect to the parent node.
+#
+# One could convert this to the absolute weighted number of samples reaching a node,
+# by multiplying this number by `tree_.weighted_n_node_samples[node_idx]` for the
+# given node. Note sample weights are not used in this example, so the weighted
+# number of samples is the number of samples reaching the node because each sample
+# has a weight of 1 by default.
 #
 # For example, in the above tree built on the iris dataset, the root node has
-# ``value = [37, 34, 41]``, indicating there are 37 samples
+# ``value = [0.33, 0.304, 0.366]`` indicating there are 33% of class 0 samples,
+# 30.4% of class 1 samples, and 36.6% of class 2 samples at the root node. One can
+# convert this to the absolute number of samples by multiplying by the number of
+# samples reaching the root node, which is `tree_.weighted_n_node_samples[0]`.
+# Then the root node has ``value = [37, 34, 41]``, indicating there are 37 samples
 # of class 0, 34 samples of class 1, and 41 samples of class 2 at the root node.
+#
 # Traversing the tree, the samples are split and as a result, the ``value`` array
-# reaching each node changes. The left child of the root node has ``value = [37, 0, 0]``
+# reaching each node changes. The left child of the root node has ``value = [1., 0, 0]``
+# (or ``value = [37, 0, 0]`` when converted to the absolute number of samples)
 # because all 37 samples in the left child node are from class 0.
 #
 # Note: In this example, `n_outputs=1`, but the tree classifier can also handle
@@ -148,8 +161,10 @@
 
 ##############################################################################
 # We can compare the above output to the plot of the decision tree.
+# Here, we show the proportions of samples of each class that reach each
+# node corresponding to the actual elements of `tree_.value` array.
 
-tree.plot_tree(clf)
+tree.plot_tree(clf, proportion=True)
 plt.show()
 
 ##############################################################################

1.5/_downloads/038d1885eb5f5ea53aca42da3031fe38/plot_document_clustering.zip

@@ -6,43 +6,46 @@
 Demonstrate the resolution of a regression problem
 using a k-Nearest Neighbor and the interpolation of the
 target using both barycenter and constant weights.
-
 """
 
 # Author: Alexandre Gramfort <[email protected]>
 #         Fabian Pedregosa <[email protected]>
 #
 # License: BSD 3 clause (C) INRIA
 
-
 # %%
 # Generate sample data
 # --------------------
+# Here we generate a few data points to use to train the model. We also generate
+# data in the whole range of the training data to visualize how the model would
+# react in that whole region.
 import matplotlib.pyplot as plt
 import numpy as np
 
 from sklearn import neighbors
 
-np.random.seed(0)
-X = np.sort(5 * np.random.rand(40, 1), axis=0)
-T = np.linspace(0, 5, 500)[:, np.newaxis]
-y = np.sin(X).ravel()
+rng = np.random.RandomState(0)
+X_train = np.sort(5 * rng.rand(40, 1), axis=0)
+X_test = np.linspace(0, 5, 500)[:, np.newaxis]
+y = np.sin(X_train).ravel()
 
 # Add noise to targets
 y[::5] += 1 * (0.5 - np.random.rand(8))
 
 # %%
 # Fit regression model
 # --------------------
+# Here we train a model and visualize how `uniform` and `distance`
+# weights in prediction effect predicted values.
 n_neighbors = 5
 
 for i, weights in enumerate(["uniform", "distance"]):
     knn = neighbors.KNeighborsRegressor(n_neighbors, weights=weights)
-    y_ = knn.fit(X, y).predict(T)
+    y_ = knn.fit(X_train, y).predict(X_test)
 
     plt.subplot(2, 1, i + 1)
-    plt.scatter(X, y, color="darkorange", label="data")
-    plt.plot(T, y_, color="navy", label="prediction")
+    plt.scatter(X_train, y, color="darkorange", label="data")
+    plt.plot(X_test, y_, color="navy", label="prediction")
     plt.axis("tight")
     plt.legend()
     plt.title("KNeighborsRegressor (k = %i, weights = '%s')" % (n_neighbors, weights))

1.5/_downloads/03c018a16384c69f3a89e473650d57ee/plot_svm_margin.zip

@@ -22,7 +22,7 @@
       },
       "outputs": [],
       "source": [
-        "from sklearn.inspection import permutation_importance\n\n\ndef plot_permutation_importance(clf, X, y, ax):\n    result = permutation_importance(clf, X, y, n_repeats=10, random_state=42, n_jobs=2)\n    perm_sorted_idx = result.importances_mean.argsort()\n\n    ax.boxplot(\n        result.importances[perm_sorted_idx].T,\n        vert=False,\n        labels=X.columns[perm_sorted_idx],\n    )\n    ax.axvline(x=0, color=\"k\", linestyle=\"--\")\n    return ax"
+        "import matplotlib\n\nfrom sklearn.inspection import permutation_importance\nfrom sklearn.utils.fixes import parse_version\n\n\ndef plot_permutation_importance(clf, X, y, ax):\n    result = permutation_importance(clf, X, y, n_repeats=10, random_state=42, n_jobs=2)\n    perm_sorted_idx = result.importances_mean.argsort()\n\n    # `labels` argument in boxplot is deprecated in matplotlib 3.9 and has been\n    # renamed to `tick_labels`. The following code handles this, but as a\n    # scikit-learn user you probably can write simpler code by using `labels=...`\n    # (matplotlib < 3.9) or `tick_labels=...` (matplotlib >= 3.9).\n    tick_labels_parameter_name = (\n        \"tick_labels\"\n        if parse_version(matplotlib.__version__) >= parse_version(\"3.9\")\n        else \"labels\"\n    )\n    tick_labels_dict = {tick_labels_parameter_name: X.columns[perm_sorted_idx]}\n    ax.boxplot(result.importances[perm_sorted_idx].T, vert=False, **tick_labels_dict)\n    ax.axvline(x=0, color=\"k\", linestyle=\"--\")\n    return ax"
       ]
     },
     {
@@ -58,7 +58,7 @@
       },
       "outputs": [],
       "source": [
-        "import matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\n\nmdi_importances = pd.Series(clf.feature_importances_, index=X_train.columns)\ntree_importance_sorted_idx = np.argsort(clf.feature_importances_)\ntree_indices = np.arange(0, len(clf.feature_importances_)) + 0.5\n\nfig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 8))\nmdi_importances.sort_values().plot.barh(ax=ax1)\nax1.set_xlabel(\"Gini importance\")\nplot_permutation_importance(clf, X_train, y_train, ax2)\nax2.set_xlabel(\"Decrease in accuracy score\")\nfig.suptitle(\n    \"Impurity-based vs. permutation importances on multicollinear features (train set)\"\n)\n_ = fig.tight_layout()"
+        "import matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\n\nmdi_importances = pd.Series(clf.feature_importances_, index=X_train.columns)\ntree_importance_sorted_idx = np.argsort(clf.feature_importances_)\n\nfig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 8))\nmdi_importances.sort_values().plot.barh(ax=ax1)\nax1.set_xlabel(\"Gini importance\")\nplot_permutation_importance(clf, X_train, y_train, ax2)\nax2.set_xlabel(\"Decrease in accuracy score\")\nfig.suptitle(\n    \"Impurity-based vs. permutation importances on multicollinear features (train set)\"\n)\n_ = fig.tight_layout()"
       ]
     },
     {

1.5/_downloads/041e98b4797bb4ddc34c0045e5886c3e/plot_digits_classification_exercise.zip

@@ -51,7 +51,7 @@
       },
       "outputs": [],
       "source": [
-        "import matplotlib.pyplot as plt\n\n\ndef plot_samples(S, axis_list=None):\n    plt.scatter(\n        S[:, 0], S[:, 1], s=2, marker=\"o\", zorder=10, color=\"steelblue\", alpha=0.5\n    )\n    if axis_list is not None:\n        for axis, color, label in axis_list:\n            axis /= axis.std()\n            x_axis, y_axis = axis\n            plt.quiver(\n                (0, 0),\n                (0, 0),\n                x_axis,\n                y_axis,\n                zorder=11,\n                width=0.01,\n                scale=6,\n                color=color,\n                label=label,\n            )\n\n    plt.hlines(0, -3, 3)\n    plt.vlines(0, -3, 3)\n    plt.xlim(-3, 3)\n    plt.ylim(-3, 3)\n    plt.xlabel(\"x\")\n    plt.ylabel(\"y\")\n\n\nplt.figure()\nplt.subplot(2, 2, 1)\nplot_samples(S / S.std())\nplt.title(\"True Independent Sources\")\n\naxis_list = [(pca.components_.T, \"orange\", \"PCA\"), (ica.mixing_, \"red\", \"ICA\")]\nplt.subplot(2, 2, 2)\nplot_samples(X / np.std(X), axis_list=axis_list)\nlegend = plt.legend(loc=\"lower right\")\nlegend.set_zorder(100)\n\nplt.title(\"Observations\")\n\nplt.subplot(2, 2, 3)\nplot_samples(S_pca_ / np.std(S_pca_, axis=0))\nplt.title(\"PCA recovered signals\")\n\nplt.subplot(2, 2, 4)\nplot_samples(S_ica_ / np.std(S_ica_))\nplt.title(\"ICA recovered signals\")\n\nplt.subplots_adjust(0.09, 0.04, 0.94, 0.94, 0.26, 0.36)\nplt.tight_layout()\nplt.show()"
+        "import matplotlib.pyplot as plt\n\n\ndef plot_samples(S, axis_list=None):\n    plt.scatter(\n        S[:, 0], S[:, 1], s=2, marker=\"o\", zorder=10, color=\"steelblue\", alpha=0.5\n    )\n    if axis_list is not None:\n        for axis, color, label in axis_list:\n            x_axis, y_axis = axis / axis.std()\n            plt.quiver(\n                (0, 0),\n                (0, 0),\n                x_axis,\n                y_axis,\n                zorder=11,\n                width=0.01,\n                scale=6,\n                color=color,\n                label=label,\n            )\n\n    plt.hlines(0, -5, 5, color=\"black\", linewidth=0.5)\n    plt.vlines(0, -3, 3, color=\"black\", linewidth=0.5)\n    plt.xlim(-5, 5)\n    plt.ylim(-3, 3)\n    plt.gca().set_aspect(\"equal\")\n    plt.xlabel(\"x\")\n    plt.ylabel(\"y\")\n\n\nplt.figure()\nplt.subplot(2, 2, 1)\nplot_samples(S / S.std())\nplt.title(\"True Independent Sources\")\n\naxis_list = [(pca.components_.T, \"orange\", \"PCA\"), (ica.mixing_, \"red\", \"ICA\")]\nplt.subplot(2, 2, 2)\nplot_samples(X / np.std(X), axis_list=axis_list)\nlegend = plt.legend(loc=\"upper left\")\nlegend.set_zorder(100)\n\nplt.title(\"Observations\")\n\nplt.subplot(2, 2, 3)\nplot_samples(S_pca_ / np.std(S_pca_))\nplt.title(\"PCA recovered signals\")\n\nplt.subplot(2, 2, 4)\nplot_samples(S_ica_ / np.std(S_ica_))\nplt.title(\"ICA recovered signals\")\n\nplt.subplots_adjust(0.09, 0.04, 0.94, 0.94, 0.26, 0.36)\nplt.tight_layout()\nplt.show()"
       ]
     }
   ],

1.5/_downloads/04b9a7769df5b331f4d94e1d065b4311/plot_voting_decision_regions.zip

@@ -34,6 +34,7 @@
 # `plot_confusion_matrix`. Read more about this new API in the
 # :ref:`User Guide <visualizations>`.
 
+import matplotlib
 import matplotlib.pyplot as plt
 
 from sklearn.datasets import make_classification
@@ -43,6 +44,7 @@
 from sklearn.metrics import RocCurveDisplay
 from sklearn.model_selection import train_test_split
 from sklearn.svm import SVC
+from sklearn.utils.fixes import parse_version
 
 X, y = make_classification(random_state=0)
 X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
@@ -117,9 +119,18 @@
 
 fig, ax = plt.subplots()
 sorted_idx = result.importances_mean.argsort()
-ax.boxplot(
-    result.importances[sorted_idx].T, vert=False, labels=feature_names[sorted_idx]
+
+# `labels` argument in boxplot is deprecated in matplotlib 3.9 and has been
+# renamed to `tick_labels`. The following code handles this, but as a
+# scikit-learn user you probably can write simpler code by using `labels=...`
+# (matplotlib < 3.9) or `tick_labels=...` (matplotlib >= 3.9).
+tick_labels_parameter_name = (
+    "tick_labels"
+    if parse_version(matplotlib.__version__) >= parse_version("3.9")
+    else "labels"
 )
+tick_labels_dict = {tick_labels_parameter_name: feature_names[sorted_idx]}
+ax.boxplot(result.importances[sorted_idx].T, vert=False, **tick_labels_dict)
 ax.set_title("Permutation Importance of each feature")
 ax.set_ylabel("Features")
 fig.tight_layout()

1.5/_downloads/053b58bbfc8177072856c743b2c93424/plot_varimax_fa.zip

@@ -17,13 +17,13 @@
 
 The two species are:
 
- - `"Bradypus variegatus"
-   <http://www.iucnredlist.org/details/3038/0>`_ ,
-   the Brown-throated Sloth.
+ - `Bradypus variegatus
+   <http://www.iucnredlist.org/details/3038/0>`_,
+   the brown-throated sloth.
 
- - `"Microryzomys minutus"
-   <http://www.iucnredlist.org/details/13408/0>`_ ,
-   also known as the Forest Small Rice Rat, a rodent that lives in Peru,
+ - `Microryzomys minutus
+   <http://www.iucnredlist.org/details/13408/0>`_,
+   also known as the forest small rice rat, a rodent that lives in Peru,
    Colombia, Ecuador, Peru, and Venezuela.
 
 References

1.5/_downloads/0639a004b8e8cf5b7fbcc4942c47e8ba/plot_validation_curve.zip

@@ -26,18 +26,27 @@
 # ------------------------------------------------------
 #
 # First, we define a function to ease the plotting:
+import matplotlib
+
 from sklearn.inspection import permutation_importance
+from sklearn.utils.fixes import parse_version
 
 
 def plot_permutation_importance(clf, X, y, ax):
     result = permutation_importance(clf, X, y, n_repeats=10, random_state=42, n_jobs=2)
     perm_sorted_idx = result.importances_mean.argsort()
 
-    ax.boxplot(
-        result.importances[perm_sorted_idx].T,
-        vert=False,
-        labels=X.columns[perm_sorted_idx],
+    # `labels` argument in boxplot is deprecated in matplotlib 3.9 and has been
+    # renamed to `tick_labels`. The following code handles this, but as a
+    # scikit-learn user you probably can write simpler code by using `labels=...`
+    # (matplotlib < 3.9) or `tick_labels=...` (matplotlib >= 3.9).
+    tick_labels_parameter_name = (
+        "tick_labels"
+        if parse_version(matplotlib.__version__) >= parse_version("3.9")
+        else "labels"
     )
+    tick_labels_dict = {tick_labels_parameter_name: X.columns[perm_sorted_idx]}
+    ax.boxplot(result.importances[perm_sorted_idx].T, vert=False, **tick_labels_dict)
     ax.axvline(x=0, color="k", linestyle="--")
     return ax
 
@@ -66,7 +75,6 @@ def plot_permutation_importance(clf, X, y, ax):
 
 mdi_importances = pd.Series(clf.feature_importances_, index=X_train.columns)
 tree_importance_sorted_idx = np.argsort(clf.feature_importances_)
-tree_indices = np.arange(0, len(clf.feature_importances_)) + 0.5
 
 fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 8))
 mdi_importances.sort_values().plot.barh(ax=ax1)

1.5/_downloads/06754f94d3767e38162c19499b317556/plot_digits_last_image.zip

@@ -87,7 +87,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### Rational Quadradtic kernel\n\n"
+        "### Rational Quadratic kernel\n\n"
       ]
     },
     {
@@ -156,7 +156,7 @@
       },
       "outputs": [],
       "source": [
-        "from sklearn.gaussian_process.kernels import ConstantKernel, DotProduct\n\nkernel = ConstantKernel(0.1, (0.01, 10.0)) * (\n    DotProduct(sigma_0=1.0, sigma_0_bounds=(0.1, 10.0)) ** 2\n)\ngpr = GaussianProcessRegressor(kernel=kernel, random_state=0)\n\nfig, axs = plt.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))\n\n# plot prior\nplot_gpr_samples(gpr, n_samples=n_samples, ax=axs[0])\naxs[0].set_title(\"Samples from prior distribution\")\n\n# plot posterior\ngpr.fit(X_train, y_train)\nplot_gpr_samples(gpr, n_samples=n_samples, ax=axs[1])\naxs[1].scatter(X_train[:, 0], y_train, color=\"red\", zorder=10, label=\"Observations\")\naxs[1].legend(bbox_to_anchor=(1.05, 1.5), loc=\"upper left\")\naxs[1].set_title(\"Samples from posterior distribution\")\n\nfig.suptitle(\"Dot-product kernel\", fontsize=18)\nplt.tight_layout()"
+        "from sklearn.gaussian_process.kernels import ConstantKernel, DotProduct\n\nkernel = ConstantKernel(0.1, (0.01, 10.0)) * (\n    DotProduct(sigma_0=1.0, sigma_0_bounds=(0.1, 10.0)) ** 2\n)\ngpr = GaussianProcessRegressor(kernel=kernel, random_state=0, normalize_y=True)\n\nfig, axs = plt.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))\n\n# plot prior\nplot_gpr_samples(gpr, n_samples=n_samples, ax=axs[0])\naxs[0].set_title(\"Samples from prior distribution\")\n\n# plot posterior\ngpr.fit(X_train, y_train)\nplot_gpr_samples(gpr, n_samples=n_samples, ax=axs[1])\naxs[1].scatter(X_train[:, 0], y_train, color=\"red\", zorder=10, label=\"Observations\")\naxs[1].legend(bbox_to_anchor=(1.05, 1.5), loc=\"upper left\")\naxs[1].set_title(\"Samples from posterior distribution\")\n\nfig.suptitle(\"Dot-product kernel\", fontsize=18)\nplt.tight_layout()"
       ]
     },
     {