使用卷积神经网络解决美食图片的分类问题：：：数据集在我这里，私聊给！！！！！！！！！
环境：python3.7 ， 飞浆版本2.0 ， 操作平台pycharm
步骤1：美食图片数据集介绍与加载：
本实践使用的数据集包含5000张格式为jpg的三通道彩色图像，共5种食物类别。对于本实践中的数据包，具体处理与加载的方式与宝石分类类似，如不知，则请看我之前宝石分类的那篇文章
https://www.cnblogs.com/caizhou520/p/17810369.html
首先定义个方法对数据集的压缩包进行解压缩，解压完成之后可以看到数据集：
1 def unzip_data(src_path,target_path): 2 ''' 3 解压原始数据集，将src_path路径下的zip包解压至target_path目录下 4 ''' 5 if(not os.path.isdir(target_path + "foods")): 6 z = zipfile.ZipFile(src_path, 'r') 7 z.extractall(path=target_path) 8 z.close()
然后，定义get_data_list()方法遍历文件夹和图片，按照一定比例将数据分为训练集和验证集，并生成对应的train.txt和eval.txt文档，然后用json的形式对整个数据集进行一个说明；
1 def get_data_list(target_path,train_list_path,eval_list_path): 2 ''' 3 生成数据列表 4 ''' 5 #存放所有类别的信息 6 class_detail = [] 7 #获取所有类别保存的文件夹名称 8 data_list_path=target_path+"foods/" 9 class_dirs = os.listdir(data_list_path) 10 #总的图像数量 11 all_class_images = 0 12 #存放类别标签 13 class_label=0 14 #存放类别数目 15 class_dim = 0 16 #存储要写进eval.txt和train.txt中的内容 17 trainer_list=[] 18 eval_list=[] 19 #读取每个类别 20 for class_dir in class_dirs: 21 if class_dir != ".DS_Store": 22 class_dim += 1 23 #每个类别的信息 24 class_detail_list = {} 25 eval_sum = 0 26 trainer_sum = 0 27 #统计每个类别有多少张图片 28 class_sum = 0 29 #获取类别路径 30 path = data_list_path + class_dir 31 # 获取所有图片 32 img_paths = os.listdir(path) 33 for img_path in img_paths: # 遍历文件夹下的每个图片 34 name_path = path + '/' + img_path # 每张图片的路径 35 if class_sum % 10 == 0: # 每10张图片取一个做验证数据 36 eval_sum += 1 # test_sum为测试数据的数目 37 eval_list.append(name_path + "\t%d" % class_label + "\n") 38 else: 39 trainer_sum += 1 40 trainer_list.append(name_path + "\t%d" % class_label + "\n")#trainer_sum测试数据的数目 41 class_sum += 1 #每类图片的数目 42 all_class_images += 1 #所有类图片的数目 43 44 # 说明的json文件的class_detail数据 45 class_detail_list['class_name'] = class_dir #类别名称 46 class_detail_list['class_label'] = class_label #类别标签 47 class_detail_list['class_eval_images'] = eval_sum #该类数据的测试集数目 48 class_detail_list['class_trainer_images'] = trainer_sum #该类数据的训练集数目 49 class_detail.append(class_detail_list) 50 #初始化标签列表 51 train_parameters['label_dict'][str(class_label)] = class_dir 52 class_label += 1 53 54 #初始化分类数 55 train_parameters['class_dim'] = class_dim 56 57 #乱序 58 random.shuffle(eval_list) 59 with open(eval_list_path, 'a') as f: 60 for eval_image in eval_list: 61 f.write(eval_image) 62 63 random.shuffle(trainer_list) 64 with open(train_list_path, 'a') as f2: 65 for train_image in trainer_list: 66 f2.write(train_image) 67 68 # 说明的json文件信息 69 readjson = {} 70 readjson['all_class_name'] = data_list_path #文件父目录 71 readjson['all_class_images'] = all_class_images 72 readjson['class_detail'] = class_detail 73 jsons = json.dumps(readjson, sort_keys=True, indent=4, separators=(',', ': ')) 74 with open(train_parameters['readme_path'],'w') as f: 75 f.write(jsons) 76 print ('生成数据列表完成！')
生成train.txt文本和eval.txt文本：
生成训练数据和测试数据：
1 class FoodDataset(paddle.io.Dataset): 2 def __init__(self, data_path, mode='train'): 3 """ 4 数据读取器 5 :param data_path: 数据集所在路径 6 :param mode: train or eval 7 """ 8 super().__init__() 9 self.data_path = data_path 10 self.img_paths = [] 11 self.labels = [] 12 13 if mode == 'train': 14 with open(os.path.join(self.data_path, "train.txt"), "r", encoding="utf-8") as f: 15 self.info = f.readlines() 16 for img_info in self.info: 17 img_path, label = img_info.strip().split('\t') 18 self.img_paths.append(img_path) 19 self.labels.append(int(label)) 20 21 else: 22 with open(os.path.join(self.data_path, "eval.txt"), "r", encoding="utf-8") as f: 23 self.info = f.readlines() 24 for img_info in self.info: 25 img_path, label = img_info.strip().split('\t') 26 self.img_paths.append(img_path) 27 self.labels.append(int(label)) 28 29 30 def __getitem__(self, index): 31 """ 32 获取一组数据 33 :param index: 文件索引号 34 :return: 35 """ 36 # 第一步打开图像文件并获取label值 37 img_path = self.img_paths[index] 38 img = Image.open(img_path) 39 if img.mode != 'RGB': 40 img = img.convert('RGB') 41 img = img.resize((64, 64), Image.BILINEAR) 42 img = np.array(img).astype('float32') 43 img = img.transpose((2, 0, 1)) / 255 44 label = self.labels[index] 45 label = np.array([label], dtype="int64") 46 return img, label 47 48 def print_sample(self, index: int = 0): 49 print("文件名", self.img_paths[index], "\t标签值", self.labels[index]) 50 51 def __len__(self): 52 return len(self.img_paths) 53 54 55 # In[7]: 56 57 58 #训练数据加载 59 train_dataset = FoodDataset(data_path='/home/aistudio/data/',mode='train') 60 train_loader = paddle.io.DataLoader(train_dataset, batch_size=train_parameters['train_batch_size'], shuffle=True) 61 #测试数据加载 62 eval_dataset = FoodDataset(data_path='/home/aistudio/data/',mode='eval') 63 eval_loader = paddle.io.DataLoader(eval_dataset, batch_size = 8, shuffle=False)
步骤2：自定义卷积神经网络：
1 #定义卷积网络 2 class MyCNN(nn.Layer): 3 def __init__(self): 4 super(MyCNN,self).__init__() 5 # in_channels, out_channels, kernel_size, stride=1, padding=0 6 self.conv0 = nn.Conv2D(in_channels = 3,out_channels=64, kernel_size=3,padding=0,stride=1) 7 self.pool0 = nn.MaxPool2D(kernel_size = 2,stride = 2) 8 self.conv1 = nn.Conv2D(in_channels = 64,out_channels=128,kernel_size=3,padding=0, stride = 1) 9 self.pool1 = nn.MaxPool2D(kernel_size = 2, stride = 2) 10 self.conv2 = nn.Conv2D(in_channels = 128,out_channels=128,kernel_size=5,padding=0) 11 self.pool2 = nn.MaxPool2D(kernel_size = 2, stride = 2) 12 self.fc1 = nn.Linear(in_features=128*5*5,out_features=5) 13 14 def forward(self,input): 15 x = self.conv0(input) 16 x = self.pool0(x) 17 x = self.conv1(x) 18 x = self.pool1(x) 19 x = self.conv2(x) 20 x = self.pool2(x) 21 x = paddle.reshape(x,shape=[-1,128*5*5]) 22 y = self.fc1(x) 23 24 return y 25 26 27 # In[31]: 28 29 30 # 实例化网络 31 model = MyCNN() 32 # 定义输入 33 input_define = paddle.static.InputSpec(shape=[-1, 3 , 64, 64], 34 dtype="float32", 35 name="img") 36 37 label_define = paddle.static.InputSpec(shape=[-1, 1], 38 dtype="int64", 39 name="label") 40 model = paddle.Model(model, inputs=input_define, labels=label_define) 41 params_info = model.summary((1,3,64,64)) 42 print(params_info) # 打印模型基础结构和参数信息
打印出网络结构图，如下图所示，总共做了三次卷积和池化操作，最后经过全连接层，然后再输出5个类别图像的比率，选择概率大的图片：
步骤3：模型的训练：
定义训练集的准确率图和损失率图：
1 Batch=0 2 Batchs=[] 3 all_train_accs=[] 4 def draw_train_acc(Batchs, train_accs): 5 title="training accs" 6 plt.title(title, fontsize=24) 7 plt.xlabel("batch", fontsize=14) 8 plt.ylabel("acc", fontsize=14) 9 plt.plot(Batchs, train_accs, color='green', label='training accs') 10 plt.legend() 11 plt.grid() 12 plt.show() 13 14 all_train_loss=[] 15 def draw_train_loss(Batchs, train_loss): 16 title="training loss" 17 plt.title(title, fontsize=24) 18 plt.xlabel("batch", fontsize=14) 19 plt.ylabel("loss", fontsize=14) 20 plt.plot(Batchs, train_loss, color='red', label='training loss') 21 plt.legend() 22 plt.grid() 23 plt.show()
对模型进行训练，把训练好的模型的准确率和损失率通过定义的matplotlib画出来：
1 model=MyCNN() # 模型实例化 2 model.train() # 训练模式 3 cross_entropy = paddle.nn.CrossEntropyLoss() 4 opt=paddle.optimizer.SGD(learning_rate=0.001, parameters=model.parameters()) 5 6 epochs_num=train_parameters['num_epochs'] #迭代次数 7 for pass_num in range(train_parameters['num_epochs']): 8 for batch_id,data in enumerate(train_loader()): 9 image = data[0] 10 label = data[1] 11 predict=model(image) #数据传入model 12 # print(predict) 13 # print(np.argmax(predict,axis=1)) 14 loss=cross_entropy(predict,label) 15 acc=paddle.metric.accuracy(predict,label.reshape([-1,1]))#计算精度 16 # acc = np.mean(label==np.argmax(predict,axis=1)) 17 18 if batch_id!=0 and batch_id%10==0: 19 Batch = Batch+10 20 Batchs.append(Batch) 21 all_train_loss.append(loss.numpy()[0]) 22 all_train_accs.append(acc.numpy()[0]) 23 print("epoch:{},step:{},train_loss:{},train_acc:{}".format(pass_num,batch_id,loss.numpy()[0],acc.numpy()[0])) 24 loss.backward() 25 opt.step() 26 opt.clear_grad() #opt.clear_grad()来重置梯度 27 paddle.save(model.state_dict(),'MyCNN')#保存模型 28 draw_train_acc(Batchs,all_train_accs) 29 draw_train_loss(Batchs,all_train_loss)
步骤4：使用验证集数据对模型的好坏进行评估：
1 #模型评估 2 para_state_dict = paddle.load("MyCNN") 3 model = MyCNN() 4 model.set_state_dict(para_state_dict) #加载模型参数 5 model.eval() #验证模式 6 7 accs = [] 8 9 for batch_id,data in enumerate(eval_loader()):#测试集 10 image=data[0] 11 label=data[1] 12 predict=model(image) 13 acc=paddle.metric.accuracy(predict,label) 14 accs.append(acc.numpy()[0]) 15 avg_acc = np.mean(accs) 16 print("当前模型在验证集上的准确率为:",avg_acc)
由图可知，其模型在验证集的准确率较低。可能是由于训练迭代的次数比较少，建议改进模型进行迭代；
步骤5：预测一个新的图像是否和真实的类别保持一致
1 ''' 2 模型预测 3 ''' 4 5 para_state_dict = paddle.load("MyCNN") 6 model = MyCNN() 7 model.set_state_dict(para_state_dict) #加载模型参数 8 model.eval() #验证模式 9 10 #展示预测图片 11 infer_path='data/foods/baklava/1936599.jpg' 12 img = Image.open(infer_path) 13 plt.imshow(img) #根据数组绘制图像 14 plt.show() #显示图像 15 #对预测图片进行预处理 16 infer_imgs = [] 17 infer_imgs.append(load_image(infer_path)) 18 infer_imgs = np.array(infer_imgs) 19 label_dic = train_parameters['label_dict'] 20 for i in range(len(infer_imgs)): 21 data = infer_imgs[i] 22 dy_x_data = np.array(data).astype('float32') 23 dy_x_data=dy_x_data[np.newaxis,:, : ,:] 24 img = paddle.to_tensor (dy_x_data) 25 out = model(img) 26 lab = np.argmax(out.numpy()) #argmax():返回最大数的索引 27 print("第{}个样本,被预测为：{},真实标签为：{}".format(i+1,label_dic[str(lab)],infer_path.split('/')[-2]) ) 28 print("结束")
本实验完整代码如下所示：
1 #!/usr/bin/env python 2 # coding: utf-8 3 4 # 5 6 # ## 任务描述： 7 # 8 # ### 如何根据据图像的视觉内容为图像赋予一个语义类别是**图像分类**的目标，也是图像检索、图像内容分析和目标识别等问题的基础。 9 # 10 # ### 本实践旨在通过一个美食分类的案列，让大家理解和掌握如何使用飞桨动态图搭建一个**卷积神经网络**。 11 # 12 # ### 特别提示：本实践所用数据集均来自互联网，请勿用于商务用途。 13 14 # In[32]: 15 16 17 import os 18 import zipfile 19 import random 20 import json 21 import paddle 22 import sys 23 import numpy as np 24 from PIL import Image 25 from PIL import ImageEnhance 26 import paddle 27 from paddle import fluid 28 import matplotlib.pyplot as plt 29 import paddle.vision.transforms as T 30 import paddle.nn as nn 31 import paddle.nn.functional as F 32 33 34 # In[33]: 35 36 37 ''' 38 参数配置 39 ''' 40 train_parameters = { 41 "input_size": [3, 64, 64], #输入图片的shape 42 "class_dim": 5, #分类数 43 "src_path":"data/data42610/foods.zip", #原始数据集路径 44 "target_path":"/home/aistudio/data/", #要解压的路径 45 "train_list_path": "/home/aistudio/data/train.txt", #train.txt路径 46 "eval_list_path": "/home/aistudio/data/eval.txt", #eval.txt路径 47 "readme_path": "/home/aistudio/data/readme.json", #readme.json路径 48 "label_dict":{}, #标签字典 49 "num_epochs": 2, #训练轮数 50 "train_batch_size": 64, #训练时每个批次的大小 51 "learning_strategy": { #优化函数相关的配置 52 "lr": 0.01 #超参数学习率 53 } 54 } 55 56 57 # In[34]: 58 59 60 print(paddle.__version__) 61 62 63 # # **一、数据准备** 64 # 65 # ### （1）解压原始数据集 66 # 67 # ### （2）按照比例划分训练集与验证集 68 # 69 # ### （3）乱序，生成数据列表 70 # 71 # ### （4）构造训练数据集提供器和验证数据集提供器 72 73 # In[35]: 74 75 76 77 def unzip_data(src_path,target_path): 78 ''' 79 解压原始数据集，将src_path路径下的zip包解压至target_path目录下 80 ''' 81 if(not os.path.isdir(target_path + "foods")): 82 z = zipfile.ZipFile(src_path, 'r') 83 z.extractall(path=target_path) 84 z.close() 85 86 def get_data_list(target_path,train_list_path,eval_list_path): 87 ''' 88 生成数据列表 89 ''' 90 #存放所有类别的信息 91 class_detail = [] 92 #获取所有类别保存的文件夹名称 93 data_list_path=target_path+"foods/" 94 class_dirs = os.listdir(data_list_path) 95 #总的图像数量 96 all_class_images = 0 97 #存放类别标签 98 class_label=0 99 #存放类别数目 100 class_dim = 0 101 #存储要写进eval.txt和train.txt中的内容 102 trainer_list=[] 103 eval_list=[] 104 #读取每个类别 105 for class_dir in class_dirs: 106 if class_dir != ".DS_Store": 107 class_dim += 1 108 #每个类别的信息 109 class_detail_list = {} 110 eval_sum = 0 111 trainer_sum = 0 112 #统计每个类别有多少张图片 113 class_sum = 0 114 #获取类别路径 115 path = data_list_path + class_dir 116 # 获取所有图片 117 img_paths = os.listdir(path) 118 for img_path in img_paths: # 遍历文件夹下的每个图片 119 name_path = path + '/' + img_path # 每张图片的路径 120 if class_sum % 10 == 0: # 每10张图片取一个做验证数据 121 eval_sum += 1 # test_sum为测试数据的数目 122 eval_list.append(name_path + "\t%d" % class_label + "\n") 123 else: 124 trainer_sum += 1 125 trainer_list.append(name_path + "\t%d" % class_label + "\n")#trainer_sum测试数据的数目 126 class_sum += 1 #每类图片的数目 127 all_class_images += 1 #所有类图片的数目 128 129 # 说明的json文件的class_detail数据 130 class_detail_list['class_name'] = class_dir #类别名称 131 class_detail_list['class_label'] = class_label #类别标签 132 class_detail_list['class_eval_images'] = eval_sum #该类数据的测试集数目 133 class_detail_list['class_trainer_images'] = trainer_sum #该类数据的训练集数目 134 class_detail.append(class_detail_list) 135 #初始化标签列表 136 train_parameters['label_dict'][str(class_label)] = class_dir 137 class_label += 1 138 139 #初始化分类数 140 train_parameters['class_dim'] = class_dim 141 142 #乱序 143 random.shuffle(eval_list) 144 with open(eval_list_path, 'a') as f: 145 for eval_image in eval_list: 146 f.write(eval_image) 147 148 random.shuffle(trainer_list) 149 with open(train_list_path, 'a') as f2: 150 for train_image in trainer_list: 151 f2.write(train_image) 152 153 # 说明的json文件信息 154 readjson = {} 155 readjson['all_class_name'] = data_list_path #文件父目录 156 readjson['all_class_images'] = all_class_images 157 readjson['class_detail'] = class_detail 158 jsons = json.dumps(readjson, sort_keys=True, indent=4, separators=(',', ': ')) 159 with open(train_parameters['readme_path'],'w') as f: 160 f.write(jsons) 161 print ('生成数据列表完成！') 162 163 164 # In[5]: 165 166 167 ''' 168 参数初始化 169 ''' 170 src_path=train_parameters['src_path'] 171 target_path=train_parameters['target_path'] 172 train_list_path=train_parameters['train_list_path'] 173 eval_list_path=train_parameters['eval_list_path'] 174 batch_size=train_parameters['train_batch_size'] 175 176 ''' 177 解压原始数据到指定路径 178 ''' 179 unzip_data(src_path,target_path) 180 181 ''' 182 划分训练集与验证集，乱序，生成数据列表 183 ''' 184 #每次生成数据列表前，首先清空train.txt和eval.txt 185 with open(train_list_path, 'w') as f: 186 f.seek(0) 187 f.truncate() 188 with open(eval_list_path, 'w') as f: 189 f.seek(0) 190 f.truncate() 191 192 #生成数据列表 193 get_data_list(target_path,train_list_path,eval_list_path) 194 195 196 # In[6]: 197 198 199 200 class FoodDataset(paddle.io.Dataset): 201 def __init__(self, data_path, mode='train'): 202 """ 203 数据读取器 204 :param data_path: 数据集所在路径 205 :param mode: train or eval 206 """ 207 super().__init__() 208 self.data_path = data_path 209 self.img_paths = [] 210 self.labels = [] 211 212 if mode == 'train': 213 with open(os.path.join(self.data_path, "train.txt"), "r", encoding="utf-8") as f: 214 self.info = f.readlines() 215 for img_info in self.info: 216 img_path, label = img_info.strip().split('\t') 217 self.img_paths.append(img_path) 218 self.labels.append(int(label)) 219 220 else: 221 with open(os.path.join(self.data_path, "eval.txt"), "r", encoding="utf-8") as f: 222 self.info = f.readlines() 223 for img_info in self.info: 224 img_path, label = img_info.strip().split('\t') 225 self.img_paths.append(img_path) 226 self.labels.append(int(label)) 227 228 229 def __getitem__(self, index): 230 """ 231 获取一组数据 232 :param index: 文件索引号 233 :return: 234 """ 235 # 第一步打开图像文件并获取label值 236 img_path = self.img_paths[index] 237 img = Image.open(img_path) 238 if img.mode != 'RGB': 239 img = img.convert('RGB') 240 img = img.resize((64, 64), Image.BILINEAR) 241 img = np.array(img).astype('float32') 242 img = img.transpose((2, 0, 1)) / 255 243 label = self.labels[index] 244 label = np.array([label], dtype="int64") 245 return img, label 246 247 def print_sample(self, index: int = 0): 248 print("文件名", self.img_paths[index], "\t标签值", self.labels[index]) 249 250 def __len__(self): 251 return len(self.img_paths) 252 253 254 # In[7]: 255 256 257 #训练数据加载 258 train_dataset = FoodDataset(data_path='/home/aistudio/data/',mode='train') 259 train_loader = paddle.io.DataLoader(train_dataset, batch_size=train_parameters['train_batch_size'], shuffle=True) 260 #测试数据加载 261 eval_dataset = FoodDataset(data_path='/home/aistudio/data/',mode='eval') 262 eval_loader = paddle.io.DataLoader(eval_dataset, batch_size = 8, shuffle=False) 263 264 265 # In[8]: 266 267 268 print(train_dataset.__len__()) 269 print(eval_dataset.__len__()) 270 271 272 # # **二、模型配置** 273 # 274 # 275 276 # In[30]: 277 278 279 #定义卷积网络 280 class MyCNN(nn.Layer): 281 def __init__(self): 282 super(MyCNN,self).__init__() 283 # in_channels, out_channels, kernel_size, stride=1, padding=0 284 self.conv0 = nn.Conv2D(in_channels = 3,out_channels=64, kernel_size=3,padding=0,stride=1) 285 self.pool0 = nn.MaxPool2D(kernel_size = 2,stride = 2) 286 self.conv1 = nn.Conv2D(in_channels = 64,out_channels=128,kernel_size=3,padding=0, stride = 1) 287 self.pool1 = nn.MaxPool2D(kernel_size = 2, stride = 2) 288 self.conv2 = nn.Conv2D(in_channels = 128,out_channels=128,kernel_size=5,padding=0) 289 self.pool2 = nn.MaxPool2D(kernel_size = 2, stride = 2) 290 self.fc1 = nn.Linear(in_features=128*5*5,out_features=5) 291 292 def forward(self,input): 293 x = self.conv0(input) 294 x = self.pool0(x) 295 x = self.conv1(x) 296 x = self.pool1(x) 297 x = self.conv2(x) 298 x = self.pool2(x) 299 x = paddle.reshape(x,shape=[-1,128*5*5]) 300 y = self.fc1(x) 301 302 return y 303 304 305 # In[31]: 306 307 308 # 实例化网络 309 model = MyCNN() 310 # 定义输入 311 input_define = paddle.static.InputSpec(shape=[-1, 3 , 64, 64], 312 dtype="float32", 313 name="img") 314 315 label_define = paddle.static.InputSpec(shape=[-1, 1], 316 dtype="int64", 317 name="label") 318 model = paddle.Model(model, inputs=input_define, labels=label_define) 319 params_info = model.summary((1,3,64,64)) 320 print(params_info) # 打印模型基础结构和参数信息 321 322 323 # # **三、模型训练 && 四、模型评估** 324 325 # In[24]: 326 327 328 Batch=0 329 Batchs=[] 330 all_train_accs=[] 331 def draw_train_acc(Batchs, train_accs): 332 title="training accs" 333 plt.title(title, fontsize=24) 334 plt.xlabel("batch", fontsize=14) 335 plt.ylabel("acc", fontsize=14) 336 plt.plot(Batchs, train_accs, color='green', label='training accs') 337 plt.legend() 338 plt.grid() 339 plt.show() 340 341 all_train_loss=[] 342 def draw_train_loss(Batchs, train_loss): 343 title="training loss" 344 plt.title(title, fontsize=24) 345 plt.xlabel("batch", fontsize=14) 346 plt.ylabel("loss", fontsize=14) 347 plt.plot(Batchs, train_loss, color='red', label='training loss') 348 plt.legend() 349 plt.grid() 350 plt.show() 351 352 353 # In[25]: 354 355 356 model=MyCNN() # 模型实例化 357 model.train() # 训练模式 358 cross_entropy = paddle.nn.CrossEntropyLoss() 359 opt=paddle.optimizer.SGD(learning_rate=0.001, parameters=model.parameters()) 360 361 epochs_num=train_parameters['num_epochs'] #迭代次数 362 for pass_num in range(train_parameters['num_epochs']): 363 for batch_id,data in enumerate(train_loader()): 364 image = data[0] 365 label = data[1] 366 predict=model(image) #数据传入model 367 # print(predict) 368 # print(np.argmax(predict,axis=1)) 369 loss=cross_entropy(predict,label) 370 acc=paddle.metric.accuracy(predict,label.reshape([-1,1]))#计算精度 371 # acc = np.mean(label==np.argmax(predict,axis=1)) 372 373 if batch_id!=0 and batch_id%10==0: 374 Batch = Batch+10 375 Batchs.append(Batch) 376 all_train_loss.append(loss.numpy()[0]) 377 all_train_accs.append(acc.numpy()[0]) 378 print("epoch:{},step:{},train_loss:{},train_acc:{}".format(pass_num,batch_id,loss.numpy()[0],acc.numpy()[0])) 379 loss.backward() 380 opt.step() 381 opt.clear_grad() #opt.clear_grad()来重置梯度 382 paddle.save(model.state_dict(),'MyCNN')#保存模型 383 draw_train_acc(Batchs,all_train_accs) 384 draw_train_loss(Batchs,all_train_loss) 385 386 387 # # **五、模型评估** 388 389 # In[12]: 390 391 392 #模型评估 393 para_state_dict = paddle.load("MyCNN") 394 model = MyCNN() 395 model.set_state_dict(para_state_dict) #加载模型参数 396 model.eval() #验证模式 397 398 accs = [] 399 400 for batch_id,data in enumerate(eval_loader()):#测试集 401 image=data[0] 402 label=data[1] 403 predict=model(image) 404 acc=paddle.metric.accuracy(predict,label) 405 accs.append(acc.numpy()[0]) 406 avg_acc = np.mean(accs) 407 print("当前模型在验证集上的准确率为:",avg_acc) 408 409 410 # In[13]: 411 412 413 import os 414 import zipfile 415 416 def unzip_infer_data(src_path,target_path): 417 ''' 418 解压预测数据集 419 ''' 420 if(not os.path.isdir(target_path)): 421 z = zipfile.ZipFile(src_path, 'r') 422 z.extractall(path=target_path) 423 z.close() 424 425 426 def load_image(img_path): 427 ''' 428 预测图片预处理 429 ''' 430 img = Image.open(img_path) 431 if img.mode != 'RGB': 432 img = img.convert('RGB') 433 img = img.resize((64, 64), Image.BILINEAR) 434 img = np.array(img).astype('float32') 435 img = img.transpose((2, 0, 1)) # HWC to CHW 436 img = img/255 # 像素值归一化 437 return img 438 439 440 infer_src_path = '/home/aistudio/data/data42610/foods.zip' 441 infer_dst_path = '/home/aistudio/data/foods_test' 442 unzip_infer_data(infer_src_path,infer_dst_path) 443 444 ''' 445 模型预测 446 ''' 447 448 para_state_dict = paddle.load("MyCNN") 449 model = MyCNN() 450 model.set_state_dict(para_state_dict) #加载模型参数 451 model.eval() #验证模式 452 453 #展示预测图片 454 infer_path='data/foods/baklava/1936599.jpg' 455 img = Image.open(infer_path) 456 plt.imshow(img) #根据数组绘制图像 457 plt.show() #显示图像 458 #对预测图片进行预处理 459 infer_imgs = [] 460 infer_imgs.append(load_image(infer_path)) 461 infer_imgs = np.array(infer_imgs) 462 label_dic = train_parameters['label_dict'] 463 for i in range(len(infer_imgs)): 464 data = infer_imgs[i] 465 dy_x_data = np.array(data).astype('float32') 466 dy_x_data=dy_x_data[np.newaxis,:, : ,:] 467 img = paddle.to_tensor (dy_x_data) 468 out = model(img) 469 lab = np.argmax(out.numpy()) #argmax():返回最大数的索引 470 print("第{}个样本,被预测为：{},真实标签为：{}".format(i+1,label_dic[str(lab)],infer_path.split('/')[-2]) ) 471 print("结束")