北京网站优化方法,免费咨询服务期,报名网站建设定做,体验营销是什么CNN原理
从DNN到CNN
卷积层与汇聚
深度神经网络DNN中#xff0c;相邻层的所有神经元之间都有连接#xff0c;这叫全连接#xff1b;卷积神经网络 CNN 中#xff0c;新增了卷积层#xff08;Convolution#xff09;与汇聚#xff08;Pooling#xff09;。DNN 的全连接…CNN原理
从DNN到CNN
卷积层与汇聚
深度神经网络DNN中相邻层的所有神经元之间都有连接这叫全连接卷积神经网络 CNN 中新增了卷积层Convolution与汇聚Pooling。DNN 的全连接层对应 CNN 的卷积层汇聚是与激活函数类似的附件单个卷积层的结构是卷积层-激活函数-(汇聚)其中汇聚可省略。
2.CNN专攻多维数据 在深度神经网络 DNN 课程的最后一章使用 DNN 进行了手写数字的识别。但是图像至少就有二维向全连接层输入时需要多维数据拉平为 1 维数据这样一来图像的形状就被忽视了很多特征是隐藏在空间属性里的如下图所示。 而卷积层可以保持输入数据的维数不变当输入数据是二维图像时卷积层会以多维数据的形式接收输入数据并同样以多维数据的形式输出至下一层如下图所示。
卷积层
CNN 中的卷积层与 DNN 中的全连接层是平级关系全连接层中的权重与偏置即y ω1x1 ω2x2 ω3x3 b中的 ω 与 b卷积层中的权重与偏置变得稍微复杂。 内部参数权重卷积核 当输入数据进入卷积层后输入数据会与卷积核进行卷积运算如下图 上图中的输入大小是4,4卷积核大小事3,3输出大小是2,2卷积运算的原理是逐元素乘积后再相加。 内部参数偏置 在卷积运算的过程中也存在偏置如下图所示 外部参数补充 为了防止经过多个卷积层后图像越卷越小可以在进行卷积层的处理之前向输入数据的周围填入固定的数据比如 0这称为填充padding。 对上图大小为(4, 4)的输入数据应用了幅度为 1 的填充填充值为 0。 外部参数步幅 使用卷积核的位置间隔被称为步幅stride之前的例子中步幅都是 1如果将步幅设为 2此时使用卷积核的窗口的间隔变为 2。 综上增大填充后输出尺寸会变大而增大步幅后输出尺寸会变小 输入与输出尺寸的关系 假设输入尺寸为(H, W)卷积核的尺寸为(FH, FW)填充为 P步幅为 S。则输出尺寸(OH, OW)的计算公式为
多通道
在上一小节讲的卷积层仅仅针对二维的输入与输出数据一般是灰度图像可称之为单通道。 但是彩色图像除了高、长两个维度之外还有第三个维度通道channel。例如以 RGB 三原色为基础的彩色图像其通道方向就有红、黄、蓝三部分可视为 3 个单通道二维图像的混合叠加。一般的当输入数据是二维时权重被称为卷积核Kernel当输入数据是三维或更高时权重被称为滤波器Filter。
1.多通道输入 对三维数据的卷积操作如图 1-8 所示输入数据与滤波器的通道数必须要设为相同的值可以发现这种情况下的输出结果降级为了二维 将数据和滤波器看作长方体如图 1-9 所示 C、H、W 是固定的顺序通道数要写在高与宽的前面 图 1-9 可看出仅通过一个卷积层三维就被降成二维了。大多数时候我们想让三维的特征多经过几个卷积层因此就需要多通道输出如图 1-10 所示。 别忘了卷积运算中存在偏置如果进一步追加偏置的加法运算处理则结果如图 1-11 所示每个通道都有一个单独的偏置。
汇聚很多教材也叫做池化
汇聚Pooling仅仅是从一定范围内提取一个特征值所以不存在要学习的内部参数。一般有平均汇聚与最大值汇聚。 平均汇聚 一个以步幅为2进行的2*2窗口的平均汇聚如图1-12所示 最大值汇聚 一个以步幅为 2 进行 2*2 窗口的最大值汇聚如图 1-13 所示 汇聚对图像的高 H 和宽 W 进行特征提取不改变通道数 C。
尺寸变换总结
卷积层 现假设卷积层的填充为P步幅为S由
输入数据的尺寸是( CHW) 。滤波器的尺寸是FNCFHFW。输出数据的尺寸是(FNOHOW) 。
可得 2. 汇聚 现假设汇聚的步幅为 S由
输入数据的尺寸是( CHW) 。输出数据的尺寸是(COHOW) 。
可得
LeNet-5
网络结构
LeNet-5 虽诞生于 1998 年但基于它的手写数字识别系统则非常成功。 该网络共 7 层输入图像尺寸为 28×28输出则是 10 个神经元分别表示某手写数字是 0 至 9 的概率。 PS:输出层由 10 个径向基函数 RBF 组成用于归一化最终的结果目前RBF 已被 Softmax 取代。 根据网络结构在 PyTorch 的 nn.Sequential 中编写为
self.net nn.Sequential(nn.Conv2d(1, 6, kernel_size5, padding2), nn.Tanh(), # C1卷积层nn.AvgPool2d(kernel_size2, stride2), # S2平均汇聚nn.Conv2d(6, 16, kernel_size5), nn.Tanh(), # C3卷积层nn.AvgPool2d(kernel_size2, stride2), # S4平均汇聚nn.Conv2d(16, 120, kernel_size5), nn.Tanh(), # C5卷积层nn.Flatten(), # 把图像铺平成一维nn.Linear(120, 84), nn.Tanh(), # F5全连接层nn.Linear(84, 10) # F6全连接层
)其中nn.Conv2d( )需要四个参数分别为
in_channel此层输入图像的通道数out_channel此层输出图像的通道数kernel_size卷积核尺寸padding填充stride步幅。
制作数据集
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasets
import matplotlib.pyplot as plt
%matplotlib inline# 展示高清图
from matplotlib_inline import backend_inline
backend_inline.set_matplotlib_formats(svg)# 制作数据集
# 数据集转换参数
transform transforms.Compose([transforms.ToTensor(), transforms.Normalize(0.1307, 0.3081)
])
# 下载训练集与测试集
train_Data datasets.MNIST(root D:/Jupyter/dataset/mnist/, # 下载路径train True, # 是 train 集download True, # 如果该路径没有该数据集就下载transform transform # 数据集转换参数
)
test_Data datasets.MNIST(root D:/Jupyter/dataset/mnist/, # 下载路径train False, # 是 test 集download True, # 如果该路径没有该数据集就下载transform transform # 数据集转换参数
)# 批次加载器
train_loader DataLoader(train_Data, shuffleTrue, batch_size256)
test_loader DataLoader(test_Data, shuffleFalse, batch_size256)搭建神经网络
class CNN(nn.Module):def __init__(self):super(CNN,self).__init__()self.net nn.Sequential(nn.Conv2d(1, 6, kernel_size5, padding2), nn.Tanh(),nn.AvgPool2d(kernel_size2, stride2),nn.Conv2d(6, 16, kernel_size5), nn.Tanh(),nn.AvgPool2d(kernel_size2, stride2),nn.Conv2d(16, 120, kernel_size5), nn.Tanh(),nn.Flatten(),nn.Linear(120, 84), nn.Tanh(),nn.Linear(84, 10))def forward(self, x):y self.net(x)return y# 查看网络结构
X torch.rand(size (1, 1, 28, 28))
for layer in CNN().net:X layer(X)print( layer.__class__.__name__, output shape: \t, X.shape )# 创建子类的实例并搬到 GPU 上
model CNN().to(cuda:0)训练网络
# 损失函数的选择
loss_fn nn.CrossEntropyLoss() # 自带 softmax 激活函数# 优化算法的选择
learning_rate 0.9 # 设置学习率
optimizer torch.optim.SGD(model.parameters(),lr learning_rate,
)# 训练网络
epochs 5
losses [] # 记录损失函数变化的列表
for epoch in range(epochs):for (x, y) in train_loader: # 获取小批次的 x 与 yx, y x.to(cuda:0), y.to(cuda:0)Pred model(x) # 一次前向传播小批量loss loss_fn(Pred, y) # 计算损失函数losses.append(loss.item()) # 记录损失函数的变化optimizer.zero_grad() # 清理上一轮滞留的梯度loss.backward() # 一次反向传播optimizer.step() # 优化内部参数
Fig plt.figure()
plt.plot(range(len(losses)), losses)
plt.show()测试网络
# 测试网络
correct 0
total 0
with torch.no_grad(): # 该局部关闭梯度计算功能for (x, y) in test_loader: # 获取小批次的 x 与 yx, y x.to(cuda:0), y.to(cuda:0)Pred model(x) # 一次前向传播小批量_, predicted torch.max(Pred.data, dim1)correct torch.sum( (predicted y) )total y.size(0) print(f测试集精准度: {100*correct/total} %) #OUT:测试集精准度: 9.569999694824219 %AlexNet
网络结构
AlexNet 是第一个现代深度卷积网络模型其首次使用了很多现代网络的技术方法作为 2012 年 ImageNet 图像分类竞赛冠军输入为 3×224×224 的图像输出为 1000 个类别的条件概率。 考虑到如果使用 ImageNet 训练集会导致训练时间过长这里使用稍低亿档的 1×28×28 的 MNIST 数据集并手动将其分辨率从 1×28×28 提到 1×224×224同时输出从 1000 个类别降到 10 个修改后的网络结构见下表。 根据网络结构在 PyTorch 的 nn.Sequential 中编写为
self.net nn.Sequential(nn.Conv2d(1, 96, kernel_size11, stride4, padding1), nn.ReLU(),nn.MaxPool2d(kernel_size3, stride2),nn.Conv2d(96, 256, kernel_size5, padding2), nn.ReLU(),nn.MaxPool2d(kernel_size3, stride2),nn.Conv2d(256, 384, kernel_size3, padding1), nn.ReLU(),nn.Conv2d(384, 384, kernel_size3, padding1), nn.ReLU(),nn.Conv2d(384, 256, kernel_size3, padding1), nn.ReLU(),nn.MaxPool2d(kernel_size3, stride2),nn.Flatten(),nn.Linear(6400, 4096), nn.ReLU(),nn.Dropout(p0.5), # Dropout——随机丢弃权重nn.Linear(4096, 4096), nn.ReLU(),nn.Dropout(p0.5), # 按概率 p 随机丢弃突触nn.Linear(4096, 10)
)制作数据集
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasets
import matplotlib.pyplot as plt
%matplotlib inline# 展示高清图
from matplotlib_inline import backend_inline
backend_inline.set_matplotlib_formats(svg)# 制作数据集
# 数据集转换参数
transform transforms.Compose([transforms.ToTensor(),transforms.Resize(224),transforms.Normalize(0.1307, 0.3081)
])
# 下载训练集与测试集
train_Data datasets.FashionMNIST(root D:/Jupyter/dataset/mnist/,train True,download True,transform transform
)
test_Data datasets.FashionMNIST(root D:/Jupyter/dataset/mnist/,train False,download True,transform transform
)# 批次加载器
train_loader DataLoader(train_Data, shuffleTrue, batch_size128)
test_loader DataLoader(test_Data, shuffleFalse, batch_size128)搭建神经网络
class CNN(nn.Module):def __init__(self):super(CNN,self).__init__()self.net nn.Sequential(nn.Conv2d(1, 96, kernel_size11, stride4, padding1),nn.ReLU(),nn.MaxPool2d(kernel_size3, stride2),nn.Conv2d(96, 256, kernel_size5, padding2),nn.ReLU(),nn.MaxPool2d(kernel_size3, stride2),nn.Conv2d(256, 384, kernel_size3, padding1),nn.ReLU(),nn.Conv2d(384, 384, kernel_size3, padding1),nn.ReLU(),nn.Conv2d(384, 256, kernel_size3, padding1),nn.ReLU(),nn.MaxPool2d(kernel_size3, stride2),nn.Flatten(),nn.Linear(6400, 4096), nn.ReLU(),nn.Dropout(p0.5),nn.Linear(4096, 4096), nn.ReLU(),nn.Dropout(p0.5),nn.Linear(4096, 10))def forward(self, x):y self.net(x)return y# 查看网络结构
X torch.rand(size (1, 1, 224, 224))
for layer in CNN().net:X layer(X)print( layer.__class__.__name__, output shape: \t, X.shape )# 创建子类的实例并搬到 GPU 上
model CNN().to(cuda:0)训练网络
# 损失函数的选择
loss_fn nn.CrossEntropyLoss() # 自带 softmax 激活函数# 优化算法的选择
learning_rate 0.1 # 设置学习率
optimizer torch.optim.SGD(model.parameters(),lr learning_rate,
)# 训练网络
epochs 10
losses [] # 记录损失函数变化的列表
for epoch in range(epochs):for (x, y) in train_loader: # 获取小批次的 x 与 yx, y x.to(cuda:0), y.to(cuda:0)Pred model(x) # 一次前向传播小批量loss loss_fn(Pred, y) # 计算损失函数losses.append(loss.item()) # 记录损失函数的变化optimizer.zero_grad() # 清理上一轮滞留的梯度loss.backward() # 一次反向传播optimizer.step() # 优化内部参数
Fig plt.figure()
plt.plot(range(len(losses)), losses)
plt.show()测试网络
# 测试网络
correct 0
total 0
with torch.no_grad(): # 该局部关闭梯度计算功能for (x, y) in test_loader: # 获取小批次的 x 与 yx, y x.to(cuda:0), y.to(cuda:0)Pred model(x) # 一次前向传播小批量_, predicted torch.max(Pred.data, dim1)correct torch.sum( (predicted y) )total y.size(0)
print(f测试集精准度: {100*correct/total} %)GoogLeNet
网络结构
2014 年获得 ImageNet 图像分类竞赛的冠军是 GoogLeNet其解决了一个重要问题滤波器超参数选择困难如何能够自动找到最佳的情况。 其在网络中引入了一个小网络——Inception 块由 4 条并行路径组成4 条路径互不干扰。这样一来超参数最好的分支的那条分支其权重会在训练过程中不断增加这就类似于帮我们挑选最佳的超参数如示例所示。
# 一个 Inception 块
class Inception(nn.Module):def __init__(self, in_channels):super(Inception, self).__init__()self.branch1 nn.Conv2d(in_channels, 16, kernel_size1)self.branch2 nn.Sequential(nn.Conv2d(in_channels, 16, kernel_size1),nn.Conv2d(16, 24, kernel_size3, padding1),nn.Conv2d(24, 24, kernel_size3, padding1))self.branch3 nn.Sequential(nn.Conv2d(in_channels, 16, kernel_size1),nn.Conv2d(16, 24, kernel_size5, padding2))self.branch4 nn.Conv2d(in_channels, 24, kernel_size1)def forward(self, x):branch1 self.branch1(x)branch2 self.branch2(x)branch3 self.branch3(x)branch4 self.branch4(x)outputs [branch1, branch2, branch3, branch4]return torch.cat(outputs, 1)此外分支 2 和分支 3 上增加了额外 1×1 的滤波器这是为了减少通道数降低模型复杂度。 GoogLeNet 之所以叫 GoogLeNet是为了向 LeNet 致敬其网络结构为
class CNN(nn.Module):def __init__(self):super(CNN, self).__init__()self.net nn.Sequential(nn.Conv2d(1, 10, kernel_size5), nn.ReLU(),nn.MaxPool2d(kernel_size2, stride2),Inception(in_channels10),nn.Conv2d(88, 20, kernel_size5), nn.ReLU(),nn.MaxPool2d(kernel_size2, stride2),Inception(in_channels20),nn.Flatten(),nn.Linear(1408, 10) )def forward(self, x):y self.net(x)return y制作数据集
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasets
import matplotlib.pyplot as plt
%matplotlib inline# 展示高清图
from matplotlib_inline import backend_inline
backend_inline.set_matplotlib_formats(svg)# 制作数据集
# 数据集转换参数
transform transforms.Compose([transforms.ToTensor(),transforms.Normalize(0.1307, 0.3081)
])
# 下载训练集与测试集
train_Data datasets.FashionMNIST(root D:/Jupyter/dataset/mnist/,train True,download True,transform transform
)
test_Data datasets.FashionMNIST(root D:/Jupyter/dataset/mnist/,train False,download True,transform transform
)# 批次加载器
train_loader DataLoader(train_Data, shuffleTrue, batch_size128)
test_loader DataLoader(test_Data, shuffleFalse, batch_size128)搭建神经网络
# 一个 Inception 块
class Inception(nn.Module):def __init__(self, in_channels):super(Inception, self).__init__()self.branch1 nn.Conv2d(in_channels, 16, kernel_size1)self.branch2 nn.Sequential(nn.Conv2d(in_channels, 16, kernel_size1),nn.Conv2d(16, 24, kernel_size3, padding1),nn.Conv2d(24, 24, kernel_size3, padding1))self.branch3 nn.Sequential(nn.Conv2d(in_channels, 16, kernel_size1),nn.Conv2d(16, 24, kernel_size5, padding2))self.branch4 nn.Conv2d(in_channels, 24, kernel_size1)def forward(self, x):branch1 self.branch1(x)branch2 self.branch2(x)branch3 self.branch3(x)branch4 self.branch4(x)outputs [branch1, branch2, branch3, branch4]return torch.cat(outputs, 1)class CNN(nn.Module):def __init__(self):super(CNN, self).__init__()self.net nn.Sequential(nn.Conv2d(1, 10, kernel_size5), nn.ReLU(),nn.MaxPool2d(kernel_size2, stride2),Inception(in_channels10),nn.Conv2d(88, 20, kernel_size5), nn.ReLU(),nn.MaxPool2d(kernel_size2, stride2),Inception(in_channels20),nn.Flatten(),nn.Linear(1408, 10))def forward(self, x):y self.net(x) return y# 查看网络结构
X torch.rand(size (1, 1, 28, 28))
for layer in CNN().net:X layer(X)print( layer.__class__.__name__, output shape: \t, X.shape )# 创建子类的实例并搬到 GPU 上
model CNN().to(cuda:0)训练网络
# 损失函数的选择
loss_fn nn.CrossEntropyLoss()# 优化算法的选择
learning_rate 0.1 # 设置学习率
optimizer torch.optim.SGD(model.parameters(),lr learning_rate,
)# 训练网络
epochs 10
losses [] # 记录损失函数变化的列表
for epoch in range(epochs):for (x, y) in train_loader: # 获取小批次的 x 与 yx, y x.to(cuda:0), y.to(cuda:0)Pred model(x) # 一次前向传播小批量loss loss_fn(Pred, y) # 计算损失函数losses.append(loss.item()) # 记录损失函数的变化optimizer.zero_grad() # 清理上一轮滞留的梯度loss.backward() # 一次反向传播optimizer.step() # 优化内部参数
Fig plt.figure()
plt.plot(range(len(losses)), losses)
plt.show()测试网络
# 测试网络
correct 0
total 0
with torch.no_grad(): # 该局部关闭梯度计算功能for (x, y) in test_loader: # 获取小批次的 x 与 yx, y x.to(cuda:0), y.to(cuda:0)Pred model(x) # 一次前向传播小批量_, predicted torch.max(Pred.data, dim1)correct torch.sum( (predicted y) )total y.size(0)print(f测试集精准度: {100*correct/total} %)ResNet
网络结构
残差网络Residual NetworkResNet荣获 2015 年的 ImageNet 图像分类竞赛冠军其可以缓解深度神经网络中增加深度带来的“梯度消失”问题。 在反向传播计算梯度时梯度是不断相乘的假如训练到后期各层的梯度均小于 1则其相乘起来就会不断趋于 0。因此深度学习的隐藏层并非越多越好隐藏层越深梯度越趋于 0此之谓“梯度消失”。
制作数据集
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasets
import matplotlib.pyplot as plt
%matplotlib inline# 展示高清图
from matplotlib_inline import backend_inline
backend_inline.set_matplotlib_formats(svg)# 制作数据集
# 数据集转换参数
transform transforms.Compose([transforms.ToTensor(),transforms.Normalize(0.1307, 0.3081)
])
# 下载训练集与测试集
train_Data datasets.FashionMNIST(root D:/Jupyter/dataset/mnist/,train True,download True,transform transform
)
test_Data datasets.FashionMNIST(root D:/Jupyter/dataset/mnist/,train False,download True,transform transform
)# 批次加载器
train_loader DataLoader(train_Data, shuffleTrue, batch_size128)
test_loader DataLoader(test_Data, shuffleFalse, batch_size128)搭建神经网络
# 残差块
class ResidualBlock(nn.Module):def __init__(self, channels):super(ResidualBlock, self).__init__()self.net nn.Sequential(nn.Conv2d(channels, channels, kernel_size3, padding1),nn.ReLU(),nn.Conv2d(channels, channels, kernel_size3, padding1),)def forward(self, x):y self.net(x)return nn.functional.relu(xy)class CNN(nn.Module):def __init__(self):super(CNN, self).__init__()self.net nn.Sequential(nn.Conv2d(1, 16, kernel_size5), nn.ReLU(),nn.MaxPool2d(2), ResidualBlock(16),nn.Conv2d(16, 32, kernel_size5), nn.ReLU(),nn.MaxPool2d(2), ResidualBlock(32),nn.Flatten(),nn.Linear(512, 10))def forward(self, x):y self.net(x) return y# 查看网络结构
X torch.rand(size (1, 1, 28, 28))for layer in CNN().net:X layer(X)print( layer.__class__.__name__, output shape: \t, X.shape )# 创建子类的实例并搬到 GPU 上
model CNN().to(cuda:0)训练网络
# 损失函数的选择
loss_fn nn.CrossEntropyLoss()# 优化算法的选择
learning_rate 0.1 # 设置学习率
optimizer torch.optim.SGD(model.parameters(),lr learning_rate,
)# 训练网络
epochs 10
losses [] # 记录损失函数变化的列表
for epoch in range(epochs):for (x, y) in train_loader: # 获取小批次的 x 与 yx, y x.to(cuda:0), y.to(cuda:0)Pred model(x) # 一次前向传播小批量loss loss_fn(Pred, y) # 计算损失函数losses.append(loss.item()) # 记录损失函数的变化optimizer.zero_grad() # 清理上一轮滞留的梯度loss.backward() # 一次反向传播optimizer.step() # 优化内部参数
Fig plt.figure()
plt.plot(range(len(losses)), losses)
plt.show()测试网络
# 测试网络
correct 0
total 0
with torch.no_grad(): # 该局部关闭梯度计算功能for (x, y) in test_loader: # 获取小批次的 x 与 yx, y x.to(cuda:0), y.to(cuda:0)Pred model(x) # 一次前向传播小批量_, predicted torch.max(Pred.data, dim1)correct torch.sum( (predicted y) )total y.size(0)
print(f测试集精准度: {100*correct/total} %)
