使用paddlepaddle 进行人脸识别

数据获取

数据集

使用python库

因为实在百度的AI studio平台用的，那个平台不能用pytorch与tensorflow，只能用paddlepaddle，所以本代码使用paddlepaddle。

简单介绍paddlepaddle

以下简称paddle
paddle与tensorflow等用法大致一样，paddle也是用tensor作为数据使用的。
paddle使用方法分为python世界与paddle世界，两个世界的数据不互通，但是两个世界有接口进行数据传输。
本代码的工作流程
1.数据准备，数据划分与数据预处理
2.卷积神经网络的配置
3.卷积神经网络的训练与评估
4.模型预测

知识储备

python一些基本库的操作
卷积神经网络的过程。
paddlepaddle的使用（百度的ai studio平台有官方文档）

人脸识别代码

（都能做人脸识别了，改写文件地址的事就不用说了吧）
本代码依旧使用jupyter进行运行。
本人建议（强烈建议用jupyter与spyder进行python代码编写
jupyter可以一块一块的运行，非常适合读代码
spyder中运行可以把变量都显示在右上角，可以方便查看变量的类型与内容）

1.（以下为数据准备）
数据集中章子怡、姜文、彭于晏三位明星的人脸图片。总计317张图片，章子怡100张，姜文103张，彭于晏114张。按照9:1的比例进行划分，90%用于训练，10%用于测试。

自定义的数据集，首先要生成图像列表，把自定的图像分为测试集和训练集，并带有标签。下面的程序可以单独运行，只要把一个大类的文件夹路径传进去就可以了,该程序会把里面的每个小类别都迭代,生成固定格式的列表.比如我们把人脸类别的根目录传进去../images/face。最后会在指定目录下面生成三个文件，readme.json、trainer.list和test.list.

import os
import json# 设置要生成文件的路径
data_root_path = '/home/aistudio/images/face'
# 所有类别的信息
class_detail = []
# 获取所有类别保存的文件夹名称，这里是['zhangziyi', 'jiangwen', 'pengyuyan']
class_dirs = os.listdir(data_root_path)
# 类别标签
class_label_dict = {'zhangziyi': 0, 'jiangwen': 1, 'pengyuyan': 2}
# 获取总类别的名称
father_paths = data_root_path.split('/')    #['', 'home', 'aistudio', 'images', 'face']
#清除错误路径
while True:if father_paths[father_paths.__len__() - 1] == '':del father_paths[father_paths.__len__() - 1]else:breakfather_path = father_paths[father_paths.__len__() - 1]#father_path = 'face'
# 把生产的数据列表都放在自己的总类别文件夹中
data_list_path = '/home/aistudio/%s/' % father_path
# 如果不存在这个文件夹,就创建
isexist = os.path.exists(data_list_path)
if not isexist:os.makedirs(data_list_path)
# 清空原来的数据
with open(data_list_path + "test.list", 'w') as f:pass
with open(data_list_path + "trainer.list", 'w') as f:pass
# 总的图像数量
all_class_images = 0
# 读取每个类别

分测试集和训练集

#分测试集和训练集
for class_dir in class_dirs:# 每个类别的信息class_detail_list = {}test_sum = 0trainer_sum = 0# 统计每个类别有多少张图片class_sum = 0# 获取类别路径path = data_root_path + "/" + class_dir# 获取所有图片img_paths = os.listdir(path)for img_path in img_paths:                                  # 遍历文件夹下的每个图片name_path = path + '/' + img_path                       # 每张图片的路径if class_sum % 10 == 0:                                 # 每10张图片取一个做测试数据test_sum += 1                                       #test_sum测试数据的数目with open(data_list_path + "test.list", 'a') as f:f.write(name_path + "\t%d" % class_label_dict[class_dir] + "\n") #class_label 标签：0,1,2else:trainer_sum += 1                                    #trainer_sum测试数据的数目with open(data_list_path + "trainer.list", 'a') as f:f.write(name_path + "\t%d" % class_label_dict[class_dir] + "\n")#class_label 标签：0,1,2class_sum += 1                                          #每类图片的数目all_class_images += 1                                   #所有类图片的数目# 说明的json文件的class_detail数据class_detail_list['class_name'] = class_dir             #类别名称，如jiangwenclass_detail_list['class_label'] = class_label_dict[class_dir]          #类别标签，0,1,2class_detail_list['class_test_images'] = test_sum       #该类数据的测试集数目class_detail_list['class_trainer_images'] = trainer_sum #该类数据的训练集数目class_detail.append(class_detail_list)

# 获取类别数量
all_class_sum = class_dirs.__len__()
# 说明的json文件信息
readjson = {}
readjson['all_class_name'] = father_path                  #文件父目录
readjson['all_class_sum'] = all_class_sum                #
readjson['all_class_images'] = all_class_images
readjson['class_detail'] = class_detail
jsons = json.dumps(readjson, sort_keys=True, indent=4, separators=(',', ': '))
with open(data_list_path + "readme.json",'w') as f:f.write(jsons)
print ('生成数据列表完成！')
print ("标签及其类别：{}".format(class_label_dict))

#导入要用到的模块
import paddle
import paddle.fluid as fluid
import numpy
import sys
import os
from multiprocessing import cpu_count
import matplotlib.pyplot as plt
import numpy as np

train_reader和test_reader分别用于获取训练集和测试集 paddle.reader.shuffle()表示每次缓存BUF_SIZE个数据项，并进行打乱 paddle.batch()表示每BATCH_SIZE组成一个batch

自定义数据集需要先定义自己的reader，把图像数据处理一些，并输出图片的数组和标签。

# 定义训练的mapper
# train_mapper函数的作用是用来对训练集的图像进行处理修剪和数组变换，返回img数组和标签
# sample是一个python元组，里面保存着图片的地址和标签。 ('../images/face/zhangziyi/20181206145348.png', 2)
def train_mapper(sample):img, label = sample# 进行图片的读取，由于数据集的像素维度各不相同，需要进一步处理对图像进行变换img = paddle.dataset.image.load_image(img)       #进行了简单的图像变换，这里对图像进行crop修剪操作，输出img的维度为(3, 100, 100)img = paddle.dataset.image.simple_transform(im=img,          #输入图片是HWC   resize_size=100, # 剪裁图片crop_size=100, is_color=True,  #彩色图像is_train=True)#将img数组进行进行归一化处理，得到0到1之间的数值img= img.flatten().astype('float32')/255.0return img, label
# 对自定义数据集创建训练集train的reader
def train_r(train_list, buffered_size=1024):def reader():with open(train_list, 'r') as f:# 将train.list里面的标签和图片的地址方法一个list列表里面，中间用\t隔开'#../images/face/jiangwen/0b1937e2-f929-11e8-8a8a-005056c00008.jpg\t0'lines = [line.strip() for line in f]for line in lines:# 图像的路径和标签是以\t来分割的,所以我们在生成这个列表的时候,使用\t就可以了img_path, lab = line.strip().split('\t')yield img_path, int(lab) # 创建自定义数据训练集的train_readerreturn paddle.reader.xmap_readers(train_mapper, reader,cpu_count(), buffered_size)# sample是一个python元组，里面保存着图片的地址和标签。 ('../images/face/zhangziyi/20181206145348.png', 2)
def test_mapper(sample):img, label = sampleimg = paddle.dataset.image.load_image(img)img = paddle.dataset.image.simple_transform(im=img, resize_size=100, crop_size=100, is_color=True, is_train=False)img= img.flatten().astype('float32')/255.0return img, label# 对自定义数据集创建验证集test的reader
def test_r(test_list, buffered_size=1024):def reader():with open(test_list, 'r') as f:lines = [line.strip() for line in f]for line in lines:#图像的路径和标签是以\t来分割的,所以我们在生成这个列表的时候,使用\t就可以了img_path, lab = line.strip().split('\t')yield img_path, int(lab)return paddle.reader.xmap_readers(test_mapper, reader,cpu_count(), buffered_size)

BATCH_SIZE = 32
# 把图片数据生成reader
trainer_reader = train_r(train_list="/home/aistudio/face/trainer.list")
train_reader = paddle.batch(paddle.reader.shuffle(reader=trainer_reader,buf_size=300),batch_size=BATCH_SIZE)tester_reader = test_r(test_list="/home/aistudio/face/test.list")
test_reader = paddle.batch(tester_reader, batch_size=BATCH_SIZE)

打印看下数据是什么样的？PaddlePaddle接口提供的数据已经经过了归一化、居中等处理尝试打印一下，观察一下自定义的数据集

train_data = paddle.batch(trainer_reader,batch_size=3)
sampledata=next(train_data())
print(sampledata[0])

8.（以下是卷积神经网络的配置）
定义卷积层
（这块看不懂补卷积神经网络的知识）

def convolutional_neural_network(image, type_size):# 第一个卷积--池化层conv_pool_1 = fluid.nets.simple_img_conv_pool(input=image,# 输入图像filter_size=3,# 滤波器的大小num_filters=32,# filter 的数量。它与输出的通道相同pool_size=2,# 池化层大小2*2pool_stride=2,# 池化层步长act='relu') # 激活类型# Dropout主要作用是减少过拟合，随机让某些权重不更新  # Dropout是一种正则化技术，通过在训练过程中阻止神经元节点间的联合适应性来减少过拟合。# 根据给定的丢弃概率dropout随机将一些神经元输出设置为0，其他的仍保持不变。drop = fluid.layers.dropout(x=conv_pool_1, dropout_prob=0.5)# 第二个卷积--池化层conv_pool_2 = fluid.nets.simple_img_conv_pool(input=drop,filter_size=3,num_filters=64,pool_size=2,pool_stride=2,act='relu')# 减少过拟合，随机让某些权重不更新                                                   drop = fluid.layers.dropout(x=conv_pool_2, dropout_prob=0.5)# 第三个卷积--池化层conv_pool_3 = fluid.nets.simple_img_conv_pool(input=drop,filter_size=3,num_filters=64,pool_size=2,pool_stride=2,act='relu')# 减少过拟合，随机让某些权重不更新                                                   drop = fluid.layers.dropout(x=conv_pool_3, dropout_prob=0.5)# 全连接层fc = fluid.layers.fc(input=drop, size=512, act='relu')# 减少过拟合，随机让某些权重不更新                                                   drop =  fluid.layers.dropout(x=fc, dropout_prob=0.5)                                                   # 输出层 以softmax为激活函数的全连接输出层，输出层的大小为图像类别type_size个数predict = fluid.layers.fc(input=drop,size=type_size,act='softmax')return predict

定义两个paddle世界里面的数据，便于之后模型的定义。

img = fluid.layers.data(name='img', shape=[3,100,100], dtype='float32')# 标签shape=1
label = fluid.layers.data(name='label', shape=[1], dtype='int64')

定义模型

# ##### 获取分类器，用cnn网络进行分类type_size要和训练的类别一致 ########
predict = convolutional_neural_network(image=img, type_size=4)

定义损失函数和准确率

这次使用的是交叉熵损失函数，该函数在分类任务上比较常用。

定义了一个损失函数之后，还有对它求平均值，因为定义的是一个Batch的损失值。

同时我们还可以定义一个准确率函数，这个可以在我们训练的时候输出分类的准确率。

# 获取损失函数和准确率
cost = fluid.layers.cross_entropy(input=predict, label=label)
# 计算cost中所有元素的平均值
avg_cost = fluid.layers.mean(cost)
#计算准确率
accuracy = fluid.layers.accuracy(input=predict, label=label)

定义优化方法

接着是定义优化方法，这次我们使用的是Adam优化方法，同时指定学习率为0.001。

# 定义优化方法
optimizer = fluid.optimizer.Adam(learning_rate=0.001)    # Adam是一阶基于梯度下降的算法，基于自适应低阶矩估计该函数实现了自适应矩估计优化器optimizer.minimize(avg_cost)                             # 取局部最优化的平均损失
print(type(accuracy))

在上述模型配置完毕后，得到两个fluid.Program：fluid.default_startup_program() 与fluid.default_main_program() 配置完毕了。

参数初始化操作会被写入fluid.default_startup_program()

fluid.default_main_program()用于获取默认或全局main program(主程序)。该主程序用于训练和测试模型。fluid.layers 中的所有layer函数可以向 default_main_program 中添加算子和变量。default_main_program 是fluid的许多编程接口（API）的Program参数的缺省值。例如,当用户program没有传入的时候， Executor.run() 会默认执行 default_main_program 。
13.（以下是训练模型与评估模型）
创建Executor

首先定义运算场所 fluid.CPUPlace()和 fluid.CUDAPlace(0)分别表示运算场所为CPU和GPU

Executor:接收传入的program，通过run()方法运行program。

训练分为三步：第一步配置好训练的环境，第二步用训练集进行训练，并用验证集对训练进行评估，不断优化，第三步保存好训练的模型
（简单来说就是套话，基本相当于闭区间连续开区间可导）

# 使用CPU进行训练
place = fluid.CPUPlace()
# 创建一个executor
exe = fluid.Executor(place)
# 对program进行参数初始化1.网络模型2.损失函数3.优化函数
c = exe.run(fluid.default_startup_program())

定义数据映射器

DataFeeder负责将数据提供器（train_reader,test_reader）返回的数据转成一种特殊的数据结构，使其可以输入到Executor中。

feed_list设置向模型输入的向变量表或者变量表名
（简单来说这个就是运行模型的时候，需要将python世界的数据传给paddle，下面就是先定义了，也可以不用这行代码，直接在下面的训练网络中的exe.run()中在feed中定义。）

feeder = fluid.DataFeeder(feed_list=[img, label], place=place)#定义输入数据的维度，第一个是图片数据，第二个是图片对应的标签。

展示模型训练曲线

all_train_iter=0
all_train_iters=[]
all_train_costs=[]
all_train_accs=[]def draw_train_process(title,iters,costs,accs,label_cost,lable_acc):plt.title(title, fontsize=24)plt.xlabel("iter", fontsize=20)plt.ylabel("cost/acc", fontsize=20)plt.plot(iters, costs,color='red',label=label_cost) plt.plot(iters, accs,color='green',label=lable_acc) plt.legend()plt.grid()plt.show()

训练并保存模型

Executor接收传入的program,并根据feed map(输入映射表)和fetch_list(结果获取表) 向program中添加feed operators(数据输入算子)和fetch operators（结果获取算子)。

feed map为该program提供输入数据。fetch_list提供program训练结束后用户预期的变量。

这次训练5个Pass。每一个Pass训练结束之后，再使用验证集进行验证，并求出相应的损失值Cost和准确率acc。

（对于exe.run()的参数进行解读
1.program参数为套话，
2.feed参数为你要传给paddle世界的变量。
3.fetch_list为你要从paddle世界中拿回python世界的变量，这个参数里的变量作为返回值传回。
）

# 训练的轮数
EPOCH_NUM = 50
print('开始训练...')
#两种方法，用两个不同的路径分别保存训练的模型
#model_save_dir = "/home/aistudio/data/model_vgg"
model_save_dir = "/home/aistudio/data/model_cnn"
for pass_id in range(EPOCH_NUM):train_cost = 0for batch_id, data in enumerate(train_reader()):                         #遍历train_reader的迭代器，并为数据加上索引batch_idtrain_cost, train_acc = exe.run(program=fluid.default_main_program(),                            #运行主程序feed=feeder.feed(data),                                          #喂入一个batch的数据fetch_list=[avg_cost, accuracy])                                 #fetch均方误差和准确率all_train_iter=all_train_iter+BATCH_SIZEall_train_iters.append(all_train_iter)all_train_costs.append(train_cost[0])all_train_accs.append(train_acc[0])if batch_id % 10 == 0:                                               #每10次batch打印一次训练、进行一次测试print("\nPass %d, Step %d, Cost %f, Acc %f" % (pass_id, batch_id, train_cost[0], train_acc[0]))# 开始测试test_accs = []                                                            #测试的损失值test_costs = []                                                           #测试的准确率# 每训练一轮 进行一次测试for batch_id, data in enumerate(test_reader()):                           # 遍历test_readertest_cost, test_acc = exe.run(program=fluid.default_main_program(),  # #运行测试主程序feed=feeder.feed(data),                #喂入一个batch的数据fetch_list=[avg_cost, accuracy])       #fetch均方误差、准确率test_accs.append(test_acc[0])                                        #记录每个batch的误差test_costs.append(test_cost[0])                                      #记录每个batch的准确率# 求测试结果的平均值test_cost = (sum(test_costs) / len(test_costs))                           # 每轮的平均误差test_acc = (sum(test_accs) / len(test_accs))                              # 每轮的平均准确率print('Test:%d, Cost:%0.5f, ACC:%0.5f' % (pass_id, test_cost, test_acc))# 如果保存路径不存在就创建if not os.path.exists(model_save_dir):os.makedirs(model_save_dir)# 保存训练的模型，executor 把所有相关参数保存到 dirname 中fluid.io.save_inference_model(dirname=model_save_dir, feeded_var_names=["img"],target_vars=[predict],executor=exe)draw_train_process("training",all_train_iters,all_train_costs,all_train_accs,"trainning cost","trainning acc")print('训练模型保存完成！')

训练结果

开始训练...Pass 0, Step 0, Cost 1.348765, Acc 0.406250
Test:0, Cost:0.87479, ACC:0.71875Pass 1, Step 0, Cost 0.996161, Acc 0.562500
Test:1, Cost:0.79946, ACC:0.81250Pass 2, Step 0, Cost 0.857416, Acc 0.562500
Test:2, Cost:0.61938, ACC:0.87500Pass 3, Step 0, Cost 0.928970, Acc 0.625000
Test:3, Cost:0.65270, ACC:0.81250Pass 4, Step 0, Cost 0.799504, Acc 0.562500
Test:4, Cost:0.48459, ACC:0.79688Pass 5, Step 0, Cost 0.832786, Acc 0.625000
Test:5, Cost:0.43842, ACC:0.84375Pass 6, Step 0, Cost 0.844179, Acc 0.687500
Test:6, Cost:0.50380, ACC:0.79688Pass 7, Step 0, Cost 0.629867, Acc 0.781250
Test:7, Cost:0.48292, ACC:0.82812Pass 8, Step 0, Cost 0.756400, Acc 0.687500
Test:8, Cost:0.30525, ACC:0.87500Pass 9, Step 0, Cost 0.517354, Acc 0.718750
Test:9, Cost:0.19674, ACC:0.93750Pass 10, Step 0, Cost 0.449566, Acc 0.750000
Test:10, Cost:0.22605, ACC:0.87500Pass 11, Step 0, Cost 0.316750, Acc 0.843750
Test:11, Cost:0.20127, ACC:0.93750Pass 12, Step 0, Cost 0.773299, Acc 0.625000
Test:12, Cost:0.49228, ACC:0.82812Pass 13, Step 0, Cost 0.636977, Acc 0.718750
Test:13, Cost:0.25362, ACC:0.90625Pass 14, Step 0, Cost 0.502778, Acc 0.750000
Test:14, Cost:0.18963, ACC:0.93750Pass 15, Step 0, Cost 0.480923, Acc 0.750000
Test:15, Cost:0.18480, ACC:0.93750Pass 16, Step 0, Cost 0.297340, Acc 0.937500
Test:16, Cost:0.19979, ACC:0.89062Pass 17, Step 0, Cost 0.397132, Acc 0.812500
Test:17, Cost:0.20924, ACC:0.90625Pass 18, Step 0, Cost 0.536720, Acc 0.750000
Test:18, Cost:0.10472, ACC:0.98438Pass 19, Step 0, Cost 0.326673, Acc 0.843750
Test:19, Cost:0.12716, ACC:0.93750Pass 20, Step 0, Cost 0.620206, Acc 0.750000
Test:20, Cost:0.12389, ACC:0.93750Pass 21, Step 0, Cost 0.248110, Acc 0.875000
Test:21, Cost:0.26824, ACC:0.87500Pass 22, Step 0, Cost 0.400013, Acc 0.843750
Test:22, Cost:0.11487, ACC:0.95312Pass 23, Step 0, Cost 0.441241, Acc 0.812500
Test:23, Cost:0.09749, ACC:0.96875Pass 24, Step 0, Cost 0.432491, Acc 0.781250
Test:24, Cost:0.12886, ACC:0.95312Pass 25, Step 0, Cost 0.467345, Acc 0.781250
Test:25, Cost:0.08277, ACC:0.95312Pass 26, Step 0, Cost 0.372901, Acc 0.843750
Test:26, Cost:0.11423, ACC:0.93750Pass 27, Step 0, Cost 0.256766, Acc 0.875000
Test:27, Cost:0.13660, ACC:0.93750Pass 28, Step 0, Cost 0.349426, Acc 0.812500
Test:28, Cost:0.16325, ACC:0.92188Pass 29, Step 0, Cost 0.132241, Acc 1.000000
Test:29, Cost:0.16529, ACC:0.93750Pass 30, Step 0, Cost 0.268292, Acc 0.875000
Test:30, Cost:0.10938, ACC:0.96875Pass 31, Step 0, Cost 0.129154, Acc 1.000000
Test:31, Cost:0.13127, ACC:0.93750Pass 32, Step 0, Cost 0.181589, Acc 0.937500
Test:32, Cost:0.09389, ACC:0.96875Pass 33, Step 0, Cost 0.160934, Acc 0.906250
Test:33, Cost:0.07949, ACC:0.96875Pass 34, Step 0, Cost 0.315892, Acc 0.875000
Test:34, Cost:0.04833, ACC:0.98438Pass 35, Step 0, Cost 0.376673, Acc 0.843750
Test:35, Cost:0.08582, ACC:0.96875Pass 36, Step 0, Cost 0.167184, Acc 0.968750
Test:36, Cost:0.08826, ACC:0.98438Pass 37, Step 0, Cost 0.242697, Acc 0.906250
Test:37, Cost:0.04399, ACC:0.98438Pass 38, Step 0, Cost 0.297262, Acc 0.812500
Test:38, Cost:0.12274, ACC:0.95312Pass 39, Step 0, Cost 0.272865, Acc 0.875000
Test:39, Cost:0.05779, ACC:0.96875Pass 40, Step 0, Cost 0.217407, Acc 0.937500
Test:40, Cost:0.04750, ACC:1.00000Pass 41, Step 0, Cost 0.255237, Acc 0.875000
Test:41, Cost:0.06270, ACC:0.98438Pass 42, Step 0, Cost 0.497028, Acc 0.718750
Test:42, Cost:0.06846, ACC:0.95312Pass 43, Step 0, Cost 0.174684, Acc 0.906250
Test:43, Cost:0.04472, ACC:0.98438Pass 44, Step 0, Cost 0.206826, Acc 0.937500
Test:44, Cost:0.05809, ACC:0.98438Pass 45, Step 0, Cost 0.410881, Acc 0.781250
Test:45, Cost:0.24499, ACC:0.92188Pass 46, Step 0, Cost 0.269225, Acc 0.906250
Test:46, Cost:0.06178, ACC:0.98438Pass 47, Step 0, Cost 0.178426, Acc 0.937500
Test:47, Cost:0.05151, ACC:1.00000Pass 48, Step 0, Cost 0.203568, Acc 0.875000
Test:48, Cost:0.02748, ACC:1.00000Pass 49, Step 0, Cost 0.146326, Acc 0.937500
Test:49, Cost:0.04516, ACC:1.00000训练模型保存完成！

16.
模型预测
下面是预测程序，直接单独运行In[*]就可以。预测主要有四步：第一步配置好预测的环境，第二步准备好要预测的图片，第三步加载预测的模型，把要预测的图片放到模型里进行预测，第四步输出预测的结果

# coding:utf-8
import paddle.fluid as fluid
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
import paddle# 使用CPU进行训练
place = fluid.CPUPlace()
# 定义一个executor
infer_exe = fluid.Executor(place)
inference_scope = fluid.core.Scope()#要想运行一个网络，需要指明它运行所在的域，确切的说： exe.Run(&scope)
#选择保存不同的训练模型
params_dirname ="/home/aistudio/data/model_cnn"
#params_dirname ='/home/aistudio/data/model_vgg'# （1）图片预处理
def load_image(path):img = paddle.dataset.image.load_and_transform(path,100,100, False).astype('float32')#img.shape是(3, 100, 100)img = img / 255.0 return imginfer_imgs = []
infer_path = []
zzy = '/home/aistudio/images/face/zhangziyi/20181206144436.png'
jw = '/home/aistudio/images/face/pengyuyan/20181206161115.png'
pyy = '/home/aistudio/images/face/jiangwen/0acb8d12-f929-11e8-ac67-005056c00008.jpg'
infer_path.append((Image.open(zzy), load_image(zzy)))
infer_path.append((Image.open(jw), load_image(jw)))
infer_path.append((Image.open(pyy), load_image(pyy)))print('infer_imgs的维度：',np.array(infer_path[0][1]).shape)#fluid.scope_guard修改全局/默认作用域（scope）, 运行时中的所有变量都将分配给新的scope
with fluid.scope_guard(inference_scope):#获取训练好的模型#从指定目录中加载 推理model(inference model)[inference_program,# 预测用的programfeed_target_names,# 是一个str列表，它包含需要在推理 Program 中提供数据的变量的名称。fetch_targets] = fluid.io.load_inference_model(params_dirname, infer_exe)#fetch_targets：是一个 Variable 列表，从中我们可以得到推断结果。image_and_path = infer_path[0]plt.imshow(image_and_path[0])   #根据数组绘制图像plt.show()        #显示图像# 开始预测results = infer_exe.run(inference_program,                      #运行预测程序feed={feed_target_names[0]: np.array([image_and_path[1]])},#喂入要预测的数据fetch_list=fetch_targets)               #得到推测结果print('results:',np.argmax(results[0]))# 训练数据的标签label_list = ["zhangziyi","jiangwen","pengyuyan"]print(results)print("infer results: %s" % label_list[np.argmax(results[0])])