import numpy as np
from sklearn.metrics import accuracy_score

# Дані: 950 здорових + 50 хворих
y_true = np.array([0] * 950 + [1] * 50)

# "Розумна" модель: завжди прогнозує клас 0
y_pred_naive = np.zeros(1000)

# "Ідеальна" модель: правильно класифікує всіх
y_pred_perfect = y_true.copy()

# Реальна модель: 90% правильно для кожного класу
y_pred_real = y_true.copy()
# Помиляється у 10% випадків для кожного класу
errors_class_0 = np.random.choice(950, size=95, replace=False)
errors_class_1 = np.random.choice(np.arange(950, 1000), size=5, replace=False)
y_pred_real[errors_class_0] = 1
y_pred_real[errors_class_1] = 0

print("Точність різних моделей:")
print(f"Наївна модель (завжди '0'): {accuracy_score(y_true, y_pred_naive):.1%}")
print(f"Реальна модель (90% для кожного класу): {accuracy_score(y_true, y_pred_real):.1%}")
print(f"Ідеальна модель: {accuracy_score(y_true, y_pred_perfect):.1%}")

import matplotlib.pyplot as plt
from sklearn.metrics import recall_score

names = ['Наївна', 'Реальна', 'Ідеальна']
preds = [y_pred_naive, y_pred_real, y_pred_perfect]
acc = [accuracy_score(y_true, p) for p in preds]
rec = [recall_score(y_true, p) for p in preds]

x = np.arange(len(names))
plt.figure(figsize=(9, 5))
plt.bar(x - 0.2, acc, 0.4, label='Accuracy', color='#3b82f6')
plt.bar(x + 0.2, rec, 0.4, label='Recall (клас "хворий")', color='#ef4444')
for i in range(len(names)):
    plt.text(x[i] - 0.2, acc[i] + 0.02, f'{acc[i]:.0%}', ha='center')
    plt.text(x[i] + 0.2, rec[i] + 0.02, f'{rec[i]:.0%}', ha='center')
plt.xticks(x, names)
plt.ylim(0, 1.15)
plt.title('Accuracy обманює на незбалансованих даних', fontsize=13)
plt.legend()
plt.show()

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

# Реальні діагнози (ground truth)
y_true = np.array([0, 0, 1, 1, 0, 1, 0, 1, 0, 0,
                   0, 1, 0, 0, 1, 1, 0, 1, 0, 0])

# Прогнози моделі
y_pred = np.array([0, 0, 1, 0, 0, 1, 1, 1, 0, 0,
                   0, 1, 0, 0, 0, 1, 0, 1, 0, 0])

# Побудова Confusion Matrix
cm = confusion_matrix(y_true, y_pred)

print("Confusion Matrix:")
print(cm)
print(f"\nTrue Negatives (TN): {cm[0, 0]}")
print(f"False Positives (FP): {cm[0, 1]}")
print(f"False Negatives (FN): {cm[1, 0]}")
print(f"True Positives (TP): {cm[1, 1]}")

# Візуалізація Confusion Matrix
fig, ax = plt.subplots(figsize=(8, 6))
disp = ConfusionMatrixDisplay(confusion_matrix=cm,
                               display_labels=['Здоровий (0)', 'Хворий (1)'])
disp.plot(cmap='Blues', ax=ax, colorbar=False)
plt.title('Confusion Matrix: Діагностика хвороби', fontsize=14, pad=20)
plt.xlabel('Прогноз моделі', fontsize=12)
plt.ylabel('Справжній діагноз', fontsize=12)
plt.tight_layout()
plt.show()

# Інтерпретація
total = cm.sum()
correct = cm[0, 0] + cm[1, 1]
accuracy = correct / total

print(f"\nЗагальна кількість пацієнтів: {total}")
print(f"Правильних діагнозів: {correct} ({accuracy:.1%})")
print(f"Помилкових діагнозів: {total - correct}")
print(f"\nЗ них:")
print(f"  - Хибна тривога (FP): {cm[0, 1]} (здорового визнали хворим)")
print(f"  - Пропуск хвороби (FN): {cm[1, 0]} (хворого не виявили)")

from sklearn.metrics import precision_score

# З попереднього прикладу
y_true = np.array([0, 0, 1, 1, 0, 1, 0, 1, 0, 0,
                   0, 1, 0, 0, 1, 1, 0, 1, 0, 0])
y_pred = np.array([0, 0, 1, 0, 0, 1, 1, 1, 0, 0,
                   0, 1, 0, 0, 0, 1, 0, 1, 0, 0])

# Обчислення Precision
precision = precision_score(y_true, y_pred)

# Ручний підрахунок для перевірки
TP = ((y_true == 1) & (y_pred == 1)).sum()
FP = ((y_true == 0) & (y_pred == 1)).sum()
precision_manual = TP / (TP + FP)

print(f"Precision (sklearn): {precision:.3f}")
print(f"Precision (ручний): {precision_manual:.3f}")
print(f"\nІнтерпретація:")
print(f"Серед {TP + FP} прогнозів 'хворий', насправді хворих — {TP}")
print(f"Точність позитивних прогнозів: {precision:.1%}")

import matplotlib.pyplot as plt

plt.figure(figsize=(8, 3))
plt.barh(['Прогнози\n"хворий"'], [TP], color='#10b981', label=f'TP = {TP}')
plt.barh(['Прогнози\n"хворий"'], [FP], left=[TP], color='#ef4444', label=f'FP = {FP}')
plt.title(f'Precision = {TP}/{TP + FP} = {precision:.1%}', fontsize=13)
plt.xlabel('Кількість прогнозів')
plt.legend(loc='lower right')
plt.show()

from sklearn.metrics import recall_score

# Обчислення Recall
recall = recall_score(y_true, y_pred)

# Ручний підрахунок
TP = ((y_true == 1) & (y_pred == 1)).sum()
FN = ((y_true == 1) & (y_pred == 0)).sum()
recall_manual = TP / (TP + FN)

print(f"Recall (sklearn): {recall:.3f}")
print(f"Recall (ручний): {recall_manual:.3f}")
print(f"\nІнтерпретація:")
print(f"Усього справжніх хворих: {TP + FN}")
print(f"Виявлено моделлю: {TP}")
print(f"Пропущено (FN): {FN}")
print(f"Повнота виявлення: {recall:.1%}")

import matplotlib.pyplot as plt

plt.figure(figsize=(8, 3))
plt.barh(['Справжні\nхворі'], [TP], color='#10b981', label=f'Виявлено TP = {TP}')
plt.barh(['Справжні\nхворі'], [FN], left=[TP], color='#f59e0b', label=f'Пропущено FN = {FN}')
plt.title(f'Recall = {TP}/{TP + FN} = {recall:.1%}', fontsize=13)
plt.xlabel('Кількість пацієнтів')
plt.legend(loc='lower right')
plt.show()

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import precision_score, recall_score
from sklearn.datasets import make_classification

# Генерація синтетичних даних
X, y = make_classification(n_samples=200, n_features=10, n_informative=8,
                           n_redundant=2, n_classes=2, weights=[0.7, 0.3],
                           random_state=42)

# Навчання моделі
model = LogisticRegression(random_state=42)
model.fit(X, y)

# Отримання ймовірностей
y_probs = model.predict_proba(X)[:, 1]

# Тестування різних порогів
thresholds = [0.3, 0.5, 0.7, 0.9]
results = []

for threshold in thresholds:
    y_pred = (y_probs >= threshold).astype(int)
    precision = precision_score(y, y_pred)
    recall = recall_score(y, y_pred)
    
    results.append({
        'Поріг': threshold,
        'Precision': f'{precision:.3f}',
        'Recall': f'{recall:.3f}',
        'Прогнозів "1"': y_pred.sum()
    })

import pandas as pd
results_df = pd.DataFrame(results)
print(results_df.to_string(index=False))

import matplotlib.pyplot as plt

ts = np.linspace(0.05, 0.95, 91)
prec = [precision_score(y, (y_probs >= t).astype(int), zero_division=0) for t in ts]
rec = [recall_score(y, (y_probs >= t).astype(int)) for t in ts]

plt.figure(figsize=(10, 6))
plt.plot(ts, prec, color='#3b82f6', linewidth=2.5, label='Precision')
plt.plot(ts, rec, color='#ef4444', linewidth=2.5, label='Recall')
for t in thresholds:
    plt.axvline(t, color='gray', linestyle=':', alpha=0.6)
plt.xlabel('Поріг класифікації', fontsize=12)
plt.ylabel('Значення метрики', fontsize=12)
plt.title('Компроміс Precision / Recall', fontsize=14)
plt.legend()
plt.grid(alpha=0.3)
plt.show()

# Порівняння середніх
precision_cases = [
    (0.9, 0.9),  # Обидві метрики високі
    (0.9, 0.1),  # Precision високий, Recall низький
    (0.5, 0.5),  # Обидві середні
]

for p, r in precision_cases:
    arithmetic = (p + r) / 2
    harmonic = 2 * (p * r) / (p + r) if (p + r) > 0 else 0
    
    print(f"Precision={p:.1f}, Recall={r:.1f}")
    print(f"  Арифметичне середнє: {arithmetic:.3f}")
    print(f"  F1-Score (гармонійне): {harmonic:.3f}")
    print()

import matplotlib.pyplot as plt

labels = [f'P={p}, R={r}' for p, r in precision_cases]
arith = [(p + r) / 2 for p, r in precision_cases]
harm = [2 * p * r / (p + r) for p, r in precision_cases]

x = np.arange(len(labels))
plt.figure(figsize=(9, 5))
plt.bar(x - 0.2, arith, 0.4, label='Арифметичне середнє', color='#94a3b8')
plt.bar(x + 0.2, harm, 0.4, label='F1 (гармонійне)', color='#3b82f6')
for i in range(len(labels)):
    plt.text(x[i] - 0.2, arith[i] + 0.02, f'{arith[i]:.2f}', ha='center')
    plt.text(x[i] + 0.2, harm[i] + 0.02, f'{harm[i]:.2f}', ha='center')
plt.xticks(x, labels)
plt.ylim(0, 1.1)
plt.title('F1 жорстко штрафує дисбаланс метрик', fontsize=13)
plt.legend()
plt.show()

from sklearn.metrics import f1_score, precision_score, recall_score

# З попередніх прикладів
precision = precision_score(y_true, y_pred)
recall = recall_score(y_true, y_pred)
f1 = f1_score(y_true, y_pred)

# Ручний підрахунок
f1_manual = 2 * (precision * recall) / (precision + recall)

print(f"Precision: {precision:.3f}")
print(f"Recall: {recall:.3f}")
print(f"F1-Score (sklearn): {f1:.3f}")
print(f"F1-Score (ручний): {f1_manual:.3f}")
print(f"\nІнтерпретація:")
print(f"Модель досягла балансу між точністю ({precision:.1%})")
print(f"та повнотою ({recall:.1%}) з F1 = {f1:.3f}")

import matplotlib.pyplot as plt

names = ['Precision', 'Recall', 'F1-Score']
vals = [precision, recall, f1]

plt.figure(figsize=(8, 5))
bars = plt.bar(names, vals, color=['#3b82f6', '#ef4444', '#8b5cf6'])
for bar, v in zip(bars, vals):
    plt.text(bar.get_x() + bar.get_width() / 2, v + 0.02, f'{v:.3f}', ha='center', fontsize=12)
plt.ylim(0, 1.1)
plt.title('F1 лежить між Precision та Recall', fontsize=13)
plt.show()

from sklearn.metrics import fbeta_score

# Обчислення різних F-мір
f05 = fbeta_score(y_true, y_pred, beta=0.5)  # Пріоритет Precision
f1 = fbeta_score(y_true, y_pred, beta=1.0)   # Баланс
f2 = fbeta_score(y_true, y_pred, beta=2.0)   # Пріоритет Recall

print(f"F0.5 (пріоритет Precision): {f05:.3f}")
print(f"F1   (баланс):              {f1:.3f}")
print(f"F2   (пріоритет Recall):    {f2:.3f}")
print(f"\nPrecision: {precision:.3f}")
print(f"Recall:    {recall:.3f}")

import matplotlib.pyplot as plt

names = ['Precision', 'F0.5', 'F1', 'F2', 'Recall']
vals = [precision, f05, f1, f2, recall]
colors = ['#3b82f6', '#60a5fa', '#8b5cf6', '#f87171', '#ef4444']

plt.figure(figsize=(9, 5))
bars = plt.bar(names, vals, color=colors)
for bar, v in zip(bars, vals):
    plt.text(bar.get_x() + bar.get_width() / 2, v + 0.01, f'{v:.3f}', ha='center', fontsize=12)
plt.ylim(0.6, 0.92)
plt.title('Fβ зміщується до Precision (β<1) або Recall (β>1)', fontsize=13)
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_curve, roc_auc_score

# Генерація даних
X, y = make_classification(n_samples=500, n_features=10, n_informative=8,
                           n_classes=2, weights=[0.6, 0.4], random_state=42)

# Розділення на навчальну та тестову вибірки
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

# Навчання моделі
model = LogisticRegression(random_state=42)
model.fit(X_train, y_train)

# Отримання ймовірностей для побудови ROC
y_probs = model.predict_proba(X_test)[:, 1]

print(f"Навчальна вибірка: {X_train.shape}")
print(f"Тестова вибірка: {X_test.shape}")
print(f"Розподіл класів у тесті: {np.bincount(y_test)}")

# Обчислення TPR та FPR для різних порогів
fpr, tpr, thresholds = roc_curve(y_test, y_probs)
auc_score = roc_auc_score(y_test, y_probs)

# Побудова графіка
plt.figure(figsize=(10, 7))

# ROC-крива моделі
plt.plot(fpr, tpr, linewidth=2.5, color='#3b82f6', 
         label=f'Logistic Regression (AUC = {auc_score:.3f})')

# Діагональ (випадкова модель)
plt.plot([0, 1], [0, 1], 'k--', linewidth=2, alpha=0.7,
         label='Випадкова модель (AUC = 0.5)')

# Ідеальна модель
plt.plot([0, 0, 1], [0, 1, 1], 'g:', linewidth=2, alpha=0.7,
         label='Ідеальна модель (AUC = 1.0)')

plt.xlabel('False Positive Rate (FPR)', fontsize=12)
plt.ylabel('True Positive Rate (TPR / Recall)', fontsize=12)
plt.title('ROC-крива', fontsize=14, pad=15)
plt.legend(loc='lower right', fontsize=11)
plt.grid(alpha=0.3)
plt.xlim([-0.02, 1.02])
plt.ylim([-0.02, 1.02])
plt.tight_layout()
plt.show()

print(f"\nAUC (Area Under Curve): {auc_score:.3f}")

from sklearn.metrics import precision_recall_curve, average_precision_score

# Створення сильно незбалансованого датасету (95% : 5%)
X_imb, y_imb = make_classification(n_samples=1000, n_features=10, n_informative=8,
                                    n_classes=2, weights=[0.95, 0.05], random_state=42)

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
)

# Навчання моделі
model_imb = LogisticRegression(random_state=42, max_iter=1000)
model_imb.fit(X_train_imb, y_train_imb)
y_probs_imb = model_imb.predict_proba(X_test_imb)[:, 1]

# Обчислення метрик
precision, recall, pr_thresholds = precision_recall_curve(y_test_imb, y_probs_imb)
avg_precision = average_precision_score(y_test_imb, y_probs_imb)

fpr_imb, tpr_imb, roc_thresholds = roc_curve(y_test_imb, y_probs_imb)
auc_imb = roc_auc_score(y_test_imb, y_probs_imb)

print(f"Розподіл класів у тестовій вибірці:")
print(f"  Клас 0: {(y_test_imb == 0).sum()} ({(y_test_imb == 0).mean():.1%})")
print(f"  Клас 1: {(y_test_imb == 1).sum()} ({(y_test_imb == 1).mean():.1%})")
print(f"\nROC-AUC: {auc_imb:.3f}")
print(f"Average Precision: {avg_precision:.3f}")

# Візуалізація обох кривих
fig, axes = plt.subplots(1, 2, figsize=(14, 6))

# ROC-крива
axes[0].plot(fpr_imb, tpr_imb, linewidth=2.5, color='#3b82f6',
             label=f'AUC = {auc_imb:.3f}')
axes[0].plot([0, 1], [0, 1], 'k--', linewidth=2, alpha=0.7)
axes[0].set_xlabel('False Positive Rate', fontsize=12)
axes[0].set_ylabel('True Positive Rate', fontsize=12)
axes[0].set_title('ROC-крива (здається відмінно!)', fontsize=13)
axes[0].legend(loc='lower right')
axes[0].grid(alpha=0.3)

# Precision-Recall крива
axes[1].plot(recall, precision, linewidth=2.5, color='#f59e0b',
             label=f'AP = {avg_precision:.3f}')
axes[1].axhline(y=(y_test_imb == 1).mean(), color='k', linestyle='--',
                linewidth=2, alpha=0.7, label='Baseline (випадкова)')
axes[1].set_xlabel('Recall', fontsize=12)
axes[1].set_ylabel('Precision', fontsize=12)
axes[1].set_title('PR-крива (реалістичніша оцінка)', fontsize=13)
axes[1].legend(loc='lower left')
axes[1].grid(alpha=0.3)

plt.tight_layout()
plt.show()

from sklearn.metrics import confusion_matrix

# Обчислення Specificity вручну
cm = confusion_matrix(y_test, model.predict(X_test))
TN, FP, FN, TP = cm.ravel()

specificity = TN / (TN + FP)
sensitivity = TP / (TP + FN)  # Це той самий Recall

print(f"Confusion Matrix:")
print(cm)
print(f"\nSensitivity (Recall для класу 1): {sensitivity:.3f}")
print(f"Specificity (Recall для класу 0): {specificity:.3f}")
print(f"\nІнтерпретація:")
print(f"  Серед {TP + FN} хворих виявлено {TP} ({sensitivity:.1%})")
print(f"  Серед {TN + FP} здорових правильно визначено {TN} ({specificity:.1%})")

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(6.5, 5.5))
ax.imshow(cm, cmap='Blues')
for i in range(2):
    for j in range(2):
        ax.text(j, i, cm[i, j], ha='center', va='center', fontsize=22,
                color='white' if cm[i, j] > 50 else '#1f2937')
ax.set_xticks([0, 1]); ax.set_xticklabels(['Здоровий', 'Хворий'])
ax.set_yticks([0, 1]); ax.set_yticklabels(['Здоровий', 'Хворий'])
ax.set_xlabel('Прогноз'); ax.set_ylabel('Факт')
ax.set_title(f'Specificity = {specificity:.1%}  |  Sensitivity = {sensitivity:.1%}', fontsize=12)
plt.show()

from sklearn.metrics import classification_report

# Прогнози моделі
y_pred = model.predict(X_test)

# Генерація звіту
report = classification_report(y_test, y_pred, 
                               target_names=['Здоровий', 'Хворий'])

print(report)

import matplotlib.pyplot as plt

rep = classification_report(y_test, y_pred, target_names=['Здоровий', 'Хворий'],
                            output_dict=True)
classes = ['Здоровий', 'Хворий']
metrics = ['precision', 'recall', 'f1-score']
colors = ['#3b82f6', '#ef4444', '#8b5cf6']

x = np.arange(len(classes))
plt.figure(figsize=(9, 5))
for k, (m, c) in enumerate(zip(metrics, colors)):
    vals = [rep[cl][m] for cl in classes]
    plt.bar(x + (k - 1) * 0.25, vals, 0.25, label=m, color=c)
    for xi, v in zip(x, vals):
        plt.text(xi + (k - 1) * 0.25, v + 0.005, f'{v:.2f}', ha='center', fontsize=10)
plt.xticks(x, classes)
plt.ylim(0.85, 1.0)
plt.title('Метрики по класах (classification_report)', fontsize=13)
plt.legend()
plt.show()

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score

# Навчання трьох різних моделей
models = {
    'Logistic Regression': LogisticRegression(random_state=42, max_iter=1000),
    'Decision Tree': DecisionTreeClassifier(random_state=42, max_depth=5),
    'Random Forest': RandomForestClassifier(random_state=42, n_estimators=100)
}

results = []

for name, model in models.items():
    # Навчання
    model.fit(X_train, y_train)
    
    # Прогнози
    y_pred = model.predict(X_test)
    y_probs = model.predict_proba(X_test)[:, 1]
    
    # Метрики
    results.append({
        'Model': name,
        'Accuracy': accuracy_score(y_test, y_pred),
        'Precision': precision_score(y_test, y_pred),
        'Recall': recall_score(y_test, y_pred),
        'F1-Score': f1_score(y_test, y_pred),
        'ROC-AUC': roc_auc_score(y_test, y_probs)
    })

# Порівняльна таблиця
import pandas as pd
results_df = pd.DataFrame(results)
print(results_df.to_string(index=False))

# Побудова графіка порівняння
fig, ax = plt.subplots(figsize=(12, 6))

metrics = ['Accuracy', 'Precision', 'Recall', 'F1-Score', 'ROC-AUC']
x = np.arange(len(metrics))
width = 0.25

for i, (name, row) in enumerate(results_df.iterrows()):
    values = [row[m] for m in metrics]
    ax.bar(x + i * width, values, width, label=row['Model'], alpha=0.8)

ax.set_xlabel('Метрики', fontsize=12)
ax.set_ylabel('Значення', fontsize=12)
ax.set_title('Порівняння моделей за різними метриками', fontsize=14, pad=15)
ax.set_xticks(x + width)
ax.set_xticklabels(metrics)
ax.legend()
ax.set_ylim([0.85, 1.0])
ax.grid(axis='y', alpha=0.3)
plt.tight_layout()
plt.show()

# Висновок
best_model = results_df.loc[results_df['ROC-AUC'].idxmax(), 'Model']
print(f"\n🏆 Найкраща модель за ROC-AUC: {best_model}")