scikit-learn

https://scikit-learn.org/stable/
Admin
scikit-learn is an open-source Python library providing simple and efficient tools for predictive...
Tokens:2,943,616
Snippets:22,017
Trust Score:9.5
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Imports and data setup

Source: https://scikit-learn.org/stable/_downloads/e79f7ef202cb51e147d56261691eae8d/plot_callback_support.ipynb

Imports and random data generation for the callback support example.

```python
import numpy as np

from sklearn.base import BaseEstimator, clone
from sklearn.callback import CallbackSupportMixin, ProgressBar, with_callbacks
from sklearn.metrics.pairwise import euclidean_distances
from sklearn.model_selection import check_cv
from sklearn.utils import check_random_state
from sklearn.utils.parallel import Parallel, delayed
from sklearn.utils.validation import check_is_fitted, validate_data

n_samples, n_features = 100, 4
rng = np.random.RandomState(42)
X = rng.rand(n_samples, n_features)
```

--------------------------------

### Import and setup for learning curve example

Source: https://scikit-learn.org/stable/_downloads/ca0bfe2435d9b3fffe21c713e63d3a6f/plot_learning_curve.ipynb

Imports the necessary modules and loads the digits dataset. Defines a GaussianNB and an SVC with RBF kernel for later use.

```python
# Authors: The scikit-learn developers
# SPDX-License-Identifier: BSD-3-Clause
```

```python
from sklearn.datasets import load_digits
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC

X, y = load_digits(return_X_y=True)
naive_bayes = GaussianNB()
svc = SVC(kernel="rbf", gamma=0.001)
```

--------------------------------

### Example: Get data home path and check existence

Source: https://scikit-learn.org/stable/modules/generated/sklearn.datasets.get_data_home.html

This example imports os and get_data_home, calls get_data_home() to get the default data directory path, and checks that the path exists.

```python
>>> import os
>>> from sklearn.datasets import get_data_home
>>> data_home_path = get_data_home()
>>> os.path.exists(data_home_path)
True
```

--------------------------------

### Imports and data setup for metadata routing examples

Source: https://scikit-learn.org/stable/metadata_routing.html

Required imports and synthetic data for all metadata routing examples. Creates X, y, my_groups, my_weights, and my_other_weights used in the subsequent cross_validate calls.

```python
>>> import numpy as np
>>> from sklearn.metrics import make_scorer, accuracy_score
>>> from sklearn.linear_model import LogisticRegressionCV, LogisticRegression
>>> from sklearn.model_selection import cross_validate, GridSearchCV, GroupKFold
>>> from sklearn.feature_selection import SelectKBest
>>> from sklearn.pipeline import make_pipeline
>>> n_samples, n_features = 100, 4
>>> rng = np.random.RandomState(42)
>>> X = rng.rand(n_samples, n_features)
>>> y = rng.randint(0, 2, size=n_samples)
>>> my_groups = rng.randint(0, 10, size=n_samples)
>>> my_weights = rng.rand(n_samples)
>>> my_other_weights = rng.rand(n_samples)
```

--------------------------------

### Import libraries and set license header

Source: https://scikit-learn.org/stable/auto_examples/inspection/plot_linear_model_coefficient_interpretation.html

Initial setup for the example: license header and imports for plotting, numerical operations, data handling, scientific computing, and seaborn for visualization.

```python
# Authors: The scikit-learn developers
# SPDX-License-Identifier: BSD-3-Clause

```

```python
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import scipy as sp
import seaborn as sns

```

--------------------------------

### log_loss with probability estimates

Source: https://scikit-learn.org/stable/modules/model_evaluation.html

Demonstrates log_loss with ground-truth labels and a probability matrix. The first entry [.9, .1] indicates 90% probability for label 0. The log loss is non-negative and equals 0.1738 in this example.

```python
>>> from sklearn.metrics import log_loss
>>> y_true = [0, 0, 1, 1]
>>> y_proba = [[.9, .1], [.8, .2], [.3, .7], [.01, .99]]
>>> log_loss(y_true, y_proba)
0.1738
```

--------------------------------

### Compute ranking loss with sklearn.metrics.label_ranking_loss

Source: https://scikit-learn.org/stable/modules/model_evaluation.html

Shows how to compute the ranking loss using sklearn.metrics.label_ranking_loss. The example first computes a loss of 0.75 for a given score matrix, then updates y_score to a perfect prediction and shows the loss becomes 0.0.

```python
>>> import numpy as np
>>> from sklearn.metrics import label_ranking_loss
>>> y_true = np.array([[1, 0, 0], [0, 0, 1]])
>>> y_score = np.array([[0.75, 0.5, 1], [1, 0.2, 0.1]])
>>> label_ranking_loss(y_true, y_score)
0.75
>>> # With the following prediction, we have perfect and minimal loss
>>> y_score = np.array([[1.0, 0.1, 0.2], [0.1, 0.2, 0.9]])
>>> label_ranking_loss(y_true, y_score)
0.0
```

--------------------------------

### Binary classification metrics with scikit-learn

Source: https://scikit-learn.org/stable/modules/model_evaluation.html

These examples demonstrate binary classification metrics using scikit-learn. The first shows precision, recall, F1, and F-beta scores for a small dataset, including the output of precision_recall_fscore_support. The second computes precision-recall curves and average precision for a binary classifier with scores.

```python
>>> from sklearn import metrics
>>> y_pred = [0, 1, 0, 0]
>>> y_true = [0, 1, 0, 1]
>>> metrics.precision_score(y_true, y_pred)
1.0
>>> metrics.recall_score(y_true, y_pred)
0.5
>>> metrics.f1_score(y_true, y_pred)
0.66
>>> metrics.fbeta_score(y_true, y_pred, beta=0.5)
0.83
>>> metrics.fbeta_score(y_true, y_pred, beta=1)
0.66
>>> metrics.fbeta_score(y_true, y_pred, beta=2)
0.55
>>> metrics.precision_recall_fscore_support(y_true, y_pred, beta=0.5)
(array([0.66, 1.        ]), array([1. , 0.5]), array([0.71, 0.83]), array([2, 2]))
```

```python
>>> import numpy as np
>>> from sklearn.metrics import precision_recall_curve
>>> from sklearn.metrics import average_precision_score
>>> y_true = np.array([0, 0, 1, 1])
>>> y_scores = np.array([0.1, 0.4, 0.35, 0.8])
>>> precision, recall, threshold = precision_recall_curve(y_true, y_scores)
>>> precision
array([0.5       , 0.66, 0.5       , 1.        , 1.        ])
>>> recall
array([1. , 1. , 0.5, 0.5, 0. ])
>>> threshold
array([0.1 , 0.35, 0.4 , 0.8 ])
>>> average_precision_score(y_true, y_scores)
0.83
```

--------------------------------

### Multi-label ROC AUC with decision values

Source: https://scikit-learn.org/stable/modules/model_evaluation.html

Shows how to compute multi-label ROC AUC using decision values, which do not require the probability processing shown in the previous example. The output is an array of per-label AUC scores.

```python
>>> from sklearn.linear_model import RidgeClassifierCV
>>> clf = RidgeClassifierCV().fit(X, y)
>>> y_score = clf.decision_function(X)
>>> roc_auc_score(y, y_score, average=None)
array([0.82, 0.85, 0.93, 0.87, 0.94])
```

--------------------------------

### Using a string scorer with cross_val_score

Source: https://scikit-learn.org/stable/modules/model_evaluation.html

Shows how to pass a string scorer name (e.g., 'recall_macro') to cross_val_score. The example loads the iris dataset, creates an SVM classifier, and evaluates it with 5-fold cross-validation, outputting the array of scores.

```python
>>> from sklearn import svm, datasets
>>> from sklearn.model_selection import cross_val_score
>>> X, y = datasets.load_iris(return_X_y=True)
>>> clf = svm.SVC(random_state=0)
>>> cross_val_score(clf, X, y, cv=5, scoring='recall_macro')
array([0.96, 0.96, 0.96, 0.93, 1.        ])
```

--------------------------------

### Compute coverage error with sklearn.metrics.coverage_error

Source: https://scikit-learn.org/stable/modules/model_evaluation.html

Shows how to compute the coverage error metric using sklearn.metrics.coverage_error. The example uses a binary indicator matrix y_true and a score matrix y_score, and prints the resulting coverage error value of 2.5.

```python
>>> import numpy as np
>>> from sklearn.metrics import coverage_error
>>> y_true = np.array([[1, 0, 0], [0, 0, 1]])
>>> y_score = np.array([[0.75, 0.5, 1], [1, 0.2, 0.1]])
>>> coverage_error(y_true, y_score)
2.5
```

--------------------------------

### d2_log_loss_score usage examples

Source: https://scikit-learn.org/stable/modules/model_evaluation.html

Shows three calls to d2_log_loss_score with different y_true and y_proba inputs. The first returns 0.0 for a constant prediction, the second returns 0.981 for near-perfect predictions, and the third returns -0.552 for a model worse than the null model.

```python
>>> from sklearn.metrics import d2_log_loss_score
>>> y_true = [1, 1, 2, 3]
>>> y_proba = [
...    [0.5, 0.25, 0.25],
...    [0.5, 0.25, 0.25],
...    [0.5, 0.25, 0.25],
...    [0.5, 0.25, 0.25],
... ]
>>> d2_log_loss_score(y_true, y_proba)
0.0
>>> y_true = [1, 2, 3]
>>> y_proba = [
...     [0.98, 0.01, 0.01],
...     [0.01, 0.98, 0.01],
...     [0.01, 0.01, 0.98],
... ]
>>> d2_log_loss_score(y_true, y_proba)
0.981
>>> y_true = [1, 2, 3]
>>> y_proba = [
...     [0.1, 0.6, 0.3],
...     [0.1, 0.6, 0.3],
...     [0.4, 0.5, 0.1],
... ]
>>> d2_log_loss_score(y_true, y_proba)
-0.552
```

--------------------------------

### top_k_accuracy_score with k=2

Source: https://scikit-learn.org/stable/modules/model_evaluation.html

Computes top-k accuracy, a generalization of accuracy_score where a prediction is correct if the true label is among the k highest predicted scores. The example uses k=2 and shows the fraction (0.75) and the count (3.0) with normalize=False.

```python
>>> import numpy as np
>>> from sklearn.metrics import top_k_accuracy_score
>>> y_true = np.array([0, 1, 2, 2])
>>> y_score = np.array([[0.5, 0.2, 0.2],
...                     [0.3, 0.4, 0.2],
...                     [0.2, 0.4, 0.3],
...                     [0.7, 0.2, 0.1]])
>>> top_k_accuracy_score(y_true, y_score, k=2)
0.75
>>> # Not normalizing gives the number of "correctly" classified samples
>>> top_k_accuracy_score(y_true, y_score, k=2, normalize=False)
3.0
```

--------------------------------

### Compute zero_one_loss for multilabel classification

Source: https://scikit-learn.org/stable/modules/model_evaluation.html

Computes the zero-one loss for a multilabel classification example with binary label indicators. The first label set [0,1] has an error, so the default normalized loss is 0.5 (percentage of imperfectly predicted subsets). Setting normalize to False returns the count of such subsets (1.0).

```python
>>> zero_one_loss(np.array([[0, 1], [1, 1]]), np.ones((2, 2)))
0.5

>>> zero_one_loss(np.array([[0, 1], [1, 1]]), np.ones((2, 2)),  normalize=False)
1.0
```

--------------------------------

### Binary ROC AUC with predict_proba and decision_function

Source: https://scikit-learn.org/stable/modules/model_evaluation.html

Binary classification example using the breast cancer dataset. The first block fits a LogisticRegression and shows that classes_[1] is 1. The second block computes ROC AUC from probability estimates via predict_proba(X)[:, 1]. The third block uses non-thresholded decision values from decision_function(X); both yield 0.99.

```python
>>> from sklearn.datasets import load_breast_cancer
>>> from sklearn.linear_model import LogisticRegression
>>> from sklearn.metrics import roc_auc_score
>>> X, y = load_breast_cancer(return_X_y=True)
>>> clf = LogisticRegression().fit(X, y)
>>> clf.classes_
array([0, 1])
```

```python
>>> y_score = clf.predict_proba(X)[:, 1]
>>> roc_auc_score(y, y_score)
0.99
```

```python
>>> roc_auc_score(y, clf.decision_function(X))
0.99
```

--------------------------------

### Build documentation with example gallery

Source: https://scikit-learn.org/stable/developers/contributing.html

Generate the documentation including the example gallery. This runs all examples and takes a while.

```bash
make html

```

--------------------------------

### Build documentation with selected examples

Source: https://scikit-learn.org/stable/developers/contributing.html

Build the documentation while running only examples whose filenames match the given pattern. Supports regular expressions for more advanced filtering.

```bash
EXAMPLES_PATTERN="plot_calibration" make html

```

--------------------------------

### Import required libraries for Affinity Propagation

Source: https://scikit-learn.org/stable/_downloads/91999ecc168932f9034d0cbc1cc248fa/plot_affinity_propagation.ipynb

Imports numpy, metrics, AffinityPropagation, and make_blobs. This is the setup for the example.

```python
# Authors: The scikit-learn developers
# SPDX-License-Identifier: BSD-3-Clause

import numpy as np

from sklearn import metrics
from sklearn.cluster import AffinityPropagation
from sklearn.datasets import make_blobs
```

--------------------------------

### Serve built documentation locally

Source: https://scikit-learn.org/stable/developers/contributing.html

Run a local HTTP server to view the built HTML documentation in a web browser. The built files are placed in _build/html/.

```bash
python -m http.server -d _build/html

```

--------------------------------

### Imports and random data for callback example

Source: https://scikit-learn.org/stable/auto_examples/callbacks/plot_callback_support.html

Imports required modules and generates random data (X) with 100 samples and 4 features using a fixed random state. This setup is used throughout the example script.

```python
# Authors: The scikit-learn developers
# SPDX-License-Identifier: BSD-3-Clause

```

```python
import numpy as np

from sklearn.base import BaseEstimator, clone
from sklearn.callback import CallbackSupportMixin, ProgressBar, with_callbacks
from sklearn.metrics.pairwise import euclidean_distances
from sklearn.model_selection import check_cv
from sklearn.utils import check_random_state
from sklearn.utils.parallel import Parallel, delayed
from sklearn.utils.validation import check_is_fitted, validate_data

n_samples, n_features = 100, 4
rng = np.random.RandomState(42)
X = rng.rand(n_samples, n_features)

```

--------------------------------

### Setup and data generation

Source: https://scikit-learn.org/stable/_downloads/fd3181da9f1988c60c583c95e97389f8/plot_feature_agglomeration_vs_univariate_selection.ipynb

Imports necessary modules, sets up a temporary cache directory, and generates synthetic data with a small number of informative features.

```python
print(__doc__)

# Code source: Gaël Varoquaux
# Modified for documentation by Jaques Grobler
# License: BSD 3 clause

import shutil
import tempfile

import numpy as np
import matplotlib.pyplot as plt
from scipy import ndimage
from sklearn import feature_selection
from sklearn.cluster import FeatureAgglomeration
from sklearn.feature_extraction.image import grid_to_graph
from sklearn.linear_model import Ridge
from sklearn.pipeline import Pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import KFold

###############################################################################
# Generate data
size = 1

rng = np.random.RandomState(0)
X = rng.randn(200, 100)
y = X[:, 0] + 2 * X[:, 1] - X[:, 2] - 2 * X[:, 3]

###############################################################################
# The learning rate and the number of samples are set to be small to keep the
# example fast and to illustrate the benefit of feature agglomeration.

# Create a temporary directory to store the caching files
cachedir = tempfile.mkdtemp()
mem = Memory(location=cachedir, verbose=0)

# Create the feature agglomeration object
agglomeration = FeatureAgglomeration(n_clusters=5, connectivity=grid_to_graph(n_x=size, n_y=size))

# Create the pipeline: agglomeration -> ridge regression
clf = Pipeline([("agglomeration", agglomeration), ("ridge", ridge)])

# Fit the pipeline with cross-validation
cv = KFold(n_splits=5, shuffle=True, random_state=0)
clf.fit(X, y)

# Extract the coefficients and inverse the transformation to plot them
coef_ = clf.best_estimator_.steps[-1][1].coef_
coef_ = clf.best_estimator_.steps[0][1].inverse_transform(coef_.reshape(1, -1))
coef_agglomeration_ = coef_.reshape(size, size)
```

--------------------------------

### Import libraries and set up matplotlib

Source: https://scikit-learn.org/stable/_downloads/69531acbb2cc9d87ef86f75c8eaba68d/plot_sgdocsvm_vs_ocsvm.ipynb

Imports required libraries and sets matplotlib font parameters. This is the initial setup for the example.

```python
import matplotlib
import matplotlib.lines as mlines
import matplotlib.pyplot as plt
import numpy as np

from sklearn.kernel_approximation import Nystroem
from sklearn.linear_model import SGDOneClassSVM
from sklearn.pipeline import make_pipeline
from sklearn.svm import OneClassSVM

font = {"weight": "normal", "size": 15}

matplotlib.rc("font", **font)
```

--------------------------------

### set_output

Source: https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.StackingClassifier.html

Set output container. Refer to the user guide for more details and Introducing the set_output API for an example on how to use the API.

```APIDOC
## set_output

### Description
Set output container. Refer to the user guide for more details and Introducing the set_output API for an example on how to use the API.

### Method
`set_output(_*_, _transform =None_)`

### Parameters
- **transform** ({“default”, “pandas”, “polars”}, default=None) - Optional - Configure output of `transform` and `fit_transform`.
  - `"default"`: Default output format of a transformer
  - `"pandas"`: DataFrame output
  - `"polars"`: Polars output
  - `None`: Transform configuration is unchanged

Added in version 1.4: `"polars"` option was added.

### Returns
- **self** (estimator instance) - Estimator instance.
```

--------------------------------

### Import libraries and set up parameters

Source: https://scikit-learn.org/stable/_downloads/49cd91d05440a1c88b074430761aeb76/plot_cv_indices.ipynb

Imports required libraries and sets up random state, colormaps, and the number of splits for the cross-validation visualization examples.

```python
# Authors: The scikit-learn developers
# SPDX-License-Identifier: BSD-3-Clause

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.patches import Patch

from sklearn.model_selection import (
    GroupKFold,
    GroupShuffleSplit,
    KFold,
    ShuffleSplit,
    StratifiedGroupKFold,
    StratifiedKFold,
    StratifiedShuffleSplit,
    TimeSeriesSplit,
)

rng = np.random.RandomState(1338)
cmap_data = plt.cm.Paired
cmap_cv = plt.cm.coolwarm
n_splits = 4
```

--------------------------------

### Prepare ARM64 development folder and download tools

Source: https://scikit-learn.org/stable/developers/tips.html

Prepares a folder on the host filesystem and downloads the necessary tools and source code for ARM64 development. This is the first step in setting up a local dev environment to reproduce ARM-specific bugs on an x86_64 host.

```bash
mkdir arm64
pushd arm64
wget https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-Linux-aarch64.sh
git clone https://github.com/scikit-learn/scikit-learn.git
```

--------------------------------

### Query neighbors within a radius with BallTree

Source: https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.BallTree.html

Query for neighbors within a given radius using BallTree. The example uses query_radius with r=0.3, first with count_only=True to get the count (3), then without to get the indices of neighbors within that distance.

```python
>>> import numpy as np
>>> rng = np.random.RandomState(0)
>>> X = rng.random_sample((10, 3))  # 10 points in 3 dimensions
>>> tree = BallTree(X, leaf_size=2)
>>> print(tree.query_radius(X[:1], r=0.3, count_only=True))
3
>>> ind = tree.query_radius(X[:1], r=0.3)
>>> print(ind)  # indices of neighbors within distance 0.3
[3 0 1]
```

--------------------------------

### Query neighbors within a radius with KDTree

Source: https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KDTree.html

Query for neighbors within a given radius using the KDTree. The example uses query_radius with r=0.3, first with count_only=True to get the count (3), then without to get the indices of neighbors within that distance.

```python
>>> import numpy as np
>>> rng = np.random.RandomState(0)
>>> X = rng.random_sample((10, 3))  # 10 points in 3 dimensions
>>> tree = KDTree(X, leaf_size=2)
>>> print(tree.query_radius(X[:1], r=0.3, count_only=True))
3
>>> ind = tree.query_radius(X[:1], r=0.3)
>>> print(ind)  # indices of neighbors within distance 0.3
[3 0 1]

```

--------------------------------

### Build documentation without example gallery

Source: https://scikit-learn.org/stable/developers/contributing.html

Generate the documentation website without the example gallery. The output is placed in the _build/html/stable directory.

```bash
make

```

--------------------------------

### SplineTransformer B-spline basis example

Source: https://scikit-learn.org/stable/auto_examples/release_highlights/plot_release_highlights_1_0_0.html

The SplineTransformer generates a B-spline basis for continuous features. This example fits a degree-2 spline with 3 knots on a simple 5x1 array and shows the resulting transformed output. Refer to the User Guide for more details.

```python
import numpy as np

from sklearn.preprocessing import SplineTransformer

X = np.arange(5).reshape(5, 1)
spline = SplineTransformer(degree=2, n_knots=3)
spline.fit_transform(X)

```

```python
array([[0.5  , 0.5  , 0.   , 0.   ],
       [0.125, 0.75 , 0.125, 0.   ],
       [0.   , 0.5  , 0.5  , 0.   ],
       [0.   , 0.125, 0.75 , 0.125],
       [0.   , 0.   , 0.5  , 0.5  ]])

```

--------------------------------

### Example: Retrieve configuration keys with sklearn.get_config

Source: https://scikit-learn.org/stable/modules/generated/sklearn.get_config.html

Import sklearn and call get_config to obtain the configuration dictionary. The example prints the keys of the returned dictionary, which are the parameter names accepted by set_config.

```python
>>> import sklearn
>>> config = sklearn.get_config()
>>> config.keys()
dict_keys([...])
```
Tokens:
Raw