卷积神经网络（高级篇）
GoogleNet网络结构
GoogleNet常被用做基础主干网络，通过一些修改完成我们的需要。
在GoogleNet中把相同的块封装成一个类来减少代码冗余，如图中红色圈出的一个部分称为Inception块。
Inception Model
问题：构造神经网络时，超参数比较难选，比如kenel。
解决办法：把几种卷积都用一下，效果更好的卷积被赋予的权重会更大，自动找到最优卷积的组合，针对每一个卷积结果再进行求和。
-
concarenate： 把张量拼接起来，必须保证图像的宽度和高度是一致的。
-
Average Pooling 均值池化： 最大池化会导致图像变为原来的一半，均值池化可以人为指定padding 和 stride 来保证输入和输出的图像是一样的。
-
信息融合： 同一通道的值通过某种运算得到的信息。例如在考试中比较分数高低时是通过对各科分数乘以权重1求总分，因为在多个维度下不太好比较。
-
1*1卷积的作用
-
最主要目的就是改变通道的数量，减少运算量。卷积核的个数决定了输出的通道数，输入的通道数决定了卷积核的层数/通道个数。
运算量变成了原来的十分之一，大大提高了计算效率。
代码实现：
代码实现：
import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
import matplotlib.pyplot as plt
# 1、准备数据集
batch_size = 64
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])
train_dataset = datasets.MNIST(root='dataset/mnist',
train=True,
download=True,
transform=transform)
train_loader = DataLoader(dataset=train_dataset,
batch_size=batch_size,
shuffle=True)
test_dataset = datasets.MNIST(root='dataset/mnist',
train=False,
download=True,
transform=transform)
test_loader = DataLoader(dataset=test_dataset,
batch_size=batch_size,
shuffle=False)
# 2、建立模型
class Inception(torch.nn.Module):
def __init__(self, in_channels):
super().__init__()
self.branch1X1 = torch.nn.Conv2d(in_channels, 16, kernel_size=1)
self.branch5X5 = torch.nn.Conv2d(16, 24, kernel_size=5, padding=2)
self.branch3X3_1 = torch.nn.Conv2d(16, 24, kernel_size=3, padding=1)
self.branch3X3_2 = torch.nn.Conv2d(24, 24, kernel_size=3, padding=1)
self.branch_pool = torch.nn.Conv2d(in_channels, 24, kernel_size=1)
def forward(self, x):
branch1X1 = self.branch1X1(x)
branch5X5 = self.branch1X1(x)
branch5X5 = self.branch5X5(branch5X5)
branch3X3 = self.branch1X1(x)
branch3X3 = self.branch3X3_1(branch3X3)
branch3X3 = self.branch3X3_2(branch3X3)
branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
branch_pool = self.branch_pool(branch_pool)
outputs = [branch1X1, branch5X5, branch3X3, branch_pool]
# （b, c, w, h），dim=1——以第一个维度channel来拼接
return torch.cat(outputs, dim=1)
class Net(torch.nn.Module):
def __init__(self):
super().__init__()
self.conv1 = torch.nn.Conv2d(1, 10, kernel_size=5)
# # 88 = 24 + 16 + 24 + 24
self.conv2 = torch.nn.Conv2d(88, 20, kernel_size=5)
self.incep1 = Inception(in_channels=10)
self.incep2 = Inception(in_channels=20)
self.pooling = torch.nn.MaxPool2d(2)
# 1408：我们可以先不定义fc层，并将forward函数中return语句的前两句去掉，通过模型查看尺寸确定后在进行定义
self.fc = torch.nn.Linear(1408, 10)
def forward(self, x):
in_size = x.size(0) # x的第0维就是batch_size
x = F.relu(self.pooling(self.conv1(x)))
x = self.incep1(x)
x = F.relu(self.pooling(self.conv2(x)))
x = self.incep2(x)
x = x.view(in_size, -1)
x = self.fc(x)
return x
model = Net()
# 将模型迁移到GPU上运行，cuda:0表示第0块显卡
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# print(torch.cuda.is_available())
model.to(device)
# 3、建立损失函数和优化器
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)
# 4、定义训练函数
def train(epoch):
running_loss = 0
for batch_idx, data in enumerate(train_loader, 0):
inputs, target = data
# 将要计算的张量也迁移到GPU上——输入和输出
inputs, target = inputs.to(device), target.to(device)
optimizer.zero_grad()
# 前馈 反馈 更新
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
# 5、定义测试函数
accuracy = []
def test():
correct = 0
total = 0
with torch.no_grad():
for data in test_loader:
images, labels = data
# 测试中的张量也迁移到GPU上
images, labels = images.to(device), labels.to(device)
outputs = model(images)
_, predicted = torch.max(outputs.data, dim=1)
total += labels.size(0)
# 两个张量比较，得出的是其中相等的元素的个数（即一个批次中预测正确的个数）
correct += (predicted == labels).sum().item()
print('Accuracy on test set: %d %%' % (100 * correct / total))
accuracy.append(100 * correct / total)
if __name__ == '__main__':
for epoch in range(10):
train(epoch)
test()
print(accuracy)
plt.plot(range(10), accuracy)
plt.xlabel("epoch")
plt.ylabel("Accuracy")
plt.show()
Stack layer
**问题：**为什么网络层次更深反而准确率会下降，训练效果更差？
**梯度消失：**在反向传播时需要根据链式法则把一连串的梯度乘起来，若每个梯度都小于1，则乘起来的结果接近于0，导致权重在更新时没有什么变化。
**解决办法：**逐层训练，每一层加锁，但是深度学习中层数太多难以实现。
ResNet（Residual Network）
残差网络多一个跳连接，在做完卷积激活之前，将该层的输入加上输出一起作为整个的输出来激活。可解决梯度消失的问题。（要求经过两层的输出与输入的x 张量维度必须一样，即通道、高度、维度都必须一样）
Residual block
代码实现：
import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
import matplotlib.pyplot as plt
# 1、准备数据集
batch_size = 64
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])
train_dataset = datasets.MNIST(root='dataset/mnist',
train=True,
download=True,
transform=transform)
train_loader = DataLoader(dataset=train_dataset,
batch_size=batch_size,
shuffle=True)
test_dataset = datasets.MNIST(root='dataset/mnist',
train=False,
download=True,
transform=transform)
test_loader = DataLoader(dataset=test_dataset,
batch_size=batch_size,
shuffle=False)
# 2、建立模型
class ResidualBlock(torch.nn.Module):
def __init__(self, channels):
super().__init__()
self.channels = channels
self.conv1 = torch.nn.Conv2d(channels, channels, kernel_size=3, padding=1)
self.conv2 = torch.nn.Conv2d(channels, channels, kernel_size=3, padding=1)
def forward(self, x):
y = F.relu(self.conv1(x))
y = self.conv2(x)
return F.relu(x+y)
class Net(torch.nn.Module):
def __init__(self):
super().__init__()
self.conv1 = torch.nn.Conv2d(1, 16, kernel_size=5)
self.conv2 = torch.nn.Conv2d(16, 32, kernel_size=5)
self.pooling = torch.nn.MaxPool2d(2)
self.rblock1 = ResidualBlock(16)
self.rblock2 = ResidualBlock(32)
self.fc = torch.nn.Linear(512, 10)
def forward(self, x):
in_size = x.size(0) # x的第0维就是batch_size
x = self.pooling(F.relu(self.conv1(x)))
x = self.rblock1(x)
x = self.pooling(F.relu(self.conv2(x)))
x = self.rblock2(x)
x = x.view(in_size, -1)
x = self.fc(x)
return x
model = Net()
# 将模型迁移到GPU上运行，cuda:0表示第0块显卡
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# print(torch.cuda.is_available())
model.to(device)
# 3、建立损失函数和优化器
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)
# 4、定义训练函数
def train(epoch):
running_loss = 0
for batch_idx, data in enumerate(train_loader, 0):
inputs, target = data
# 将要计算的张量也迁移到GPU上——输入和输出
inputs, target = inputs.to(device), target.to(device)
optimizer.zero_grad()
# 前馈 反馈 更新
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
# 5、定义测试函数
accuracy = []
def test():
correct = 0
total = 0
with torch.no_grad():
for data in test_loader:
images, labels = data
# 测试中的张量也迁移到GPU上
images, labels = images.to(device), labels.to(device)
outputs = model(images)
_, predicted = torch.max(outputs.data, dim=1)
total += labels.size(0)
# 两个张量比较，得出的是其中相等的元素的个数（即一个批次中预测正确的个数）
correct += (predicted == labels).sum().item()
print('Accuracy on test set: %d %%' % (100 * correct / total))
accuracy.append(100 * correct / total)
if __name__ == '__main__':
for epoch in range(10):
train(epoch)
test()
print(accuracy)
plt.plot(range(10), accuracy)
plt.xlabel("epoch")
plt.ylabel("Accuracy")
plt.show()
作业：
作业1：阅读论文Identity Mappings in Deep Residual Networks
该论文给出了很多residual block实现的方式。
实现constant scaling
class ResidualBlock(nn.Module):
def __init__(self, channels):
super().__init__()
self.channels = channels
self.conv1 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)
def forward(self, x):
y = F.relu(self.conv1(x))
y = self.conv2(x)
z = 0.5 * (x + y)
return F.relu(z)
实现conv sortcut
class ResidualBlock(nn.Module):
def __init__(self, channels):
super().__init__()
self.channels = channels
self.conv1 = nn.Conv2d(channels, channels,
kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(channels, channels,
kernel_size=3, padding=1)
self.conv3 = nn.Conv2d(channels, channels,
kernel_size=1)
def forward(self, x):
y = F.relu(self.conv1(x))
y = self.conv2(x)
z = self.conv3(x) + y
return F.relu(z)
作业2：阅读论文 Densely Connected Convolutional Networks
建议学习流程
- 学习理论知识（《深度学习》花书）
- 阅读PyTorch文档（至少通读一遍）
- 复现经典之作（先读代码、再自己写代码）
- 选特定领域进行研究，融会贯通，扩充视野，广泛阅读
414
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
