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

5.1 卷积

考虑到使用全连接前馈网络来处理图像时，会出现如下问题：

模型参数过多，容易发生过拟合。?在全连接前馈网络中，隐藏层的每个神经元都要跟该层所有输入的神经元相连接。随着隐藏层神经元数量的增多，参数的规模也会急剧增加，导致整个神经网络的训练效率非常低，也很容易发生过拟合。
难以提取图像中的局部不变性特征。?自然图像中的物体都具有局部不变性特征，比如尺度缩放、平移、旋转等操作不影响其语义信息。而全连接前馈网络很难提取这些局部不变性特征。

卷积神经网络有三个结构上的特性：局部连接、权重共享和汇聚。这些特性使得卷积神经网络具有一定程度上的平移、缩放和旋转不变性。和前馈神经网络相比，卷积神经网络的参数也更少。因此，通常会使用卷积神经网络来处理图像信息。

卷积是分析数学中的一种重要运算，常用于信号处理或图像处理任务。本节以二维卷积为例来进行实践。

5.1.1 二维卷积运算

????????在机器学习和图像处理领域，卷积的主要功能是在一个图像（或特征图）上滑动一个卷积核，通过卷积操作得到一组新的特征。在计算卷积的过程中，需要进行卷积核的翻转，而这也会带来一些不必要的操作和开销。因此，在具体实现上，一般会以数学中的互相关（Cross-Correlatio）运算来代替卷积。
????????在神经网络中，卷积运算的主要作用是抽取特征，卷积核是否进行翻转并不会影响其特征抽取的能力。特别是当卷积核是可学习的参数时，卷积和互相关在能力上是等价的。因此，很多时候，为方便起见，会直接用互相关来代替卷积。

5.1.2 二维卷积算子

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

根据公式 $y_{i,j}=\sum_{u=0}^{U-1}\sum_{v=0}^{V-1}w_{uv}x_{i+u,j+v}$ ，我们首先实现一个简单的二维卷积算子，代码实现如下：

import torch
import torch.nn as nn

class Conv2D(nn.Module):
    def __init__(self, weight_attr=torch.tensor([[0., 1.],[2., 3.]])):
        super(Conv2D, self).__init__()
        # 使用'torch.Parameter'进行参数初始化
        self.weight = torch.nn.Parameter(weight_attr)

    def forward(self, X):
        """
        输入：
            - X：输入矩阵，shape=[B, M, N]，B为样本数量
        输出：
            - output：输出矩阵
        """
        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, dim=[1,2])
        return output

# 随机构造一个二维输入矩阵
torch.random.manual_seed(100)
inputs = torch.tensor([[[1.,2.,3.],[4.,5.,6.],[7.,8.,9.]]])

conv2d = Conv2D()
outputs = conv2d(inputs)
print("input: {}, \noutput: {}".format(inputs, outputs))

input: tensor([[[1., 2., 3.],
? ? ? ? ?[4., 5., 6.],
? ? ? ? ?[7., 8., 9.]]]),?
output: tensor([[[25., 31.],
? ? ? ? ?[43., 49.]]], grad_fn=<CopySlices>)

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

参数量

由于二维卷积的运算方式为在一个图像（或特征图）上滑动一个卷积核，通过卷积操作得到一组新的特征。所以参数量仅仅与卷积核的尺寸有关，对于一个输入矩阵 $X\in \mathbb{R}^{M\times N}$ 和一个滤波器 $W\in \mathbb{R}^{U\times V}$ ，卷积核的参数量为U×V。

假设有一幅大小为32×32的图像，如果使用全连接前馈网络进行处理，即便第一个隐藏层神经元个数为1，此时该层的参数量也高达1025个，此时该层的计算过程如?图5.3?所示。

计算量

在卷积神经网络中运算时，通常会统计网络总的乘加运算次数作为计算量（FLOPs，floating point of operations），来衡量整个网络的运算速度。对于单个二维卷积，计算量的统计方式为：

其中M′×N′表示输出特征图的尺寸，即输出特征图上每个点都要与卷积核 $W\in \mathbb{R}^{U\times V}$ 进行U×V次乘加运算。对于一幅大小为32×32的图像，使用3×3的卷积核进行运算可以得到以下的输出特征图尺寸：

此时，计算量为：?

5.1.4 感受野

????????输出特征图上每个点的数值，是由输入图片上大小为U×V的区域的元素与卷积核每个元素相乘再相加得到的，所以输入图像上U×V区域内每个元素数值的改变，都会影响输出点的像素值。我们将这个区域叫做输出特征图上对应点的感受野。感受野内每个元素数值的变动，都会影响输出点的数值变化。比如3×3卷积对应的感受野大小就是3×3，如?图5.4?所示。

而当通过两层3×3的卷积之后，感受野的大小将会增加到5×5，如?图5.5?所示。?

因此，当增加卷积网络深度的同时，感受野将会增大，输出特征图中的一个像素点将会包含更多的图像语义信息。?

5.1.5 卷积的变种

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

5.1.5.1 步长（Stride）

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

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

5.1.5.2 零填充（Zero Padding）

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

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

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

引入步长和零填充后，二维卷积算子代码实现如下：

import torch
import torch.nn as nn


class Conv2D(nn.Module):
    def __init__(self, kernel_size, stride=1, padding=0, weight_attr=False):
        super(Conv2D, self).__init__()
        if type(weight_attr) == bool:
            weight_attr = torch.ones(size=(kernel_size, kernel_size))
        self.weight = torch.nn.Parameter(weight_attr)
        # 步长
        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,
                    dim=[1, 2])
        return output


inputs = torch.randn(size=[2, 8, 8])
conv2d_padding = Conv2D(kernel_size=3, padding=1,weight_attr=torch.zeros((3,3)))
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))

When kernel_size=3, padding=1 stride=1, input's shape: torch.Size([2, 8, 8]), output's shape: torch.Size([2, 8, 8])
When kernel_size=3, padding=1 stride=2, input's shape: torch.Size([2, 8, 8]), output's shape: torch.Size([2, 4, 4])

从输出结果看出，使用3×33×3大小卷积，padding为1，当stride=1时，模型的输出特征图可以与输入特征图保持一致；当stride=2时，输出特征图的宽和高都缩小一倍。

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

在图像处理任务中，常用拉普拉斯算子对物体边缘进行提取，拉普拉斯算子为一个大小为3×3的卷积核，中心元素值是8，其余元素值是?1。

下面我们利用上面定义的Conv2D算子，构造一个简单的拉普拉斯算子，并对一张输入的灰度图片进行边缘检测，提取出目标的外形轮廓。

import torch
import torch.nn as nn


class Conv2D(nn.Module):
    def __init__(self, kernel_size, stride=1, padding=0, weight_attr=False):
        super(Conv2D, self).__init__()
        if type(weight_attr) == bool:
            weight_attr = torch.ones(size=(kernel_size, kernel_size))
        self.weight = torch.nn.Parameter(weight_attr)
        # 步长
        self.stride = stride
        # 零填充
        self.padding = padding

    def forward(self, X):
        # 零填充
        new_X = nn.ZeroPad2d(1)(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,
                    dim=[1, 2])
        return output


import matplotlib.pyplot as plt
from PIL import Image
import numpy as np

def main():
    # 读取图片
    img = Image.open('number.jpg').convert('L').resize((256,256))

    # 设置卷积核参数
    w = np.array([[-1,-1,-1], [-1,8,-1], [-1,-1,-1]], dtype='float32')
    # 创建卷积算子，卷积核大小为3x3，并使用上面的设置好的数值作为卷积核权重的初始化参数
    conv = Conv2D(kernel_size=3, stride=1, padding=0, weight_attr=torch.tensor(w))

    # 将读入的图片转化为float32类型的numpy.ndarray
    inputs = np.array(img).astype('float32')
    print("bf to_tensor, inputs:",inputs)
    # 将图片转为Tensor
    inputs = torch.tensor(inputs)
    print("bf unsqueeze, inputs:",inputs)
    inputs = torch.unsqueeze(inputs, dim=0)
    print("af unsqueeze, inputs:",inputs)
    outputs = conv.forward(inputs)
    print(outputs)
    outputs = outputs.data.squeeze().numpy()
    # 可视化结果
    plt.imshow(img)
    plt.title('input image', fontsize=15)
    plt.show()
    plt.imshow(outputs, cmap='gray')
    plt.title('output feature map', fontsize=15)
    plt.show()

if __name__=="__main__":
    main()

bf to_tensor, inputs: [[0. 0. 0. ... 0. 0. 0.]
?[0. 0. 0. ... 0. 0. 0.]
?[0. 0. 0. ... 0. 0. 0.]
?...
?[0. 0. 0. ... 0. 0. 0.]
?[0. 0. 0. ... 0. 0. 0.]
?[0. 0. 0. ... 0. 0. 0.]]
bf unsqueeze, inputs: tensor([[0., 0., 0., ?..., 0., 0., 0.],
? ? ? ? [0., 0., 0., ?..., 0., 0., 0.],
? ? ? ? [0., 0., 0., ?..., 0., 0., 0.],
? ? ? ? ...,
? ? ? ? [0., 0., 0., ?..., 0., 0., 0.],
? ? ? ? [0., 0., 0., ?..., 0., 0., 0.],
? ? ? ? [0., 0., 0., ?..., 0., 0., 0.]])
af unsqueeze, inputs: tensor([[[0., 0., 0., ?..., 0., 0., 0.],
? ? ? ? ?[0., 0., 0., ?..., 0., 0., 0.],
? ? ? ? ?[0., 0., 0., ?..., 0., 0., 0.],
? ? ? ? ?...,
? ? ? ? ?[0., 0., 0., ?..., 0., 0., 0.],
? ? ? ? ?[0., 0., 0., ?..., 0., 0., 0.],
? ? ? ? ?[0., 0., 0., ?..., 0., 0., 0.]]])
tensor([[[0., 0., 0., ?..., 0., 0., 0.],
? ? ? ? ?[0., 0., 0., ?..., 0., 0., 0.],
? ? ? ? ?[0., 0., 0., ?..., 0., 0., 0.],
? ? ? ? ?...,
? ? ? ? ?[0., 0., 0., ?..., 0., 0., 0.],
? ? ? ? ?[0., 0., 0., ?..., 0., 0., 0.],
? ? ? ? ?[0., 0., 0., ?..., 0., 0., 0.]]], grad_fn=<CopySlices>)

outputs = outputs.data.squeeze().numpy()

?这行代码将输出图片从tensor转换为numpy，可是这行代码并不能运行完成，这行代码运行过程中，程序就会停止运行，并出现以下结束代码

进程已结束,退出代码-1073741571 (0xC00000FD)

?查了一下这应该是栈溢出的问题，我使用了尾递归优化也没解决问题，所以暂时先用上次作业的方法完成边缘检测。

import torch
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号 #有中文出现的情况，需要u'内容

img = Image.open("number.jpg").convert('L').resize((256,256))
plt.imshow(img,cmap='gray')
plt.title('原图')
plt.show()
img = np.array(img, dtype='float32').reshape(1, 1, img.size[1], img.size[0])
img = torch.from_numpy(img)

# 定义卷积层，单通道输入，单通道输出，因此需要1个3*3的卷积核
conv_layer = torch.nn.Conv2d(
    in_channels=1,
    out_channels=1,
    kernel_size=3,
    stride=1,
    padding=0
)

# 边缘检测卷积核
outline_kernel = [[-1, -1, -1],
                  [-1, 8, -1],
                  [-1, -1, -1]]
kernel = torch.from_numpy(np.array(outline_kernel, dtype='float32').reshape(1, 1, 3, 3))
conv_layer.weight.data = kernel

# 推理
img_output = conv_layer(img)
print(img_output.shape)

# 展示
plt.imshow(img_output.data.squeeze().numpy(),cmap='gray')
plt.title('特征图')
plt.show()

?从输出结果看，使用拉普拉斯算子，目标的边缘可以成功被检测出来。

补充：

上面栈溢出的问题，在和室友别被打脸的博客_CSDN博客-领域博主和HBU_fangerfang的博客_CSDN博客-神经网络与深度学习领域博主讨论后，将原图尺寸调小，resize为32*32后可以正常运行。

img = Image.open('number.jpg').convert('L').resize((32,32))

?经测试，临界值为104，105*105就会栈溢出。

选做题

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

因为上述的这些算子在本质上都是通过卷积计算实现的，只是所使用到的卷积核参数有所不同
所以可以构建一个通用的计算算子，只需要传入对应的卷积核参数即可实现不同的边缘检测
并且在后处理时集成了上述的四种计算最终边缘强度的方式

import os
import cv2
import matplotlib.pyplot as plt
import torch
from PIL import Image

import numpy as np

import torch
import torch.nn as nn


class EdgeOP(nn.Module):
    def __init__(self, kernel):
        '''
        kernel: shape(out_channels, in_channels, h, w)
        '''
        super(EdgeOP, self).__init__()
        out_channels, in_channels, h, w = kernel.shape
        self.filter = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=(h, w),
                                padding='same', )
        self.filter.weight.data = torch.tensor(kernel,dtype=torch.float32)

    @staticmethod
    def postprocess(outputs, mode=0, weight=None):
        '''
        Input: NCHW
        Output: NHW(mode==1-3) or NCHW(mode==4)

        Params:
            mode: switch output mode(0-4)
            weight: weight when mode==3
        '''
        if mode == 0:
            results = torch.sum(torch.abs(outputs), dim=1)
        elif mode == 1:
            results = torch.sqrt(torch.sum(torch.pow(outputs, 2), dim=1))
        elif mode == 2:
            results = torch.max(torch.abs(outputs), dim=1)[0]
        elif mode == 3:
            if weight is None:
                C = outputs.shape[1]
                weight = torch.tensor([1 / C] * C, dtype=torch.float32)
            else:
                weight = torch.tensor(weight, dtype=torch.float32)
            results = torch.einsum('nchw, c -> nhw', torch.abs(outputs), weight)
        elif mode == 4:
            results = torch.abs(outputs)
        return torch.clip(results, 0, 255).to(torch.uint8)

    @torch.no_grad()
    def forward(self, images, mode=0, weight=None):
        outputs = self.filter(images)
        return self.postprocess(outputs, mode, weight)

图像边缘检测测试函数

为了方便测试就构建了如下的测试函数，测试同一张图片不同算子/不同边缘强度计算方法的边缘检测效果

def test_edge_det(kernel, img_path='number.jpg'):
    img = cv2.imread(img_path, 0)
    img_tensor = torch.tensor(img, dtype=torch.float32)[None, None, ...]
    op = EdgeOP(kernel)
    all_results = []
    for mode in range(4):
        results = op(img_tensor, mode=mode)
        all_results.append(results.numpy()[0])

    results = op(img_tensor, mode=4)
    for result in results.numpy()[0]:
        all_results.append(result)
    return all_results, np.concatenate(all_results, 1)

Roberts 算子

roberts_kernel = np.array([
    [[
        [1, 0],
        [0, -1]
    ]],
    [[
        [0, -1],
        [1, 0]
    ]]
])

_, concat_res = test_edge_det(roberts_kernel)
Image.fromarray(concat_res).show()

Prewitt 算子

prewitt_kernel = np.array([
    [[
        [-1, -1, -1],
        [ 0,  0,  0],
        [ 1,  1,  1]
    ]],
    [[
        [-1,  0,  1],
        [-1,  0,  1],
        [-1,  0,  1]
    ]],
    [[
        [ 0,  1,  1],
        [-1,  0,  1],
        [-1, -1,  0]
    ]],
    [[
        [ -1, -1,  0],
        [ -1,  0,  1],
        [  0,  1,  1]
    ]]
])

_, concat_res = test_edge_det(prewitt_kernel)
Image.fromarray(concat_res).show()

?可以看出Prewitt算子要比Roberts算子效果好很多。

Sobel 算子

sobel_kernel = np.array([
    [[
        [-1, -2, -1],
        [ 0,  0,  0],
        [ 1,  2,  1]
    ]],
    [[
        [-1,  0,  1],
        [-2,  0,  2],
        [-1,  0,  1]
    ]],
    [[
        [ 0,  1,  2],
        [-1,  0,  1],
        [-2, -1,  0]
    ]],
    [[
        [ -2, -1,  0],
        [ -1,  0,  1],
        [  0,  1,  2]
    ]]
])

_, concat_res = test_edge_det(sobel_kernel)
Image.fromarray(concat_res).show()

?Sobel算子比Prewitt算子更亮一些

Scharr 算子

scharr_kernel = np.array([
    [[
        [-3, -10, -3],
        [ 0,   0,  0],
        [ 3,  10,  3]
    ]],
    [[
        [-3,  0,   3],
        [-10, 0,  10],
        [-3,  0,   3]
    ]],
    [[
        [ 0,  3,  10],
        [-3,  0,  3],
        [-10, -3,  0]
    ]],
    [[
        [ -10, -3, 0],
        [ -3,  0, 3],
        [ 0,  3,  10]
    ]]
])

_, concat_res = test_edge_det(scharr_kernel)
Image.fromarray(concat_res).show()

?这个Scharr算子就更亮了，前两个周围还有类似气泡的东西。

Krisch 算子

Krisch_kernel = np.array([
    [[
        [5, 5, 5],
        [-3,0,-3],
        [-3,-3,-3]
    ]],
    [[
        [-3, 5,5],
        [-3,0,5],
        [-3,-3,-3]
    ]],
    [[
        [-3,-3,5],
        [-3,0,5],
        [-3,-3,5]
    ]],
    [[
        [-3,-3,-3],
        [-3,0,5],
        [-3,5,5]
    ]],
    [[
        [-3, -3, -3],
        [-3,0,-3],
        [5,5,5]
    ]],
    [[
        [-3, -3, -3],
        [5,0,-3],
        [5,5,-3]
    ]],
    [[
        [5, -3, -3],
        [5,0,-3],
        [5,-3,-3]
    ]],
    [[
        [5, 5, -3],
        [5,0,-3],
        [-3,-3,-3]
    ]],
])

_, concat_res = test_edge_det(Krisch_kernel)

Robinson算子

robinson_kernel = np.array([
    [[
        [1, 2, 1],
        [0, 0, 0],
        [-1, -2, -1]
    ]],
    [[
        [0, 1, 2],
        [-1, 0, 1],
        [-2, -1, 0]
    ]],
    [[
        [-1, 0, 1],
        [-2, 0, 2],
        [-1, 0, 1]
    ]],
    [[
        [-2, -1, 0],
        [-1, 0, 1],
        [0, 1, 2]
    ]],
    [[
        [-1, -2, -1],
        [0, 0, 0],
        [1, 2, 1]
    ]],
    [[
        [0, -1, -2],
        [1, 0, -1],
        [2, 1, 0]
    ]],
    [[
        [1, 0, -1],
        [2, 0, -2],
        [1, 0, -1]
    ]],
    [[
        [2, 1, 0],
        [1, 0, -1],
        [0, -1, -2]
    ]],
])

_, concat_res = test_edge_det(robinson_kernel)
Image.fromarray(concat_res).show()

Laplacian 算子

laplacian_kernel = np.array([
    [[
        [1, 1, 1],
        [1, -8, 1],
        [1, 1, 1]
    ]],
    [[
        [0, 1, 0],
        [1, -4, 1],
        [0, 1, 0]
    ]]
])

_, concat_res = test_edge_det(laplacian_kernel)
Image.fromarray(concat_res).show()

方法对比

$Roberts$ ?算子：基于一阶导数的方法
$Prewitt$ ?算子：基于一阶导数的方法
$Sobel$ ?算子：基于一阶导数的方法
$Laplacian$ ?算子：基于二阶导数的方法

公式对比

$Roberts$ ?算子： $d_{x}=\begin{bmatrix} -1 & 0\\ 0 & 1 \end{bmatrix}$ ， $d_{y}=\begin{bmatrix} 0 & -1\\ 1 & 0 \end{bmatrix}$
$Prewitt$ ?算子： $G_{x}=\begin{bmatrix} -1 & 0 & 1\\ -1 & 0 & 1\\ -1 & 0 & 1 \end{bmatrix}$ ， $G_{y}=\begin{bmatrix} 1 & 1 & 1\\ 0 & 0 & 0\\ -1 & -1 & -1 \end{bmatrix}$
$Sobel$ ?算子： $G_{x}=\begin{bmatrix} -1 & 0 & +1\\ -2 & 0 & +2\\ -1 & 0 & +1 \end{bmatrix}$ ， $G_{x}=\begin{bmatrix} -1 & -2 & -1\\ 0 & 0 & 0\\ +1 & +2 & +1 \end{bmatrix}$
$Laplacian$ ?算子： $4$ ?领域： $\begin{bmatrix} 0 & 1 & 0\\ 1 & -4 & 1\\ 0& 1 & 0 \end{bmatrix}$ ； $8$ ?邻域： $\begin{bmatrix} 1 & 1 & 1\\ 1 & -8 & 1\\ 1 & 1 & 1 \end{bmatrix}$

优点对比?

? $Roberts$ 算子：对垂直边缘的检测效果好于斜向边缘
? ? ? ? ? ? ? ? ? ? ? ? ? 对具有陡峭的低噪声的图像效果最好
? ? ? ? ? ? ? ? ? ? ? ? ? 定位精度高
? $Prewitt$ 算子：边缘检测结果在水平方向和垂直方向均比 $Prewitt$ 算子明显
? ? ? ? ? ? ? ? ? ? ? ? ? ?适合用来识别噪声较多，灰度渐变的图像
? ? ? ? ? ? ? ? ? ? ? ? ? ?对噪声有抑制作用，抑制噪声的原理是通过像素平均
? $Sobel$ 算子：算子要比 $Prewitt$ 算子更能准确检测图像边缘
? ? ? ? ? ? ? ? ? ? ? 边缘定位较准确，常用于噪声较多，灰度渐变的图像
? ? ? ? ? ? ? ? ? ? ? 对像素位置的影响做了加权，相比之下比 ?算子、算子效果更好
? ? ? ? ? ? ? ? ? ? ? 以滤波算子的形式来提取边缘，X，Y方向各用一个模板，两个模板组合起来构成一? ? ? ? ? ? ? ? ? ? ? ? 个梯度算子。 X方向模板对垂直边缘影响最大， Y方向模板对水平边缘影响最大。
? $Laplacian$ 算子：对图像中的阶跃性边缘点定位准确

缺点对比

? $Roberts$ 算子：对噪声敏感，无法抑制噪声的影响
? ? ? ? ? ? ? ? ? ? ? ? ? 提取边缘的结果是边缘比较粗
? ? ? ? ? ? ? ? ? ? ? ? ? 边缘定位不是很准确
? $Prewitt$ 算子：像素平均相当于对图像的低通滤波，所以 $Prewitt$ 算子对边缘的定位不

? ? ? ? ? ? ? ? ? ? ? ? ? 如? $Roberts$ 算子
? $Sobel$ 算子：由于边缘是位置的标志，对灰度的变化不敏感
? $Laplacian$ 算子：对噪声比较敏感，只适用于无噪声图像
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 容易丢失边缘方向信息，造成一些不连续的检测边缘

常用场景对比

? $Roberts$ ?算子：常用于垂直边缘明显或具有陡峭的低噪声的图像的边缘检测任务
$Prewitt$ ?算子：常用于噪声较多、灰度渐变的图像的边缘检测任务
$Sobel$ ?算子：常用于噪声较多，灰度渐变的图像的边缘检测任务
$Laplacian$ ?算子：常用于归一化检测结果，进行方差计算，可以用在模糊检测任务上

2、实现的简易的?Canny?边缘检测算法

经典的 Canny 边缘检测算法和其实现方法

算法原理

Canny 是一个经典的图像边缘检测算法，一般包含如下几个步骤：
- 使用高斯模糊对图像进行模糊降噪处理
- 基于图像梯度幅值进行图像边缘增强
- 非极大值抑制处理进行图像边缘细化
- 图像二值化和边缘连接得到最终的结果

代码实现

基于 OpenCV 实现快速的 Canny 边缘检测

在 OpenCV 中只需要使用 cv2.Canny 函数即可实现 Canny 边缘检测

import cv2
import numpy as np

from PIL import Image

lower = 30  # 最小阈值
upper = 70  # 最大阈值

img_path = 'number.jpg'  # 指定测试图像路径

gray = cv2.imread(img_path, 0)  # 读取灰度图像
edge = cv2.Canny(gray, lower, upper) # Canny 图像边缘检测

contrast = np.concatenate([edge, gray], 1) # 图像拼接
Image.fromarray(contrast).show() # 显示图像

基于 Numpy 模块实现简单的 Canny 检测器?

0. 导入必要的包

import cv2
import math
import numpy as np

1. 高斯模糊

def smooth(img_gray, kernel_size=5):
    # 生成高斯滤波器
    """
    要生成一个 (2k+1)x(2k+1) 的高斯滤波器，滤波器的各个元素计算公式如下：

    H[i, j] = (1/(2*pi*sigma**2))*exp(-1/2*sigma**2((i-k-1)**2 + (j-k-1)**2))
    """
    sigma1 = sigma2 = 1.4
    gau_sum = 0
    gaussian = np.zeros([kernel_size, kernel_size])
    for i in range(kernel_size):
        for j in range(kernel_size):
            gaussian[i, j] = math.exp(
                (-1 / (2 * sigma1 * sigma2)) *
                (np.square(i - 3) + np.square(j-3))
            ) / (2 * math.pi * sigma1 * sigma2)
            gau_sum = gau_sum + gaussian[i, j]

    # 归一化处理
    gaussian = gaussian / gau_sum

    # 高斯滤波

    img_gray = np.pad(img_gray, ((kernel_size//2, kernel_size//2), (kernel_size//2, kernel_size//2)), mode='constant')
    W, H = img_gray.shape
    new_gray = np.zeros([W - kernel_size, H - kernel_size])

    for i in range(W-kernel_size):
        for j in range(H-kernel_size):
            new_gray[i, j] = np.sum(
                img_gray[i: i + kernel_size, j: j + kernel_size] * gaussian
            )

    return new_gray

2. 计算图像的梯度幅值

def gradients(new_gray):
    """
    :type: image which after smooth
    :rtype:
        dx: gradient in the x direction
        dy: gradient in the y direction
        M: gradient magnitude
        theta: gradient direction
    """

    W, H = new_gray.shape
    dx = np.zeros([W-1, H-1])
    dy = np.zeros([W-1, H-1])
    M = np.zeros([W-1, H-1])
    theta = np.zeros([W-1, H-1])

    for i in range(W-1):
        for j in range(H-1):
            dx[i, j] = new_gray[i+1, j] - new_gray[i, j]
            dy[i, j] = new_gray[i, j+1] - new_gray[i, j]
            # 图像梯度幅值作为图像强度值
            M[i, j] = np.sqrt(np.square(dx[i, j]) + np.square(dy[i, j]))
            # 计算  θ - artan(dx/dy)
            theta[i, j] = math.atan(dx[i, j] / (dy[i, j] + 0.000000001))

    return dx, dy, M, theta

3. 非极大值抑制

def NMS(M, dx, dy):

    d = np.copy(M)
    W, H = M.shape
    NMS = np.copy(d)
    NMS[0, :] = NMS[W-1, :] = NMS[:, 0] = NMS[:, H-1] = 0

    for i in range(1, W-1):
        for j in range(1, H-1):

            # 如果当前梯度为0，该点就不是边缘点
            if M[i, j] == 0:
                NMS[i, j] = 0

            else:
                gradX = dx[i, j]  # 当前点 x 方向导数
                gradY = dy[i, j]  # 当前点 y 方向导数
                gradTemp = d[i, j]  # 当前梯度点

                # 如果 y 方向梯度值比较大，说明导数方向趋向于 y 分量
                if np.abs(gradY) > np.abs(gradX):
                    weight = np.abs(gradX) / np.abs(gradY)  # 权重
                    grad2 = d[i-1, j]
                    grad4 = d[i+1, j]

                    # 如果 x, y 方向导数符号一致
                    # 像素点位置关系
                    # g1 g2
                    #    c
                    #    g4 g3
                    if gradX * gradY > 0:
                        grad1 = d[i-1, j-1]
                        grad3 = d[i+1, j+1]

                    # 如果 x，y 方向导数符号相反
                    # 像素点位置关系
                    #    g2 g1
                    #    c
                    # g3 g4
                    else:
                        grad1 = d[i-1, j+1]
                        grad3 = d[i+1, j-1]

                # 如果 x 方向梯度值比较大
                else:
                    weight = np.abs(gradY) / np.abs(gradX)
                    grad2 = d[i, j-1]
                    grad4 = d[i, j+1]

                    # 如果 x, y 方向导数符号一致
                    # 像素点位置关系
                    #      g3
                    # g2 c g4
                    # g1
                    if gradX * gradY > 0:

                        grad1 = d[i+1, j-1]
                        grad3 = d[i-1, j+1]

                    # 如果 x，y 方向导数符号相反
                    # 像素点位置关系
                    # g1
                    # g2 c g4
                    #      g3
                    else:
                        grad1 = d[i-1, j-1]
                        grad3 = d[i+1, j+1]

                # 利用 grad1-grad4 对梯度进行插值
                gradTemp1 = weight * grad1 + (1 - weight) * grad2
                gradTemp2 = weight * grad3 + (1 - weight) * grad4

                # 当前像素的梯度是局部的最大值，可能是边缘点
                if gradTemp >= gradTemp1 and gradTemp >= gradTemp2:
                    NMS[i, j] = gradTemp

                else:
                    # 不可能是边缘点
                    NMS[i, j] = 0

    return NMS

4. 图像二值化和边缘连接

def double_threshold(NMS, threshold1, threshold2):
    NMS = np.pad(NMS, ((1, 1), (1, 1)), mode='constant')
    W, H = NMS.shape
    DT = np.zeros([W, H])

    # 定义高低阈值
    TL = threshold1  * np.max(NMS)
    TH = threshold2  * np.max(NMS)

    for i in range(1, W-1):
        for j in range(1, H-1):
           # 双阈值选取
            if (NMS[i, j] < TL):
                DT[i, j] = 0

            elif (NMS[i, j] > TH):
                DT[i, j] = 1

           # 连接
            elif ((NMS[i-1, j-1:j+1] < TH).any() or
                    (NMS[i+1, j-1:j+1].any() or
                     (NMS[i, [j-1, j+1]] < TH).any())):
                DT[i, j] = 1

    return DT

5. Canny 边缘检测

def canny(gray, threshold1, threshold2, kernel_size=5):
    norm_gray = gray
    gray_smooth = smooth(norm_gray, kernel_size)
    dx, dy, M, theta = gradients(gray_smooth)
    nms = NMS(M, dx, dy)
    DT = double_threshold(nms, threshold1, threshold2)
    return DT

6. 代码测试

import cv2
import numpy as np

from PIL import Image

lower = 0.1 # 最小阈值
upper = 0.3 # 最大阈值

img_path = '1-2.jpg' # 指定测试图像路径

gray = cv2.imread(img_path, 0) # 读取灰度图像
edge = canny(gray, lower, upper) # Canny 图像边缘检测
edge = (edge * 255).astype(np.uint8) # 反归一化

contrast = np.concatenate([edge, gray], 1) # 图像拼接
Image.fromarray(contrast).show() # 显示图像

基于 Pytorch 实现的 Canny 边缘检测器

0. 导入必要的模块

import torch
import torch.nn as nn
import math
import cv2
import numpy as np
from scipy.signal import gaussian

?1. 卷积参数设置

def get_state_dict(filter_size=5, std=1.0, map_func=lambda x:x):
    generated_filters = gaussian(filter_size, std=std).reshape([1, filter_size
                                                   ]).astype(np.float32)

    gaussian_filter_horizontal = generated_filters[None, None, ...]

    gaussian_filter_vertical = generated_filters.T[None, None, ...]

    sobel_filter_horizontal = np.array([[[
        [1., 0., -1.],
        [2., 0., -2.],
        [1., 0., -1.]]]],
        dtype='float32'
    )

    sobel_filter_vertical = np.array([[[
        [1., 2., 1.],
        [0., 0., 0.],
        [-1., -2., -1.]]]],
        dtype='float32'
    )

    directional_filter = np.array(
        [[[[ 0.,  0.,  0.],
          [ 0.,  1., -1.],
          [ 0.,  0.,  0.]]],


        [[[ 0.,  0.,  0.],
          [ 0.,  1.,  0.],
          [ 0.,  0., -1.]]],


        [[[ 0.,  0.,  0.],
          [ 0.,  1.,  0.],
          [ 0., -1.,  0.]]],


        [[[ 0.,  0.,  0.],
          [ 0.,  1.,  0.],
          [-1.,  0.,  0.]]],


        [[[ 0.,  0.,  0.],
          [-1.,  1.,  0.],
          [ 0.,  0.,  0.]]],


        [[[-1.,  0.,  0.],
          [ 0.,  1.,  0.],
          [ 0.,  0.,  0.]]],


        [[[ 0., -1.,  0.],
          [ 0.,  1.,  0.],
          [ 0.,  0.,  0.]]],


        [[[ 0.,  0., -1.],
          [ 0.,  1.,  0.],
          [ 0.,  0.,  0.]]]],
        dtype=np.float32
    )

    connect_filter = np.array([[[
        [1., 1., 1.],
        [1., 0., 1.],
        [1., 1., 1.]]]],
        dtype=np.float32
    )

    return {
        'gaussian_filter_horizontal.weight': map_func(gaussian_filter_horizontal),
        'gaussian_filter_vertical.weight': map_func(gaussian_filter_vertical),
        'sobel_filter_horizontal.weight': map_func(sobel_filter_horizontal),
        'sobel_filter_vertical.weight': map_func(sobel_filter_vertical),
        'directional_filter.weight': map_func(directional_filter),
        'connect_filter.weight': map_func(connect_filter)
    }

2. Canny 检测器

class CannyDetector(nn.Module):
    def __init__(self, filter_size=5, std=1.0, device='cpu'):
        super(CannyDetector, self).__init__()
        # 配置运行设备
        self.device = device

        # 高斯滤波器
        self.gaussian_filter_horizontal = nn.Conv2d(in_channels=1, out_channels=1, kernel_size=(1,filter_size), padding=(0,filter_size//2), bias=False)
        self.gaussian_filter_vertical = nn.Conv2d(in_channels=1, out_channels=1, kernel_size=(filter_size,1), padding=(filter_size//2,0), bias=False)

        # Sobel 滤波器
        self.sobel_filter_horizontal = nn.Conv2d(in_channels=1, out_channels=1, kernel_size=3, padding=1, bias=False)
        self.sobel_filter_vertical = nn.Conv2d(in_channels=1, out_channels=1, kernel_size=3, padding=1, bias=False)

        # 定向滤波器
        self.directional_filter = nn.Conv2d(in_channels=1, out_channels=8, kernel_size=3, padding=1, bias=False)

        # 连通滤波器
        self.connect_filter = nn.Conv2d(in_channels=1, out_channels=1, kernel_size=3, padding=1, bias=False)

        # 初始化参数
        params = get_state_dict(filter_size=filter_size, std=std, map_func=lambda x:torch.from_numpy(x).to(self.device))
        self.load_state_dict(params)

    @torch.no_grad()
    def forward(self, img, threshold1=10.0, threshold2=100.0):
        # 拆分图像通道
        img_r = img[:,0:1] # red channel
        img_g = img[:,1:2] # green channel
        img_b = img[:,2:3] # blue channel

        # Step1: 应用高斯滤波进行模糊降噪
        blur_horizontal = self.gaussian_filter_horizontal(img_r)
        blurred_img_r = self.gaussian_filter_vertical(blur_horizontal)
        blur_horizontal = self.gaussian_filter_horizontal(img_g)
        blurred_img_g = self.gaussian_filter_vertical(blur_horizontal)
        blur_horizontal = self.gaussian_filter_horizontal(img_b)
        blurred_img_b = self.gaussian_filter_vertical(blur_horizontal)

        # Step2: 用 Sobel 算子求图像的强度梯度
        grad_x_r = self.sobel_filter_horizontal(blurred_img_r)
        grad_y_r = self.sobel_filter_vertical(blurred_img_r)
        grad_x_g = self.sobel_filter_horizontal(blurred_img_g)
        grad_y_g = self.sobel_filter_vertical(blurred_img_g)
        grad_x_b = self.sobel_filter_horizontal(blurred_img_b)
        grad_y_b = self.sobel_filter_vertical(blurred_img_b)

        # Step2: 确定边缘梯度和方向
        grad_mag = torch.sqrt(grad_x_r**2 + grad_y_r**2)
        grad_mag += torch.sqrt(grad_x_g**2 + grad_y_g**2)
        grad_mag += torch.sqrt(grad_x_b**2 + grad_y_b**2)
        grad_orientation = (torch.atan2(grad_y_r+grad_y_g+grad_y_b, grad_x_r+grad_x_g+grad_x_b) * (180.0/math.pi))
        grad_orientation += 180.0
        grad_orientation =  torch.round(grad_orientation / 45.0) * 45.0

        # Step3: 非最大抑制，边缘细化
        all_filtered = self.directional_filter(grad_mag)

        inidices_positive = (grad_orientation / 45) % 8
        inidices_negative = ((grad_orientation / 45) + 4) % 8

        batch, _, height, width = inidices_positive.shape
        pixel_count = height * width * batch
        pixel_range = torch.Tensor([range(pixel_count)]).to(self.device)

        indices = (inidices_positive.reshape((-1, )) * pixel_count + pixel_range).squeeze()
        channel_select_filtered_positive = all_filtered.reshape((-1, ))[indices.long()].reshape((batch, 1, height, width))

        indices = (inidices_negative.reshape((-1, )) * pixel_count + pixel_range).squeeze()
        channel_select_filtered_negative = all_filtered.reshape((-1, ))[indices.long()].reshape((batch, 1, height, width))

        channel_select_filtered = torch.stack([channel_select_filtered_positive, channel_select_filtered_negative])

        is_max = channel_select_filtered.min(dim=0)[0] > 0.0

        thin_edges = grad_mag.clone()
        thin_edges[is_max==0] = 0.0

        # Step4: 双阈值
        low_threshold = min(threshold1, threshold2)
        high_threshold = max(threshold1, threshold2)
        thresholded = thin_edges.clone()
        lower = thin_edges<low_threshold
        thresholded[lower] = 0.0
        higher = thin_edges>high_threshold
        thresholded[higher] = 1.0
        connect_map = self.connect_filter(higher.float())
        middle = torch.logical_and(thin_edges>=low_threshold, thin_edges<=high_threshold)
        thresholded[middle] = 0.0
        connect_map[torch.logical_not(middle)] = 0
        thresholded[connect_map>0] = 1.0
        thresholded[..., 0, :] = 0.0
        thresholded[..., -1, :] = 0.0
        thresholded[..., :, 0] = 0.0
        thresholded[..., :, -1] = 0.0
        thresholded = (thresholded>0.0).float()

        return thresholded

3. 代码测试

if __name__ == '__main__':
    import cv2
    import numpy as np
    img_path = '1-2.png'
    res_path = "1-2_torch_our.png"
    img = cv2.imread(img_path)/255.0 # height, width, channel
    img = np.transpose(img, [2, 1, 0]) # channel width height
    canny_operator = CannyDetector()
    result = canny_operator(torch.from_numpy(np.expand_dims(img, axis=0)).float(),threshold1=2.5, threshold2=5 ) # batch channel width height
    res = np.squeeze(result.numpy())
    res = np.transpose(res, [1, 0])
    res = (res*255).astype(np.uint8)
    cv2.imwrite(res_path, res)

$Canny$ ?算子：非微分边缘检测算子

?????????????实现步骤：1. 用高斯滤波器平滑图像
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?2. 计算图像中每个像素点的梯度强度和方向
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?3. 对梯度幅值进行非极大值抑制
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?4. 用双阈值算法检测来确定真实和潜在的边缘

??????????????优点：对噪声不敏感，不容易受到噪声干扰
? ? ? ? ? ? ? ? ? ? ? ? ?能够检测到真正的弱边缘
? ? ? ? ? ? ? ? ? ? ? ? ?使用两种不同的阈值分别检测强边缘和弱边缘
? ? ? ? ? ? ? ? ? ? ? ? ?仅当强边缘与弱边缘相连时才将弱边缘包含在输出图像中
? ? ? ? ? ? ? 缺点：易使高频边缘被平滑掉，从而造成边缘丢失

? ? ? ? ? ? ?常用场景：被用于诸如“车道线检测”等实际项目中，是最有效的边缘检测方法

3、复现论文 Holistically-Nested Edge Detection，发表于 CVPR 2015 ，一个基于深度学习的端到端边缘检测模型。

Holistically：整体

Nested：嵌套的

主要解决两个问题：

基于整个图像的训练和预测；
多尺度和多水平的特征学习。
该算法通过深度学习模型，完成了从图像到图像的预测，并通过学习到的丰富的分级特征，完成边缘检测中的细节问题。

基本想法:

本文提出的end-to-end的边缘检测系统，称为holistically-nested edge detection (HED)

holistically来表示边缘预测的结果是基于图像到图像的，端到端的过程；
nested则强调了在生成的输出过程中不断地继承和学习得到精确的边缘预测图的过程（具体算法后面再说明）。这里使用多尺度的方法进行特征的学习，多尺度下的该方法边缘检测结果示意图如下图，图中的d,e,f分别为卷积层2,3,4响应得到的边缘检测结果，HED方法的最后输出是远远优于canny算子的?

?从上图中可以看出，canny检测会存在断开线的情况，而HED基本没有这种现象，HED的效果明显优于canny。?

创新点:

(1)端到端：image-to-image

(2)基于FCN和VGG 改进，同时引出6个loss进行优化训练，通过多个side output输出不同scale的边缘，然后通过一个训练的权重融合函数得到最终的边缘输出。可以solve edge 和物体boundaries的ambiguity

(3)样本不平衡处理方法：class-balanced_sigmoid_cross_entropy?

网络整体理解:

?

可以看到的是整个过程只有一个卷积+池化的过程，Unet还有上采样的过程，这是不同点；
图中的有5个马的图片，从大到小，从浅到深，纹理越来越少，这分别是经过了maxpool和卷积得到的不同尺寸的输出。从图中可以看到，这些输出叫做side-output 1到side-output 5。
图中这五个特征图经过虚线，得到了一个Y，这个Y是经过“weighted-fusion”得到了，简单的说就是，五个图经过一个可以训练的权重参数，融合成了最终的输出

4、复现论文 Richer Convolutional Features for Edge Detection，CVPR 2017 发表，一个基于更丰富的卷积特征的边缘检测模型?【RCF】。

背景

边缘检测是视觉任务中非常基础的任务，现有的基于CNN的边缘检测方法有两个明显的问题：

现有的方法大多只使用CNN的最后一层conv的结果，忽略了中间层的结果
更多的方法集中在探究更深的CNN，但边缘检测是数据比较少，而且容易发生梯度消失的现象
本文的出发点如下图所示，不同卷积层获得的结果随着深度增加而更加粗糙

?网络结构：

VGG作为主干网络，每个卷积层捕获的有用信息随着感受野大小的增加而变得更粗糙（以下5条是论文中对网络架构的介绍）
提出RCF，切断了所有全连接层、池化层第5层，切除全连接层是为了使用全卷积层，实现image-to-image的预测，加入pool5层会使步幅增加两倍，这通常会导致边缘定位的退化
VGG16中每个阶段中的每个卷积层都连接到核大小为1×1和通道深度为21的卷积层。每个阶段的特征映射都是用一个eltwise层（相加）来积累的，以获得混合特征。
一个1×1个卷积层跟随每个eltwise层。然后，使用一个反卷积层对这个特征映射进行上采样。
在每个阶段，交叉熵损失/Sigmoid连接到上采样层。
所有上采样层都是级联的。然后使用1×1卷积从每个阶段融合特征映射。最后，采用交叉熵损失/Sigmoid得到融合损失/输出

RCF提供了一种比现有机制更好的机制来学习来自各级卷积特征的多尺度信息，作者认为这些特征都与边缘检测有关
在RCF中，高级特征较粗，可以在较大的对象或对象部分边界处获得强响应。

?提出的新的损失函数是这个

在这里插入图片描述

相比HED，RCF一是捕捉了所有conv的特征进行融合得到最终的结果，二是提出新的损失函数，三是提出多尺度测试

5、Crisp Edge Detection（CED）模型是前面介绍过的 HED 模型的另一种改进模型

介绍

????????卷积网络得到的边缘检测图，是高度“正确”，但并不那么“清晰”的，这是由于，首先，在更具鉴别性的卷积顶层，特征的空间分辨率急剧降低，导致边缘输出模糊，再次，全卷积会导致相邻像素的相似应答（线性插值方式），因此也会影响细边缘的产生。
????????提出了一种新的细化体系结构，灵感来自最近在密集图像标记方面的进展，细化路径为网络增加了额外的非线性，进一步减少了相邻像素内边缘响应之间的相关性。
????????本文对ConvNet的边缘图进行了系统的研究。结果表明，ConvNet具有良好的边缘像素分类能力，但定位能力较差；
????????本文将细化方案和亚像素卷积组合成一种新的体系结构，这是专门为学习脆边检测器而设计的；
????????在BSDS500上的结果在所有匹配距离上都优于最先进的方法。本文还表明，清晰的边缘映射可以改善光流估计和目标提案的生成。

从卷积网络中学到的：

为什么HED可以得到这么高的分数，作者认为是评价标准的问题，匹配方式由最大允许距离d控制，如果边缘像素与label像素距离小于d，也会被认为是正确的。 “脆度”可以通过降低基准中的d来衡量。人类的表现随d的下降更快，而HED随d的下降，比人类下降更快

CED网络结构

????????一方面是前馈传播，获取丰富的网络特征图，而一大特点是，用了一个反向细化路径（backward-refining path，也就是图中的橙色框，扩展开就是第二个虚线框中的结构）来补充HED网络，它使用有效的亚像素卷积逐步提高样本特征，反向细化路径将特征映射与沿前向传播路径的中间特征融合，这个细化方式由多个细化模块一起组成，最终达到原图的分辨率。
????????细化模块融合了一个自顶向下的特征映射和前传上的特征映射，并使用亚像素卷积向上采样。在进行融合的时候，通过减少两个特征映射的维数来实现融合（即降维，由于通道数不同，不得不这样做）。
????????将输入前向路径特征映射的通道数表示为kh。经过卷积和RELU运算后，信道被简化为k‘h，远小于kh。同样的操作从先前的细化模块对特征映射进行校正，从ku生成k‘u。将上述特征映射连接到一个新的具有k‘u+k’h通道的特征映射中，并将其减少，用k‘d通道通过3×3卷积层进行特征映射。从而降低了总体计算成本，平衡了两个输入特征映射。
????????对于上采样，采用亚像素卷积操作，而非流行的反卷积操作，这样对于边缘的定位表现似乎更好。亚像素卷积不是通过单个反卷积层直接输出放大特征映射，而是由一个卷积层和一个跟随相移层组成的一种网络层。总体上看，参数量也比HED少了许多。

????????一句话概述本文特点就是，研究了HED网络，CED提出了细化的方案，即一、反向细化路径模块，以及二、采用亚像素卷积替代线性插值的全卷积，对于边缘定位效果更好。