Функції активації та побудова нейронної мережі для передбачення вад серця

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

def sigmoid_derivative(z):
    s = sigmoid(z)
    return s * (1 - s)

# Діапазон значень
z = np.linspace(-10, 10, 500)

# Візуалізація
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))

# Сигмоїда
ax1.plot(z, sigmoid(z), color='#3b82f6', linewidth=3, label='σ(z)')
ax1.axhline(0, color='gray', linestyle='--', alpha=0.3)
ax1.axhline(1, color='gray', linestyle='--', alpha=0.3)
ax1.axvline(0, color='gray', linestyle='--', alpha=0.3)
ax1.grid(alpha=0.3)
ax1.set_xlabel('z', fontsize=14)
ax1.set_ylabel('σ(z)', fontsize=14)
ax1.set_title('Функція Sigmoid', fontsize=16, fontweight='bold')
ax1.legend(fontsize=12)

# Похідна сигмоїди
ax2.plot(z, sigmoid_derivative(z), color='#ef4444', linewidth=3, label="σ'(z) = σ(z)·(1 - σ(z))")
ax2.axhline(0, color='gray', linestyle='--', alpha=0.3)
ax2.axvline(0, color='gray', linestyle='--', alpha=0.3)
ax2.fill_between(z, 0, sigmoid_derivative(z), alpha=0.2, color='#ef4444')

# Позначимо максимум похідної
max_val = sigmoid_derivative(0)
ax2.plot(0, max_val, 'o', color='#dc2626', markersize=12, label=f'Максимум: σ\'(0) = {max_val:.3f}')
ax2.annotate(f'Макс = {max_val:.3f}\nпри z=0', xy=(0, max_val), xytext=(2, max_val),
             arrowprops=dict(arrowstyle='->', color='#dc2626', lw=2),
             fontsize=12, color='#dc2626', fontweight='bold')

# Критичні зони
ax2.axvspan(-10, -5, alpha=0.15, color='yellow', label='Зони зникаючого градієнта')
ax2.axvspan(5, 10, alpha=0.15, color='yellow')
ax2.text(-7.5, 0.15, 'σ\'(z) ≈ 0', fontsize=11, ha='center', style='italic')
ax2.text(7.5, 0.15, 'σ\'(z) ≈ 0', fontsize=11, ha='center', style='italic')

ax2.grid(alpha=0.3)
ax2.set_xlabel('z', fontsize=14)
ax2.set_ylabel("σ'(z)", fontsize=14)
ax2.set_title('Похідна Sigmoid', fontsize=16, fontweight='bold')
ax2.legend(fontsize=11, loc='upper right')

plt.tight_layout()
plt.show()

import numpy as np
import matplotlib.pyplot as plt

def relu(z):
    return np.maximum(0, z)

def relu_derivative(z):
    return np.where(z > 0, 1, 0)

z = np.linspace(-5, 5, 500)

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))

# ReLU функція
ax1.plot(z, relu(z), color='#10b981', linewidth=3, label='ReLU(z)')
ax1.axhline(0, color='gray', linestyle='--', alpha=0.3)
ax1.axvline(0, color='gray', linestyle='--', alpha=0.3)
ax1.grid(alpha=0.3)
ax1.set_xlabel('z', fontsize=14)
ax1.set_ylabel('ReLU(z)', fontsize=14)
ax1.set_title('Функція ReLU', fontsize=16, fontweight='bold')
ax1.legend(fontsize=12)
ax1.fill_between(z[z > 0], 0, relu(z)[z > 0], alpha=0.2, color='#10b981')
ax1.text(2, 1, 'Активна зона\n(градієнт = 1)', fontsize=12, color='#059669', fontweight='bold')
ax1.text(-3, 1, 'Мертва зона\n(градієнт = 0)', fontsize=12, color='#6b7280', fontweight='bold')

# ReLU похідна
ax2.plot(z, relu_derivative(z), color='#f59e0b', linewidth=3, drawstyle='steps-post', label="ReLU'(z)")
ax2.axhline(0, color='gray', linestyle='--', alpha=0.3)
ax2.axhline(1, color='#10b981', linestyle='--', alpha=0.3, linewidth=2)
ax2.axvline(0, color='gray', linestyle='--', alpha=0.3)
ax2.grid(alpha=0.3)
ax2.set_xlabel('z', fontsize=14)
ax2.set_ylabel("ReLU'(z)", fontsize=14)
ax2.set_title('Похідна ReLU', fontsize=16, fontweight='bold')
ax2.legend(fontsize=12)
ax2.set_ylim(-0.2, 1.3)

# Позначення константного градієнта
ax2.annotate('Градієнт = 1 (константа!)\nНемає зникання', 
             xy=(3, 1), xytext=(2, 1.15),
             arrowprops=dict(arrowstyle='->', color='#10b981', lw=2),
             fontsize=12, color='#059669', fontweight='bold',
             bbox=dict(boxstyle='round,pad=0.5', facecolor='#d1fae5', edgecolor='#10b981'))

plt.tight_layout()
plt.show()

import numpy as np
import matplotlib.pyplot as plt

def relu(z):
    return np.maximum(0, z)

def leaky_relu(z, alpha=0.01):
    return np.where(z > 0, z, alpha * z)

z = np.linspace(-5, 5, 500)

plt.figure(figsize=(12, 7))
plt.plot(z, relu(z), color='#10b981', linewidth=3, label='ReLU', linestyle='--', alpha=0.7)
plt.plot(z, leaky_relu(z), color='#f59e0b', linewidth=3, label='Leaky ReLU (α=0.01)')

plt.axhline(0, color='gray', linestyle='--', alpha=0.3)
plt.axvline(0, color='gray', linestyle='--', alpha=0.3)
plt.grid(alpha=0.3)

# Позначення відмінностей
plt.fill_between(z[z < 0], 0, leaky_relu(z)[z < 0], alpha=0.3, color='#f59e0b', 
                 label='Зона відновлення (α·z)')
plt.annotate('ReLU: градієнт = 0\n(нейрон "вмирає")', 
             xy=(-3, 0), xytext=(-4, 1.5),
             arrowprops=dict(arrowstyle='->', color='#6b7280', lw=2),
             fontsize=11, color='#6b7280', fontweight='bold')
plt.annotate('Leaky ReLU: градієнт = 0.01\n(нейрон продовжує навчатися)', 
             xy=(-3, -0.03), xytext=(-4, -2),
             arrowprops=dict(arrowstyle='->', color='#f59e0b', lw=2),
             fontsize=11, color='#d97706', fontweight='bold',
             bbox=dict(boxstyle='round,pad=0.5', facecolor='#fef3c7', edgecolor='#f59e0b'))

plt.xlabel('z', fontsize=14)
plt.ylabel('Активація', fontsize=14)
plt.title('Порівняння ReLU та Leaky ReLU', fontsize=16, fontweight='bold')
plt.legend(fontsize=12, loc='upper left')
plt.ylim(-0.3, 5)
plt.tight_layout()
plt.show()

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Налаштування візуалізації
sns.set_style("whitegrid")
plt.rcParams['figure.figsize'] = (14, 6)
plt.rcParams['font.size'] = 12

# Назви стовпців (не вказані у файлі даних)
column_names = [
    'age', 'sex', 'cp', 'trestbps', 'chol', 'fbs', 
    'restecg', 'thalach', 'exang', 'oldpeak', 'slope', 
    'ca', 'thal', 'target'
]

# Завантаження даних
url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/heart-disease/processed.cleveland.data'
df = pd.read_csv(url, names=column_names, na_values='?')

print("=" * 70)
print("ДАТАСЕТ UCI HEART DISEASE — ОГЛЯД")
print("=" * 70)
print(f"\nРозмір датасету: {df.shape[0]} пацієнтів × {df.shape[1]} ознак")
print(f"\nПерші 5 записів:")
print(df.head())

# Інформація про типи даних та пропуски
print("\n" + "=" * 70)
print("ІНФОРМАЦІЯ ПРО СТОВПЦІ ТА ПРОПУЩЕНІ ЗНАЧЕННЯ")
print("=" * 70)
print(df.info())

print("\n" + "=" * 70)
print("ПРОПУЩЕНІ ЗНАЧЕННЯ ПО СТОВПЦЯХ")
print("=" * 70)
missing = df.isnull().sum()
missing_pct = (missing / len(df)) * 100
missing_df = pd.DataFrame({
    'Стовпець': missing.index,
    'Кількість пропусків': missing.values,
    'Відсоток': missing_pct.values
}).query('`Кількість пропусків` > 0')

if len(missing_df) > 0:
    print(missing_df.to_string(index=False))
else:
    print("✅ Пропущених значень немає!")

# Видалення рядків із пропусками
df_clean = df.dropna()

print(f"\nДатасет після очищення: {df_clean.shape[0]} пацієнтів")

# Перетворення цільової змінної у бінарну (0 = здоровий, 1 = хворий)
df_clean['target'] = (df_clean['target'] > 0).astype(int)

print("\nРозподіл класів:")
print(df_clean['target'].value_counts().sort_index())
print(f"\nВідсоток хворих: {df_clean['target'].mean() * 100:.1f}%")

# Статистичний опис числових ознак
print("=" * 70)
print("СТАТИСТИЧНИЙ ОПИС ЧИСЛОВИХ ОЗНАК")
print("=" * 70)
print(df_clean.describe().round(2))

# Розподіл віку за статтю та діагнозом
fig, axes = plt.subplots(1, 2, figsize=(16, 6))

# Розподіл віку
axes[0].hist([df_clean[df_clean['target'] == 0]['age'], 
              df_clean[df_clean['target'] == 1]['age']], 
             bins=15, label=['Здорові', 'Хворі'], color=['#10b981', '#ef4444'], alpha=0.7)
axes[0].set_xlabel('Вік (роки)', fontsize=14)
axes[0].set_ylabel('Кількість пацієнтів', fontsize=14)
axes[0].set_title('Розподіл віку за діагнозом', fontsize=16, fontweight='bold')
axes[0].legend(fontsize=12)
axes[0].grid(alpha=0.3)

# Співвідношення чоловіки/жінки з хворобою
sex_target = pd.crosstab(df_clean['sex'], df_clean['target'], normalize='index') * 100
sex_labels = ['Жінки', 'Чоловіки']
x = np.arange(len(sex_labels))
width = 0.35

axes[1].bar(x - width/2, sex_target[0], width, label='Здорові', color='#10b981', alpha=0.8)
axes[1].bar(x + width/2, sex_target[1], width, label='Хворі', color='#ef4444', alpha=0.8)
axes[1].set_xlabel('Стать', fontsize=14)
axes[1].set_ylabel('Відсоток (%)', fontsize=14)
axes[1].set_title('Частота серцевих захворювань за статтю', fontsize=16, fontweight='bold')
axes[1].set_xticks(x)
axes[1].set_xticklabels(sex_labels, fontsize=13)
axes[1].legend(fontsize=12)
axes[1].grid(alpha=0.3, axis='y')

plt.tight_layout()
plt.show()

# Кореляційна матриця
plt.figure(figsize=(14, 11))
correlation_matrix = df_clean.corr()

# Використання маски для верхнього трикутника (естетично краще)
mask = np.triu(np.ones_like(correlation_matrix, dtype=bool))

sns.heatmap(correlation_matrix, mask=mask, annot=True, fmt='.2f', cmap='RdYlGn_r', 
            center=0, square=True, linewidths=1, cbar_kws={"shrink": 0.8})

plt.title('Кореляційна матриця клінічних ознак\n(Метод Пірсона)', 
          fontsize=16, fontweight='bold', pad=20)
plt.tight_layout()
plt.show()

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import TensorDataset, DataLoader
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, confusion_matrix
import numpy as np
import pandas as pd

# Перевірка доступності GPU
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"Використовуємо пристрій: {device}")
if device.type == 'cuda':
    print(f"GPU: {torch.cuda.get_device_name(0)}")

# Завантаження очищеного датасету (з попередньої секції)
column_names = ['age', 'sex', 'cp', 'trestbps', 'chol', 'fbs', 
                'restecg', 'thalach', 'exang', 'oldpeak', 'slope', 
                'ca', 'thal', 'target']
url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/heart-disease/processed.cleveland.data'
df = pd.read_csv(url, names=column_names, na_values='?').dropna()
df['target'] = (df['target'] > 0).astype(int)

# Розділення на ознаки (X) та цільову змінну (y)
X = df.drop('target', axis=1).values
y = df['target'].values

print(f"Розмір датасету: {X.shape[0]} пацієнтів × {X.shape[1]} ознак")
print(f"Розподіл класів: {np.bincount(y)} (0=здорові, 1=хворі)")

# Розбиття на train (70%), validation (15%), test (15%)
X_temp, X_test, y_temp, y_test = train_test_split(X, y, test_size=0.15, random_state=42, stratify=y)
X_train, X_val, y_train, y_val = train_test_split(X_temp, y_temp, test_size=0.176, random_state=42, stratify=y_temp)
# 0.176 від 85% ≈ 15% від загального датасету

print("Розбиття датасету:")
print(f"  Train:      {X_train.shape[0]} зразків ({X_train.shape[0]/X.shape[0]*100:.1f}%)")
print(f"  Validation: {X_val.shape[0]} зразків ({X_val.shape[0]/X.shape[0]*100:.1f}%)")
print(f"  Test:       {X_test.shape[0]} зразків ({X_test.shape[0]/X.shape[0]*100:.1f}%)")

# Перевірка балансу класів у кожній вибірці
print("\nБаланс класів:")
print(f"  Train:      {np.bincount(y_train)} → {y_train.mean()*100:.1f}% хворих")
print(f"  Validation: {np.bincount(y_val)} → {y_val.mean()*100:.1f}% хворих")
print(f"  Test:       {np.bincount(y_test)} → {y_test.mean()*100:.1f}% хворих")

# Масштабування ознак (критично для нейронних мереж!)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)  # Fit лише на train!
X_val_scaled = scaler.transform(X_val)
X_test_scaled = scaler.transform(X_test)

print("Масштабування завершено. Приклад трансформації:")
print(f"  Оригінальне середнє (train): {X_train.mean(axis=0)[:3].round(2)}")
print(f"  Після масштабування (train): {X_train_scaled.mean(axis=0)[:3].round(6)}")
print(f"  Стандартне відхилення (train): {X_train_scaled.std(axis=0)[:3].round(2)}")

# Перетворення NumPy масивів у PyTorch тензори
X_train_tensor = torch.FloatTensor(X_train_scaled)
y_train_tensor = torch.FloatTensor(y_train).unsqueeze(1)  # Додаємо розмірність для (N, 1)

X_val_tensor = torch.FloatTensor(X_val_scaled)
y_val_tensor = torch.FloatTensor(y_val).unsqueeze(1)

X_test_tensor = torch.FloatTensor(X_test_scaled)
y_test_tensor = torch.FloatTensor(y_test).unsqueeze(1)

# Створення Dataset та DataLoader
train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
val_dataset = TensorDataset(X_val_tensor, y_val_tensor)
test_dataset = TensorDataset(X_test_tensor, y_test_tensor)

batch_size = 32
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

print(f"DataLoader створено:")
print(f"  Train: {len(train_loader)} батчів по {batch_size} зразків")
print(f"  Val:   {len(val_loader)} батчів")
print(f"  Test:  {len(test_loader)} батчів")

class HeartDiseaseNet(nn.Module):
    """
    Нейронна мережа для передбачення серцево-судинних захворювань.
    
    Архітектура:
      - Вхід: 13 клінічних ознак
      - Прихований шар 1: 64 нейрони (ReLU + Dropout 30%)
      - Прихований шар 2: 32 нейрони (ReLU + Dropout 20%)
      - Вихід: 1 нейрон (Sigmoid) — ймовірність хвороби
    """
    
    def __init__(self, input_size=13, hidden1=64, hidden2=32, dropout1=0.3, dropout2=0.2):
        super(HeartDiseaseNet, self).__init__()
        
        # Прихований шар 1
        self.fc1 = nn.Linear(input_size, hidden1)
        self.relu1 = nn.ReLU()
        self.dropout1 = nn.Dropout(dropout1)
        
        # Прихований шар 2
        self.fc2 = nn.Linear(hidden1, hidden2)
        self.relu2 = nn.ReLU()
        self.dropout2 = nn.Dropout(dropout2)
        
        # Вихідний шар
        self.fc3 = nn.Linear(hidden2, 1)
        self.sigmoid = nn.Sigmoid()
        
    def forward(self, x):
        """Прямий прохід (forward propagation)"""
        # Шар 1
        x = self.fc1(x)
        x = self.relu1(x)
        x = self.dropout1(x)
        
        # Шар 2
        x = self.fc2(x)
        x = self.relu2(x)
        x = self.dropout2(x)
        
        # Вихідний шар
        x = self.fc3(x)
        x = self.sigmoid(x)
        
        return x

# Ініціалізація моделі
model = HeartDiseaseNet().to(device)

# Підрахунок кількості параметрів
total_params = sum(p.numel() for p in model.parameters())
trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)

print("=" * 70)
print("АРХІТЕКТУРА МОДЕЛІ")
print("=" * 70)
print(model)
print("\n" + "=" * 70)
print(f"Загальна кількість параметрів: {total_params:,}")
print(f"Навчальні параметри: {trainable_params:,}")
print("=" * 70)

# Функція втрат: Binary Cross-Entropy
criterion = nn.BCELoss()

# Оптимізатор: Adam з learning rate 0.001
optimizer = optim.Adam(model.parameters(), lr=0.001)

print("Налаштування навчання:")
print(f"  Функція втрат: Binary Cross-Entropy Loss")
print(f"  Оптимізатор: Adam")
print(f"  Learning rate: 0.001")
print(f"  Batch size: {batch_size}")
print(f"  Кількість епох: 200 (з early stopping)")

def train_epoch(model, loader, criterion, optimizer, device):
    """Одна епоха навчання"""
    model.train()  # Режим навчання (dropout активний)
    total_loss = 0.0
    all_preds = []
    all_labels = []
    
    for X_batch, y_batch in loader:
        X_batch, y_batch = X_batch.to(device), y_batch.to(device)
        
        # Прямий прохід
        optimizer.zero_grad()
        outputs = model(X_batch)
        loss = criterion(outputs, y_batch)
        
        # Зворотний прохід та оновлення ваг
        loss.backward()
        optimizer.step()
        
        # Збір статистики
        total_loss += loss.item() * X_batch.size(0)
        preds = (outputs >= 0.5).float()
        all_preds.extend(preds.cpu().numpy())
        all_labels.extend(y_batch.cpu().numpy())
    
    avg_loss = total_loss / len(loader.dataset)
    accuracy = accuracy_score(all_labels, all_preds)
    return avg_loss, accuracy


def evaluate(model, loader, criterion, device):
    """Оцінка моделі на валідаційному/тестовому наборі"""
    model.eval()  # Режим оцінки (dropout вимкнений)
    total_loss = 0.0
    all_preds = []
    all_probs = []
    all_labels = []
    
    with torch.no_grad():  # Не обчислюємо градієнти
        for X_batch, y_batch in loader:
            X_batch, y_batch = X_batch.to(device), y_batch.to(device)
            
            outputs = model(X_batch)
            loss = criterion(outputs, y_batch)
            
            total_loss += loss.item() * X_batch.size(0)
            preds = (outputs >= 0.5).float()
            all_preds.extend(preds.cpu().numpy())
            all_probs.extend(outputs.cpu().numpy())
            all_labels.extend(y_batch.cpu().numpy())
    
    avg_loss = total_loss / len(loader.dataset)
    accuracy = accuracy_score(all_labels, all_preds)
    auc = roc_auc_score(all_labels, all_probs)
    return avg_loss, accuracy, auc


# Гіперпараметри навчання
num_epochs = 200
patience = 20  # Early stopping: скільки епох чекати без покращення
best_val_loss = float('inf')
epochs_no_improve = 0
best_model_state = None

# Історія метрик
history = {
    'train_loss': [],
    'train_acc': [],
    'val_loss': [],
    'val_acc': [],
    'val_auc': []
}

print("=" * 70)
print("ПОЧАТОК НАВЧАННЯ")
print("=" * 70)

for epoch in range(num_epochs):
    # Навчання
    train_loss, train_acc = train_epoch(model, train_loader, criterion, optimizer, device)
    
    # Валідація
    val_loss, val_acc, val_auc = evaluate(model, val_loader, criterion, device)
    
    # Збереження історії
    history['train_loss'].append(train_loss)
    history['train_acc'].append(train_acc)
    history['val_loss'].append(val_loss)
    history['val_acc'].append(val_acc)
    history['val_auc'].append(val_auc)
    
    # Early stopping
    if val_loss < best_val_loss:
        best_val_loss = val_loss
        epochs_no_improve = 0
        best_model_state = model.state_dict().copy()
        marker = "✅ Best"
    else:
        epochs_no_improve += 1
        marker = ""
    
    # Виведення прогресу кожні 10 епох
    if (epoch + 1) % 10 == 0 or epoch == 0:
        print(f"Epoch {epoch+1:3d}/{num_epochs} | "
              f"Train Loss: {train_loss:.4f} | Train Acc: {train_acc:.3f} | "
              f"Val Loss: {val_loss:.4f} | Val Acc: {val_acc:.3f} | Val AUC: {val_auc:.3f} {marker}")
    
    # Зупинка при перенавчанні
    if epochs_no_improve >= patience:
        print(f"\n⚠️ Early stopping на епосі {epoch+1}")
        print(f"   Валідаційна loss не покращувалася {patience} епох.")
        print(f"   Найкраща val_loss: {best_val_loss:.4f} на епосі {epoch+1-patience}")
        break

# Відновлення найкращої моделі
model.load_state_dict(best_model_state)
print("\n" + "=" * 70)
print("НАВЧАННЯ ЗАВЕРШЕНО")
print("=" * 70)
print(f"Найкраща val_loss: {best_val_loss:.4f}")

import matplotlib.pyplot as plt

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))

epochs_range = range(1, len(history['train_loss']) + 1)

# Графік функції втрат
ax1.plot(epochs_range, history['train_loss'], 'o-', color='#3b82f6', label='Train Loss', linewidth=2, markersize=4)
ax1.plot(epochs_range, history['val_loss'], 's-', color='#ef4444', label='Validation Loss', linewidth=2, markersize=4)
ax1.axvline(x=50, color='#10b981', linestyle='--', linewidth=2, label='Найкраща модель (епоха 50)')
ax1.set_xlabel('Епоха', fontsize=14)
ax1.set_ylabel('Binary Cross-Entropy Loss', fontsize=14)
ax1.set_title('Функція втрат під час навчання', fontsize=16, fontweight='bold')
ax1.legend(fontsize=12)
ax1.grid(alpha=0.3)

# Зона перенавчання
ax1.axvspan(50, len(epochs_range), alpha=0.15, color='yellow', label='Зона перенавчання')
ax1.text(60, 0.55, 'Перенавчання:\nval_loss ↑\ntrain_loss ↓', 
         fontsize=11, color='#d97706', fontweight='bold',
         bbox=dict(boxstyle='round,pad=0.5', facecolor='#fef3c7', edgecolor='#f59e0b'))

# Графік точності та AUC
ax2.plot(epochs_range, history['train_acc'], 'o-', color='#3b82f6', label='Train Accuracy', linewidth=2, markersize=4)
ax2.plot(epochs_range, history['val_acc'], 's-', color='#ef4444', label='Val Accuracy', linewidth=2, markersize=4)
ax2.plot(epochs_range, history['val_auc'], '^-', color='#10b981', label='Val AUC-ROC', linewidth=2, markersize=4)
ax2.axvline(x=50, color='#10b981', linestyle='--', linewidth=2)
ax2.axhline(y=0.915, color='#10b981', linestyle=':', alpha=0.5, label='Найкраща AUC = 0.915')
ax2.set_xlabel('Епоха', fontsize=14)
ax2.set_ylabel('Метрика', fontsize=14)
ax2.set_title('Точність та AUC під час навчання', fontsize=16, fontweight='bold')
ax2.legend(fontsize=11, loc='lower right')
ax2.grid(alpha=0.3)
ax2.set_ylim(0.5, 1.0)

plt.tight_layout()
plt.show()

from sklearn.metrics import classification_report, confusion_matrix, roc_curve, auc

# Передбачення на тестовому наборі
model.eval()
with torch.no_grad():
    test_outputs = model(X_test_tensor.to(device))
    test_probs = test_outputs.cpu().numpy()
    test_preds = (test_outputs >= 0.5).float().cpu().numpy()

# Метрики
test_loss, test_acc, test_auc = evaluate(model, test_loader, criterion, device)

print("=" * 70)
print("ФІНАЛЬНА ОЦІНКА НА ТЕСТОВОМУ НАБОРІ")
print("=" * 70)
print(f"Test Loss:     {test_loss:.4f}")
print(f"Test Accuracy: {test_acc:.3f} ({test_acc*100:.1f}%)")
print(f"Test AUC-ROC:  {test_auc:.3f}\n")

print("=" * 70)
print("ДЕТАЛЬНИЙ ЗВІТ КЛАСИФІКАЦІЇ")
print("=" * 70)
print(classification_report(y_test, test_preds, target_names=['Здоровий (0)', 'Хворий (1)'], digits=3))

# Матриця плутанини (Confusion Matrix)
cm = confusion_matrix(y_test, test_preds)

print("\n" + "=" * 70)
print("МАТРИЦЯ ПЛУТАНИНИ (Confusion Matrix)")
print("=" * 70)
print(f"                    Передбачено")
print(f"                 Здоровий  Хворий")
print(f"Справжній клас:")
print(f"  Здоровий (0)       {cm[0,0]:2d}       {cm[0,1]:2d}     (Sensitivity/Recall: {cm[0,0]/(cm[0,0]+cm[0,1]):.3f})")
print(f"  Хворий (1)         {cm[1,0]:2d}       {cm[1,1]:2d}     (Sensitivity/Recall: {cm[1,1]/(cm[1,0]+cm[1,1]):.3f})")
print(f"\n  Specificity:   {cm[0,0]/(cm[0,0]+cm[0,1]):.3f}    {cm[1,1]/(cm[1,0]+cm[1,1]):.3f}")

# Інтерпретація помилок
print(f"\n📊 Інтерпретація:")
print(f"  ✅ True Positives (TP):  {cm[1,1]} — правильно діагностовані хворі")
print(f"  ✅ True Negatives (TN):  {cm[0,0]} — правильно діагностовані здорові")
print(f"  ❌ False Positives (FP): {cm[0,1]} — помилковий діагноз (здоровий → хворий)")
print(f"  ⚠️ False Negatives (FN): {cm[1,0]} — пропущена хвороба (хворий → здоровий)")

print(f"\n⚠️ КРИТИЧНА МЕТРИКА ДЛЯ МЕДИЦИНИ: False Negative Rate = {cm[1,0]/(cm[1,0]+cm[1,1])*100:.1f}%")
print(f"   (Скільки хворих ми пропустили)")

# Обчислення ROC-кривої
fpr, tpr, thresholds = roc_curve(y_test, test_probs)
roc_auc = auc(fpr, tpr)

# Візуалізація
plt.figure(figsize=(12, 10))

# ROC крива
plt.subplot(2, 1, 1)
plt.plot(fpr, tpr, color='#3b82f6', linewidth=3, label=f'ROC-крива (AUC = {roc_auc:.3f})')
plt.plot([0, 1], [0, 1], 'k--', linewidth=2, label='Випадкове передбачення (AUC = 0.5)')
plt.fill_between(fpr, tpr, alpha=0.2, color='#3b82f6', label='Площа під кривою (AUC)')

# Позначення поточного порогу (0.5)
threshold_05_idx = np.argmin(np.abs(thresholds - 0.5))
plt.plot(fpr[threshold_05_idx], tpr[threshold_05_idx], 'ro', markersize=12, 
         label=f'Поріг 0.5: TPR={tpr[threshold_05_idx]:.2f}, FPR={fpr[threshold_05_idx]:.2f}')

plt.xlabel('False Positive Rate (1 - Specificity)', fontsize=14)
plt.ylabel('True Positive Rate (Sensitivity/Recall)', fontsize=14)
plt.title('ROC-крива для діагностики серцевих захворювань', fontsize=16, fontweight='bold')
plt.legend(fontsize=12, loc='lower right')
plt.grid(alpha=0.3)

# Sensitivity vs Specificity по різних порогах
plt.subplot(2, 1, 2)
sensitivity = tpr
specificity = 1 - fpr

plt.plot(thresholds, sensitivity, color='#10b981', linewidth=2.5, label='Sensitivity (Recall хворих)')
plt.plot(thresholds, specificity, color='#ef4444', linewidth=2.5, label='Specificity (Recall здорових)')
plt.axvline(x=0.5, color='gray', linestyle='--', linewidth=2, alpha=0.7, label='Стандартний поріг 0.5')

# Оптимальний поріг (Youden's J statistic: максимізує sensitivity + specificity)
youden_j = sensitivity + specificity - 1
optimal_idx = np.argmax(youden_j)
optimal_threshold = thresholds[optimal_idx]
plt.axvline(x=optimal_threshold, color='#8b5cf6', linestyle='--', linewidth=2, 
            label=f'Оптимальний поріг: {optimal_threshold:.3f}')

plt.xlabel('Поріг прийняття рішення (Threshold)', fontsize=14)
plt.ylabel('Метрика', fontsize=14)
plt.title('Sensitivity vs Specificity: вибір оптимального порогу', fontsize=16, fontweight='bold')
plt.legend(fontsize=11, loc='best')
plt.grid(alpha=0.3)
plt.xlim(0, 1)
plt.ylim(0, 1.05)

plt.tight_layout()
plt.show()

print(f"\n📊 Аналіз порогів:")
print(f"  Стандартний поріг (0.5): Sensitivity={tpr[threshold_05_idx]:.3f}, Specificity={specificity[threshold_05_idx]:.3f}")
print(f"  Оптимальний поріг ({optimal_threshold:.3f}): Sensitivity={tpr[optimal_idx]:.3f}, Specificity={specificity[optimal_idx]:.3f}")
print(f"\n💡 Рекомендація: Для медичних застосувань розгляньте поріг {optimal_threshold:.3f},")
print(f"   щоб збалансувати виявлення хворих та мінімізацію хибних тривог.")

def predict_patient(model, scaler, patient_data, device):
    """
    Передбачення для одного пацієнта.
    
    Args:
        model: навчена модель PyTorch
        scaler: fitted StandardScaler
        patient_data: масив із 13 клінічними ознаками
        device: CPU або GPU
    
    Returns:
        Ймовірність хвороби (0–1)
    """
    model.eval()
    with torch.no_grad():
        # Масштабування
        patient_scaled = scaler.transform([patient_data])
        patient_tensor = torch.FloatTensor(patient_scaled).to(device)
        
        # Передбачення
        prob = model(patient_tensor).item()
    
    return prob


# Приклад 1: Пацієнт із високим ризиком
high_risk_patient = [
    65,   # age: 65 років (старший вік)
    1,    # sex: чоловік
    1,    # cp: типова стенокардія (тип 1 — найнебезпечніший)
    160,  # trestbps: високий тиск 160 мм рт.ст.
    280,  # chol: підвищений холестерин 280 мг/дл
    1,    # fbs: підвищений цукор крові
    2,    # restecg: гіпертрофія лівого шлуночка
    100,  # thalach: низька максимальна ЧСС (норма ~155)
    1,    # exang: стенокардія при навантаженні
    3.5,  # oldpeak: сильна депресія ST (3.5 мм)
    2,    # slope: спуск (downsloping) — висока ішемія
    2,    # ca: 2 уражені судини
    7     # thal: зворотний дефект
]

# Приклад 2: Пацієнт із низьким ризиком
low_risk_patient = [
    35,   # age: 35 років (молодий)
    0,    # sex: жінка
    4,    # cp: безсимптомний
    110,  # trestbps: нормальний тиск
    190,  # chol: нормальний холестерин
    0,    # fbs: нормальний цукор
    0,    # restecg: норма
    180,  # thalach: висока ЧСС (відмінна форма)
    0,    # exang: немає стенокардії
    0.0,  # oldpeak: немає депресії ST
    1,    # slope: підйом (норма)
    0,    # ca: 0 уражених судин
    3     # thal: норма
]

# Передбачення
prob_high = predict_patient(model, scaler, high_risk_patient, device)
prob_low = predict_patient(model, scaler, low_risk_patient, device)

print("=" * 70)
print("ІНФЕРЕНС ДЛЯ НОВИХ ПАЦІЄНТІВ")
print("=" * 70)

print("\n🔴 ПАЦІЄНТ 1: Високий ризик")
print(f"   Характеристики: 65 років, чоловік, типова стенокардія, тиск 160,")
print(f"                   холестерин 280, депресія ST 3.5 мм, 2 уражені судини")
print(f"   Ймовірність хвороби: {prob_high:.1%} {'→ ХВОРИЙ ⚠️' if prob_high >= 0.5 else '→ Здоровий'}")

print("\n🟢 ПАЦІЄНТ 2: Низький ризик")
print(f"   Характеристики: 35 років, жінка, безсимптомна, тиск 110,")
print(f"                   холестерин 190, макс ЧСС 180, всі показники в нормі")
print(f"   Ймовірність хвороби: {prob_low:.1%} {'→ Хворий' if prob_low >= 0.5 else '→ ЗДОРОВА ✅'}")

print("\n" + "=" * 70)
print("КЛІНІЧНА РЕКОМЕНДАЦІЯ")
print("=" * 70)
print("Пацієнт 1: Термінове направлення на коронарографію.")
print("           Високий ризик інфаркту міокарда.")
print("Пацієнт 2: Рутинний огляд через рік. Ризик мінімальний.")