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

Θα προχωρήσουμε σε πρόβλεψη των 20 αριθμών με τα με τα δεδομένα σε αύξουσα σειρά. 

We will proceed with predicting the 20 numbers using the data in ascending order.

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
import joblib
import numpy as np
import pandas as pd
import tensorflow as tf

from sklearn.preprocessing    import MinMaxScaler
from statsmodels.tsa.seasonal import STL
from colorama                 import Fore, Style

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

dataset_0 = np.array([7, 16, 2, 1, 2, 10, 1, 1, 3, 9])
dataset_1 = np.array([8, 20, 11, 3, 5, 12, 7, 2, 4, 10])
dataset_2 = np.array([9, 21, 13, 6, 9, 21, 9, 8, 14, 13])
dataset_3 = np.array([11, 28, 22, 8, 10, 23, 11, 11, 19, 14])
dataset_4 = np.array([14, 29, 23, 12, 11, 24, 13, 20, 21, 15])
dataset_5 = np.array([15, 33, 27, 13, 13, 34, 17, 24, 23, 17])
dataset_6 = np.array([17, 34, 29, 17, 14, 37, 23, 28, 27, 24])
dataset_7 = np.array([23, 36, 30, 19, 17, 41, 26, 30, 29, 26])
dataset_8 = np.array([24, 37, 39, 21, 21, 49, 28, 32, 34, 29])
dataset_9 = np.array([30, 38, 42, 26, 24, 50, 36, 34, 35, 32])
dataset_10 = np.array([32, 41, 43, 30, 29, 51, 38, 38, 38, 35])
dataset_11 = np.array([33, 44, 50, 31, 30, 56, 39, 43, 48, 40])
dataset_12 = np.array([35, 52, 55, 34, 31, 59, 47, 44, 51, 48])
dataset_13 = np.array([51, 63, 62, 41, 37, 60, 50, 47, 55, 55])
dataset_14 = np.array([52, 66, 64, 44, 51, 68, 63, 51, 56, 60])
dataset_15 = np.array([56, 71, 68, 45, 55, 71, 68, 58, 60, 61])
dataset_16 = np.array([59, 72, 69, 53, 56, 73, 73, 60, 61, 70])
dataset_17 = np.array([64, 74, 71, 58, 63, 76, 74, 64, 70, 76])
dataset_18 = np.array([66, 77, 74, 59, 66, 79, 75, 72, 74, 77])
dataset_19 = np.array([74, 80, 75, 60, 80, 80, 77, 76, 76, 80])

datasets = [dataset_0, dataset_1, dataset_2, dataset_3, dataset_4, dataset_5, dataset_6, 

dataset_7, dataset_8, dataset_9, dataset_10, dataset_11, dataset_12, dataset_13, dataset_14,

 dataset_15, dataset_16, dataset_17, dataset_18, dataset_19]

names = ["dataset_0", "dataset_1", "dataset_2", "dataset_3", "dataset_4", "dataset_5", 

"dataset_6", "dataset_7", "dataset_8", "dataset_9", "dataset_10", "dataset_11", "dataset_12",

 "dataset_13", "dataset_14", "dataset_15", "dataset_16", "dataset_17", "dataset_18", 

"dataset_19"]

def create_dataset(data, look_back=1):
    X, y = [], []
    for i in range(len(data) - look_back):
        a = data[i:(i + look_back)]
        X.append(a)
        y.append(data[i + look_back])
    return np.array(X), np.array(y)

start_date = '2024-01-01'
datasets_with_date = []
for data in datasets:
    dates = pd.date_range(start=start_date, periods=len(data), freq='D')
    datasets_with_date.append(pd.Series(data, index=dates))

models = []
scalers = []

for i, data_series in enumerate(datasets_with_date):

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

    result = STL(data_series, seasonal=7, robust=True).fit()
    data_combined = np.column_stack((result.seasonal, result.trend, result.resid))
    if len(data_combined.shape) == 1:
        data_combined = data_combined.reshape(-1, 1)
    scaler = MinMaxScaler(feature_range=(0, 1))
    scaled_data = scaler.fit_transform(data_combined)

    X, y = create_dataset(scaled_data, look_back=1)
    split_point = int(len(X) * 0.8)
    X_train, X_test = X[:split_point], X[split_point:]
    y_train, y_test = y[:split_point], y[split_point:]

    look_back=1
    features = 3

    input_layer = Input(shape=(look_back, features))
    lstm1, state_h1, state_c1 = (LSTM(32,
                                      return_sequences=True,
                                      return_state=True,
                                      activation='tanh',
                                      recurrent_activation='sigmoid',
                                      use_bias=True,
                                      unit_forget_bias=True,
                                      go_backwards=False,
                                      stateful=False,
                                      unroll=True,
                                      recurrent_dropout=0.1, )
                                 (input_layer))
    dropout1 = Dropout(0.1)(lstm1)
    lstm2, state_h2, state_c2 = (LSTM(32,
                                      return_sequences=True,
                                      return_state=True,
                                      activation='tanh',
                                      recurrent_activation='sigmoid',
                                      use_bias=True,
                                      unit_forget_bias=True,
                                      go_backwards=False,
                                      stateful=False,
                                      unroll=True,
                                      recurrent_dropout=0.1, )
                                 (dropout1, initial_state=[state_h1, state_c1]))
    dropout2 = Dropout(0.1)(lstm2)
    lstm3, state_h3, state_c3 = (LSTM(32,
                                      return_sequences=False,
                                      return_state=True,
                                      activation='tanh',
                                      recurrent_activation='sigmoid',
                                      use_bias=True,
                                      unit_forget_bias=True,
                                      go_backwards=False,
                                      stateful=False,
                                      unroll=True,
                                      recurrent_dropout=0.1, )
                                 (dropout2, initial_state=[state_h2, state_c2]))
    dropout3 = Dropout(0.1)(lstm3)
    output_layer = (Dense(3,
                          activation='linear',
                          use_bias=True, )
                    (dropout3))
    model = Model(inputs=input_layer, outputs=output_layer)

    model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.01), 

loss='mean_squared_error',
                  metrics=[tf.keras.metrics.MeanSquaredError(),
                           tf.keras.metrics.MeanAbsoluteError()])

    early_stopping = EarlyStopping(monitor='val_loss', patience=100, verbose=2,

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

mode='min', factor=0.01, min_lr=0.0000001)
    history = model.fit(X_train, y_train, epochs=50, batch_size=1,   verbose=2, 

validation_data=(X_test, y_test), callbacks=[early_stopping, reduce_lr])

    model.save(f'model_{names[i]}.keras')
    joblib.dump(scaler, f'scaler_{names[i]}.pkl')
    models.append(model)
    scalers.append(scaler)

    tf.keras.backend.clear_session()

all_final_prediction = []
for i, model in enumerate(models):
    scaler = scalers[i]
    result = STL(datasets_with_date[i], seasonal=7, robust=True).fit()
    data_combined = np.column_stack((result.seasonal, result.trend, result.resid))
    if len(data_combined.shape) == 1:
        data_combined = data_combined.reshape(-1, 1)

    last_data = data_combined[-1].reshape(1, -1)
    scaled_last_data = scaler.transform(last_data)
    scaled_last_data = scaled_last_data.reshape(1, 1, 3)

    prediction = model.predict(scaled_last_data)
    prediction_rescaled = scaler.inverse_transform(prediction)

    final_prediction = sum(prediction_rescaled[0])
    print(f"{Fore.GREEN}\nΠροβλεπόμενη επόμενη τιμή για το {names[i]}: {Style.RESET_ALL}

 {final_prediction:.2f}")
    all_final_prediction.append(final_prediction)

    print(f"{Fore.BLUE}Ιστορικό εκπαίδευσης:{Style.RESET_ALL}")
    for key in history.history.keys():
        print(f"{Fore.RED}{key}:{Style.RESET_ALL} {history.history[key][-1]:.4f}")

last_values = [dataset[-1] if isinstance(dataset[-1], (int, float)) else dataset[-1][0] 

for dataset in datasets]
predicted_values_rounded = [round(pred, 2) for pred in all_final_prediction]
last_values_rounded = [round(value, 2) for value in last_values]
common_values = sorted(set(predicted_values_rounded).intersection(set(last_values_rounded)))

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

for pred in all_final_prediction)}")
print(f"{Fore.RED}Η  ΤΕΛΕΥΤΑΙΑ   ΚΛΗΡΩΣΗ:{Style.RESET_ALL} {', '.join(f'{value:.2f}'

 for value in last_values_rounded)}")
print(f"\n{Fore.BLUE}ΚΟΙΝΟΙ ΑΡΙΘΜΟΙ: {Style.RESET_ALL}{Fore.RED}{common_values}

{Style.RESET_ALL}")

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

Το πρόγραμμα που παρουσιάζετε χρησιμοποιεί προηγμένες τεχνικές μηχανικής μάθησης για την πρόβλεψη των τιμών σε χρονοσειρές, χρησιμοποιώντας τα δεδομένα από πολλαπλά σετ. Ας δούμε βήμα προς βήμα πώς λειτουργεί:

Επεξεργασία Δεδομένων:

Τα δεδομένα από κάθε σετ οργανώνονται σε χρονοσειρές με ημερομηνίες.

Αποσυνθέτουμε κάθε χρονοσειρά σε τρεις συστατικές: εποχικότητα, τάση και υπόλοιπα μέσω του μοντέλου STL, το οποίο είναι χρήσιμο για την εξαγωγή και ανάλυση των εποχικών συστατικών από τα δεδομένα.

Κλιμάκωση Δεδομένων:

Οι αποσυνθεμένες τιμές κλιμακώνονται σε εύρος [0, 1] με τη χρήση MinMaxScaler για βελτιστοποίηση της διαδικασίας εκμάθησης του νευρωνικού δικτύου.

Δημιουργία Μοντέλου Νευρωνικού Δικτύου:

Χρησιμοποιείτε LSTM (Long Short-Term Memory) δίκτυα, τα οποία είναι κατάλληλα για πρόβλεψη χρονοσειρών λόγω της ικανότητάς τους να απομνημονεύουν πληροφορίες για μεγάλες περιόδους.

Το μοντέλο περιλαμβάνει πολλαπλά επίπεδα LSTM και Dropout για την αποφυγή υπερπροσαρμογής, καθώς και ένα τελικό στρώμα πυκνής σύνδεσης για την πρόβλεψη της εξόδου.

Εκπαίδευση και Αποθήκευση Μοντέλων:

Το μοντέλο εκπαιδεύεται με δεδομένα εκπαίδευσης και επικυρώνεται σε δεδομένα δοκιμής. Χρησιμοποιείτε η προσαρμογή ρυθμού μάθησης και νωρίστη διακοπή για βελτιστοποίηση της απόδοσης.

Το κάθε μοντέλο και ο αντίστοιχος scaler αποθηκεύονται για μελλοντική χρήση.

Πρόβλεψη Μελλοντικών Τιμών:

Για την πρόβλεψη των επόμενων τιμών, χρησιμοποιούνται τα τελευταία δεδομένα από κάθε σετ.

Οι προβλέψεις μετατρέπονται πίσω στην αρχική κλίμακα χρησιμοποιώντας τον scaler και παρουσιάζονται.

Αποτελέσματα και Ανάλυση:

Εκτυπώνονται οι προβλεπόμενες τιμές, καθώς και ιστορικά στοιχεία από την εκπαίδευση.

Αναλύονται οι κοινές τιμές από τις τελευταίες πραγματικές τιμές και τις προβλέψεις, παρέχοντας μια ένδειξη της ακρίβειας του μοντέλου.

Αυτή η μέθοδος προσφέρει μια δυναμική και ευέλικτη προσέγγιση στην πρόβλεψη τιμών με τη βοήθεια τεχνητής νοημοσύνης, ιδανική για περίπλοκες χρονοσειρές και δεδομένα μεγάλου όγκου.

ΟΙ ΠΡΟΒΛΕΠΟΜΕΝΟΙ ΑΡΙΘΜΟΙ: 0.05, 0.12, 0.10, 0.14, 0.19, 0.25, 0.30, 0.41, 0.41,

 0.42, 0.46, 0.46, 0.49, 0.54, 0.63, 0.68, 0.67, 0.73, 0.74, 0.76

ΟΙ  ΤΕΛΕΥΤΑΙΑ   ΚΛΗΡΩΣΗ : 0.03, 0.04, 0.05, 0.08, 0.17, 0.21, 0.22, 0.33, 0.37,

 0.39, 0.46, 0.47, 0.51, 0.55, 0.64, 0.69, 0.71, 0.73, 0.77, 0.78

ΚΟΙΝΟΙ ΑΡΙΘΜΟΙ: [0.05, 0.46, 0.73]