import os
import shutil
import test_img_v1
import paddle as paddle
import test_img_reader

crop_size = 224
resize_size = 250

# 定义输入层
paddle.enable_static()
image = paddle.static.data(name='image', shape=[-1,3, crop_size, crop_size], dtype='float32')
label = paddle.static.data(name='label', shape=[-1,1], dtype='int64')

# 获取分类器，因为这次只爬取了6个类别的图片，所以分类器的类别大小为6
model = test_img_v1.net(image, 6)

# 交叉熵损失函数 该函数会将softmax操作、交叉熵损失函数的计算过程进行合并，从而提供了数值上更稳定的计算
cost = paddle.nn.functional.cross_entropy(input=model, label=label)
#计算平均值
avg_cost = paddle.mean(cost)
#使用输入和标签计算准确率
acc = paddle.metric.accuracy(input=model, label=label)

# 获取训练和测试程序
test_program = paddle.static.default_main_program().clone(for_test=True)

# Adam优化器 能够利用梯度的一阶矩估计和二阶矩估计动态调整每个参数的学习率
#L2Decay实现L2权重衰减正则化，用于模型训练，有助于防止模型对训练数据过拟合
optimizer = paddle.optimizer.Adam(learning_rate=1e-3,
weight_decay =paddle.regularizer.L2Decay(0.0001))
opts = optimizer.minimize(avg_cost)

# 获取自定义数据
train_reader = paddle.batch(reader=test_img_reader.train_reader('../images/train.list', crop_size, resize_size), batch_size=32)
test_reader = paddle.batch(reader=test_img_reader.test_reader('../images/test.list', crop_size), batch_size=32)

# 定义一个使用GPU的执行器
place = paddle.CPUPlace()
exe = paddle.static.Executor(place)
exe.run(paddle.static.default_startup_program())

# 定义输入数据维度
feeder = paddle.fluid.DataFeeder(place=place, feed_list=[image, label])

# 训练100次
for pass_id in range(1):
# 进行训练
for batch_id, data in enumerate(train_reader()):
train_cost, train_acc = exe.run(program=paddle.static.default_main_program(),
feed=feeder.feed(data),
fetch_list=[avg_cost, acc])

# 每100个batch打印一次信息
if batch_id % 100 == 0:
print('Pass:%d, Batch:%d, Cost:%0.5f, Accuracy:%0.5f' %
(pass_id, batch_id, train_cost[0], train_acc[0]))

# 进行测试
test_accs = []
test_costs = []
for batch_id, data in enumerate(test_reader()):
test_cost, test_acc = exe.run(program=test_program,
feed=feeder.feed(data),
fetch_list=[avg_cost, acc])
test_accs.append(test_acc[0])
test_costs.append(test_cost[0])
# 求测试结果的平均值
test_cost = (sum(test_costs) / len(test_costs))
test_acc = (sum(test_accs) / len(test_accs))
print('Test:%d, Cost:%0.5f, Accuracy:%0.5f' % (pass_id, test_cost, test_acc))

# 保存预测模型
save_path = 'infer_model2/'
# 删除旧的模型文件
shutil.rmtree(save_path, ignore_errors=True)
# 创建保持模型文件目录
os.makedirs(save_path)
# 保存预测模型
paddle.static.save_inference_model(save_path+"dish", feed_vars=[image], fetch_vars=[model], executor=exe)

from PIL import Image
import numpy as np
import paddle

import paddle.fluid as fluid

# 定义输入层
crop_size = 224
resize_size = 250

paddle.enable_static()

# 定义一个使用GPU的执行器
# place = paddle.CPUPlace()
# exe = paddle.static.Executor(place)
# exe.run(paddle.static.default_startup_program())

place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())

# 保存预测模型路径
save_path = 'infer_model2/dish'
# 从模型中获取预测程序、输入数据名称列表、分类器
[inference_program, feed_target_names, fetch_targets] = paddle.static.load_inference_model(path_prefix=save_path, executor=exe)

# 预处理图片
def load_image(file):
img = Image.open(file)
# 统一图像大小
img = img.resize((224, 224), Image.ANTIALIAS)
# 转换成numpy值
img = np.array(img).astype(np.float32)
# 转换成CHW
img = img.transpose((2, 0, 1))
# 转换成BGR
img = img[(2, 1, 0), :, :] / 255.0
img = np.expand_dims(img, axis=0)
return img

# 获取图片数据
img = load_image('../test_images/yuan_ce077f744206d6fbc17e25ff31b080d4.jpg')

# 执行预测
result = exe.run(program=inference_program,
feed={feed_target_names[0]: img},
fetch_list=fetch_targets)

# 显示图片并输出结果最大的label
lab = np.argsort(result)[0][0][-1]

names = ['苹果', '哈密瓜', '胡萝卜', '樱桃', '黄瓜', '西瓜']

print('预测结果标签为：%d， 名称为：%s， 概率为：%f' % (lab, names[lab], result[0][0][lab]))