Pushing the docs to dev/ for branch: main, commit 5d145bf760539d40f4e2c50c0f4c46200945c978

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: 532532c020da4c5a5fd3c1222d624cbe
+config: 876bf1130acd94fa0034f5c0777d7383
 tags: 645f666f9bcd5a90fca523b33c5a78b7

dev/_downloads/067cd5d39b097d2c49dd98f563dac13a/plot_iterative_imputer_variants_comparison.ipynb

@@ -4,7 +4,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "\n# Imputing missing values with variants of IterativeImputer\n\n.. currentmodule:: sklearn\n\nThe :class:`~impute.IterativeImputer` class is very flexible - it can be\nused with a variety of estimators to do round-robin regression, treating every\nvariable as an output in turn.\n\nIn this example we compare some estimators for the purpose of missing feature\nimputation with :class:`~impute.IterativeImputer`:\n\n* :class:`~linear_model.BayesianRidge`: regularized linear regression\n* :class:`~tree.RandomForestRegressor`: Forests of randomized trees regression\n* :func:`~pipeline.make_pipeline`(:class:`~kernel_approximation.Nystroem`,\n  :class:`~linear_model.Ridge`): a pipeline with the expansion of a degree 2\n  polynomial kernel and regularized linear regression\n* :class:`~neighbors.KNeighborsRegressor`: comparable to other KNN\n  imputation approaches\n\nOf particular interest is the ability of\n:class:`~impute.IterativeImputer` to mimic the behavior of missForest, a\npopular imputation package for R.\n\nNote that :class:`~neighbors.KNeighborsRegressor` is different from KNN\nimputation, which learns from samples with missing values by using a distance\nmetric that accounts for missing values, rather than imputing them.\n\nThe goal is to compare different estimators to see which one is best for the\n:class:`~impute.IterativeImputer` when using a\n:class:`~linear_model.BayesianRidge` estimator on the California housing\ndataset with a single value randomly removed from each row.\n\nFor this particular pattern of missing values we see that\n:class:`~linear_model.BayesianRidge` and\n:class:`~ensemble.RandomForestRegressor` give the best results.\n\nIt should be noted that some estimators such as\n:class:`~ensemble.HistGradientBoostingRegressor` can natively deal with\nmissing features and are often recommended over building pipelines with\ncomplex and costly missing values imputation strategies.\n"
+        "\n# Imputing missing values with variants of IterativeImputer\n\n.. currentmodule:: sklearn\n\nThe :class:`~impute.IterativeImputer` class is very flexible - it can be\nused with a variety of estimators to do round-robin regression, treating every\nvariable as an output in turn.\n\nIn this example we compare some estimators for the purpose of missing feature\nimputation with :class:`~impute.IterativeImputer`:\n\n* :class:`~linear_model.BayesianRidge`: regularized linear regression\n* :class:`~ensemble.RandomForestRegressor`: Forests of randomized trees regression\n* :func:`~pipeline.make_pipeline` (:class:`~kernel_approximation.Nystroem`,\n  :class:`~linear_model.Ridge`): a pipeline with the expansion of a degree 2\n  polynomial kernel and regularized linear regression\n* :class:`~neighbors.KNeighborsRegressor`: comparable to other KNN\n  imputation approaches\n\nOf particular interest is the ability of\n:class:`~impute.IterativeImputer` to mimic the behavior of missForest, a\npopular imputation package for R.\n\nNote that :class:`~neighbors.KNeighborsRegressor` is different from KNN\nimputation, which learns from samples with missing values by using a distance\nmetric that accounts for missing values, rather than imputing them.\n\nThe goal is to compare different estimators to see which one is best for the\n:class:`~impute.IterativeImputer` when using a\n:class:`~linear_model.BayesianRidge` estimator on the California housing\ndataset with a single value randomly removed from each row.\n\nFor this particular pattern of missing values we see that\n:class:`~linear_model.BayesianRidge` and\n:class:`~ensemble.RandomForestRegressor` give the best results.\n\nIt should be noted that some estimators such as\n:class:`~ensemble.HistGradientBoostingRegressor` can natively deal with\nmissing features and are often recommended over building pipelines with\ncomplex and costly missing values imputation strategies.\n"
       ]
     },
     {

dev/_downloads/07fcc19ba03226cd3d83d4e40ec44385/auto_examples_python.zip

@@ -25,7 +25,7 @@
 # ------------
 # We load two categories from the training set. You can adjust the number of
 # categories by adding their names to the list or setting `categories=None` when
-# calling the dataset loader :func:`~sklearn.datasets.fetch20newsgroups` to get
+# calling the dataset loader :func:`~sklearn.datasets.fetch_20newsgroups` to get
 # the 20 of them.
 
 from sklearn.datasets import fetch_20newsgroups

dev/_downloads/091282551e0bf11fedc96b869dfa8408/plot_grid_search_text_feature_extraction.py

@@ -4,7 +4,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "\n# Fitting an Elastic Net with a precomputed Gram Matrix and Weighted Samples\n\nThe following example shows how to precompute the gram matrix\nwhile using weighted samples with an ElasticNet.\n\nIf weighted samples are used, the design matrix must be centered and then\nrescaled by the square root of the weight vector before the gram matrix\nis computed.\n\n<div class=\"alert alert-info\"><h4>Note</h4><p>`sample_weight` vector is also rescaled to sum to `n_samples`, see the\n   documentation for the `sample_weight` parameter to\n   :func:`linear_model.ElasticNet.fit`.</p></div>\n"
+        "\n# Fitting an Elastic Net with a precomputed Gram Matrix and Weighted Samples\n\nThe following example shows how to precompute the gram matrix\nwhile using weighted samples with an :class:`~sklearn.linear_model.ElasticNet`.\n\nIf weighted samples are used, the design matrix must be centered and then\nrescaled by the square root of the weight vector before the gram matrix\nis computed.\n\n<div class=\"alert alert-info\"><h4>Note</h4><p>`sample_weight` vector is also rescaled to sum to `n_samples`, see the\n   documentation for the `sample_weight` parameter to\n   :meth:`~sklearn.linear_model.ElasticNet.fit`.</p></div>\n"
       ]
     },
     {

dev/_downloads/1054d40caffbd65c52b20dac784c7c5c/plot_elastic_net_precomputed_gram_matrix_with_weighted_samples.ipynb

@@ -128,8 +128,8 @@ def f(x):
 # Analysis of the error metrics
 # -----------------------------
 #
-# Measure the models with :func:`mean_squared_error` and
-# :func:`mean_pinball_loss` metrics on the training dataset.
+# Measure the models with :func:`~sklearn.metrics.mean_squared_error` and
+# :func:`~sklearn.metrics.mean_pinball_loss` metrics on the training dataset.
 import pandas as pd
 
 
@@ -156,7 +156,7 @@ def highlight_min(x):
 # training converged.
 #
 # Note that because the target distribution is asymmetric, the expected
-# conditional mean and conditional median are signficiantly different and
+# conditional mean and conditional median are significantly different and
 # therefore one could not use the squared error model get a good estimation of
 # the conditional median nor the converse.
 #
@@ -194,7 +194,7 @@ def highlight_min(x):
 # --------------------------------------
 #
 # We can also evaluate the ability of the two extreme quantile estimators at
-# producing a well-calibrated conditational 90%-confidence interval.
+# producing a well-calibrated conditional 90%-confidence interval.
 #
 # To do this we can compute the fraction of observations that fall between the
 # predictions:

dev/_downloads/2f3ef774a6d7e52e1e6b7ccbb75d25f0/plot_gradient_boosting_quantile.py

@@ -22,7 +22,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Data loading\nWe load two categories from the training set. You can adjust the number of\ncategories by adding their names to the list or setting `categories=None` when\ncalling the dataset loader :func:`~sklearn.datasets.fetch20newsgroups` to get\nthe 20 of them.\n\n"
+        "## Data loading\nWe load two categories from the training set. You can adjust the number of\ncategories by adding their names to the list or setting `categories=None` when\ncalling the dataset loader :func:`~sklearn.datasets.fetch_20newsgroups` to get\nthe 20 of them.\n\n"
       ]
     },
     {

dev/_downloads/3992a64e742c874f5df2ba26ae9c049b/plot_grid_search_text_feature_extraction.ipynb

@@ -112,7 +112,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "### ROC curve using micro-averaged OvR\n\nMicro-averaging aggregates the contributions from all the classes (using\n:func:`np.ravel`) to compute the average metrics as follows:\n\n$TPR=\\frac{\\sum_{c}TP_c}{\\sum_{c}(TP_c + FN_c)}$ ;\n\n$FPR=\\frac{\\sum_{c}FP_c}{\\sum_{c}(FP_c + TN_c)}$ .\n\nWe can briefly demo the effect of :func:`np.ravel`:\n\n"
+        "### ROC curve using micro-averaged OvR\n\nMicro-averaging aggregates the contributions from all the classes (using\n:func:`numpy.ravel`) to compute the average metrics as follows:\n\n$TPR=\\frac{\\sum_{c}TP_c}{\\sum_{c}(TP_c + FN_c)}$ ;\n\n$FPR=\\frac{\\sum_{c}FP_c}{\\sum_{c}(FP_c + TN_c)}$ .\n\nWe can briefly demo the effect of :func:`numpy.ravel`:\n\n"
       ]
     },
     {

dev/_downloads/40f4aad91af595a370d7582e3a23bed7/plot_roc.ipynb

@@ -5,7 +5,7 @@
 
 This example applies to :ref:`olivetti_faces_dataset` different unsupervised
 matrix decomposition (dimension reduction) methods from the module
-:py:mod:`sklearn.decomposition` (see the documentation chapter
+:mod:`sklearn.decomposition` (see the documentation chapter
 :ref:`decompositions`).
 
 
@@ -146,9 +146,10 @@ def plot_gallery(title, images, n_col=n_col, n_row=n_row, cmap=plt.cm.gray):
 # Sparse components - MiniBatchSparsePCA
 # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 #
-# Mini-batch sparse PCA (`MiniBatchSparsePCA`) extracts the set of sparse
-# components that best reconstruct the data. This variant is faster but
-# less accurate than the similar :py:mod:`sklearn.decomposition.SparsePCA`.
+# Mini-batch sparse PCA (:class:`~sklearn.decomposition.MiniBatchSparsePCA`)
+# extracts the set of sparse components that best reconstruct the data. This
+# variant is faster but less accurate than the similar
+# :class:`~sklearn.decomposition.SparsePCA`.
 
 # %%
 batch_pca_estimator = decomposition.MiniBatchSparsePCA(
@@ -164,9 +165,9 @@ def plot_gallery(title, images, n_col=n_col, n_row=n_row, cmap=plt.cm.gray):
 # Dictionary learning
 # ^^^^^^^^^^^^^^^^^^^
 #
-# By default, :class:`MiniBatchDictionaryLearning` divides the data into
-# mini-batches and optimizes in an online manner by cycling over the
-# mini-batches for the specified number of iterations.
+# By default, :class:`~sklearn.decomposition.MiniBatchDictionaryLearning`
+# divides the data into mini-batches and optimizes in an online manner by
+# cycling over the mini-batches for the specified number of iterations.
 
 # %%
 batch_dict_estimator = decomposition.MiniBatchDictionaryLearning(
@@ -179,9 +180,11 @@ def plot_gallery(title, images, n_col=n_col, n_row=n_row, cmap=plt.cm.gray):
 # Cluster centers - MiniBatchKMeans
 # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 #
-# `MiniBatchKMeans` is computationally efficient and implements on-line
-# learning with a `partial_fit` method. That is why it could be beneficial
-# to enhance some time-consuming algorithms with  `MiniBatchKMeans`.
+# :class:`sklearn.cluster.MiniBatchKMeans` is computationally efficient and
+# implements on-line learning with a
+# :meth:`~sklearn.decomposition.MiniBatchKMeans.partial_fit` method. That is
+# why it could be beneficial to enhance some time-consuming algorithms with
+# :class:`~sklearn.cluster.MiniBatchKMeans`.
 
 # %%
 kmeans_estimator = cluster.MiniBatchKMeans(
@@ -203,10 +206,10 @@ def plot_gallery(title, images, n_col=n_col, n_row=n_row, cmap=plt.cm.gray):
 # Factor Analysis components - FA
 # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 #
-# `Factor Analysis` is similar to `PCA` but has the advantage of modelling the
-# variance in every direction of the input space independently
-# (heteroscedastic noise).
-# Read more in the :ref:`User Guide <FA>`.
+# :class:`~sklearn.decomposition.FactorAnalysis` is similar to
+# :class:`~sklearn.decomposition.PCA` but has the advantage of modelling the
+# variance in every direction of the input space independently (heteroscedastic
+# noise). Read more in the :ref:`User Guide <FA>`.
 
 # %%
 fa_estimator = decomposition.FactorAnalysis(n_components=n_components, max_iter=20)
@@ -239,9 +242,10 @@ def plot_gallery(title, images, n_col=n_col, n_row=n_row, cmap=plt.cm.gray):
 # a dictionary. It is possible to constrain the dictionary and/or coding coefficients
 # to be positive to match constraints that may be present in the data.
 #
-# :class:`MiniBatchDictionaryLearning` implements a faster, but less accurate
-# version of the dictionary learning algorithm that is better suited for large
-# datasets. Read more in the :ref:`User Guide <MiniBatchDictionaryLearning>`.
+# :class:`~sklearn.decomposition.MiniBatchDictionaryLearning` implements a
+# faster, but less accurate version of the dictionary learning algorithm that
+# is better suited for large datasets. Read more in the :ref:`User Guide
+# <MiniBatchDictionaryLearning>`.
 
 # %%
 # Plot the same samples from our dataset but with another colormap.
@@ -252,11 +256,11 @@ def plot_gallery(title, images, n_col=n_col, n_row=n_row, cmap=plt.cm.gray):
 
 # %%
 # Similar to the previous examples, we change parameters and train
-# `MiniBatchDictionaryLearning` estimator on all images. Generally,
-# the dictionary learning and sparse encoding decompose input data
-# into the dictionary and the coding coefficients matrices.
-# :math:`X \approx UV`, where :math:`X = [x_1, . . . , x_n]`,
-# :math:`X \in \mathbb{R}^{m×n}`, dictionary :math:`U \in \mathbb{R}^{m×k}`, coding
+# :class:`~sklearn.decomposition.MiniBatchDictionaryLearning` estimator on all
+# images. Generally, the dictionary learning and sparse encoding decompose
+# input data into the dictionary and the coding coefficients matrices. :math:`X
+# \approx UV`, where :math:`X = [x_1, . . . , x_n]`, :math:`X \in
+# \mathbb{R}^{m×n}`, dictionary :math:`U \in \mathbb{R}^{m×k}`, coding
 # coefficients :math:`V \in \mathbb{R}^{k×n}`.
 #
 # Also below are the results when the dictionary and coding

dev/_downloads/4825fc8223d1af0f3b61080c3dea3a62/plot_faces_decomposition.py

@@ -24,7 +24,7 @@
 # %%
 # Quantile loss in :class:`ensemble.HistGradientBoostingRegressor`
 # ----------------------------------------------------------------
-# :class:`ensemble.HistGradientBoostingRegressor` can model quantiles with
+# :class:`~ensemble.HistGradientBoostingRegressor` can model quantiles with
 # `loss="quantile"` and the new parameter `quantile`.
 from sklearn.ensemble import HistGradientBoostingRegressor
 import numpy as np
@@ -56,7 +56,7 @@
 # `get_feature_names_out` Available in all Transformers
 # -----------------------------------------------------
 # :term:`get_feature_names_out` is now available in all Transformers. This enables
-# :class:`pipeline.Pipeline` to construct the output feature names for more complex
+# :class:`~pipeline.Pipeline` to construct the output feature names for more complex
 # pipelines:
 from sklearn.compose import ColumnTransformer
 from sklearn.preprocessing import OneHotEncoder, StandardScaler
@@ -101,12 +101,13 @@
 
 
 # %%
-# Grouping infrequent categories in :class:`OneHotEncoder`
-# --------------------------------------------------------
-# :class:`OneHotEncoder` supports aggregating infrequent categories into a single
-# output for each feature. The parameters to enable the gathering of infrequent
-# categories are `min_frequency` and `max_categories`. See the
-# :ref:`User Guide <encoder_infrequent_categories>` for more details.
+# Grouping infrequent categories in :class:`~preprocessing.OneHotEncoder`
+# -----------------------------------------------------------------------
+# :class:`~preprocessing.OneHotEncoder` supports aggregating infrequent
+# categories into a single output for each feature. The parameters to enable
+# the gathering of infrequent categories are `min_frequency` and
+# `max_categories`. See the :ref:`User Guide <encoder_infrequent_categories>`
+# for more details.
 from sklearn.preprocessing import OneHotEncoder
 import numpy as np
 
@@ -165,14 +166,15 @@
 # - :class:`linear_model.TweedieRegressor`
 
 # %%
-# MiniBatchNMF: an online version of NMF
-# --------------------------------------
-# The new class :class:`decomposition.MiniBatchNMF` implements a faster but less
-# accurate version of non-negative matrix factorization (:class:`decomposition.NMF`).
-# :class:`MiniBatchNMF` divides the data into mini-batches and optimizes the NMF model
-# in an online manner by cycling over the mini-batches, making it better suited for
-# large datasets. In particular, it implements `partial_fit`, which can be used for
-# online learning when the data is not readily available from the start, or when the
+# :class:`~decomposition.MiniBatchNMF`: an online version of NMF
+# --------------------------------------------------------------
+# The new class :class:`~decomposition.MiniBatchNMF` implements a faster but
+# less accurate version of non-negative matrix factorization
+# (:class:`~decomposition.NMF`). :class:`~decomposition.MiniBatchNMF` divides the
+# data into mini-batches and optimizes the NMF model in an online manner by
+# cycling over the mini-batches, making it better suited for large datasets. In
+# particular, it implements `partial_fit`, which can be used for online
+# learning when the data is not readily available from the start, or when the
 # data does not fit into memory.
 import numpy as np
 from sklearn.decomposition import MiniBatchNMF
@@ -198,13 +200,14 @@
 )
 
 # %%
-# BisectingKMeans: divide and cluster
-# -----------------------------------
-# The new class :class:`cluster.BisectingKMeans` is a variant of :class:`KMeans`, using
-# divisive hierarchical clustering. Instead of creating all centroids at once, centroids
-# are picked progressively based on a previous clustering: a cluster is split into two
-# new clusters repeatedly until the target number of clusters is reached, giving a
-# hierarchical structure to the clustering.
+# :class:`~cluster.BisectingKMeans`: divide and cluster
+# -----------------------------------------------------
+# The new class :class:`~cluster.BisectingKMeans` is a variant of
+# :class:`~cluster.KMeans`, using divisive hierarchical clustering. Instead of
+# creating all centroids at once, centroids are picked progressively based on a
+# previous clustering: a cluster is split into two new clusters repeatedly
+# until the target number of clusters is reached, giving a hierarchical
+# structure to the clustering.
 from sklearn.datasets import make_blobs
 from sklearn.cluster import KMeans, BisectingKMeans
 import matplotlib.pyplot as plt