Pushing the docs to 1.1/ for branch: 1.1.X, commit c987b5ca84610bf5251ea8fa33b48c5826942a0d

Author: sklearn-ci

Diff for: 1.1/.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: 44afcf8dd215cc5d065a44ea3a818dd0
+config: d0bdad28d397ffd9f93c5892709f416d
 tags: 645f666f9bcd5a90fca523b33c5a78b7

Diff for: 1.1/_downloads/07fcc19ba03226cd3d83d4e40ec44385/auto_examples_python.zip

@@ -50,7 +50,7 @@
 ax.plot(X_1d, y, "o", alpha=0.5, markersize=1)
 for quantile, hist in hist_quantiles.items():
     ax.plot(X_1d, hist.predict(X), label=quantile)
-ax.legend(loc="lower left")
+_ = ax.legend(loc="lower left")
 
 
 # %%
@@ -96,6 +96,7 @@
 
 log_reg_input_features = log_reg[:-1].get_feature_names_out()
 pd.Series(log_reg[-1].coef_.ravel(), index=log_reg_input_features).plot.bar()
+plt.tight_layout()
 
 
 # %%
@@ -161,3 +162,64 @@
 # - :class:`linear_model.GammaRegressor`
 # - :class:`linear_model.PoissonRegressor`
 # - :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
+# data does not fit into memory.
+import numpy as np
+from sklearn.decomposition import MiniBatchNMF
+
+rng = np.random.RandomState(0)
+n_samples, n_features, n_components = 10, 10, 5
+true_W = rng.uniform(size=(n_samples, n_components))
+true_H = rng.uniform(size=(n_components, n_features))
+X = true_W @ true_H
+
+nmf = MiniBatchNMF(n_components=n_components, random_state=0)
+
+for _ in range(10):
+    nmf.partial_fit(X)
+
+W = nmf.transform(X)
+H = nmf.components_
+X_reconstructed = W @ H
+
+print(
+    f"relative reconstruction error: ",
+    f"{np.sum((X - X_reconstructed) ** 2) / np.sum(X**2):.5f}",
+)
+
+# %%
+# 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.
+from sklearn.datasets import make_blobs
+from sklearn.cluster import KMeans, BisectingKMeans
+import matplotlib.pyplot as plt
+
+X, _ = make_blobs(n_samples=1000, centers=2, random_state=0)
+
+km = KMeans(n_clusters=5, random_state=0).fit(X)
+bisect_km = BisectingKMeans(n_clusters=5, random_state=0).fit(X)
+
+fig, ax = plt.subplots(1, 2, figsize=(10, 5))
+ax[0].scatter(X[:, 0], X[:, 1], s=10, c=km.labels_)
+ax[0].scatter(km.cluster_centers_[:, 0], km.cluster_centers_[:, 1], s=20, c="r")
+ax[0].set_title("KMeans")
+
+ax[1].scatter(X[:, 0], X[:, 1], s=10, c=bisect_km.labels_)
+ax[1].scatter(
+    bisect_km.cluster_centers_[:, 0], bisect_km.cluster_centers_[:, 1], s=20, c="r"
+)
+_ = ax[1].set_title("BisectingKMeans")

Diff for: 1.1/_downloads/4cf0456267ced0f869a458ef4776d4c5/plot_release_highlights_1_1_0.py

@@ -33,7 +33,7 @@
       },
       "outputs": [],
       "source": [
-        "from sklearn.datasets import make_regression\nfrom sklearn.ensemble import HistGradientBoostingRegressor\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Simple regression function for X * cos(X)\nrng = np.random.RandomState(42)\nX_1d = np.linspace(0, 10, num=2000)\nX = X_1d.reshape(-1, 1)\ny = X_1d * np.cos(X_1d) + rng.normal(scale=X_1d / 3)\n\nquantiles = [0.95, 0.5, 0.05]\nparameters = dict(loss=\"quantile\", max_bins=32, max_iter=50)\nhist_quantiles = {\n    f\"quantile={quantile:.2f}\": HistGradientBoostingRegressor(\n        **parameters, quantile=quantile\n    ).fit(X, y)\n    for quantile in quantiles\n}\n\nfig, ax = plt.subplots()\nax.plot(X_1d, y, \"o\", alpha=0.5, markersize=1)\nfor quantile, hist in hist_quantiles.items():\n    ax.plot(X_1d, hist.predict(X), label=quantile)\nax.legend(loc=\"lower left\")"
+        "from sklearn.datasets import make_regression\nfrom sklearn.ensemble import HistGradientBoostingRegressor\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Simple regression function for X * cos(X)\nrng = np.random.RandomState(42)\nX_1d = np.linspace(0, 10, num=2000)\nX = X_1d.reshape(-1, 1)\ny = X_1d * np.cos(X_1d) + rng.normal(scale=X_1d / 3)\n\nquantiles = [0.95, 0.5, 0.05]\nparameters = dict(loss=\"quantile\", max_bins=32, max_iter=50)\nhist_quantiles = {\n    f\"quantile={quantile:.2f}\": HistGradientBoostingRegressor(\n        **parameters, quantile=quantile\n    ).fit(X, y)\n    for quantile in quantiles\n}\n\nfig, ax = plt.subplots()\nax.plot(X_1d, y, \"o\", alpha=0.5, markersize=1)\nfor quantile, hist in hist_quantiles.items():\n    ax.plot(X_1d, hist.predict(X), label=quantile)\n_ = ax.legend(loc=\"lower left\")"
       ]
     },
     {
@@ -69,7 +69,7 @@
       },
       "outputs": [],
       "source": [
-        "import pandas as pd\n\nlog_reg_input_features = log_reg[:-1].get_feature_names_out()\npd.Series(log_reg[-1].coef_.ravel(), index=log_reg_input_features).plot.bar()"
+        "import pandas as pd\n\nlog_reg_input_features = log_reg[:-1].get_feature_names_out()\npd.Series(log_reg[-1].coef_.ravel(), index=log_reg_input_features).plot.bar()\nplt.tight_layout()"
       ]
     },
     {
@@ -114,6 +114,42 @@
       "source": [
         "## Performance improvements\nReductions on pairwise distances for dense float64 datasets has been refactored\nto better take advantage of non-blocking thread parallelism. For example,\n:meth:`neighbors.NearestNeighbors.kneighbors` and\n:meth:`neighbors.NearestNeighbors.radius_neighbors` can respectively be up to \u00d720 and\n\u00d75 faster than previously. In summary, the following functions and estimators\nnow benefit from improved performance:\n\n- :func:`metrics.pairwise_distances_argmin`\n- :func:`metrics.pairwise_distances_argmin_min`\n- :class:`cluster.AffinityPropagation`\n- :class:`cluster.Birch`\n- :class:`cluster.MeanShift`\n- :class:`cluster.OPTICS`\n- :class:`cluster.SpectralClustering`\n- :func:`feature_selection.mutual_info_regression`\n- :class:`neighbors.KNeighborsClassifier`\n- :class:`neighbors.KNeighborsRegressor`\n- :class:`neighbors.RadiusNeighborsClassifier`\n- :class:`neighbors.RadiusNeighborsRegressor`\n- :class:`neighbors.LocalOutlierFactor`\n- :class:`neighbors.NearestNeighbors`\n- :class:`manifold.Isomap`\n- :class:`manifold.LocallyLinearEmbedding`\n- :class:`manifold.TSNE`\n- :func:`manifold.trustworthiness`\n- :class:`semi_supervised.LabelPropagation`\n- :class:`semi_supervised.LabelSpreading`\n\nTo know more about the technical details of this work, you can read\n`this suite of blog posts <https://blog.scikit-learn.org/technical/performances/>`_.\n\nMoreover, the computation of loss functions has been refactored using\nCython resulting in performance improvements for the following estimators:\n\n- :class:`linear_model.LogisticRegression`\n- :class:`linear_model.GammaRegressor`\n- :class:`linear_model.PoissonRegressor`\n- :class:`linear_model.TweedieRegressor`\n\n"
       ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## MiniBatchNMF: an online version of NMF\nThe new class :class:`decomposition.MiniBatchNMF` implements a faster but less\naccurate version of non-negative matrix factorization (:class:`decomposition.NMF`).\n:class:`MiniBatchNMF` divides the data into mini-batches and optimizes the NMF model\nin an online manner by cycling over the mini-batches, making it better suited for\nlarge datasets. In particular, it implements `partial_fit`, which can be used for\nonline learning when the data is not readily available from the start, or when the\ndata does not fit into memory.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "import numpy as np\nfrom sklearn.decomposition import MiniBatchNMF\n\nrng = np.random.RandomState(0)\nn_samples, n_features, n_components = 10, 10, 5\ntrue_W = rng.uniform(size=(n_samples, n_components))\ntrue_H = rng.uniform(size=(n_components, n_features))\nX = true_W @ true_H\n\nnmf = MiniBatchNMF(n_components=n_components, random_state=0)\n\nfor _ in range(10):\n    nmf.partial_fit(X)\n\nW = nmf.transform(X)\nH = nmf.components_\nX_reconstructed = W @ H\n\nprint(\n    f\"relative reconstruction error: \",\n    f\"{np.sum((X - X_reconstructed) ** 2) / np.sum(X**2):.5f}\",\n)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## BisectingKMeans: divide and cluster\nThe new class :class:`cluster.BisectingKMeans` is a variant of :class:`KMeans`, using\ndivisive hierarchical clustering. Instead of creating all centroids at once, centroids\nare picked progressively based on a previous clustering: a cluster is split into two\nnew clusters repeatedly until the target number of clusters is reached, giving a\nhierarchical structure to the clustering.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.datasets import make_blobs\nfrom sklearn.cluster import KMeans, BisectingKMeans\nimport matplotlib.pyplot as plt\n\nX, _ = make_blobs(n_samples=1000, centers=2, random_state=0)\n\nkm = KMeans(n_clusters=5, random_state=0).fit(X)\nbisect_km = BisectingKMeans(n_clusters=5, random_state=0).fit(X)\n\nfig, ax = plt.subplots(1, 2, figsize=(10, 5))\nax[0].scatter(X[:, 0], X[:, 1], s=10, c=km.labels_)\nax[0].scatter(km.cluster_centers_[:, 0], km.cluster_centers_[:, 1], s=20, c=\"r\")\nax[0].set_title(\"KMeans\")\n\nax[1].scatter(X[:, 0], X[:, 1], s=10, c=bisect_km.labels_)\nax[1].scatter(\n    bisect_km.cluster_centers_[:, 0], bisect_km.cluster_centers_[:, 1], s=20, c=\"r\"\n)\n_ = ax[1].set_title(\"BisectingKMeans\")"
+      ]
     }
   ],
   "metadata": {