Scikit-learn: полное руководство по машинному обучению на Python

import sklearn
print(sklearn.__version__)

python -m venv sklearn_env
source sklearn_env/bin/activate # для Linux/Mac
sklearn_env\Scripts\activate # для Windows

import numpy as np
from sklearn import datasets

# Загрузка датасета ирисов
iris = datasets.load_iris()
X = iris.data # Признаки: (150, 4)
y = iris.target # Метки классов: (150,)

print(f"Форма данных X: {X.shape}")
print(f"Форма целевой переменной y: {y.shape}")

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

# Создание конвейера: стандартизация -> SVM
pipe = Pipeline([
('scaler', StandardScaler()),
('classifier', SVC())
])

# Обучение всего конвейера одной командой
pipe.fit(X_train, y_train)

# Предсказание с использованием обученного конвейера
predictions = pipe.predict(X_test)

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, y = iris.data, iris.target

# Разделение на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.25, random_state=42
)

# Создание и обучение модели
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)

# Предсказание и оценка
y_pred = clf.predict(X_test)
print(classification_report(y_test, y_pred, target_names=iris.target_names))

# Важность признаков
feature_importance = dict(zip(iris.feature_names, clf.feature_importances_))
for feature, importance in sorted(feature_importance.items(), key=lambda x: x[1], reverse=True):
print(f"{feature}: {importance:.4f}")

from sklearn.datasets import fetch_california_housing
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

# Загрузка данных
housing = fetch_california_housing()
X, y = housing.data, housing.target

# Разделение выборки
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)

# Обучение модели
reg = LinearRegression()
reg.fit(X_train, y_train)

# Предсказание
y_pred = reg.predict(X_test)

# Оценка качества
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)

print(f"RMSE: {rmse:.4f}")
print(f"R²: {r2:.4f}")

# Коэффициенты модели
for i, feature in enumerate(housing.feature_names):
print(f"{feature}: {reg.coef_[i]:.6f}")
print(f"Intercept: {reg.intercept_:.6f}")

from sklearn.cluster import KMeans, DBSCAN
from sklearn.datasets import make_blobs
from sklearn.metrics import silhouette_score
import matplotlib.pyplot as plt
import numpy as np

# Генерация данных
X, _ = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=0)

# Метод K-средних
kmeans = KMeans(n_clusters=4, random_state=0)
kmeans_labels = kmeans.fit_predict(X)

# Метод DBSCAN
dbscan = DBSCAN(eps=0.3, min_samples=10)
dbscan_labels = dbscan.fit_predict(X)

# Оценка качества кластеризации
print(f"K-means silhouette score: {silhouette_score(X, kmeans_labels):.4f}")
if len(set(dbscan_labels)) > 1: # DBSCAN может определить шум (-1)
dbscan_score = silhouette_score(X[dbscan_labels >= 0], dbscan_labels[dbscan_labels >= 0])
print(f"DBSCAN silhouette score: {dbscan_score:.4f}")

# Визуализация результатов (требуется matplotlib)
plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.scatter(X[:, 0], X[:, 1], c=kmeans_labels, cmap='viridis')
plt.title('K-means Clustering')

plt.subplot(1, 2, 2)
plt.scatter(X[:, 0], X[:, 1], c=dbscan_labels, cmap='viridis')
plt.title('DBSCAN Clustering')

plt.tight_layout()
plt.show()

from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
from sklearn.datasets import load_digits

# Загрузка данных
digits = load_digits()
X, y = digits.data, digits.target

# Применение PCA
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)
print(f"Explained variance ratio: {sum(pca.explained_variance_ratio_):.4f}")

# Применение t-SNE
tsne = TSNE(n_components=2, random_state=42)
X_tsne = tsne.fit_transform(X)

# Визуализация результатов
plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
scatter = plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, cmap='viridis')
plt.title('PCA visualization')
plt.colorbar(scatter)

plt.subplot(1, 2, 2)
scatter = plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y, cmap='viridis')
plt.title('t-SNE visualization')
plt.colorbar(scatter)

plt.tight_layout()
plt.show()

from sklearn.model_selection import train_test_split, cross_val_score, KFold

# Простое разделение на тренировочную и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)

# Перекрестная проверка для более надежной оценки
cv = KFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(model, X, y, cv=cv, scoring='accuracy')
print(f"Cross-validation scores: {scores}")
print(f"Average accuracy: {scores.mean():.4f} ± {scores.std():.4f}")

from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from sklearn.ensemble import RandomForestClassifier
from scipy.stats import randint

# Определение пространства параметров
param_grid = {
'n_estimators': [50, 100, 200],
'max_depth': [None, 10, 20, 30],
'min_samples_split': [2, 5, 10],
'min_samples_leaf': [1, 2, 4]
}

# Полный перебор параметров (Grid Search)
grid_search = GridSearchCV(
RandomForestClassifier(random_state=42),
param_grid,
cv=5,
scoring='accuracy',
n_jobs=-1
)
grid_search.fit(X_train, y_train)

print(f"Best parameters: {grid_search.best_params_}")
print(f"Best cross-validation score: {grid_search.best_score_:.4f}")

# Случайный поиск (Randomized Search) – эффективнее для большого пространства параметров
param_dist = {
'n_estimators': randint(50, 500),
'max_depth': randint(10, 50),
'min_samples_split': randint(2, 20),
'min_samples_leaf': randint(1, 10)
}

random_search = RandomizedSearchCV(
RandomForestClassifier(random_state=42),
param_distributions=param_dist,
n_iter=100,
cv=5,
scoring='accuracy',
n_jobs=-1,
random_state=42
)
random_search.fit(X_train, y_train)

print(f"Best parameters from random search: {random_search.best_params_}")
print(f"Best cross-validation score: {random_search.best_score_:.4f}")

from sklearn.metrics import (accuracy_score, precision_score, recall_score, f1_score,
roc_auc_score, confusion_matrix, classification_report,
mean_squared_error, mean_absolute_error, r2_score)

# Для классификации
y_pred = model.predict(X_test)
y_prob = model.predict_proba(X_test)[:, 1] # Вероятности для положительного класса

print(f"Accuracy: {accuracy_score(y_test, y_pred):.4f}")
print(f"Precision: {precision_score(y_test, y_pred):.4f}")
print(f"Recall: {recall_score(y_test, y_pred):.4f}")
print(f"F1 score: {f1_score(y_test, y_pred):.4f}")
print(f"ROC AUC: {roc_auc_score(y_test, y_prob):.4f}")

print("\nConfusion Matrix:")
print(confusion_matrix(y_test, y_pred))

print("\nClassification Report:")
print(classification_report(y_test, y_pred))

# Для регрессии
y_pred_reg = reg_model.predict(X_test)

print(f"Mean Squared Error: {mean_squared_error(y_test, y_pred_reg):.4f}")
print(f"Root Mean Squared Error: {mean_squared_error(y_test, y_pred_reg, squared=False):.4f}")
print(f"Mean Absolute Error: {mean_absolute_error(y_test, y_pred_reg):.4f}")
print(f"R² Score: {r2_score(y_test, y_pred_reg):.4f}")

from sklearn.model_selection import learning_curve
import matplotlib.pyplot as plt
import numpy as np

# Вычисление кривых обучения
train_sizes, train_scores, test_scores = learning_curve(
model, X, y, cv=5, scoring='accuracy',
train_sizes=np.linspace(0.1, 1.0, 10)
)

# Средние значения и стандартные отклонения
train_mean = np.mean(train_scores, axis=1)
train_std = np.std(train_scores, axis=1)
test_mean = np.mean(test_scores, axis=1)
test_std = np.std(test_scores, axis=1)

# Визуализация кривых
plt.figure(figsize=(10, 6))
plt.plot(train_sizes, train_mean, label='Training score', color='blue', marker='o')
plt.fill_between(train_sizes, train_mean – train_std, train_mean + train_std, color='blue', alpha=0.15)
plt.plot(train_sizes, test_mean, label='Cross-validation score', color='green', marker='s')
plt.fill_between(train_sizes, test_mean – test_std, test_mean + test_std, color='green', alpha=0.15)
plt.title('Learning Curve')
plt.xlabel('Training Examples')
plt.ylabel('Accuracy Score')
plt.legend(loc='best')
plt.grid(True)
plt.show()

import pickle
import joblib
from sklearn.ensemble import RandomForestClassifier

# Обучение модели
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Сохранение модели с помощью pickle
with open('model.pkl', 'wb') as f:
pickle.dump(model, f)

# Загрузка модели
with open('model.pkl', 'rb') as f:
loaded_model = pickle.load(f)

# Альтернативный способ с использованием joblib (эффективнее для больших моделей)
joblib.dump(model, 'model.joblib')
loaded_model = joblib.load('model.joblib')

# Проверка загруженной модели
print(f"Accuracy on test data: {loaded_model.score(X_test, y_test):.4f}")

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.ensemble import RandomForestClassifier

# Создание полного конвейера обработки данных
full_pipeline = Pipeline([
('scaler', StandardScaler()), # Нормализация данных
('feature_selection', SelectKBest(f_classif, k=10)), # Отбор признаков
('classifier', RandomForestClassifier(n_estimators=100, random_state=42)) # Классификатор
])

# Обучение всего конвейера
full_pipeline.fit(X_train, y_train)

# Сохранение конвейера
joblib.dump(full_pipeline, 'full_pipeline.joblib')

# Использование конвейера для предсказаний
y_pred = full_pipeline.predict(X_test)
print(f"Pipeline accuracy: {accuracy_score(y_test, y_pred):.4f}")

# app.py
from flask import Flask, request, jsonify
import joblib
import numpy as np

app = Flask(__name__)

# Загрузка модели
model = joblib.load('model.joblib')

@app.route('/predict', methods=['POST'])
def predict():
# Получение данных из запроса
data = request.json
features = np.array(data['features']).reshape(1, -1)

# Генерация предсказания
prediction = model.predict(features)[0]
probability = model.predict_proba(features)[0].tolist()

# Возврат результата
return jsonify({
'prediction': int(prediction),
'probability': probability
})

if __name__ == '__main__':
app.run(debug=True)

import requests

# Отправка запроса к API
url = "http://localhost:5000/predict"
data = {
"features": [5\.1, 3.5, 1.4, 0.2] # Пример признаков для ириса
}
response = requests.post(url, json=data)

# Обработка ответа
result = response.json()
print(f"Prediction: Class {result['prediction']}")
print(f"Probabilities: {result['probability']}")

import pandas as pd
from sklearn.metrics import accuracy_score
import joblib
import datetime
import json

def monitor_model_performance(model_path, new_data_path, metrics_log_path):
# Загрузка модели
model = joblib.load(model_path)

# Загрузка новых данных
new_data = pd.read_csv(new_data_path)
X_new = new_data.drop('target', axis=1)
y_new = new_data['target']

# Вычисление производительности
y_pred = model.predict(X_new)
accuracy = accuracy_score(y_new, y_pred)

# Запись метрики
timestamp = datetime.datetime.now().isoformat()
metrics_entry = {
'timestamp': timestamp,
'accuracy': accuracy,
'data_size': len(X_new)
}

# Добавление в журнал метрик
try:
with open(metrics_log_path, 'r') as f:
metrics_log = json.load(f)
except (FileNotFoundError, json.JSONDecodeError):
metrics_log = []

metrics_log.append(metrics_entry)

with open(metrics_log_path, 'w') as f:
json.dump(metrics_log, f, indent=2)

# Проверка на снижение производительности
if len(metrics_log) > 1 and accuracy < metrics_log[-2]['accuracy'] * 0.95:
print(f"WARNING: Performance dropped by more than 5%! Current: {accuracy:.4f}, Previous: {metrics_log[-2]['accuracy']:.4f}")

return accuracy

# Пример использования
performance = monitor_model_performance('model.joblib', 'new_data.csv', 'metrics_log.json')
print(f"Current model performance: {performance:.4f}")