shape_num = input_data.shape X_row = input_data.iloc[:, :shape_num[1]-1] Y_row = input_data.iloc[:, shape_num[1]-1] train_x, val_test_x, train_y, val_test_y = train_test_split(X_row, Y_row, test_size = 0.3, shuffle = True) val_x, test_x, val_y, test_y = train_test_split(val_test_x, val_test_y, test_size = 0.5, shuffle = True)

这段代码是在对输入数据进行预处理，主要是将输入数据划分为训练集、验证集和测试集。具体来说，首先根据输入数据的形状获取输入数据的列数，然后将输入数据的前shape_num[1]-1列作为X，最后一列作为Y。接着，使用train_test_split函数将X和Y按照一定比例（这里是测试集占30%）划分为训练集和剩下的数据。再次使用train_test_split函数将剩下的数据按照一定比例（这里是验证集和测试集各占剩余数据的一半）划分为验证集和测试集。其中，shuffle参数为True表示在划分数据时进行随机打乱。这样处理后，就可以将训练集、验证集和测试集用于模型的训练、验证和测试了。

相关问题

写一个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/ 即可使用销售额预测系统。

要求如下：不使用tensorflow、pytorch等框架，写一个三输入一输出的bp神经网络，训练集与测试集的比例为7:3，数据集的格式为Excel

### 回答1：

我理解你的要求是：请构建一个三输入一输出的BP神经网络，不使用框架，训练集和测试集的比例为7：3，数据集的格式为Excel。可以使用Python来编写代码，首先需要读取Excel文件中的训练集和测试集，然后定义模型的结构，并设置超参数，最后使用梯度下降算法训练模型，并在测试集上评估模型的性能。

### 回答2：
使用Python语言编写一个简单的三输入一输出的BP神经网络，并使用Excel作为数据集。

首先，需要安装`openpyxl`库来读取和写入Excel文件。可以使用以下命令来安装库：

pip install openpyxl

接下来，创建一个名为`bp_neural_network.py`的文件，并在文件中编写以下代码：

import math
import random
from openpyxl import Workbook, load_workbook

def sigmoid(x):
    return 1 / (1 + math.exp(-x))

def derivative_sigmoid(x):
    return x * (1 - x)

class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.hidden_weights = [[random.uniform(-1, 1) for _ in range(hidden_size)] for _ in range(input_size)]
        self.output_weights = [random.uniform(-1, 1) for _ in range(hidden_size)]
        
    def train(self, learning_rate, epochs, train_file):
        workbook = load_workbook(train_file)
        sheet = workbook.active
        num_samples = sheet.max_row - 1
        for epoch in range(epochs):
            for i in range(2, sheet.max_row + 1):
                input_data = [sheet.cell(row=i, column=j).value for j in range(1, self.input_size + 1)]
                output_data = sheet.cell(row=i, column=self.input_size + 1).value

                hidden_input = [sum([input_data[j] * self.hidden_weights[j][k] for j in range(self.input_size)]) for k in range(self.hidden_size)]
                hidden_output = [sigmoid(x) for x in hidden_input]

                output_input = sum([hidden_output[j] * self.output_weights[j] for j in range(self.hidden_size)])
                output_output = sigmoid(output_input)

                output_error = output_data - output_output
                output_delta = output_error * derivative_sigmoid(output_output)

                hidden_error = [output_delta * self.output_weights[j] for j in range(self.hidden_size)]
                hidden_delta = [hidden_error[j] * derivative_sigmoid(hidden_output[j]) for j in range(self.hidden_size)]

                self.output_weights = [self.output_weights[j] + learning_rate * output_delta * hidden_output[j] for j in range(self.hidden_size)]
                self.hidden_weights = [[self.hidden_weights[i][j] + learning_rate * hidden_delta[j] * input_data[i] for j in range(self.hidden_size)] for i in range(self.input_size)]

    def predict(self, test_file):
        workbook = load_workbook(test_file)
        sheet = workbook.active
        num_samples = sheet.max_row - 1
        correct_predictions = 0
        for i in range(2, sheet.max_row + 1):
            input_data = [sheet.cell(row=i, column=j).value for j in range(1, self.input_size + 1)]
            output_data = sheet.cell(row=i, column=self.input_size + 1).value

            hidden_input = [sum([input_data[j] * self.hidden_weights[j][k] for j in range(self.input_size)]) for k in range(self.hidden_size)]
            hidden_output = [sigmoid(x) for x in hidden_input]

            output_input = sum([hidden_output[j] * self.output_weights[j] for j in range(self.hidden_size)])
            output_output = sigmoid(output_input)

            predicted_output = round(output_output)
            if predicted_output == output_data:
                correct_predictions += 1

        accuracy = correct_predictions / num_samples * 100
        return accuracy

input_size = 3
hidden_size = 4
output_size = 1

learning_rate = 0.1
epochs = 100
train_file = "train_data.xlsx"
test_file = "test_data.xlsx"

network = NeuralNetwork(input_size, hidden_size, output_size)

network.train(learning_rate, epochs, train_file)
accuracy = network.predict(test_file)

print("Accuracy:", accuracy)

在代码中，我们首先定义了Sigmoid激活函数及其导数函数。然后，创建了一个名为`NeuralNetwork`的类，其中包含了神经网络的初始化函数、训练函数和预测函数。
在训练函数中，我们使用`openpyxl`库打开并读取训练集的Excel文件。每次迭代，我们从每一行中读取输入数据和输出数据，并计算每一层的输入和输出。然后，我们根据误差和导数更新权重。在预测函数中，我们使用相同的方式读取测试集的Excel文件，并根据模型的权重进行预测并计算准确率。

最后，可以根据需要，将训练数据保存到名为`train_data.xlsx`的Excel文件中，将测试数据保存到名为`test_data.xlsx`的Excel文件中。

需要注意的是，由于本文提供的代码为简化版，请根据实际需求和数据集的格式对代码进行适当的修改和优化。

### 回答3：
要实现一个三输入一输出的bp神经网络，我们可以使用Python中的常用库，如numpy和pandas，来读取和处理Excel数据集。

首先，我们需要导入所需的库：
import numpy as np
import pandas as pd

然后，我们可以使用pandas库的read_excel函数来读取Excel数据集。假设Excel文件名为data.xlsx，数据在工作表“Sheet1”中，我们可以使用以下代码读取数据集：
data = pd.read_excel('data.xlsx', sheet_name='Sheet1')

接下来，我们需要划分数据集为训练集和测试集。我们可以使用numpy库的random.permutation函数来随机打乱数据集，并通过索引划分为训练集和测试集。假设数据集有100个样本，我们可以使用以下代码将数据集划分为训练集和测试集：
shuffled_indices = np.random.permutation(data.shape[0])
train_indices = shuffled_indices[:int(0.7*data.shape[0])]
test_indices = shuffled_indices[int(0.7*data.shape[0]):]

接下来，我们可以提取输入和输出的特征，并将它们存储在不同的变量中。假设输入特征位于Excel文件的第一列至第三列，输出特征位于第四列，我们可以使用以下代码提取输入和输出的特征：
train_X = data.iloc[train_indices, :3].values
train_y = data.iloc[train_indices, 3].values
test_X = data.iloc[test_indices, :3].values
test_y = data.iloc[test_indices, 3].values

现在我们有了训练集和测试集的输入和输出特征。接下来，我们可以定义神经网络的结构，并进行训练和预测。由于题目要求不使用任何深度学习框架，我们需要手动实现bp神经网络的前向传播和反向传播过程。这包括定义网络的权重和偏置，定义激活函数（如sigmoid函数），进行前向传播计算输出，计算损失函数，计算梯度，更新权重和偏置等。

以上是一个简单实现的提示，完整实现一个bp神经网络需要更多的代码和数学推导。希望这些提示能对你提供一些帮助。