请您帮忙检查这样写代码用LSTM做预测有没有问题

任务要求：用一天的数据（73个，早8到晚10每小时4个）预测接下来的一小时（4个）的数值，就是用任意的连续的73个预测接下来的4个
 

from keras.models import Sequential
import numpy as np
import pandas as pd
from numpy import array
from keras.layers import LSTM
from keras.layers import Dense
import matplotlib.pyplot as plt
import keras.backend as K
from keras.callbacks import LearningRateScheduler
from keras import optimizers
from keras.callbacks import ReduceLROnPlateau

# 数据归一化与反归一化
def data_processing(raw_data):
    return (raw_data-np.min(raw_data))/(np.max(raw_data)-np.min(raw_data))#极差规格化

def anti_standard(data1,data2):
    return data1*(np.max(data2)-np.min(data2))+np.min(data2)

#读取这个CSV的第一列的前2000行
data = pd.read_csv('index11.csv', nrows=2000,usecols=[1])

data = data.iloc[:,0].tolist()
data = data_processing(data)#标准化处理
train = data[0:]

#生成训练数据集的函数
def split_sequence(sequence, n_steps_in, n_steps_out):
	X, y = list(), list()
	for i in range(len(sequence)):
		end_ix = i + n_steps_in
		out_end_ix = end_ix + n_steps_out
		if out_end_ix > len(sequence):
			break
		seq_x, seq_y = sequence[i:end_ix], sequence[end_ix:out_end_ix]
		X.append(seq_x)
		y.append(seq_y)
	return array(X), array(y)

#定义学习率的衰减，每两百次减少到40%，不知道是否合适？
def scheduler(epoch):
        # 每100次epoch，学习率减小为原来的1/10
        if epoch % 200 == 0 and epoch != 0:
            lr = K.get_value(model.optimizer.lr)
            K.set_value(model.optimizer.lr, lr * 0.4)
            print("lr changed to {}".format(lr * 0.4))
        return K.get_value(model.optimizer.lr)

raw_seq = train

# 用之前的73步，预测之后的4步
n_steps_in, n_steps_out = 73, 4
X, y = split_sequence(raw_seq, n_steps_in, n_steps_out)


n_features = 1
X = X.reshape((X.shape[0], n_steps_in,n_features))

#初始化adam优化器对象,随机梯度下降法，支持动量参数，支持学习衰减率，支持Nesterov动量
adam = optimizers.Adam(lr=0.003, beta_1=0.9, beta_2=0.999, epsilon=1e-08)

# 定义模型
model = Sequential()
#一共是两层LSTM，第一层输出256维，第二层输出64维，然后添加一个dense(4)输出一个4维
model.add(LSTM(256,  return_sequences=True, input_shape=(n_steps_in,n_features)))#input_shape=(20,1)
model.add(LSTM(64,activation='sigmoid'))
model.add(Dense(n_steps_out))
model.compile(optimizer='adam', loss='mean_squared_error',metrics=['acc'])

history = model.fit(X, y, epochs=1000, batch_size=219, verbose=1,validation_split=0.15, callbacks=[reduce_lr])

model.save('my_model4.h5')
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])

图中的上面两个是分别是acc和val_acc,下面的是两个val_loss和loss
上面这些用来生成H5模型，然后我在另外一个py文件中调用这个h5，执行一次读取73个数，然后输出4个就是预测值？不知道这么想是不是正确的？最终是想应用在Java项目中的，所以对准确度有比较高的要求，我现在照着这个代码运行，每次的val_acc都到了70% 左右就不在上升了，呈现一个在70% 上下稳定的状况了，不知道LSTM()里面的参数、优化器的选择，学习率的设置，输入的shape...方面哪些应该调整。希望您能指点一下。