self.action_data = self.load_action_data()

这段代码看起来是在一个 Python 类的构造函数中加载动作数据。`load_action_data()` 方法可能会从某个数据源（比如文件或数据库）中读取预定义的动作，以便后面在对话系统中使用。这里的 `self` 是指这个类的实例对象本身，`action_data` 是一个成员变量，存储着读取到的动作数据。

相关问题

def load_action_data(self): return get_item_base_data(self.table_name) # 求皮尔逊相关系数 def sim_pearson(self, p1, p2): # 得到双方都曾评价过的物品列表 si = {item: 1 for item in p1 if item in p2} n = len(si) if n == 0: return 0 # 对所有偏好求和 sum1 = sum(p1[it] for it in si) sum2 = sum(p2[it] for it in si) # 求平方和 sum1sq = sum(pow(p1[it], 2) for it in si) sum2sq = sum(pow(p2[it], 2) for it in si) # 求乘积之和 pSum = sum(p1[it] * p2[it] for it in si) # 计算皮尔逊评价值 num = pSum - (sum1 * sum2 / n) den = sqrt((sum1sq - pow(sum1, 2) / n) * (sum2sq - pow(sum2, 2) / n)) if den == 0: return 0 r = num / den return r

这段代码看起来是一个推荐系统中用来计算皮尔逊相关系数的函数。它接受两个用户的评分数据（p1和p2），找到它们共同评价过的物品列表（si），并计算它们之间的相关性（r）。在计算过程中，它首先计算出每个用户对共同评价过的物品的偏好值的平均值（sum1和sum2），然后计算它们的平方和（sum1sq和sum2sq），以及它们的乘积之和（pSum）。最后，它计算出相关性系数r，并返回它。

写一个python Flask销售预测系统，系统有一个suanfa.py文件，该文件的作用：先读取shuju.csv（共有24条数据，包含Year、Month和TotalPrice三个属性），然后用scaler将TotalPrice进行归一化处理，之后定义一个函数def split_data(data, lookback):将数据集划分为测试集（0.2）和训练集（0.8），data_raw = data.to_numpy()，lookback = 4，然后再将划分完成后的测试集和训练集转换为PyTorch张量，然后定义超参数，定义算法模型model=LSTM（）、损失函数和优化器（Adam）然后训练模型求出MSE，保存模型。有一个predict.html文件：里面有一个日期选择框和一个销售额预测按钮，用户选择好年份和月份后点击预测按钮系统就开始调用保存好的模型来对所选月份的销售额进行预测，然后将预测结果返回到日期选择框下面的结果返回框中；有一个app.py文件：定义路径。用flask和bootstrap、LayUI写出完整详细代码

对于这个任务，我们需要完成以下几个步骤：

1. 编写算法脚本 suanfa.py，用于数据处理、模型训练和预测。
2. 编写 Flask 应用 app.py，用于处理用户请求并返回结果。
3. 编写 HTML 页面 predict.html，用于获取用户输入并向后端发送请求。

下面是详细的代码：

suanfa.py

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


def split_data(data, lookback):
    """
    划分数据集为训练集和测试集
    :param data: DataFrame格式的原始数据集
    :param lookback: 窗口大小，即用前几个月的销售额来预测下一个月的销售额
    :return: (训练集输入数据, 训练集输出数据, 测试集输入数据, 测试集输出数据, scaler)
    """
    data_raw = data.to_numpy()
    scaler = MinMaxScaler(feature_range=(-1, 1))
    data_scaled = scaler.fit_transform(data_raw)

    result = []
    for index in range(len(data_scaled) - lookback):
        result.append(data_scaled[index: index + lookback])

    result = np.array(result)
    row = round(0.8 * result.shape[0])
    train = result[:int(row), :]
    np.random.shuffle(train)
    x_train = train[:, :-1]
    y_train = train[:, -1][:, -1]
    x_test = result[int(row):, :-1]
    y_test = result[int(row):, -1][:, -1]

    x_train = torch.from_numpy(x_train).type(torch.Tensor)
    x_test = torch.from_numpy(x_test).type(torch.Tensor)
    y_train = torch.from_numpy(y_train).type(torch.Tensor)
    y_test = torch.from_numpy(y_test).type(torch.Tensor)

    return x_train, y_train, x_test, y_test, scaler


class LSTM(nn.Module):
    def __init__(self, input_size=1, hidden_layer_size=100, output_size=1):
        super().__init__()
        self.hidden_layer_size = hidden_layer_size

        self.lstm = nn.LSTM(input_size, hidden_layer_size)

        self.linear = nn.Linear(hidden_layer_size, output_size)

        self.hidden_cell = (torch.zeros(1, 1, self.hidden_layer_size),
                            torch.zeros(1, 1, self.hidden_layer_size))

    def forward(self, input_seq):
        lstm_out, self.hidden_cell = self.lstm(input_seq.view(len(input_seq), 1, -1), self.hidden_cell)
        predictions = self.linear(lstm_out.view(len(input_seq), -1))
        return predictions[-1]


def train_model(data, lookback, model_path):
    """
    训练模型并保存
    :param data: DataFrame格式的原始数据集
    :param lookback: 窗口大小，即用前几个月的销售额来预测下一个月的销售额
    :param model_path: 保存模型的路径
    """
    x_train, y_train, x_test, y_test, scaler = split_data(data, lookback)

    model = LSTM()
    loss_function = nn.MSELoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

    epochs = 150
    for i in range(epochs):
        for j in range(x_train.size()[0]):
            optimizer.zero_grad()
            model.hidden_cell = (torch.zeros(1, 1, model.hidden_layer_size),
                                 torch.zeros(1, 1, model.hidden_layer_size))

            y_pred = model(x_train[j])

            single_loss = loss_function(y_pred, y_train[j])
            single_loss.backward()
            optimizer.step()

        if i % 25 == 1:
            print(f'epoch: {i:3} loss: {single_loss.item():10.8f}')

    torch.save(model.state_dict(), model_path)
    print("Model saved")


def predict(model_path, input_date):
    """
    使用保存的模型预测销售额
    :param model_path: 保存模型的路径
    :param input_date: 用户选择的日期，格式为'YYYY-MM'
    :return: 预测销售额
    """
    model = LSTM()
    model.load_state_dict(torch.load(model_path))
    model.eval()

    data = pd.read_csv('shuju.csv')
    data = data.set_index('Year-Month')

    # 将输入的日期转换为对应的行数
    row_num = data.index.get_loc(input_date)

    x = data.iloc[row_num - 4:row_num + 1]['TotalPrice'].values
    x = scaler.transform(x.reshape(-1, 1))
    x = torch.from_numpy(x).type(torch.Tensor)

    with torch.no_grad():
        model.hidden = (torch.zeros(1, 1, model.hidden_layer_size),
                        torch.zeros(1, 1, model.hidden_layer_size))
        pred = model(x)

    pred = scaler.inverse_transform(pred.reshape(-1, 1))
    return round(pred[0][0])

app.py

from flask import Flask, render_template, request
from suanfa import predict

app = Flask(__name__)

# 预测模型保存路径
model_path = 'model.pth'


@app.route('/')
def index():
    return render_template('predict.html')


@app.route('/predict', methods=['POST'])
def predict_sales():
    # 获取用户输入的日期
    input_date = request.form['input_date']
    # 调用预测函数得到预测结果
    pred = predict(model_path, input_date)

    return render_template('predict.html', prediction=pred)

predict.html

<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <title>销售额预测系统</title>
  <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css">
  <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap-theme.min.css">
  <link rel="stylesheet" href="https://cdn.bootcss.com/layer/2.3/skin/default/layer.css">
  <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
  <script src="https://cdn.bootcss.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
  <script src="https://cdn.bootcss.com/layer/2.3/layer.js"></script>
</head>
<body>
  <div class="container">
    <div class="page-header">
      <h1>销售额预测系统</h1>
    </div>
    <div class="row">
      <div class="col-md-6 col-md-offset-3">
        <form class="form-inline" action="/predict" method="POST">
          <div class="form-group">
            <label for="input_date">日期：</label>
            <input type="month" class="form-control" id="input_date" name="input_date" required>
          </div>
          <button type="submit" class="btn btn-primary">预测</button>
        </form>
        {% if prediction %}
        <div class="alert alert-success" role="alert">
          预测结果：{{ prediction }} 元
        </div>
        {% endif %}
      </div>
    </div>
  </div>
</body>
</html>

在运行应用之前，需要在命令行中安装以下依赖：

pip install Flask pandas numpy torch sklearn

接下来，在命令行中输入以下命令启动应用：

export FLASK_APP=app.py
flask run

然后在浏览器中访问 http://127.0.0.1:5000/ 即可使用销售额预测系统。