水果识别 python paddlepaddle 人工智能_paddle.dataset.image.simple_transform

第三篇文章
数字图像处理的一个结课作业，技术上就是搭建一个深度学习网络，训练出模型，保存模型，调用模型实现预测
其实，程序的代码也是，我在bilibili上面通过观看教学视频一个一个敲出来的，所用的编程语言是python加上一个百度关于人工智能的拓展库paddle，尽管整个代码敲出来我对于深度学习的概念还是很模糊，但是不得不讲，百度的paddle（飞浆）还是挺友好的，它的这个库使的一些不是专业从事深度学习的也可以做一个基于深度学习的小demo
这里还是讲一下我在B站上是观看的某内人工智能学院的教学视频（全名的话这里不太方便），由于这个程序不是跑在自己的电脑上的，你可能面临的问题就是有了代码，有了数据集，不知道怎么跑这个程序，这里简单说一下，该项目是在百度的Ai studio上创建的（一个网页）,网页上有一个在线的编辑器，运行程序的时候为了训练模型更快使用的百度云计算的GPU加速卡，所以真的需要的话可以加一下我Q2833306588（希望能给大家带来帮助，但是不要使随便抄抄应付作业）
源程序如下：（代码量还是挺客观的）
#fruits_classify.py
#图像分类：水果分类识别
#数据集介绍：
#1036张水果图片
#共有五个类别（苹果288张，香蕉275张，葡萄216张，橙子276张，梨251张）

#1.数据的预处理
import os
import j
name_dict={“apple”:0,“banana”:1,“grape”:2,
“orange”:3,“pear”:4} #名称——分类数字对应字典
#定义一些要用到的变量
data_root_path=“data/fruits/” #数据集目录
test_file_path=data_root_path+“test.list” #测试集文件路径
train_file_path=data_root_path+“train.list” #训练集文件路径
readme_file=data_root_path+“readme.json” #样本数据汇总文件
name_data_list={} #再定义一个字典，用来保存所有图片的路径和标签

def save_train_test_file(path,name):
if name not in name_data_list: #如果某类水果不在字典中
img_list=[] #创建一个空的列表
img_list.append(path) #压入文件路径
name_data_list[name]=img_list #保存列表到字典
else:#如果某类水果已经在字典中
name_data_list[name].append(path)#直接存入字典

#遍历目录将图片路径存入字典，然后再由字典将图片路径写入文件
dirs=os.listdir(data_root_path) #列出data/fruits/目录下的所有内容
for d in dirs:
full_path=data_root_path+d #拼出完整目录路径
if os.path.isdir(full_path): #如果是目录，遍历目录中的图片
imgs=os.listdir(full_path)
for img in imgs:
save_train_test_file(full_path+"/"+img,d) #保存文件路径的函数
else: #如果是文件，不对其处理
pass

#print(name_data_list)#打印字典

#分测试集和测试集合
with open(test_file_path,“w”) as f: #以写的格式打开测试集文件
pass #不作操作，相当于清空文件
with open(train_file_path,“w”) as f:
pass
#遍历字典，没10笔数据分一笔数据测试集，其他到训练集
for name,img_list in name_data_list.items():
i=0
num=len(img_list)#打印每一类图片张数
print("%s: %d张"%(name,num))
for img in img_list:
if i%10==0:#放入测试集
with open(test_file_path,“a”) as f:#以追加的格式是打开文件
line="%s\t%d\n"%(img,name_dict[name])#拼一行
f.write(line)#写入
else:#放入训练集
with open(train_file_path,“a”) as f:
line="%s\t%d\n"%(img,name_dict[name])#拼一行
f.write(line)
i+=1

#2.网络搭建，模型训练/保存
import paddle
import paddle.fluid as fluid
import numpy
import sys
from multiprocessing import cpu_count #多线程
import matplotlib.pyplot as plt #数据可视化

def train_mapper(sample): #函数功能：对数据修剪
img,label=sample#sample由图片路径和标记合成
if not os.path.exists(img):
print(“图片不存在：”,img)
else:
#读取图片，并且多图片作彩色变换
img=paddle.dataset.image.load_image(img)#读取图片
#对图片进行变换，修建，输出单通道的100*100的矩阵
img=paddle.dataset.image.simple_transform(im=img,
resize_size=100,
crop_size=100,
is_color=True,
is_train=True)
#图像的归一化处理，将值压缩到0~1之间
img=img.flatten().astype(“float32”)/255.0 #将每一个像素点的值除以255
return img,label #加工处理过的图片 和标签

#自定义reader，从数据集读取数据，并交给train_mapper处理
def train_r(train_list,buffered_size=1024):
def reader():
with open(train_list,“r”) as f:
#列表推导式，把文件里的内容都读出来，放到lines列表中
lines=[line.strip() for line in f]#strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）
for line in lines:
img_path,lab=line.strip().split("\t")
yield img_path,int(lab) #读取文件中的一行数据
#下面是一个高阶的函数，相当于建一个通道，可以将reader读取的数据映射train_mapper里面
return paddle.reader.xmap_readers(train_mapper,#mapper函数
reader,#reader函数
cpu_count(),#线程数
buffered_size)#缓冲区大小
#搭建神经网络
#输入层->卷积—池化/dropout->卷积-池化/dropout
#->卷积-池化/dropout->全连接层->dropout->全连接层
def convolution_nural_network(image,type_size):
#第一个卷积池化层
conv_pool_1=fluid.nets.simple_img_conv_pool(
input=image,#输入数据
filter_size=3,#卷积核大小，经验值
num_filters=32,#卷积核数量，与输出通道数相同
pool_size=2,#池化层大小22
pool_stride=2,#池化层步长 与卷积的过程一致，但是算法不同，将池化核最大值取出
act=“relu”#激活函数
)
#dropout:丢弃学习，随机丢弃一些神经元的输出，防止过拟合
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,#池化层大小22
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,#池化层大小2*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)  # 丢弃率
predict=fluid.layers.fc(input=drop,#输入
                        size=type_size,#最终分类个数5个类别
                        act="softmax")#激活函数
return predict
1
2
3
4
5
6
7
8
9
10

#准备数据执行训练
BATCH_SIZE=32
trainer_reader=train_r(train_list=train_file_path)
train_reader=paddle.batch(paddle.reader.shuffle(reader=trainer_reader,buf_size=1200),
batch_size=BATCH_SIZE)
#训练时的输入数据
image=fluid.layers.data(name=“image”,
shape=[3,100,100],
dtype=“float32”)
#训练时希望的输出值（真实类别）
label=fluid.layers.data(name=“label”,
shape=[1],
dtype=“int64”)
#调用函数创建卷积神经网络
predict=convolution_nural_network(image=image,#输入数据
type_size=5 )#类别数量
#交叉熵，度量两个概率之间的差异
cost=fluid.layers.cross_entropy(input=predict,#预测值
label=label)#期待值
avg_cost=fluid.layers.mean(cost) #求损失值的平均值
#计算准确率
accuracy=fluid.layers.accuracy(input=predict,#预测值
label=label)#期望值

#定义优化器
#自适应梯度下降优化器
optimizer=fluid.optimizer.Adam(learning_rate=0.001)
optimizer.minimize(avg_cost)
#定义执行器
place=fluid.CUDAPlace(0)#gpu上执行
exe=fluid.Executor(place)
exe.run(fluid.default_startup_program())#初始化系统参数
feeder=fluid.DataFeeder(feed_list=[image,label],
place=place)#喂入数据
for pass_id in range(10):#训练10轮
train_cost=0
for batch_id,data in enumerate(train_reader()):
train_cost,train_acc=exe.run(program=fluid.default_main_program(),#执行默认program
feed=feeder.feed(data),#输入数据
fetch_list=[avg_cost,accuracy])#获取结果，损失值和正确率
if batch_id%20==0:#没20次训练打印一笔
print(“pass:%d,batch:%d,cost:%f,acc:%f”%(pass_id,batch_id,train_cost[0],train_acc[0]))
print(“训练完成！”)

#保存模型
model_save_dir=“model/fruits/”#模型保存路径
if not os.path.exists(model_save_dir):
os.mkdir(model_save_dir)#如果文件不存在就新建一个文件
fluid.io.save_inference_model(dirname=model_save_dir,
feeded_var_names=[“image”],
target_vars=[predict],
executor=exe)
print(“保存模型完成！”)

#3.模型加载，执行预测
from PIL import Image #引入一个图形库

place=fluid.CPUPlace()#不需要再GPU上面跑
infer_exe=fluid.Executor(place)

#定义一个加载图像函数
def load_image(path):#加载一张图片，并调整为100*100
img=paddle.dataset.image.load_and_transform(path,100,100,False).astype(“float32”)
img=img/255.0#归一化处理
return img

infer_imgs=[]#图像数据列表
test_img=“apple.png”#待预测图像路径
infer_imgs.append(load_image(test_img))#加载图像数据，添加至列表
infer_imgs=numpy.array(infer_imgs)#!!!转换为array
#加载模型
[infer_program,feed_target_names,fetch_targets]=
fluid.io.load_inference_model(model_save_dir,infer_exe)
#显示原始图片
img=Image.open(test_img)#打开原始图片
plt.imshow(img)#显示原始图片
plt.show()
#执行预测
results=infer_exe.run(infer_program,
feed={feed_target_names[0]:infer_imgs},
fetch_list=fetch_targets)
print(results)#results为数组，包含每个类别的概率
result=numpy.argmax(results[0])#获取最大概率的索引
for k,v in name_dict.items():#根据字典获取预测结果的名字
if result==v:
print(“预测结果：”,k)

数据集的话还是建议联系一下我，我同事可以把B站的博主推给你，观看视频来一遍可能更直观