Incompatibilidad de dimensiones del modelo Convolutional LSTM al realizar predicciones y problemas de dimensiones de predicción.

Eres un traductor de español que traduce documentos de tecnología. Traduce lo siguiente al español. No traduzcas el código y los resultados en markdown.

Estructuré un modelo Convolutional LSTM para predecir los próximos datos del precio de Bitcoin, usando los datos pasados analizados del precio de cierre de Bitcoin y otras características.

Pasemos directamente al código:

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

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline

import tensorflow as tf
import tensorflow.keras as keras
import keras_tuner as kt
from keras_tuner import HyperParameters as hp
from keras.models import Sequential
from keras.layers import InputLayer, ConvLSTM1D, LSTM, Flatten, RepeatVector, Dense, TimeDistributed
from keras.callbacks import EarlyStopping

from tensorflow.keras.metrics import RootMeanSquaredError
from tensorflow.keras.optimizers import Adam
import keras.backend as K
from keras.losses import Huber

from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()

DIR = '../input/btc-features-targets'
SEG_DIR = '../input/segmented'

segmentized_features = os.listdir(SEG_DIR)
btc_train_features = []
for seg in segmentized_features:
    train_features = pd.read_csv(f'{SEG_DIR}/{seg}')
    train_features.set_index('date', inplace=True)
    btc_train_features.append(scaler.fit_transform(train_features.values))

btc_train_targets = pd.read_csv(f'{DIR}/btc_train_targets.csv')
btc_train_targets.set_index('date', inplace=True)

btc_test_features = pd.read_csv(f'{DIR}/btc_test_features.csv')
btc_tef1 = btc_test_features.iloc[:111]
btc_tef2 = btc_test_features.iloc[25:]
btc_tef1.set_index('date', inplace=True)
btc_tef2.set_index('date', inplace=True)

btc_test_targets = pd.read_csv(f'{DIR}/btc_test_targets.csv')
btc_test_targets.set_index('date', inplace=True)

btc_trt_log = np.log(btc_train_targets)

btc_tefs1 = scaler.fit_transform(btc_tef1.values)
btc_tefs2 = scaler.fit_transform(btc_tef2.values)
btc_tet_log = np.log(btc_test_targets)

scaled_train_features = []

for features in btc_train_features:
    shape = features.shape
    scaled_train_features.append(np.expand_dims(features, [0,3]))

shape2 = btc_tefs1.shape
btc_tefs1 = np.expand_dims(btc_tefs1, [0,3])

shape3 = btc_tefs2.shape
btc_tefs2 = np.expand_dims(btc_tefs2, [0,3])

btc_trt_log = btc_trt_log.values[0]
btc_tet_log = btc_tet_log.values[0]

def build(hp):
    model = keras.Sequential()

    model.add(InputLayer(input_shape=(111,32,1)))

    convLSTM_hp_filters = hp.Int(name='convLSTM_filters', min_value=32,max_value=512, step=32)
    convLSTM_hp_kernel_size = hp.Choice(name='convLSTM_kernel_size', values=[3,5,7])
    convLSTM_activation = hp.Choice(name='convLSTM_activation', values=['selu', 'relu'])
    model.add(ConvLSTM1D(filters=convLSTM_hp_filters,
                        kernel_size=convLSTM_hp_kernel_size,
                        padding='same',
                        activation=convLSTM_activation,
                        use_bias=True,
                        bias_initializer='zeros'))

    model.add(Flatten())

    model.add(RepeatVector(5))

    LSTM_hp_units = hp.Int(name='LSTM_units', min_value=32,max_value=512, step=32)
    LSTM_activation = hp.Choice(name='LSTM_activation', values=['selu', 'relu'])
    model.add(LSTM(units=LSTM_hp_units, activation=LSTM_activation, return_sequences=True))

    dense_units = hp.Int(name='dense_units',min_value=32,max_value=512,step=32)
    dense_activation = hp.Choice(name='dense_activation',values=['selu', 'relu'])
    model.add(TimeDistributed(Dense(units=dense_units, activation=dense_activation)))

    model.add(Dense(1))


    hp_learning_rate = hp.Choice(name='learning_rate', values=[1e-2, 1e-3, 1e-4])

    model.compile(optimizer=Adam(learning_rate=hp_learning_rate),
                loss=Huber(),
                metrics=[RootMeanSquaredError()])
    return model

tuner = kt.Hyperband(build,
                     objective=kt.Objective('root_mean_squared_error', direction='min'),
                     max_epochs=10,
                     factor=3)
early_stop = EarlyStopping(monitor='root_mean_squared_error',patience=5)


opt_hps = []
for train_features in scaled_train_features:
    tuner.search(train_features, btc_trt_log, epochs=50, callbacks=[early_stop])
    opt_hps.append(tuner.get_best_hyperparameters(num_trials=1)[0])

models, epochs = ([] for _ in range(2))

for hps in opt_hps:
    model = tuner.hypermodel.build(hps)
    models.append(model)

history = model.fit(train_features,btc_trt_log,epochs=70, verbose=0)

rmse = history.history['root_mean_squared_error']
best_epoch = rmse.index(min(rmse)) + 1
epochs.append(best_epoch)

hypermodel = tuner.hypermodel.build(opt_hps[0])
for train_features, epoch in zip(scaled_train_features, epochs):
    hypermodel.fit(train_features,btc_trt_log,epochs=epoch)

tp1 = hypermodel.predict(btc_tefs1).flatten()
tp2 = hypermodel.predict(btc_tefs2).flatten()

test_predictions = np.concatenate((tp1,tp2[86:]),axis=None)

Los hiperparámetros del modelo están configurados usando keras_tuner; ya que hubo problemas de ResourceExhaustError reportados por el cuaderno cuando se realizó el entrenamiento con el conjunto completo de características, se usan conjuntos de datos segmentados en su lugar (y aparentemente, según el estudio realizado utilizando la arquitectura de modelo similar, el entrenamiento se puede hacer eficientemente a través de este enfoque de entrenamiento).

La dimensión de entrada de cada conjunto de datos segmentado es (111,32,1).

No hay ningún problema reportado hasta antes del último bloque de código. Los modelos funcionan bien. Sin embargo, cuando se ejecuta la función .predict(), el cuaderno muestra un error, que indica que la dimensión de las características de entrada para hacer predicciones es incompatible con la dimensión de las características de entrada utilizadas durante el entrenamiento. No entendí la razón detrás de su aparición, ya que hasta donde sé, las dimensiones de entrada de un conjunto de datos de entrenamiento para un modelo DNN no pueden ser idénticas a las dimensiones de entrada de un conjunto de datos de prueba.

A pesar de que se utilizan todos los datos de precios desde 2018 hasta principios de 2021 como conjuntos de datos de entrenamiento, solo se necesitan predicciones para el período mediados de 2021.

El conjunto de datos utilizado para la predicción tiene una dimensión de (136,32,1). Intenté igualar la dimensión de este conjunto de datos a (111,32,1),