NNDL 实验六 卷积神经网络（1）卷积

最新推荐文章于 2022-11-06 22:11:51 发布
最新推荐文章于 2022-11-06 22:11:51 发布
阅读量878 收藏 1
点赞数 1
文章标签： cnn 深度学习 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51316271/article/details/127358658
版权

目录

5.1 卷积

卷积神经网络（Convolutional Neural Network，CNN）

  • 受生物学上感受野机制的启发而提出。
  • 一般是由卷积层、汇聚层和全连接层交叉堆叠而成的前馈神经网络
  • 有三个结构上的特性：局部连接、权重共享、汇聚。
  • 具有一定程度上的平移、缩放和旋转不变性。
  • 和前馈神经网络相比，卷积神经网络的参数更少。
  • 主要应用在图像和视频分析的任务上，其准确率一般也远远超出了其他的神经网络模型。
  • 近年来卷积神经网络也广泛地应用到自然语言处理、推荐系统等领域。

5.1.1 二维卷积运算

在这里插入图片描述

5.1.2 二维卷积算子

在本书后面的实现中，算子都继承paddle.nn.Layer，并使用支持反向传播的飞桨API进行实现，这样我们就可以不用手工写backword()的代码实现。
【使用pytorch实现】

import torch
import torch.nn as nn
import torch.nn
import numpy as np


class Conv2D(nn.Module):
    def __init__(self, kernel_size):
        super(Conv2D, self).__init__()
        w = torch.tensor(np.array([[0., 1.], [2., 3.]], dtype='float32').reshape([kernel_size, kernel_size]))
        self.weight = torch.nn.Parameter(w, requires_grad=True)

    def forward(self, X):
        u, v = self.weight.shape
        output = torch.zeros([X.shape[0], X.shape[1] - u + 1, X.shape[2] - v + 1])
        for i in range(output.shape[1]):
            for j in range(output.shape[2]):
                output[:, i, j] = torch.sum(X[:, i:i + u, j:j + v] * self.weight, axis=[1, 2])
        return output


# 随机构造一个二维输入矩阵
inputs = torch.as_tensor([[[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]])
conv2d = Conv2D(kernel_size=2)
outputs = conv2d(inputs)
print("input: {}, \noutput: {}".format(inputs, outputs))

结果：
在这里插入图片描述

5.1.3 二维卷积的参数量和计算量

随着隐藏层神经元数量的变多以及层数的加深，

使用全连接前馈网络处理图像数据时，参数量会急剧增加。

如果使用卷积进行图像处理，相较于全连接前馈网络，参数量少了非常多。
在这里插入图片描述
在这里插入图片描述

5.1.4 感受野

输出特征图上每个点的数值，是由输入图片上大小为U×V的区域的元素与卷积核每个元素相乘再相加得到的，所以输入图像上U×V区域内每个元素数值的改变，都会影响输出点的像素值。我们将这个区域叫做输出特征图上对应点的感受野。感受野内每个元素数值的变动，都会影响输出点的数值变化。比如3×3卷积对应的感受野大小就是3×3，如图。
在这里插入图片描述
而当通过两层3×3的卷积之后，感受野的大小将会增加到5×5，如图所示。
在这里插入图片描述
因此，当增加卷积网络深度的同时，感受野将会增大，输出特征图中的一个像素点将会包含更多的图像语义信息。

5.1.5 卷积的变种

在卷积的标准定义基础上，还可以引入卷积核的滑动步长和零填充来增加卷积的多样性，从而更灵活地进行特征抽取。

5.1.5.1 步长（Stride）

在卷积运算的过程中，有时会希望跳过一些位置来降低计算的开销，也可以把这一过程看作是对标准卷积运算输出的下采样。

在计算卷积时，可以在所有维度上每间隔S个元素计算一次，S称为卷积运算的步长（Stride），也就是卷积核在滑动时的间隔。

此时，对于一个输入矩阵X∈RM×N和一个滤波器W∈RU×V，它们的卷积为
在这里插入图片描述
在二维卷积运算中，当步长S=2时，计算过程如图所示。

在这里插入图片描述
卷积核的步长度代表提取的精度，步长小，提取的特征会更全面，不会遗漏太多信息。但同时可能造成计算量增大，甚至过拟合等问题。步长大，计算量会下降，但很有可能错失一些有用的特征。步长选多少没有一套明确的标准，还是要看你输入图像的大小和卷积核的大小。总之在计算资源够用的前提下，最好不要让你卷积核错失太多特征。

5.1.5.2 零填充（Zero Padding）

在卷积运算中，还可以对输入用零进行填充使得其尺寸变大。根据卷积的定义，如果不进行填充，当卷积核尺寸大于1时，输出特征会缩减。对输入进行零填充则可以对卷积核的宽度和输出的大小进行独立的控制。

在二维卷积运算中，零填充（Zero Padding）是指在输入矩阵周围对称地补上P个0。图 为使用零填充的示例。
在这里插入图片描述
在这里插入图片描述

  • 对于奇数卷积核，通过让padding=(k-1)/2，即可实现same的效果。即输出尺寸保持不变或以步长倍数缩小（对于奇数输入尺寸则向上取整）
  • 对于偶数卷积核，若是偶数输入尺寸，则padding=floor((k-1)/2)可实现same的效果
  • 对于偶数卷积核，若是奇数输入尺寸，则padding=ceil((k-1)/2)可实现same的效果
  • 若涉及到空洞卷积，则公式变为：d*(k-1)/2

5.1.6 带步长和零填充的二维卷积算子

从输出结果看出，使用3×3大小卷积，

padding为1，

当stride=1时，模型的输出特征图与输入特征图保持一致；

当stride=2时，模型的输出特征图的宽和高都缩小一倍。

【使用pytorch实现】

import torch
import torch.nn as nn
import torch.nn
import numpy as np


class Conv2D(nn.Module):
    def __init__(self, kernel_size,stride=1, padding=0):
        super(Conv2D, self).__init__()
        w = torch.tensor(np.array([[0., 1., 2.], [3., 4. ,5.],[6.,7.,8.]], dtype='float32').reshape([kernel_size, kernel_size]))
        self.weight = torch.nn.Parameter(w, requires_grad=True)
        self.stride = stride
        self.padding = padding

    def forward(self, X):
        # 零填充
        new_X = torch.zeros([X.shape[0], X.shape[1] + 2 * self.padding, X.shape[2] + 2 * self.padding])
        new_X[:, self.padding:X.shape[1] + self.padding, self.padding:X.shape[2] + self.padding] = X
        u, v = self.weight.shape
        output_w = (new_X.shape[1] - u) // self.stride + 1
        output_h = (new_X.shape[2] - v) // self.stride + 1
        output = torch.zeros([X.shape[0], output_w, output_h])
        for i in range(0, output.shape[1]):
            for j in range(0, output.shape[2]):
                output[:, i, j] = torch.sum(
                    new_X[:, self.stride * i:self.stride * i + u, self.stride * j:self.stride * j + v] * self.weight,
                    axis=[1, 2])
        return output


inputs = torch.randn(size=[2, 8, 8])
conv2d_padding = Conv2D(kernel_size=3, padding=1)
outputs = conv2d_padding(inputs)
print("When kernel_size=3, padding=1 stride=1, input's shape: {}, output's shape: {}".format(inputs.shape, outputs.shape))
conv2d_stride = Conv2D(kernel_size=3, stride=2, padding=1)
outputs = conv2d_stride(inputs)
print("When kernel_size=3, padding=1 stride=2, input's shape: {}, output's shape: {}".format(inputs.shape, outputs.shape))

结果：
在这里插入图片描述
从输出结果看出，使用3×3大小卷积：
padding为1，当stride=1时，模型的输出特征图与输入特征图保持一致。
padding为1，当stride=2时，模型的输出特征图的宽和高都缩小了一倍。

5.1.7 使用卷积运算完成图像边缘检测任务

【使用pytorch实现】
在这里插入图片描述

import torch
import torch.nn as nn
import torch.nn
import numpy as np


class Conv2D(nn.Module):
    def __init__(self, kernel_size,stride=1, padding=0):
        super(Conv2D, self).__init__()
        # 设置卷积核参数
        w = np.array([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]], dtype='float32').reshape((3,3))
        w=torch.from_numpy(w)
        self.weight = torch.nn.Parameter(w, requires_grad=True)
        self.stride = stride
        self.padding = padding

    def forward(self, X):
        # 零填充
        new_X = torch.zeros([X.shape[0], X.shape[1] + 2 * self.padding, X.shape[2] + 2 * self.padding])
        new_X[:, self.padding:X.shape[1] + self.padding, self.padding:X.shape[2] + self.padding] = X
        u, v = self.weight.shape
        output_w = (new_X.shape[1] - u) // self.stride + 1
        output_h = (new_X.shape[2] - v) // self.stride + 1
        output = torch.zeros([X.shape[0], output_w, output_h])
        for i in range(0, output.shape[1]):
            for j in range(0, output.shape[2]):
                output[:, i, j] = torch.sum(
                    new_X[:, self.stride * i:self.stride * i + u, self.stride * j:self.stride * j + v] * self.weight,
                    axis=[1, 2])
        return output

import matplotlib.pyplot as plt
from PIL import Image
# 读取图片
img = Image.open(r'C:\Users\86155\Desktop\tower.png').convert('L')
img = np.array(img, dtype='float32')
im = torch.from_numpy(img.reshape((img.shape[0],img.shape[1])))

# 创建卷积算子，卷积核大小为3x3，并使用上面的设置好的数值作为卷积核权重的初始化参数
conv = Conv2D(kernel_size=3, stride=1, padding=0)

# 将读入的图片转化为float32类型的numpy.ndarray
inputs = np.array(im).astype('float32')
print("bf as_tensor, inputs:",inputs)
# 将图片转为Tensor
inputs = torch.as_tensor(inputs)
print("bf unsqueeze, inputs:",inputs)
inputs = torch.unsqueeze(inputs, axis=0)
print("af unsqueeze, inputs:",inputs)
outputs = conv(inputs)
print(outputs)
# outputs = outputs.data.squeeze().numpy()
# # 可视化结果
plt.subplot(121).set_title('input image', fontsize=15)
plt.imshow(img.astype('uint8'),cmap='gray')
plt.subplot(122).set_title('output feature map', fontsize=15)
plt.imshow(outputs.squeeze().detach().numpy(), cmap='gray')
plt.savefig('conv-vis.pdf')
plt.show()

结果：
在这里插入图片描述

选做题

Pytorch实现1、2；阅读3、4、5写体会。

1.实现一些传统边缘检测算子，如：Roberts、Prewitt、Sobel、Scharr、Kirsch、Robinson、Laplacian。

import cv2
import numpy as np

# 加载图像
image = cv2.imread(r'C:\Users\86155\Desktop\tower.png', 0)
image = cv2.resize(image, (800, 800))
# 自定义卷积核
# Roberts边缘算子
kernel_Roberts_x = np.array([
    [1, 0],
    [0, -1]
])
kernel_Roberts_y = np.array([
    [0, -1],
    [1, 0]
])
# Sobel边缘算子
kernel_Sobel_x = np.array([
    [-1, 0, 1],
    [-2, 0, 2],
    [-1, 0, 1]])
kernel_Sobel_y = np.array([
    [1, 2, 1],
    [0, 0, 0],
    [-1, -2, -1]])
# Prewitt边缘算子
kernel_Prewitt_x = np.array([
    [-1, 0, 1],
    [-1, 0, 1],
    [-1, 0, 1]])
kernel_Prewitt_y = np.array([
    [1, 1, 1],
    [0, 0, 0],
    [-1, -1, -1]])


# Kirsch 边缘检测算子
def kirsch(image):
    m, n = image.shape
    list = []
    kirsch = np.zeros((m, n))
    for i in range(2, m - 1):
        for j in range(2, n - 1):
            d1 = np.square(5 * image[i - 1, j - 1] + 5 * image[i - 1, j] + 5 * image[i - 1, j + 1] -
                           3 * image[i, j - 1] - 3 * image[i, j + 1] - 3 * image[i + 1, j - 1] -
                           3 * image[i + 1, j] - 3 * image[i + 1, j + 1])
            d2 = np.square((-3) * image[i - 1, j - 1] + 5 * image[i - 1, j] + 5 * image[i - 1, j + 1] -
                           3 * image[i, j - 1] + 5 * image[i, j + 1] - 3 * image[i + 1, j - 1] -
                           3 * image[i + 1, j] - 3 * image[i + 1, j + 1])
            d3 = np.square((-3) * image[i - 1, j - 1] - 3 * image[i - 1, j] + 5 * image[i - 1, j + 1] -
                           3 * image[i, j - 1] + 5 * image[i, j + 1] - 3 * image[i + 1, j - 1] -
                           3 * image[i + 1, j] + 5 * image[i + 1, j + 1])
            d4 = np.square((-3) * image[i - 1, j - 1] - 3 * image[i - 1, j] - 3 * image[i - 1, j + 1] -
                           3 * image[i, j - 1] + 5 * image[i, j + 1] - 3 * image[i + 1, j - 1] +
                           5 * image[i + 1, j] + 5 * image[i + 1, j + 1])
            d5 = np.square((-3) * image[i - 1, j - 1] - 3 * image[i - 1, j] - 3 * image[i - 1, j + 1] - 3
                           * image[i, j - 1] - 3 * image[i, j + 1] + 5 * image[i + 1, j - 1] +
                           5 * image[i + 1, j] + 5 * image[i + 1, j + 1])
            d6 = np.square((-3) * image[i - 1, j - 1] - 3 * image[i - 1, j] - 3 * image[i - 1, j + 1] +
                           5 * image[i, j - 1] - 3 * image[i, j + 1] + 5 * image[i + 1, j - 1] +
                           5 * image[i + 1, j] - 3 * image[i + 1, j + 1])
            d7 = np.square(5 * image[i - 1, j - 1] - 3 * image[i - 1, j] - 3 * image[i - 1, j + 1] +
                           5 * image[i, j - 1] - 3 * image[i, j + 1] + 5 * image[i + 1, j - 1] -
                           3 * image[i + 1, j] - 3 * image[i + 1, j + 1])
            d8 = np.square(5 * image[i - 1, j - 1] + 5 * image[i - 1, j] - 3 * image[i - 1, j + 1] +
                           5 * image[i, j - 1] - 3 * image[i, j + 1] - 3 * image[i + 1, j - 1] -
                           3 * image[i + 1, j] - 3 * image[i + 1, j + 1])

            # 第一种方法：取各个方向的最大值，效果并不好，采用另一种方法
            list = [d1, d2, d3, d4, d5, d6, d7, d8]
            kirsch[i, j] = int(np.sqrt(max(list)))
    for i in range(m):
        for j in range(n):
            if kirsch[i, j] > 127:
                kirsch[i, j] = 255
            else:
                kirsch[i, j] = 0
    return kirsch


# 拉普拉斯卷积核
kernel_Laplacian_1 = np.array([
    [0, 1, 0],
    [1, -4, 1],
    [0, 1, 0]])
kernel_Laplacian_2 = np.array([
    [1, 1, 1],
    [1, -8, 1],
    [1, 1, 1]])
# 下面两个卷积核不具有旋转不变性
kernel_Laplacian_3 = np.array([
    [2, -1, 2],
    [-1, -4, -1],
    [2, 1, 2]])
kernel_Laplacian_4 = np.array([
    [-1, 2, -1],
    [2, -4, 2],
    [-1, 2, -1]])
# 5*5 LoG卷积模板
kernel_LoG = np.array([
    [0, 0, -1, 0, 0],
    [0, -1, -2, -1, 0],
    [-1, -2, 16, -2, -1],
    [0, -1, -2, -1, 0],
    [0, 0, -1, 0, 0]])
# 卷积
output_1 = cv2.filter2D(image, -1, kernel_Prewitt_x)
output_2 = cv2.filter2D(image, -1, kernel_Sobel_x)
output_3 = cv2.filter2D(image, -1, kernel_Prewitt_x)
output_4 = cv2.filter2D(image, -1, kernel_Laplacian_1)
output_5 = kirsch(image)
# 显示锐化效果
image = cv2.resize(image, (800, 600))
output_1 = cv2.resize(output_1, (800, 600))
output_2 = cv2.resize(output_2, (800, 600))
output_3 = cv2.resize(output_3, (800, 600))
output_4 = cv2.resize(output_4, (800, 600))
output_5 = cv2.resize(output_5, (800, 600))
cv2.imshow('Original Image', image)
cv2.imshow('Prewitt Image', output_1)
cv2.imshow('Sobel Image', output_2)
cv2.imshow('Prewitt Image', output_3)
cv2.imshow('Laplacian Image', output_4)
cv2.imshow('kirsch Image', output_5)
# 停顿
if cv2.waitKey(0) & 0xFF == 27:
    cv2.destroyAllWindows()

结果：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.实现的简易的 Canny 边缘检测算法。

import cv2
# 加载图像
image = cv2.imread(r'C:\Users\86155\Desktop\tower.png',0)
image = cv2.resize(image,(800,800))
def Canny(image,k,t1,t2):
    img = cv2.GaussianBlur(image, (k, k), 0)
    canny = cv2.Canny(img, t1, t2)
    return canny
image = cv2.resize(image, (800, 600))
cv2.imshow('Original Image', image)
output =cv2.resize(Canny(image,3,50,150),(800,600))
cv2.imshow('Canny Image', output)
# 停顿
if cv2.waitKey(0) & 0xFF == 27:
    cv2.destroyAllWindows()

结果：
在这里插入图片描述
在这里插入图片描述

3.复现论文 Holistically-Nested Edge Detection，发表于 CVPR 2015

一个基于深度学习的端到端边缘检测模型。
边缘检测系列3：【HED】 Holistically-Nested 边缘检测

HED 模型包含五个层级的特征提取架构，每个层级中：

  1. 使用 VGG Block 提取层级特征图
  2. 使用层级特征图计算层级输出
  3. 层级输出上采样

最后融合五个层级输出作为模型的最终输出：

  1. 通道维度拼接五个层级的输出

  2. 1x1 卷积对层级输出进行融合

模型总体架构图如下：
在这里插入图片描述
HED和Canny的处理结果进行比较：
在这里插入图片描述
从处理结果的展示中可以看到HED的精度高于Canny。Canny的精度主要依赖于阈值的设置，通过人为的阈值设置可以检测到细粒度的边缘，很依赖图片像素值。但是相比于神经网络，Canny缺失语义方面的理解，神经网络对边缘的理解是更多层次的。HED属于深度学习网络的一种，而且加入了Deep supervision，每个Side output继承上一层的特征，最后对多层特征融合，进一步取得了精度的提升。

4.复现论文 Richer Convolutional Features for Edge Detection，CVPR 2017 发表

一个基于更丰富的卷积特征的边缘检测模型 【RCF】。
边缘检测系列4：【RCF】基于更丰富的卷积特征的边缘检测

RCF 基于 HED 网络，与 VGG16 相比，RCF 主要做了如下修改：

  • 与 HED 相同，RCF 去掉了最后一个池化层和之后的全连接层，形成了全卷积网络。
  • 在 VGG16 的每个卷积层之后连接一个 1×1 大小深度为 21 的卷积层，并将每一阶段的特征累积得到混合特征。
  • 在每个阶段得到混合特征之后添加反卷积层进行上采样(upsample)。
  • 在上采样层之后添加 loss/sigmoid 层计算损失。
  • 将所有上采用层连接，对每个阶段的特征进行融合，最后再通过 loss/sigmoid 层计算损失。

模型结构图如下：
在这里插入图片描述
论文每个阶段的输出如下：
在这里插入图片描述

RCF与HED之间最明显区别之处在以下三个方面：

  1. HED对于边缘检测来说，丢失了许多非常有用的信息，因为它仅使用到VGG16中每个阶段的最后一层卷积特征。RCF与之相反，它使用了所有卷积层的特征，使得在更大的范围内捕获更多的对象或对象局部边界成为可能。
  2. RCF创造性的提出了一个对训练样本非常合适的损失函数。而且，本文首先将标注人数大于A的边缘像素作为正样例，为0的作为负样例。除此之外，还忽略了标注者人数小于A的边缘像素，既不作为正样例，也不作为负样例。
  3. 与之相反的是，HED将标注人数小于总人数一半的边缘像素作为负样例。上述做法会迷惑网络的训练，因为这些点并不是真实的分边缘像素点。

5.【CED】添加了反向细化路径的 HED 模型 - 飞桨AI Studio (baidu.com)

Crisp Edge Detection（CED）模型是前面介绍过的 HED 模型的另一种改进模型。
边缘检测系列5：【CED】添加了反向细化路径的 HED 模型

CED 模型总体基于 HED 模型改造而来，其中做了如下几个改进：

  • 将模型中的上采样操作从转置卷积插值更换为 PixelShuffle
  • 添加了反向细化路径，即一个反向的从高层级特征逐步往低层级特征的边缘细化路径
  • 没有多层级输出，最终的输出为融合了各层级的特征的边缘检测结果

架构图如下：
在这里插入图片描述

PixelShuffle: 正常情况下，卷积操作会使特征图的高和宽缩小。但当我们的步长即 stride = 1/r < 1时，可以让卷积后的特征图的高和宽扩大——即分辨率增大或者叫上采样，这个新的操作叫做 PixelShuffle.

更多算法细节可以参考论文：Real-Time Single Image and Video Super-Resolution Using an Efficient Sub-Pixel Convolutional Neural Network

原理图如下：
在这里插入图片描述

CED的两个主要组成部分：前向传播路径和反向细化路径。 前向传播路径类似于HED。 它生成具有丰富语义信息的高维低分辨率特征图。 反向细化路径将沿着向前传播路径的特征图与中间特征进行融合。 这个细化是通过细化模块多次完成的。 每次我们使用子像素卷积将特征分辨率提高一个小的因子（2x），最终达到输入分辨率。

总结

本次实验比较基础，主要是学习卷积层的一些常识，像步长、感受野、补零(具体概念见上个博客作业)，这些在大二上都已经学过一遍。还完成了边缘检测任务，并学习了一些经典的边缘检测算子和算法，这是比较新的知识

参考：
边缘检测-HED-RCF
边缘检测系列5：【CED】添加了反向细化路径的 HED 模型

乳酸蔓越莓吐司
关注
奇数卷积核VS偶数卷积核
qq_40268255的博客
02-17 7374
在跑一份代码时，效果一直提升不上去，偶然将3 * 3的卷积核换成了4 * 4的卷积核，效果奇佳，于是搜索了一下卷积核的大小对网络性能的影响，总结如下： 1.大卷积核和小卷积核 显然，大卷积核的感受野更大，自然提取特征的性能更好，一个5 * 5的卷积核可以由两个3 * 3的卷积核替换，但是带来的代价是：大卷积核的计算速度更慢，参数量更多。因此，通常使用小卷积核，小卷积核所需要的参数量更少，且产...
conv2卷积计算整理
zr459927180的博客
02-29 5616
关于conv2函数的计算过程 假设有两个矩阵a,b，a的大小是ma行na列，b的大小是mb行nb列。 c=conv2(a,b)计算这两个矩阵的卷积，c的大小是ma+mb-1行，na+nb-1列。 计算过程如下： 1.对矩阵a进行边界填补0，填充规则是：在a的第一行之前和最后一行之后分别填充mb-1行0，并在a的第一列之前和最后一列之后分别填充nb-1列0； 2.对矩阵b进行翻转，上下换位
卷积核_NeurIPS2019 通用网络之偶数卷积核
weixin_42411545的博客
12-31 847
Convolution with even-sized kernels and symmetric paddingShuang Wu (Tsinghua University) · Guanrui Wang (Tsinghua University) · Pei Tang (Tsinghua University) · Feng Chen (Tsinghua University) · Lupin...
卷积神经网络.基础知识
Stay Hungry Stay Foolish
03-12 1131
卷积的操作的通用公式： 对于一个n*n大小的输入图片，使用一个大小为 f*f 的filter，其中padding为p，卷积stride为 s，得到的输出结果的维度为： * 1.Padding 中文意思为 填充 分析上面的卷积操作： 左边我们输入的图像的大小为 6*6, filter的大小为 3*3，按照一般的卷积操作(这里假设没有提出padding、stride的概念...
对于 CNN 卷积网络的理解——Padding 的两种方式
weixin_40267373的博客
05-03 3540
TensorFlow—Conv2D padding 问题导言1. Padding='VALID'2. Padding='SAME'2.1. 2x2 大小的卷积核2.2. 3x3 大小的卷积核2.3. 4x4 大小的卷积核3. 对齐方式不同 导言 最近在看卷积神经网络（CNN）的时候，遇到了 padding 这个属性（补全方式），查了很多资料，发现目前网上讨论的大都是padding之后输出张量大小如...
NNDL 实验六 卷积神经网络（4）ResNet18实现MNIST
Guo_weiqi的博客
11-06 275
NNDL 实验六 卷积神经网络（4）ResNet18实现MNIST
NNDL 实验六 卷积神经网络（3）LeNet实现MNIST
m0_51799083的博客
11-03 141
NNDL 实验六 卷积神经网络（3）LeNet实现MNIST
偶数卷积模板
weixin_30788731的博客
05-07 457
常用的是：奇数×奇数。 奇数锚点刚好在中间。奇数核拥有天然的绝对中心点，能更好地获取中心信息。 奇数卷积模板保护位置信息：锚点刚好在中间，方便以模块中心为标准进行滑动卷积，避免了位置信息发生偏移。 在像素领域，偶数卷积模板没有一个“绝对的物理中心”。 边缘提取，Roberts算子是偶数的卷积模板。Roberts交叉梯度算子。 对于一图像矩阵： Robert...
Convolutional Neural Network (CNN or ConvNet) 卷积核的大小一般都是奇数*奇数
既然选择了远方 便只顾风雨兼程 - 永强
08-24 1692
Convolutional Neural Network (CNN or ConvNet) 卷积核的大小一般都是奇数*奇数 在 Convolutional Neural Network (CNN or ConvNet) 中，卷积核的大小几乎都是奇数*奇数 (5∗55*55∗5，3∗33*33∗3，1∗11*11∗1)。 The LeNet-5 architecture consists of two sets of convolutional and average pooling layers, fol
Convolution with even-sized kernels and symmetric padding论文解读笔记
Mr.Ma-master
12-25 1527
文章目录导读摘要引言相关工作对称填充实验讨论总结 导读 我们都习惯使用3*3的卷积核，这篇文章介绍了偶数卷积核其实表现更强 。 首先附上文章地址： Convolution with even-sized kernels and symmetric padding【PDF】 摘要 紧凑型卷积神经网络主要通过深度卷积，扩展的通道和复杂的拓扑来提高效率，这反过来又加剧了训练过程。 此外，在这些模型中...
pytorch中的卷积操作详解
热门推荐
霹雳吧啦Wz
11-05 4万+
首先说下pytorch中的Tensor通道排列顺序是：[batch, channel, height, width] 我们常用的卷积（Conv2d）在pytorch中对应的函数是： torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=Tr...
CNN为什么卷积核的大小都是奇数
Fan9_的博客
08-13 4295
CNN的卷积核大小都是奇数而没有偶数主要有以下两点原因： 1、奇数卷积核有中心像素点 如下图中，奇数大小的卷积核有唯一的中心像素点，而偶数大小的卷积核没有中心像素点 为什么需要中心像素点？因为中心像素点有以下两点左右： 确定局部卷积后要更新的像素点位置。如下图的卷积操作，中心像素的位置对应着当前卷积操作wx+b的值要赋给那个位置。如果卷积核是偶数，中...
为什么要用3x3卷积？偶数卷积核其实表现更强
小白学视觉
08-12 4736
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达来源：AI科技评论作者 | BBuf编辑 |唐里下面要介绍的论文发于NeurlPS2019，题为「Convolution with even-sized kernels and symmetric padding」，axriv地址为：https://arxiv.org/abs/1903.08385。...
cnn 卷积核为什么都是奇数
无左无右的博客
06-30 1221
原因1： 奇数相对于偶数，有中心点，对边沿、对线条更加敏感，可以更有效的提取边沿信息。 偶数也可以使用，但是效率比奇数低。在数以万计或亿计的计算过程中，每个卷积核差一点，累计的效率就会差很多。 或者解释： 《数字图像处理 (第三版)》(阮秋琦翻译)p89 也可以使用偶数尺寸的滤波器，或使用混合有偶数尺寸和奇数尺寸的滤波器。但是，使用奇数尺寸的滤波器可简化索引，并更为直观，因为滤波器的中心落在整...
深度学习: 卷积核（滤波器）为什么都是奇数
北冥有小鱼
07-30 3204
卷积核一般都把size设为奇数，主要有以下两个原因： 1.保证锚点（卷积核的中心）刚好在中间，方便以模块中心为标准进行滑动卷积。 2.保证了padding时，图像的两边依然相对称...
为什么卷积核一般是奇数的正方形
tortelee的博客
07-03 6766
本文翻译，原网址：https://datascience.stackexchange.com/questions/23183/why-convolutions-always-use-odd-numbers-as-filter-size卷积运算，简单地说，是两个矩阵的元素乘积的组合。只要这两个矩阵在维度上是一致的，就不应该有问题，所以我可以理解你的查询背后的动机。A.1然而，卷积的意图是根据滤波器或...
深度学习中卷积核问题
NOT_GUY的博客
06-23 1921
1、卷积核为什么采用奇数？浅层来看，肯定采用卷积核尺寸采用偶数×偶数的效果比奇数×奇数差。（1）保证了锚点刚好在中间，方便以模块中心为标准进行滑动卷积；（2）考虑padding时，图像的两边依然相对称。2、1×1卷积核的作用（1）可以对图像进行升维操作和降维操作；（2）多个feature map的线性组合，实现跨通道的交互和信息整合。3、GoogleNet中浅层的inception模块的3×3和5...
神经网络NNDL二分类代码
最新发布
11-28
以下是一个简单的二分类神经网络的代码示例，其中包括两个线性层和一个Logistic算子（Sigmoid激活函数）： ```python import torch class TwoLayerNet(torch.nn.Module): def __init__(self, input_size, hidden_size, output_size): super(TwoLayerNet, self).__init__() self.linear1 = torch.nn.Linear(input_size, hidden_size) self.linear2 = torch.nn.Linear(hidden_size, output_size) self.sigmoid = torch.nn.Sigmoid() def forward(self, x): h = self.linear1(x) h_sigmoid = self.sigmoid(h) y_pred = self.linear2(h_sigmoid) return y_pred # 创建一个输入大小为5，隐藏大小为10，输出大小为1的二分类神经网络 model = TwoLayerNet(5, 10, 1) # 定义损失函数和优化器 criterion = torch.nn.BCEWithLogitsLoss() optimizer = torch.optim.SGD(model.parameters(), lr=0.1) # 训练模型 for epoch in range(100): # 前向传播 y_pred = model(x_data) # 计算损失 loss = criterion(y_pred, y_data) # 反向传播 optimizer.zero_grad() loss.backward() optimizer.step() # 打印损失 print('Epoch: {}, Loss: {:.4f}'.format(epoch+1, loss.item())) ```
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值