今天跑模型的时候，换个数据集训练模型，发生如下错误，我代码里都没有用到batch_index这个东西，求解

Question

def Metrics_M(real1,pre1):  # 这是最重要的那个方法，直接输出我们的评价指标！！！
    y = np.array(real1)     # 将(real1（真实值）转化为一个数组y)
    y_hat = np.array(pre1)   # 将(pre1（预测值）转化为一个数组y_hat)
    MSE = metrics.mean_squared_error(y, y_hat)  # 计算均方误差回归损失MSE
    # ##要的就是这个东西
    RMSE = metrics.mean_squared_error(y, y_hat)**0.5  # 计算均方误差回归损失的0.5次方，即开根，即均方根误差
    MAE = metrics.mean_absolute_error(y, y_hat)     # 计算平均绝对值误差
    ######
    n = len(real1)      # 定义 real1数组的长度
    return RMSE,MAE     # 返回 均方根误差和平均绝对值误差

# ################################这段代码应该是要把AHP-EW的值，单独拿出来操作
t_pc=test[index]        # text是数据文件，这几句话代表：取数据表中表头为total的数据
t_real=test[index]
t_real1=test[index]
t_real2=test[index]

X = t_real.values       # 分别取前面已经定义好了的指标的值
X_tcr=t_real1.values
X_thq=t_real2.values

dataset=pd.DataFrame(X)     # 将X弄成一个表格
dataset_tcr=pd.DataFrame(X_tcr)     # 将X_tcr成一个表格
dataset_thq=pd.DataFrame(X_thq)     # 将X_thq弄成一个表格

##################
eader_row_index =0  # 定义了四个指标，应该是某类指数
index_col_name =0
col_to_predict =0
cols_to_drop =None

if index_col_name:  # 如果其=0
    dataset.set_index(index_col_name, inplace=True)     # 将列index_col_name转换为行索引，原来的列index_col_name就没了
if cols_to_drop:    # 如果其等于None
    dataset.drop(cols_to_drop, axis =1, inplace = True)  # 将删除“行号为1”的列
col_names = dataset.columns.values.tolist()     # 将矩阵转化为列表
values = dataset.values   
# move the column to predict to be the first col: 把预测列调至第一列
col_to_predict_index = col_to_predict if type(col_to_predict) == int else col_names.index(col_to_predict)
output_col_name = col_names[col_to_predict_index]
if col_to_predict_index > 0:
    col_names = [col_names[col_to_predict_index]] + col_names[:col_to_predict_index] + col_names[col_to_predict_index+1:]
values = np.concatenate((values[:, col_to_predict_index].reshape((values.shape[0], 1)), values[:,:col_to_predict_index], values[:,col_to_predict_index+1:]), axis=1)
values = values.astype("float32")
col_names, values,n_features, output_col_name=col_names,values,values.shape[1], output_col_name
verbose = 2
dropnan = True
n_vars = 1 if type(values) is list else values.shape[1]
if col_names is None: col_names = ["var%d" % (j+1) for j in range(n_vars)]
df = DataFrame(values)
cols, names = list(), list()

# input sequence (t-n, ... t-1)
for i in range(n_in, 0, -1):
    cols.append(df.shift(i))
    names += [("%s(t-%d)" % (col_names[j], i)) for j in range(n_vars)]

# forecast sequence (t, t+1, ... t+n)
for i in range(0, n_out):
    cols.append(df.shift(-i))         # 这里循环结束后cols是个列表，每个列表都是一个shift过的矩阵
    if i == 0:
        names += [("%s(t)" % (col_names[j])) for j in range(n_vars)]
    else:
        names += [("%s(t+%d)" % (col_names[j], i)) for j in range(n_vars)]

# put it all together
agg = concat(cols, axis=1)    # 将cols中的每一行元素一字排开，连接起来，vala t-n_in, valb t-n_in ... valta t, valb t... vala t+n_out-1, valb t+n_out-1
agg.columns = names
# drop rows with NaN values
if dropnan:
    agg.dropna(inplace=True)
if verbose:
    print("\nsupervised data shape:", agg.shape)
values=agg.values
train_X= values[:values.shape[0]-n_in, 0:n_in]      # 训练集
train_Y= values[:values.shape[0]-n_in, n_in:n_in+n_out]
test_X=values[values.shape[0]-n_in:,0:n_in]
test_Y= values[values.shape[0]-n_in:,n_in:n_in+n_out]
val_X=values[values.shape[0]-2*n_in:values.shape[0]-n_in,0:n_in]    # 测设集
val_Y=values[values.shape[0]-2*n_in:values.shape[0]-n_in,n_in:n_in+n_out]

# ##########################RNN模型！！！！！
model = Sequential()    # Sequential表示序列模型
# activation激活函数'tanh',能够把输入的实际值进行压缩到（-1，1）之间
model .add(SimpleRNN (units =128, activation = 'tanh'
            ,return_sequences=True
            ,input_shape = (n_in,1)))   # 前面将n_in定义成30，这表明输入数据的形状
model.add(Dropout(0.2)) # 神经网络正则化
#Dropout的做法是在训练过程中随机地忽略一些神经元。这些神经元被随机地“抛弃”了。
# 也就是说它们在正向传播过程中对于下游神经元的贡献效果暂时消失了，反向传播时该神经元也不会有任何权重的更新。
# 这么做的效果就是，网络模型对神经元特定的权重不那么敏感。这反过来又提升了模型的泛化能力，不容易对训练数据过拟合。

# 激活函数'relu',这个函数表达：x小于零时取零，x大于零时就是x,更简单的说负数不要
model .add(SimpleRNN (units =128, activation = 'relu'
            ,return_sequences=True
            ,input_shape = (n_in,1)))
model.add(Dropout(0.2))# 再次正则化
# 激活函数'linear',将神经元搞成线性的，
model .add(SimpleRNN (units=n_out, activation = 'linear'
            ,input_shape = (n_in,1)))
# 优化器，大多数机器学习（深度学习）任务就是最小化损失，在损失函数定义好的情况下，使用一种优化器进行求解最小损失
# Adam是梯度下降算法的一种变形，但是每次迭代参数的学习率都有一定的范围，不会因为梯度很大而导致学习率（步长）也变得很大，参数的值相对比较稳定
adam = keras.optimizers.Adam(lr = 0.0005, beta_1=0.95, beta_2=0.999,epsilon=1e-08)
# model.compile()方法用于在配置训练方法时，告知训练时用的优化器、损失函数和准确率评测标准
model.compile(loss='mae', optimizer=adam)   # 损失函数设为mae，也就是MAE；优化器设为adam-上一行定义好的

# model.fit()用于执行训练过程！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
# shape[0]表示获取矩阵的行数，shape[1]表示获取矩阵的列数，epochs即迭代次数，表示所有训练数据都被使用过一次时的更新次数
# shuffle=True用于打乱数据，每次都以不同的顺序返回；batch_size：表示单次传递给程序用以训练的参数个数，这里设置为7,也就是7个7个的数据训练。
# validation_data用来防止过度拟合
# model.fit(训练集输入特征，训练集的标签，epochs(迭代次数)，validate(测设集输入特征，测试集的标签))
model.fit(train_X.reshape(train_X.shape[0],train_X.shape[1],1),train_Y,epochs=500,shuffle=True,batch_size=7,validation_data=(val_X.reshape(val_X.shape[0],val_X.shape[1],1),val_Y))
### 模型保存
modelPath='D:\python项目文件\食品安全/RNN_ok.model'
joblib.dump(model,modelPath)

Answer 1