利用PyTorch实现卷积神经网络

PyTorch中实现卷积的重要基础函数

1、nn.Conv2d:

nn.Conv2d在pytorch中用于实现卷积。
 

nn.Conv2d(
    in_channels=32,
    out_channels=64,
    kernel_size=3,
    stride=1,
    padding=1,
)

1、in_channels为输入通道数。
2、out_channels为输出通道数。
3、kernel_size为卷积核大小。
4、stride为步数。
5、padding为padding情况。
6、dilation表示空洞卷积情况。

2、nn.MaxPool2d(kernel_size=2)
nn.MaxPool2d在pytorch中用于实现最大池化。

具体使用方式如下：
 

MaxPool2d(kernel_size, 
		stride=None, 
		padding=0, 
		dilation=1, 
		return_indices=False, 
		ceil_mode=False)

1、kernel_size为池化核的大小
2、stride为步长
3、padding为填充情况

3、nn.ReLU()
nn.ReLU()用来实现Relu函数，实现非线性。

4、x.view()
x.view用于reshape特征层的形状。

全部代码
这是一个简单的CNN模型，用于预测mnist手写体。
 

import os
import numpy as np
import torch
import torch.nn as nn
import torch.utils.data as Data
import torchvision
import matplotlib.pyplot as plt
# 循环世代
EPOCH = 20
BATCH_SIZE = 50

# 下载mnist数据集
train_data = torchvision.datasets.MNIST(root='./mnist/',train=True,transform=torchvision.transforms.ToTensor(),download=True,)
# (60000, 28, 28)
print(train_data.train_data.size())
# (60000)
print(train_data.train_labels.size())

train_loader = Data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)

# 测试集
test_data = torchvision.datasets.MNIST(root='./mnist/', train=False)

# (2000, 1, 28, 28)
# 标准化
test_x = torch.unsqueeze(test_data.test_data, dim=1).type(torch.FloatTensor)[:2000]/255.
test_y = test_data.test_labels[:2000]

# 建立pytorch神经网络
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        #----------------------------#
        #   第一部分卷积
        #----------------------------#
        self.conv1 = nn.Sequential(
            nn.Conv2d(
                in_channels=1,
                out_channels=32,
                kernel_size=5,
                stride=1,
                padding=2,
                dilation=1
            ),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),
        )
        #----------------------------#
        #   第二部分卷积
        #----------------------------#
        self.conv2 = nn.Sequential( 
            nn.Conv2d(
                in_channels=32,
                out_channels=64,
                kernel_size=3,
                stride=1,
                padding=1,
                dilation=1
            ),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),
        )
        #----------------------------#
        #   全连接+池化+全连接
        #----------------------------#
        self.ful1 = nn.Linear(64 * 7 * 7, 512)
        self.drop = nn.Dropout(0.5)
        self.ful2 = nn.Sequential(nn.Linear(512, 10),nn.Softmax())

    #----------------------------#
    #   前向传播
    #----------------------------#
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0), -1)
        x = self.ful1(x)
        x = self.drop(x)
        output = self.ful2(x)

        return output

cnn = CNN()
# 指定优化器
optimizer = torch.optim.Adam(cnn.parameters(), lr=1e-3) 
# 指定loss函数
loss_func = nn.CrossEntropyLoss()

for epoch in range(EPOCH):
    for step, (b_x, b_y) in enumerate(train_loader): 
        #----------------------------#
        #   计算loss并修正权值
        #----------------------------#
        output = cnn(b_x)
        loss = loss_func(output, b_y) 
        optimizer.zero_grad() 
        loss.backward() 
        optimizer.step() 
        #----------------------------#
        #   打印
        #----------------------------#
        if step % 50 == 0:
            test_output = cnn(test_x)

            pred_y = torch.max(test_output, 1)[1].data.numpy()
            accuracy = float((pred_y == test_y.data.numpy()).astype(int).sum()) / float(test_y.size(0))
            print('Epoch: %2d'% epoch, ', loss: %.4f' % loss.data.numpy(), ', accuracy: %.4f' % accuracy)