小批量梯度下降

# 小批量梯度下降必须使用到的3各Pytorch内置工具
# 1.DataSet用于封装数据
# 2.DataLoader用于加载数据不同的批次
# 3.random_split用于划分训练集与测试集
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
from torch.utils.data import Dataset, random_split, DataLoader


# 制作数据集
# 在封装我们的数据集时，必须继承DataSet类，重写__init__,__getitem__,__len__三个方法
# 分别用来加载数据集、获取数据索引、获取数据总量
# 小批次训练时，输入特征与输出特征的划分必须写在MyData的子类里面
# 1.继承Datasetlei
class MyData(Dataset):
    # 2.重写__init__方法
    def __init__(self, filepath):
        # 导入数据
        df = pd.read_excel(filepath)
        # 将对象退化为数组
        arr = df.values
        # 转化为float32类型数组
        arr = arr.astype(np.float32)
        # 将数组转化为张量
        ts = torch.tensor(arr)
        # 将训练集搬移到cuda上
        ts = ts.to('cuda')
        # 前8列为输入特征
        self.X = ts[:, 1:9]
        # 后1列为输出特征
        self.Y = ts[:, -1].reshape(-1, 1)
        # 样本的总数
        self.len = ts.shape[0]

    # 3.重写__getitem__方法
    def __getitem__(self, index):
        return self.X[index], self.Y[index]

    # 4.重写__len__方法
    def __len__(self):
        return self.len


# 划分训练集和测试集
Data = MyData('D:\PyCharm\Data.xlsx')
train_size = int(len(Data) * 0.7)  # 训练集样本的数量
test_size = len(Data) - train_size  # 测试集样本的数量
train_data, test_data = random_split(Data, [train_size, test_size])

# 批次加载器
train_loader = DataLoader(dataset=train_data, batch_size=128, shuffle=True)
# shuffle用于在每个epoch内是否先打乱顺序
test_loader = DataLoader(dataset=test_data, batch_size=64, shuffle=False)


# 搭建神经网络
class DNN(nn.Module):
    def __init__(self):
        super(DNN, self).__init__()
        self.net = nn.Sequential(
            nn.Linear(8, 32),
            nn.Sigmoid(),
            nn.Linear(32, 8),
            nn.Sigmoid(),
            nn.Linear(8, 4),
            nn.Sigmoid(),
            nn.Linear(4, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        y = self.net(x)
        return y


model = DNN().to('cuda:0')  # 创建子类实例，并搬到GPU上
print(model)
# 训练网络
# 1.损失函数的选择
loss_fn = nn.BCELoss(reduction='mean')
# 2.优化算法的选择
learning_rate = 0.005
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
# 3.训练网络
epochs = 500
losses = []  # 记录损失函数变化的列表
for epoch in range(epochs):
    # 获取小批次的x和y
    for (x, y) in train_loader:
        # 进行一次前向传播（小批量）
        Pred = model(x)
        # 计算损失函数
        loss = loss_fn(Pred, y)
        # 记录损失函数的变化
        losses.append(loss.item())
        # 清理上一轮滞留的梯度
        optimizer.zero_grad()
        # 进行一次反向传播
        loss.backward()
        # 优化内部参数
        optimizer.step()

Fig = plt.figure()
plt.plot(range(len(losses)), losses)
plt.show()

# 测试网络
correct = 0
total = 0
with torch.no_grad():  # 局部关闭梯度计算功能
    for (x, y) in test_loader:
        # 进行一次前向传播
        Pred = model(x)
        Pred[Pred >= 0.5] = 1
        Pred[Pred < 0.5] = 0
        correct += torch.sum((Pred == y).all(1))
        total += y.size(0)
print(f"测试集精准度{100 * correct / total}%")