卷积神经网络：从头开始构建一个CNN

末蓝、 2022-01-12 13:55 309阅读 0赞

# ![20191009191333910.png][][日萌社][Link 1] #

[人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战（不定时更新）][AI_Keras PyTorch MXNet TensorFlow PaddlePaddle]

--------------------

[参考文章：手把手带你走进卷积神经网络！][Link 2]

[关于对神经网络的介绍][Link 3]

[原文][Link 4]

#  #

--------------------

# **动机** #

CNN的经典用例是执行图像分类，例如查看宠物的图像并确定它是猫还是狗。这是一项看似非常简单的任务，你可能会有这样的疑惑：为什么不使用普通的神经网络呢？不得不说这是一个好问题。

**原因1：图像很大**

目前用于计算机视觉问题的图像通常为224x224甚至更大。想象一下，构建一个神经网络来处理224x224彩色图像：包括图像中的3个颜色通道（RGB），即224x224x3=150528个输入权重！这种网络中的典型隐藏层可能有1024个节点，因此我们必须仅为第一层训练150528x1024=15亿个权重。想象一下拥有15亿个权重的神经网络，是不是太大了？这几乎是不可能完成训练的。

最重要的是其实我们并不需要那么多的权重，相反我们仅知道像素点其邻居的点才是最有用的。因为图像中的物体是由小的局部特征组成的，如圆形虹膜或一张纸的方角。对于第一个隐藏层中的每个节点来说，查看每个像素似乎是很浪费的！

**原因2：位置可变**

如果你训练了一个网络来检测狗，那么无论图像出现在哪张照片中，你都希望它能够检测到狗。想象一下，训练一个在某个狗图像上运行良好的网络，然后为它提供相同图像的略微移位版本，此时的网络会有完全不同的反应！

那么CNN是如何帮助我们解决这些问题的呢？不要着急我们很快就会看到CNN如何帮助我们缓解这些问题！

--------------------

# **数据集** #

在这篇文章中，我们将解决计算机视觉的“Hello，World！”：MNIST手写数字分类问题。很简单：给定图像，将其分类为数字。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70][]

MNIST数据集中的每个图像都是28x28，其中包含了一个居中的灰度数字。说实话，一个正常的神经网络实际上可以很好地解决这个问题。你可以将每个图像视为28x28=784维矢量，将其输入到784-dim图层，堆叠一些隐藏图层，最后输出10个节点的输出图层，每个数字1个。

这样做可以完成任务，因为MNIST数据集包含的都是些居中的小图像，因此我们不会遇到上述的大小或移位问题。但是，请记住，大多数现实世界的图像分类问题并不容易。

那么就让我们进入CNN吧！

--------------------

# **卷积** #

什么是卷积神经网络？

它们基本上是使用卷积层的神经网络，即Conv层，它们基于卷积的数学运算。Conv图层由一组过滤器组成，你可以将其视为2d数字矩阵。这是一个示例3x3过滤器：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 1][]

我们可以通过将滤波器与输入图像进行卷积来产生输出图像。这包括：

*  在某个位置覆盖图像顶部的过滤器；
 *  在过滤器中的值与图像中的相应值之间执行逐元素乘法；
 *  所有元素（element-wise products）求和，此和是输出图像中目标像素的输出值。
 *  重复所有位置。

注释：实际上我们（以及许多CNN实现）在技术上使用互相关（Cross-correlation）而不是卷积，但它们几乎完全相同。

这4步描述有点抽象，所以让我们举个例子吧，考虑这个微小的4x4灰度图像和这个3x3过滤器：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 2][]

图像中的数字表示像素强度，其中0是黑色，255是白色。我们将对输入图像和过滤器进行卷积以生成2x2输出图像：

![20190618225111504.png][]

首先，让我们将过滤器叠加在图片的左上角：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 3][]

接下来，我们在重叠图像值和过滤器值之间执行逐元素乘法。以下是结果，从左上角开始向右，然后向下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 4][]

第2步：执行逐元素乘法。

接下来，我们总结所有结果。这很容易：62-33=29。

最后，我们将结果放在输出图像的目标像素中。由于我们的过滤器覆盖在输入图像的左上角，因此我们的目标像素是输出图像的左上角像素：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 5][]

我们做同样的步骤来生成输出图像的其余部分：

**3.1这有用吗？**

用过滤器卷积图像有什么作用？我们可以先使用我们一直使用的示例3x3滤波器，这通常被称为垂直索贝尔滤波器：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 6][]

以下是垂直Sobel滤波器的示例：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 7][]

同样，还有一个水平Sobel滤波器：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 8][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 9][]

到底发生了什么？Sobel滤波器是边缘检测器。垂直Sobel滤波器检测的是垂直边缘，水平Sobel滤波器的是检测水平边缘。现在可以轻松解释输出图像：输出图像中的亮像素（具有高值的像素）表示原始图像中存在强边缘。

你能看出为什么边缘检测图像可能比原始图像更有用吗？回想一下我们的MNIST手写数字分类问题。在MNIST上训练的CNN可以寻找数字1，例如，通过使用边缘检测滤波器并检查图像中心附近的两个突出的垂直边缘。通常，卷积有助于我们查找特定的本地化图像特征。

**3.2填充（Padding）**

还记得先用3x3过滤器对4x4的输入图像进行卷积，以产生2x2输出图像吗？通常，我们希望输出图像的大小与输入图像的大小相同。为此，我们在图像周围添加零，以便我们可以在更多位置叠加过滤器。3x3滤镜需要1个像素的填充：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 10][]

这称为“相同”填充，因为输入和输出具有相同的尺寸。不使用任何填充，这是我们一直在做的，有时也被称为“有效”填充。

**3.3 Conv图层**

既然我们知道图像卷积是如何工作的以及为什么用它，那让我们看看它是如何在CNN中实际使用的。如前所述，CNN包括使用一组过滤器将输入图像转换为输出图像的conv layer。conv层的主要参数是它具有的过滤器数量。

对于我们的MNIST CNN，我们将使用一个带有8个过滤器的小conv layer作为我们网络中的初始层。这意味着它会将28x28输入图像转换为26x26x8输出向量：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 11][]

提醒：输出为26x26x8而不是28x28x8，因为我们使用有效填充，这会将输入的宽度和高度减少2。

conv layer中的4个过滤器中的每一个都会产生26x26输出，因此堆叠在一起它们构成26x26x8的向量。

**3.4执行卷积**

是时候将我们学到的东西放到代码中了！我们将实现一个conv layer的前馈部分，该部分负责处理带有输入图像的过滤器，以产生输出向量。为简单起见，我们假设过滤器是3x3（其实5x5和7x7过滤器也很常见）。

让我们开始实现一个conv layer类：

import numpy as np
    #过滤器是3x3
    class Conv3x3:
    	def __init__(self, num_filters):
    		self.num_filters = num_filters
                    #过滤器是3x3，然后有num_filters个过滤器
    		self.filters = np.random.randn(num_filters, 3, 3) / 9

该类只有一个参数 num\_filters：过滤器的数量。

在构造函数中，num\_filters存储过滤器的数量的同时，并使用NumPy的randn()方法初始化随机过滤器三维数组filters 。

注意：在初始化期间初始值很重要，如果初始值太大或太小，则训练网络将无效。

要了解更多信息，请阅读Xavier Initialization（https://www.quora.com/What-is-an-intuitive-explanation-of-the-Xavier-Initialization-for-Deep-Neural-Networks）。

接下来，实际卷积：

class Conv3x3:
    	
    	# 使用有效填充生成所有可能的3x3图像区域。图像是二维numpy数组。
    	def iterate_regions(self, image):
    		for i in range(h - 2):
    			for j in range(w - 2):
    				im_region = image[i:(i + 3), j:(j + 3)]
    				yield im_region, i, j
    				
            # 使用给定的输入执行conv层的正向传递。
            def forward(self, input):
                #输入是二维numpy数组
                h, w = input.shape
                #返回具有维度（H、W、num_filters过滤器的数量）的三维numpy数组。
                output = np.zeros((h - 2, w - 2, self.num_filters))
                for im_region, i, j in self.iterate_regions(input):
                    output[i, j] = np.sum(im_region * self.filters, axis=(1, 2))
                return output

iterate\_regions()是一个辅助生成器方法，为我们生成所有有效的3x3图像区域，这对于稍后实现此类的后向部分非常有用。

上面是实际执行卷积的代码行。让我们分解一下：

*  im\_region：一个包含相关图像区域的3x3阵列。
 *  self.filters：一个3d数组，过滤器三维数组filters。
 *  im\_region\*self.filters ：我们使用numpy的广播（broadcasting）功能以元素方式乘以两个数组，结果是具有相同尺寸的3d数组。
 *  num\_filters：过滤器的数量
 *  我们设置是axis=(1, 2)：(0,1,2)代表三维数组的高度x宽度x长度，长度为第三维度指num\_filters过滤器的数量，因为我们只希望在后面两个维度（宽度x长度）
 *  axis的用法：[人工智能中 Numpy的 相关函数使用][Numpy_]
 *  我们使用np.sum()，产生一个长度为1d的数组，其中每个元素包含相应过滤器的卷积结果。
 *  我们将结果分配给output\[i,j\]，其中包含输出中像素的卷积结果（i，j）。

对输出中的每个像素执行上面的序列，直到我们获得我们想要的结果！让我们的代码进行测试运行：

import mnist
    	from conv import Conv3x3
    
    	# The mnist package handles the MNIST dataset for us!
    	# Learn more at https://github.com/datapythonista/mnist
    	train_images = mnist.train_images()
    	train_labels = mnist.train_labels()
    
    	conv = Conv3x3(8) #过滤器的数量为8
    	output = conv.forward(train_images[0])
    	print(output.shape) # 输入图像是28x28的mnist图像的2d numpy数组，输出图像的形状是(26, 26,8)的·3d numpy数组

注意：为简单起见，在我们的Conv3x3实现中，我们假设输入是一个2d numpy数组，因为这是我们的MNIST图像的存储方式。这对我们有用，我们将它用作网络中的第一层，但大多数CNN都有更多的Conv层。如果我们要构建一个需要Conv3x3多次使用的更大的网络，我们必须使输入成为3d numpy数组。

--------------------

# **池化（Pooling）** #

图像中的相邻像素倾向于具有相似的值，因此conv layer通常也会为输出中的相邻像素产生类似的值。但是conv layer中输出的大部分信息都是冗余的，例如，如果我们使用边缘检测过滤器并在某个位置找到强边缘，那么我们也可能会在距离原始像素1个像素偏移的位置找到相对较强的边缘。但是，我们可能并没有找到任何新的东西。

池化层解决了这个问题。他们所做的就是减少通过猜测在输入中产生的汇总值。该池通常是通过简单的操作完成max，min或average等这些操作。以下是池化大小为2的Max Pooling图层的示例：

![20190618225709372.gif][]

为了执行最大池化，我们以2x2块（因为池大小=2）遍历输入图像，并将最大值放入相应像素的输出图像中。

对于我们的MNIST CNN，我们将在初始conv layer之后放置一个池大小为2的Max Pooling层，这样池化层就会将26x26x8输入转换为13x13x8输出：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 12][]

**4.1执行池化**

我们将使用MaxPool2与上一节中的conv类相同的方法实现一个类：

使用池大小为2的最大池层。生成不重叠的2x2图像区域以供池覆盖。图像是二维numpy数组
     
    import numpy as np
    class MaxPool2:
    	def iterate_regions(self, image):
    		h, w, _ = image.shape
    		new_h = h // 2
    		new_w = w // 2
    
    		for i in range(new_h):
    			for j in range(new_w):
    				im_region = image[(i * 2):(i * 2 + 2), (j * 2):(j * 2 + 2)]
    				yield im_region, i, j
    			
    		
    	def forward(self, input):
    		#使用给定的输入执行MaxPool层的正向传递。返回具有维度（H/2、W/2、num_filters过滤器的数量）的三维numpy数组。
    		#输入是一个具有尺寸的三维numpy数组（H、W、num_filters过滤器的数量）
    		h, w, num_filters = input.shape
    		output = np.zeros((h // 2, w // 2, num_filters))
    
    		#此类与我们之前实现的Conv3x3类工作方式类似。特别注意的是为了找到给定图像区域的最大值，我们使用np.amax。
    		#我们设置是axis=(0,1)，因为我们只希望在前两个维度（高度和宽度）上进行最大化，而不是第三个维度num_filters过滤器的数量。
    		for im_region, i, j in self.iterate_regions(input):
    			output[i, j] = np.amax(im_region, axis=(0, 1))
    
    		return output

此类与我们之前实现的Conv3x3类工作方式类似。特别注意的是为了找到给定图像区域的最大值，我们使用np.amax()。我们设置是axis=(0,1)，因为我们只希望在前两个维度（高度x宽度26x26）上进行最大化，而不是第三个维度num\_filters过滤器的数量。

我们来试试吧！

运行：
    	import mnist
    	from conv import Conv3x3
    	from maxpool import MaxPool2
    
    	# The mnist package handles the MNIST dataset for us!
    	# Learn more at https://github.com/datapythonista/mnist
    	train_images = mnist.train_images()
    	train_labels = mnist.train_labels()
    
    	conv = Conv3x3(8) #过滤器的数量为8
    	pool = MaxPool2()
    
    	output = conv.forward(train_images[0])
    	output = pool.forward(output)
    	print(output.shape) # 池化后的3维输出图像(13, 13, 8)

MNIST CNN马上要完成了！

--------------------

# **Softmax** #

为了完成我们的CNN，我们需要让它能够实际进行预测。我们将通过使用标准最终层来实现多类分类问题：Softmax层，一个使用softmax激活函数的标准全连接（密集）层。

提示：完全连接层将每个节点连接到前一层的每个输出。我们在之前的神经网络的介绍中使用了完全连接的图层。

Softmax将任意实际值转换为概率。如果你对其背后的数学有兴趣，自己可以简单了解下，因为它很简单。

**5.1用法**

我们将使用一个带有10个节点的softmax层，每个节点都代表一个数字，softmax层是我们CNN的最后一层。图层中的每个节点都将连接到输入，在使用softmax变换之后，概率最高的节点表示的数字将成为CNN的输出！

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 13][]

**5.2交叉熵损失函数**

你可能会有这样的疑问，为什么还要将输出转换为概率呢？最高输出值是否总是具有最高概率？如果你有这样的疑问，那说明你的感觉很对。我们实际上不需要使用softmax来预测数字，因为我们可以选择网络输出最高的数字！

softmax真正做的是帮助我们量化我们对预测的确定程度，这在训练和评估我们的CNN时非常有用。更具体地说，它可以帮我们确定每个预测的正确程度。

**5.3实施Softmax**

让我们实现一个Softmax图层类：

实现一个Softmax图层类：	
    import numpy as np
    
    class Softmax:
      #具有SoftMax激活功能的标准全连接层
    
      def __init__(self, input_len, nodes):
        #我们除以输入长度以减少初始值的方差
        self.weights = np.random.randn(input_len, nodes) / input_len
        self.biases = np.zeros(nodes)
    
      def forward(self, input):
        #使用给定的输入执行SoftMax层的正向传递。返回包含各自概率值的1d numpy数组。
    	#输入可以是任何维度的数组。
        input = input.flatten()
        input_len, nodes = self.weights.shape
    
        totals = np.dot(input, self.weights) + self.biases
        exp = np.exp(totals)
        return exp / np.sum(exp, axis=0)

我们现在已经完成了CNN的整个编码工作！把它放在一起：

import mnist
    import numpy as np
    from conv import Conv3x3
    from maxpool import MaxPool2
    from softmax import Softmax
    
    #我们只使用前1K测试示例（全部是10K个）。为了时间的利益。如果你想的话，可以随意改变
    test_images = mnist.test_images()[:1000]
    test_labels = mnist.test_labels()[:1000]
    
    conv = Conv3x3(8)                  # 28x28x1 -> 26x26x8
    pool = MaxPool2()                  # 26x26x8 -> 13x13x8
    softmax = Softmax(13 * 13 * 8, 10) # 13x13x8 -> 10
    
    def forward(image, label):
    
    	#完成CNN的前向传递并计算准确度和交叉熵损失。
    	#图像是二维numpy数组。标签是数字
    	#我们将图像从[0，255]转换为[-0.5，0.5]以使其更容易。一起工作。这是标准做法。
    
    	out = conv.forward((image / 255) - 0.5)
    	out = pool.forward(out)
    	out = softmax.forward(out)
    
    	# 计算交叉熵损失和精度。np.log() 是自然日志
    	loss = -np.log(out[label])
    	acc = 1 if np.argmax(out) == label else 0
    
    	return out, loss, acc
    
    print('MNIST CNN 初始化!')
    loss = 0
    num_correct = 0
    
    for i, (im, label) in enumerate(zip(test_images, test_labels)):
    	# 向前传递
    	_, l, acc = forward(im, label)
    	loss += l
    	num_correct += acc
    
    	# 每100步打印一次统计数据
    	if i % 100 == 99:
    	print( '[Step %d] Past 100 steps: Average Loss %.3f | Accuracy: %d%%' % (i + 1, loss / 100, num_correct) )
    	loss = 0
    	num_correct = 0

执行cnn.py，我们可以得到：

MNIST CNN initialized!
    [Step 100] Past 100 steps: Average Loss 2.302 | Accuracy: 11%
    [Step 200] Past 100 steps: Average Loss 2.302 | Accuracy: 8%
    [Step 300] Past 100 steps: Average Loss 2.302 | Accuracy: 3%
    [Step 400] Past 100 steps: Average Loss 2.302 | Accuracy: 12%

--------------------

# **结论** #

关于CNN的介绍就到此结束了！在这篇文章中，我们：

*  介绍了为什么CNN可能对某些问题更有用，例如图像分类；
 *  介绍了MNIST手写数字数据集；
 *  了解了Conv图层，它将过滤器与图像进行卷积，以产生更有用的输出；
 *  了解了Pooling图层，它可以帮助修剪除最有用特征之外的内容；
 *  实现了Softmax层，因此我们可以使用交叉熵损失函数。

[20191009191333910.png]: /images/20220112/610bbb8130a84d55b6ad47f732659f75.png
[Link 1]: http://www.rimengshe.com/
[AI_Keras PyTorch MXNet TensorFlow PaddlePaddle]: https://blog.csdn.net/zimiao552147572/article/details/88867161
[Link 2]: https://mp.weixin.qq.com/s?__biz=MjM5MjAwODM4MA==&mid=2650722769&idx=3&sn=b08e2b19ef9675c980d636e9babcf9f1&chksm=bea6a00289d129146f028b2fb1916922c02951753b20038bc81d9da9cccacf8dacfdc78b2ca5&scene=0&xtrack=1&key=1873ed4ed1cb893e98d1e62d791e4e0b536553a6d359f68fd7ca45c17ea4f1a2efd40c5531ca321d1369e70a520dd5d90589f97cd95685e8bc9bcb8c4562c3a7024317567865a993177e183ee38cbf3a&ascene=14&uin=MTcwODI1NDk2MQ%3D%3D&devicetype=Windows+10&version=62060833&lang=zh_CN&pass_ticket=QhKqIhrAMd1ceNUN8raEuIkkHlehClJtmU%2Bd5zdxn31zKtm3Nr3VZVOHs3xXh8xm
[Link 3]: https://victorzhou.com/blog/intro-to-neural-networks/
[Link 4]: https://victorzhou.com/blog/intro-to-cnns-part-1/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70]: /images/20220112/e8212923f3cf4ee7be8e2b6bc21b7214.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 1]: /images/20220112/d9a9b63451c04a409f4ce683e6968859.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 2]: /images/20220112/afd512b22b164daba6e9dc75c52a487e.png
[20190618225111504.png]: /images/20220112/94e4fb0e6d464f6d8d783a9c1538016e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 3]: /images/20220112/8f072995ea144f18ba47437d8ab1a37b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 4]: /images/20220112/faffbddadd4848b4ba46f7ca3dd9a9f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 5]: /images/20220112/e2a638ed85834c85a2481570bd76439d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 6]: /images/20220112/0685132c755c4a35b6db744a8e5abde7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 7]: /images/20220112/2d19a2c5a8da447887fdabc1721b6cf9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 8]: /images/20220112/b0891872954545d884a7492c0ff8e19d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 9]: /images/20220112/e4812507ed784f239f06ae04309150e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 10]: /images/20220112/98edca0f82344c9ca260398d8496e4b3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 11]: /images/20220112/ae79bcb8fe70466e802abaebe8f383c3.png
[Numpy_]: https://blog.csdn.net/zimiao552147572/article/details/91157311
[20190618225709372.gif]: /images/20220112/e822d2f903dd4f9cbed97d69b6991f10.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 12]: /images/20220112/0ab72015346d46c09979e3b95668309e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 13]: /images/20220112/c82822cc33cf4e1ba3183f3acd681659.png