【深度学习】paddlepaddle——基于多层神经网络的图像识别案例

# 1、导包
import paddle.fluid as fluid
import paddle
import time

start = time.time()


def test_program(exe, feeder, program, fetch_list, reader):
    """
    测试进程
    :param exe:执行器
    :param feeder: 数据与网络关系
    :param program: 测试主进程
    :param fetch_list: 需要执行之后返回的损失与准确率
    :param reader: 测试reader
    :return:
    """
    # 训练次数
    count = 0
    # 整个测试集的总损失
    sum_loss = 0
    # 整个训练集的准确率
    sum_acc = 0
    for test_data in reader():
        test_avg_loss_value, test_acc_values = exe.run(
            program=program,  # 测试主进程
            feed=feeder.feed(test_data),  # 给测试喂数据
            fetch_list=fetch_list  # 需要执行之后返回的值
        )

        sum_loss += test_avg_loss_value
        sum_acc += test_acc_values
        count += 1
    # 得到整个训练集的平均损失，与整个训练集的准确率
    test_avg_loss = sum_loss / count
    test_acc = sum_acc / count

    return test_avg_loss, test_acc


# 2、数据处理---paddlepaddle 自带的mnist数据已经经过了数据处理

# 3、定义reader
# paddlepaddle给我们已经定义好了reader，只需要去调用

# 4、指定训练场所
place = fluid.CPUPlace()

# 5、配置网络
# 特征数据层
image = fluid.layers.data(name="image", shape=[1, 28, 28], append_batch_size=True, dtype="float64")
# 目标数据层
label = fluid.layers.data(name="label", shape=[1], append_batch_size=True, dtype="int64")
# 设计2个隐层 一个输出层 共3层的fc网络
h1 = fluid.layers.fc(input=image, size=128, name="h1", act="relu")
h2 = fluid.layers.fc(input=h1, size=64, name="h2", act="relu")

# 输出层
y_predict = fluid.layers.fc(input=h2, size=10, name="output_layer", act="softmax")

# 6、损失
# 交叉熵损失
loss = fluid.layers.cross_entropy(input=y_predict, label=label)
# 计算平均损失
avg_loss = fluid.layers.mean(loss)

# 计算准确率
acc = fluid.layers.accuracy(input=y_predict, label=label)

# 7、指定优化---sgd随机梯度下降优化算法
sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.1)
# 指定去优化损失
sgd_optimizer.minimize(avg_loss)

# 8、指定网络与数据层的关系
feeder = fluid.DataFeeder(feed_list=[image, label], place=place)

# 9、构建执行器
# 训练执行器
exe_train = fluid.Executor(place=place)
# 测试执行器
exe_test = fluid.Executor(place=place)

# 10、初始化网络参数
# 初始化参数进程
startup_program = fluid.default_startup_program()
exe_train.run(startup_program)
# 主进程
# 训练主进程
train_main_program = fluid.default_main_program()
# 测试主进程
test_main_program = train_main_program.clone(for_test=True)

# 11、获取图片数据
# 并不是直接拿到数据就往网络里面送
# 构建一个缓冲区，--打乱顺序，--再往网络里面送
# paddle.dataset.mnist.train() ----paddlepaddle的训练reader
# 缓冲区大小buf_size与批次大小batch_size 并没有多大的关系
# 一般设计的时候注意：buf_size 略微需要比batch_size 大一点就可以
# 而且batch_size 不能过大
# 训练reader 与测试reader 的batch_size数量必须一致
train_reader = paddle.batch(
    paddle.reader.shuffle(paddle.dataset.mnist.train(), buf_size=50),
    batch_size=10
)
test_reader = paddle.batch(
    paddle.reader.shuffle(paddle.dataset.mnist.test(), buf_size=50),
    batch_size=10
)

# 12、训练
# 指定训练轮数
loop_num = 2
# 定义的执行次数
step = 0

flag = False

for loop in range(loop_num):
    print("第%d轮训练" % loop)
    # train_data 每批次的数据
    for train_data in train_reader():
        # 执行器运行训练主进程
        train_avg_loss_value, train_acc_value = exe_train.run(
            program=train_main_program,  # 训练主进程
            feed=feeder.feed(train_data),  # 利用数据层与网络构建好的关系，将真实的数据喂给网络
            fetch_list=[avg_loss, acc]  # 执行之后需要返回的结果的值
        )
        # 每隔10步来打印一下损失与准确率
        if step % 10 == 0 and step != 0:
            print("第%d次训练的损失为%f,准确率为%f" % (step, train_avg_loss_value, train_acc_value))

        step += 1

        # 每隔100步 去测试集中测试一下训练效果
        if step % 100 == 0 and step != 0:
            test_avg_loss, test_acc = test_program(exe_test,
                                                   feeder,
                                                   test_main_program,
                                                   fetch_list=[avg_loss, acc],
                                                   reader=test_reader
                                                   )
            print("*" * 100)
            print("测试集的损失为：%f,准确率为：%f" % (test_avg_loss, test_acc))
            print("*" * 100)
            if test_avg_loss <= 0.1 and test_acc >= 0.98:
                flag = True
                print("最终测试集的损失为：%f,准确率为：%f" % (test_avg_loss, test_acc))

                end = time.time()
                print("运行总时长为：", end - start)
                break
    if flag:
        break