The numbers for the next column:
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.keras.models import Model
from tensorflow.keras.layers import LSTM, Dropout, Dense, Input, Concatenate, MultiHeadAttention, LayerNormalization, BatchNormalization
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint
from tensorflow.keras import regularizers, backend as K
from tensorflow.keras.constraints import UnitNorm, MaxNorm
from tensorflow.keras.initializers import RandomUniform, GlorotUniform
from colorama import Fore, Style
from sklearn.metrics import mean_squared_error, mean_absolute_error
seed_value = 1
tf.random.set_seed(seed_value)
np.random.seed(seed_value)
dataset_1 = np.array([0.01, 0.1, 0.02, 0.05, 0.03, 0.08, 0.05, 0.01, 0.04, 0.1, 0.05, 0.02, 0.08, 0.08, 0.06, 0.07, 0.1, 0.01, 0.04, 0.09, 0.01, 0.07, 0.07, 0.03, 0.06, 0.08, 0.09, 0.09, 0.06, 0.07, 0.09, 0.09, 0.1, 0.09, 0.08, 0.1, 0.07, 0.01, 0.04, 0.03, 0.02, 0.03, 0.04, 0.01, 0.05, 0.01, 0.05, 0.01, 0.09, 0.1, 0.07, 0.06, 0.06, 0.05, 0.06, 0.02, 0.01, 0.01, 0.08, 0.09, 0.06, 0.06, 0.1, 0.06, 0.05, 0.06, 0.07, 0.05, 0.07, 0.06, 0.03, 0.04, 0.09, 0.06, 0.1, 0.05, 0.1, 0.1, 0.07, 0.05, 0.02, 0.01, 0.09, 0.07, 0.08, 0.01, 0.07, 0.04, 0.04, 0.02, 0.1, 0.09, 0.06, 0.08, 0.06, 0.06, 0.05, 0.02, 0.04, 0.08, 0.09, 0.04, 0.05, 0.03, 0.07, 0.02, 0.01, 0.05, 0.08, 0.02, 0.05, 0.03, 0.08, 0.1, 0.09, 0.01, 0.05, 0.02, 0.04, 0.05, 0.04, 0.08, 0.04, 0.1, 0.09, 0.07, 0.04, 0.03, 0.09, 0.08, 0.02, 0.09, 0.06, 0.06, 0.07, 0.07, 0.01, 0.03, 0.07, 0.05, 0.09, 0.09, 0.01, 0.02, 0.02, 0.06, 0.1, 0.06, 0.03, 0.04, 0.1, 0.04, 0.04, 0.08, 0.07, 0.06, 0.03, 0.06, 0.05, 0.02, 0.07, 0.07])
dataset_2 = np.diff(dataset_1)
dataset_3 = np.array([0.09, 0.08, 0.1, 0.01, 0.04, 0.04, 0.02, 0.04, 0.04, 0.1, 0.01, 0.04, 0.05, 0.05, 0.09, 0.08, 0.01, 0.06, 0.09, 0.09, 0.01, 0.08, 0.07, 0.02, 0.07, 0.1, 0.07, 0.1, 0.06, 0.05, 0.1, 0.1, 0.02, 0.04, 0.04, 0.07, 0.01, 0.04, 0.05, 0.07, 0.05, 0.1, 0.09, 0.03, 0.06, 0.1, 0.03, 0.05, 0.01, 0.08, 0.01, 0.03, 0.02, 0.06, 0.05, 0.03, 0.06, 0.05, 0.05, 0.04, 0.06, 0.08, 0.02, 0.06, 0.08, 0.07, 0.06, 0.05, 0.08, 0.1, 0.1, 0.04, 0.03, 0.02, 0.04, 0.06, 0.03, 0.03, 0.04, 0.07, 0.02, 0.01, 0.06, 0.05, 0.01, 0.1, 0.04, 0.04, 0.1, 0.1, 0.02, 0.1, 0.1, 0.03, 0.03, 0.02, 0.1, 0.04, 0.03, 0.01, 0.06, 0.1, 0.01, 0.01, 0.01, 0.01, 0.06, 0.02, 0.09, 0.02, 0.03, 0.1, 0.02, 0.06, 0.03, 0.01, 0.08, 0.08, 0.04, 0.04, 0.1, 0.1, 0.06, 0.07, 0.06, 0.09, 0.04, 0.1, 0.09, 0.02, 0.01, 0.04, 0.06, 0.04, 0.03, 0.09, 0.1, 0.1, 0.1, 0.01, 0.06, 0.05, 0.06, 0.03, 0.02, 0.01, 0.05, 0.07, 0.04, 0.04, 0.1, 0.01, 0.04, 0.09, 0.1, 0.09, 0.06, 0.07, 0.06, 0.1, 0.05, 0.04, 0.07, 0.04, 0.04])
dataset_4 = np.diff(dataset_3)
def prepare_data_with_lags(dataset, lag, look_back=1, features=1, outputs=1):
dataset = dataset.reshape(-1, 1)
input_data_X = []
output_data_y = []
for i in range(len(dataset) - look_back - lag):
a = dataset[i:(i + look_back + lag), :features]
input_data_X.append(a)
output_data_y.append(dataset[i + look_back + lag, :outputs])
return np.array(input_data_X), np.array(output_data_y)
best_lag_1 = 6
best_lag_2 = 1
best_lag_3 = 6
best_lag_4 = 1
input_data_X_1, output_data_y_1 = prepare_data_with_lags(dataset_1, best_lag_1)
input_data_X_2, output_data_y_2 = prepare_data_with_lags(dataset_2, best_lag_2)
input_data_X_3, output_data_y_3 = prepare_data_with_lags(dataset_3, best_lag_3)
input_data_X_4, output_data_y_4 = prepare_data_with_lags(dataset_4, best_lag_4)
split_ratio = 0.8
split_index_1 = int(len(input_data_X_1) * split_ratio)
split_index_2 = int(len(input_data_X_2) * split_ratio)
split_index_3 = int(len(input_data_X_3) * split_ratio)
split_index_4 = int(len(input_data_X_4) * split_ratio)
train_X_1, val_X_1 = input_data_X_1[:split_index_1], input_data_X_1[split_index_1:]
train_Y_1, val_Y_1 = output_data_y_1[:split_index_1], output_data_y_1[split_index_1:]
train_X_2, val_X_2 = input_data_X_2[:split_index_2], input_data_X_2[split_index_2:]
train_Y_2, val_Y_2 = output_data_y_2[:split_index_2], output_data_y_2[split_index_2:]
train_X_3, val_X_3 = input_data_X_3[:split_index_3], input_data_X_3[split_index_3:]
train_Y_3, val_Y_3 = output_data_y_3[:split_index_3], output_data_y_3[split_index_3:]
train_X_4, val_X_4 = input_data_X_4[:split_index_4], input_data_X_4[split_index_4:]
train_Y_4, val_Y_4 = output_data_y_4[:split_index_4], output_data_y_4[split_index_4:]
def create_tf_dataset(X, y, batch_size=1):
dataset = tf.data.Dataset.from_tensor_slices((X, y))
dataset = dataset.cache().shuffle(buffer_size=len(X)).batch(batch_size).prefetch(buffer_size=tf.data.AUTOTUNE)
return dataset
train_dataset_1 = create_tf_dataset(train_X_1, train_Y_1)
val_dataset_1 = create_tf_dataset(val_X_1, val_Y_1)
train_dataset_2 = create_tf_dataset(train_X_2, train_Y_2)
val_dataset_2 = create_tf_dataset(val_X_2, val_Y_2)
train_dataset_3 = create_tf_dataset(train_X_3, train_Y_3)
val_dataset_3 = create_tf_dataset(val_X_3, val_Y_3)
train_dataset_4 = create_tf_dataset(train_X_4, train_Y_4)
val_dataset_4 = create_tf_dataset(val_X_4, val_Y_4)
def build_model(input_shape):
encoder_inputs = Input(shape=input_shape)
encoder_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=False,
implementation=2,
bias_constraint= tf.keras.constraints.UnitNorm(axis=0),
kernel_constraint= tf.keras.constraints.UnitNorm(axis=0),
recurrent_constraint= tf.keras.constraints.UnitNorm(axis=0),
bias_initializer= RandomUniform(minval=-0.09, maxval=0.09),
kernel_initializer= RandomUniform(minval=-0.09, maxval=0.09),
recurrent_initializer= RandomUniform(minval=-0.09, maxval=0.09),
bias_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
kernel_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
activity_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
recurrent_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
recurrent_dropout=0.1,) (encoder_inputs))
encoder_lstm1 = LayerNormalization()(encoder_lstm1)
encoder_lstm1 = Dropout(0.2)(encoder_lstm1)
encoder_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=False,
implementation=2,
bias_constraint= tf.keras.constraints.UnitNorm(axis=0),
kernel_constraint= tf.keras.constraints.UnitNorm(axis=0),
recurrent_constraint= tf.keras.constraints.UnitNorm(axis=0),
bias_initializer= RandomUniform(minval=-0.09, maxval=0.09),
kernel_initializer= RandomUniform(minval=-0.09, maxval=0.09),
recurrent_initializer= RandomUniform(minval=-0.09, maxval=0.09),
bias_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
kernel_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
activity_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
recurrent_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
recurrent_dropout=0.1, ) (encoder_lstm1))
encoder_lstm2 = LayerNormalization()(encoder_lstm2)
encoder_lstm2 = Dropout(0.2)(encoder_lstm2)
encoder_lstm3, state_h3, state_c3 = (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=False,
implementation=2,
bias_constraint= tf.keras.constraints.UnitNorm(axis=0),
kernel_constraint= tf.keras.constraints.UnitNorm(axis=0),
recurrent_constraint= tf.keras.constraints.UnitNorm(axis=0),
bias_initializer= RandomUniform(minval=-0.09, maxval=0.09),
kernel_initializer= RandomUniform(minval=-0.09, maxval=0.09),
recurrent_initializer= RandomUniform(minval=-0.09, maxval=0.09),
bias_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
kernel_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
activity_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
recurrent_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
recurrent_dropout=0.1,)(encoder_lstm2))
encoder_lstm3 = LayerNormalization()(encoder_lstm3)
encoder_lstm3 = Dropout(0.2)(encoder_lstm3)
encoder_states = [state_h3, state_c3]
decoder_inputs = Input(shape=input_shape)
decoder_lstm1, _, _ = (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=False,
implementation=2,
bias_constraint= tf.keras.constraints.UnitNorm(axis=0),
kernel_constraint= tf.keras.constraints.UnitNorm(axis=0),
recurrent_constraint= tf.keras.constraints.UnitNorm(axis=0),
bias_initializer= RandomUniform(minval=-0.09, maxval=0.09),
kernel_initializer= RandomUniform(minval=-0.09, maxval=0.09),
recurrent_initializer= RandomUniform(minval=-0.09, maxval=0.09),
bias_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
kernel_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
activity_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
recurrent_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
recurrent_dropout=0.1,)(decoder_inputs, initial_state=encoder_states))
decoder_lstm1 = LayerNormalization()(decoder_lstm1)
decoder_lstm1 = Dropout(0.2)(decoder_lstm1)
decoder_lstm2, _, _ = (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=False,
implementation=2,
bias_constraint= tf.keras.constraints.UnitNorm(axis=0),
kernel_constraint= tf.keras.constraints.UnitNorm(axis=0),
recurrent_constraint= tf.keras.constraints.UnitNorm(axis=0),
bias_initializer= RandomUniform(minval=-0.09, maxval=0.09),
kernel_initializer= RandomUniform(minval=-0.09, maxval=0.09),
recurrent_initializer= RandomUniform(minval=-0.09, maxval=0.09),
bias_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
kernel_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
activity_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
recurrent_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
recurrent_dropout=0.1,)(decoder_lstm1))
decoder_lstm2 = LayerNormalization()(decoder_lstm2)
decoder_lstm2 = Dropout(0.2)(decoder_lstm2)
decoder_lstm3, _, _ = (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=False,
implementation=2,
bias_constraint= tf.keras.constraints.UnitNorm(axis=0),
kernel_constraint= tf.keras.constraints.UnitNorm(axis=0),
recurrent_constraint= tf.keras.constraints.UnitNorm(axis=0),
bias_initializer= RandomUniform(minval=-0.09, maxval=0.09),
kernel_initializer= RandomUniform(minval=-0.09, maxval=0.09),
recurrent_initializer= RandomUniform(minval=-0.09, maxval=0.09),
bias_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
kernel_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
activity_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
recurrent_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
recurrent_dropout=0.1,)(decoder_lstm2))
decoder_lstm3 = LayerNormalization()(decoder_lstm3)
decoder_lstm3 = Dropout(0.2)(decoder_lstm3)
attention_output = MultiHeadAttention(num_heads=8, key_dim=32)(encoder_lstm3, decoder_lstm3)
attention_output = LayerNormalization()(attention_output + decoder_lstm3)
outputs = (Dense(1,
activation='tanh',
use_bias=True,
bias_initializer= RandomUniform(minval=-0.09, maxval=0.09),
kernel_initializer= RandomUniform(minval=-0.09, maxval=0.09),
bias_constraint= tf.keras.constraints.UnitNorm(axis=0),
kernel_constraint= tf.keras.constraints.UnitNorm(axis=0),
bias_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
activity_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001),
kernel_regularizer= regularizers.l1_l2(l1=0.00000001, l2=0.00000001))(attention_output))
model = Model([encoder_inputs, decoder_inputs], outputs)
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001, clipvalue=1.0), loss='mean_squared_error',
metrics=[tf.keras.metrics.MeanSquaredError(),tf.keras.metrics.MeanAbsoluteError()])
return model
model_1 = build_model((train_X_1.shape[1], train_X_1.shape[2]))
model_2 = build_model((train_X_2.shape[1], train_X_2.shape[2]))
model_3 = build_model((train_X_3.shape[1], train_X_3.shape[2]))
model_4 = build_model((train_X_4.shape[1], train_X_4.shape[2]))
early_stopping = EarlyStopping(monitor='val_loss', patience=50, restore_best_weights=True)
reduce_lr = ReduceLROnPlateau( monitor='val_loss', patience=20, factor=0.1, min_lr=0.0000001)
model_checkpoint = ModelCheckpoint("best_model.weights.h5", monitor='val_loss', save_best_only=True, save_weights_only=True)
callbacks = [early_stopping, reduce_lr, model_checkpoint]
model_1.fit([train_X_1, train_X_1], train_Y_1, epochs=50, batch_size=1, validation_data=([val_X_1, val_X_1], val_Y_1), callbacks=callbacks)
tf.keras.backend.clear_session()
model_2.fit([train_X_2, train_X_2], train_Y_2, epochs=50, batch_size=1, validation_data=([val_X_2, val_X_2], val_Y_2), callbacks=callbacks)
tf.keras.backend.clear_session()
model_3.fit([train_X_3, train_X_3], train_Y_3, epochs=50, batch_size=1, validation_data=([val_X_3, val_X_3], val_Y_3), callbacks=callbacks)
tf.keras.backend.clear_session()
model_4.fit([train_X_4, train_X_4], train_Y_4, epochs=50, batch_size=1, validation_data=([val_X_4, val_X_4], val_Y_4), callbacks=callbacks)
tf.keras.backend.clear_session()
predictions_1 = model_1.predict([val_X_1, val_X_1]).flatten()
predictions_2 = model_2.predict([val_X_2, val_X_2]).flatten()
predictions_3 = model_3.predict([val_X_3, val_X_3]).flatten()
predictions_4 = model_4.predict([val_X_4, val_X_4]).flatten()
last_value_1 = dataset_1[-best_lag_1:].reshape(1, best_lag_1, 1)
next_prediction_1 = model_1.predict([last_value_1, last_value_1]).flatten()
next_prediction_1 = np.clip(next_prediction_1, 0.01, 0.1)
last_value_2 = dataset_2[-best_lag_2:].reshape(1, best_lag_2, 1)
next_prediction_2 = model_2.predict([last_value_2, last_value_2]).flatten()
next_prediction_2 = np.clip(next_prediction_2, 0.01, 0.1)
last_value_3 = dataset_3[-best_lag_3:].reshape(1, best_lag_3, 1)
next_prediction_3 = model_3.predict([last_value_3, last_value_3]).flatten()
next_prediction_3 = np.clip(next_prediction_3, 0.01, 0.1)
last_value_4 = dataset_4[-best_lag_4:].reshape(1, best_lag_4, 1)
next_prediction_4 = model_4.predict([last_value_4, last_value_4]).flatten()
next_prediction_4 = np.clip(next_prediction_4, 0.01, 0.1)
std_dev_1 = np.random.uniform(0.01, 0.05)
random_noise_1 = np.random.normal(0.05, std_dev_1, size=next_prediction_1.shape)
noise_sign1 = np.random.choice([-1, 1], size=next_prediction_1.shape)
next_prediction_1_with_noise = next_prediction_1 + (random_noise_1 * noise_sign1)
next_prediction_1_with_noise = np.clip(next_prediction_1_with_noise, 0.01, 0.1)
std_dev_3 = np.random.uniform(0.01, 0.05)
random_noise_3 = np.random.normal(0.05, std_dev_3, size=next_prediction_3.shape)
noise_sign3 = np.random.choice([-1, 1], size=next_prediction_3.shape)
next_prediction_3_with_noise = next_prediction_3 + (random_noise_3 * noise_sign3)
next_prediction_3_with_noise = np.clip(next_prediction_3_with_noise, 0.01, 0.1)
difference2 = dataset_1[-1] + next_prediction_2
difference2 = np.clip(difference2, 0.01, 0.1)
difference4 = dataset_3[-1] + next_prediction_4
difference4 = np.clip(difference4, 0.01, 0.1)
print(f"\n{Fore.GREEN}Πρόβλεψη επόμενης τιμής για το dataset 2: {Style.RESET_ALL}{next_prediction_2[0]:.3f}")
print(f"{Fore.GREEN}Πρόβλεψη επόμενης τιμής για το dataset 4: {Style.RESET_ALL}{next_prediction_4[0]:.3f}")
print(f"\n{Fore.RED}Πρόβλεψη επόμενης τιμής για το dataset 1: {Style.RESET_ALL}{next_prediction_1[0]:.2f}")
print(f"{Fore.RED}Πρόβλεψη με διαφορά για το dataset 1: {Style.RESET_ALL}{difference2[0]:.2f}")
print(f"{Fore.RED}Πρόβλεψη με τυχαιότητα για το dataset 1: {Style.RESET_ALL}{next_prediction_1_with_noise[0]:.2f}")
print(f"\n{Fore.BLUE}Πρόβλεψη επόμενης τιμής για το dataset 3: {Style.RESET_ALL}{next_prediction_3[0]:.2f}")
print(f"{Fore.BLUE}Πρόβλεψη με διαφορά για το dataset 3: {Style.RESET_ALL}{difference4[0]:.2f}")
print(f"{Fore.BLUE}Πρόβλεψη με τυχαιότητα για το dataset 3: {Style.RESET_ALL}{next_prediction_3_with_noise[0]:.2f}")
last_values = ", ".join(map(str, [round(dataset_1[-1], 2), round(dataset_2[-1], 2), round(dataset_3[-1], 2), round(dataset_4[-1], 2)]))
print(f"\n{Fore.RED}ΤΕΛΕΥΤΑΙΑ ΤΙΜΗ ΑΠΟ ΚΑΘΕ DATASET:{Style.RESET_ALL}{last_values}")
print(f"{Fore.MAGENTA}Ολες οι προβλέψεις των dataset:{Style.RESET_ALL}{Fore.YELLOW}{next_prediction_1[0]:.2f}, {difference2[0]:.2f}, {next_prediction_1_with_noise[0]:.2f}, {next_prediction_3[0]:.2f}, {difference4[0]:.2f}, {next_prediction_3_with_noise[0]:.2f}{Style.RESET_ALL}")
Αποτελέσματα:
Το πρόγραμμα που αναφέρατε περιέχει ένα σύνθετο κώδικα που χρησιμοποιεί βαθιά μάθηση για να κάνει προβλέψεις σε χρονοσειρές με βάση τέσσερα διαφορετικά σύνολα δεδομένων (datasets). Παρακάτω αναλύεται η λειτουργία του προγράμματος ανά κύριο τμήμα:
1. Προετοιμασία Δεδομένων
Χρησιμοποιείται η συνάρτηση prepare_data_with_lags για να δημιουργήσει εκπαιδευτικά και δοκιμαστικά δεδομένα από τα αρχικά σύνολα δεδομένων (datasets), με βάση τις τιμές και τις χρονικές υστερήσεις (lags). Αυτό περιλαμβάνει τη δημιουργία "παραθύρων" δεδομένων που θα χρησιμοποιηθούν για την εκπαίδευση των μοντέλων.
2. Διαμόρφωση TensorFlow Dataset
Για τη βελτιστοποίηση της φόρτωσης και επεξεργασίας των δεδομένων, δημιουργούνται αντικείμενα tf.data.Dataset, τα οποία επιτρέπουν την αποδοτική διαχείριση μνήμης και επεξεργασίας των δεδομένων κατά την εκπαίδευση των μοντέλων.
3. Κατασκευή Μοντέλου LSTM
Χρησιμοποιείται ένα σύνθετο μοντέλο LSTM, το οποίο περιλαμβάνει τρία επίπεδα LSTM για τον εντοπισμό και τη μάθηση συσχετίσεων σε χρονοσειρές, ενισχυμένο με επίπεδα κανονικοποίησης και Dropout για την αποφυγή υπερπροσαρμογής. Επιπλέον, χρησιμοποιείται MultiHeadAttention για βελτίωση της απόδοσης του μοντέλου μέσω της παράλληλης επεξεργασίας πολλαπλών σημείων των δεδομένων.
4. Εκπαίδευση και Αξιολόγηση
Τα μοντέλα εκπαιδεύονται χρησιμοποιώντας την συνάρτηση fit, με δεδομένα εκπαίδευσης και επικύρωσης. Χρησιμοποιούνται callbacks όπως Early Stopping και ReduceLROnPlateau για βελτιστοποίηση της διαδικασίας εκπαίδευσης και αποφυγή υπερπροσαρμογής.
5. Προβλέψεις και Τυχαίες Διακυμάνσεις
Το μοντέλο χρησιμοποιείται για να κάνει προβλέψεις για τα δεδομένα επικύρωσης, και γίνονται πειράματα με την προσθήκη τυχαίου θορύβου για να δούμε πώς το μοντέλο αντιδρά σε μη-ιδανικές συνθήκες.
6. Οπτικοποίηση και Αναφορά
Παρέχονται εκτυπώσεις των αποτελεσμάτων των προβλέψεων και των τελευταίων τιμών των datasets, δίνοντας μια σαφή εικόνα των αποτελεσμάτων των μοντέλων.
Αυτή η λεπτομερής και εξελιγμένη ανάλυση δείχνει τον συνδυασμό της προχωρημένης τεχνολογίας τεχνητής νοημοσύνης και των μεθόδων μηχανικής μάθησης για την εξαγωγή πρακτικών και εφαρμόσιμων πληροφοριών από δεδομένα χρονοσειρών.
Πρόβλεψη επόμενης τιμής για το dataset 2: 0.010
Πρόβλεψη επόμενης τιμής για το dataset 4: 0.100
Πρόβλεψη επόμενης τιμής για το dataset 1: 0.06
Πρόβλεψη με διαφορά για το dataset 1: 0.08
Πρόβλεψη με τυχαιότητα για το dataset 1: 0.03
Πρόβλεψη επόμενης τιμής για το dataset 3: 0.01
Πρόβλεψη με διαφορά για το dataset 3: 0.10
Πρόβλεψη με τυχαιότητα για το dataset 3: 0.05
ΤΕΛΕΥΤΑΙΑ ΤΙΜΗ ΑΠΟ ΚΑΘΕ DATASET:0.07, 0.0, 0.04, 0.0
Ολες οι προβλέψεις των dataset:0.06, 0.08, 0.03, 0.01, 0.10, 0.05