Инструменты Data Science: scikit-learn, TensorFlow и PyTorch для ML на Python

Раздел: Data Science -> Scikit-learn

Библиотеки для машинного обучения на Python

Как построить модель классификации с помощью scikit-learn?

Для задач классического машинного обучения (регрессия, классификация, кластеризация) оптимальным выбором является библиотека scikit-learn. Она предоставляет единообразный API, множество встроенных алгоритмов и инструментов для оценки моделей.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report

iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42)

model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
predictions = model.predict(X_test)
print(classification_report(y_test, predictions, target_names=iris.target_names))

библиотеки для машинного обучения python (библиотеки для машинного обучения в python (scikit-learn, tensorflow, pytorch))

              precision    recall  f1-score   support

      setosa       1.00      1.00      1.00        10
  versicolor       1.00      1.00      1.00         9
   virginica       1.00      1.00      1.00        11

    accuracy                           1.00        30
   macro avg       1.00      1.00      1.00        30
weighted avg       1.00      1.00      1.00        30

Feature names python (имена признаков в python)

После разделения данных на обучающую и тестовую выборки создаётся случайный лес из 100 деревьев. Модель обучается методом fit, затем делаются предсказания. Отчёт о классификации показывает идеальные метрики на данном простом наборе данных.

Типичная ошибка: несоответствие типов данных (например, строковые метки вместо числовых) приводит к ошибке при обучении. Решение – привести целевые значения к числовому виду с помощью LabelEncoder.

Как выполнить регрессию с помощью scikit-learn?

Для регрессии используется, например, RandomForestRegressor или LinearRegression. Возьмём набор данных о ценах на жильё в Калифорнии.

from sklearn.datasets import fetch_california_housing
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error

housing = fetch_california_housing()
X_train, X_test, y_train, y_test = train_test_split(housing.data, housing.target, test_size=0.2, random_state=42)

reg = RandomForestRegressor(n_estimators=50, random_state=42)
reg.fit(X_train, y_train)
y_pred = reg.predict(X_test)
print('MSE:', mean_squared_error(y_test, y_pred))

Python model (модели в python (машинное обучение))

MSE: 0.255...

статистическая библиотека python (статистическая библиотека python (scipy, statsmodels))

Метрика среднеквадратичной ошибки показывает качество предсказания. Чем меньше MSE, тем точнее модель.

Проблема: переобучение при слишком большом количестве деревьев или глубине. Решение – использовать перекрёстную проверку (например, GridSearchCV) для подбора гиперпараметров.

Когда стоит использовать TensorFlow для глубокого обучения?

TensorFlow (с Keras) подходит для продакшн-систем, требующих масштабирования на нескольких GPU и TPU. Он предоставляет низкоуровневый контроль над вычислениями и высокоуровневые API для быстрого прототипирования.

import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(x_train, y_train, epochs=5, validation_data=(x_test, y_test))

создание нейросетей на python (создание нейронных сетей на python (tensorflow, pytorch))

Epoch 1/5
1875/1875 [==============================] - 6s 3ms/step - loss: 0.2613 - accuracy: 0.9261 - val_loss: 0.1402 - val_accuracy: 0.9589
...
Epoch 5/5
1875/1875 [==============================] - 5s 3ms/step - loss: 0.0848 - accuracy: 0.9737 - val_loss: 0.0775 - val_accuracy: 0.9761

библиотека scikit python (библиотека scikit-learn для python)

Модель состоит из слоя Flatten, одного полносвязного слоя с ReLU и выходного слоя с softmax. После обучения точность на валидации достигает 97.6%.

Распространённая проблема: нехватка памяти на GPU при больших размерах батча. Решение – уменьшить batch_size или использовать смешанную точность (mixed_precision).

В каких случаях PyTorch оказывается удобнее?

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

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

digits = load_digits()
X_train, X_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.2, random_state=42)

X_train_t = torch.tensor(X_train, dtype=torch.float32)
y_train_t = torch.tensor(y_train, dtype=torch.long)
X_test_t = torch.tensor(X_test, dtype=torch.float32)
y_test_t = torch.tensor(y_test, dtype=torch.long)

train_dataset = TensorDataset(X_train_t, y_train_t)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

model = nn.Sequential(
    nn.Linear(64, 128),
    nn.ReLU(),
    nn.Linear(128, 10)
)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(10):
    for batch_x, batch_y in train_loader:
        optimizer.zero_grad()
        outputs = model(batch_x)
        loss = criterion(outputs, batch_y)
        loss.backward()
        optimizer.step()

with torch.no_grad():
    test_outputs = model(X_test_t)
    _, predicted = torch.max(test_outputs, 1)
    accuracy = (predicted == y_test_t).sum().item() / len(y_test_t)
    print(f'Accuracy: {accuracy:.4f}')

задачи машинного обучения python (задачи машинного обучения на python)

Accuracy: 0.9694

Цикл обучения вручную управляет градиентами, что даёт гибкость. PyTorch использует динамический граф, поэтому можно менять архитектуру на каждой итерации (например, для RNN).

Ошибка: несоответствие типов тензоров (например, float и long). Решение – явно приводить типы с помощью .float(), .long() или использовать аргумент dtype при создании тензора.

- Python создание модели (создание модели машинного обучения на python)

Расширенные примеры работы с библиотеками

Scikit-learn: пайплайны и подбор гиперпараметров

Пайплайны объединяют предобработку и модель в один объект, что упрощает перекрёстную проверку. В примере используется StandardScaler и SVM с подбором C через GridSearchCV.

Пример
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.datasets import load_wine

wine = load_wine()
X_train, X_test, y_train, y_test = train_test_split(wine.data, wine.target, test_size=0.2, random_state=42)

pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('svm', SVC())
])

param_grid = {
    'svm__C': [0.1, 1, 10],
    'svm__kernel': ['linear', 'rbf']
}

grid = GridSearchCV(pipe, param_grid, cv=5, scoring='accuracy')
grid.fit(X_train, y_train)
print('Best params:', grid.best_params_)
print('Test accuracy:', grid.score(X_test, y_test))
Best params: {'svm__C': 1, 'svm__kernel': 'rbf'}
Test accuracy: 1.0

Результат показывает, что оптимальные гиперпараметры – C=1 и ядро RBF. Пайплайн автоматически применяет масштабирование только на тренировочных данных, избегая утечки.

TensorFlow: сохранение и загрузка модели

Для развёртывания моделей в production важно уметь сохранять обученные веса. Формат SavedModel позволяет восстановить модель без переобучения.

Пример
model.save('mnist_model')
loaded_model = tf.keras.models.load_model('mnist_model')
loss, acc = loaded_model.evaluate(x_test, y_test, verbose=0)
print('Loaded model accuracy:', acc)
Loaded model accuracy: 0.9761

Модель сохраняется в папку 'mnist_model' со всей архитектурой, весами и конфигурацией оптимизатора. Загрузка восстанавливает точность без потерь.

PyTorch: кастомный Dataset и DataLoader для изображений

Для работы с собственными данными часто требуется написать класс, наследующий torch.utils.data.Dataset. Пример загружает изображения из папок и применяет аугментацию.

Пример
import os
from PIL import Image
from torch.utils.data import Dataset
from torchvision import transforms

class CatDogDataset(Dataset):
    def __init__(self, root_dir, transform=None):
        self.root_dir = root_dir
        self.transform = transform
        self.images = [f for f in os.listdir(root_dir) if f.endswith(('.jpg','.png'))]
        
    def __len__(self):
        return len(self.images)
    
    def __getitem__(self, idx):
        img_name = os.path.join(self.root_dir, self.images[idx])
        image = Image.open(img_name).convert('RGB')
        label = 0 if 'cat' in self.images[idx] else 1
        if self.transform:
            image = self.transform(image)
        return image, label

transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

dataset = CatDogDataset('path/to/images', transform=transform)
dataloader = DataLoader(dataset, batch_size=16, shuffle=True)
for images, labels in dataloader:
    print(images.shape, labels.shape)
    break
torch.Size([16, 3, 224, 224]) torch.Size([16])

Кастомный датасет загружает изображения и возвращает тензоры с нормализацией. Это основа для обучения любой модели свёрточной сети.

Библиотеки для машинного обучения в Python (scikit-learn, TensorFlow, PyTorch) - comments

En
библиотеки для машинного обучения python (python)