基于python实现resnet_小黑的Python日记：Pytorch简单实现ResNet18
大噶好啊，我系小黑喵
论文笔记
1.F(x)=H(x)-x(优化残差F(x)更容易解决梯度问题和退化问题)
2.Residual Learning:
Residual Block
example
3.y = F(x,{Wi}) + Ws·x(Shortcuts Ws可以将x映射为和y同一dimension)
4.结构：
Resnet Architectures
代码
###author:xiaoheimiao
import torch
import torchvision
import matplotlib.pyplot as plt
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torchvision.transforms import transforms
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
#定义make_layer
def make_layer(in_channel, out_channel, block_num, stride=1):
shortcut = nn.Sequential(
nn.Conv2d(in_channel, out_channel, 1, stride),
nn.BatchNorm2d(out_channel))
layers = list()
layers.append(ResBlock(in_channel, out_channel, stride, shortcut))
for i in range(1, block_num):
layers.append(ResBlock(out_channel, out_channel))
return nn.Sequential(*layers)
#定义ResBlock，见Resnet Learning图
class ResBlock(nn.Module):
def __init__(self, in_channel, out_channel, stride=1, shortcut=None):
super(ResBlock, self).__init__()
self.left = nn.Sequential(
nn.Conv2d(in_channel, out_channel, 3, stride, 1, bias=False),
nn.BatchNorm2d(out_channel),
nn.ReLU(True),
nn.Conv2d(out_channel, out_channel, 3, 1, 1, bias=False),
nn.BatchNorm2d(out_channel),
)
self.right = shortcut
def forward(self, x):
out = self.left(x)
residual = x if self.right is None else self.right(x)
out += residual
return F.relu(out)
# 堆叠Resnet，见上表所示结构
class Resnet(nn.Module):
def __init__(self):
super(Resnet, self).__init__()
self.pre = nn.Sequential(
nn.Conv2d(3, 64, 7, 2, 3, bias=False), nn.BatchNorm2d(64),
nn.ReLU(True), nn.MaxPool2d(3, 2, 1))
self.layer1 = make_layer(64, 64, 2)
self.layer2 = make_layer(64, 128, 2, stride=2)
self.layer3 = make_layer(128, 256, 2, stride=2)
self.layer4 = make_layer(256, 512, 2, stride=2)
self.avg = nn.AvgPool2d(7)
self.classifier = nn.Sequential(nn.Linear(512, 10))
def forward(self, x):
x = self.pre(x)
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
x = self.layer4(x)
x = self.avg(x)
x = x.view(x.size(0), -1)
out = self.classifier(x)
return out
#训练函数
def net_train():
net.train()
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# 将输入传入GPU
inputs, labels = data
inputs, labels = inputs.to(device), labels.to(device)
# 将梯度置零
optimizer.zero_grad()
# 前向传播-计算误差-反向传播-优化
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# 计算误差并显示
running_loss += loss.item()
if i % 127 == 0: # print every mini-batches
print(
'[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 128))
running_loss = 0.0
print('Training Epoch Finished')
#测试函数
def net_test():
correct = 0
total = 0
# 关闭梯度
with torch.no_grad():
for data in testloader:
images, labels = data
images, labels = images.to(device), labels.to(device)
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print('Accuracy of the network on the 10000 test images: %d %%' %
(100 * correct / total))
return
#数据集函数
def net_dataloader(root, train_transform, test_transform):
trainset = torchvision.datasets.CIFAR10(
root, train=True, transform=train_transform, download=False)
testset = torchvision.datasets.CIFAR10(
root, train=False, transform=test_transform, download=False)
trainloader = DataLoader(
trainset, batch_size=128, shuffle=True, num_workers=4)
testloader = DataLoader(
testset, batch_size=16, shuffle=False, num_workers=4)
print('Initializing Dataset...')
return trainloader, testloader
# main
if __name__ == "__main__":
# 创建实例并送入GPU
net = Resnet().to(device)
# 选择误差
criterion = nn.CrossEntropyLoss()
# 选择优化器
optimizer = torch.optim.Adam(net.parameters(), lr=1e-3)
# 数据位置
root = './pydata/data/'
# 数据处理
train_transform = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
test_transform = transforms.Compose([
transforms.Resize(224),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
# 创建数据loader
trainloader, testloader = net_dataloader(root, train_transform,
test_transform)
# run
n_epoch = 5 #改变epoch
for epoch in range(n_epoch):
print('Training...')
net_train() #每个epoch训练一次，测试一次
print('Testing...')
net_test()
大约18个epoch就有85%准确率啦！
Training