Основные новшества scikit-learn 1.8

Поддержка Array API (позволяет выполнять вычисления на GPU)

Постепенное внедрение стандарта Python Array API в scikit-learn означает, что входные массивы PyTorch и CuPy используются напрямую. Это позволяет использовать в оценщиках и функциях scikit-learn устройства, отличные от CPU, например GPU, для выполнения вычислений. В результате повышается производительность и упрощается интеграция с этими библиотеками.

В scikit-learn 1.8 поддержка входных данных, совместимых с Array API, была добавлена в несколько оценщиков и функций, например в тензоры PyTorch и массивы CuPy.

Поддержка Array API добавлена в следующие оценщики: preprocessing.StandardScaler, preprocessing.PolynomialFeatures, linear_model.RidgeCV, linear_model.RidgeClassifierCV, mixture.GaussianMixture и calibration.CalibratedClassifierCV.

Поддержка Array API также добавлена в несколько метрик модуля sklearn.metrics. Подробнее см. в разделе Поддержка входных данных, совместимых с Array API.

Инструкции по использованию scikit-learn с библиотеками, совместимыми с Array API, например PyTorch или CuPy, приведены на странице поддержки Array API. Примечание: поддержка Array API является экспериментальной и должна быть явно включена как в SciPy, так и в scikit-learn.

Ниже приведён фрагмент кода, который сначала использует препроцессор для создания признаков на CPU, а затем calibration.CalibratedClassifierCV и linear_model.RidgeCV совместно на GPU с помощью PyTorch:

ridge_pipeline_gpu = make_pipeline(
    # Ensure that all features (including categorical features) are preprocessed
    # on the CPU and mapped to a numerical representation.
    feature_preprocessor,
    # Move the results to the GPU and perform computations there
    FunctionTransformer(
        lambda x: torch.tensor(x.to_numpy().astype(np.float32), device="cuda"))
    ,
    CalibratedClassifierCV(
        RidgeClassifierCV(alphas=alphas), method="temperature"
    ),
)
with sklearn.config_context(array_api_dispatch=True):
    cv_results = cross_validate(ridge_pipeline_gpu, features, target)

Подробнее см. в полном блокноте в Google Colab. В этом конкретном примере использование GPU в Colab вместо одного ядра CPU ускоряет выполнение в 10 раз — это довольно типично для таких задач.

Поддержка свободнопоточного CPython 3.14

scikit-learn поддерживает свободнопоточный CPython; в частности, для всех поддерживаемых платформ доступны свободнопоточные колёса для Python 3.14.

Мы будем очень признательны за отзывы пользователей. Вот несколько вещей, которые можно попробовать:

• установите свободнопоточный CPython 3.14, запустите свой скрипт scikit-learn и проверьте, не возникли ли неожиданные ошибки. Обратите внимание: настоятельно рекомендуется использовать CPython 3.14, а не 3.13, поскольку после выхода CPython 3.13 было исправлено несколько ошибок свободнопоточного режима.

• если вы используете некоторые оценщики с параметром n_jobs, попробуйте изменить backend по умолчанию на threading с помощью joblib.parallel_config, как показано во фрагменте ниже. Это может ускорить выполнение кода, поскольку backend joblib по умолчанию использует процессы и создаёт большую нагрузку, чем потоки.

  grid_search = GridSearchCV(clf, param_grid=param_grid, n_jobs=4)
  with joblib.parallel_config(backend="threading"):
      grid_search.fit(X, y)
  

• не стесняйтесь сообщать о любых проблемах или неожиданном поведении производительности, создав обращение на GitHub!

Свободнопоточный CPython (также известный как nogil) — это версия CPython, призванная обеспечить эффективное использование нескольких потоков за счёт удаления глобальной блокировки интерпретатора (GIL).

Подробнее о свободнопоточном CPython см. в документации py-free-threading, в частности в разделах об установке свободнопоточного CPython и отслеживания совместимости экосистемы.

В scikit-learn одна из целей свободнопоточного Python — эффективнее задействовать многоядерные CPU, используя потоки вместо подпроцессов для параллельных вычислений при передаче n_jobs>1 в функции или оценщики. Ожидается повышение эффективности за счёт устранения необходимости в межпроцессном взаимодействии. Учтите, что переключение backend joblib по умолчанию и проверка корректной работы всего кода со свободнопоточным Python — это продолжающаяся долгосрочная работа.

Масштабирование температуры в CalibratedClassifierCV

Калибровка вероятностей классификаторов с помощью масштабирования температуры доступна в calibration.CalibratedClassifierCV, если задать method="temperature". Этот метод особенно хорошо подходит для задач многоклассовой классификации, поскольку позволяет получить (более) точные калиброванные вероятности всего с одним свободным параметром. Это отличается от всех остальных доступных методов калибровки, в которых используется схема «один против остальных» и добавляются дополнительные параметры для каждого класса.

from sklearn.calibration import CalibratedClassifierCV
from sklearn.datasets import make_classification
from sklearn.naive_bayes import GaussianNB

X, y = make_classification(n_classes=3, n_informative=8, random_state=42)
clf = GaussianNB().fit(X, y)
sig = CalibratedClassifierCV(clf, method="sigmoid", ensemble=False).fit(X, y)
ts = CalibratedClassifierCV(clf, method="temperature", ensemble=False).fit(X, y)

В следующем примере показано, что при многоклассовой классификации с тремя классами масштабирование температуры может обеспечить более точные калиброванные вероятности, чем калибровка сигмоидой.

import matplotlib.pyplot as plt

from sklearn.calibration import CalibrationDisplay

fig, axes = plt.subplots(
    figsize=(8, 4.5),
    ncols=3,
    sharey=True,
)
for i, c in enumerate(ts.classes_):
    CalibrationDisplay.from_predictions(
        y == c, clf.predict_proba(X)[:, i], name="Uncalibrated", ax=axes[i], marker="s"
    )
    CalibrationDisplay.from_predictions(
        y == c,
        ts.predict_proba(X)[:, i],
        name="Temperature scaling",
        ax=axes[i],
        marker="o",
    )
    CalibrationDisplay.from_predictions(
        y == c, sig.predict_proba(X)[:, i], name="Sigmoid", ax=axes[i], marker="v"
    )
    axes[i].set_title(f"Class {c}")
    axes[i].set_xlabel(None)
    axes[i].set_ylabel(None)
    axes[i].get_legend().remove()
fig.suptitle("Reliability Diagrams per Class")
fig.supxlabel("Mean Predicted Probability")
fig.supylabel("Fraction of Class")
fig.legend(*axes[0].get_legend_handles_labels(), loc=(0.72, 0.5))
plt.subplots_adjust(right=0.7)
_ = fig.show()

Повышение эффективности линейных моделей

Время обучения оценщиков с квадратичной функцией потерь и штрафом L1 значительно сокращено: ElasticNet, Lasso, MultiTaskElasticNet, MultiTaskLasso и их варианты с кросс-валидацией. Сокращение времени обучения в основном достигнуто благодаря правилам безопасного отсева по разрыву. Они позволяют решателю координатного спуска заранее обнулять коэффициенты признаков и больше к ним не возвращаться. Чем сильнее штраф L1, тем раньше признаки можно исключить из дальнейшего обновления.

from time import time

from sklearn.datasets import make_regression
from sklearn.linear_model import ElasticNetCV

X, y = make_regression(n_features=10_000, random_state=0)
model = ElasticNetCV()
tic = time()
model.fit(X, y)
toc = time()
print(f"Fitting ElasticNetCV took {toc - tic:.3} seconds.")

Fitting ElasticNetCV took 14.3 seconds.

HTML-представление оценщиков

Гиперпараметры в раскрывающейся таблице HTML-представления теперь содержат ссылки на онлайн-документацию. Описания из docstring также отображаются в виде всплывающих подсказок при наведении.

from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

clf = make_pipeline(StandardScaler(), LogisticRegression(random_state=0, C=10))

Разверните схему оценщика ниже, щёлкнув «LogisticRegression», а затем «Parameters».

clf

Pipeline(steps=[('standardscaler', StandardScaler()),
                ('logisticregression',
                 LogisticRegression(C=10, random_state=0))])

DecisionTreeRegressor с criterion="absolute_error"

tree.DecisionTreeRegressor с criterion="absolute_error" теперь работает значительно быстрее. Теперь его сложность составляет O(n * log(n)) вместо O(n**2), как было раньше, что позволяет масштабировать его до миллионов точек данных.

Например, на наборе данных из 100_000 образцов с одним признаком выполнение одного разбиения занимает около 100 мс, тогда как раньше на это требовалось около 20 секунд.

import time

from sklearn.datasets import make_regression
from sklearn.tree import DecisionTreeRegressor

X, y = make_regression(n_samples=100_000, n_features=1)
tree = DecisionTreeRegressor(criterion="absolute_error", max_depth=1)

tic = time.time()
tree.fit(X, y)
elapsed = time.time() - tic
print(f"Fit took {elapsed:.2f} seconds")

Fit took 0.14 seconds

Классический MDS

Классический MDS, также известный как «анализ главных координат» (PCoA) или «шкалирование Торгерсона», теперь доступен в модуле sklearn.manifold. Классический MDS близок к PCA и вместо аппроксимации расстояний аппроксимирует попарные скалярные произведения, для которых существует точное аналитическое решение на основе разложения на собственные значения.

Рассмотрим это новое дополнение на примере набора данных в форме S-кривой, чтобы получить низкоразмерное представление данных.

import matplotlib.pyplot as plt
from matplotlib import ticker

from sklearn import datasets, manifold

n_samples = 1500
S_points, S_color = datasets.make_s_curve(n_samples, random_state=0)
md_classical = manifold.ClassicalMDS(n_components=2)
S_scaling = md_classical.fit_transform(S_points)

fig = plt.figure(figsize=(8, 4))
ax1 = fig.add_subplot(1, 2, 1, projection="3d")
x, y, z = S_points.T
ax1.scatter(x, y, z, c=S_color, s=50, alpha=0.8)
ax1.set_title("Original S-curve samples", size=16)
ax1.view_init(azim=-60, elev=9)
for axis in (ax1.xaxis, ax1.yaxis, ax1.zaxis):
    axis.set_major_locator(ticker.MultipleLocator(1))

ax2 = fig.add_subplot(1, 2, 2)
x2, y2 = S_scaling.T
ax2.scatter(x2, y2, c=S_color, s=50, alpha=0.8)
ax2.set_title("Classical MDS", size=16)
for axis in (ax2.xaxis, ax2.yaxis):
    axis.set_major_formatter(ticker.NullFormatter())

plt.show()

Общее время выполнения скрипта: (0 минут 15.144 секунды)

Download Jupyter notebook: plot_release_highlights_1_8_0.ipynb

Download Python source code: plot_release_highlights_1_8_0.py

Download zipped: plot_release_highlights_1_8_0.zip

Связанные примеры

Основные нововведения scikit-learn 1.6

Основные нововведения scikit-learn 1.7

Основные нововведения scikit-learn 1.0

Основные нововведения scikit-learn 1.2