visual and CNN
边缘检测
比如对于6x6的灰度图像：构造3x3的filter（滤波器（卷积核））
向右移动步长为1，直到边界，再回到起点，向下移动一步
为什么可以做边缘检测：
右侧4x4矩阵中间的白色区域就包含了6x6矩阵的垂直边缘
可以用神经网络反向传播来训练出比较好的滤波器矩阵参数选择
padding
卷积后的输出矩阵大小公式：(n-f+1)x(n-f+1)
为了不让图像卷积后逐渐变小
图像矩阵的边缘元素被处理（被卷积的次数）次数少，边缘元素信息丢失较多
所以可以在卷积前填充图像：
0填充，
p = 1代表补充一圈->(n+2p-f+1)x(n+2p-f+1) == 新的输出
填充多少：
（1）Valid：不填充
（2）Same：使得输入输出的大小相同 --> p = (f-1)/2
卷积核矩阵fxf：f通常为奇数，这样可以填充四周（偶数填充）
strided步长
最终的矩阵：(n+2p-f)/s+1
如果不为整数则向下取整
在数学中通常卷积前，还会将卷积核沿垂直和水平方向翻转
三维卷积
卷积层（通道，宽度，高度都可能会变）
滤波器的通道数量必须和图片的通道数量相同
如果想检验红色通道的边缘可以将卷积核第二三通道设置为全0
如果需要检测多个边缘，同时使用多个滤波器
神经网络+卷积
滤波器类似普通前馈神经网络中的w0xa[0]
卷积核的数量为特征数量
如果有十个3x3x3滤波器则总共有280个参数（包括10个bias）
deep Convnet
卷积层，池化层，全连接层
池化层
池化（下采样，通道数不变，高度宽度可能会变）
max pooling 最大池化
步长为2的：
最大化运算：如果在滤波器中提取到某个特征，那么保留其最大值
最大池化提升效率的原因：减少数据的数据量,降低运算需求
池化层有若干超参数（f，s）
也是(n+2p-f)/s+1向下取整
平均池化层：average pooling
输入输出层数相同
卷积神经网络
要明确输入张量大小和最后要的输出的大小
进行维度和大小的变换
卷积的运算过程
例如3通道图像和一组通道3的卷积核运算，得到一个通道的结果
卷积核的组数即为最后得到的通道数，一组卷积核中的卷积核个数应该与输入的图像通道数相同
对应元素的数乘
import torch
in_channels,out_channels = 5,10
w,h = 100,100
kernel_size = 3
batch_size = 1
input = torch.randn(batch_size,in_channels,w,h)
conv_layer = torch.nn.Conv2d(in_channels,out_channels,kernel_size=kernel_size)
outputs = conv_layer(input)
print(input.shape)
print(outputs.shape)
print(conv_layer.weight.shape)
#10个卷积组，每个卷积组维5x3x3（五通道）
# 初始化卷积层可以设置很多参数，但是必须设置的是输入输出通道数核卷积核大小
torch.Size([1, 5, 100, 100])
torch.Size([1, 10, 98, 98])
torch.Size([10, 5, 3, 3])
卷积层中的多输入多输出通道
每个通道都有一个卷积核，结果是所有通道卷积结果的和
多个输出通道
无论有多少输入通道，我们可以有多个三维卷积核，每个核生成一个输出通道
每个卷积核对应的输出通道可以识别特定的模式
下一层的输入通道识别并组合输入中的模式
padding
stride步长
下采样最大池化层
没有权重
1x1卷积
不识别空间模式，只是融合通道（一个像素的多通道加权和）
pytorch实现两个卷积层的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='../dataset/mnist/',
train=True,download=False,
transform=transform)
test_dataset = datasets.MNIST(root='../dataset/mnist/',
train=False,download=False,
transform=transform)
train_loader = DataLoader(train_dataset,
shuffle=True,
batch_size=batch_size)
test_loader = DataLoader(test_dataset,
shuffle=True,
batch_size=batch_size)
# 定义神经网络模型类，继承自torch.nn.Module
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
# 定义第一个卷积层，输入通道为1（灰度图像），输出通道为10，卷积核大小为5
self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
# 定义第二个卷积层，输入通道为10，输出通道为20，卷积核大小为5
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
# 定义最大池化层，池化窗口大小为2
self.pooling = nn.MaxPool2d(2)
# 定义全连接层，输入大小为320，输出大小为10
self.fc = nn.Linear(320, 10)
# 定义前向传播函数
def forward(self, x):
batch_size = x.size(0) # 获取输入的批量大小
x = F.relu(self.pooling(self.conv1(x)))
x = F.relu(self.pooling(self.conv2(x)))
x = x.view(batch_size, -1) # 将张量展平为一维
x = self.fc(x) # 全连接层
return x
# 创建模型实例
model = Net()
# -----------------------------------------------------------
# 如果要使用GPU
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model.to(device)#模型权重迁移到gpu
# -----------------------------------------------------------
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),lr=0.01,momentum=0.5)
def train(epoch):#一轮训练
running_loss = 0.0
for batch_idx,data in enumerate(train_loader,0):
inputs,target = data
# 数据迁移到显卡，模型和数据要放到同一块显卡
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()#计算一个epoch的损失
if batch_idx%300==299:
print('[%d,%5d] loss:%.3f'%(epoch+1,batch_idx+1,running_loss/300))#每300个batch则输出一次平均损失
running_loss = 0.00
#test
def test():
correct = 0
total = 0
with torch.no_grad():#test不计算梯度
for data in test_loader:
images,labels = data
outputs = model(images)
_,pred = torch.max(outputs.data,dim = 1)
total+=labels.size(0)
correct+=(pred==labels).sum().item()
print("acc on test set:%d %%" % (100*correct/total))
for epoch in range(10):
train(epoch)
test()
[1, 300] loss:0.681
[1, 600] loss:0.212
[1, 900] loss:0.150
acc on test set:96 %
[2, 300] loss:0.112
[2, 600] loss:0.103
[2, 900] loss:0.085
acc on test set:98 %
[3, 300] loss:0.074
[3, 600] loss:0.077
[3, 900] loss:0.072
acc on test set:98 %
[4, 300] loss:0.064
[4, 600] loss:0.066
[4, 900] loss:0.057
acc on test set:98 %
[5, 300] loss:0.055
[5, 600] loss:0.052
[5, 900] loss:0.058
acc on test set:97 %
[6, 300] loss:0.047
[6, 600] loss:0.049
[6, 900] loss:0.050
acc on test set:98 %
[7, 300] loss:0.043
[7, 600] loss:0.044
[7, 900] loss:0.046
acc on test set:98 %
[8, 300] loss:0.038
[8, 600] loss:0.043
[8, 900] loss:0.043
acc on test set:98 %
[9, 300] loss:0.042
[9, 600] loss:0.037
[9, 900] loss:0.036
acc on test set:98 %
[10, 300] loss:0.036
[10, 600] loss:0.034
[10, 900] loss:0.036
acc on test set:98 %
from PIL import Image
img,lb = test_dataset[5]
img_pil = transforms.ToPILImage()(img)
print(lb)
outputs = model(img)
_,pred = torch.max(outputs.data,dim = 1)
print(pred)
img_pil
1
tensor([1])
img,lb = test_dataset[6]
img_pil = transforms.ToPILImage()(img)
print(lb)
outputs = model(img)
_,pred = torch.max(outputs.data,dim = 1)
print(pred)
img_pil
4
tensor([4])
为什么卷积神经网络有用
卷积参数映射较少
参数共享
稀疏连接，其他特征对某输出没有影响
