Pytorch搭建神经网络的小案例

推荐学习b站视频

torch.Tensor()默认是torch.FloatTensor()的简称，创建的为float32位的数据类型；
torch.LongTensor是64位整型

optimizer.zero_grad() 清空过往梯度
loss.backward()：反向传播
optimizer.step():在反向传播后更新参数

使用GPU加速,注意要把模型和数据都放到GPU上
device=torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model=MyModel().to(device)
x,y=x.to(device),y.to(device)

import torch
import torch.nn as nn
import torch.utils.data as Data
import torch.optim as optim
import torch.nn.functional as F
import numpy as np
#使用GPU加速
device=torch.device('cuda' if torch.cuda.is_available() else 'cpu')
#构建数据集
def fizzbuzz_encode(number):#判断number属于哪个类别
    if number%15==0:
        return 3#fizzbuzz
    elif number%5==0:
        return 2#buzz
    elif number%3==0:
        return 1#fizz
    return 0
def fizzbuzz_decode(number,label):#返回number真实类别
    return [str(number),'fizz','buzz','fizzbuzz'][label]


NUM_DIGITS=10
def binary_encode(number):#将一个数转换成他的NUM_DIGITS位二进制数
    return np.array([number >> d&1 for d in range(NUM_DIGITS)][::-1])
# 1：[0 0 0 0 0 0 0 0 0 1]

x_train=torch.Tensor([binary_encode(number) for number in range(100,1024)])
y_train=torch.LongTensor([fizzbuzz_encode(number) for number in range(100,1024)])

class MyDataset(Data.Dataset):#继承torch.utils.data.Dataset
    def __init__(self,x_train,y_train):
        self.x_train=x_train
        self.y_train=y_train

    def __getitem__(self, idx):#函数重写返回编号为idx的数据
        return self.x_train[idx],self.y_train[idx]

    def __len__(self):#限制数据长度
        return len(self.x_train)

train_dataset=MyDataset(x_train,y_train)

train_loader=Data.DataLoader(train_dataset,batch_size=16,shuffle=True)#DataLoader返回打包好的数据,batch_size=数据个数,shuffle=True打乱数据
#Dataset一次只能取出一个样本数据,使用Dataloader可以获得多个样本数据
# print(iter(train_loader).next())
#以上为构建数据集，通常构建数据集比较消耗时间
class MyModel(nn.Module):
    def __init__(self):#在这里定义网络层
        super(MyModel, self).__init__()
        self.liner1=nn.Linear(10,64)
        self.activate1=nn.ReLU()
        self.liner2=nn.Linear(64,8)
        self.activate2=nn.ReLU()
        self.liner3=nn.Linear(8,4)

    def forward(self,x):#前向传播
        output=self.liner1(x)
        output=self.activate1(output)
        output=self.liner2(output)
        output=self.activate2(output)
        output=self.liner3(output)
        return output

model=MyModel().to(device)#建立模型，将模型放到GPU上(也要把数据放到GPU上)
loss_fn=nn.CrossEntropyLoss()#构建损失函数
optimizer=optim.Adam(model.parameters(),lr=0.01)#构建优化器(模型参数,学习率)

Epoch=100

for epoch in range(Epoch):
    idx=0
    for x,y in train_loader:
        x,y=x.to(device),y.to(device)
        pred=model(x)
        loss=loss_fn(pred,y)
        idx+=1
        if  idx%10==0:
            print(loss)
        #三件套
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

#可以使用GPU加素计算
x_test=torch.Tensor([binary_encode(15)]).to(device)#构建一个验证集,也放到GPU上
pred=model(x_test)
softmax=nn.Softmax(dim=1)
pred=softmax(pred)
result=np.argmax(pred.cpu().detach().numpy(),1)
print(result)#输出预测的分类