Petr2 DNN a CNN CM train

import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten, Input
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import confusion_matrix
from sklearn.utils.class_weight import compute_class_weight
import matplotlib.pyplot as plt
import seaborn as sns
import scipy.stats as st

# Training data
train_data = np.array([
    [332, 1], [289, 1], [250, 1], [91, 1], [-91, 1], [-206, 1], [-206, 1],
    [-228, 1], [-239, 1], [-256, 1], [-266, 1], [-278, 1], [-279, 1],
    [-289, 1], [-297, 1], [-297, 1], [-311, 1], [-312, 1], [-324, 1],
    [-348, 1], [-396, 1], [-509, 1], [-521, 1], [-526, 1], [-550, 1],
    [-606, 1], [-633, 1], [-728, 1], [550, 0], [385, 0], [341, 0], [289, 0],
    [228, 0], [137, 0], [110, 0], [75, 0], [-33, 0], [-70, 0], [-226, 0],
    [-251, 0], [-263, 0], [-273, 0], [-280, 0], [-390, 0], [-440, 0],
    [792, 0], [757, 0], [718, 0], [591, 0], [585, 0], [578, 0], [524, 0],
    [512, 0], [463, 0], [455, 0], [431, 0], [421, 0], [396, 0], [387, 0],
    [386, 0], [379, 0], [370, 0], [361, 0], [341, 0], [339, 0], [338, 0],
    [328, 0], [323, 0], [307, 0], [303, 0], [288, 0], [284, 0], [282, 0],
    [277, 0], [232, 0], [164, 0], [131, 0], [108, 0], [35, 0], [8, 0],
    [-87, 0], [-228, 0], [-230, 0], [-276, 0], [-347, 0], [-367, 0],
    [-543, 0], [294, 1], [284, 1], [104, 1], [-186, 1], [-238, 1], [-262, 1],
    [-280, 1], [-325, 1], [-326, 1], [-384, 1], [-422, 1], [-498, 1],
    [390, 0], [266, 0], [-297, 0], [-331, 0], [585, 0], [531, 0], [520, 0],
    [465, 0], [251, 0], [133, 0], [55, 0], [-228, 0], [-248, 0], [-306, 0]
])

# Test data
test_data = np.array([
    [559, 1], [359, 1], [191, 1], [-62, 1], [-177, 1], [-199, 1],
    [-261, 1], [-265, 1], [-298, 1], [-300, 1], [-301, 1], [-318, 1],
    [-321, 1], [-368, 1], [-393, 1], [-469, 1], [-513, 1], [-584, 1],
    [-586, 1], [-745, 1], [-960, 1], [376, 0], [329, 0], [756, 0], [562, 0],
    [511, 0], [445, 0], [402, 0], [341, 0], [340, 0], [312, 0], [305, 0],
    [264, 0], [-216, 0], [231, 1], [208, 1], [155, 1], [-200, 1], [-258, 1],
    [-364, 1], [-566, 1], [414, 0], [-240, 0], [599, 0], [521, 0], [428, 0],
    [415, 0], [337, 0]
])

# Rozdělení na vstupy (X) a výstupy (y)
X_train = train_data[:, 0].reshape(-1, 1)
y_train = train_data[:, 1]
X_test = test_data[:, 0].reshape(-1, 1)
y_test = test_data[:, 1]

# Normalizace dat pomocí Z-score
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# 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))

# Definování DNN modelu
dnn_model = Sequential([
    Input(shape=(1,)),  # Vstupní vrstva
    Dense(64, activation='relu'),  # První skrytá vrstva
    Dense(32, activation='relu'),  # Druhá skrytá vrstva
    Dense(16, activation='relu'),  # Třetí skrytá vrstva
    Dense(8, activation='relu'),   # Čtvrtá skrytá vrstva
    Dense(1, activation='sigmoid')  # Výstupní vrstva
])

# Kompilace DNN modelu s použitím class_weight
dnn_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Trénování DNN modelu s použitím class_weight
dnn_model.fit(X_train, y_train, epochs=200, batch_size=10, verbose=0, class_weight=class_weight_dict)

# Predikce pravděpodobností pro testovací sadu pomocí DNN
y_probs_dnn = dnn_model.predict(X_test)

# Změna prahové hodnoty pro rozhodnutí
threshold = 0.5  # Experimentujte s různými hodnotami
y_pred_dnn = (y_probs_dnn > threshold).astype("int32")

# Vyhodnocení modelu pomocí confusion matrix (testovací data)
conf_matrix_dnn = confusion_matrix(y_test, y_pred_dnn)
plt.figure(figsize=(10, 7))
sns.heatmap(conf_matrix_dnn, annot=True, fmt='d', cmap='Blues')
plt.title('Konfuzní Matice s Váhou Tříd a Úpravou Prahové Hodnoty (DNN) - Testovací data')
plt.ylabel('Skutečný Štítek')
plt.xlabel('Predikovaný Štítek')
plt.show()

# Vyhodnocení modelu pomocí confusion matrix (trénovací data)
y_probs_train_dnn = dnn_model.predict(X_train)
y_pred_train_dnn = (y_probs_train_dnn > threshold).astype("int32")
conf_matrix_train_dnn = confusion_matrix(y_train, y_pred_train_dnn)
plt.figure(figsize=(10, 7))
sns.heatmap(conf_matrix_train_dnn, annot=True, fmt='d', cmap='Greens')
plt.title('Konfuzní Matice s Váhou Tříd a Úpravou Prahové Hodnoty (DNN) - Trénovací data')
plt.ylabel('Skutečný Štítek')
plt.xlabel('Predikovaný Štítek')
plt.show()

# Výpočet konfidenčního intervalu pro predikované pravděpodobnosti (DNN)
mean_prob_dnn = np.mean(y_probs_dnn)
ci_lower_dnn, ci_upper_dnn = st.t.interval(0.85, len(y_probs_dnn)-1, loc=mean_prob_dnn, scale=st.sem(y_probs_dnn))

# Oprava chyby s formátováním
ci_lower_dnn, ci_upper_dnn = ci_lower_dnn.item(), ci_upper_dnn.item()

# Vykreslení pravděpodobnosti výhry s konfidenčním intervalem (DNN)
plt.figure(figsize=(8, 6))
plt.hist(y_probs_dnn, bins=20, color='skyblue', edgecolor='black', alpha=0.7)
plt.axvline(x=mean_prob_dnn, color='red', linestyle='--', label=f'Mean Probability: {mean_prob_dnn:.2f}')
plt.axvspan(ci_lower_dnn, ci_upper_dnn, color='orange', alpha=0.3, label=f'85% CI: [{ci_lower_dnn:.2f}, {ci_upper_dnn:.2f}]')
plt.title('Pravděpodobnost Výhry s 85% Konfidenčním Intervalem (DNN)')
plt.xlabel('Predikovaná Pravděpodobnost')
plt.ylabel('Frekvence')
plt.legend()
plt.show()

# Přidání rozměru pro CNN
X_train_cnn = X_train.reshape(-1, 1, 1)
X_test_cnn = X_test.reshape(-1, 1, 1)

# Definování CNN modelu
cnn_model = Sequential([
    Input(shape=(1, 1)),  # Vstupní vrstva
    Flatten(),  # Plochý vstup
    Dense(64, activation='relu'),  # První hustá vrstva
    Dense(32, activation='relu'),  # Druhá hustá vrstva
    Dense(16, activation='relu'),  # Třetí hustá vrstva
    Dense(8, activation='relu'),   # Čtvrtá hustá vrstva
    Dense(1, activation='sigmoid')  # Výstupní vrstva
])

# Kompilace CNN modelu
cnn_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Trénování CNN modelu
cnn_model.fit(X_train_cnn, y_train, epochs=200, verbose=0, class_weight=class_weight_dict)

# Vyhodnocení modelu na testovacích datech
_, accuracy_cnn = cnn_model.evaluate(X_test_cnn, y_test)
print(f'CNN Test Accuracy: {accuracy_cnn:.2f}')

# Predikce pravděpodobností pro testovací sadu pomocí CNN
y_pred_probs_cnn = cnn_model.predict(X_test_cnn).flatten()
y_pred_cnn = (y_pred_probs_cnn > threshold).astype("int32")

# Vyhodnocení modelu pomocí confusion matrix (trénovací data)
y_probs_train_cnn = cnn_model.predict(X_train_cnn).flatten()
y_pred_train_cnn = (y_probs_train_cnn > threshold).astype("int32")
conf_matrix_train_cnn = confusion_matrix(y_train, y_pred_train_cnn)
plt.figure(figsize=(10, 7))
sns.heatmap(conf_matrix_train_cnn, annot=True, fmt='d', cmap='Greens')
plt.title('Konfuzní Matice s Váhou Tříd a Úpravou Prahové Hodnoty (CNN) - Trénovací data')
plt.ylabel('Skutečný Štítek')
plt.xlabel('Predikovaný Štítek')
plt.show()

# Vykreslení grafu Rozdíl ELO vs. Pravděpodobnost Výhry (DNN) s obarvením
plt.figure(figsize=(10, 5))
for i in range(len(y_test)):
    if y_test[i] == 1 and y_pred_dnn[i] == 1:
        plt.scatter(X_test[i], y_probs_dnn[i], color='yellow', s=100, marker='o', label='TP' if i == 0 else "")
    elif y_test[i] == 0 and y_pred_dnn[i] == 0:
        plt.scatter(X_test[i], y_probs_dnn[i], color='green', s=100, marker='o', label='TN' if i == 0 else "")
    elif y_test[i] == 0 and y_pred_dnn[i] == 1:
        plt.scatter(X_test[i], y_probs_dnn[i], color='red', s=100, marker='o', label='FP' if i == 0 else "")
    elif y_test[i] == 1 and y_pred_dnn[i] == 0:
        plt.scatter(X_test[i], y_probs_dnn[i], color='blue', s=100, marker='o', label='FN' if i == 0 else "")

plt.title('Rozdíl ELO vs. Pravděpodobnost Výhry (DNN)')
plt.xlabel('Rozdíl ELO')
plt.ylabel('Predikovaná Pravděpodobnost')
plt.legend(loc='upper left')  # Přidání legendy
plt.grid(True)
plt.show()

# Vykreslení grafu Rozdíl ELO vs. Pravděpodobnost Výhry (CNN) s obarvením
plt.figure(figsize=(10, 5))
for i in range(len(y_test)):
    if y_test[i] == 1 and y_pred_cnn[i] == 1:
        plt.scatter(X_test[i], y_pred_probs_cnn[i], color='yellow', s=100, marker='o', label='TP' if i == 0 else "")
    elif y_test[i] == 0 and y_pred_cnn[i] == 0:
        plt.scatter(X_test[i], y_pred_probs_cnn[i], color='green', s=100, marker='o', label='TN' if i == 0 else "")
    elif y_test[i] == 0 and y_pred_cnn[i] == 1:
        plt.scatter(X_test[i], y_pred_probs_cnn[i], color='red', s=100, marker='o', label='FP' if i == 0 else "")
    elif y_test[i] == 1 and y_pred_cnn[i] == 0:
        plt.scatter(X_test[i], y_pred_probs_cnn[i], color='blue', s=100, marker='o', label='FN' if i == 0 else "")

plt.title('Rozdíl ELO vs. Pravděpodobnost Výhry (CNN)')
plt.xlabel('Rozdíl ELO')
plt.ylabel('Predikovaná Pravděpodobnost')
plt.legend(loc='upper left')  # Přidání legendy
plt.grid(True)
plt.show()