Scikit-learn: как работать с главной ML-библиотекой Python

В мире машинного обучения на Python есть библиотека, которую знают все. Причина популярности проста — она закрывает бо́льшую часть повседневных задач аналитика данных и делает это надёжно.

Когда в 2007 году Дэвид Курнапо (David Cournapeau) начал проект scikit-learn, а позже к нему присоединились Матьё Брюшер и команда INRIA запустили проект scikit-learn, они вряд ли предполагали, что через почти двадцать лет их библиотека станет стандартом для классического ML. Но так вышло. И сейчас, в 2026 году, scikit-learn — это каркас, на котором держится огромная часть корпоративной аналитики.

Разработчики называют библиотеку sklearn — так она фигурирует в импортах. Официальное наименование — scikit-learn. Два названия, одна библиотека: короткое для кода, длинное для проекта и документации.

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

Что такое scikit-learn

Scikit-learn — это open-source библиотека классического машинного обучения для Python. Она включает алгоритмы для классификации, регрессии, кластеризации, понижения размерности, предобработки данных и оценки качества моделей. Всё это построено поверх NumPy и SciPy.

Библиотека появилась в 2007 году как ответвление от проекта SciPy. Изначально она называлась scikits.learn — один из «scikits», то есть дополнительных пакетов для SciPy. Со временем проект вырос в самостоятельную библиотеку, но имя осталось.

Сегодня scikit-learn — это больше ста реализованных алгоритмов и утилит. От линейной регрессии до градиентного бустинга, от метода главных компонент до t-SNE. И все они подчиняются одному и тому же интерфейсу.

Границы библиотеки чёткие: sklearn — про классический ML на табличных данных. Нейросети, компьютерное зрение, обработка естественного языка в промышленных масштабах — это уже территория PyTorch, TensorFlow и других. Но если у вас есть таблица с признаками и целевой переменной — scikit-learn даст всё, что нужно, чтобы построить работающую модель. Классификация клиентов, прогнозирование продаж, оценка рисков, кластеризация пользователей — здесь scikit-learn вне конкуренции.

В июне 2026 года вышла версия 1.9.0. Она поддерживает Python 3.11–3.14 и принесла несколько важных изменений: экспериментальные колбэки для отслеживания прогресса обучения, поддержку GPU для логистической регрессии, новую зависимость narwhals для лучшей работы с pandas и polars. В библиотеке появилась возможность возвращать разреженные массивы SciPy вместо разреженных матриц. Но главное — API остаётся стабильным. То, что работало в версии 1.5, работает и сейчас.

Зачем разработчикам всё это знать? Затем, что большинство компаний, которые занимаются машинным обучением, используют классические алгоритмы на табличных данных. Градиентный бустинг, логистическая регрессия, случайный лес. Они обучаются за секунды, их можно объяснить бизнесу, и они дают результат не хуже, а иногда и лучше нейросетей.

Когда выбирают sklearn, а не нейросети

В 2026 году нейросети — это модно. О них пишут в новостях, их обсуждают на конференциях, кажется, что все вокруг только и делают, что обучают трансформеры. Но реальность корпоративного ML несколько иная.

Большинство задач в бизнесе — это работа с табличными данными. Клиенты, транзакции, логи, показатели. Структурированные датасеты с десятками или сотнями признаков. И для таких задач классические алгоритмы из scikit-learn часто оказываются эффективнее нейросетей.

Градиентный бустинг (например, HistGradientBoostingClassifier) обучается за минуты на миллионах строк и даёт качество, которое сложно превзойти. Логистическая регрессия — прозрачная, быстрая, с весами признаков, которые можно показать бизнес-заказчику. Случайный лес устойчив к выбросам и не требует сложной предобработки.

В финансах и медицине интерпретируемость модели — регуляторное требование. Вы обязаны объяснить, почему клиенту отказали в кредите или почему пациенту поставили определённый диагноз. Нейросеть этого не даст. А линейная модель или дерево решений — дают.

Scikit-learn иногда ошибочно воспринимают как «устаревший ML». На деле это полноценный рабочий стандарт для своего класса задач. И если ваш проект не требует распознавания лиц или генерации текста — скорее всего, вы будете использовать именно его.

Установка

Установка scikit-learn — одна команда. Но есть нюанс.

Правильный вариант:

pip install scikit-learn

Или через conda:

conda install -c conda-forge scikit-learn

Неправильный вариант — pip install sklearn. Такой пакет не существует. Он был удалён из репозитория PyPI несколько лет назад, потому что разработчики хотели, чтобы люди ставили полное имя — scikit-learn. А импортировали — короткое.

После установки проверьте версию:

import sklearn
print(sklearn.__version__)

Должно вывести 1.9.0 или более свежую версию.

Если Python старше 3.11 — сначала обновите интерпретатор, иначе установка не пройдёт.

Главная идея API: fit, predict, transform

В scikit-learn все объекты устроены одинаково. Это главная фишка библиотеки: выучили интерфейс один раз — умеете пользоваться сотней алгоритмов. 

Есть три основных метода:

Некоторые объекты поддерживают fit_transform() — обучаются и сразу преобразуют данные за один проход.

Покажем на минимальном примере с логистической регрессией. Возьмём встроенный датасет для классификации:

from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train)

predictions = model.predict(X_test)
print(predictions[:5])

Всё, что мы сделали, — создали объект модели, вызвали fit() на обучающей выборке и predict() на тестовой. Тот же интерфейс работает для случайного леса, градиентного бустинга, SVM, метода k-ближайших соседей и любого другого алгоритма в библиотеке.

Для трансформеров — например, StandardScaler — интерфейс такой же:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X_train)  # обучаем и преобразуем
X_test_scaled = scaler.transform(X_test)   # только преобразуем

fit_transform() на обучающей выборке вычисляет среднее и стандартное отклонение и сразу применяет масштабирование. На тестовой — только применяет уже вычисленные параметры. Последний момент важен, поэтому мы к нему ещё вернёмся.

Первая модель от начала до конца

Теперь соберём всё вместе. Пройдём полный цикл: от загрузки данных до оценки качества модели.

Возьмём датасет California Housing. Он содержит данные о районах Калифорнии по переписи 1990 года: медианный доход, возраст домов, количество комнат, население, географические координаты. В отличие от load_iris, внутри библиотеки он не лежит: при первом вызове fetch_california_housing() скачивает данные из интернета и кладёт в локальный кеш. Целевая переменная — медианная стоимость дома в районе.

Важно: не используйте датасет Boston Housing. Он был удалён из библиотеки несколько лет назад из-за этических проблем — в нём содержались данные с расовой предвзятостью.

import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error

# 1. Загружаем данные
housing = fetch_california_housing()
X, y = housing.data, housing.target

# 2. Делим на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 3. Масштабируем признаки
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 4. Обучаем модель
model = LinearRegression()
model.fit(X_train_scaled, y_train)

# 5. Делаем предсказания
y_pred = model.predict(X_test_scaled)

# 6. Оцениваем качество
mae = mean_absolute_error(y_test, y_pred)
print(f"Средняя абсолютная ошибка: {mae:.2f}")

На этом примере мы сделали шесть шагов. Каждый из них обязателен, если вы строите модель с нуля. Пропуск любого шага — и модель либо не обучится, либо даст неверные результаты.

Почему train_test_split идёт первым

Это самый важный методологический момент. Многие новички делают ошибку: сначала преобразуют все данные, а потом делят их на train и test.

# ❌ Неправильно
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)  # масштабируем все данные
X_train, X_test = train_test_split(X_scaled, ...)  # потом делим

В этом случае масштабирование учитывало статистику тестовой выборки. При обучении модель «увидела» информацию из теста — средние значения и стандартные отклонения были вычислены с учётом всех данных. Это называется data leakage — утечка данных.

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

Правильный порядок:

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

Метрики: как понять, что модель работает

Обучили модель — теперь нужно понять, хорошая она или нет. Метрики качества помогают ответить на этот вопрос.

Для регрессии (задача предсказания числа) используют:

В примере выше мы использовали MAE:

from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(y_test, y_pred)

Для классификации (задача предсказания категории) есть другие метрики. Все они считаются через четыре величины: TP (true positive) — объекты, которые модель верно отнесла к положительному классу; TN (true negative) — верно отнесённые к отрицательному; FP (false positive) — ложные срабатывания; FN (false negative) — пропущенные объекты.

Выбор метрики зависит от задачи. Если ложноположительные срабатывания дороги (например, в медицине — поставить здоровому человеку ложный диагноз) — важнее precision. Если пропуск целевого события дорог (например, не найти уходящего клиента) — важнее recall.

Для многоклассовой классификации метрики усредняют по классам. Макро-усреднение считает метрику для каждого класса отдельно и берёт простое среднее — все классы влияют одинаково, даже редкие. Микро-усреднение складывает TP, FP и FN по всем классам и считает метрику один раз — тогда результат определяют крупные классы.

from sklearn.metrics import accuracy_score, precision_score, recall_score

accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred, average='macro')
recall = recall_score(y_test, y_pred, average='macro')

Pipeline: собираем шаги в один объект

Учебный код, который мы написали выше, работает. Но у него есть недостатки:

Решение — Pipeline.

Pipeline — это объект, который объединяет несколько шагов в одну последовательность. Он принимает список трансформеров и финальную модель. Вызывает fit() — и все шаги выполняются по порядку. Вызывает predict() — и данные проходят через все трансформеры, а потом через модель.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('regressor', LinearRegression())
])

pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)

На этом всё. Pipeline сам применяет scaler к обучающей выборке при fit() и к тестовой при predict(). При кросс-валидации он тоже работает корректно: преобразования применяются только к текущей обучающей части, а тестовая часть не участвует в вычислении статистик.

Если нужно применить разные преобразования к разным колонкам — используйте ColumnTransformer. Пример ниже независимый: ColumnTransformer обращается к колонкам по именам, поэтому данные должны лежать в DataFrame, а не в numpy-массиве. Чтобы получить DataFrame из встроенного датасета, загружайте его так: fetch_california_housing(as_frame=True).

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder

# Предположим, у нас есть числовые и категориальные признаки
numeric_features = ['income', 'rooms']
categorical_features = ['district_type']

preprocessor = ColumnTransformer([
    ('num', StandardScaler(), numeric_features),
    ('cat', OneHotEncoder(), categorical_features)
])

pipeline = Pipeline([
    ('preprocessor', preprocessor),
    ('classifier', LogisticRegression())
])

ColumnTransformer применяет разные трансформеры к разным колонкам и объединяет результаты в одну матрицу признаков. В версии 1.9 улучшили отображение ColumnTransformer в Jupyter — теперь видно, какие колонки как преобразуются.

Pipeline — это стандарт промышленной разработки на scikit-learn. В учебных ноутбуках можно обойтись без него, но в реальных проектах он обязателен.

Подбор гиперпараметров: GridSearchCV

У модели есть параметры, которые она изучает во время обучения — например, веса признаков в линейной регрессии. А есть гиперпараметры — те, которые мы задаём до обучения. Например, C в логистической регрессии (сила регуляризации) или max_depth в дереве решений (максимальная глубина).

Гиперпараметры влияют на качество модели. Их нужно подбирать. Вручную перебирать значения — долго и неэффективно. Для этого есть GridSearchCV.

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

from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestRegressor

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('model', RandomForestRegressor(random_state=42))
])

param_grid = {
    'model__n_estimators': [50, 100, 200],
    'model__max_depth': [5, 10, None]
}

grid_search = GridSearchCV(
    pipeline,
    param_grid,
    cv=5,
    scoring='neg_mean_absolute_error',
    n_jobs=-1
)

grid_search.fit(X_train, y_train)

print(f"Лучшие параметры: {grid_search.best_params_}")
print(f"Лучшее качество: {-grid_search.best_score_:.2f}")

Обратите внимание на синтаксис model__n_estimators. Двойное подчёркивание — это способ обратиться к параметрам вложенных объектов в Pipeline. model — это имя шага в Pipeline, n_estimators — параметр модели.

GridSearchCV реализует тот же интерфейс fit/predict, что и все остальные объекты в scikit-learn. Поэтому его можно использовать точно так же:

best_model = grid_search.best_estimator_
y_pred = best_model.predict(X_test)

Предупреждение: комбинаторный взрыв. Если у вас пять параметров по десять значений каждый — это 100 000 комбинаций. С пятикратной кросс-валидацией — 500 000 обучений. Это может занять часы или даже дни.

Для больших сеток используйте RandomizedSearchCV — он перебирает случайные комбинации из заданного распределения и работает быстрее.

В версии 1.9 в GridSearchCV появилась поддержка колбэков — например, можно добавить ProgressBar и видеть прогресс перебора.

Что учить дальше

Scikit-learn — это первая библиотека, которую осваивает аналитик данных. Но путь не заканчивается на ней.

Что стоит изучить дальше:

Scikit-learn — это фундамент. На нём строится всё остальное. Если вы освоили его API и поняли принципы работы с пайплайнами и кросс-валидацией, вы уже можете решать большинство задач классического ML.

А дальше — выбор за вами. Углубляться в теорию алгоритмов, осваивать инженерию данных, переходить в deep learning или становиться ML-инженером. В любом случае навыки работы со sklearn останутся с вами надолго.

Советуем дополнительно почитать

12 библиотек Python, которые стоит попробовать в 2026 году — что ставят рядом со scikit-learn: polars, инструменты профилирования и ускорения вычислений.

Matplotlib: полное руководство по визуализации данных — как показать результаты модели: кривые обучения, важность признаков, матрица ошибок.

Что такое MLOps — что происходит с моделью после обучения: версионирование, мониторинг и отслеживание дрейфа.

Что такое корреляция — с чего начинается отбор признаков и почему два похожих столбца ломают линейную модель.

Big data: что такое большие данные — где заканчиваются возможности одной машины и начинается инфраструктура, под которую scikit-learn уже не рассчитан.