PyTorch中的卷积神经网络

1  输入、输出和卷积层的维度

 

import torch
in_channels,out_channels=5,10
width,height=100,100
kernel_size=3
batch_size=1

input=torch.randn(batch_size,in_channels,width,height)
conv_layer=torch.nn.Conv2d(in_channels,out_channels,kernel_size=kernel_size)
output=conv_layer(input)

print(input.shape)              #B*inC*W*H
print(output.shape)             #B*outC*W*H
print(conv_layer.weight.shape)  #outC*inC*W*H

2 torch.nn.Conv2d的参数

• padding表示周围填充的像素个数
• stride表示卷积核在图像上移动时每两步之间的跨度

import torch
input=[3,4,6,5,7,
       2,4,6,8,2,
       1,6,7,8,4,
       9,7,4,6,2,
       3,7,5,4,1]
input=torch.Tensor(input).view(1,1,5,5)

conv_layer=torch.nn.Conv2d(1,1,kernel_size=3,padding=1,bias=False)
kernel=torch.Tensor([1,2,3,4,5,6,7,8,9]).view(1,1,3,3)
conv_layer.weight.data=kernel.data  #给卷积层的权重赋值

output=conv_layer(input)
print(output)

2.1 padding=1和padding=2（默认stride=1）

padding=1时

padding=2时

2.2 stride=1和stride=2（默认padding=0）

stride=1时

stride=2时 

 

3  torch.nn.MaxPool2d

import torch

input=[3,4,6,5,
       2,4,6,8,
       1,6,7,8,
       9,7,4,6]
input=torch.Tensor(input).view(1,1,4,4)
maxpooling_layer=torch.nn.MaxPool2d(kernel_size=2)
output=maxpooling_layer(input)
print(output)

4 卷积神经网络

4.1 两层卷积 

 

4.2 三层卷积

 

import torch
from torch.utils.data import DataLoader
from torchvision import transforms,datasets
import torch.nn.functional as F
import torch.optim as optim

batch_size=64
transform=transforms.Compose([
    transforms.ToTensor(),  #把PIL图像转化为Tensor,W*H*C->C*W*H
    transforms.Normalize((0.1307,),(0.3081,))   #第一个是均值，第二个是标准差，针对MNIST
])

train_dataset=datasets.MNIST(root='../dataset/',
                             train=True,
                             transform=transform,
                             download=True)
test_dataset=datasets.MNIST(root='../dataset/',
                            train=False,
                            transform=transform,
                            download=True)
train_loader=DataLoader(dataset=train_dataset,
                        batch_size=batch_size,
                        shuffle=True)
test_loader=DataLoader(dataset=test_dataset,
                       batch_size=batch_size,
                       shuffle=False)

class Net(torch.nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.conv1=torch.nn.Conv2d(1,10,kernel_size=1)
        self.conv2=torch.nn.Conv2d(10,20,kernel_size=3)
        self.conv3=torch.nn.Conv2d(20,30,kernel_size=3)
        self.pooling=torch.nn.MaxPool2d(2)
        self.fc=torch.nn.Linear(120,10)

    def forward(self,x):
        batch_size=x.size(0)                    #(batch,1,28,28)
        x=F.relu(self.pooling(self.conv1(x)))   #(batch,10,14,14)
        x=F.relu(self.pooling(self.conv2(x)))   #(batch,20,6,6)
        x=F.relu(self.pooling(self.conv3(x)))   #(batch,30,2,2)
        x=x.view(batch_size,-1)
        x=self.fc(x)
        return x

model=Net()

criterion=torch.nn.CrossEntropyLoss()
optimizer=optim.SGD(model.parameters(),lr=0.01,momentum=0.5)

def train(epoch):
    running_loss=0.0
    for batch_idx,data in enumerate(train_loader,0):
        inputs,target=data
        optimizer.zero_grad()

        #forward+backward+update
        outputs=model(inputs)
        loss=criterion(outputs,target)
        loss.backward()
        optimizer.step()

        running_loss+=loss.item()
        if batch_idx%300==299:
            print('[%d,%5d]loss:%.3f'%(epoch+1,batch_idx+1,running_loss/300))
            running_loss=0.0

def test():
    correct=0
    total=0
    with torch.no_grad():   #不计算梯度
        for data in test_loader:    #test_loader中按batch把数据分开
            images,labels=data
            outputs=model(images)
            _,predicted=torch.max(outputs.data,dim=1)
            total+=labels.size(0)
            #print('labels=',labels)
            correct+=(predicted==labels).sum().item()
    print('Accuracy on test set:%d %% [%d/%d]'%(100*correct/total,correct,total))

if __name__=='__main__':
    for epoch in range(10):
        train(epoch)
        test()