基于经典网络架构训练图像分类模型（102类花的数据集）

亦凉 2022-09-11 08:24 309阅读 0赞

# 基于经典网络架构训练图像分类模型（102类花的数据集） #

基于经典网络架构训练图像分类模型（102类花的数据集）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center]

> 模块的官方网址：https://pytorch.org/docs/stable/torchvision/index.html  
> 站在巨人的肩膀上学习，调用人家写好的厉害的东西

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

点进去torchvision.models模块后可以看到各种经典网络，再点进去可以看到例子教你怎么调用：

![åœ¨è¿™é‡Œæ’å¥å›¾ç‰‡æè¿°][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 3]

## 1.导入需要用到的库 ##

import os
    import matplotlib.pyplot as plt
    %matplotlib inline
    import numpy as np
    import torch
    from torch import nn
    import torch.optim as optim
    import torchvision
    #pip install torchvision    #如果你的电脑没有安装torchvision模块就得去用这个指令安装
    from torchvision import transforms, models, datasets
    #https://pytorch.org/docs/stable/torchvision/index.html  #模块的官方网址，上面例子有教你怎么用
    import imageio
    import time
    import warnings
    import random
    import sys
    import copy
    import json
    from PIL import Image

## 2.数据读取与预处理操作 ##

102分类的花的数据集百度云盘下载

> 链接：https://pan.baidu.com/s/1aEJIyJs7rtZfMQpZQgC\_6g  
> 提取码：3o1q

下载好后放在代码同目录下进行数据读取：

data_dir = './flower_data/'
    train_dir = data_dir + '/train'
    valid_dir = data_dir + '/valid'

### 2.1数据增强 ###

data\_transforms 中指定了所有图像预处理操作

ImageFolder 假设所有的文件按文件夹保存好，每个文件夹下面存贮同一类别的图片，文件夹的名字为分类的名字

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

data_transforms = {
        'train': transforms.Compose([transforms.RandomRotation(45),#随机旋转，-45到45度之间随机选
            transforms.CenterCrop(224),#从中心开始裁剪，留下224*224的。（随机裁剪得到的数据更多）
            transforms.RandomHorizontalFlip(p=0.5),#随机水平翻转 选择一个概率去翻转，0.5就是50%翻转，50%不翻转
            transforms.RandomVerticalFlip(p=0.5),#随机垂直翻转
            transforms.ColorJitter(brightness=0.2, contrast=0.1, saturation=0.1, hue=0.1),#参数1为亮度，参数2为对比度，参数3为饱和度，参数4为色相
            transforms.RandomGrayscale(p=0.025),#概率转换成灰度率，3通道就是R=G=B
            transforms.ToTensor(),  #转成tensor的格式
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])#均值，标准差（拿人家算好的）
        ]),
        'valid': transforms.Compose([transforms.Resize(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) #要和训练集保持一致的标准化操作
        ]),
    }

#### 2.2、Batch数据制作 ####

batch_size = 8
    
    image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x]) for x in ['train', 'valid']}
    dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=batch_size, shuffle=True) for x in ['train', 'valid']}
    dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'valid']}
    class_names = image_datasets['train'].classes

image_datasets

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

dataloaders

![在这里插入图片描述][20200917160359713.png_pic_center]

dataset_sizes

![在这里插入图片描述][20200917160418529.png_pic_center]

#### 2.3、读取标签对应的实际名字（方便我们后期查看对应的类别名字） ####

> json文件百度云盘  
> 链接：https://pan.baidu.com/s/18xbAXdMABtqpPSUWh1FbFg  
> 提取码：v2aa

with open('cat_to_name.json', 'r') as f:
        cat_to_name = json.load(f)
    
    cat_to_name

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 6]

### 2.4 数据可视化 ###

注意tensor的数据需要转换成numpy的格式，而且还需要还原回标准化的结果

def im_convert(tensor):
        """ 展示数据"""
        
        image = tensor.to("cpu").clone().detach()
        image = image.numpy().squeeze()
        image = image.transpose(1,2,0)
        image = image * np.array((0.229, 0.224, 0.225)) + np.array((0.485, 0.456, 0.406)) #还原回去
        image = image.clip(0, 1)
    
        return image

fig=plt.figure(figsize=(20, 12))
    columns = 4
    rows = 2
    
    dataiter = iter(dataloaders['valid'])
    inputs, classes = dataiter.next()
    
    for idx in range (columns*rows):
        ax = fig.add_subplot(rows, columns, idx+1, xticks=[], yticks=[])
        ax.set_title(cat_to_name[str(int(class_names[classes[idx]]))])
        plt.imshow(im_convert(inputs[idx]))
    plt.show()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 7]

## 三、用迁移学习来做 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 8]

用别人用大量数据集训练出来的权重来初始化（尽可能选和我们目标相似的项目的权重）

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 9]

两种方案进行迁移学习：

① 用别人训练好的权重来给我们当做初始化权重，然后我们继续对我们的数据集进行训练得到我们的权重模型。

② 直接拿别人训练好的权重模型来做特征提取，我们不自己训练了，冻住卷积神经网络的参数更新迭代，我们就改训练用来分类的全连接层就好了。

我们下面用第 ② 种方案来做

### 3.1、加载models中提供的模型，并且直接用训练的好权重当做初始化参数 ###

第一次执行需要下载，可能会比较慢（根据你的网络状况）

model_name = 'resnet'  #可选的比较多 ['resnet', 'alexnet', 'vgg', 'squeezenet', 'densenet', 'inception']
    #是否用人家训练好的特征来做
    feature_extract = True 
    
    # 是否用GPU训练
    train_on_gpu = torch.cuda.is_available()
    
    if not train_on_gpu:
        print('CUDA is not available.  Training on CPU ...')
    else:
        print('CUDA is available!  Training on GPU ...')
        
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

![在这里插入图片描述][20200917163252840.png_pic_center]

def set_parameter_requires_grad(model, feature_extracting):
        if feature_extracting:
            for param in model.parameters():
                param.requires_grad = False
    
    
    
    model_ft = models.resnet152()
    model_ft

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 10]

### 3.2参考pytorch官网例子 ###

def initialize_model(model_name, num_classes, feature_extract, use_pretrained=True):
        # 选择合适的模型，不同模型的初始化方法稍微有点区别
        model_ft = None
        input_size = 0
    
        if model_name == "resnet":
            """ Resnet152
            """
            model_ft = models.resnet152(pretrained=use_pretrained)
            set_parameter_requires_grad(model_ft, feature_extract)
            num_ftrs = model_ft.fc.in_features
            model_ft.fc = nn.Sequential(nn.Linear(num_ftrs, 102),
                                       nn.LogSoftmax(dim=1))
            input_size = 224
    
        elif model_name == "alexnet":
            """ Alexnet
            """
            model_ft = models.alexnet(pretrained=use_pretrained)
            set_parameter_requires_grad(model_ft, feature_extract)
            num_ftrs = model_ft.classifier[6].in_features
            model_ft.classifier[6] = nn.Linear(num_ftrs,num_classes)
            input_size = 224
    
        elif model_name == "vgg":
            """ VGG11_bn
            """
            model_ft = models.vgg16(pretrained=use_pretrained)
            set_parameter_requires_grad(model_ft, feature_extract)
            num_ftrs = model_ft.classifier[6].in_features
            model_ft.classifier[6] = nn.Linear(num_ftrs,num_classes)
            input_size = 224
    
        elif model_name == "squeezenet":
            """ Squeezenet
            """
            model_ft = models.squeezenet1_0(pretrained=use_pretrained)
            set_parameter_requires_grad(model_ft, feature_extract)
            model_ft.classifier[1] = nn.Conv2d(512, num_classes, kernel_size=(1,1), stride=(1,1))
            model_ft.num_classes = num_classes
            input_size = 224
    
        elif model_name == "densenet":
            """ Densenet
            """
            model_ft = models.densenet121(pretrained=use_pretrained)
            set_parameter_requires_grad(model_ft, feature_extract)
            num_ftrs = model_ft.classifier.in_features
            model_ft.classifier = nn.Linear(num_ftrs, num_classes)
            input_size = 224
    
        elif model_name == "inception":
            """ Inception v3
            Be careful, expects (299,299) sized images and has auxiliary output
            """
            model_ft = models.inception_v3(pretrained=use_pretrained)
            set_parameter_requires_grad(model_ft, feature_extract)
            # Handle the auxilary net
            num_ftrs = model_ft.AuxLogits.fc.in_features
            model_ft.AuxLogits.fc = nn.Linear(num_ftrs, num_classes)
            # Handle the primary net
            num_ftrs = model_ft.fc.in_features
            model_ft.fc = nn.Linear(num_ftrs,num_classes)
            input_size = 299
    
        else:
            print("Invalid model name, exiting...")
            exit()
    
        return model_ft, input_size

#### 3.3、设置哪些层需要训练 ####

model_ft, input_size = initialize_model(model_name, 102, feature_extract, use_pretrained=True) #改成我们要训练的102类
    
    #GPU计算
    model_ft = model_ft.to(device)
    
    # 模型保存
    filename='checkpoint.pth'
    
    # 是否训练所有层
    params_to_update = model_ft.parameters()
    print("Params to learn:")
    if feature_extract:
        params_to_update = []
        for name,param in model_ft.named_parameters():
            if param.requires_grad == True:
                params_to_update.append(param)
                print("\t",name)
    else:
        for name,param in model_ft.named_parameters():
            if param.requires_grad == True:
                print("\t",name)

这里会下载别人训练好的resnet的权重模型，我们用他的权重来进行我们的特征提取。

![在这里插入图片描述][20200917164313362.png_pic_center]

### 四、优化器设置 ###

# 优化器设置
    optimizer_ft = optim.Adam(params_to_update, lr=1e-2)
    scheduler = optim.lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1)#学习率每7个epoch衰减成原来的1/10
    #最后一层已经LogSoftmax()了，所以不能nn.CrossEntropyLoss()来计算了，nn.CrossEntropyLoss()相当于logSoftmax()和nn.NLLLoss()整合
    criterion = nn.NLLLoss()

### 五、训练模块 ###

训练我们最后的层，前面的用人家训练好的权重模型

def train_model(model, dataloaders, criterion, optimizer, num_epochs=25, is_inception=False,filename=filename):
        since = time.time()
        best_acc = 0
        """
        checkpoint = torch.load(filename)
        best_acc = checkpoint['best_acc']
        model.load_state_dict(checkpoint['state_dict'])
        optimizer.load_state_dict(checkpoint['optimizer'])
        model.class_to_idx = checkpoint['mapping']
        """
        model.to(device)   #用GPU训练
    
        val_acc_history = []
        train_acc_history = []
        train_losses = []
        valid_losses = []
        LRs = [optimizer.param_groups[0]['lr']]
    
        best_model_wts = copy.deepcopy(model.state_dict())
    
        for epoch in range(num_epochs):
            print('Epoch {}/{}'.format(epoch, num_epochs - 1))
            print('-' * 10)
    
            # 训练和验证
            for phase in ['train', 'valid']:
                if phase == 'train':
                    model.train()  # 训练
                else:
                    model.eval()   # 验证
    
                running_loss = 0.0
                running_corrects = 0
    
                # 把数据都取个遍
                for inputs, labels in dataloaders[phase]:
                    inputs = inputs.to(device)   #将input传入GPU计算
                    labels = labels.to(device)   #将labels传入GPU计算
    
                    # 清零
                    optimizer.zero_grad()
                    # 只有训练的时候计算和更新梯度
                    with torch.set_grad_enabled(phase == 'train'):
                        if is_inception and phase == 'train':
                            outputs, aux_outputs = model(inputs)
                            loss1 = criterion(outputs, labels)
                            loss2 = criterion(aux_outputs, labels)
                            loss = loss1 + 0.4*loss2
                        else:#resnet执行的是这里
                            outputs = model(inputs)
                            loss = criterion(outputs, labels)
    
                        _, preds = torch.max(outputs, 1)
    
                        # 训练阶段更新权重
                        if phase == 'train':
                            loss.backward()
                            optimizer.step()
    
                    # 计算损失
                    running_loss += loss.item() * inputs.size(0)
                    running_corrects += torch.sum(preds == labels.data)
    
                epoch_loss = running_loss / len(dataloaders[phase].dataset)
                epoch_acc = running_corrects.double() / len(dataloaders[phase].dataset)
                
                
                time_elapsed = time.time() - since
                print('Time elapsed {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))
                print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc))
                
    
                # 得到最好那次的模型
                if phase == 'valid' and epoch_acc > best_acc:
                    best_acc = epoch_acc
                    best_model_wts = copy.deepcopy(model.state_dict())
                    state = {
                      'state_dict': model.state_dict(),
                      'best_acc': best_acc,
                      'optimizer' : optimizer.state_dict(),
                    }
                    torch.save(state, filename)
                if phase == 'valid':
                    val_acc_history.append(epoch_acc)
                    valid_losses.append(epoch_loss)
                    scheduler.step(epoch_loss)
                if phase == 'train':
                    train_acc_history.append(epoch_acc)
                    train_losses.append(epoch_loss)
            
            print('Optimizer learning rate : {:.7f}'.format(optimizer.param_groups[0]['lr']))
            LRs.append(optimizer.param_groups[0]['lr'])
            print()
    
        time_elapsed = time.time() - since
        print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))
        print('Best val Acc: {:4f}'.format(best_acc))
    
        # 训练完后用最好的一次当做模型最终的结果
        model.load_state_dict(best_model_wts)
        return model, val_acc_history, train_acc_history, valid_losses, train_losses, LRs

**开始训练**

model_ft,val_acc_history, train_acc_history, valid_losses, train_losses, LRs = train_model(
    model_ft,
    dataloaders,
    criterion,
    optimizer_ft,
    num_epochs=20, 
    is_inception=(model_name=="inception"))

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 11]

train loss 不断下降，test loss不断下降，说明网络仍在学习;（最好的）

train loss 不断下降，test loss趋于不变，说明网络过拟合;（max pool或者正则化）

train loss 趋于不变，test loss不断下降，说明数据集100%有问题;（检查dataset）

train loss 趋于不变，test loss趋于不变，说明学习遇到瓶颈，需要减小学习率或批量数目;（减少学习率）

train loss 不断上升，test loss不断上升，说明网络结构设计不当，训练超参数设置不当，数据集经过清洗等问题。（最不好的情况）

### 六、在我们训练后得到的best权重后再训练，现在是全部训练了 ###

在我们训练出来的权重模型当成初始化权重进行进一步训练，现在是训练所有的层了（从头开始用我们的数据集训练）。

for param in model_ft.parameters():
        param.requires_grad = True
    
    # 再继续训练所有的参数，学习率调小一点
    optimizer = optim.Adam(params_to_update, lr=1e-4)
    scheduler = optim.lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1)
    
    # 损失函数
    criterion = nn.NLLLoss()

# Load the checkpoint
    
    checkpoint = torch.load(filename)
    best_acc = checkpoint['best_acc']
    model_ft.load_state_dict(checkpoint['state_dict'])
    optimizer.load_state_dict(checkpoint['optimizer'])
    #model_ft.class_to_idx = checkpoint['mapping']

**开始训练：**

model_ft,val_acc_history,train_acc_history,valid_losses,train_losses,LRs  = 
    train_model(model_ft,
    dataloaders,
    criterion,
    optimizer,
    num_epochs=10,
    is_inception=(model_name=="inception"))

![在这里插入图片描述][20200917170843942.png_pic_center]

### 七、测试网络效果 ###

![在这里插入图片描述][20200917170949816.png_pic_center]

#### 7.1、加载训练好的模型 ####

model_ft, input_size = initialize_model(model_name, 102, feature_extract, use_pretrained=True)
    
    # GPU模式
    model_ft = model_ft.to(device)
    
    # 保存文件的名字
    filename='checkpoint.pth'
    
    # 加载模型
    checkpoint = torch.load(filename)
    best_acc = checkpoint['best_acc']
    model_ft.load_state_dict(checkpoint['state_dict'])

![在这里插入图片描述][20200917171109752.png_pic_center]

### 7.2、测试数据预处理 ###

测试数据处理方法需要跟训练时一直才可以  
crop操作的目的是保证输入的大小是一致的  
标准化操作也是必须的，用跟训练数据相同的mean和std,但是需要注意一点训练数据是在0-1上进行标准化，所以测试数据也需要先归一化  
PyTorch中颜色通道是第一个维度，跟很多工具包都不一样，需要转换

def process_image(image_path):
        # 读取测试数据
        img = Image.open(image_path)
        # Resize,thumbnail方法只能进行缩小，所以进行了判断
        if img.size[0] > img.size[1]:
            img.thumbnail((10000, 256))
        else:
            img.thumbnail((256, 10000))
        # Crop操作
        left_margin = (img.width-224)/2
        bottom_margin = (img.height-224)/2
        right_margin = left_margin + 224
        top_margin = bottom_margin + 224
        img = img.crop((left_margin, bottom_margin, right_margin,   
                          top_margin))
        # 相同的预处理方法
        img = np.array(img)/255
        mean = np.array([0.485, 0.456, 0.406]) #provided mean
        std = np.array([0.229, 0.224, 0.225]) #provided std
        img = (img - mean)/std
        
        # 注意颜色通道应该放在第一个位置
        img = img.transpose((2, 0, 1))
        
        return img

def imshow(image, ax=None, title=None):
        """展示数据"""
        if ax is None:
            fig, ax = plt.subplots()
        
        # 颜色通道还原
        image = np.array(image).transpose((1, 2, 0))
        
        # 预处理还原
        mean = np.array([0.485, 0.456, 0.406])
        std = np.array([0.229, 0.224, 0.225])
        image = std * image + mean
        image = np.clip(image, 0, 1)
        
        ax.imshow(image)
        ax.set_title(title)
        
        return ax

在验证集随便选一张花的图片放到代码同目录下进行测试，我这里选的是‘image\_06621.jpg’这张。

image_path = 'image_06621.jpg'
    img = process_image(image_path)
    imshow(img)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 12]

# 得到一个batch的测试数据
    dataiter = iter(dataloaders['valid'])
    images, labels = dataiter.next()
    
    model_ft.eval()
    
    if train_on_gpu:
        output = model_ft(images.cuda())
    else:
        output = model_ft(images)

output表示对一个batch中每一个数据得到其属于各个类别的可能性

![在这里插入图片描述][20200917171356172.png_pic_center]

#### 7.3、得到概率最大的那个 ####

_, preds_tensor = torch.max(output, 1)
    
    preds = np.squeeze(preds_tensor.numpy()) if not train_on_gpu else np.squeeze(preds_tensor.cpu().numpy())
    preds

#### 7.4、展示预测结果 ####

fig=plt.figure(figsize=(20, 20))
    columns =4
    rows = 2
    
    for idx in range (columns*rows):
        ax = fig.add_subplot(rows, columns, idx+1, xticks=[], yticks=[])
        plt.imshow(im_convert(images[idx]))
        ax.set_title("{} ({})".format(cat_to_name[str(preds[idx])], cat_to_name[str(labels[idx].item())]),
                     color=("green" if cat_to_name[str(preds[idx])]==cat_to_name[str(labels[idx].item())] else "red"))
    plt.show()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 13]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center]: /images/20220828/f4ce820188294394b5f718818ebc2415.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20200917151810369.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20220828/3fe2ff79feca436b8369335a048d234c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20220828/ee2db068f65e492fafae4b50a3179b85.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20220828/489227debdf347ed952b8c0dd804a39d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20220828/2b1c9e6b14ca419f9ce7db326b11b870.png
[20200917160359713.png_pic_center]: /images/20220828/b9f55030b160449ab25d552411dc7b4f.png
[20200917160418529.png_pic_center]: /images/20220828/0ce94ef2084746f6b57d50145ee82067.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20220828/a3feaada2052409990ad6595f97b8ff7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20220828/07fd9b93a2ba492b855788c250a15dfa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20220828/d26fec06ed0144cf817be7536e5f0311.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20220828/e454659293e94527b28096b44856cc38.png
[20200917163252840.png_pic_center]: /images/20220828/ac60ae463f754940a54c15abfb6840ac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20220828/4c0c0f8d9f1f438983542372cf46efba.png
[20200917164313362.png_pic_center]: /images/20220828/64ee93bf8e3943da97edfc84fbd91bf5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20220828/c5f1ab2dc9824267933aad6522696837.png
[20200917170843942.png_pic_center]: /images/20220828/bf53e73c43ee46bdb6c1f594b83263ae.png
[20200917170949816.png_pic_center]: /images/20220828/6e277987c079466db39620d6cb7c29b8.png
[20200917171109752.png_pic_center]: /images/20220828/2a24cc22f7ad4a9fb8dc3a348aa6f89a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20220828/96eab4bd0cde4f709cf1ac1cd2e9ec55.png
[20200917171356172.png_pic_center]: /images/20220828/63b7dfcb19cf4f7e8fe4b1f5db00ad27.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpdXppdGFv_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20220828/bbc48c0ecbc1453dac0ac587598c7f81.png