pytorch学习笔记7

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as f
from torchvision import datesets,transforms
import matplotlib.pyplot as plt
import numoy as np
%matplotlib inline
#读取数据
#定义超参数
input_size=28#图像尺寸为28x28
num_classes=10#标签的种类数
num_epochs=3#训练的循环周期
batch_size=64#一个批次的大小，64张图片

#训练集
train_dataset=datasets.mnist(root=  ,
                             train=true,
                             transform=transforms.totensor(),
                             download=true)

#测试集
test_dataset=datasets.mnist(root=  ,
                             train=flase,
                             transform=transforms.totensor(),
                            )

#构建batch数据集
train_loader=torch.utils.data.dataloader(dataset=train_dataset,
                                        batch_size=batch_size,
                                        shuffle=true
                                        )//该函数用来划分batch。shuffle:洗牌。默认设置为False。在每次迭代训练时是否将数据洗牌，默认设置是False。将输入数据的顺序打乱，是为了使数据更有独立性，但如果数据是有序列特征的，就不要设置成True了。

test_loader=torch.utils.data.dataloader(dataset=test_dataset,
                                        batch_size=batch_size,
                                        shuffle=true
                                        )
class CNN(nn.module):
    def _init_(self):
        super(CNN,self)._init_()
            self.conv1=nn.sequential(    //nn.Sequential():一个序列容器,用于搭建神经网络的模块按照传入构造器的顺序添加到nn.Sequential()容器中
                nn.conv2d(               //二维卷积
                    in_channels=1,//灰度图
                    out_channels=16,//要得到多少个特征图
                    kernel_size=5,//卷积核大小
                    stride=1,//步长
                    padding=2,
                    ),
                    nn.relu()
                    nn.maxpool2d(kernel_size=2),
                )
            self.conv2=nn.sequential(
                nn.conv2d(16,32,5,1,2),
                nn.relu(),
                nn.maxpool2d(2)
                )
            self.out=nn.linear(32*7*7,10)

    def forward(self,x)
        x=self.conv1(x)
        x=self.conv2(x)
        x=x.view(x.size(0),-1)
        output=self.out(x)
        return output

def accuracy(predictions,labels);
    pred=torch.max(predictions.data,1)[1]  //troch.max()[1]：只返回最大值的索引；1：返回每行最大值元素
    rights=pred.eq(labels.data.view_as(pred)).sum()//比较两向量是否相等。如果相等，对应维度上的数为1，若果不相等则对应位置上的元素为0.
    return rights/len(labels)

#训练网络模型
net=CNN()
#损失函数
criterion=nn.crossentropyloss()
#优化器
optimizer=optim.adam(net.parameters(),lr=0.001)

#开始循环训练

for epoch in range(num_epochs):
    #当前的epoch的结果保存下来
    train_rights=[]
    for batch_idx,(data,target) in enumerate(train_loader):#针对容器中的每一个批进行循环；枚举：索引+值
        net.train()
        output=net(data)
        loss=criterion(output,target)
        optimizer.zero_grad()
        loss.backward
        optimizer.step()
        right=accuracy(output,target)
        train_right.append(right)


        if batch_idx % 100 ==0:
            net.eval()//在测试模型代码段加入
            val_right=[]

            for (data,target) in test_loader:
                output =net(data)
                right=accuracy(output,target)
                val_right.append(right)
            #准确率计算
            train_r=(sum([tup[0] for tup in train_rights]),sum([tup[1] for tup in train_rights]))
            val_r=(sum([tup[0] for tup in val_rights]),sum([tup[1] for tup in val_rights]))//不理解