We will proceed with predicting the next numbers of LOTTO using the seq2seq method with LSTM model and utilizing encoder/decoder and attention mechanisms.
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, median_absolute_error
from sklearn.metrics import mean_absolute_percentage_error, r2_score
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 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.05, 0.07, 0.11, 0.16, 0.23, 0.29],
[0.01, 0.13, 0.14, 0.21, 0.23, 0.31],
[0.11, 0.13, 0.21, 0.34, 0.46, 0.49],
[0.15, 0.23, 0.31, 0.39, 0.41, 0.42],
[0.01, 0.03, 0.23, 0.31, 0.37, 0.42],
[0.01, 0.16, 0.21, 0.27, 0.32, 0.41],
[0.02, 0.05, 0.4, 0.41, 0.43, 0.45],
[0.06, 0.09, 0.14, 0.18, 0.3, 0.44],
[0.07, 0.12, 0.34, 0.37, 0.4, 0.43],
[0.04, 0.07, 0.17, 0.19, 0.2, 0.37],
[0.03, 0.04, 0.1, 0.41, 0.45, 0.47],
[0.05, 0.11, 0.24, 0.35, 0.42, 0.49],
[0.04, 0.07, 0.11, 0.18, 0.28, 0.42],
[0.03, 0.19, 0.23, 0.39, 0.43, 0.49],
[0.04, 0.15, 0.16, 0.42, 0.45, 0.48],
[0.04, 0.07, 0.1, 0.32, 0.33, 0.4],
[0.12, 0.17, 0.2, 0.22, 0.42, 0.45],
[0.06, 0.1, 0.15, 0.38, 0.42, 0.48],
[0.04, 0.17, 0.27, 0.34, 0.36, 0.48],
[0.19, 0.26, 0.31, 0.32, 0.45, 0.48],
[0.27, 0.3, 0.31, 0.34, 0.35, 0.47],
[0.13, 0.14, 0.23, 0.28, 0.35, 0.36],
[0.01, 0.03, 0.26, 0.37, 0.46, 0.47],
[0.02, 0.08, 0.18, 0.24, 0.29, 0.4],
[0.05, 0.15, 0.25, 0.37, 0.39, 0.41],
[0.02, 0.07, 0.2, 0.3, 0.31, 0.34],
[0.06, 0.08, 0.12, 0.15, 0.21, 0.46],
[0.06, 0.11, 0.15, 0.31, 0.35, 0.49],
[0.06, 0.14, 0.18, 0.2, 0.23, 0.3],
[0.03, 0.13, 0.19, 0.22, 0.32, 0.38],
[0.08, 0.25, 0.31, 0.38, 0.39, 0.41],
[0.23, 0.26, 0.36, 0.41, 0.43, 0.47],
[0.13, 0.23, 0.36, 0.41, 0.46, 0.48],
[0.13, 0.14, 0.17, 0.24, 0.37, 0.46],
[0.08, 0.41, 0.42, 0.43, 0.44, 0.47],
[0.03, 0.05, 0.17, 0.26, 0.32, 0.44],
[0.01, 0.06, 0.08, 0.16, 0.21, 0.23],
[0.1, 0.11, 0.17, 0.19, 0.23, 0.33],
[0.01, 0.2, 0.24, 0.32, 0.42, 0.47],
[0.03, 0.05, 0.11, 0.25, 0.39, 0.45],
[0.03, 0.05, 0.22, 0.3, 0.39, 0.48],
[0.02, 0.07, 0.26, 0.39, 0.45, 0.49],
[0.08, 0.2, 0.23, 0.24, 0.3, 0.44],
[0.09, 0.11, 0.16, 0.25, 0.31, 0.45],
[0.03, 0.13, 0.36, 0.37, 0.38, 0.48],
[0.11, 0.24, 0.26, 0.32, 0.45, 0.49],
[0.05, 0.13, 0.14, 0.16, 0.26, 0.33],
[0.13, 0.22, 0.4, 0.41, 0.47, 0.48],
[0.07, 0.09, 0.13, 0.31, 0.32, 0.44],
])
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_model(input_shape: Tuple[int, int], num_units: List[int]) -> Model:
encoder_inputs = Input(shape=input_shape)
encoder_lstm1 = LSTM(num_units[0], activation='tanh', return_sequences=True, return_state=True, unroll=True, unit_forget_bias=True)
encoder_outputs1, state_h1, state_c1 = encoder_lstm1(encoder_inputs)
encoder_lstm2 = LSTM(num_units[1], activation='tanh', return_sequences=True, return_state=True, unroll=True, unit_forget_bias=True)
encoder_outputs2, state_h2, state_c2 = encoder_lstm2(encoder_outputs1)
encoder_states = [state_h2, state_c2]
decoder_inputs = Input(shape=input_shape)
decoder_lstm1 = LSTM(num_units[0], activation='tanh', return_sequences=True, return_state=True, unroll=True, unit_forget_bias=True)
decoder_outputs1, _, _ = decoder_lstm1(decoder_inputs, initial_state=[state_h1, state_c1])
score = Dot(axes=[2, 2])([decoder_outputs1, 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_lstm2 = LSTM(num_units[1], activation='tanh', return_sequences=True, return_state=True, unroll=True, unit_forget_bias=True)
decoder_outputs2, _, _ = decoder_lstm2(decoder_combined_context, initial_state=encoder_states)
decoder_dense = Dense(input_shape[1], activation='linear', use_bias=True)
decoder_outputs = decoder_dense(decoder_outputs2)
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 = 50) -> tf.keras.callbacks.History:
early_stopping = EarlyStopping(monitor='val_loss', patience=15, verbose=2, mode='min', restore_best_weights=True)
reduce_lr = ReduceLROnPlateau(monitor='val_loss', patience=10, 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 = [128, 128]
model = build_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()
if __name__ == "__main__":
main()
Αποτελέσματα:
Το πρόγραμμα που περιγράφετε είναι μια εξελιγμένη μέθοδος για την πρόβλεψη των επόμενων αριθμών σε ένα παιχνίδι ΛΟΤΤΟ χρησιμοποιώντας την τεχνολογία του νευρωνικού δικτύου LSTM (Long Short-Term Memory), μια δημοφιλής μορφή αναδρομικών νευρωνικών δικτύων που είναι ικανά να μαθαίνουν απαιτήσεις από την ακολουθία των δεδομένων. Το συγκεκριμένο μοντέλο συνδυάζει τη δομή seq2seq με μηχανισμούς προσοχής για να βελτιώσει την ακρίβεια της πρόβλεψης.
Στοιχεία Προγράμματος
Δημιουργία Συνόλου Δεδομένων: Το πρόγραμμα ξεκινά με τη δημιουργία ενός συνόλου δεδομένων που αποτελείται από σειρές αριθμών από τις κληρώσεις του ΛΟΤΤΟ.
Επεξεργασία Δεδομένων: Διαχωρισμός των δεδομένων σε εκπαιδευτικά και επαληθευτικά σύνολα, καθώς και η δημιουργία ακολουθιών που θα χρησιμοποιηθούν για την εκπαίδευση του μοντέλου.
Κατασκευή Μοντέλου: Χρήση δύο επιπέδων LSTM σε κάθε ένα από τον encoder και τον decoder με ενσωματωμένο μηχανισμό προσοχής, που βοηθά στην εστίαση του μοντέλου στα πιο σημαντικά μέρη της εισόδου για την παραγωγή ακριβέστερων προβλέψεων.
Εκπαίδευση Μοντέλου: Το μοντέλο εκπαιδεύεται στα δεδομένα, χρησιμοποιώντας τεχνικές όπως Early Stopping και ReduceLROnPlateau για τη βελτιστοποίηση της εκπαίδευσης και την αποφυγή υπερπροσαρμογής.
Πρόβλεψη και Αποτελέσματα: Μετά την εκπαίδευση, το μοντέλο χρησιμοποιείται για την πρόβλεψη της επόμενης σειράς αριθμών. Τα αποτελέσματα συγκρίνονται με την τελευταία κλήρωση για να δούμε πόσο κοντά έφτασε το μοντέλο στην πραγματικότητα.
Στοιχεία Προγράμματος
Δημιουργία Συνόλου Δεδομένων: Το πρόγραμμα ξεκινά με τη δημιουργία ενός συνόλου δεδομένων που αποτελείται από σειρές αριθμών από τις κληρώσεις του ΛΟΤΤΟ.
Επεξεργασία Δεδομένων: Διαχωρισμός των δεδομένων σε εκπαιδευτικά και επαληθευτικά σύνολα, καθώς και η δημιουργία ακολουθιών που θα χρησιμοποιηθούν για την εκπαίδευση του μοντέλου.
Κατασκευή Μοντέλου: Χρήση δύο επιπέδων LSTM σε κάθε ένα από τον encoder και τον decoder με ενσωματωμένο μηχανισμό προσοχής, που βοηθά στην εστίαση του μοντέλου στα πιο σημαντικά μέρη της εισόδου για την παραγωγή ακριβέστερων προβλέψεων.
Εκπαίδευση Μοντέλου: Το μοντέλο εκπαιδεύεται στα δεδομένα, χρησιμοποιώντας τεχνικές όπως Early Stopping και ReduceLROnPlateau για τη βελτιστοποίηση της εκπαίδευσης και την αποφυγή υπερπροσαρμογής.
Πρόβλεψη και Αποτελέσματα: Μετά την εκπαίδευση, το μοντέλο χρησιμοποιείται για την πρόβλεψη της επόμενης σειράς αριθμών. Τα αποτελέσματα συγκρίνονται με την τελευταία κλήρωση για να δούμε πόσο κοντά έφτασε το μοντέλο στην πραγματικότητα.
ΟΙ ΠΡΟΒΛΕΠΟΜΕΝΟΙ ΑΡΙΘΜΟΙ: 8, 15, 23, 34, 38, 44
Η ΤΕΛΕΥΤΑΙΑ ΚΛΗΡΩΣΗ: 7, 9, 13, 31, 32, 44
ΚΟΙΝΕΣ ΤΙΜΕΣ: [44]