飞浆PaddlePaddle 猫狗数据大战

1 数据集的准备以及处置惩罚操作

1.1 数据集

在练习模型之前的时间我们需要提前准备数据集
数据集下载链接
1.2 文件解压操作（python）

1. # 第一步，把原数据解压
2. import zipfile
3. import os
4. import shutil
6. def unzipFile(source_file, target_dir):
7.     ''' 解压单个文件到目标文件夹。
8.     '''
9.     zf = zipfile.ZipFile(source_file)
10.     try:
11.         zf.extractall(path=target_dir)
12.     except RuntimeError as e:
13.         print(e)
14.     zf.close()
16. sour = 'data/data20541/dogs-vs-cats.zip'
17. targ = ''
18. if not os.path.exists('data/dogCat/dog'):   #用os.path.exists来判断'data/dogCat/dog'路径存不存在
19.     unzipFile(source_file = sour, target_dir = targ)
20.     os.remove('sample_submission.csv')

复制代码

首先：我们需要制定一个函数来解压zip文件。
然后：通过python中的库中的文件操作函数ZipFile()来解压
末了：把解压好的文件在通过extractall()函数放在target_dir目录下

---

第二步：原数据解压之后是 形成 train.zip 和 test.zip 文件还需要解压一遍，让他们解压之后形成练习集和测试集。

1. if not os.path.exists('data/dogCat/dog'):
2.     # 先解压训练集
3.     train_file = 'train.zip'
4.     train_targetdir = 'data'
5.     unzipFile(source_file = train_file, target_dir = train_targetdir)
6.     os.remove(train_file)
7.    
8.     # 再解压测试集
9.     test_file = 'test.zip'
10.     test_targetdir = 'data'
11.     unzipFile(source_file = test_file, target_dir = test_targetdir)
12.     os.remove(test_file)

复制代码

1.3 数据的分类

   在练习盘算机辨认动物之前，我们需要进行区分，比如：你要让盘算机进行猫狗的区分那么你的数据集中有其他的动物的图片，这样的话在练习过程中在辨认关键信息的时间就出错！！！。因此我们需要排除干扰选项。
  排除干扰项思路：把文件的所有图片都遍历一遍然后进行筛选出猫和狗的图片。
执行代码：

1. dataRootPath = 'data/dogCat'
3. def copyFiles(fileDirs, targetDir):
4.     for fileDir in fileDirs:
5.         shutil.copy(fileDir, targetDir)
6.         
7. def divideData():
8.     global dataRootPath
9.     classDirs = os.listdir('data/train')
10.     dogDirs = [os.path.join('data/train',x) for x in classDirs if x.find('dog')>=0]
11.     catDirs = [os.path.join('data/train',x) for x in classDirs if x.find('cat')>=0]
12.     print('总图片数量为：%d'%len(classDirs))
13.     print('\t猫的图片数量为：%d'%len(catDirs))
14.     print('\t狗的图片数量为：%d'%len(dogDirs))
16.     # 遍历图片，转移数据集
17.     dogPath = os.path.join(dataRootPath, 'dog')
18.     if not os.path.exists(dogPath):
19.         os.makedirs(dogPath)
20.     copyFiles(dogDirs, dogPath)
21.    
22.     catPath = os.path.join(dataRootPath, 'cat')
23.     if not os.path.exists(catPath):
24.         os.makedirs(catPath)
25.     copyFiles(catDirs, catPath)
26.    
27. if not os.path.exists('data/dogCat/dog'):
28.     divideData()

复制代码

接下来我们来介绍以上提到的函数：
1 os.listdir(路径) ==== 这是把路径中的目录展开 。就是把目录展开了，然后就是目录中的子文件或者文件了。这里就是指的是图片！！！
2 os.path.join(路径，路径1)==== 这里就是列表的初始化 ，先是判断你的x有没有dog或者cat的笔墨（这一步就是先筛选图片名称为dog和cat）。 如果符合那么就把路径1链接到路劲之后。 如：os.path.join(‘data/dogcat/’,dog1.jpg) -> 结果：data/dogcat/dog1.jpg
3 os.path.exists(路径) 就是判断路径存不存在
4 os.mkdir(名称) 就是创建名称目录
5 shutil.copy(dest,source) 就是把文件进行复制
总结：以上代码就是为了把干扰选项给去掉，为了更好的练习出大模型！！！
1.4 创建练习集和测试集

   在经过以上操作后：我们就可以开始进行对数据进行划分和创建数据集合测试集了

1. #Python   os标准库，用于文件操作、  random随机数生成、 JSON解析和系统参数访问。
2. import os
3. import random
4. import json
5. import sys
6. #Paddle.fluid,paddle框架的核心模块，用于构建和训练深度学习模型。
7. import paddle
8. import paddle.fluid as fluid
9. #数值计算库，用于处理数组和矩阵.
10. import numpy
12. from multiprocessing import cpu_count
13. from visualdl import LogWriter
14. #matplotlib.pyplot用于绘图和数据可视化
15. import matplotlib.pyplot as plt
16. import numpy as np
18. #PIL 用于打开和处理图像
19. from PIL import Image
22. import paddle
23. paddle.enable_static()
26. #定义长度，和宽度
27. IMG_H =64
28. IMG_W =64
30. #缓冲区大小，用来读取数据处理和预处理
31. BUFFER_SIZE = 1024
33. #一次批量处理的个数
34. BATCH_SIZE =64
36. #是否使用gpu
37. USE_CUDA = True
38. #训练次数
39. TRAIN_NUM = 150
40. #学习率
41. LEARNING_RATE = 0.005
43. DATA_TRAIN = 0.75 #训练集在数据集中占多少数据  # 表示在训练模型时，使用多大规模的数据
45. #每执行玩一个模型就放在work/model 中，这样方便模型的拿取
46. model_save_dir = "work/model"
48. def genDataList(dataRootPath, trainPercent=0.8):
49.     # 函数会自动检测dataRootPath下的所有文件夹，每一个文件夹为1个类别的图片
50.     # 然后生成图片的list，即paddlepaddle能获取信息的形式
51.     # 默认随机抽取20%作为测试集（验证集）
52.     # random.seed(42)  #设置随机种子。
54.    
55.     classDirs = os.listdir(dataRootPath)#os.listdir用来获取dataRootPath的所有文件和文件夹
56.     #os.isdir 判断是否为目录  #os.path.join 拼接
57.     classDirs = [x for x in classDirs if os.path.isdir(os.path.join(dataRootPath,x))]
58.     listDirTest = os.path.join(dataRootPath, "test.list")
59.     listDirTrain = os.path.join(dataRootPath, "train.list")
60.     # 清空原来的数据，当一‘w’模式打开文件夹时，1：文件已存在，那么就会清空数据 2：文件不存在，就会新建一个文件
61.     #避免旧数据干扰
62.     # with open(listDirTest, 'w') as f:
63.     #     pass
64.     # with open(listDirTrain, 'w') as f:
65.     #     pass
66.     with open(listDirTest, 'w') as f:
67.         pass  # 清空测试集文件
68.     with open(listDirTrain, 'w') as f:
69.         pass  # 清空训练集文件
70.    
71.     # 随机划分训练集与测试集
72.     classLabel = 0              # 初始化类别标签，从0开始
73.     class_detail = []           # 记录每个类别的描述
74.     classList = []              # 记录所有的类别名
75.     num_images = 0              # 统计图片的总数量
76.     for classDir in classDirs:
77.         classPath = os.path.join(dataRootPath,classDir)     # 获取类别为classDir的图片所在的目录,拼接子目录 如：data/DogCat/dog
78.         imgPaths = os.listdir(classPath)                    # 获取类别为classDir的所有图片名
79.         # 从中取trainPercent（默认80%）作为训练集
80.         imgIndex = list(range(len(imgPaths)))               #生成图片索引列表
81.         random.shuffle(imgIndex)                            #打乱图片索引
82.         imgIndexTrain = imgIndex[:int(len(imgIndex)*trainPercent)]#划分训练集与测试集
83.         imgIndexTest = imgIndex[int(len(imgIndex)*trainPercent):]
85.         #把代码追加到listDirTest 与 listDirTrain 目录下
86.         with open(listDirTest,'a') as f:
87.             for i in imgIndexTest:
88.                 imgPath = os.path.join(classPath,imgPaths[i]) #打开目录listDirTest  把刚刚定义的imgIndexTest写入到该目录下 路劲大致如：data/DogCat/dog/dog.1jpg  
89.                 f.write(imgPath + '\t%d' % classLabel + '\n') # 写入格式图片路劲\t类别标签\n
90.         with open(listDirTrain,'a') as f:
91.             for i in imgIndexTrain:
92.                 imgPath = os.path.join(classPath,imgPaths[i])
93.                 f.write(imgPath + '\t%d' % classLabel + '\n')        
95.         num_images += len(imgPaths)
96.         
97.         classList.append(classDir) #将类别名称添加到classList中
98.         class_detail_list = {}   #记录该类别的名称、标签、测试集图片数量和训练集图片数量
99.         class_detail_list['class_name'] = classDir             #类别名称，如dog
100.         class_detail_list['class_label'] = classLabel          #类别标签，如cat 的标签是 0     dog的标签是 1
101.         class_detail_list['class_test_images'] = len(imgIndexTest)       #该类数据的测试集数目
102.         class_detail_list['class_trainer_images'] = len(imgIndexTrain)   #该类数据的训练集数目
103.         class_detail.append(class_detail_list)     
104.         classLabel += 1
106.     # 说明的json文件信息
107.     readjson = {} #包含所有类别的名称、总类别数量、总图片数量以及每个类别的详细信息。
108.     readjson['all_class_name'] = classList                      # 文件父目录
109.     readjson['all_class_sum'] = len(classDirs)                  # 总类别数量
110.     readjson['all_class_images'] = num_images                   # 总图片数量
111.     readjson['class_detail'] = class_detail                     # 每种类别的情况
112.     jsons = json.dumps(readjson, sort_keys=True, indent=4, separators=(',', ': '))#json.dumps的作用是将Python对象转换成JSON格式的字符串。这里的参数看起来是用于格式化输出的。
113.     #sort_keys对字典的键（Key）按字母顺序排序。设置缩进为4个空格，使JSON字符串具有层次结构
114.     with open(os.path.join(dataRootPath,"readme.json"),'w') as f:#把jsons字符串写入到dataRootPath/readme.json中用于保存数据集的元信息（如类别名称、标签、图片数量等）
115.         f.write(jsons)
116.     print ('生成数据列表完成！')
117.     return readjson['all_class_sum']
119. classNumber = genDataList(dataRootPath)#返回类别数量
120. print(classNumber)

复制代码

我们照旧一步一步来：
1 变量：

1. #定义长度，和宽度
2. IMG_H =64
3. IMG_W =64
4. #缓冲区大小，用来读取数据处理和预处理
5. BUFFER_SIZE = 1024
6. #一次批量处理的个数
7. BATCH_SIZE =64
8. #是否使用gpu
9. USE_CUDA = True
10. #训练次数
11. TRAIN_NUM = 150
12. #学习率
13. LEARNING_RATE = 0.005
14. DATA_TRAIN = 0.75 #训练集在数据集中占多少数据  # 表示在训练模型时，使用多大规模的数据
15. #每执行玩一个模型就放在work/model 中，这样方便模型的拿取
16. model_save_dir = "work/model"

复制代码

这是我们在练习时进行定义的全局变量：
IMG_H IMG_W 定义的输出图像的长宽高度
BUFFER_SIZE 就是缓冲区的大小用于读取数据处置惩罚和预处置惩罚
BATCH_SIZE 就是在练习时一次读取的个数
USE_CUDA = True 这是使用GPU来进行练习，因为你使用CPU的话这个程序会练习的很慢或者练习不出来。
TRAIN_NUM 练习次数
LEARNING_RATE 学习率
DATA_TRAIN 练习集在数据集中占多少数据 表现在练习模型时，使用多大规模的数据
model_save_dir 每执行玩一个模型就放在work/model 中，这样方便模型的拿取

---

然后就是我们的genDataList函数：

1. def genDataList(dataRootPath, trainPercent=0.8):
2.     # 函数会自动检测dataRootPath下的所有文件夹，每一个文件夹为1个类别的图片
3.     # 然后生成图片的list，即paddlepaddle能获取信息的形式
4.     # 默认随机抽取20%作为测试集（验证集）
5.     # random.seed(42)  #设置随机种子。
7.    
8.     classDirs = os.listdir(dataRootPath)#os.listdir用来获取dataRootPath的所有文件和文件夹
9.     #os.isdir 判断是否为目录  #os.path.join 拼接
10.     classDirs = [x for x in classDirs if os.path.isdir(os.path.join(dataRootPath,x))]
11.     listDirTest = os.path.join(dataRootPath, "test.list")
12.     listDirTrain = os.path.join(dataRootPath, "train.list")
13.     # 清空原来的数据，当一‘w’模式打开文件夹时，1：文件已存在，那么就会清空数据 2：文件不存在，就会新建一个文件
14.     #避免旧数据干扰
15.     # with open(listDirTest, 'w') as f:
16.     #     pass
17.     # with open(listDirTrain, 'w') as f:
18.     #     pass
19.     with open(listDirTest, 'w') as f:
20.         pass  # 清空测试集文件
21.     with open(listDirTrain, 'w') as f:
22.         pass  # 清空训练集文件
23.    
24.     # 随机划分训练集与测试集
25.     classLabel = 0              # 初始化类别标签，从0开始
26.     class_detail = []           # 记录每个类别的描述
27.     classList = []              # 记录所有的类别名
28.     num_images = 0              # 统计图片的总数量
29.     for classDir in classDirs:
30.         classPath = os.path.join(dataRootPath,classDir)     # 获取类别为classDir的图片所在的目录,拼接子目录 如：data/DogCat/dog
31.         imgPaths = os.listdir(classPath)                    # 获取类别为classDir的所有图片名
32.         # 从中取trainPercent（默认80%）作为训练集
33.         imgIndex = list(range(len(imgPaths)))               #生成图片索引列表
34.         random.shuffle(imgIndex)                            #打乱图片索引
35.         imgIndexTrain = imgIndex[:int(len(imgIndex)*trainPercent)]#划分训练集与测试集
36.         imgIndexTest = imgIndex[int(len(imgIndex)*trainPercent):]
38.         #把代码追加到listDirTest 与 listDirTrain 目录下
39.         with open(listDirTest,'a') as f:
40.             for i in imgIndexTest:
41.                 imgPath = os.path.join(classPath,imgPaths[i]) #打开目录listDirTest  把刚刚定义的imgIndexTest写入到该目录下 路劲大致如：data/DogCat/dog/dog.1jpg  
42.                 f.write(imgPath + '\t%d' % classLabel + '\n') # 写入格式图片路劲\t类别标签\n
43.         with open(listDirTrain,'a') as f:
44.             for i in imgIndexTrain:
45.                 imgPath = os.path.join(classPath,imgPaths[i])
46.                 f.write(imgPath + '\t%d' % classLabel + '\n')        
48.         num_images += len(imgPaths)
49.         
50.         classList.append(classDir) #将类别名称添加到classList中
51.         class_detail_list = {}   #记录该类别的名称、标签、测试集图片数量和训练集图片数量
52.         class_detail_list['class_name'] = classDir             #类别名称，如dog
53.         class_detail_list['class_label'] = classLabel          #类别标签，如cat 的标签是 0     dog的标签是 1
54.         class_detail_list['class_test_images'] = len(imgIndexTest)       #该类数据的测试集数目
55.         class_detail_list['class_trainer_images'] = len(imgIndexTrain)   #该类数据的训练集数目
56.         class_detail.append(class_detail_list)     
57.         classLabel += 1

复制代码

根据我的解释可以得出：
这个函数第一步就是创建出数据集和测试集：

1. imgIndex = list(range(len(imgPaths)))               #生成图片索引列表
2.         random.shuffle(imgIndex)                            #打乱图片索引
3.         imgIndexTrain = imgIndex[:int(len(imgIndex)*trainPercent)]#划分训练集与测试集
4.         imgIndexTest = imgIndex[int(len(imgIndex)*trainPercent):]
8. ......之后就是把文件写入操作

复制代码

第二步就是记录属性

1. classLabel = 0              # 初始化类别标签，从0开始
2.     class_detail = []           # 记录每个类别的描述
3.     classList = []              # 记录所有的类别名
4.     num_images = 0              # 统计图片的总数量

复制代码

他们把记录出来的这些属性，用json进行连接。
得出：

把狗做标记：为1 （class_label= 1）
然后圈红圈的分别是练习集的个数，和测试集的个数
猫同理。
1.5 数据处置惩罚和创建数据处置惩罚器

1. def trainMapper(sample):
2.     global IMG_H, IMG_W
3.     img, label = sample
4.    
5.     # 图像加载（兼容老版本）
6.     img = paddle.dataset.image.load_image(img)  # 所有版本通用
7.    
8.     # 图像变换（老版本无水平翻转，需手动添加）
9.     img = paddle.dataset.image.simple_transform(
10.         im=img,
11.         resize_size=IMG_H,
12.         crop_size=IMG_W,
13.         is_color=True,
14.         is_train=True  # 在1.x版本中此参数可能不触发翻转
15.     )
16.     img = img.flatten().astype('float32') / 255.0
17.     return img, label
20. # 对自定义数据集创建训练集train的reader
21. def trainReader(train_list, buffered_size=1024):
22.     global DATA_TRAIN
23.     def reader():
24.         with open(train_list, 'r') as f:
25.             # 将train.list里面的标签和图片的地址放在一个list列表里面，中间用\t隔开'
26.             # 如data/dogCat/Cat_/1.jpg\t0'
27.             lines = [line.strip() for line in f]# 读取所有行并去除首尾空格
28.             np.random.shuffle(lines)#打乱数据顺序增强随机性
29.             lines = lines[:int(len(lines)*DATA_TRAIN)]
30.             for line in lines:
31.                 # 图像的路径和标签是以\t来分割的,所以我们在生成这个列表的时候,使用\t就可以了
32.                 img_path, lab = line.strip().split('\t')# 分割路径与标签
33.                 yield img_path, int(lab) # 生成数据元组（路径, 标签）
34.     # 创建自定义数据训练集的train_reader
35.     return paddle.reader.xmap_readers(trainMapper, reader, cpu_count(), buffered_size)
36.     def testMapper(sample):
37.     global IMG_H
38.     global IMG_W
39.     img, label = sample
40.     img = paddle.dataset.image.load_image(img)
41.     img = paddle.dataset.image.simple_transform(im=img,
42.                                                 resize_size=IMG_H, crop_size=IMG_W,
43.                                                 is_color=True, is_train=False)
44.     img= img.flatten().astype('float32')/255.0
45.     return img, label
47. # 对自定义数据集创建验证集test的reader
48. def testReader(test_list, buffered_size=1024):
49.     global DATA_TRAIN
50.     def reader():
51.         with open(test_list, 'r') as f:
52.             lines = [line.strip() for line in f]
53.             np.random.shuffle(lines)
54.             lines = lines[int(len(lines)*DATA_TRAIN):]
55.             for line in lines:
56.                 #图像的路径和标签是以\t来分割的,所以我们在生成这个列表的时候,使用\t就可以了
57.                 img_path, lab = line.strip().split('\t')
58.                 yield img_path, int(lab)
60.     return paddle.reader.xmap_readers(testMapper, reader, cpu_count(), buffered_size)

复制代码

在这里呢，我们就解说一下怎么处置惩罚数据的：

1. img = paddle.dataset.image.simple_transform(
2.         im=img,
3.         resize_size=IMG_H,
4.         crop_size=IMG_W,
5.         is_color=True,
6.         is_train=True  # 在1.x版本中此参数可能不触发翻转
7.     )
8.     img = img.flatten().astype('float32') / 255.0

复制代码

通过simple_transform 这个类成员函数进行处置惩罚数据：
resize_size=IMG_H 这里代表的是缩放，就比如：本来3232的照片 缩放成1616。
crop_size=IMG_W 这里代表着中心裁剪
is_color = True 这里就是代表有颜色额图片
is_train=True 如果是True的话，这里的函数有大概对图片进行随机裁剪（增强数据）
末了img = img.flatten().astype(‘float32’) / 255.0 代表这归一化 按（0，1）处置惩罚
而在测试的时间is_train=False 这就是不采用随机裁剪

---

创建数据集Reader

1. def createDataReader(BatchSize = 128):
2.     global BUFFER_SIZE
3.     # 把图片数据生成reader
4.     trainer_reader = trainReader(train_list = os.path.join(dataRootPath,"train.list"))
5.     train_reader = paddle.batch(
6.         paddle.reader.shuffle(reader=trainer_reader, buf_size=BUFFER_SIZE),
7.         batch_size=BatchSize)
8.    
9.     tester_reader = testReader(test_list = os.path.join(dataRootPath,"test.list"))
10.     test_reader = paddle.batch(tester_reader, batch_size=BatchSize)
11.     print('train_reader, test_reader创建完成！')
12.     return train_reader, test_reader

复制代码

这里不做解释
2 网络构建

CNN版本–

1. def convolutional_neural_network(image, classNumber):
2.     # 第一个卷积-池化层 #修改第一步就是先是卷积池化->bn->激活   查找论文中 可以得出BN在激活前：在激活函数前进行 BN，能更有效地约束激活前的输入分布，
3.     #使网络更容易学习到合适的参数，ReLU 对负值输入会直接截断（输出0），如果激活后再 BN，可能丢失部分信息；而先 BN 再激活，可以确保激活函数的输入是归一化的正值，梯度更稳定。
4.     #论文《Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift》建议将 BN 放在激活前，以最大化其规范化效果。
5.     conv_pool_1 = fluid.nets.simple_img_conv_pool(
6.         input=image,         # 输入图像
7.         filter_size=5,       # 滤波器的大小
8.         num_filters=20,      # filter 的数量
9.         pool_size=2,         # 池化核大小
10.         pool_stride=2,       # 池化步长
11.         act=None             # 先不激活
12.     )
13.     conv_pool_1 = fluid.layers.batch_norm(conv_pool_1)  # BN
14.     conv_pool_1 = fluid.layers.relu(conv_pool_1)        # 激活
16.     # 第二个卷积-池化层
17.     conv_pool_2 = fluid.nets.simple_img_conv_pool(
18.         input=conv_pool_1,
19.         filter_size=5,
20.         num_filters=50,
21.         pool_size=2,
22.         pool_stride=2,
23.         act=None
24.     )
25.     conv_pool_2 = fluid.layers.batch_norm(conv_pool_2)  # BN
26.     conv_pool_2 = fluid.layers.relu(conv_pool_2)        # 激活
28.     # 第三个卷积-池化层
29.     conv_pool_3 = fluid.nets.simple_img_conv_pool(
30.         input=conv_pool_2,
31.         filter_size=5,
32.         num_filters=50,
33.         pool_size=2,
34.         pool_stride=2,
35.         act=None
36.     )
37.     conv_pool_3 = fluid.layers.batch_norm(conv_pool_3)  # BN
38.     conv_pool_3 = fluid.layers.relu(conv_pool_3)        # 激活
40.     # 全连接输出层
41.     prediction = fluid.layers.fc(input=conv_pool_3, size=classNumber, act='softmax')
42.     print('神经网络创建完成！')
43.     return prediction

复制代码

~卷积层：nn.Conv2d用于提取特征，参数包罗输入通道数、输出通道数、卷积核大小等。
​~池化层：nn.MaxPool2d用于降维，通常使用最大池化。
~​全连接层：nn.Linear用于将特征映射到终极输出空间。
​~激活函数：F.relu是ReLU激活函数，增加非线性。
​~展平操作：x.view将特征图展平为一维向量，以便输入全连接层。
这里就需要我们进行深度学习了！！！
如果是网络构建的话选择CNN就OK了！！！
DeepID 人脸辨认网络结构

1. def DeepID(images, classNumber):
2.     # 第一个卷积-池化层
3.     conv_pool_1 = fluid.nets.simple_img_conv_pool(
4.         input=images,
5.         filter_size=5,
6.         num_filters=32,
7.         pool_size=2,
8.         pool_stride=2,
9.         act=None             # 先不激活
10.     )
11.     conv_pool_1 = fluid.layers.batch_norm(conv_pool_1)  # BN
12.     conv_pool_1 = fluid.layers.relu(conv_pool_1)        # 激活
14.     # 第二个卷积-池化层
15.     conv_pool_2 = fluid.nets.simple_img_conv_pool(
16.         input=conv_pool_1,
17.         filter_size=3,
18.         num_filters=40,
19.         pool_size=2,
20.         pool_stride=1,
21.         act=None
22.     )
23.     conv_pool_2 = fluid.layers.batch_norm(conv_pool_2)  # BN
24.     conv_pool_2 = fluid.layers.relu(conv_pool_2)        # 激活
26.     # 第三个卷积-池化层
27.     conv_pool_3 = fluid.nets.simple_img_conv_pool(
28.         input=conv_pool_2,
29.         filter_size=3,
30.         num_filters=60,
31.         pool_size=2,
32.         pool_stride=2,
33.         act=None
34.     )
35.     conv_pool_3 = fluid.layers.batch_norm(conv_pool_3)  # BN
36.     conv_pool_3 = fluid.layers.relu(conv_pool_3)        # 激活
38.     # 全连接层 fc160_1
39.     fc160_1 = fluid.layers.fc(input=conv_pool_3, size=160)
41.     # 第四个卷积层（无池化）
42.     conv_4 = fluid.layers.conv2d(
43.         input=conv_pool_3,
44.         num_filters=128,
45.         filter_size=3,
46.         act=None             # 先不激活
47.     )
48.     conv_4 = fluid.layers.batch_norm(conv_4)  # BN
49.     conv_4 = fluid.layers.relu(conv_4)        # 激活
51.     # 全连接层 fc160_2
52.     fc160_2 = fluid.layers.fc(input=conv_4, size=160)
54.     # 合并全连接层
55.     fc160 = fluid.layers.elementwise_add(fc160_1, fc160_2, act="relu")  # 必须保留
56.     # 全连接输出层
57.     prediction = fluid.layers.fc(input=fc160, size=classNumber, act='softmax')
58.     return prediction

复制代码

卷积层：提取人脸的局部特征。
​池化层：降维并增强特征的鲁棒性。
​全连接层：将高维特征映射到种别空间。
​末了一层无激活函数：输出的是人脸特征向量，而不是直接的分类结果。
DeepID 与 CNN 网络结构的差异

特性CNN​DeepID​网络结构通用结构，适用于多种视觉任务专为人脸辨认筹划，提取高维特征​输入数据通用图像数据（如分类任务中的物体图像）固定大小的人脸图像（如 112x112 或 128x128）​输出种别概率（分类任务）高维特征向量（用于相似性盘算）练习目标最大化正确种别的概率（交叉熵丧失等）学习高维、鉴别性强的人脸特征，联合团结贝叶斯模型优化特征空间后续处置惩罚直接输出结果（如分类标签）特征向量用于人脸验证或聚类，通常联合团结贝叶斯模型​应用场景图像分类、目标检测、语义分割等人脸辨认、人脸验证、人脸聚类等 总结：
​CNN 是一种通用框架，适用于多种视觉任务，网络结构和练习目标灵活多样。
​DeepID 是一种专用网络，专注于人脸辨认任务，通过网络提取高维特征并联合团结贝叶斯模型优化特征空间。
3 深度学习模型练习和推理的焦点设置

1. def setPredictor(learning_rate =0.0001):
2.    
3.     image = fluid.layers.data(name='image', shape=[3, IMG_H, IMG_W], dtype='float32')#接收形状为 【3,H,W】 的输入图像
4.     label = fluid.layers.data(name='label', shape=[1], dtype='int64')#接收形状为 1 的标签
5.    
6.     # 建立网络
7.     # predict =  convolutional_neural_network(image, classNumber)
8.     predict = DeepID(image, classNumber)
9.    
10.    
11.     ###################################################################################
12.    
13.     # 获取损失函数和准确率
14.     cost = fluid.layers.cross_entropy(input=predict, label=label) # 交叉熵
15.     avg_cost = fluid.layers.mean(cost)                            # 计算cost中所有元素的平均值
16.     acc = fluid.layers.accuracy(input=predict, label=label)       #使用输入和标签计算准确率
17.    
18.     # 定义优化方法
19.     # optimizer =fluid.optimizer.Adam(learning_rate=learning_rate)
20.     # optimizer.minimize(avg_cost)
21.     # 定义带动量的 SGD 优化器
22.     optimizer = fluid.optimizer.Momentum(
23.         learning_rate=learning_rate,
24.         momentum=0.9,
25.         regularization=fluid.regularizer.L2Decay(regularization_coeff=1e-4)
26.     )
27.     optimizer.minimize(avg_cost)
28.    
31.    
32.     # 定义优化器时添加梯度裁剪    正则：原le-4  改成 le-3
33.     # optimizer = fluid.optimizer.Momentum(
34.     #     learning_rate=learning_rate,
35.     #     momentum=0.9,
36.     #     regularization=fluid.regularizer.L2Decay(1e-4),
37.     #     grad_clip=fluid.clip.GradientClipByGlobalNorm(clip_norm=5.0)  # 全局范数裁剪
38.     # )
39.     # optimizer.minimize(avg_cost)
40.    
41.     # 定义使用CPU还是GPU，使用CPU时USE_CUDA = False,使用GPU时USE_CUDA = True
42.     place = fluid.CUDAPlace(0) if USE_CUDA else fluid.CPUPlace()
43.    
44.     # 创建执行器，初始化参数
45.     exe = fluid.Executor(place) #就像请一个厨师（执行器）按照菜谱（模型结构）在指定的厨房（CPU或GPU）里做菜。
46.     exe.run(fluid.default_startup_program()) #运行模型的“启动程序”，初始化所有参数（比如神经网络的权重和偏置）
47.     feeder = fluid.DataFeeder( feed_list=[image, label],place=place)#创建一个“数据喂入器”，负责将输入数据（如图像和标签）传递给模型
48.    
49.     # 获取测试程序
50.     test_program = fluid.default_main_program().clone(for_test=True)
51.    
52.     return image, label, predict, avg_cost, acc, exe, feeder, test_program
53.     ###################################################################################
55. image, label, predict, avg_cost, acc, exe, feeder, test_program = setPredictor(LEARNING_RATE)

复制代码

4 制图

1. import matplotlib.pyplot as plt
2. import numpy as np
5. def draw_figure(dictCostAccdictCostAcc, xlabel, ylabel_1, ylabel_2):
6.     plt.xlabel(xlabel, fontsize=20)
7.     plt.plot(dictCostAcc[xlabel], dictCostAcc[ylabel_1],color='red',label=ylabel_1)
8.     plt.plot(dictCostAcc[xlabel], dictCostAcc[ylabel_2],color='green',label=ylabel_2)
9.     plt.legend()
10.     plt.grid()
12. def draw_train_process(epoch, dictCostAcc):
13.     # train的cost与accuray的变化
14.     plt.figure(figsize=(10, 3))
15.     plt.title('epoch - ' + str(epoch), fontsize=24)
16.     plt.subplot(1,3,1)
17.     draw_figure(dictCostAcc, 'iteration', 'iter_cost', 'iter_acc')
18.     plt.subplot(1,3,2)
19.     draw_figure(dictCostAcc, 'epoch', 'cost_train', 'cost_test')
20.     plt.subplot(1,3,3)
21.     draw_figure(dictCostAcc, 'epoch', 'acc_train', 'acc_test')
22.     plt.show()

复制代码

draw_figure() 功能：
绘制单个子图，展示两个指标的变化曲线。
通过 dictCostAcc 提供的数据绘制曲线，dictCostAcc 是一个字典，包罗练习过程中的各种指标（如丧失和准确率）
参数：
dictCostAcc
一个字典，包罗练习过程中的数据。
键是指标名称（如 ‘iteration’、‘iter_cost’ 等），值是对应的数值列表
xlabel
X 轴的标签（如 ‘iteration’ 或 ‘epoch’）。
两个 Y 轴的指标名称（如 ‘iter_cost’ 和 ‘iter_acc’）。
draw_train_process（）
功能
绘制整个练习过程的指标变化，包罗：
每个迭代的丧失和准确率。
每个 epoch 的练习和测试丧失。
每个 epoch 的练习和测试准确率。
使用 matplotlib 的子图功能，将三个指标绘制在同一张图中。
5 练习

1. all_train_iter=0
2. all_train_iters=[]
3. all_train_costs=[]
4. all_train_accs=[]
5. # 记录迭代过程中，每一个epoch的平均cost与accuracy
6. epoch_train_costs = []
7. epoch_test_costs = []
8. epoch_train_accs = []
9. epoch_test_accs = []
11. train_reader, test_reader = createDataReader(BATCH_SIZE)
14. if not os.path.exists(model_save_dir):
15.     os.makedirs(model_save_dir)
17. print('开始训练...')
18. for pass_id in range(TRAIN_NUM):
19.     # train_reader, test_reader = createDataReader(BATCH_SIZE)
21.     print("epoch %d -------------" % pass_id)
22.     train_accs = []                                                          #训练的损失值
23.     train_costs = []                                                          #训练的准确率
24.     for batch_id, data in enumerate(train_reader()):                         #遍历train_reader的迭代器，并为数据加上索引batch_id
25.         train_cost, train_acc = exe.run(
26.             program=fluid.default_main_program(),                            #运行主程序
27.             feed=feeder.feed(data),                                          #喂入一个batch的数据
28.             fetch_list=[avg_cost, acc])                                      #fetch均方误差和准确率
30.         all_train_iter=all_train_iter+BATCH_SIZE
31.         all_train_iters.append(all_train_iter)
32.         all_train_costs.append(train_cost[0])
33.         all_train_accs.append(train_acc[0])
34.         train_costs.append(train_cost[0])
35.         train_accs.append(train_acc[0])
36.         if batch_id % 50 == 0:                                               #每10次batch打印一次训练、进行一次测试
37.             print("\tPass %d, Step %d, Cost %f, Acc %f" %
38.             (pass_id, batch_id, train_cost[0], train_acc[0]))
39.    
40.     epoch_train_costs.append(sum(train_costs) / len(train_costs))            #每个epoch的cost
41.     epoch_train_accs.append(sum(train_accs)/len(train_accs))                 #每个epoch的acc
42.     print('\t\tTrain:%d, Cost:%0.5f, ACC:%0.5f' % (pass_id, epoch_train_costs[-1], epoch_train_accs[-1]))
43.    
44.     # 开始测试
45.     test_accs = []                                                            #测试的损失值
46.     test_costs = []                                                           #测试的准确率
47.     # 每训练一轮 进行一次测试
48.    
49.     for batch_id, data in enumerate(test_reader()):                           # 遍历test_reader
50.          test_cost, test_acc = exe.run(program=test_program,  # #运行测试主程序
51.                                        feed=feeder.feed(data),                #喂入一个batch的数据
52.                                        fetch_list=[avg_cost, acc])            #fetch均方误差、准确率
53.          test_accs.append(test_acc[0])                                        #记录每个batch的误差
54.          test_costs.append(test_cost[0])                                      #记录每个batch的准确率
56.     epoch_test_costs.append(sum(test_costs) / len(test_costs))
57.     epoch_test_accs.append(sum(test_accs) / len(test_accs))
58.     print('\t\tTest:%d, Cost:%0.5f, ACC:%0.5f' % (pass_id, epoch_test_costs[-1], epoch_test_accs[-1]))
59.     if pass_id < 3:
60.         continue
61.     else:
62.         dictCostAcc = {}
63.         dictCostAcc['iteration'] = all_train_iters
64.         dictCostAcc['iter_cost'] = all_train_costs
65.         dictCostAcc['iter_acc'] = all_train_accs
66.         dictCostAcc['epoch'] = list(range(pass_id+1))
67.         dictCostAcc['cost_train'] = epoch_train_costs
68.         dictCostAcc['cost_test'] = epoch_test_costs
69.         dictCostAcc['acc_train'] = epoch_train_accs
70.         dictCostAcc['acc_test'] = epoch_test_accs
71.         draw_train_process(pass_id, dictCostAcc)
72.     # draw_train_process("training",all_train_iters,all_train_costs,all_train_accs,"trainning cost","trainning acc","iter",'cost/acc')
74.     print('\n')
75.    
76.     if pass_id % 5 == 0:
77.         # 每5个epoch保存一个模型
78.         model_dir = os.path.join(model_save_dir,str(pass_id))
79.         if not os.path.exists(model_dir):
80.             os.makedirs(model_dir)
81.         fluid.io.save_inference_model(model_dir, ['image'], [predict], exe)
82.         print('第%d个epoch的训练模型保存完成！'%pass_id)

复制代码

1 变量初始化

1. all_train_iter = 0
2. all_train_iters = []
3. all_train_costs = []
4. all_train_accs = []
5. epoch_train_costs = []
6. epoch_test_costs = []
7. epoch_train_accs = []
8. epoch_test_accs = []

复制代码

  ​功能：初始化变量，用于记录练习和测试过程中的丧失和准确率。
  ​变量分析：
all_train_iter：记录总的迭代次数。
all_train_iters：记录所有练习迭代的索引（累积的 batch 数）。
all_train_costs：记录每个 batch 的练习丧失。
all_train_accs：记录每个 batch 的练习准确率。
epoch_train_costs：记录每个 epoch 的平均练习丧失。
epoch_test_costs：记录每个 epoch 的平均测试丧失。
epoch_train_accs：记录每个 epoch 的平均练习准确率。
epoch_test_accs：记录每个 epoch 的平均测试准确率。
2 数据读取器

1. train_reader, test_reader = createDataReader(BATCH_SIZE)

复制代码

  ​功能：创建练习和测试数据读取器。
  ​createDataReader(BATCH_SIZE)：
自定义函数，返回练习和测试数据的迭代器。
​BATCH_SIZE：每个 batch 的样本数量。
3. 模型保存目录

1. if not os.path.exists(model_save_dir):
2.     os.makedirs(model_save_dir)

复制代码

  ​功能：查抄模型保存目录是否存在，如果不存在则创建。 ​model_save_dir：模型保存的路径。
  4. 练习过程

1. for pass_id in range(TRAIN_NUM):
2.     print("epoch %d -------------" % pass_id)
3.     train_accs = []
4.     train_costs = []

复制代码

  功能：开始练习过程，TRAIN_NUM 是总的练习轮数（epoch）。
  变量分析：
pass_id：当前是第几个 epoch。
train_accs：记录当前 epoch 的所有 batch 的练习准确率。
train_costs：记录当前 epoch 的所有 batch 的练习丧失。
4.1 遍历练习数据

1. for batch_id, data in enumerate(train_reader()):
2.     train_cost, train_acc = exe.run(
3.         program=fluid.default_main_program(),
4.         feed=feeder.feed(data),
5.         fetch_list=[avg_cost, acc]
6.     )

复制代码

  功能：遍历练习数据读取器，逐 batch 进行练习。
  ​train_reader()：
返回练习数据的迭代器，每次迭代返回一个 batch 的数据。
​exe.run：
运行主程序，执行前向流传和反向流传。
​program=fluid.default_main_program()：指定运行的程序。
​feed=feeder.feed(data)：将当前 batch 的数据喂入模型。
​fetch_list=[avg_cost, acc]：获取练习的丧失和准确率。
​train_cost 和 train_acc：
train_cost：当前 batch 的练习丧失。
train_acc：当前 batch 的练习准确率。
4.2 记录练习数据

1. all_train_iter += BATCH_SIZE
2. all_train_iters.append(all_train_iter)
3. all_train_costs.append(train_cost[0])
4. all_train_accs.append(train_acc[0])
5. train_costs.append(train_cost[0])
6. train_accs.append(train_acc[0])

复制代码

  功能：记录每个 batch 的练习数据。
  ​all_train_iter：累积迭代次数，每次增加一个 batch 的样本数（BATCH_SIZE）。
​all_train_iters：记录总的迭代次数。
​all_train_costs 和 all_train_accs：记录所有 batch 的练习丧失和准确率。
​train_costs 和 train_accs：记录当前 epoch 的所有 batch 的练习丧失和准确率。
4.3 打印练习信息

1. if batch_id % 50 == 0:
2.     print("\tPass %d, Step %d, Cost %f, Acc %f" %
3.           (pass_id, batch_id, train_cost[0], train_acc[0]))

复制代码

  ​功能：每 50 个 batch 打印一次练习信息。
  ​打印内容：
当前 epoch (pass_id)。
当前 batch 的索引 (batch_id)。
当前 batch 的练习丧失 (train_cost[0])。
当前 batch 的练习准确率 (train_acc[0])。
4.4 盘算并记录每个 epoch 的平均丧失和准确率

1. epoch_train_costs.append(sum(train_costs) / len(train_costs))
2. epoch_train_accs.append(sum(train_accs) / len(train_accs))

复制代码

  ​功能：盘算当前 epoch 的平均练习丧失和准确率，并记录下来。
  5. 测试过程

1. for batch_id, data in enumerate(test_reader()):
2.     test_cost, test_acc = exe.run(
3.         program=test_program,
4.         feed=feeder.feed(data),
5.         fetch_list=[avg_cost, acc]
6.     )
7.     test_accs.append(test_acc[0])
8.     test_costs.append(test_cost[0])

复制代码

  功能：遍历测试数据读取器，逐 batch 进行测试。
  ​test_reader()：返回测试数据的迭代器，每次迭代返回一个 batch 的数据。
​exe.run：运行测试程序，获取测试的丧失和准确率。
​test_cost 和 test_acc：当前 batch 的测试丧失和准确率。
​test_costs 和 test_accs：记录所有 batch 的测试丧失和准确率。
5.1 盘算并记录每个 epoch 的平均测试丧失和准确率

1. epoch_test_costs.append(sum(test_costs) / len(test_costs))
2. epoch_test_accs.append(sum(test_accs) / len(test_accs))

复制代码

  功能：盘算当前 epoch 的平均测试丧失和准确率，并记录下来。
  6 打印练习和测试信息

1. print('\t\tTrain:%d, Cost:%0.5f, ACC:%0.5f' % (pass_id, epoch_train_costs[-1], epoch_train_accs[-1]))
2. print('\t\tTest:%d, Cost:%0.5f, ACC:%0.5f' % (pass_id, epoch_test_costs[-1], epoch_test_accs[-1]))

复制代码

  ​功能：打印当前 epoch 的平均练习丧失和准确率，以及测试丧失和准确率。
  7. 可视化练习过程

1. if pass_id < 3:
2.     continue
3. else:
4.     dictCostAcc = {
5.         'iteration': all_train_iters,
6.         'iter_cost': all_train_costs,
7.         'iter_acc': all_train_accs,
8.         'epoch': list(range(pass_id+1)),
9.         'cost_train': epoch_train_costs,
10.         'cost_test': epoch_test_costs,
11.         'acc_train': epoch_train_accs,
12.         'acc_test': epoch_test_accs
13.     }
14.     draw_train_process(pass_id, dictCostAcc)

复制代码

  ​功能：从第 4 个 epoch 开始，定期可视化练习过程。
  dictCostAcc：
构造一个字典，包罗练习和测试的所有数据。
​键值对：
‘iteration’：总的迭代次数。
‘iter_cost’：每个 batch 的练习丧失。
‘iter_acc’：每个 batch 的练习准确率。
‘epoch’：当前的 epoch 数。
‘cost_train’：每个 epoch 的平均练习丧失。
‘cost_test’：每个 epoch 的平均测试丧失。
‘acc_train’：每个 epoch 的平均练习准确率。
‘acc_test’：每个 epoch 的平均测试准确率。
​
2.draw_train_process：
调用可视化函数，绘制练习过程的曲线。
8. 定期保存模型

1. if pass_id % 5 == 0:
2.     model_dir = os.path.join(model_save_dir, str(pass_id))
3.     if not os.path.exists(model_dir):
4.         os.makedirs(model_dir)
5.     fluid.io.save_inference_model(model_dir, ['image'], [predict], exe)
6.     print('第%d个epoch的训练模型保存完成！' % pass_id)

复制代码

  ​功能：每 5 个 epoch 保存一次模型。
  ​model_dir：
模型保存的路径，包罗当前 epoch 的编号。
​fluid.io.save_inference_model：
保存推理模型，供后续推理使用。
​参数：
model_dir：模型保存的路径。
[‘image’]：输入数据的名称。
[predict]：需要保存的模型变量。
exe：执行器。
​打印信息：
打印模型保存完成的提示。
6 预测+结果

1. def createInfer():
2.     global USE_CUDA
3.     place = fluid.CUDAPlace(0) if USE_CUDA else fluid.CPUPlace()
4.     infer_exe = fluid.Executor(place)
5.     inference_scope = fluid.core.Scope()
6.     return infer_exe, inference_scope
7.         
8. def load_image(path):
9.     global IMG_H, IMG_W
10.     img = paddle.dataset.image.load_and_transform(path,IMG_H,IMG_W, False).astype('float32')
11.     img = img / 255.0
12.     img = np.expand_dims(img, axis=0)
13.     return img
15. def getClassList(path):
16.     with open(path,'r') as load_f:
17.         new_dict = json.load(load_f)
18.         return new_dict['all_class_name']
19.         
20. def predImgs(pathImgList, optimalEpoch):
21.     pred_label_list = []
22.     pred_class_list = []
23.     modelpath = os.path.join(model_save_dir, str(optimalEpoch))
24.     for pathImg in pathImgList:
25.         infer_exe, inference_scope = createInfer()
26.         with fluid.scope_guard(inference_scope):
27.             #从指定目录中加载 推理model(inference model)
28.             [inference_program, # 预测用的program
29.              feed_target_names, # 是一个str列表，它包含需要在推理 Program 中提供数据的变量的名称。
30.              fetch_targets] = fluid.io.load_inference_model(modelpath,#fetch_targets：是一个 Variable 列表，从中我们可以得到推断结果。
31.                                                             infer_exe)     #infer_exe: 运行 inference model的 executor
32.             
33.             img = Image.open(pathImg)
34.             plt.imshow(img)   
35.             plt.show()   
36.             
37.             img = load_image(pathImg)
38.         
39.             results = infer_exe.run(inference_program,                 #运行预测程序
40.                                     feed={feed_target_names[0]: img},  #喂入要预测的img
41.                                     fetch_list=fetch_targets)          #得到推测结果
42.             # print('results',results)
43.             # print('results[0]',np.argmax(results[0]))
44.             label_list = getClassList(os.path.join(dataRootPath,'readme.json'))
45.             pred_label = np.argmax(results[0])
46.             pred_class = label_list[np.argmax(results[0])]
47.             print("infer results: %s" % label_list[np.argmax(results[0])])
48.             pred_label_list.append(pred_label)
49.             pred_class_list.append(pred_class)
50.     return pred_label_list, pred_class_list
54. pathcat = 'data/test/100.jpg'
55. pathdog = 'data/test/1000.jpg'
56. predImgList = ['data/test/'+str(x)+'.jpg' for x in range(1,29)]
57. predImgs(predImgList,95)

复制代码

练习时间的图像：

好啦根本的就介绍到这里啦！！！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。