pytorch的基础学习（每日一更）day04--正馈神经网络

本代码使用MNIST数据集，神经网络的隐藏层只有一层，结构简单，代码注释齐全（可直接copy运行）

知识点：

1.通过cmd查看GPU的状态

​ nvidia-smi（查看GPU状态）

​ nvidia-smi -L (查看电脑可用的GPU)

2.设置使用GPU的代码

device=torch.device('cuda' if torch.cuda.is_available() else 'cpu')

3.使用到to(device)的地方有

①初始化模型

model=NeuralNet(input_size,hidden_size,num_classes).to(device)

②设置输入的X Y

images=images.view(-1,28*28).to(device)
labels=labels.to(device)

3.构建NN架构时（思考下面代码得意思）

super(NeuralNet,self).__init__()

Python中的super(Net, self).init()是指首先找到Net的父类（比如是类NNet），然后把类Net的对象self转换为类NNet的对象，然后“被转换”的类NNet对象调用自己的init函数，其实简单理解就是子类把父类的__init__()放到自己的__init__()当中，这样子类就有了父类的__init__()的那些东西。

回过头来看看我们的我们最上面的代码，Net类继承nn.Module，super(Net, self).init()就是对继承自父类nn.Module的属性进行初始化。而且是用nn.Module的初始化方法来初始化继承的属性。

import torch
import torchvision
import torch.nn as nn
import torchvision.transforms as transforms

#1.设置GPU or CPU
device=torch.device('cuda' if torch.cuda.is_available() else 'cpu')


#2.设置超参数
input_size=28*28   #784
hidden_size=500
num_classes=10
batch_size=100
num_epochs=5
learning_rate=0.001

#3.设置数据
train_dataset=torchvision.datasets.MNIST(root="../day03LogisticRegression/mnistData",
                           train=True,
                           transform=transforms.ToTensor(),
                           download=True)
test_dataset=torchvision.datasets.MNIST(root="../day03LogisticRegression/mnistData",
                           train=False,
                           transform=transforms.ToTensor(),
                           download=True)
#4.加载数据
train_loader=torch.utils.data.DataLoader(dataset=train_dataset,
                            batch_size=batch_size,
                            shuffle=True
                            )
test_loader=torch.utils.data.DataLoader(dataset=test_dataset,
                            batch_size=batch_size,
                            shuffle=False
                            )
#5.一个隐藏层的全连接神经网络
#定义一个类表示NN的架构（__init__()     forward（））
class NeuralNet(nn.Module):
    #__init__中定义NN的结构
        #fc1 relu fc2 都是layer对象
    def __init__(self,input_size,hidden_size,num_classes):
        super(NeuralNet,self).__init__()
        self.fc1=nn.Linear(input_size,hidden_size)
        self.relu=nn.ReLU()
        self.fc2=nn.Linear(hidden_size,num_classes)

    #forward
    def forward(self,x):
        out=self.fc1(x)
        out=self.relu(out)
        out=self.fc2(out)

        return out
# 初始化一个模型实例(并且使用to()函数调用GPU)
model=NeuralNet(input_size,hidden_size,num_classes).to(device)

# 6. 设置损失函数、优化器
criterion=nn.CrossEntropyLoss()
optimizer=torch.optim.Adam(model.parameters(),
                 lr=learning_rate)

#7.训练模型
total_step=len(train_loader)

for epoch in range(1,num_epochs+1):
    for i,(images,labels) in enumerate(train_loader):
        #将图片形状与NN结构相匹配
        images=images.view(-1,28*28).to(device)
        labels=labels.to(device)

        #forward
        prev=model(images)

        #compute loss
        loss=criterion(prev,labels)

        #backford and optimizer
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        #print loss
        if i%100==0:
            print('Epoch[{}/{}],Step[{}/{}],Loss:{:.4f}'
                .format(epoch,num_epochs,i+1,total_step,loss.item()))

#测试模型
with torch.no_grad():
    correct=0
    total=0
    for images,labels in test_loader:
        images=images.view(-1,28*28).to(device)
        labels=labels.to(device)

        outputs=model(images)
        _,predicted=torch.max(outputs.data,1)

        total+=labels.size(0)
        correct+=(predicted==labels).sum().item()

    print('Accuracy of th model on the 10000 test images : {}%'
            .format(correct*100/total))

结束

pytorch的基础学习结束