python操作resultym.csv数据表（有Date（YYYY/MM）、TotalPrice两列数据），数据表第一行为表头信息，数据表中前27行都有数据，以此为基础，python调用resultym.csv表进行操作：循环调用以resultym.csv为数据集构建的pytorch lstm预测模型（模型实现过程：先读取resultym.csv，然后用scaler将TotalPrice进行归一化处理，之后定义一个函数def split_data(data, lookback):将数据集划分为测试集（0.2）和训练集（0.8），data_raw = data.to_numpy()，lookback = 4，然后再将划分完成后的测试集和训练集转换为PyTorch张量，然后定义超参数，定义算法模型model=LSTM（）、损失函数和优化器（Adam）然后训练模型），该模型能够根据Date值来预测TotalPrice值，然后将第一次预测出的y_test_pred赋值给B26、将第二次预测出的值赋给B27、将第三次预测出的值赋给B28，一直循环直到求出B50的数值。每预测出一个值就在表的最后一行插入一组数据，插入的数据为：Date插入的值按照前面的年月往下延(即按照2023/03、2023/04、2023/05········2025/01的顺序)，TotalPrice插入的值定义为2222222.5。直到求出第50行的数值，脚本停止运行。

以下是一个可能的实现过程，仅供参考：

import pandas as pd
import numpy as np
import torch
import torch.nn as nn
from sklearn.preprocessing import MinMaxScaler

# 定义模型
class LSTM(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(LSTM, self).__init__()
        self.hidden_size = hidden_size
        self.lstm = nn.LSTM(input_size, hidden_size)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, input):
        h0 = torch.zeros(1, input.size(1), self.hidden_size).to(input.device)
        c0 = torch.zeros(1, input.size(1), self.hidden_size).to(input.device)
        output, _ = self.lstm(input, (h0, c0))
        output = self.fc(output[-1])
        return output

# 定义数据划分函数
def split_data(data, lookback):
    data_raw = data.to_numpy()
    scaler = MinMaxScaler()
    data_scaled = scaler.fit_transform(data_raw)
    x = []
    y = []
    for i in range(len(data_scaled) - lookback):
        x.append(data_scaled[i:i + lookback])
        y.append(data_scaled[i + lookback])
    x = np.array(x)
    y = np.array(y)
    train_size = int(len(x) * 0.8)
    x_train = torch.from_numpy(x[:train_size, :, :]).type(torch.Tensor)
    y_train = torch.from_numpy(y[:train_size, :]).type(torch.Tensor)
    x_test = torch.from_numpy(x[train_size:, :, :]).type(torch.Tensor)
    y_test = torch.from_numpy(y[train_size:, :]).type(torch.Tensor)
    return x_train, y_train, x_test, y_test, scaler

# 读取数据
data = pd.read_csv("resultym.csv")
lookback = 4
total_price_col_idx = 1
output_size = 1
hidden_size = 16
device = torch.device("cpu")
model = LSTM(lookback, hidden_size, output_size).to(device)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
num_epochs = 1000

# 预测并插入数据
for i in range(26, 50):
    # 划分数据集
    x_train, y_train, x_test, y_test, scaler = split_data(data.iloc[:i, 1:], lookback)
    # 训练模型
    for epoch in range(num_epochs):
        optimizer.zero_grad()
        y_train_pred = model(x_train.to(device))
        loss = criterion(y_train_pred, y_train.to(device))
        loss.backward()
        optimizer.step()

    # 预测测试集
    x_test = x_test[-1:, :, :]
    y_test_pred = model(x_test.to(device))
    y_test_pred = scaler.inverse_transform(y_test_pred.detach().numpy())[0][0]
    data.loc[i, "TotalPrice"] = y_test_pred
    data.loc[i+1] = [f"2023/{i+4:02d}", 2222222.5]

# 输出结果
print(data)

其中，模型训练和预测的过程与前面的实现类似，主要的区别在于每次预测完之后需要将预测结果插入数据表中，并且在插入时需要按照一定规则生成新的日期值。另外，由于每次预测时只需要使用前面的数据，因此可以每次只读取前面的部分数据进行训练和预测，避免了重复计算。