Учебно-методические комплексы

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

from sklearn.datasets import load_wine

from sklearn.model_selection import train_test_split, cross_val_score

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report, confusion_matrix



# Модели для сравнения

from sklearn.linear_model import LogisticRegression

from sklearn.tree import DecisionTreeClassifier

from sklearn.ensemble import RandomForestClassifier

from sklearn.svm import SVC



# Загрузка данных

data = load_wine()

X = pd.DataFrame(data.data, columns=data.feature_names)

y = pd.Series(data.target)



print(f"Размер выборки: {X.shape}")

print(f"Количество классов: {len(np.unique(y))}")

print(f"Признаки: {list(X.columns)}")



# Нормализация данных

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)



# Разделение на обучающую и тестовую выборки

X_train, X_test, y_train, y_test = train_test_split(

    X_scaled, y, test_size=0.3, random_state=42, stratify=y

)

print(f"Обучающая выборка: {X_train.shape}")

print(f"Тестовая выборка: {X_test.shape}")

# Список моделей для сравнения

models = {

    'Logistic Regression': LogisticRegression(max_iter=1000, random_state=42),

    'Decision Tree': DecisionTreeClassifier(random_state=42),

    'Random Forest': RandomForestClassifier(n_estimators=100, random_state=42),

    'SVM (RBF)': SVC(kernel='rbf', random_state=42)

}



# Обучение и оценка

results = []



for name, model in models.items():

    # Обучение

    model.fit(X_train, y_train)

    

    # Предсказания

    y_pred = model.predict(X_test)

    

    # Метрики

    acc = accuracy_score(y_test, y_pred)

    prec = precision_score(y_test, y_pred, average='weighted')

    rec = recall_score(y_test, y_pred, average='weighted')

    f1 = f1_score(y_test, y_pred, average='weighted')

    

    # Кросс-валидация

    cv_scores = cross_val_score(model, X_train, y_train, cv=5)

    

    results.append({

        'Model': name,

        'Accuracy': acc,

        'Precision': prec,

        'Recall': rec,

        'F1-score': f1,

        'CV_mean': cv_scores.mean(),

        'CV_std': cv_scores.std()

    })



results_df = pd.DataFrame(results)

print("Сравнение моделей:")

print(results_df.round(4))

# Визуализация результатов

fig, axes = plt.subplots(1, 2, figsize=(14, 5))



# График 1: Сравнение метрик

x = np.arange(len(results_df['Model']))

width = 0.2



axes[0].bar(x - width, results_df['Accuracy'], width, label='Accuracy')

axes[0].bar(x, results_df['Precision'], width, label='Precision')

axes[0].bar(x + width, results_df['Recall'], width, label='Recall')

axes[0].set_xlabel('Модель')

axes[0].set_ylabel('Значение метрики')

axes[0].set_title('Сравнение метрик качества моделей')

axes[0].set_xticks(x)

axes[0].set_xticklabels(results_df['Model'], rotation=45, ha='right')

axes[0].legend()

axes[0].set_ylim(0, 1.05)



# График 2: Кросс-валидация

axes[1].bar(x, results_df['CV_mean'], yerr=results_df['CV_std'], capsize=5)

axes[1].set_xlabel('Модель')

axes[1].set_ylabel('Средняя точность (CV)')

axes[1].set_title('Результаты 5-кратной кросс-валидации')

axes[1].set_xticks(x)

axes[1].set_xticklabels(results_df['Model'], rotation=45, ha='right')

axes[1].set_ylim(0, 1.05)



plt.tight_layout()

plt.show()

from sklearn.metrics import ConfusionMatrixDisplay



# Выберем две лучшие модели

best_models = ['Random Forest', 'SVM (RBF)']



fig, axes = plt.subplots(1, 2, figsize=(12, 5))



for i, name in enumerate(best_models):

    model = models[name]

    y_pred = model.predict(X_test)

    ConfusionMatrixDisplay.from_predictions(y_test, y_pred, ax=axes[i], cmap='Blues')

    axes[i].set_title(f'{name}\nAccuracy: {accuracy_score(y_test, y_pred):.3f}')



plt.tight_layout()

plt.show()



# Детальный отчёт для лучшей модели

best_model_name = results_df.loc[results_df['Accuracy'].idxmax(), 'Model']

best_model = models[best_model_name]

y_pred_best = best_model.predict(X_test)



print(f"Лучшая модель: {best_model_name}")

print("Classification Report:")

print(classification_report(y_test, y_pred_best, target_names=data.target_names))

# Эксперимент с Random Forest (разное количество деревьев)

n_estimators_values = [10, 50, 100, 150, 200]

rf_results = []



for n in n_estimators_values:

    rf = RandomForestClassifier(n_estimators=n, random_state=42)

    rf.fit(X_train, y_train)

    y_pred = rf.predict(X_test)

    acc = accuracy_score(y_test, y_pred)

    cv_scores = cross_val_score(rf, X_train, y_train, cv=5)

    rf_results.append({

        'n_estimators': n,

        'accuracy': acc,

        'cv_mean': cv_scores.mean(),

        'cv_std': cv_scores.std()

    })



rf_results_df = pd.DataFrame(rf_results)

print("Эксперимент с количеством деревьев в Random Forest:")

print(rf_results_df)



# Визуализация

plt.figure(figsize=(10, 5))

plt.plot(rf_results_df['n_estimators'], rf_results_df['accuracy'], 'o-', label='Test accuracy')

plt.plot(rf_results_df['n_estimators'], rf_results_df['cv_mean'], 's-', label='CV mean')

plt.fill_between(rf_results_df['n_estimators'], 

                 rf_results_df['cv_mean'] - rf_results_df['cv_std'],

                 rf_results_df['cv_mean'] + rf_results_df['cv_std'], alpha=0.3)

plt.xlabel('Количество деревьев (n_estimators)')

plt.ylabel('Точность')

plt.title('Влияние количества деревьев на качество Random Forest')

plt.legend()

plt.grid(True, alpha=0.3)

plt.show()