Инструменты Data Science: scikit-learn, TensorFlow и PyTorch для ML на Python
Библиотеки для машинного обучения на 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 30Feature 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 при создании тензора.
Расширенные примеры работы с библиотеками
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])
Кастомный датасет загружает изображения и возвращает тензоры с нормализацией. Это основа для обучения любой модели свёрточной сети.