petr6 OK

import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Input, BatchNormalization
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.regularizers import l2
from scipy.optimize import curve_fit
from sklearn.utils.class_weight import compute_class_weight
from sklearn.preprocessing import StandardScaler

# Definice dat
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]
])

X_train = data[:, :2]
y_train = data[:, 2]

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

y_test = np.array([0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0,
                   1, 1, 0, 0, 1, 0, 1, 1, 1, 1])

# Standardizace vstupních dat
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Výpočet vah tříd pro vyrovnání nevyváženosti dat
class_weights = compute_class_weight('balanced', classes=np.unique(y_train), y=y_train)
class_weight_dict = dict(enumerate(class_weights))

# Definice vylepšeného modelu DNN
def build_improved_model():
    model = Sequential([
        Input(shape=(2,)),
        Dense(128, activation='relu', kernel_regularizer=l2(0.01)),
        BatchNormalization(),
        Dropout(0.3),
        Dense(64, activation='relu', kernel_regularizer=l2(0.01)),
        BatchNormalization(),
        Dropout(0.3),
        Dense(32, activation='relu', kernel_regularizer=l2(0.01)),
        BatchNormalization(),
        Dense(1, activation='sigmoid')
    ])
    return model

# Sestavení modelu
model = build_improved_model()
model.compile(optimizer=Adam(learning_rate=0.001), loss='binary_crossentropy', metrics=['accuracy'])

# Trénink modelu s použitím vah tříd a větším počtem epoch
history = model.fit(X_train_scaled, y_train, epochs=500, batch_size=32, validation_split=0.2, verbose=0, class_weight=class_weight_dict)

# Predikce pomocí modelu
y_pred_train = model.predict(X_train_scaled)
y_pred_test = model.predict(X_test_scaled)

# Určení optimálního thresholdu
best_threshold = 0.5  # Můžete optimalizovat pomocí metod jako Optuna

# Vypočtení binárních predikcí podle optimálního thresholdu
y_pred_test_binary = (y_pred_test > best_threshold).astype(int)
y_test_binary = y_test.astype(int)

# Vytvoření confusion matrix
cm = confusion_matrix(y_test_binary, y_pred_test_binary)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Výhra 2. hráče', 'Výhra 1. hráče'])

# Vizualizace confusion matrix
plt.figure(figsize=(10, 8))
disp.plot(cmap='Blues', values_format='d')
plt.title('Confusion Matrix')
plt.show()

# Seřazení trénovacích dat podle prvního indexu
sorted_indices = np.argsort(X_train[:, 0])
X_train_sorted = X_train[sorted_indices]
y_pred_train_sorted = y_pred_train[sorted_indices]

# Definice správné sigmoid funkce
def sigmoid(x, L, x0, k, b):
    return L / (1 + np.exp(-k * (x - x0))) + b

# Fitování sigmoid funkce
p0 = [1, np.median(X_train_sorted[:, 0]), 0.005, 0]  # Počáteční odhad parametrů
popt, _ = curve_fit(sigmoid, X_train_sorted[:, 0], y_pred_train_sorted.flatten(), p0, method='trf', maxfev=10000)

# Definice správně otočené ELO funkce
def elo_probability(rating_diff):
    return 1 - 1 / (1 + 10**(-rating_diff/400))

# Vytvoření grafu
plt.figure(figsize=(12, 8))

# Vykreslení TP, TN, FP, FN
tp = np.logical_and(y_train == 1, y_pred_train.flatten() > best_threshold)
tn = np.logical_and(y_train == 0, y_pred_train.flatten() <= best_threshold)
fp = np.logical_and(y_train == 0, y_pred_train.flatten() > best_threshold)
fn = np.logical_and(y_train == 1, y_pred_train.flatten() <= best_threshold)

plt.scatter(X_train[tp, 0], y_pred_train[tp], c='green', label='Správně pozitivní', alpha=0.5)
plt.scatter(X_train[tn, 0], y_pred_train[tn], c='blue', label='Správně negativní', alpha=0.5)
plt.scatter(X_train[fp, 0], y_pred_train[fp], c='red', label='Falešně pozitivní', alpha=0.5)
plt.scatter(X_train[fn, 0], y_pred_train[fn], c='orange', label='Falešně negativní', alpha=0.5)

# Vykreslení vyhlazené sigmoid funkce
x_sigmoid = np.linspace(900, 2300, 1000)  # Rozšířený rozsah pro lepší zobrazení
y_sigmoid = sigmoid(x_sigmoid, *popt)
plt.plot(x_sigmoid, y_sigmoid, 'k-', label='Sigmoid fit', linewidth=2)

# Vykreslení správně otočené ELO křivky
elo_diff = x_sigmoid - np.mean(X_train[:, 1])  # Rozdíl ELO vzhledem k průměrnému ELO druhého hráče
y_elo = elo_probability(elo_diff)
plt.plot(x_sigmoid, y_elo, 'b--', label='ELO model (otočený)', linewidth=3)

plt.xlabel('ELO prvního hráče')
plt.ylabel('Pravděpodobnost výhry')
plt.title('Pravděpodobnost výhry prvního hráče (trénovací data)')
plt.legend()
plt.grid(True)
plt.ylim(-0.1, 1.1)  # Rozšíření rozsahu osy y pro lepší zobrazení
plt.show()

# Vyhodnocení modelu
test_loss, test_accuracy = model.evaluate(X_test_scaled, y_test)
print(f'Přesnost na testovacích datech: {test_accuracy:.4f}')

# Výpis parametrů sigmoid funkce
print(f'Parametry sigmoid funkce: L={popt[0]:.4f}, x0={popt[1]:.4f}, k={popt[2]:.4f}, b={popt[3]:.4f}')

# Výpis hodnot sigmoid funkce pro x=1000 a x=2200
print(f'Hodnota sigmoid funkce pro x=1000: {sigmoid(1000, *popt):.4f}')
print(f'Hodnota sigmoid funkce pro x=2200: {sigmoid(2200, *popt):.4f}')

# Výpis hodnot správně otočeného ELO modelu pro rozdíl 400 bodů
print(f'Pravděpodobnost výhry podle správně otočeného ELO modelu pro rozdíl 400 bodů: {elo_probability(400):.4f}')