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

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: 910925378d81091757cadf53646763e2
+config: 9b326f5a24b70ee04933e1c4cba406d7
 tags: 645f666f9bcd5a90fca523b33c5a78b7

dev/_downloads/07fcc19ba03226cd3d83d4e40ec44385/auto_examples_python.zip

@@ -0,0 +1,201 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n# Release Highlights for scikit-learn 1.5\n\n.. currentmodule:: sklearn\n\nWe are pleased to announce the release of scikit-learn 1.5! Many bug fixes\nand improvements were added, as well as some key new features. Below we\ndetail the highlights of this release. **For an exhaustive list of\nall the changes**, please refer to the `release notes <release_notes_1_5>`.\n\nTo install the latest version (with pip)::\n\n    pip install --upgrade scikit-learn\n\nor with conda::\n\n    conda install -c conda-forge scikit-learn\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## FixedThresholdClassifier: Setting the decision threshold of a binary classifier\nAll binary classifiers of scikit-learn use a fixed decision threshold of 0.5 to\nconvert probability estimates (i.e. output of `predict_proba`) into class\npredictions. However, 0.5 is almost never the desired threshold for a given problem.\n:class:`~model_selection.FixedThresholdClassifier` allows to wrap any binary\nclassifier and set a custom decision threshold.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.datasets import make_classification\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.metrics import confusion_matrix\n\nX, y = make_classification(n_samples=1_000, weights=[0.9, 0.1], random_state=0)\nclassifier = LogisticRegression(random_state=0).fit(X, y)\n\nprint(\"confusion matrix:\\n\", confusion_matrix(y, classifier.predict(X)))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Lowering the threshold, i.e. allowing more samples to be classified as the positive\nclass, increases the number of true positives at the cost of more false positives\n(as is well known from the concavity of the ROC curve).\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.model_selection import FixedThresholdClassifier\n\nwrapped_classifier = FixedThresholdClassifier(classifier, threshold=0.1).fit(X, y)\n\nprint(\"confusion matrix:\\n\", confusion_matrix(y, wrapped_classifier.predict(X)))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## TunedThresholdClassifierCV: Tuning the decision threshold of a binary classifier\nThe decision threshold of a binary classifier can be tuned to optimize a given\nmetric, using :class:`~model_selection.TunedThresholdClassifierCV`.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.metrics import balanced_accuracy_score\n\n# Due to the class imbalance, the balanced accuracy is not optimal for the default\n# threshold. The classifier tends to over predict the majority class.\nprint(f\"balanced accuracy: {balanced_accuracy_score(y, classifier.predict(X)):.2f}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Tuning the threshold to optimize the balanced accuracy gives a smaller threshold\nthat allows more samples to be classified as the positive class.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.model_selection import TunedThresholdClassifierCV\n\ntuned_classifier = TunedThresholdClassifierCV(\n    classifier, cv=5, scoring=\"balanced_accuracy\"\n).fit(X, y)\n\nprint(f\"new threshold: {tuned_classifier.best_threshold_:.4f}\")\nprint(\n    f\"balanced accuracy: {balanced_accuracy_score(y, tuned_classifier.predict(X)):.2f}\"\n)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        ":class:`~model_selection.TunedThresholdClassifierCV` also benefits from the\nmetadata routing support (`Metadata Routing User Guide<metadata_routing>`)\nallowing to optimze complex business metrics, detailed\nin `Post-tuning the decision threshold for cost-sensitive learning\n<sphx_glr_auto_examples_model_selection_plot_cost_sensitive_learning.py>`.\n\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Performance improvements in PCA\n:class:`~decomposition.PCA` has a new solver, \"covariance_eigh\", which is faster\nand more memory efficient than the other solvers for datasets with a large number\nof samples and a small number of features.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.datasets import make_low_rank_matrix\nfrom sklearn.decomposition import PCA\n\nX = make_low_rank_matrix(\n    n_samples=10_000, n_features=100, tail_strength=0.1, random_state=0\n)\n\npca = PCA(n_components=10).fit(X)\n\nprint(f\"explained variance: {pca.explained_variance_ratio_.sum():.2f}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "The \"full\" solver has also been improved to use less memory and allows to\ntransform faster. The \"auto\" option for the solver takes advantage of the\nnew solver and is now able to select an appropriate solver for sparse\ndatasets.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "from scipy.sparse import random\n\nX = random(10000, 100, format=\"csr\", random_state=0)\n\npca = PCA(n_components=10, svd_solver=\"auto\").fit(X)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## ColumnTransformer is subscriptable\nThe transformers of a :class:`~compose.ColumnTransformer` can now be directly\naccessed using indexing by name.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "import numpy as np\nfrom sklearn.compose import ColumnTransformer\nfrom sklearn.preprocessing import StandardScaler, OneHotEncoder\n\nX = np.array([[0, 1, 2], [3, 4, 5]])\ncolumn_transformer = ColumnTransformer(\n    [(\"std_scaler\", StandardScaler(), [0]), (\"one_hot\", OneHotEncoder(), [1, 2])]\n)\n\ncolumn_transformer.fit(X)\n\nprint(column_transformer[\"std_scaler\"])\nprint(column_transformer[\"one_hot\"])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Custom imputation strategies for the SimpleImputer\n:class:`~impute.SimpleImputer` now supports custom strategies for imputation,\nusing a callable that computes a scalar value from the non missing values of\na column vector.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.impute import SimpleImputer\n\nX = np.array(\n    [\n        [-1.1, 1.1, 1.1],\n        [3.9, -1.2, np.nan],\n        [np.nan, 1.3, np.nan],\n        [-0.1, -1.4, -1.4],\n        [-4.9, 1.5, -1.5],\n        [np.nan, 1.6, 1.6],\n    ]\n)\n\n\ndef smallest_abs(arr):\n    \"\"\"Return the smallest absolute value of a 1D array.\"\"\"\n    return np.min(np.abs(arr))\n\n\nimputer = SimpleImputer(strategy=smallest_abs)\n\nimputer.fit_transform(X)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Pairwise distances with non-numeric arrays\n:func:`~metrics.pairwise_distances` can now compute distances between\nnon-numeric arrays using a callable metric.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.metrics import pairwise_distances\n\nX = [\"cat\", \"dog\"]\nY = [\"cat\", \"fox\"]\n\n\ndef levenshtein_distance(x, y):\n    \"\"\"Return the Levenshtein distance between two strings.\"\"\"\n    if x == \"\" or y == \"\":\n        return max(len(x), len(y))\n    if x[0] == y[0]:\n        return levenshtein_distance(x[1:], y[1:])\n    return 1 + min(\n        levenshtein_distance(x[1:], y),\n        levenshtein_distance(x, y[1:]),\n        levenshtein_distance(x[1:], y[1:]),\n    )\n\n\npairwise_distances(X, Y, metric=levenshtein_distance)"
+      ]
+    }
+  ],
+  "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.9.19"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

dev/_downloads/6f1e7a639e0699d6164445b55e6c116d/auto_examples_jupyter.zip

@@ -0,0 +1,183 @@
+# ruff: noqa
+"""
+=======================================
+Release Highlights for scikit-learn 1.5
+=======================================
+
+.. currentmodule:: sklearn
+
+We are pleased to announce the release of scikit-learn 1.5! Many bug fixes
+and improvements were added, as well as some key new features. Below we
+detail the highlights of this release. **For an exhaustive list of
+all the changes**, please refer to the :ref:`release notes <release_notes_1_5>`.
+
+To install the latest version (with pip)::
+
+    pip install --upgrade scikit-learn
+
+or with conda::
+
+    conda install -c conda-forge scikit-learn
+
+"""
+
+# %%
+# FixedThresholdClassifier: Setting the decision threshold of a binary classifier
+# -------------------------------------------------------------------------------
+# All binary classifiers of scikit-learn use a fixed decision threshold of 0.5 to
+# convert probability estimates (i.e. output of `predict_proba`) into class
+# predictions. However, 0.5 is almost never the desired threshold for a given problem.
+# :class:`~model_selection.FixedThresholdClassifier` allows to wrap any binary
+# classifier and set a custom decision threshold.
+from sklearn.datasets import make_classification
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import confusion_matrix
+
+X, y = make_classification(n_samples=1_000, weights=[0.9, 0.1], random_state=0)
+classifier = LogisticRegression(random_state=0).fit(X, y)
+
+print("confusion matrix:\n", confusion_matrix(y, classifier.predict(X)))
+
+# %%
+# Lowering the threshold, i.e. allowing more samples to be classified as the positive
+# class, increases the number of true positives at the cost of more false positives
+# (as is well known from the concavity of the ROC curve).
+from sklearn.model_selection import FixedThresholdClassifier
+
+wrapped_classifier = FixedThresholdClassifier(classifier, threshold=0.1).fit(X, y)
+
+print("confusion matrix:\n", confusion_matrix(y, wrapped_classifier.predict(X)))
+
+# %%
+# TunedThresholdClassifierCV: Tuning the decision threshold of a binary classifier
+# --------------------------------------------------------------------------------
+# The decision threshold of a binary classifier can be tuned to optimize a given
+# metric, using :class:`~model_selection.TunedThresholdClassifierCV`.
+from sklearn.metrics import balanced_accuracy_score
+
+# Due to the class imbalance, the balanced accuracy is not optimal for the default
+# threshold. The classifier tends to over predict the majority class.
+print(f"balanced accuracy: {balanced_accuracy_score(y, classifier.predict(X)):.2f}")
+
+# %%
+# Tuning the threshold to optimize the balanced accuracy gives a smaller threshold
+# that allows more samples to be classified as the positive class.
+from sklearn.model_selection import TunedThresholdClassifierCV
+
+tuned_classifier = TunedThresholdClassifierCV(
+    classifier, cv=5, scoring="balanced_accuracy"
+).fit(X, y)
+
+print(f"new threshold: {tuned_classifier.best_threshold_:.4f}")
+print(
+    f"balanced accuracy: {balanced_accuracy_score(y, tuned_classifier.predict(X)):.2f}"
+)
+
+# %%
+# :class:`~model_selection.TunedThresholdClassifierCV` also benefits from the
+# metadata routing support (:ref:`Metadata Routing User Guide<metadata_routing>`)
+# allowing to optimze complex business metrics, detailed
+# in :ref:`Post-tuning the decision threshold for cost-sensitive learning
+# <sphx_glr_auto_examples_model_selection_plot_cost_sensitive_learning.py>`.
+
+# %%
+# Performance improvements in PCA
+# -------------------------------
+# :class:`~decomposition.PCA` has a new solver, "covariance_eigh", which is faster
+# and more memory efficient than the other solvers for datasets with a large number
+# of samples and a small number of features.
+from sklearn.datasets import make_low_rank_matrix
+from sklearn.decomposition import PCA
+
+X = make_low_rank_matrix(
+    n_samples=10_000, n_features=100, tail_strength=0.1, random_state=0
+)
+
+pca = PCA(n_components=10).fit(X)
+
+print(f"explained variance: {pca.explained_variance_ratio_.sum():.2f}")
+
+# %%
+# The "full" solver has also been improved to use less memory and allows to
+# transform faster. The "auto" option for the solver takes advantage of the
+# new solver and is now able to select an appropriate solver for sparse
+# datasets.
+from scipy.sparse import random
+
+X = random(10000, 100, format="csr", random_state=0)
+
+pca = PCA(n_components=10, svd_solver="auto").fit(X)
+
+# %%
+# ColumnTransformer is subscriptable
+# ----------------------------------
+# The transformers of a :class:`~compose.ColumnTransformer` can now be directly
+# accessed using indexing by name.
+import numpy as np
+from sklearn.compose import ColumnTransformer
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+
+X = np.array([[0, 1, 2], [3, 4, 5]])
+column_transformer = ColumnTransformer(
+    [("std_scaler", StandardScaler(), [0]), ("one_hot", OneHotEncoder(), [1, 2])]
+)
+
+column_transformer.fit(X)
+
+print(column_transformer["std_scaler"])
+print(column_transformer["one_hot"])
+
+# %%
+# Custom imputation strategies for the SimpleImputer
+# --------------------------------------------------
+# :class:`~impute.SimpleImputer` now supports custom strategies for imputation,
+# using a callable that computes a scalar value from the non missing values of
+# a column vector.
+from sklearn.impute import SimpleImputer
+
+X = np.array(
+    [
+        [-1.1, 1.1, 1.1],
+        [3.9, -1.2, np.nan],
+        [np.nan, 1.3, np.nan],
+        [-0.1, -1.4, -1.4],
+        [-4.9, 1.5, -1.5],
+        [np.nan, 1.6, 1.6],
+    ]
+)
+
+
+def smallest_abs(arr):
+    """Return the smallest absolute value of a 1D array."""
+    return np.min(np.abs(arr))
+
+
+imputer = SimpleImputer(strategy=smallest_abs)
+
+imputer.fit_transform(X)
+
+# %%
+# Pairwise distances with non-numeric arrays
+# ------------------------------------------
+# :func:`~metrics.pairwise_distances` can now compute distances between
+# non-numeric arrays using a callable metric.
+from sklearn.metrics import pairwise_distances
+
+X = ["cat", "dog"]
+Y = ["cat", "fox"]
+
+
+def levenshtein_distance(x, y):
+    """Return the Levenshtein distance between two strings."""
+    if x == "" or y == "":
+        return max(len(x), len(y))
+    if x[0] == y[0]:
+        return levenshtein_distance(x[1:], y[1:])
+    return 1 + min(
+        levenshtein_distance(x[1:], y),
+        levenshtein_distance(x, y[1:]),
+        levenshtein_distance(x[1:], y[1:]),
+    )
+
+
+pairwise_distances(X, Y, metric=levenshtein_distance)