深度学习基础教程-用paddle实现-之数字识别_paddleocr 只识别数字

手写数字识别

本文是学习博客，转载自百度paddle框架的学习文档，代码自己敲了一遍，（由于python2和python3 的区别）会有一点改动。

代码：

from PIL import Image
import matplotlib.pyplot as plt
import numpy as np
import paddle
import paddle.fluid as fluid

"""
我们需要设置 inference_program 函数。我们想用这个程序来演示三个不同的分类器，每个分类器都定义为 Python 函数。 
我们需要将图像数据输入到分类器中。Paddle 为读取数据提供了一个特殊的层 layer.data 层。 
让我们创建一个数据层来读取图像并将其连接到分类网络。
"""


def softmax_regression(img,label):
    """
    定义softmax分类器：
        一个一softmax为激活函数的全链接层
    :return:
        predict_image --分类结果
    """
    predict_img = fluid.layers.fc(input = img,size = 10,act = 'softmax')
    return predict_img,label


def multilayer_perception(img,label):
    """
        定义多层感知机分类器
        含有两个隐藏层（全连接层）的多层感知机
        其中钱两个隐藏层的激活函数是RULU，输出层的激活函数是softmax
    :return:
        predict_img --分类结果
    """
    # 建立第一个隐层（全链接层） ，激活函数为relu
    hidden_1 = fluid.layers.fc(input=img,size=200,act='relu')
    # 建立第二个隐层（全连接层） ， 激活函数为relu
    hidden_2 = fluid.layers.fc(input=hidden_1,size=200,act='relu')
    # # 以softmax为激活函数的全连接输出层，输出层的大小必须为数字的个数10
    prediction = fluid.layers.fc(input=hidden_2,size=10,act='softmax')
    return  prediction , label


def converlutional_neural_network(img,label):
    """
    定义卷积神经网络分类器：
        输入的二维图像经过两个卷积-池化层，使用softmax为激活函数的全连接层作为输出层
    :return:
        predict --分类结果
    """

    #第一个卷积-池化层，使用20个5*5的滤波器，池化大小为2，池化步长为2，激活函数为RELU
    conv_pool_1 = fluid.nets.simple_img_conv_pool(
        input = img, # 输入数据的名称
        filter_size = 5 , #滤波器尺寸
        num_filters = 20 , #滤波器数量
        pool_size = 2,   #池化大小
        pool_stride = 2, #池化步长
        act = 'relu'
    )
    conv_pool_1 = fluid.layers.batch_norm(conv_pool_1)
    #第二个卷积-池化层，使用50个5*5的滤波器，池化大小为2，池化步长为2，激活函数为relu
    conv_pool_2 = fluid.nets.simple_img_conv_pool(
        input = conv_pool_1, #输入数据
        filter_size = 5,
        num_filters = 50,
        pool_size = 2,
        pool_stride = 2,
        act = 'relu'
    )

    prediction = fluid.layers.fc(input=conv_pool_2,size=10,act='softmax')

    return  prediction ,label


def train_progam(img,label):
    """
    配置 train_program
    :return:
    predict --分类结果
    avg_cost --平均损失
    acc      --准确率
    """
    # predict,label = softmax_regression(img,label) #取消注释将使用softmax回归
    # predict,label = multilayer_perception(img,label) #取消注释将使用多层感知机
    predict ,label = converlutional_neural_network(img,label) #取消注释将使用卷据-池化网络

    #使用交叉熵计算predit和label之间的损失函数
    cost = fluid.layers.cross_entropy(input = predict,label=label)
    avg_cost = fluid.layers.mean(cost)

    #计算分类准确率
    acc = fluid.layers.accuracy(input=predict,label=label)
    return predict, [avg_cost, acc]


def optimizer_funtion():
    """
    优化函数： Adam optimizer ，神经网络中常用的优化函数
    learning_rate 是学习率，它的大小与网络的训练收敛速度有关
    """
    return fluid.optimizer.Adam(learning_rate=0.001)


def set_Feeder():
    """
    下一步，我们开始训练过程。paddle.dataset.mnist.train()和paddle.dataset.mnist.test()分别做训练和测试数据集。这两个函数各自返回一个reader——PaddlePaddle中的reader是一个Python函数，每次调用的时候返回一个Python yield generator（生成器）。
下面shuffle是一个reader decorator，它接受一个reader A，返回另一个reader B。reader B 每次读入buffer_size条训练数据到一个buffer里，然后随机打乱其顺序，并且逐条输出。
batch是一个特殊的decorator，它的输入是一个reader，输出是一个batched reader。在PaddlePaddle里，一个reader每次yield一条训练数据，而一个batched reader每次yield一个minibatch。
    :return:
    """
    #一个minibatch中有64个数据
    BATCH_SIZE = 64

    train_reader = paddle.batch(
        paddle.reader.shuffle(
            reader=paddle.dataset.mnist.train(), #下载训练集，一个一次只能yield一条数的生成器
            buf_size= 500                  #读取500条数据后打乱顺序再《逐条》输出
        ),
        batch_size = BATCH_SIZE          #把逐条得到的数据，每64个作为以后minibatch输出
    )

    test_reader = paddle.batch(
        reader=paddle.dataset.mnist.test(),  # 下载训练集，一个一次只能yield一条数的生成器,
        batch_size = BATCH_SIZE  # 把逐条得到的数据，每64个作为以后minibatch输出
    )
    return train_reader ,test_reader


def event_haddle(pass_id,batch_id,cost):
    # 打印训练的中间结果，训练轮次，batch数，损失函数
    print("Pass_id: %d, Batch_id_ %d, Cost: %f" % (pass_id, batch_id, cost))


def event_haddle_plot():
    #将训练过程绘图表示
    from paddle.utils.plot import Ploter

    train_prompt = "Train cost"
    test_prompt = "Test cost"
    cost_ploter = Ploter(train_prompt, test_prompt)

    # cost_ploter.append(ploter_title, step, cost)
    # cost_ploter.plot()
    # pass


def train_test(train_test_program,train_test_feed,train_test_reader,exe,avg_cost,acc):
    #将分类准确率存在acc_set中
    acc_set = []
    # 将平均损失存储在avg_loss_set中
    avg_loss_set = []
    # 将测试 reader yield 出的每一个数据传入网络中进行训练
    for test_data in train_test_reader():
         avg_loss_np ,acc_np= exe.run(
            program = train_test_program,
            feed = train_test_feed.feed(test_data),
            fetch_list = [avg_cost,acc]
        )

    acc_set.append(float(acc_np))
    avg_loss_set.append(float(avg_loss_np))
    # 获得测试数据上的准确率和损失值
    acc_val_mean = np.array(acc_set).mean()
    avg_loss_val_mean = np.array(avg_loss_set).mean()
    # 返回平均损失值，平均准确率
    return avg_loss_val_mean, acc_val_mean


def main(save_dirname):
    # 获取数据
    train_reader, test_reader = set_Feeder()
    # 输入原始图像数据，大小为28*28*1
    img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
    # 标签层，名称为label，对应输入图片的类别标签
    label = fluid.layers.data(name='label', shape=[1], dtype='int64')

    #定义损失函数、准确率、和预测算法
    predict, [avg_cost, acc] = train_progam(img,label)

    #定义优化函数,传入损失
    optimizer = optimizer_funtion()
    optimizer.minimize(avg_cost)

    #初始化参数
    place = fluid.CPUPlace()
    exe = fluid.Executor(place)
    exe.run(fluid.default_startup_program())
    main_program = fluid.default_main_program()
    # test_program = main_program.clone(for_test=True)

    # 设置数据输入器
    feeder = fluid.DataFeeder(feed_list=[img, label], place=place)

    #设置训练过程的超参
    PASS_NUM = 5
    epochs = [epoch_id for epoch_id in range(PASS_NUM)]



    #创建执行器
    lists = []
    step = 0
    for epoch_id in epochs:
        for step_id , data in enumerate(train_reader()):
            metrics = exe.run(
                program = main_program,
                feed = feeder.feed(data),
                fetch_list=[avg_cost,acc]
            )
            if step % 100 ==0:  #每训练100次打印一次log
                print("step =  %d ; epoch_num = %d ; Cost =  %f ; acc = %f" % (step, epoch_id, metrics[0] , metrics[1]))

            step += 1

        # 测试每个epoch的分类效果
        avg_loss_val, acc_val = train_test(train_test_program = main_program,
                                           train_test_reader = test_reader,
                                           train_test_feed = feeder,
                                           exe = exe,
                                           avg_cost = avg_cost,
                                           acc=acc)
        print("Test with Epoch %d, avg_cost: %s, acc: %s" % (epoch_id, avg_loss_val, acc_val))
        # event_handler_plot(test_prompt, step, metrics[0])
        lists.append((epoch_id, avg_loss_val, acc_val))

        #保存训练好的模型进行预测
        if save_dirname is not None:
            fluid.io.save_inference_model(
                dirname=save_dirname,
                feeded_var_names=['img'],
                target_vars = [predict],
                executor = exe,
            )


def inference(save_dirname,im):
    place = fluid.CPUPlace()
    exe = fluid.Executor(place)
    inference_scope = fluid.core.Scope()
    with fluid.scope_guard(inference_scope):
        """
        使用 fluid.io.load_inference_model 获取 inference program desc,
        feed_target_names 用于指定需要传入网络的变量名
        fetch_targets 指定希望从网络中fetch出的变量名
        """

        [inference_program, feed_target_names,
         fetch_targets] = fluid.io.load_inference_model(
            save_dirname, exe, None, None)
        # 将feed构建成字典 {feed_target_name: feed_target_data}
        # 结果将包含一个与fetch_targets对应的数据列表
        print("feed_target_names:",feed_target_names)
        results = exe.run(
            program = inference_program,
            feed = {feed_target_names[0]:im},
            fetch_list = fetch_targets
        )

        print("results:",results)
        lab = np.argsort(results)
        print("lab = ",lab)


        return lab







def load_test_image(file):
    """读取自己手写数字的图片"""
    im = Image.open(file).convert('L')
    im = im.resize((28, 28), Image.ANTIALIAS)
    im = np.array(im).reshape(1, 1, 28, 28).astype(np.float32)
    im = im / 255.0 * 2.0 - 1.0
    return im



if __name__ == '__main__':
    save_dirname = r"result_train\recognize_digits.inference.model"
    #训练模型，储存model
    # main(save_dirname)

    #读取自己手写的数字图片
    file_im = r'traindata\image_cecognition\infer_8.png'
    im = load_test_image(file_im)

    # 对手写图片进行预测
    lab = inference(save_dirname,im)

    print("Inference result of image/infer_{}.png is: {}".format(file_im[-11:],lab[0][0][0]) ) #这里原文是[0][0][-1]是错的，选出来交叉熵最大的数，应该用[0][0][0]选交叉熵最小的数是预测结构。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294