pytorch练习-BP神经网络

1、将原始数据集分为训练集和测试集

2、对训练集进行批量梯度下降

3、评估测试集的准确率

4、模型的推理和训练在GPU上运行，但是验证一般在CPU上运行

5、训练集是数据集的70%，随机取得，测试集占数据集的比重是0.3，随机取得数据

import torch
import numpy as np
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
from sklearn.model_selection import train_test_split
 
 
# 读取原始数据，并划分训练集和测试集，分割符号为逗号，数据类型为float
raw_data = np.loadtxt('diabetes.csv', delimiter=',', dtype=np.float32)
X = raw_data[:, :-1]
y = raw_data[:, [-1]]
Xtrain, Xtest, Ytrain, Ytest = train_test_split(X,y,test_size=0.3)#测试集占数据集的比重
Xtest = torch.from_numpy(Xtest).cuda()#将生成的数组转换为张量
Ytest = torch.from_numpy(Ytest)
 
# 将训练数据集进行批量处理
# prepare dataset
 
class DiabetesDataset(Dataset):
    def __init__(self, data,label):
        self.len = data.shape[0] # shape(多少行，多少列)
        self.x_data = torch.from_numpy(data)
        self.y_data = torch.from_numpy(label)
 
 #通过数据的索引取出数据
    def __getitem__(self, index):
        return self.x_data[index], self.y_data[index]
 
 #返回数据集的长度
    def __len__(self):
        return self.len
 
 #实例化
train_dataset = DiabetesDataset(Xtrain,Ytrain)
#传递数据集，设置样本数量为32，打乱数据，并行工作的数量为1
train_loader = DataLoader(dataset=train_dataset, batch_size=32, shuffle=True, num_workers=1) #num_workers 多线程
 
# design model using class
class Model(torch.nn.Module):
    def __init__(self):
        #构造函数，相当于在声明，还没有进行应用
        super(Model, self).__init__()#调用父类初始化器
        self.linear1 = torch.nn.Linear(8, 6)#构造一个输入为8，输出为6的线性模型
        self.linear2 = torch.nn.Linear(6, 4)#构造一个输入为6，输出为4的线性模型
        self.linear3 = torch.nn.Linear(4, 2)#构造一个输入为4，输出为2的线性模型
        self.linear4 = torch.nn.Linear(2, 1)#构造一个输入为2，输出为1的线性模型
        self.sigmoid = torch.nn.Sigmoid()#构造一个逻辑回归模型,来解决二分类问题，概率大于0.5是1，否则是0
 
 #前向传播
    def forward(self, x):
        #用sigmoid激活线性模型1，也就是将线性模型1代入到sigmoid里面
        x = self.sigmoid(self.linear1(x))
        #用sigmoid激活线性模型2
        x = self.sigmoid(self.linear2(x))
        #用sigmoid激活线性模型3
        x = self.sigmoid(self.linear3(x))
        #用sigmoid激活线性模型4
        x = self.sigmoid(self.linear4(x))
         #返回x
        return x
 
 #实例化模型
model = Model().cuda()#把模型放在GPU
 
# construct loss and optimizer
#构造二分类交叉熵求损失降维求平均
criterion = torch.nn.BCELoss(reduction='mean')
#优化模块中的SGD模型中的所有参数，学习率为0.1
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
 
 
# training cycle forward, backward, update
 #训练
def train(epoch):
    train_loss = 0.0
    count = 0
    for i, data in enumerate(train_loader, 0):
         #将输入x和相应的标签y从数据中拿出来
        inputs, labels = data
        #把数据放在GPU
        inputs=inputs.cuda()
        labels=labels.cuda()
         #将输入送入模型中，求y的预测值
        y_pred = model(inputs)
        #计算损失
        loss = criterion(y_pred, labels).cuda()
         #梯度归零
        optimizer.zero_grad()
        #反向传播
        loss.backward()
        #优化更新
        optimizer.step()
        #计算总的损失
        train_loss += loss.item()
        #训练的次数
        count = i
 
    if epoch%2 == 0:
        #输出平均损失
        print("train loss:", train_loss/count,end=',')
 
 #测试
def test():
    # 而对于tensor的计算操作,默认是要进行计算图的构建的,在这种情况下,
    # 可以使用 with torch.no_grad():,强制之后的内容不进行计算图构建。
    with torch.no_grad():
          #将输入送入模型中，求y的预测值
        y_pred = model(Xtest).cpu()
        #torch.where（）需要三个参数：torch.where
        # （第一个为判断条件，第二个为满足条件设置的值，第三个为不满足条件设置的值）
        y_pred_label = torch.where(y_pred>=0.5,torch.tensor([1.0]),torch.tensor([0.0]))
        #计算精确度
        acc = torch.eq(y_pred_label, Ytest).sum().item() / Ytest.size(0)
        print("test acc:", acc)
 
if __name__ == '__main__':
    for epoch in range(100):
        print("epoch:", epoch)
        train(epoch)
        #在训练的时候进行测试
        if epoch%2==0:
            test()