批量梯度下降

#1.制作数据集
#从excel文件中导入  pd.read_excel()
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
from matplotlib import pyplot as plt

#导入数据
Data=pd.read_excel('D:/PyCharm/Data.xlsx',index_col=0)
#Pandas对象退化为Numpy数组
arr=Data.values
#转化为float32类型数组
arr=arr.astype(np.float32) #这一步必不可少
#数组转为张量
ts_data=torch.tensor(arr)
#把训练集搬到cuda上
ts_data=ts_data.to('cuda:0')
print(ts_data.shape)

#划分数据集  训练集和测试集7：3
#训练集的样本数量
train_size=int(len(ts_data)*0.7)
#测试集的样本数量
test_size=len(ts_data)-train_size
#打乱样本的顺序
ts_data=ts_data[torch.randperm(ts_data.size(0)),:]
#训练集样本
train_data=ts_data[:train_size,:]
#测试集样本
test_data=ts_data[train_size:,:]
print(train_data.shape)
print(test_data.shape)

#搭建神经网络
#一共9列，8个输入特征，1个输出特征
#输入层有8个神经元，输出层有1个神经元
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
#创建子类实例，并搬移到GPU上
model=DNN().to('cuda:0')
print(model)

#训练网络
#损失函数的选择
loss_fn=nn.BCELoss(reduction='mean') #reduction='mean'计算所有样本损失的平均值
#优化函数的选择
#设置学习率
learning_rate=0.005
#torch.optim.Adam实现一个Adam算法优化器
optimizer=torch.optim.Adam(model.parameters(),lr=learning_rate)
#训练网络
#设置迭代轮数
epoches=5000
#记录损失函数变化的列表
losses=[]
#训练集划分输入与输出
#前8列为输入特征
X=train_data[:,:-1]
#后1列为输出特征
Y=train_data[:,-1].reshape(-1,1) #将一阶张量升级为二阶张量
for epoch in range(epoches):
    #进行一次前向传播
    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(epoches),losses)
plt.xlabel('epoch')
plt.ylabel('loss')
plt.show()

#测试网络
#给测试集划分为输入与输出
#前8列为输入特征
X=test_data[:,:-1]
#后1列为输出特征
Y=test_data[:,-1].reshape(-1,1)
#局部关闭梯度计算功能
with torch.no_grad():
    #一次前向传播
    Pred=model(X)
    #Pred>=0.5的设置为1
    Pred[Pred>=0.5]=1
    #Pred<0.5的设置为0
    Pred[Pred<0.5]=0
    #预测正确的样本
    correct=torch.sum((Pred==Y).all(1))
    #全部的样本数量
    total=Y.size(0)
    #打印预测精度
    print(f"预测精度：{100*correct/total}")