Рандом Форест: основы, применение и сравнение с алгоритмами

ŷ = mode(T₁(x), T₂(x), ..., Tₙ(x))

# Загрузка и первичный анализ данных
import pandas as pd
import numpy as np
from sklearn.datasets import load_iris

# Загружаем датасет
iris = load_iris()
X = pd.DataFrame(iris.data, columns=iris.feature_names)
y = pd.Series(iris.target, name='species')

# Посмотрим на данные
print(X.head())
print("\nРаспределение классов:", y.value_counts())

# Проверка на пропущенные значения
print("\nПропущенные значения:", X.isnull().sum().sum())

# Если бы у нас были категориальные признаки, мы бы их кодировали
# Например, с использованием One-Hot Encoding:
# from sklearn.preprocessing import OneHotEncoder
# encoder = OneHotEncoder(sparse=False, drop='first')
# X_categorical_encoded = encoder.fit_transform(X[['categorical_column']])

# Разделение на обучающую и тестовую выборки
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.3, random_state=42, stratify=y
)

print(f"\nРазмеры выборок: обучающая {X_train.shape}, тестовая {X_test.shape}")

# Анализ корреляции между признаками
correlation_matrix = X.corr()
print("\nКорреляционная матрица:")
print(correlation_matrix)

# Визуализация корреляций (требуется matplotlib и seaborn)
import matplotlib.pyplot as plt
import seaborn as sns

plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm')
plt.title('Корреляционная матрица признаков')
plt.show()

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

# Создание модели с параметрами по умолчанию
rf_model = RandomForestClassifier(random_state=42)

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

# Прогнозирование на тестовой выборке
y_pred = rf_model.predict(X_test)

# Оценка качества модели
accuracy = accuracy_score(y_test, y_pred)
print(f"Точность модели: {accuracy:.4f}")

# Детальный отчет о производительности
print("\nОтчет о классификации:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

# Матрица ошибок
print("\nМатрица ошибок:")
conf_matrix = confusion_matrix(y_test, y_pred)
print(conf_matrix)

# Визуализация важности признаков
import matplotlib.pyplot as plt
import seaborn as sns

# Получение оценок важности признаков
feature_importance = pd.DataFrame({
'feature': X.columns,
'importance': rf_model.feature_importances_
}).sort_values('importance', ascending=False)

# Визуализация
plt.figure(figsize=(10, 6))
sns.barplot(x='importance', y='feature', data=feature_importance)
plt.title('Важность признаков в модели Random Forest')
plt.tight_layout()
plt.show()

print("\nВажность признаков:")
print(feature_importance)

# Получение вероятностей классов
y_proba = rf_model.predict_proba(X_test)

# Просмотр вероятностей для первых 5 примеров
print("\nВероятности классов для первых 5 примеров:")
probabilities_df = pd.DataFrame(
y_proba, 
columns=[f'Prob_{name}' for name in iris.target_names]
)
print(pd.concat([pd.DataFrame(X_test.iloc[:5].values, columns=X.columns), 
probabilities_df.iloc[:5]], 
axis=1))

from sklearn.metrics import roc_curve, auc
from sklearn.preprocessing import label_binarize
from itertools import cycle
import numpy as np

# Бинаризация меток для ROC-кривой
y_test_bin = label_binarize(y_test, classes=[0, 1, 2])
n_classes = 3

# Расчет ROC-кривой и AUC для каждого класса
fpr = dict()
tpr = dict()
roc_auc = dict()

for i in range(n_classes):
fpr[i], tpr[i], _ = roc_curve(y_test_bin[:, i], y_proba[:, i])
roc_auc[i] = auc(fpr[i], tpr[i])

# Построение ROC-кривых
plt.figure(figsize=(10, 8))
colors = cycle(['blue', 'red', 'green'])
for i, color in zip(range(n_classes), colors):
plt.plot(fpr[i], tpr[i], color=color, lw=2,
label=f'ROC кривая класса {iris.target_names[i]} (area = {roc_auc[i]:.2f})')

plt.plot([0, 1], [0, 1], 'k--', lw=2)
plt.xlim([0\.0, 1.0])
plt.ylim([0\.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC-кривые для многоклассовой классификации')
plt.legend(loc="lower right")
plt.show()

import joblib

# Сохранение модели
joblib.dump(rf_model, 'random_forest_iris.joblib')

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

from sklearn.model_selection import cross_val_score

# 5-кратная кросс-валидация
cv_scores = cross_val_score(rf_model, X, y, cv=5)
print(f"\nРезультаты кросс-валидации: {cv_scores}")
print(f"Средняя точность: {cv_scores.mean():.4f} ± {cv_scores.std():.4f}")

from sklearn.model_selection import GridSearchCV

# Определение пространства параметров для поиска
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],
'max_features': ['sqrt', 'log2', None]
}

# Инициализация модели
rf_model = RandomForestClassifier(random_state=42)

# Инициализация Grid Search с 5-кратной кросс-валидацией
grid_search = GridSearchCV(
estimator=rf_model,
param_grid=param_grid,
cv=5,
scoring='accuracy',
n_jobs=-1, # Используем все доступные ядра CPU
verbose=1
)

# Выполнение поиска
grid_search.fit(X_train, y_train)

# Лучшие параметры и результаты
print(f"\nЛучшие параметры: {grid_search.best_params_}")
print(f"Лучшая точность при кросс-валидации: {grid_search.best_score_:.4f}")

# Использование лучшей модели для прогнозирования
best_rf = grid_search.best_estimator_
y_pred = best_rf.predict(X_test)
best_accuracy = accuracy_score(y_test, y_pred)
print(f"Точность лучшей модели на тестовой выборке: {best_accuracy:.4f}")

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, uniform

# Определение пространства параметров с распределениями
param_distributions = {
'n_estimators': randint(50, 500),
'max_depth': [None] + list(randint(5, 50).rvs(5)),
'min_samples_split': randint(2, 20),
'min_samples_leaf': randint(1, 10),
'max_features': ['sqrt', 'log2', None, 0.5, 0.7, 0.9]
}

# Инициализация случайного поиска
random_search = RandomizedSearchCV(
estimator=RandomForestClassifier(random_state=42),
param_distributions=param_distributions,
n_iter=100, # Количество итераций
cv=5,
scoring='accuracy',
n_jobs=-1,
verbose=1,
random_state=42
)

# Выполнение поиска
random_search.fit(X_train, y_train)

print(f"\nЛучшие параметры (случайный поиск): {random_search.best_params_}")
print(f"Лучшая точность (случайный поиск): {random_search.best_score_:.4f}")

import matplotlib.pyplot as plt
import pandas as pd

# Преобразование результатов в DataFrame
results = pd.DataFrame(grid_search.cv_results_)

# Построение графиков для разных параметров
plt.figure(figsize=(12, 10))

# Влияние количества деревьев (n_estimators)
plt.subplot(2, 2, 1)
n_estimators_values = sorted(param_grid['n_estimators'])
mean_scores = [results[results['param_n_estimators']==n]['mean_test_score'].mean() 
for n in n_estimators_values]
plt.plot(n_estimators_values, mean_scores, 'o-')
plt.xlabel('Количество деревьев')
plt.ylabel('Средняя точность')
plt.title('Влияние количества деревьев')

# Влияние максимальной глубины (max_depth)
plt.subplot(2, 2, 2)
max_depth_values = [str(d) for d in sorted([d for d in param_grid['max_depth'] if d is not None])]
max_depth_values.append('None')
mean_scores = []
for d in param_grid['max_depth']:
d_str = str(d) if d is not None else 'None'
mean_scores.append((d_str, results[results['param_max_depth']==d]['mean_test_score'].mean()))
mean_scores = [score for _, score in sorted(mean_scores, key=lambda x: 
(float('inf') if x[0]=='None' else int(x[0]), x[0]))]
plt.plot(max_depth_values, mean_scores, 'o-')
plt.xlabel('Максимальная глубина')
plt.ylabel('Средняя точность')
plt.title('Влияние максимальной глубины')

plt.tight_layout()
plt.show()

from sklearn.metrics import precision_recall_fscore_support, make_scorer
from sklearn.model_selection import cross_validate

# Создаем кастомные скореры
scorers = {
'accuracy': 'accuracy',
'precision_macro': make_scorer(precision_score, average='macro'),
'recall_macro': make_scorer(recall_score, average='macro'),
'f1_macro': make_scorer(f1_score, average='macro')
}

# Кросс-валидация с разными метриками
cv_results = cross_validate(
best_rf,
X,
y,
cv=5,
scoring=scorers
)

# Вывод результатов
for metric, scores in cv_results.items():
if metric.startswith('test_'):
print(f"{metric[5:]}: {scores.mean():.4f} ± {scores.std():.4f}")

from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from catboost import CatBoostClassifier
from sklearn.model_selection import cross_val_score
import numpy as np
import pandas as pd
import time

# Список моделей для сравнения
models = {
'Логистическая регрессия': LogisticRegression(max_iter=1000, random_state=42),
'SVM': SVC(probability=True, random_state=42),
'Random Forest': RandomForestClassifier(n_estimators=100, random_state=42),
'Gradient Boosting': GradientBoostingClassifier(n_estimators=100, random_state=42),
'CatBoost': CatBoostClassifier(iterations=100, random_state=42, verbose=0)
}

# Результаты для сравнения
results = []

# Обучение и оценка каждой модели
for name, model in models.items():
start_time = time.time()

# 5-кратная кросс-валидация
scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')

# Обучение на всем наборе данных для оценки времени обучения
model.fit(X_train, y_train)

# Время обучения
train_time = time.time() – start_time

# Прогнозирование на тестовых данных
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

# Сохранение результатов
results.append({
'Модель': name,
'Точность (CV)': scores.mean(),
'Станд. отклонение (CV)': scores.std(),
'Точность (тест)': accuracy,
'Время обучения (с)': train_time
})

# Создание DataFrame с результатами
results_df = pd.DataFrame(results)
print(results_df)

from sklearn.metrics import roc_auc_score, precision_recall_curve, auc
import matplotlib.pyplot as plt

# Более детальное сравнение Random Forest и CatBoost
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
catboost_model = CatBoostClassifier(iterations=100, random_state=42, verbose=0)

# Обучение моделей
rf_model.fit(X_train, y_train)
catboost_model.fit(X_train, y_train)

# Прогнозы вероятностей
rf_probs = rf_model.predict_proba(X_test)
catboost_probs = catboost_model.predict_proba(X_test)

# Вычисление ROC AUC для каждого класса
classes = iris.target_names
rf_aucs = []
catboost_aucs = []

# Бинаризация меток для расчета ROC AUC
y_test_bin = label_binarize(y_test, classes=[0, 1, 2])

for i in range(len(classes)):
rf_auc = roc_auc_score(y_test_bin[:, i], rf_probs[:, i])
catboost_auc = roc_auc_score(y_test_bin[:, i], catboost_probs[:, i])

rf_aucs.append(rf_auc)
catboost_aucs.append(catboost_auc)

print(f"Класс {classes[i]}: RF ROC AUC = {rf_auc:.4f}, CatBoost ROC AUC = {catboost_auc:.4f}")

# Среднее значение ROC AUC
print(f"Среднее ROC AUC: RF = {np.mean(rf_aucs):.4f}, CatBoost = {np.mean(catboost_aucs):.4f}")

# Построение ROC-кривых для одного класса (для наглядности)
plt.figure(figsize=(10, 8))

class_idx = 0 # Выбираем первый класс для визуализации
fpr_rf, tpr_rf, _ = roc_curve(y_test_bin[:, class_idx], rf_probs[:, class_idx])
fpr_cb, tpr_cb, _ = roc_curve(y_test_bin[:, class_idx], catboost_probs[:, class_idx])

plt.plot(fpr_rf, tpr_rf, label=f'Random Forest (AUC = {rf_aucs[class_idx]:.4f})')
plt.plot(fpr_cb, tpr_cb, label=f'CatBoost (AUC = {catboost_aucs[class_idx]:.4f})')
plt.plot([0, 1], [0, 1], 'k--')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title(f'ROC-кривые для класса {classes[class_idx]}')
plt.legend()
plt.show()

import time

# Сравнение времени обучения и прогнозирования
models_timing = {
'Random Forest': RandomForestClassifier(n_estimators=100, random_state=42),
'CatBoost': CatBoostClassifier(iterations=100, random_state=42, verbose=0)
}

timing_results = []

for name, model in models_timing.items():
# Время обучения
start_train = time.time()
model.fit(X_train, y_train)
train_time = time.time() – start_train

# Время прогнозирования
start_predict = time.time()
model.predict(X_test)
predict_time = time.time() – start_predict

timing_results.append({
'Модель': name,
'Время обучения (с)': train_time,
'Время прогнозирования (с)': predict_time
})

timing_df = pd.DataFrame(timing_results)
print(timing_df)