Πρόβλεψη 20 αριθμών (seq2seq, GRU) για το ΚΙΝΟ. (Prediction of 20 numbers (seq2seq, GRU) for KINO.)

Θα χρησιμοποιήσουμε το μοντέλο GRU, για την πρόβλεψη των 20 αριθμών του ΚΙΝΟ.

We will use the GRU model to predict the 20 numbers for KINO.

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'

import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, mean_absolute_error
from sklearn.metrics import mean_absolute_percentage_error, 

r2_score, median_absolute_error

from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.layers import LSTM, Dropout, Dense, Input, Attention
from tensorflow.keras.layers import AdditiveAttention, Concatenate, Reshape, Dot, 

Activation, Lambda
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
from tensorflow.keras.layers import GRU

from colorama import Fore, Style
from typing import Tuple, List

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

def create_dataset() -> np.ndarray:
    """Δημιουργεί ένα σταθερό σύνολο δεδομένων."""
    return np.array([

        [0.07, 0.08, 0.09, 0.11, 0.14, 0.15, 0.17, 0.23, 0.24, 0.30, 0.32, 0.33, 0.35, 0.51, 0.52,
         0.56, 0.59, 0.64, 0.66, 0.74],
        [0.16, 0.20, 0.21, 0.28, 0.29, 0.33, 0.34, 0.36, 0.37, 0.38, 0.41, 0.44, 0.52, 0.63, 0.66,
         0.71, 0.72, 0.74, 0.77, 0.80],
        [0.02, 0.11, 0.13, 0.22, 0.23, 0.27, 0.29, 0.30, 0.39, 0.42, 0.43, 0.50, 0.55, 0.62, 0.64,
         0.68, 0.69, 0.71, 0.74, 0.75],
        [0.01, 0.03, 0.06, 0.08, 0.12, 0.13, 0.17, 0.19, 0.21, 0.26, 0.30, 0.31, 0.34, 0.41, 0.44,
         0.45, 0.53, 0.58, 0.59, 0.60],
        [0.02, 0.05, 0.09, 0.10, 0.11, 0.13, 0.14, 0.17, 0.21, 0.24, 0.29, 0.30, 0.31, 0.37, 0.51,
         0.55, 0.56, 0.63, 0.66, 0.80],
        [0.10, 0.12, 0.21, 0.23, 0.24, 0.34, 0.37, 0.41, 0.49, 0.50, 0.51, 0.56, 0.59, 0.60, 0.68,
         0.71, 0.73, 0.76, 0.79, 0.80],
        [0.01, 0.07, 0.09, 0.11, 0.13, 0.17, 0.23, 0.26, 0.28, 0.36, 0.38, 0.39, 0.47, 0.50, 0.63,
         0.68, 0.73, 0.74, 0.75, 0.77],
        [0.01, 0.02, 0.08, 0.11, 0.20, 0.24, 0.28, 0.30, 0.32, 0.34, 0.38, 0.43, 0.44, 0.47, 0.51,
         0.58, 0.60, 0.64, 0.72, 0.76],
        [0.03, 0.04, 0.14, 0.19, 0.21, 0.23, 0.27, 0.29, 0.34, 0.35, 0.38, 0.48, 0.51, 0.55, 0.56,
         0.60, 0.61, 0.70, 0.74, 0.76],
        [0.09, 0.10, 0.13, 0.14, 0.15, 0.17, 0.24, 0.26, 0.29, 0.32, 0.35, 0.40, 0.48, 0.55, 0.60,
         0.61, 0.70, 0.76, 0.77, 0.80],

    ])

def create_sequences(data: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
    """Δημιουργεί ακολουθίες από το σύνολο δεδομένων."""
    input_data, output_data = [], []
    for i in range(len(data) - 1):
        input_data.append(data[i])
        output_data.append(data[i + 1])
    return np.array(input_data), np.array(output_data)

def split_data(input_data: np.ndarray, output_data: np.ndarray, split_ratio: float = 0.8) -> 

Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
    """Διαιρεί τα δεδομένα σε σύνολα εκπαίδευσης και επικύρωσης."""
    split_point = int(len(input_data) * split_ratio)
    return input_data[:split_point], input_data[split_point:], output_data[:split_point],

 output_data[split_point:]

def build_gru_model(input_shape: Tuple[int, int], num_units: List[int]) -> Model:
    encoder_inputs = Input(shape=input_shape)
    encoder_gru1 = GRU(num_units[0], activation='tanh', return_sequences=True, return_state=True,

 unroll=True, reset_after=True)
    encoder_outputs1, state_h1 = encoder_gru1(encoder_inputs)
    encoder_dropout1 = Dropout(0.1)(encoder_outputs1)

    encoder_gru2 = GRU(num_units[1], activation='tanh', return_sequences=True, return_state=True,

 unroll=True, reset_after=True)
    encoder_outputs2, state_h2 = encoder_gru2(encoder_dropout1)
    encoder_states = [state_h2]

    decoder_inputs = Input(shape=input_shape)
    decoder_gru1 = GRU(num_units[0], activation='tanh', return_sequences=True, return_state=True,

 unroll=True, reset_after=True)
    decoder_outputs1, _ = decoder_gru1(decoder_inputs, initial_state=[state_h1])
    decoder_dropout1 = Dropout(0.1)(decoder_outputs1)

    score = Dot(axes=[2, 2])([decoder_dropout1, encoder_outputs2])
    attention_weights = Activation('tanh')(score)
    context_vector = Dot(axes=[2, 1])([attention_weights, encoder_outputs2])
    decoder_combined_context = Concatenate(axis=-1)([context_vector, decoder_outputs1])

    decoder_gru2 = GRU(num_units[1], activation='tanh', return_sequences=True, return_state=True,

 unroll=True, reset_after=True)
    decoder_outputs2, _ = decoder_gru2(decoder_combined_context, initial_state=encoder_states)
    decoder_dropout2 = Dropout(0.1)(decoder_outputs2)

    decoder_dense = Dense(input_shape[1], activation='linear', use_bias=True)
    decoder_outputs = decoder_dense(decoder_dropout2)

    return Model([encoder_inputs, decoder_inputs], decoder_outputs)

def train_model(model: Model, train_X: np.ndarray, train_Y: np.ndarray, val_X: np.ndarray,

 val_Y: np.ndarray, batch_size: int = 1, epochs: int = 150) -> tf.keras.callbacks.History:
    """Εκπαιδεύει το μοντέλο."""
    early_stopping = EarlyStopping(monitor='val_loss', patience=150, verbose=2, mode='min',

 restore_best_weights=True)
    reduce_lr = ReduceLROnPlateau(monitor='val_loss', patience=30, verbose=2, mode='min',

 factor=0.001, min_lr=1e-7)
    model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
                  loss=tf.keras.losses.MeanSquaredError(),
                  metrics=[tf.keras.metrics.MeanSquaredError(),
                           tf.keras.metrics.MeanAbsoluteError(),
                           tf.keras.metrics.MeanAbsolutePercentageError()])
    return model.fit([train_X, train_X], train_Y,
                     epochs=epochs,
                     batch_size=batch_size,
                     validation_data=([val_X, val_X], val_Y),
                     callbacks=[early_stopping, reduce_lr])

def make_predictions(model: Model, val_X: np.ndarray) -> np.ndarray:
    """Δημιουργεί προβλέψεις χρησιμοποιώντας το εκπαιδευμένο μοντέλο."""
    return model.predict([val_X, val_X])

def display_results(predicted_next_line: np.ndarray, dataset: np.ndarray) -> None:
    """Εμφανίζει τα αποτελέσματα της πρόβλεψης."""
    predictions = np.round(predicted_next_line * 100).astype(int)
    predicted_values = np.round(predicted_next_line * 100).astype(int)
    actual_values = np.round(dataset[-1] * 100).astype(int)
    predicted_set = set(predicted_values)
    actual_set = set(actual_values)
    common_values = predicted_set.intersection(actual_set)
    common_values_sorted = sorted(common_values)

    print(f"\n{Fore.GREEN}ΟΙ ΠΡΟΒΛΕΠΟΜΕΝΟΙ ΑΡΙΘΜΟΙ: {Style.RESET_ALL}

{', '.join(map(str, predictions))}")
    temperatures = ', '.join(f"{temp * 100:.0f}" for temp in dataset[-1])
    print(f"{Fore.MAGENTA}ΟΙ ΑΡΙΘΜΟΙ ΤΗΣ ΤΕΛΕΥΤΑΙΑΣ ΚΛΗΡΩΣΗΣ: {Style.RESET_ALL}{Fore.RED}

{temperatures}{Style.RESET_ALL}")
    print(f"\n{Fore.CYAN}ΚΟΙΝΕΣ ΤΙΜΕΣ ΜΕΤΑΞΥ ΠΡΟΒΛΕΨΗΣ ΚΑΙ ΤΕΛΕΥΤΑΙΑΣ ΚΛΗΡΩΣΗΣ: 

{Style.RESET_ALL}{common_values_sorted}")

def main() -> None:
    dataset = create_dataset()  # Δημιουργία συνόλου δεδομένων
    input_data, output_data = create_sequences(dataset) # Δημιουργία ακολουθιών δεδομένων
    input_data = input_data.reshape(input_data.shape[0], 1, input_data.shape[1])
    output_data = output_data.reshape(output_data.shape[0], 1, output_data.shape[1])

    train_X, val_X, train_Y, val_Y = split_data(input_data, output_data) 

    num_units = [40, 40]
    model = build_gru_model((1, dataset.shape[1]), num_units)
    history = train_model(model, train_X, train_Y, val_X, val_Y) # Εκπαίδευση μοντέλου

    next_line_input = dataset[-1].reshape(1, 1, dataset.shape[1])
    predicted_next_line = make_predictions(model, next_line_input).reshape(-1)

    display_results(predicted_next_line, dataset) # Εμφάνιση αποτελεσμάτων
    tf.keras.backend.clear_session() # Καθαρισμός συνεδρίας Keras

if __name__ == "__main__":
    main() # Εκτέλεση κύριας συνάρτησης

Αποτελέσματα:

Results:

Το πρόγραμμα χρησιμοποιεί το μοντέλο GRU για την πρόβλεψη των 20 αριθμών του ΚΙΝΟ. Αρχικά δημιουργείται ένα σταθερό σύνολο δεδομένων από ιστορικές κληρώσεις. Στη συνέχεια, τα δεδομένα μετατρέπονται σε εισαγωγικές και εκπαιδευτικές ακολουθίες για το μοντέλο. Το μοντέλο εκπαιδεύεται με αυτές τις ακολουθίες και χρησιμοποιείται για να προβλέψει τους επόμενους αριθμούς με βάση τα δεδομένα που έχει δει. Τα αποτελέσματα της πρόβλεψης εμφανίζονται μαζί με τους αριθμούς της τελευταίας κλήρωσης, επιτρέποντας τη σύγκριση και την ανάλυση της ακρίβειας των προβλέψεων.

ΟΙ ΠΡΟΒΛΕΠΟΜΕΝΟΙ ΑΡΙΘΜΟΙ: 6, 10, 13, 18, 20, 23, 30, 31, 36, 41, 42, 46, 50, 59,

 63, 67, 70, 76, 77, 80

ΟΙ ΑΡΙΘΜΟΙ ΤΗΣ ΤΕΛΕΥΤΑΙΑΣ ΚΛΗΡΩΣΗΣ: 9, 10, 13, 14, 15, 17, 24, 26, 29, 32, 35, 40

, 48, 55, 60, 61, 70, 76, 77, 80

ΚΟΙΝΕΣ ΤΙΜΕΣ ΜΕΤΑΞΥ ΠΡΟΒΛΕΨΗΣ ΚΑΙ ΤΕΛΕΥΤΑΙΑΣ ΚΛΗΡΩΣΗΣ: [10, 13, 70, 76]