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

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

from sklearn.datasets import load_breast_cancer

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import (accuracy_score, precision_score, recall_score, 

                            f1_score, roc_auc_score, roc_curve, confusion_matrix,

                            classification_report)



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

data = load_breast_cancer()

X = data.data

y = data.target



print(f"Размер: {X.shape}")

print(f"Классы: 0 - {data.target_names[0]}, 1 - {data.target_names[1]}")

print(f"Распределение классов:\n{pd.Series(y).value_counts()}")



# Разделение

X_train, X_test, y_train, y_test = train_test_split(

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

)



# Обучение

model = LogisticRegression(max_iter=1000, random_state=42)

model.fit(X_train, y_train)



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

y_pred = model.predict(X_test)

y_pred_proba = model.predict_proba(X_test)[:, 1]



print("Модель обучена!")

from sklearn.metrics import ConfusionMatrixDisplay



# Расчёт матрицы ошибок

cm = confusion_matrix(y_test, y_pred)

print("Матрица ошибок:")

print(cm)

print("Расшифровка:")

print(f"TN (True Negative): {cm[0,0]}")

print(f"FP (False Positive): {cm[0,1]}")

print(f"FN (False Negative): {cm[1,0]}")

print(f"TP (True Positive): {cm[1,1]}")



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

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



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

axes[0].set_title('Матрица ошибок (числа)')



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

axes[1].set_title('Матрица ошибок (нормализованная)')



plt.tight_layout()

plt.show()

# Расчёт метрик

acc = accuracy_score(y_test, y_pred)

prec = precision_score(y_test, y_pred)

rec = recall_score(y_test, y_pred)

f1 = f1_score(y_test, y_pred)



print("Метрики качества классификации:")

print(f"Accuracy (точность): {acc:.4f}")

print(f"Precision (точность предсказания положительного класса): {prec:.4f}")

print(f"Recall (полнота / чувствительность): {rec:.4f}")

print(f"F1-score: {f1:.4f}")



# Classification Report

print("\nПолный отчёт о классификации:")

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



# Сравнение метрик

metrics_df = pd.DataFrame({

    'Metric': ['Accuracy', 'Precision', 'Recall', 'F1-score'],

    'Value': [acc, prec, rec, f1]

})



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

plt.bar(metrics_df['Metric'], metrics_df['Value'], color='skyblue')

plt.ylim(0, 1.05)

plt.ylabel('Значение')

plt.title('Метрики качества модели')

for i, v in enumerate(metrics_df['Value']):

    plt.text(i, v + 0.02, f'{v:.3f}', ha='center')

plt.show()

# ROC-кривая

fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba)

roc_auc = roc_auc_score(y_test, y_pred_proba)



plt.figure(figsize=(8, 6))

plt.plot(fpr, tpr, linewidth=2, label=f'ROC-кривая (AUC = {roc_auc:.3f})')

plt.plot([0, 1], [0, 1], 'r--', linewidth=1, label='Случайный классификатор')

plt.xlabel('False Positive Rate (1 - Specificity)')

plt.ylabel('True Positive Rate (Recall)')

plt.title('ROC-кривая')

plt.legend()

plt.grid(True, alpha=0.3)

plt.show()



print(f"AUC (Area Under Curve): {roc_auc:.4f}")

print("Интерпретация AUC:")

print("0.9-1.0 - отличный классификатор")

print("0.8-0.9 - хороший классификатор")

print("0.7-0.8 - удовлетворительный")

print("0.5-0.7 - плохой")

print("0.5 - случайное угадывание")

# Создание несбалансированных данных

from sklearn.datasets import make_classification



# Генерируем данные с дисбалансом классов (95% vs 5%)

X_imb, y_imb = make_classification(

    n_samples=1000, n_features=10, n_classes=2,

    weights=[0.95, 0.05], random_state=42

)



print(f"Распределение классов: {np.bincount(y_imb)}")

print(f"Доля класса 1: {np.mean(y_imb):.2%}")



# Разделение

X_train_imb, X_test_imb, y_train_imb, y_test_imb = train_test_split(

    X_imb, y_imb, test_size=0.3, random_state=42, stratify=y_imb

)



# Обучение модели (простой классификатор, который всегда предсказывает 0)

from sklearn.dummy import DummyClassifier



dummy = DummyClassifier(strategy='most_frequent')

dummy.fit(X_train_imb, y_train_imb)

y_pred_dummy = dummy.predict(X_test_imb)



# Сравнение с реальной моделью

model_imb = LogisticRegression(max_iter=1000, random_state=42)

model_imb.fit(X_train_imb, y_train_imb)

y_pred_imb = model_imb.predict(X_test_imb)

y_pred_proba_imb = model_imb.predict_proba(X_test_imb)[:, 1]



print("\nDummyClassifier (всегда предсказывает 0):")

print(f"Accuracy: {accuracy_score(y_test_imb, y_pred_dummy):.4f}")

print(f"Precision: {precision_score(y_test_imb, y_pred_dummy, zero_division=0):.4f}")

print(f"Recall: {recall_score(y_test_imb, y_pred_dummy):.4f}")



print("\nЛогистическая регрессия:")

print(f"Accuracy: {accuracy_score(y_test_imb, y_pred_imb):.4f}")

print(f"Precision: {precision_score(y_test_imb, y_pred_imb):.4f}")

print(f"Recall: {recall_score(y_test_imb, y_pred_imb):.4f}")

print(f"F1-score: {f1_score(y_test_imb, y_pred_imb):.4f}")

print(f"AUC: {roc_auc_score(y_test_imb, y_pred_proba_imb):.4f}")