Python 使用seq2seq进行时间序列预测效果不佳

我试图使用Seq2seq模型预测时间序列数据

在训练模型时，我将模型的输入顺序设置为35，输出顺序设置为7

在使用该模型进行预测时，我们给出了35的输入序列和1的解码器输入大小，并且我们试图通过将模型的预测结果作为输入返回来进行预测

然而，从模型的预测结果来看，我的模型并不擅长预测

如果我的模型有任何错误，请告诉我。多谢各位

Util函数

#Generage random sampling trainset
def generate_train_sequences(x, enc_seq_length, dec_seq_length, num_enc_param, num_dec_param):
    total_start_points = len(x) - enc_seq_length - dec_seq_length
    start_x_idx = np.random.choice(range(total_start_points), total_start_points, replace = False)
    
    input_batch_idxs = [(range(i, i+enc_seq_length)) for i in start_x_idx]
    input_seq = np.take(x, input_batch_idxs, axis = 0)
    
    output_batch_idxs = [(range(i+enc_seq_length, i+enc_seq_length+dec_seq_length)) for i in start_x_idx]
    output_seq = np.take(x, output_batch_idxs, axis = 0)
    
    input_seq =(input_seq.reshape(input_seq.shape[0],input_seq.shape[1],num_enc_param))
    output_seq=(output_seq.reshape(output_seq.shape[0],output_seq.shape[1],num_dec_param))
    
    return input_seq, output_seq
#end def

def nomalize(x):
    ary = np.array(x)
    ary = ary.reshape(ary.shape[0],1)
    scaler = MinMaxScaler(feature_range=(0, 1))
    scaled = scaler.fit_transform(ary)
    scaled = scaled.reshape(1,scaled.shape[0])[0]
    return scaled , scaler
#end def

def denomalize(x,scaler):
    ary = np.array(x)
    ary = ary.reshape(ary.shape[0],1)
    ary = scaler.inverse_transform(ary)
    ary = ary.reshape(1,ary.shape[0])[0]
    return ary
#end def

def load_time_series():
    path = "./data.csv"
    df = pandas.read_csv(path)
    return df["cases"].to_numpy()
#end def

主要

num_编码器_标记=1#功能数量
num_decoder_tokens=1#功能数量
编码器长度=35
解码器长度=7
编码器\层\大小=64
解码器\层\大小=64
纪元=100
列车分离=0.60
有效分割=0.1
#编码器
编码器输入=输入（形状=（无，编码器标记数））
编码器=LSTM（编码器\层\大小，返回\序列=真）（编码器\输入）
编码器=LSTM（编码器\层\大小，返回\序列=真，返回\状态=真）（编码器）
编码器输出，状态h，状态c=编码器
#编码器状态
编码器状态=[状态h，状态c]
#译码器
解码器\u输入=输入（形状=（无，num\u解码器\u标记））
解码器=LSTM（解码器\层\大小，返回\序列=真）（解码器\输入，初始\状态=编码器\状态）
解码器=LSTM（解码器\u层\u大小，返回\u序列=True，返回\u状态=True）（解码器）
解码器\输出，\输出，\输出=解码器
#解码器输出
译码器密度=LeakyReLU（α=0.2）（译码器输出）
解码器密度=LeakyReLU（α=0.2）（解码器密度）
解码器输出=密集（解码器令牌数）（解码器密集）
#编译模型
模型=模型（[编码器输入，解码器输入]，解码器输出）
compile（优化器='adam'，loss='mse'）
#加载时间序列数据
数据=加载时间序列（）
data_nom，data_scaler=normalize（data）#将时间序列数据缩放到0~1之间
#分离式列车组
列车尺寸=整数（长度（数据）*列车分割）
数据列车=数据列车名称[：列车尺寸]
#生成序列
输入顺序，输出顺序=生成序列(
数据列车，
编码器顺序长度，
解码器序列长度，
num_编码器_令牌，
num\u编码器\u令牌
)
编码器输入数据=输入顺序
解码器\目标\数据=输出\顺序
解码器输入数据=np.0（解码器目标数据形状）
#模型拟合
记录=model.fit(
x=[编码器输入数据，解码器输入数据]，
y=解码器\目标\数据，
时代，
验证\分割=有效\分割
)
#绘制学习记录
plt.rc（'font'，family='Malgun Gothic'）
plt.xlabel（'Epoch'）
plt.ylabel（“损失”）
产品名称（“拉宁记录”）
plt.绘图（记录历史['loss'，color=“black”，label=“loss”）
plt.plot（记录历史['val\u loss'，color=“blue”，label=“val\u loss”）
plt.legend（）
plt.show（）
#此代码预测测试集区域
预测数据=数据列车.copy（）
while（len（预测数据）
num_encoder_tokens = 1 #number of features
num_decoder_tokens = 1 #number of features
encoder_seq_length = 35
decoder_seq_length = 7
encoder_layer_size = 64
decoder_layer_size = 64
epochs = 100
train_split = 0.60
vaild_split = 0.1

#Encoder
encoder_inputs = Input(shape=(None, num_encoder_tokens))
encoder = LSTM(encoder_layer_size, return_sequences=True)(encoder_inputs)
encoder = LSTM(encoder_layer_size, return_sequences=True, return_state=True)(encoder)
encoder_outputs, state_h, state_c = encoder

#Encoder state
encoder_states = [state_h, state_c]

#Decoder
decoder_inputs = Input(shape=(None, num_decoder_tokens))
decoder = LSTM(decoder_layer_size, return_sequences=True)(decoder_inputs, initial_state=encoder_states)
decoder = LSTM(decoder_layer_size, return_sequences=True, return_state=True)(decoder)
decoder_outputs, _, _ = decoder

#Decoder output
decoder_dense = LeakyReLU(alpha=0.2)(decoder_outputs)
decoder_dense = LeakyReLU(alpha=0.2)(decoder_dense)
decoder_outputs = Dense(num_decoder_tokens)(decoder_dense)
   
#Compile model
model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
model.compile(optimizer='adam', loss='mse')

#Load time series data
data = load_time_series()
data_nom, data_scaler = nomalize(data) #scale time series data between 0 ~ 1

#Split trainset
train_size = int(len(data) * train_split) 
data_train = data_nom[:train_size]

#Generate sequence
input_seq, output_seq = generate_train_sequences(
    data_train, 
    encoder_seq_length, 
    decoder_seq_length, 
    num_encoder_tokens, 
    num_encoder_tokens
)

encoder_input_data = input_seq
decoder_target_data = output_seq
decoder_input_data = np.zeros(decoder_target_data.shape)

#Model fitting
record = model.fit(
    x=[encoder_input_data, decoder_input_data], 
    y=decoder_target_data, 
    epochs=epochs, 
    validation_split=vaild_split
)

#Draw learning record
plt.rc('font', family='Malgun Gothic')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title("Larning record")
plt.plot(record.history['loss'] , color="black", label="loss")
plt.plot(record.history['val_loss'] , color="blue", label="val_loss")
plt.legend()
plt.show()

#This code predict test set area
predict_data = data_train.copy()
while(len(predict_data) <= len(data)):
    enc_in = predict_data[-encoder_seq_length:].reshape(1,encoder_seq_length,1)
    dec_in = np.zeros((1,1,1))
    
    predict_data = np.append(predict_data, model.predict([enc_in, dec_in]))
#end while

#Inverse transform to original data
predict_data = denomalize(predict_data, data_scaler)

#Draw prediction result
plt.title("predict result")    
plt.plot(data, label="real_value")
plt.plot(predict_data, label="predict")
plt.axvline(x=train_size, color="black", label="train_boundary")
plt.legend()
plt.show()