一、Residual Network
论文出处：Deep Residual Learning for Image Recognition
其核心模块：
二、复现Residual Block
这里以两层卷积层为例进行设计复现
resnet可以很好的解决梯度消失问题
Residual Block大致要点：
样本x传入模型，分为两个分支，一个分支进行卷积层、relu层、卷积层、relu层；另一个分支中的x不变
最终两个分支通过相加操作结合到一块，最终再relu激活一次即可
1，数据集
老规矩，还使用MNIST手写数字数据集，详情可参考博文：九、多分类问题
import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F #为了使用relu激活函数
import torch.optim as optim batch_size = 64
transform = transforms.Compose([transforms.ToTensor(),#把图片变成张量形式transforms.Normalize((0.1307,),(0.3081,)) #均值和标准差进行数据标准化，这俩值都是经过整个样本集计算过的
])train_dataset = datasets.MNIST(root='./',train=True,download=True,transform = transform)
train_loader = DataLoader(train_dataset,shuffle=True,batch_size=batch_size)test_dataset = datasets.MNIST(root="./",train=False,download=True,transform=transform)
test_loader = DataLoader(test_dataset,shuffle=False,batch_size=batch_size)
2，测试数据集
这里以训练集中的第1个样本(train_dataset[0])为例进行测试
因为torch中卷积层传入参数格式需要为[B,C,W,H]形式，故通过x.view(-1,1,28,28)进行转换
卷积、relu、卷积、相加、relu
为了保证输入和输出特征大小保持一致，通过加边进行补充
x,y = train_dataset[0]
x.shape
"""
torch.Size([1, 28, 28])
"""
y
"""
5
"""
x = x.view(-1,1,28,28)
x.shape #[B,C,W,H]
"""
torch.Size([1, 1, 28, 28])
"""
channel = x.shape[1] #获取channel#定义Residual Block，无非就是卷积、relu、卷积、relu然后再相加
conv1 = torch.nn.Conv2d(channel,channel,kernel_size=3,padding=1)
conv2 = torch.nn.Conv2d(channel,channel,kernel_size=3,padding=1)conv_1 = conv1(x) #第一次卷积
conv_1.shape
"""
torch.Size([1, 1, 28, 28])
"""
relu_1 = F.relu(conv_1) #relu一下
relu_1.shape
"""
torch.Size([1, 1, 28, 28])
"""H = conv_2 + x
H.shape
"""
torch.Size([1, 1, 28, 28])
"""
final = F.relu(H)
final.shape
"""
torch.Size([1, 1, 28, 28])
"""
3，Residual Block完整模块代码
class y_res(torch.nn.Module):def __init__(self,channel):super(y_res,self).__init__()self.channels = channelself.conv1 = torch.nn.Conv2d(channel,channel,kernel_size=3,padding=1)self.conv2 = torch.nn.Conv2d(channel,channel,kernel_size=3,padding=1)def forward(self,x):conv_1 = self.conv1(x)relu_1 = F.relu(conv_1)conv_2 = self.conv2(relu_1)H = conv_2 + xfinal = F.relu(H)return finalx,y = train_dataset[0]
x = x.view(-1,1,28,28)
channel = x.shape[1]
yy_res = y_res(channel)
final = yy_res(x)
final.shape
"""
torch.Size([1, 1, 28, 28])
"""
三、现学现卖
按照下面的需求进行构建模型
①准备数据集
数据集使用MNIST手写数字数据集，详细可参考博文：十、CNN卷积神经网络实战
②加载数据集
import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F #为了使用relu激活函数
import torch.optim as optim batch_size = 64
transform = transforms.Compose([transforms.ToTensor(),#把图片变成张量形式transforms.Normalize((0.1307,),(0.3081,)) #均值和标准差进行数据标准化，这俩值都是经过整个样本集计算过的
])train_dataset = datasets.MNIST(root='./',train=True,download=True,transform = transform)
train_loader = DataLoader(train_dataset,shuffle=True,batch_size=batch_size)test_dataset = datasets.MNIST(root="./",train=False,download=True,transform=transform)
test_loader = DataLoader(test_dataset,shuffle=False,batch_size=batch_size)
③模型构建
残差网络模型架构还是使用上述的模型
class yy_net(torch.nn.Module):def __init__(self):super(yy_net,self).__init__()self.conv1 = torch.nn.Conv2d(1,16,kernel_size=5)self.conv2 = torch.nn.Conv2d(16,32,kernel_size=5)self.maxpool = torch.nn.MaxPool2d(2)self.resblock1 = y_res(16)self.resblock2 = y_res(32)self.linear = torch.nn.Linear(512,10)def forward(self,x):batch_size = x.shape[0] #[B,C,W,H]x = self.maxpool(F.relu(self.conv1(x)))x = self.resblock1(x)x = self.maxpool(F.relu(self.conv2(x)))x = self.resblock2(x)x = x.view(batch_size,-1)x = self.linear(x)return x
class y_res(torch.nn.Module):def __init__(self,channel):super(y_res,self).__init__()self.channels = channelself.conv1 = torch.nn.Conv2d(channel,channel,kernel_size=3,padding=1)self.conv2 = torch.nn.Conv2d(channel,channel,kernel_size=3,padding=1)def forward(self,x):conv_1 = self.conv1(x)relu_1 = F.relu(conv_1)conv_2 = self.conv2(relu_1)H = conv_2 + xfinal = F.relu(H)return final
④损失函数和优化器
lossf = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),lr=0.0001,momentum=0.5)⑤训练函数构建
def ytrain(epoch):loss_total = 0.0for batch_index ,data in enumerate(train_loader,0):x,y = data#x,y = x.to(device), y.to(device)#GPU加速optimizer.zero_grad()y_hat = model(x)loss = lossf(y_hat,y)loss.backward()optimizer.step()loss_total += loss.item()if batch_index % 300 == 299:# 每300epoch输出一次print("epoch:%d, batch_index:%5d \t loss:%.3f"%(epoch+1, batch_index+1, loss_total/300))loss_total = 0.0 #每次epoch都将损失清除⑥测试函数构建
def ytest():correct = 0#模型预测正确的数量total = 0#样本总数with torch.no_grad():#测试不需要梯度，减小计算量for data in test_loader:#读取测试样本数据images, labels = data#images, labels = images.to(device), labels.to(device) #GPU加速pred = model(images)#预测，每一个样本占一行，每行有十个值，后续需要求每一行中最大值所对应的下标pred_maxvalue, pred_maxindex = torch.max(pred.data,dim=1)#沿着第一个维度，一行一行来，去找每行中的最大值，返回每行的最大值和所对应下标total += labels.size(0)#labels是一个(N,1)的向量，对应每个样本的正确答案correct += (pred_maxindex == labels).sum().item()#使用预测得到的最大值的索引和正确答案labels进行比较，一致就是1，不一致就是0print("Accuracy on testset :%d %%"%(100*correct / total))#correct预测正确的样本个数 / 样本总数 * 100 = 模型预测正确率⑦主函数调用
if __name__ == '__main__':for epoch in range(10):#训练10次ytrain(epoch)#训练一次if epoch%10 == 9:ytest()#训练10次，测试1次
⑧完整代码
import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F #为了使用relu激活函数
import torch.optim as optim batch_size = 64
transform = transforms.Compose([transforms.ToTensor(),#把图片变成张量形式transforms.Normalize((0.1307,),(0.3081,)) #均值和标准差进行数据标准化，这俩值都是经过整个样本集计算过的
])train_dataset = datasets.MNIST(root='./',train=True,download=True,transform = transform)
train_loader = DataLoader(train_dataset,shuffle=True,batch_size=batch_size)test_dataset = datasets.MNIST(root="./",train=False,download=True,transform=transform)
test_loader = DataLoader(test_dataset,shuffle=False,batch_size=batch_size)class yy_net(torch.nn.Module):def __init__(self):super(yy_net,self).__init__()self.conv1 = torch.nn.Conv2d(1,16,kernel_size=5)self.conv2 = torch.nn.Conv2d(16,32,kernel_size=5)self.maxpool = torch.nn.MaxPool2d(2)self.resblock1 = y_res(16)self.resblock2 = y_res(32)self.linear = torch.nn.Linear(512,10)def forward(self,x):batch_size = x.shape[0]x = self.maxpool(F.relu(self.conv1(x)))x = self.resblock1(x)x = self.maxpool(F.relu(self.conv2(x)))x = self.resblock2(x)x = x.view(batch_size,-1)x = self.linear(x)return xclass y_res(torch.nn.Module):def __init__(self,channel):super(y_res,self).__init__()self.channels = channelself.conv1 = torch.nn.Conv2d(channel,channel,kernel_size=3,padding=1)self.conv2 = torch.nn.Conv2d(channel,channel,kernel_size=3,padding=1)def forward(self,x):conv_1 = self.conv1(x)relu_1 = F.relu(conv_1)conv_2 = self.conv2(relu_1)H = conv_2 + xfinal = F.relu(H)return finalmodel = yy_net()
lossf = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),lr=0.0001,momentum=0.5) def ytrain(epoch):loss_total = 0.0for batch_index ,data in enumerate(train_loader,0):x,y = data#x,y = x.to(device), y.to(device)#GPU加速optimizer.zero_grad()y_hat = model(x)loss = lossf(y_hat,y)loss.backward()optimizer.step()loss_total += loss.item()if batch_index % 300 == 299:# 每300epoch输出一次print("epoch:%d, batch_index:%5d \t loss:%.3f"%(epoch+1, batch_index+1, loss_total/300))loss_total = 0.0 #每次epoch都将损失清除def ytest():correct = 0#模型预测正确的数量total = 0#样本总数with torch.no_grad():#测试不需要梯度，减小计算量for data in test_loader:#读取测试样本数据images, labels = data#images, labels = images.to(device), labels.to(device) #GPU加速pred = model(images)#预测，每一个样本占一行，每行有十个值，后续需要求每一行中最大值所对应的下标pred_maxvalue, pred_maxindex = torch.max(pred.data,dim=1)#沿着第一个维度，一行一行来，去找每行中的最大值，返回每行的最大值和所对应下标total += labels.size(0)#labels是一个(N,1)的向量，对应每个样本的正确答案correct += (pred_maxindex == labels).sum().item()#使用预测得到的最大值的索引和正确答案labels进行比较，一致就是1，不一致就是0print("Accuracy on testset :%d %%"%(100*correct / total))#correct预测正确的样本个数 / 样本总数 * 100 = 模型预测正确率if __name__ == '__main__':for epoch in range(10):#训练10次ytrain(epoch)#训练一次if epoch%10 == 9:ytest()#训练10次，测试1次
![[JavaEE]----Spring03](https://img-blog.csdnimg.cn/abd888e6246e43fcb6a199e363d2300d.png)
