卷积神经网络实例

import torch
import torch.nn as nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms
from torch.autograd import Variable
import time ,os

#卷积网络参数，迭代次数，一批量的样本数，学习率，准确率，时间成本
#迭代次数*一批量的样本数 = 总样本数
epochs = 10
batch_size = 100
learning_rate = [0.001, 0.005, 0.01, 0.05, 0.1]
accuracy = []
time_cost = []

os.environ["CUDA_DEVIC_ORDER"] = "PCI_BUS_ID"#指定使用某一块GPU，编号从0号开始
os.environ["CUDA_VISIBLE_DEVICES"] = "0"

#Minst数据集下载以及导入，root下载目录，是否设为训练集，转变成Tensor
train_dataset = dsets.MNIST(root='./data/',
                            train = True,
                            transform=transforms.ToTensor(),
                           download=True )
test_dataset =dsets.MNIST(root='./data/',
                          train=False,
                          transform=transforms.ToTensor(),
                          download=True)
#传入torch的数据集，DataLoader是一个迭代器，使用小批量梯度下降法，shuffle打乱数据顺序
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=True)

#卷积神经网络
class CNN(nn.Module):
    def __init__(self):
        super(CNN,self).__init__()
        # torch.nn.Sequential是一个Sequential容器，模块将按照构造函数中传递的顺序添加到模块中。
        #两层卷积层，输入数据维度28*28，过滤器5*5，首尾零填充各2个零，即原输入数据维度32*32
        self.layer1 = nn.Sequential(
            nn.Conv2d(1,16,kernel_size=5,padding=2),
            nn.BatchNorm2d(16),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        #第一层的过滤器过滤后得矩阵28*28*16，最大池化后得14*14*16,可以用 .size()查看维度数
        self.layer2 = nn.Sequential(
            nn.Conv2d(16,32,kernel_size=5,padding=2),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        #第二层的过滤器过滤后得矩阵14*14*32，最大池化后得7*7*32
        self.fc = nn.Linear(7*7*32,10)

    def forward(self,x):
        out = self.layer1(x)
        out = self.layer2(out)
        out = out.view(out.size(0), -1)#输出拉伸为一行,out.size(0)表示行数,view的第一个参数代表行数，第二个是列数
        out = self.fc(out)
        return out

cnn = CNN()
cnn.cuda()

for i in learning_rate:
    #使用CrossEntropyLoss交叉熵损失函数， Adagrad优化算法
    criterion = nn.CrossEntropyLoss()
    optimizer = torch.optim.Adagrad(cnn.parameters(), lr=i)
    start = time.time()
    #训练模型
    for e in range(epochs):
        for number, (images,labels) in enumerate(train_loader):
            images = Variable(images).cuda()
            labels = Variable(labels).cuda()

            optimizer.zero_grad()
            outputs = cnn(images)
            loss = criterion(outputs,labels)
            loss.backward()
            optimizer.step()

    cnn.eval()
    correct = 0
    total = 0
    for images,labels in test_loader:
        images = Variable(images).cuda()
        outputs = cnn(images)
        _, predicted = torch.max(outputs.detach(),1)
        total += labels.size(0)
        correct += (predicted.cpu() == labels).sum()

    end = time.time()
    time_cost.append(end-start)

    accu = 100*correct/total
    accuracy.append(accu)

torch.save(cnn.state_dict(),'CNN.pkl')
print('\nTime cost are: ',time_cost)
print('\nThe accuracy are:',accuracy)