Rouletta (αριθμοί 0 έως 36).

Η ρουλέτα είναι ένα κλασικό παιχνίδι καζίνο που βασίζεται στην τύχη. Ο τροχός της ρουλέτας αποτελείται από 37 τσέπες, (αριθμοί 0 έως 36). Κάθε τσέπη έχει έναν αριθμό και ένα χρώμα: κόκκινο ή μαύρο, εκτός από το 0, που είναι πράσινο. Ο ντίλερ (ή croupier) περιστρέφει τον τροχό και ρίχνει μια μικρή μπάλα στην αντίθετη κατεύθυνση. Η μπάλα κινείται κατά μήκος της εξωτερικής περιφέρειας του τροχού μέχρι να χάσει την ορμή της και να καταλήξει σε μία από τις τσέπες.

Στοιχηματισμός σε έναν Αριθμό (Straight Up Bet):

• Ευρωπαϊκή Ρουλέτα:
  • Πιθανότητα νίκης: $\frac{1}{37} \approx 2.70\%$
  • Πληρωμή: 35:1
  • Υπολογισμός Αναμενόμενης Αξίας: $$EV = \left(\frac{1}{37} \times 35\right) - \left(\frac{36}{37} \times 1\right) = \frac{35 - 36}{37} = -\frac{1}{37} \approx -2.70\%$$
  • 
    

Στοιχηματισμός σε Εξωτερικά Στοιχήματα (π.χ. Κόκκινο/Μαύρο, Μονά/Ζυγά):

• Ευρωπαϊκή Ρουλέτα:

• Πιθανότητα νίκης: 18 νικητήριες τσέπες από τις 37, δηλαδή $\frac{18}{37} \approx 48.65\%$
• Αναμενόμενη Αξία: $$EV = \left(\frac{18}{37} \times 1\right) - \left(\frac{19}{37} \times 1\right) = -\frac{1}{37} \approx -2.70\%$$

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
import numpy as np
import tensorflow as tf
import random
import matplotlib.pyplot as plt

from tensorflow.keras.models import Model
from tensorflow.keras.layers import LSTM, Dense, Dropout, Input
from tensorflow.keras.callbacks import ReduceLROnPlateau

from sklearn.model_selection import train_test_split
from sklearn.metrics import (mean_squared_error, mean_absolute_error,
                             mean_absolute_percentage_error, r2_score,
                             median_absolute_error)
from sklearn.model_selection import TimeSeriesSplit

from colorama import Fore, Style

seed_value = 1
random.seed(seed_value)
np.random.seed(seed_value)
tf.random.set_seed(seed_value)


output_data = np.array([

    [0.01, 0.06, 0.13, 0.09, 0.3, 0.1, 0.09, 0.04, 0.06, 0.4, 

0.7, 0.5, 0.2, 0.63, 0.14, 0.5, 0.16, 0.12, 0.75, 0.76, 0.04, 

0.05, 0.06, 0.09, 0.11, 0.12, 0.15, 0.2, 0.5, 0.8, 0.4, 0.4, 

])

output_data_1 = [row[(row >= 0.01) & (row <= 0.20)] for row in output_data]
time_series_1 = np.hstack(output_data_1)
time_series_1 = np.array(time_series_1)
print(f"time_series_1 = np.array({repr(time_series_1.tolist())})")

n_steps_1 = 3
n_outputs_1 = 1

lstm_units_1 = 50
lstm_units_2 = 100
lstm_units_3 = 50
dropout_rate_1 = 0.1

epochs_1 = 50
batch_size=1

def prepare_data(series, n_steps, n_outputs):
    X, y = [], []
    for i in range(len(series) - n_steps - n_outputs + 1):
        X.append(series[i:i + n_steps])
        y.append(series[i + n_steps:i + n_steps + n_outputs])
    return np.array(X), np.array(y)

X, y = prepare_data(time_series_1, n_steps_1, n_outputs_1)
X = X.reshape((X.shape[0], X.shape[1], 1))

X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.3, 

random_state=seed_value, shuffle=False)

inputs = Input(batch_shape=(batch_size, n_steps_1, 1))

lstm1 = LSTM(lstm_units_1, activation='tanh', recurrent_activation='sigmoid',
             return_sequences=True, stateful=True, unroll=True, unit_forget_bias=True)

(inputs)

lstm2 = LSTM(lstm_units_2, activation='tanh', recurrent_activation='sigmoid',
             return_sequences=True, stateful=True, unroll=True, unit_forget_bias=True)(lstm1)

lstm3 = LSTM(lstm_units_3, activation='tanh', recurrent_activation='sigmoid',
             return_sequences=False, stateful=True, unroll=True, unit_forget_bias=True)(lstm2)

outputs = Dense(n_outputs_1)(lstm3)

model1 = Model(inputs=inputs, outputs=outputs)

model1.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.00001),
               loss='mean_squared_error',
               metrics=[tf.keras.metrics.MeanSquaredError(),
                        tf.keras.metrics.MeanAbsoluteError(),
                        tf.keras.metrics.MeanAbsolutePercentageError()])

reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=15, min_lr=1e-8, 

verbose=1)

class ResetStatesCallback(tf.keras.callbacks.Callback):
    def on_epoch_end(self, epoch, logs=None):
        for layer in self.model.layers:
            if isinstance(layer, LSTM) and layer.stateful:
                layer.reset_states()

reset_states_callback = ResetStatesCallback()

model1.fit(X_train, y_train, epochs=epochs_1, batch_size=batch_size,
           verbose=1, validation_data=(X_val, y_val),
           callbacks=[reduce_lr, reset_states_callback])

for layer in model1.layers:
    if isinstance(layer, LSTM) and layer.stateful:
        layer.reset_states()

def predict_next(model, series, n_steps):
    input_seq = series[-n_steps:].reshape(batch_size, n_steps, 1)
    predictions = model.predict(input_seq, batch_size=batch_size, verbose=0)[0]
    return np.round(predictions, 2)

predictions_1 = predict_next(model1, time_series_1, n_steps_1)

for layer in model1.layers:
    if isinstance(layer, LSTM) and layer.stateful:
        layer.reset_states()

y_pred = model1.predict(X_val, batch_size=batch_size, verbose=0).flatten()
y_true = y_val.flatten()

mse = mean_squared_error(y_true, y_pred)
mae = mean_absolute_error(y_true, y_pred)
mape = mean_absolute_percentage_error(y_true, y_pred)
r2 = r2_score(y_true, y_pred)
medae = median_absolute_error(y_true, y_pred)

print(Fore.RED + "\nΠρόβλεψη για την χρονοσειρά 1:" + Style.RESET_ALL, predictions_1)
print(Fore.GREEN + f"\n🔹 MSE: {mse:.3f}" + Style.RESET_ALL)
print(Fore.GREEN + f"🔹 MAE: {mae:.3f}" + Style.RESET_ALL)
print(Fore.GREEN + f"🔹 MAPE: {mape:.3f}" + Style.RESET_ALL)
print(Fore.GREEN + f"🔹 R² Score: {r2:.3f}" + Style.RESET_ALL)
print(Fore.GREEN + f"🔹 Median Absolute Error: {medae:.3f}" + Style.RESET_ALL)

plt.figure(figsize=(10, 5))
plt.plot(y_true, label="Πραγματικές Τιμές (Actual)", color='blue', marker='o')
plt.plot(y_pred, label="Προβλέψεις (Predictions)", color='red', linestyle='dashed', marker='x')

plt.xlabel("Χρόνος (Time Steps)")
plt.ylabel("Τιμή")
plt.title("Σύγκριση Actual vs Predictions")
plt.legend()
plt.grid()
plt.show()