卷积神经网络、比较MLPS和CNNS、滤波器、CNN各层的作用、在Pytorch可视化CNN

青旅半醒 2022-10-29 15:20 165阅读 0赞

1.33.卷积神经网络  
1.33.1.卷积 和 神经网络  
1.33.1.1.比较MLPS和CNNS  
1.33.1.2.计算机如何看图像？  
1.33.1.3.建立自己的滤波器  
1.33.2.完整的卷积神经网络（CNNS）  
1.33.2.1.CNN各层的作用  
1.33.2.2.在Pytorch可视化CNN

## 1.33.卷积神经网络 ##

参考文章：  
https://blog.csdn.net/kstheme/article/details/99689564  
https://blog.csdn.net/zsd0819qwq/article/details/105396364  
https://www.cnblogs.com/wangqinze/p/13508801.html

卷积神经网络（CNN）是一种人工神经网络结构，因为利用卷积神经网络在**图像**和**语音识别**方面能够给出更优预测结果，这一技术也被广泛的传播可应用。卷积神经网络最常被应用的方面是计算的图像识别，不过因为不断的创新，也被应用在视频分析，自然语言处理，药物发现，等等。

**应用案例：**  
智能手机可以识别相机中的面部。  
使用Google图片搜索特定照片的能力。  
从条形码或书籍中扫描文本。

### 1.33.1.卷积 和 神经网络 ###

什么是卷积神经网络？我们可以把这个词拆开成为“卷积”和“神经网络”。

卷积也就是说神经网络不再是对每个像素的输入信息做处理了，而是图片上每一小块像素区域进行处理，这种做法加强了图片信息的连续性。使得神经网络能看到图形，而非一个点。这种做法同时也加深了神经网络对图像的理解。每次收集的时候都只是收集一小块像素区域，然后把收集来的信息进行整理，这时候整理出来的信息有了一些实际上的呈现。然后以同样的步骤，用类似的批量过滤器扫过产生的这些边缘信息，神经网络从这些边缘信息里面总结出更高层的信息结构。经过几次过滤，最后我们把这些信息套入几层普通的全连接神经层进行分类，这样就能得到输入的图片能被分为哪一类的结果了。

神经网络的基本模型由组织在不同层中的神经元组成。每个神经网络都有一个输入层和一个输出层，并根据问题的复杂性增加了许多隐藏层。一旦数据通过这些层，神经元就会学习并识别模式。神经网络的这种表示称为模型。训练完模型后，我们要求网络根据测试数据进行预测。

卷积神经网络（CNN）是一种特殊类型的神经网络，在图像上表现特别出色。卷积神经网络由Yan LeCun在1998年提出，可以识别给定输入图像中存在的数字。使用CNN的其他应用程序包括语音识别，图像分割和文本处理。在卷积神经网络之前，多层感知器（MLP）用于构建图像分类器。

图像分类是指从多波段光栅图像中提取信息类别的任务。多层感知器需要更多的时间和空间来在图片中查找信息，因为每个输入功能都需要与下一层的每个神经元相连。CNN通过使用称为本地连接的概念取代了MLP，该概念涉及将每个神经元仅连接到到输入体积的本地区域。通过允许网络的不同部分专门处理高级功能（如纹理或重复图案），可以最大程度地减少参数数量。

#### 1.33.1.1.比较MLPS和CNNS ####

考虑到MNIST数据集，由于输入图像的大小为28x28 = 784，多层感知器输入层的总数将为784。 网络应该能够预测给定输入图像中的数量，这意味着输出可能属于以下范围中的任何一个，范围从0到9（1、2、3、4、5、6、7、8、9 ）。 在输出层中，我们返回类别分数，例如，如果给定的输入是具有数字“ 3”的图像，则在输出层中，对应的神经元“ 3”比其他神经元具有更高的类别分数。 我们需要包含多少个隐藏层，每个层中应该包含多少个神经元？这是一个编码MLP的示例：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70]  
上面的代码段是使用称为Keras的框架实现的（暂时忽略语法）。它告诉我们在第一个隐藏层中有512个神经元，它们连接到形状为784的输入层。该隐藏层之后是一个随机失活层，该层克服了过拟合的问题。0.2表示在第一个隐藏层之后不考虑神经元的可能性为20％。再次，我们在第二个隐藏层中添加了与第一个隐藏层中相同数量的神经元（512），然后添加了另一个随机失活。最后，我们用包含10个类的输出层结束这组层。具有最高值的此类将是模型预测结果。

这是定义所有层之后的网络多层外观。这种多层感知器的一个缺点是全连接的以供网络学习，这需要更多的时间和空间。MLP仅接受向量作为输入。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 1]

卷积层不使用全连接层，而是使用稀疏连接层，也就是说，它们接受矩阵作为输入，这比MLP更具优势。输入特征连接到本地编码节点。在MLP中，每次节点负责获得对整个画面的理解。在CNN中，我们将图像分解为区域（像素的局部区域）。每个隐藏节点都必须输出层报告，在输出层，输出层将接收到的数据组合起来以找到模式

在我们了解CNN如何在图片中找到信息之前，我们需要了解如何提取特征。卷积神经网络使用不同的图层，每一层将保存图像中的特征。例如，考虑一张狗的照片。每当网络需要对狗进行分类时，它都应该识别所有特征-眼睛，耳朵，舌头，腿等。使用过滤器和核，这些特征被分解并在网络的局部层中识别出来。

#### 1.33.1.2.计算机如何看图像？ ####

与人类通过用眼睛了解图像的计算机不同，计算机使用一组介于0到255之间的像素值来了解图片。计算机查看这些像素值并理解它们。乍一看，它不知道物体或颜色，只识别像素值，这就是图像用于计算机的全部。

在分析像素值之后，计算机会慢慢开始了解图像是灰度还是彩色。它知道差异，因为灰度图像只有一个通道，因为每个像素代表一种颜色的强度。零表示黑色，255表示白色，黑色和白色的其他变化形式，即介于两者之间的灰色。另一方面，彩色图像具有三个通道-红色，绿色和蓝色。它们代表三种颜色（3D矩阵）的强度，并且当值同时变化时，它会产生大量的颜色！确定颜色属性后，计算机会识别图像中对象的曲线和轮廓。

可以使用PyTorch在卷积神经网络中探索此过程，以加载数据集并将滤波器应用于图像。下面是代码片段。（在GitHub上可找到此代码）  
Github地址是：https://github.com/vihar/visualising-cnns/blob/master/01\_MNIST-Image-Overview.ipynb （可以在jupyter notebook启动jupyter）

import torch
    import numpy as np
    
    from torchvision import datasets
    import torchvision.transforms as transforms
    
    num_workers = 0
    batch_size = 20
    
    transform = transforms.ToTensor()
    
    train_data = datasets.MNIST(root='data', train=True,
                                       download=True, transform=transform)
    test_data = datasets.MNIST(root='data', train=False,
                                      download=True, transform=transform)
    
    train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size,
        num_workers=num_workers)
    test_loader = torch.utils.data.DataLoader(test_data, batch_size=batch_size, 
    num_workers=num_workers)
    
    
    import matplotlib.pyplot as plt
    %matplotlib inline
        
    dataiter = iter(train_loader)
    images, labels = dataiter.next()
    images = images.numpy()
    
    fig = plt.figure(figsize=(25, 4))
    for image in np.arange(20):
        ax = fig.add_subplot(2, 20/2, image+1, xticks=[], yticks=[])
        ax.imshow(np.squeeze(images[image]), cmap='gray')
        ax.set_title(str(labels[image].item()))

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 2]

现在，让我们看看如何将单个图像输入神经网络。  
(在GitHub上可找到此代码: https://github.com/vihar/visualising-cnns/blob/master/01\_MNIST-Image-Overview.ipynb)

img = np.squeeze(images[7])
    
    fig = plt.figure(figsize = (12,12)) 
    ax = fig.add_subplot(111)
    ax.imshow(img, cmap='gray')
    width, height = img.shape
    thresh = img.max()/2.5
    for x in range(width):
        for y in range(height):
            val = round(img[x][y],2) if img[x][y] !=0 else 0
            ax.annotate(str(val), xy=(y,x),
                        horizontalalignment='center',
                        verticalalignment='center',
                        color='white' if img[x][y]<thresh else 'black')

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 3]

这就是将数字“ 3”分解为像素的方式。从一组手写数字中，随机选择“ 3”，其中显示像素值。在这里，ToTensor（）归一化实际像素值（0–255）并将其限制为0到1。为什么？因为，这使得以后的部分中的计算更加容易，无论是在解释图像还是找到图像中存在的通用模式。

import cv2
    
    sobel = np.array([[ -1, -2, -1], 
                       [ 0, 0, 0], 
                       [ 1, 2, 1]])
    
    img = np.squeeze(images[7])
    filtered_image = cv2.filter2D(img, -1, sobel)
    
    plt.imshow(filtered_image, cmap='gray')

![在这里插入图片描述][20210215231602885.png]

fig = plt.figure(figsize = (12,12)) 
    ax = fig.add_subplot(111)
    ax.imshow(filtered_image, cmap='gray')
    width, height = filtered_image.shape
    thresh = filtered_image.max()/2.5
    for x in range(width):
        for y in range(height):
            val = round(img[x][y],2) if filtered_image[x][y] !=0 else 0
            ax.annotate(str(val), xy=(y,x),
                        color='white' if filtered_image[x][y]<thresh else 'black')

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 4]

filter4x4 = filter_vals = np.array([[-1, -1, 1, 1], [-1, -1, 1, 1], [-1, -1, 1, 1], [-1, -1, 1, 1]])
    img = np.squeeze(images[7])
    filtered_image = cv2.filter2D(img, -1, filter4x4)
    plt.imshow(filtered_image, cmap='gray')

![在这里插入图片描述][20210215231820420.png]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 5]

#### 1.33.1.3.建立自己的滤波器 ####

在卷积神经网络中，图像中的像素信息被过滤。为什么我们完全需要滤波器？就像孩子一样，计算机需要经历了解图像的学习过程。值得庆幸的是，这不需要几年的时间！计算机通过从头开始学习，然后逐步进行到整体来完成此任务。因此，网络必须首先知道图像中的所有原始部分，例如边缘，轮廓和其他低层特征。一旦检测到这些，计算机便可以处理更复杂的功能。简而言之，必须先提取低级功能，然后再提取中级功能，然后再提取高级功能。滤波器提供了一种提取信息的方法。

可以使用特定的滤波器提取低级特征，该滤波器也是类似于图像的一组像素值。可以理解为连接CNN中各层的权重。将这些权重或滤波器与输入相乘，得出中间图像，中间图像表示计算机对图像的部分理解。然后，这些副产品再与更多的滤波器相乘以扩展视图。该过程以及对功能的检测一直持续到计算机了解其外观为止。

您可以根据自己的需要使用很多滤波器。您可能需要模糊，锐化，加深，进行边缘检测等-都是滤波器。

让我们看一些代码片段，以了解滤波器的功能(以下代码可以在github: https://github.com/vihar/visualising-cnns/blob/master/02\_Writing%20Your%20Own%20Filter.ipynb)。

import matplotlib.pyplot as plt
    import matplotlib.image as mpimg
    
    import cv2
    import numpy as np
    
    %matplotlib inline
    
    image = mpimg.imread('dog.jpg')
    
    plt.imshow(image)

![在这里插入图片描述][20210215232212656.png]

gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
    
    plt.imshow(gray, cmap='gray')

![在这里插入图片描述][20210215232406345.png]

custom_2x2 = np.array([[1,0],
                           [1,0]])
    
    filtered_image = cv2.filter2D(gray, -1, custom_2x2)
    
    plt.imshow(filtered_image, cmap='gray')

![在这里插入图片描述][20210215232505873.png]

sobel_y = np.array([[ -1, -2, -1], 
                       [ 0, 0, 0], 
                       [ 1, 2, 1]])
    
    ## TODO: Create and apply a Sobel x operator
    
    
    # Filter the image using filter2D, which has inputs: (grayscale image, bit-depth, kernel) 
    filtered_image = cv2.filter2D(gray, -1, sobel_y)
    
    plt.imshow(filtered_image, cmap='gray')

![在这里插入图片描述][20210215232715971.png]  
这是应用滤波器后图像的外观。这种情况下，我们使用了Sobel滤波器。

### 1.33.2.完整的卷积神经网络（CNNS） ###

我们已经知道滤波器是如何从图像中提出特征了，但是为了完成整个卷积神经网络我们需要理解用来设计CNN的各层。卷积神经网络中的各层分别叫做：  
卷积层  
池化层  
全连接层

**卷积神经网络包含卷积层（Convolution）、非线性激活层（常用ReLU层）、池化层（pooling）、全连接层（Full-Connected）和Softmax层。卷积神经网络的基本结构如下图所示。**  
![在这里插入图片描述][2021021523282352.png]

#### 1.33.2.1.CNN各层的作用 ####

**卷积层**—卷积层（CONV）使用过滤器执行卷积操作，同时扫描输入图像的尺寸。它的超参数包括滤波器尺寸，通常设置为2 \* 2, 3 \* 3, 4 \* 4, 5 \* 5（但并不仅仅限于这些尺寸），步长（S）。输出结果（O）被称为特征图或激活图，包含了输入层和滤波器计算出的所有特征。下图描述了应用卷积时产生的特殊图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 6]  
卷积操作，左侧图像是6 \* 6的大小，滤波器尺寸大小为3 \* 3，步长为1，经过卷积操作之后，变成了4 \* 4的大小。

**池化层**–池化层（POOL）用于特征的降采样，通常在卷积层之后应用。常见的两种池化操作为最大池化和平均池化，分别求取特征的最大值和平均值。下图描述了池化的基本原理：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 7]  
最大池化  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 8]  
平均池化

**全连接层**—全连接层(FC)作用于一个扁平的输入，其中每个输入都连接到所有的神经元。全连接层通常用于网络的末端，将隐藏层连接到输出层，这有助于优化类分数。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 9]  
**全连接层**

#### 1.33.2.2.在Pytorch可视化CNN ####

我们对CNN的函数有了更好的了解，现在让我们使用Facebook的PyTorch框架来实现它。

**步骤1**：加载输入图像。我们将使用NumPy和OpenCV。（在GitHub上可找到代码: https://github.com/vihar/visualising-cnns/blob/master/02\_Writing%20Your%20Own%20Filter.ipynb）

import matplotlib.pyplot as plt
    import matplotlib.image as mpimg
    
    import cv2
    import numpy as np
    
    %matplotlib inline
    img_path = 'dog.jpg'
    bgr_img = cv2.imread(img_path)
    gray_img = cv2.cvtColor(bgr_img, cv2.COLOR_BGR2GRAY)
    
    # Normalise
    gray_img = gray_img.astype("float32")/255
    plt.imshow(gray_img, cmap='gray')
    plt.show()

![在这里插入图片描述][20210215233616280.png]

**步骤2**：可视化滤波器，以更好地了解我们将使用的滤波器。（在GitHub上可找到代码:https://github.com/vihar/visualising-cnns/blob/master/02\_Writing%20Your%20Own%20Filter.ipynb）

import numpy as np
    
    filter_vals = np.array([
    [-1, -1, 1, 1], 
    [-1, -1, 1, 1], 
    [-1, -1, 1, 1], 
    [-1, -1, 1, 1]
    ])
    print('Filter shape: ', filter_vals.shape)
    
    
    # define four filters
    filter_1 = filter_vals
    filter_2 = -filter_1
    filter_3 = filter_1.T
    filter_4 = -filter_3
    filters = np.array([filter_1, filter_2, filter_3, filter_4])
    
    # For an example, print out the values of filter 1
    print('Filter 1: \n', filter_1)
    
    
    fig = plt.figure(figsize=(10, 5))
    for i in range(4):
        ax = fig.add_subplot(1, 4, i+1, xticks=[], yticks=[])
        ax.imshow(filters[i], cmap='gray')
        ax.set_title('Filter %s' % str(i+1))
        width, height = filters[i].shape
        for x in range(width):
            for y in range(height):
                ax.annotate(str(filters[i][x][y]), xy=(y,x),
                            color='white' if filters[i][x][y]<0 else 'black')

![在这里插入图片描述][20210215233747730.png]  
**步骤3**：定义卷积神经网络。该CNN具有卷积层和最大池化层，并且权重使用上述滤波器进行初始化：（GitHub上可找到代码:https://github.com/vihar/visualising-cnns/blob/master/03\_CNN%20Layers%20Visualisations%20.ipynb）

import torch
    import torch.nn as nn
    import torch.nn.functional as F
        
    
    class Net(nn.Module):
        
        def __init__(self, weight):
            super(Net, self).__init__()
            # initializes the weights of the convolutional layer to be the weights of the 4 defined filters
            k_height, k_width = weight.shape[2:]
            # assumes there are 4 grayscale filters
            self.conv = nn.Conv2d(1, 4, kernel_size=(k_height, k_width), bias=False)
            self.conv.weight = torch.nn.Parameter(weight)
            # define a pooling layer
            self.pool = nn.MaxPool2d(2, 2)
    
        def forward(self, x):
            # calculates the output of a convolutional layer
            # pre- and post-activation
            conv_x = self.conv(x)
            activated_x = F.relu(conv_x)
            
            # applies pooling layer
            pooled_x = self.pool(activated_x)
            
            # returns all layers
            return conv_x, activated_x, pooled_x
        
    # instantiate the model and set the weights
    weight = torch.from_numpy(filters).unsqueeze(1).type(torch.FloatTensor)
    model = Net(weight)
    
    # print out the layer in the network
    print(model)

**步骤4**：可视化滤波器。快速浏览一下正在使用的滤波器。（在GitHub上可找到代码）

def viz_layer(layer, n_filters= 4):
        fig = plt.figure(figsize=(20, 20))
        
        for i in range(n_filters):
            ax = fig.add_subplot(1, n_filters, i+1)
            ax.imshow(np.squeeze(layer[0,i].data.numpy()), cmap='gray')
            ax.set_title('Output %s' % str(i+1))
    
    
    # plt.imshow(gray_img, cmap='gray')
    
    fig = plt.figure(figsize=(12, 6))
    fig.subplots_adjust(left=0, right=1.5, bottom=0.8, top=1, hspace=0.05, wspace=0.05)
    
    
    for i in range(4):
        ax = fig.add_subplot(1, 4, i+1, xticks=[], yticks=[])
        ax.imshow(filters[i], cmap='gray')
        ax.set_title('Filter %s' % str(i+1))
    
        
    gray_img_tensor = torch.from_numpy(gray_img).unsqueeze(0).unsqueeze(1)
    conv_x, activated_layer, pooled_layer = model.forward(gray_img_tensor)

![在这里插入图片描述][20210215233933722.png]  
**滤波器：**  
![在这里插入图片描述][20210215234003302.png]  
\*\*步骤5：\*\*跨层滤波器输出。在CONV和POOL层中输出的图像如下所示：

viz_layer(activated_layer)
    viz_layer(pooled_layer)

**卷积层**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 10]  
**池化层**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 11]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70]: /images/20221024/b01c5afc1e5c40b281e205de1144fb6e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 1]: /images/20221024/af1940498bc24764bfe3b2a02f46a70c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 2]: /images/20221024/17de120ebb83464b8515db44eccfc566.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 3]: /images/20221024/57fb90a823ed47ac93e69b3e6ca6e472.png
[20210215231602885.png]: /images/20221024/29b62f5dd1d045a9bb6cded02b696f38.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 4]: /images/20221024/f022f86d98994a94b839a5abd0480bfd.png
[20210215231820420.png]: /images/20221024/d90de65c8c014769a73f53797b497563.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 5]: /images/20221024/9a35daf877c6474cb615069f40d24f60.png
[20210215232212656.png]: /images/20221024/e0465a5027d34e5dbe34c6915fe82b07.png
[20210215232406345.png]: /images/20221024/85b0832837264789b0a3054670de9ac6.png
[20210215232505873.png]: /images/20221024/6c60457b268a429e9d092314d60faba1.png
[20210215232715971.png]: /images/20221024/2f954e90c6494034ba96070ae1d06b07.png
[2021021523282352.png]: /images/20221024/c2f200478d454897be23113c4491e3ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 6]: /images/20221024/d44003167df047f893ba5b03ba814e13.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 7]: /images/20221024/f8574a8dbda74dae97d3ffe9f0e0594f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 8]: /images/20221024/90bd5ed711e144bd829a1f6d8b5230b9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 9]: /images/20221024/81cb8c12d6c8406da2e2dd15b5b3ead7.png
[20210215233616280.png]: /images/20221024/c86f749d924340529f6463d8a61d9015.png
[20210215233747730.png]: /images/20221024/a6901876567746ebae1d5f6ea2dca0c7.png
[20210215233933722.png]: /images/20221024/8f6b75cc63b94ac58834a086e9b513a5.png
[20210215234003302.png]: /images/20221024/51d2c7b70b48498b84cf745bdb049ddf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 10]: /images/20221024/6ee8a55c9fe245f38a66c6bfaa7f0f75.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RvdG8xMjk3NDg4NTA0_size_16_color_FFFFFF_t_70 11]: /images/20221024/186588725809427b95ce812648b0ad51.png