pytorch 实现 ResNet on Fashion-MNIST
from __future__ import print_function
import torch
import time
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
from torch import optim
from torch.autograd import Variable
from torch.utils.data import DataLoader
from torchvision.transforms import ToPILImage
show=ToPILImage()
import numpy as np
import matplotlib.pyplot as plt
#
batchSize=128
##load data
transform = transforms.Compose([transforms.Resize(96),transforms.ToTensor(),transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset = torchvision.datasets.FashionMNIST(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=batchSize, shuffle=True, num_workers=0)
testset = torchvision.datasets.FashionMNIST(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=batchSize, shuffle=False, num_workers=0)
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
def imshow(img):
img = img / 2 + 0.5
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
####network
class Residual(nn.Module):
def __init__(self,in_channel,num_channel,use_conv1x1=False,strides=1):
super(Residual,self).__init__()
self.relu=nn.ReLU()
self.bn1=nn.BatchNorm2d(in_channel,eps=1e-3)
self.conv1=nn.Conv2d(in_channels =in_channel,out_channels=num_channel,kernel_size=3,padding=1,stride=strides)
self.bn2=nn.BatchNorm2d(num_channel,eps=1e-3)
self.conv2=nn.Conv2d(in_channels=num_channel,out_channels=num_channel,kernel_size=3,padding=1)
if use_conv1x1:
self.conv3=nn.Conv2d(in_channels=in_channel,out_channels=num_channel,kernel_size=1,stride=strides)
else:
self.conv3=None
def forward(self, x):
y=self.conv1(self.relu(self.bn1(x)))
y=self.conv2(self.relu(self.bn2(y)))
# print (y.shape)
if self.conv3:
x=self.conv3(x)
# print (x.shape)
z=y+x
return z
# blk = Residual(3,3,True)
# X = Variable(torch.zeros(4, 3, 96, 96))
# out=blk(X)
def ResNet_block(in_channels,num_channels,num_residuals,first_block=False):
layers=[]
for i in range(num_residuals):
if i==0 and not first_block:
layers+=[Residual(in_channels,num_channels,use_conv1x1=True,strides=2)]
elif i>0 and not first_block:
layers+=[Residual(num_channels,num_channels)]
else:
layers += [Residual(in_channels, num_channels)]
blk=nn.Sequential(*layers)
return blk
class ResNet(nn.Module):
def __init__(self,in_channel,num_classes):
super(ResNet,self).__init__()
self.block1=nn.Sequential(nn.Conv2d(in_channels=in_channel,out_channels=64,kernel_size=7,stride=2,padding=3),
nn.BatchNorm2d(64),
nn.ReLU(),
nn.MaxPool2d(kernel_size=3,stride=2,padding=1))
self.block2=nn.Sequential(ResNet_block(64,64,2,True),
ResNet_block(64,128,2),
ResNet_block(128,256,2),
ResNet_block(256,512,2))
self.block3=nn.Sequential(nn.AvgPool2d(kernel_size=3))
self.Dense=nn.Linear(512,10)
def forward(self,x):
y=self.block1(x)
y=self.block2(y)
y=self.block3(y)
y=y.view(-1,512)
y=self.Dense(y)
return y
net=ResNet(1,10).cuda()
print (net)
criterion=nn.CrossEntropyLoss()
optimizer=optim.SGD(net.parameters(),lr=0.05,momentum=0.9)
#train
print ("training begin")
for epoch in range(3):
start = time.time()
running_loss=0
for i,data in enumerate(trainloader,0):
# print (inputs,labels)
image,label=data
image=image.cuda()
label=label.cuda()
image=Variable(image)
label=Variable(label)
# imshow(torchvision.utils.make_grid(image))
# plt.show()
# print (label)
optimizer.zero_grad()
outputs=net(image)
# print (outputs)
loss=criterion(outputs,label)
loss.backward()
optimizer.step()
running_loss+=loss.data
if i%100==99:
end=time.time()
print ('[epoch %d,imgs %5d] loss: %.7f time: %0.3f s'%(epoch+1,(i+1)*batchSize,running_loss/100,(end-start)))
start=time.time()
running_loss=0
print ("finish training")
#test
net.eval()
correct=0
total=0
for data in testloader:
images,labels=data
images=images.cuda()
labels=labels.cuda()
outputs=net(Variable(images))
_,predicted=torch.max(outputs,1)
total+=labels.size(0)
correct+=(predicted==labels).sum()
print('Accuracy of the network on the %d test images: %d %%' % (total , 100 * correct / total))
运行过程
ResNet(
(block1): Sequential(
(0): Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3))
(1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(2): ReLU()
(3): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
)
(block2): Sequential(
(0): Sequential(
(0): Residual(
(relu): ReLU()
(bn1): BatchNorm2d(64, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
(conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(bn2): BatchNorm2d(64, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
(conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
)
(1): Residual(
(relu): ReLU()
(bn1): BatchNorm2d(64, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
(conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(bn2): BatchNorm2d(64, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
(conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
)
)
(1): Sequential(
(0): Residual(
(relu): ReLU()
(bn1): BatchNorm2d(64, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
(conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
(bn2): BatchNorm2d(128, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
(conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(conv3): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2))
)
(1): Residual(
(relu): ReLU()
(bn1): BatchNorm2d(128, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
(conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(bn2): BatchNorm2d(128, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
(conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
)
)
(2): Sequential(
(0): Residual(
(relu): ReLU()
(bn1): BatchNorm2d(128, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
(conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
(bn2): BatchNorm2d(256, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
(conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(conv3): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2))
)
(1): Residual(
(relu): ReLU()
(bn1): BatchNorm2d(256, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
(conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(bn2): BatchNorm2d(256, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
(conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
)
)
(3): Sequential(
(0): Residual(
(relu): ReLU()
(bn1): BatchNorm2d(256, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
(conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
(bn2): BatchNorm2d(512, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
(conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(conv3): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2))
)
(1): Residual(
(relu): ReLU()
(bn1): BatchNorm2d(512, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
(conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(bn2): BatchNorm2d(512, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
(conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
)
)
)
(block3): Sequential(
(0): AvgPool2d(kernel_size=3, stride=3, padding=0)
)
(Dense): Linear(in_features=512, out_features=10, bias=True)
)
training begin
[epoch 1,imgs 12800] loss: 0.6906891 time: 5.284 s
[epoch 1,imgs 25600] loss: 0.4192125 time: 5.254 s
[epoch 1,imgs 38400] loss: 0.3470914 time: 5.261 s
[epoch 1,imgs 51200] loss: 0.3338268 time: 5.266 s
[epoch 2,imgs 12800] loss: 0.2725625 time: 5.286 s
[epoch 2,imgs 25600] loss: 0.2590218 time: 5.277 s
[epoch 2,imgs 38400] loss: 0.2629448 time: 5.273 s
[epoch 2,imgs 51200] loss: 0.2552892 time: 5.283 s
[epoch 3,imgs 12800] loss: 0.2204756 time: 5.299 s
[epoch 3,imgs 25600] loss: 0.2263550 time: 5.292 s
[epoch 3,imgs 38400] loss: 0.2150247 time: 5.294 s
[epoch 3,imgs 51200] loss: 0.2215548 time: 5.299 s
finish training
Accuracy of the network on the 10000 test images: 90 %
