pytorch构建模型的整个流程

"""
流程：
1.使用torchvision加载并预处理数据集
2.定义网络
3.定义损失函数和优化器
4.训练网络并更新网络参数
5.测试网络
"""
import torch as t
import torchvision as tv
import torchvision.transforms as transforms
from torchvision.transforms import ToPILImage
import matplotlib.pyplot as plt
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.autograd import Variable

show = ToPILImage() # 可以将tensor转换成Image,方便可视化
#print(show)

# 加载数据集并对数据集预处理
# 定义对数据的预处理(转为tensor,以及归一化)
transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))])

# 训练集
trainset = tv.datasets.CIFAR10(root='D:\pytorch',train=True,download=False,transform=transform)
trainloader = t.utils.data.DataLoader(trainset,batch_size=4,shuffle=True,num_workers=2)


#测试集
testset = tv.datasets.CIFAR10(root='D:\pytorch',train=False,download=False,transform=transform)
testloader = t.utils.data.DataLoader(testset,batch_size=4,shuffle=False,num_workers=2)

classes = ('plane','car','bird','cat','deer','dog','frog','horse','ship','truck')

#(data,label) = trainset[100]
#print(classes[label])
#print(data)
#show((data+1)/2).resize((100,100))

#定义网络
class Net(nn.Module):
    def __init__(self):
        # nn.Moulde子类的函数必须在构造函数中执行父类的构造函数
        # 下式等价于nn.Mould.__init__(self)
        super(Net,self).__init__()
        self.conv1 = nn.Conv2d(3,6,5) # 卷积层3表示输入图片为3通道，6表示输出通道数，5表示卷积核为5*5
        # 卷积层
        self.conv2 = nn.Conv2d(6,16,5)
        # 全连接层 y=wx+b
        self.fc1 = nn.Linear(16*5*5,120)
        self.fc2 = nn.Linear(120,84)
        self.fc3 = nn.Linear(84,10)

    def forward(self,x):
        # 卷积 -> 激活 -> 池化
        x = F.max_pool2d(F.relu(self.conv1(x)),(2,2))
        x = F.max_pool2d(F.relu(self.conv2(x)),2)
        # reshape,-1表示自适应
        x = x.view(x.size()[0],-1)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x
if __name__ == '__main__':
    net = Net()
    #print(net)
    # 定义损失函数和优化器
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(net.parameters(),lr=0.001,momentum=0.9)


    # 训练网络（包括输入数据，前向传播+反向传播，更新参数）
    for epoch in range(2):
        running_loss=0.0
        for i,data in enumerate(trainloader,0):
            #输入数据
            #print(data)
            inputs,lables = data
            inputs,lables = Variable(inputs),Variable(lables)
            #梯度清零
            optimizer.zero_grad()
            #前向传播+反向传播
            outputs = net(inputs)
            loss = criterion(outputs,lables)
            loss.backward()
            #更新参数
            optimizer.step()
            #打印log信息
            running_loss += loss.item()
            if i%2000 == 1999: # 每2000个batch打印一次训练状态
                print('[%d,%5d] loss:%.3f' % (epoch+1,i+1,running_loss/2000))
                running_loss = 0.0
    print("Finished Training")

    # 开始测试训练效果
    dataiter = iter(testloader)
    images,lables = dataiter.next() # 一个batch返回4张图片
    print('实际的label: ',' '.join('%08s' % classes [lables[j]] for j in range(4)))

    # 接着计算网络预测的lable
    # 计算图片在每个类别上的分数
    outputs = net(Variable(images))
    # 得分最高的那个类
    _,predicted = t.max(outputs.data,1)
    print('预测结果： ',' '.join('%5s'% classes [predicted[j]] for j in range(4)))

    #查看整个测试集上面的效果
    correct = 0 #预测正确的图片数
    total = 0 #总共的图片数
    for data in testloader:
        images,lables = data
        outputs = net(Variable(images))
        _, predicted = t.max(outputs.data, 1)
        total += lables.size(0)
        correct += (predicted == lables).sum()
    print('10000张测试集中的准确率：%d %%' % (100*correct/total))