基于PaddlePaddle平台训练物体分类——猫狗分类

学习目标：

在百度的PaddlePaddle平台训练自己需要的模型，以训练一个猫狗分类模型为例

PaddlePaddle平台：

• 飞桨（PaddlePaddle）是百度开发的深度学习平台，具有动静统一框架、端到端开发套件等特性，支持大规模分布式训练和高性能推理
• 作为中国首个自主研发的产业级平台，飞桨在市场份额和应用规模上均居中国第一，服务了800万开发者和22万家企事业单位，广泛应用于金融、能源、制造、交通等领域

---

学习概述：

• 基于百度的PaddlePaddle平台训练猫狗分类模型

• 学习使用PaddlePaddle平台的使用方法，其中包括寻找数据集、运行环境配置、数据预处理、训练、计算预估准确率、使用ncc工具将模型转换为kmodel模型文件等

---

训练方法：

1、寻找数据集：我们可以在搜索框搜索猫和狗，选择一个合适大小的猫与狗的数据集，便于后面训练模型，数据集样本的数量直接影响训练模型的正确率、迭代次数、训练时间等（点击跳转）

---

2、运行环境配置：首先创建一个Notebook项目，然后填写项目名称、数据集配置，此处使用AI Studio经典版、PaddlePaddle 2.4.0框架，接下来选择运行环境，我们选择免费的两核CPU就可以，然后运行创建配置好的项目

---

3、数据预处理：可以看到项目中有两个文件夹work和data，work目录下的变更会持久保存，但data目录下的变更重启环境后会自动还原。在右侧Notebook编译区可以新建代码脚本等

1. 将data目录下的猫狗.zip重命名为catanddog.zip，新建Code并运行解压数据集

# 解压猫狗数据集
!cd data/data17036 && unzip -q catanddog.zip
1
2

2. 上传预训练参数文件下载链接，新建Code并运行解预训练参数

# 解压预训练参数 
!cd data && unzip -q Pts.zip
1
2

# 解压预训练参数 pretrained
!cd data/Pts && unzip -q pretrained.zip
1
2

3. 预处理数据，同时将数据拆分成两份以便训练和计算预估准确率，将其转化为标准格式。

# 预处理数据，将其转化为标准格式。同时将数据拆分成两份，以便训练和计算预估准确率
import codecs
import os
import random
import shutil
from PIL import Image

train_ratio = 4 / 5

all_file_dir = 'data/data17036/catanddog'
class_list = [c for c in os.listdir(all_file_dir) if os.path.isdir(os.path.join(all_file_dir, c)) and not c.endswith('Set') and not c.startswith('.')]
class_list.sort()
print(class_list)
train_image_dir = os.path.join(all_file_dir, "trainImageSet")
if not os.path.exists(train_image_dir):
    os.makedirs(train_image_dir)
    
eval_image_dir = os.path.join(all_file_dir, "evalImageSet")
if not os.path.exists(eval_image_dir):
    os.makedirs(eval_image_dir)

train_file = codecs.open(os.path.join(all_file_dir, "train.txt"), 'w')
eval_file = codecs.open(os.path.join(all_file_dir, "eval.txt"), 'w')

with codecs.open(os.path.join(all_file_dir, "label_list.txt"), "w") as label_list:
    label_id = 0
    for class_dir in class_list:
        label_list.write("{0}\t{1}\n".format(label_id, class_dir))
        image_path_pre = os.path.join(all_file_dir, class_dir)
        for file in os.listdir(image_path_pre):
            try:
                img = Image.open(os.path.join(image_path_pre, file))
                if random.uniform(0, 1) <= train_ratio:
                    shutil.copyfile(os.path.join(image_path_pre, file), os.path.join(train_image_dir, file))
                    train_file.write("{0}\t{1}\n".format(os.path.join(train_image_dir, file), label_id))
                else:
                    shutil.copyfile(os.path.join(image_path_pre, file), os.path.join(eval_image_dir, file))
                    eval_file.write("{0}\t{1}\n".format(os.path.join(eval_image_dir, file), label_id))
            except Exception as e:
                pass
                # 存在一些文件打不开，此处需要稍作清洗
        label_id += 1
            
train_file.close()
eval_file.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

4、训练模型：训练常用视觉基础网络进行猫狗分类

# -*- coding: UTF-8 -*-
"""
训练常用视觉基础网络，用于分类任务
需要将训练图片，类别文件 label_list.txt 放置在同一个文件夹下
程序会先读取 train.txt 文件获取类别数和图片数量
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import numpy as np
import time
import math
import paddle
import paddle.fluid as fluid
import codecs
import logging

from paddle.fluid.initializer import MSRA
from paddle.fluid.initializer import Uniform
from paddle.fluid.param_attr import ParamAttr
from PIL import Image
from PIL import ImageEnhance

......#代码较长其余可fork项目，参考本文结尾
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

5、计算预估准确率：测试集模型评估，测试模型的正确率

from __future__ import absolute_import    
from __future__ import division    
from __future__ import print_function    
    
import os    
import numpy as np    
import random    
import time    
import codecs    
import sys    
import functools    
import math    
import paddle    
import paddle.fluid as fluid    
from paddle.fluid import core    
from paddle.fluid.param_attr import ParamAttr    
from PIL import Image, ImageEnhance    
    
target_size = [3, 224, 224]    
mean_rgb = [127.5, 127.5, 127.5]    
data_dir = "data/data17036/catanddog"    
eval_file = "eval.txt"    
use_gpu = train_parameters["use_gpu"]    
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()    
exe = fluid.Executor(place)    
save_freeze_dir = "./freeze-model"    
[inference_program, feed_target_names, fetch_targets] = fluid.io.load_inference_model(dirname=save_freeze_dir, executor=exe)    
# print(fetch_targets)    
    
    
def crop_image(img, target_size):    
    width, height = img.size    
    w_start = (width - target_size[2]) / 2    
    h_start = (height - target_size[1]) / 2    
    w_end = w_start + target_size[2]    
    h_end = h_start + target_size[1]    
    img = img.crop((w_start, h_start, w_end, h_end))    
    return img    
    
    
def resize_img(img, target_size):    
    ret = img.resize((target_size[1], target_size[2]), Image.BILINEAR)    
    return ret    
    
    
def read_image(img_path):    
    img = Image.open(img_path)    
    if img.mode != 'RGB':    
        img = img.convert('RGB')    
    img = crop_image(img, target_size)    
    img = np.array(img).astype('float32')    
    img -= mean_rgb    
    img = img.transpose((2, 0, 1))  # HWC to CHW    
    img *= 0.007843    
    img = img[np.newaxis,:]    
    return img    
    
    
def infer(image_path):    
    tensor_img = read_image(image_path)    
    label = exe.run(inference_program, feed={feed_target_names[0]: tensor_img}, fetch_list=fetch_targets)    
    return np.argmax(label)    
    
    
def eval_all():    
    eval_file_path = os.path.join(data_dir, eval_file)    
    total_count = 0    
    right_count = 0    
    with codecs.open(eval_file_path, encoding='utf-8') as flist:     
        lines = [line.strip() for line in flist]    
        t1 = time.time()    
        for line in lines:    
            total_count += 1    
            parts = line.strip().split()    
            result = infer(parts[0])    
            # print("infer result:{0} answer:{1}".format(result, parts[1]))    
            if str(result) == parts[1]:    
                right_count += 1    
        period = time.time() - t1    
        print("total eval count:{0} cost time:{1} predict accuracy:{2}".format(total_count, "%2.2f sec" % period, right_count / total_count))    
    
    
if __name__ == '__main__':    
    eval_all()  
#print：total eval count:17 cost time:1.00 sec predict accuracy:0.8235294117647058
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

6、模型转换：

1. 下载ncc工具，准备转换模型。关于ncc工具可参考K210学习记录（3）——kmodel生成与使用

!mkdir /home/aistudio/work/ncc
!wget "https://platform.bj.bcebos.com/sdk%2Fncc-linux-x86_64.tar.gz" -O ncc-linux-x86_64.tar.gz 
!tar -zxvf ncc-linux-x86_64.tar.gz -C /home/aistudio/work/ncc 
1
2
3

2. 在模型转换前，需要进行模型压缩，进行量化。为了保证量化后的精度, 需要使用训练图片调整模型。拷贝评估图片到/home/aistudio/work/images

import os
import shutil
!mkdir /home/aistudio/work/images
filenames = os.listdir("/home/aistudio/data/data17036/catanddog/evalImageSet/")

#下面方法是图片太多的时候随机选择图片  
# index = 0
# for i in range(1, len(filenames), 7):
#     srcFile = os.path.join("/home/aistudio/data/data17036/catanddog/evalImageSet/", filenames[index])
#     targetFile = os.path.join("/home/aistudio/work/images",filenames[index])
#     shutil.copyfile(srcFile,targetFile)
#     index += 7

index = 0
for i in range(0, len(filenames), 1):
    srcFile = os.path.join("/home/aistudio/data/data17036/catanddog/evalImageSet/", filenames[index])
    targetFile = os.path.join("/home/aistudio/work/images",filenames[index])
    shutil.copyfile(srcFile,targetFile)
    index += 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3. 转换为.kmodel模型

!chmod 777 /home/aistudio/work/ncc
!/home/aistudio/work/ncc/ncc -i paddle -o k210model --postprocess n1to1 --dataset work/images/ freeze-model catanddog.kmodel
1
2

小结：

• PaddlePaddle平台的学习有六个关键步骤：配置运行环境以安装PaddlePaddle、选择并获取适合的数据集、对数据进行预处理，如清洗和标准化、利用PaddlePaddle框架进行深度学习模型的训练、训练完成后，使用验证集对模型性能进行评估、最后通过ncc工具将模型转换成kmodel文件，为模型部署做准备。这一系列步骤构成了机器学习从数据准备到模型部署的完整流程
• 为提升PaddlePaddle实验效率和模型性能，可自动化实验流程，进行超参数调优，使用可视化监控训练，并通过交叉验证等方法增强模型泛化能力。
• 本实验的项目地址，为大家学习使用带来方便，大家可以fork学习，点击进入项目地址