Visual and CNN 笔记-CSDN博客

本文链接：https://blog.csdn.net/ziggybowie/article/details/137284139

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