Visual and CNN 笔记

visual and CNN

边缘检测

比如对于6x6的灰度图像:构造3x3的filter(滤波器(卷积核))

image

image

向右移动步长为1,直到边界,再回到起点,向下移动一步

image

为什么可以做边缘检测:

右侧4x4矩阵中间的白色区域就包含了6x6矩阵的垂直边缘

image

image

可以用神经网络反向传播来训练出比较好的滤波器矩阵参数选择

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

如果不为整数则向下取整

在数学中通常卷积前,还会将卷积核沿垂直和水平方向翻转

image

三维卷积

卷积层(通道,宽度,高度都可能会变)

滤波器的通道数量必须和图片的通道数量相同

如果想检验红色通道的边缘可以将卷积核第二三通道设置为全0

image

如果需要检测多个边缘,同时使用多个滤波器

image

神经网络+卷积

滤波器类似普通前馈神经网络中的w0xa[0]

卷积核的数量为特征数量

如果有十个3x3x3滤波器则总共有280个参数(包括10个bias)

image

deep Convnet

卷积层,池化层,全连接层

image

池化层

池化(下采样,通道数不变,高度宽度可能会变)

max pooling 最大池化

步长为2的:

最大化运算:如果在滤波器中提取到某个特征,那么保留其最大值

最大池化提升效率的原因:减少数据的数据量,降低运算需求

池化层有若干超参数(f,s)

也是(n+2p-f)/s+1向下取整

平均池化层:average pooling

输入输出层数相同

image

卷积神经网络

image

要明确输入张量大小和最后要的输出的大小

进行维度和大小的变换imageimage

卷积的运算过程

image
例如3通道图像和一组通道3的卷积核运算,得到一个通道的结果
卷积核的组数即为最后得到的通道数,一组卷积核中的卷积核个数应该与输入的图像通道数相同image

对应元素的数乘imageimage

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])

卷积层中的多输入多输出通道

每个通道都有一个卷积核,结果是所有通道卷积结果的和image
多个输出通道
无论有多少输入通道,我们可以有多个三维卷积核,每个核生成一个输出通道

每个卷积核对应的输出通道可以识别特定的模式
下一层的输入通道识别并组合输入中的模式

padding

image

stride步长

image

下采样最大池化层

没有权重image

image

image

image

1x1卷积

不识别空间模式,只是融合通道(一个像素的多通道加权和)

image

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])

image

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])

image

为什么卷积神经网络有用

卷积参数映射较少

参数共享

稀疏连接,其他特征对某输出没有影响

image

  • 4
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值