Petr4 DNN a CNN CM train lepsi

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import confusion_matrix, classification_report
from sklearn.utils.class_weight import compute_class_weight
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Input, BatchNormalization, Conv1D, GlobalAveragePooling1D
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
from tensorflow.keras.regularizers import l2
from scipy.ndimage import gaussian_filter1d

# Nastavitelný práh
THRESHOLD = 0.5

THRESHOLD = 0.5

train_data = np.array([
    [1141, 1050, 1], [1499, 1050, 0], [1451, 1077, 1], [1519, 1077, 1], [1191, 1093, 0],
    [1590, 1093, 1], [1777, 1093, 0], [1141, 1124, 1], [1499, 1124, 0], [1601, 1124, 0],
    [1606, 1141, 0], [1608, 1141, 0], [1870, 1141, 0], [1794, 1191, 0], [1329, 1211, 1],
    [1687, 1211, 0], [1918, 1211, 0], [1608, 1212, 0], [1050, 1228, 0], [2107, 1228, 0],
    [2202, 1266, 0], [1551, 1327, 0], [1608, 1327, 1], [1660, 1327, 0], [1329, 1332, 1],
    [1093, 1346, 0], [1546, 1419, 1], [1327, 1435, 0], [1774, 1435, 0], [1794, 1451, 0],
    [1077, 1458, 1], [1093, 1458, 1], [1731, 1458, 0], [1777, 1491, 0], [1212, 1499, 1],
    [1211, 1519, 1], [1608, 1519, 1], [1918, 1519, 0], [1458, 1538, 1], [1918, 1538, 0],
    [1794, 1545, 0], [1903, 1545, 0], [1435, 1546, 1], [1758, 1546, 0], [2076, 1546, 0],
    [1077, 1551, 1], [1690, 1551, 0], [1050, 1590, 1], [1093, 1601, 1], [1327, 1601, 0],
    [1050, 1606, 1], [1491, 1606, 1], [1519, 1608, 0], [1266, 1660, 1], [1839, 1660, 0],
    [1332, 1687, 0], [1519, 1687, 0], [1538, 1690, 1], [1870, 1690, 0], [1903, 1731, 1],
    [1918, 1731, 0], [1419, 1758, 0], [1839, 1758, 0], [1077, 1774, 1], [1519, 1774, 1],
    [2202, 1774, 0], [1538, 1777, 0], [1903, 1777, 1], [2107, 1777, 0], [1660, 1794, 0],
    [2107, 1794, 0], [1124, 1839, 1], [1519, 1839, 1], [1546, 1839, 1], [1870, 1839, 1],
    [2202, 1839, 0], [1419, 1870, 1], [2107, 1870, 0], [2202, 1870, 0], [1191, 1903, 1],
    [1601, 1903, 1], [1606, 1903, 1], [1660, 1903, 1], [1491, 1918, 1], [1212, 2076, 1],
    [1690, 2076, 1], [1546, 2107, 1], [1903, 2107, 1], [2183, 2107, 0], [1229, 2183, 1],
    [1731, 2183, 1], [1758, 2183, 0], [1918, 2183, 1], [2076, 2183, 0], [1538, 2202, 1],
    [1601, 2202, 1], [2076, 2202, 0], [1660, 2258, 1], [1777, 2258, 0], [2202, 2258, 0]
])

# Testovací data (2D)
test_data = np.array([
    [1451, 1050, 0], [1758, 1050, 0], [1346, 1211, 1], [1546, 1332, 1], [1608, 1451, 1],
    [1839, 1458, 0], [1435, 1538, 1], [1077, 1546, 1], [2183, 1551, 0], [1458, 1590, 0],
    [1538, 1606, 0], [1077, 1608, 1], [2258, 1608, 0], [1419, 1690, 1], [1545, 1731, 1],
    [1774, 1758, 0], [1545, 1774, 1], [2183, 1777, 0], [1228, 1794, 1], [1774, 1794, 0],
    [2258, 1870, 1], [1546, 1903, 1], [1774, 1918, 0], [2076, 1918, 0], [1758, 2076, 1],
    [1839, 2076, 0], [2107, 2076, 1], [2258, 2107, 1], [1731, 2202, 1], [1327, 2258, 1]
])

# Funkce pro vytvoření nových features
def create_features(X):
    elo_diff = X[:, 0] - X[:, 1]
    return np.column_stack((X, elo_diff))

# Normalizace dat pomocí Z-score
scaler = StandardScaler()

# Funkce pro vytvoření DNN modelu
def create_dnn_model(input_shape):
    model = Sequential([
        Input(shape=input_shape),
        Dense(64, activation='relu', kernel_regularizer=l2(0.01)),
        BatchNormalization(),
        Dropout(0.3),
        Dense(32, activation='relu', kernel_regularizer=l2(0.01)),
        BatchNormalization(),
        Dropout(0.3),
        Dense(16, activation='relu', kernel_regularizer=l2(0.01)),
        BatchNormalization(),
        Dropout(0.3),
        Dense(1, activation='sigmoid')
    ])
    model.compile(optimizer=Adam(learning_rate=0.001), loss='binary_crossentropy', metrics=['accuracy'])
    return model

# Funkce pro vytvoření CNN modelu
def create_cnn_model(input_shape):
    model = Sequential([
        Input(shape=input_shape),
        Conv1D(64, 2, activation='relu', padding='same', kernel_regularizer=l2(0.01)),
        BatchNormalization(),
        Conv1D(128, 2, activation='relu', padding='same', kernel_regularizer=l2(0.01)),
        BatchNormalization(),
        GlobalAveragePooling1D(),
        Dense(64, activation='relu', kernel_regularizer=l2(0.01)),
        BatchNormalization(),
        Dropout(0.3),
        Dense(32, activation='relu', kernel_regularizer=l2(0.01)),
        BatchNormalization(),
        Dropout(0.3),
        Dense(1, activation='sigmoid')
    ])
    model.compile(optimizer=Adam(learning_rate=0.001), loss='binary_crossentropy', metrics=['accuracy'])
    return model

# Funkce pro vykreslení grafů s barevnými čtverečky a křivkou trendu
def plot_colored_squares_with_trend(X, y_true, y_pred, y_prob, title):
    plt.figure(figsize=(10, 8))

    # True Positive: zelená
    tp = ((y_true == 1) & (y_pred == 1))
    plt.scatter(X[tp, 2], y_prob[tp], c='green', marker='s', s=50, label='True Positive', alpha=0.7)

    # True Negative: červená
    tn = ((y_true == 0) & (y_pred == 0))
    plt.scatter(X[tn, 2], y_prob[tn], c='red', marker='s', s=50, label='True Negative', alpha=0.7)

    # False Positive: modrá
    fp = ((y_true == 0) & (y_pred == 1))
    plt.scatter(X[fp, 2], y_prob[fp], c='blue', marker='s', s=50, label='False Positive', alpha=0.7)

    # False Negative: zlatá
    fn = ((y_true == 1) & (y_pred == 0))
    plt.scatter(X[fn, 2], y_prob[fn], c='gold', marker='s', s=50, label='False Negative', alpha=0.7)

    # Vytvoření křivky trendu
    X_diff = X[:, 2]
    num_bins = 50
    bin_means, bin_edges, _ = binned_statistic(X_diff, y_prob, statistic='mean', bins=num_bins)
    bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2

    # Odstranění NaN hodnot
    valid_indices = ~np.isnan(bin_means)
    bin_centers = bin_centers[valid_indices]
    bin_means = bin_means[valid_indices]

    # Seřazení bodů podle X pro správné vykreslení křivky
    sort_indices = np.argsort(bin_centers)
    bin_centers = bin_centers[sort_indices]
    bin_means = bin_means[sort_indices]

    # Aplikace Gaussova filtru pro vyhlazení
    smoothed_means = gaussian_filter1d(bin_means, sigma=1)

    # Vykreslení křivky trendu
    plt.plot(bin_centers, smoothed_means, color='black', label='Trend', linewidth=2)

    plt.axhline(y=THRESHOLD, color='r', linestyle='--', label='Práh')

    plt.title(title)
    plt.xlabel('Rozdíl ELO')
    plt.ylabel('Pravděpodobnost výhry')
    plt.legend()
    plt.grid(True)
    plt.show()

# Funkce pro vykreslení průběhu trénování
def plot_training_history(dnn_history, cnn_history):
    plt.figure(figsize=(15, 5))

    plt.subplot(1, 2, 1)
    plt.plot(dnn_history.history['accuracy'], label='DNN Trénovací')
    plt.plot(dnn_history.history['val_accuracy'], label='DNN Validační')
    plt.plot(cnn_history.history['accuracy'], label='CNN Trénovací')
    plt.plot(cnn_history.history['val_accuracy'], label='CNN Validační')
    plt.title('Průběh trénování (Přesnost)')
    plt.xlabel('Epocha')
    plt.ylabel('Přesnost')
    plt.legend()

    plt.subplot(1, 2, 2)
    plt.plot(dnn_history.history['loss'], label='DNN Trénovací')
    plt.plot(dnn_history.history['val_loss'], label='DNN Validační')
    plt.plot(cnn_history.history['loss'], label='CNN Trénovací')
    plt.plot(cnn_history.history['val_loss'], label='CNN Validační')
    plt.title('Průběh trénování (Loss)')
    plt.xlabel('Epocha')
    plt.ylabel('Loss')
    plt.legend()

    plt.tight_layout()
    plt.show()

# Hlavní funkce pro trénování a vyhodnocení modelů
def train_and_evaluate_models(X_train, y_train, X_test, y_test):
    # Příprava dat
    X_train = create_features(X_train)
    X_test = create_features(X_test)

    X_train_scaled = scaler.fit_transform(X_train)
    X_test_scaled = scaler.transform(X_test)

    # Příprava dat pro CNN
    X_train_cnn = X_train_scaled.reshape((X_train_scaled.shape[0], X_train_scaled.shape[1], 1))
    X_test_cnn = X_test_scaled.reshape((X_test_scaled.shape[0], X_test_scaled.shape[1], 1))

    # Výpočet váhy tříd
    class_weights = compute_class_weight(class_weight='balanced', classes=np.unique(y_train), y=y_train)
    class_weight_dict = dict(enumerate(class_weights))

    # Vytvoření a trénování modelů
    dnn_model = create_dnn_model((X_train_scaled.shape[1],))
    cnn_model = create_cnn_model((X_train_cnn.shape[1], 1))

    early_stopping = EarlyStopping(monitor='val_loss', patience=20, restore_best_weights=True)
    reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=10, min_lr=0.00001)

    dnn_history = dnn_model.fit(
        X_train_scaled, y_train,
        epochs=200,
        batch_size=32,
        validation_split=0.2,
        class_weight=class_weight_dict,
        callbacks=[early_stopping, reduce_lr],
        verbose=0
    )

    cnn_history = cnn_model.fit(
        X_train_cnn, y_train,
        epochs=200,
        batch_size=32,
        validation_split=0.2,
        class_weight=class_weight_dict,
        callbacks=[early_stopping, reduce_lr],
        verbose=0
    )

    # Predikce a vyhodnocení modelů
    dnn_train_probs = dnn_model.predict(X_train_scaled).flatten()
    dnn_test_probs = dnn_model.predict(X_test_scaled).flatten()
    cnn_train_probs = cnn_model.predict(X_train_cnn).flatten()
    cnn_test_probs = cnn_model.predict(X_test_cnn).flatten()

    dnn_train_pred = (dnn_train_probs >= THRESHOLD).astype("int32")
    dnn_test_pred = (dnn_test_probs >= THRESHOLD).astype("int32")
    cnn_train_pred = (cnn_train_probs >= THRESHOLD).astype("int32")
    cnn_test_pred = (cnn_test_probs >= THRESHOLD).astype("int32")

    print(f"Použitý práh: {THRESHOLD}")

    # Vykreslení 6 požadovaných grafů
    print("Vykreslování 6 požadovaných grafů:")

    print("1. DNN - Trénovací data")
    plot_colored_squares_with_trend(X_train, y_train, dnn_train_pred, dnn_train_probs, 'DNN - Trénovací data')

    print("2. DNN - Testovací data")
    plot_colored_squares_with_trend(X_test, y_test, dnn_test_pred, dnn_test_probs, 'DNN - Testovací data')

    print("3. CNN - Trénovací data")
    plot_colored_squares_with_trend(X_train, y_train, cnn_train_pred, cnn_train_probs, 'CNN - Trénovací data')

    print("4. CNN - Testovací data")
    plot_colored_squares_with_trend(X_test, y_test, cnn_test_pred, cnn_test_probs, 'CNN - Testovací data')

    print("5-6. Průběh accuracy a loss pro oba modely")
    plot_training_history(dnn_history, cnn_history)

    # Výpis shrnutí výsledků
    print("\nShrnutí výsledků:")
    print("DNN model:")
    print(f"Trénovací přesnost: {dnn_history.history['accuracy'][-1]:.4f}")
    print(f"Validační přesnost: {dnn_history.history['val_accuracy'][-1]:.4f}")
    print(f"Testovací přesnost: {np.mean(dnn_test_pred == y_test):.4f}")
    print("\nCNN model:")
    print(f"Trénovací přesnost: {cnn_history.history['accuracy'][-1]:.4f}")
    print(f"Validační přesnost: {cnn_history.history['val_accuracy'][-1]:.4f}")
    print(f"Testovací přesnost: {np.mean(cnn_test_pred == y_test):.4f}")

    # Výpis confusion matrix a klasifikační zprávy pro oba modely
    print("\nDNN Confusion Matrix - Testovací data:")
    print(confusion_matrix(y_test, dnn_test_pred))
    print("\nDNN Classification Report - Testovací data:")
    print(classification_report(y_test, dnn_test_pred))

    print("\nCNN Confusion Matrix - Testovací data:")
    print(confusion_matrix(y_test, cnn_test_pred))
    print("\nCNN Classification Report - Testovací data:")
    print(classification_report(y_test, cnn_test_pred))

# Zde by následovalo volání funkce train_and_evaluate_models s vašimi trénovacími a testovacími daty
# train_and_evaluate_models(X_train, y_train, X_test, y_test)


np.random.seed(42)
X_train = np.random.randint(1000, 2500, size=(1000, 2))
y_train = (X_train[:, 0] > X_train[:, 1]).astype(int)
X_test = np.random.randint(1000, 2500, size=(200, 2))
y_test = (X_test[:, 0] > X_test[:, 1]).astype(int)

# Volání hlavní funkce s ukázkovými daty
train_and_evaluate_models(X_train, y_train, X_test, y_test)

print("\nZávěr:")
print("Tento skript demonstruje kompletní proces trénování a vyhodnocení modelů pro predikci šachových výsledků.")
print("Pro spuštění analýzy je třeba poskytnout vlastní trénovací a testovací data.")
print("Skript vykreslí 6 grafů: 4 grafy s barevnými čtverečky pro DNN a CNN na trénovacích a testovacích datech,")
print("plus 2 grafy zobrazující průběh accuracy a loss během trénování.")
print("Všechny čtyři kategorie predikcí (TP, TN, FP, FN) jsou nyní zobrazeny v grafech.")
print("Křivka trendu je monotónní klesající a hladká, a správně zachází s duplicitními hodnotami rozdílu ELO.")
print("Dále poskytne shrnutí výsledků, confusion matrix a klasifikační zprávu pro oba modely.")