- CPU版本安装
pip install paddlepaddle
- GPU版本安装
pip install paddlepaddle-gpu
导入数据---->定义网络结构---->训练模型---->保存模型---->测试结果
- #coding:utf-8
- import os
- from PIL import Image
- import numpy as np
- import paddle.v2 as paddle
- # 设置是否用gpu,0为否,1为是
- with_gpu = os.getenv('WITH_GPU', '0') != '1'
- # 定义网络结构
- def convolutional_neural_network_org(img):
- # 第一层卷积层
- conv_pool_1 = paddle.networks.simple_img_conv_pool(
- input=img,
- filter_size=5,
- num_filters=20,
- num_channel=1,
- pool_size=2,
- pool_stride=2,
- act=paddle.activation.Relu())
- # 第二层卷积层
- conv_pool_2 = paddle.networks.simple_img_conv_pool(
- input=conv_pool_1,
- filter_size=5,
- num_filters=50,
- num_channel=20,
- pool_size=2,
- pool_stride=2,
- act=paddle.activation.Relu())
- # 全连接层
- predict = paddle.layer.fc(
- input=conv_pool_2, size=10, act=paddle.activation.Softmax())
- return predict
- def main():
- # 初始化定义跑模型的设备
- paddle.init(use_gpu=with_gpu, trainer_count=1)
- # 读取数据
- images = paddle.layer.data(
- name='pixel', type=paddle.data_type.dense_vector(784))
- label = paddle.layer.data(
- name='label', type=paddle.data_type.integer_value(10))
- # 调用之前定义的网络结构
- predict = convolutional_neural_network(images)
- # 定义损失函数
- cost = paddle.layer.classification_cost(input=predict, label=label)
- # 指定训练相关的参数
- parameters = paddle.parameters.create(cost)
- # 定义训练方法
- optimizer = paddle.optimizer.Momentum(
- learning_rate=0.1 / 128.0,
- momentum=0.9,
- regularization=paddle.optimizer.L2Regularization(rate=0.0005 * 128))
- # 训练模型
- trainer = paddle.trainer.SGD(
- cost=cost, parameters=parameters, update_equation=optimizer)
- lists = []
- # 定义event_handler,输出训练过程中的结果
- def event_handler(event):
- if isinstance(event, paddle.event.EndIteration):
- if event.batch_id % 100 == 0:
- print "Pass %d, Batch %d, Cost %f, %s" % (
- event.pass_id, event.batch_id, event.cost, event.metrics)
- if isinstance(event, paddle.event.EndPass):
- # 保存参数
- with open('params_pass_%d.tar' % event.pass_id, 'w') as f:
- parameters.to_tar(f)
- result = trainer.test(reader=paddle.batch(
- paddle.dataset.mnist.test(), batch_size=128))
- print "Test with Pass %d, Cost %f, %s\n" % (
- event.pass_id, result.cost, result.metrics)
- lists.append((event.pass_id, result.cost,
- result.metrics['classification_error_evaluator']))
- trainer.train(
- reader=paddle.batch(
- paddle.reader.shuffle(paddle.dataset.mnist.train(), buf_size=8192),
- batch_size=128),
- event_handler=event_handler,
- num_passes=10)
- # 找到训练误差最小的一次结果
- best = sorted(lists, key=lambda list: float(list[1]))[0]
- print 'Best pass is %s, testing Avgcost is %s' % (best[0], best[1])
- print 'The classification accuracy is %.2f%%' % (100 - float(best[2]) * 100)
- # 加载数据
- def load_image(file):
- im = Image.open(file).convert('L')
- im = im.resize((28, 28), Image.ANTIALIAS)
- im = np.array(im).astype(np.float32).flatten()
- im = im / 255.0
- return im
- # 测试结果
- test_data = []
- cur_dir = os.path.dirname(os.path.realpath(__file__))
- test_data.append((load_image(cur_dir + '/image/infer_3.png'), ))
- probs = paddle.infer(
- output_layer=predict, parameters=parameters, input=test_data)
- lab = np.argsort(-probs) # probs and lab are the results of one batch data
- print "Label of image/infer_3.png is: %d" % lab[0][0]
- if __name__ == '__main__':
- main()
- def convolutional_neural_network_org(img):
- # 第一层卷积层
- conv_pool_1 = paddle.networks.simple_img_conv_pool(
- input=img,
- filter_size=5,
- num_filters=20,
- num_channel=1,
- pool_size=2,
- pool_stride=2,
- act=paddle.activation.Relu())
- # 第二层卷积层
- conv_pool_2 = paddle.networks.simple_img_conv_pool(
- input=conv_pool_1,
- filter_size=5,
- num_filters=50,
- num_channel=20,
- pool_size=2,
- pool_stride=2,
- act=paddle.activation.Relu())
- # 全连接层
- predict = paddle.layer.fc(
- input=conv_pool_2, size=10, act=paddle.activation.Softmax())
- return predict
输出结果如下:
- I1023 13:45:46.519075 34144 Util.cpp:166] commandline: --use_gpu=True --trainer_count=1
- [INFO 2017-10-23 13:45:52,667 layers.py:2539] output for __conv_pool_0___conv: c = 20, h = 24, w = 24, size = 11520
- [INFO 2017-10-23 13:45:52,667 layers.py:2667] output for __conv_pool_0___pool: c = 20, h = 12, w = 12, size = 2880
- [INFO 2017-10-23 13:45:52,668 layers.py:2539] output for __conv_pool_1___conv: c = 50, h = 8, w = 8, size = 3200
- [INFO 2017-10-23 13:45:52,669 layers.py:2667] output for __conv_pool_1___pool: c = 50, h = 4, w = 4, size = 800
- I1023 13:45:52.675750 34144 GradientMachine.cpp:85] Initing parameters..
- I1023 13:45:52.686153 34144 GradientMachine.cpp:92] Init parameters done.
- Pass 0, Batch 0, Cost 3.048408, {'classification_error_evaluator': 0.890625}
- Pass 0, Batch 100, Cost 0.188828, {'classification_error_evaluator': 0.0546875}
- Pass 0, Batch 200, Cost 0.075183, {'classification_error_evaluator': 0.015625}
- Pass 0, Batch 300, Cost 0.070798, {'classification_error_evaluator': 0.015625}
- Pass 0, Batch 400, Cost 0.079673, {'classification_error_evaluator': 0.046875}
- Test with Pass 0, Cost 0.074587, {'classification_error_evaluator': 0.023800000548362732}
- ```
- ```
- ```
- Pass 4, Batch 0, Cost 0.032454, {'classification_error_evaluator': 0.015625}
- Pass 4, Batch 100, Cost 0.021028, {'classification_error_evaluator': 0.0078125}
- Pass 4, Batch 200, Cost 0.020458, {'classification_error_evaluator': 0.0}
- Pass 4, Batch 300, Cost 0.046728, {'classification_error_evaluator': 0.015625}
- Pass 4, Batch 400, Cost 0.030264, {'classification_error_evaluator': 0.015625}
- Test with Pass 4, Cost 0.035841, {'classification_error_evaluator': 0.01209999993443489}
- Best pass is 4, testing Avgcost is 0.0358410408473
- The classification accuracy is 98.79%
- Label of image/infer_3.png is: 3
- real 0m31.565s
- user 0m20.996s
- sys 0m15.891s
可以看到,第一行输出选择的设备是否是gpu,这里我选择的是gpu,所以等于1,如果是cpu,就是0。接下来四行输出的是网络结构,然后开始输出训练结果,训练结束,我们把这几次迭代中误差最小的结果输出来,98.79%,效果还是很不错的,毕竟只迭代了5次。最后看一下输出时间,非常快,约31秒。然而这个结果我并不是特别满意,因为之前用keras做的时候调整的网络模型训练往后准确率能够达到99.72%,所以我觉得还是可以改进一下的,所以我对这个网络结构改进了一下,请看改进版
-----------------------------------------------------------------------------------
- def convolutional_neural_network(img):
- # 第一层卷积层
- conv_pool_1 = paddle.networks.simple_img_conv_pool(
- input=img,
- filter_size=5,
- num_filters=20,
- num_channel=1,
- pool_size=2,
- pool_stride=2,
- act=paddle.activation.Relu())
- # 加一层dropout层
- drop_1 = paddle.layer.dropout(input=conv_pool_1, dropout_rate=0.2)
- # 第二层卷积层
- conv_pool_2 = paddle.networks.simple_img_conv_pool(
- input=drop_1,
- filter_size=5,
- num_filters=50,
- num_channel=20,
- pool_size=2,
- pool_stride=2,
- act=paddle.activation.Relu())
- # 加一层dropout层
- drop_2 = paddle.layer.dropout(input=conv_pool_2, dropout_rate=0.5)
- # 全连接层
- fc1 = paddle.layer.fc(input=drop_2, size=10, act=paddle.activation.Softmax())
- bn = paddle.layer.batch_norm(input=fc1,act=paddle.activation.Relu(),
- layer_attr=paddle.attr.Extra(drop_rate=0.2))
- predict = paddle.layer.fc(input=bn, size=10, act=paddle.activation.Softmax())
- return predict
- I1023 14:01:51.653827 34244 Util.cpp:166] commandline: --use_gpu=True --trainer_count=1
- [INFO 2017-10-23 14:01:57,830 layers.py:2539] output for __conv_pool_0___conv: c = 20, h = 24, w = 24, size = 11520
- [INFO 2017-10-23 14:01:57,831 layers.py:2667] output for __conv_pool_0___pool: c = 20, h = 12, w = 12, size = 2880
- [INFO 2017-10-23 14:01:57,832 layers.py:2539] output for __conv_pool_1___conv: c = 50, h = 8, w = 8, size = 3200
- [INFO 2017-10-23 14:01:57,833 layers.py:2667] output for __conv_pool_1___pool: c = 50, h = 4, w = 4, size = 800
- I1023 14:01:57.842871 34244 GradientMachine.cpp:85] Initing parameters..
- I1023 14:01:57.854014 34244 GradientMachine.cpp:92] Init parameters done.
- Pass 0, Batch 0, Cost 2.536199, {'classification_error_evaluator': 0.875}
- Pass 0, Batch 100, Cost 1.668236, {'classification_error_evaluator': 0.515625}
- Pass 0, Batch 200, Cost 1.024846, {'classification_error_evaluator': 0.375}
- Pass 0, Batch 300, Cost 1.086315, {'classification_error_evaluator': 0.46875}
- Pass 0, Batch 400, Cost 0.767804, {'classification_error_evaluator': 0.25}
- Pass 0, Batch 500, Cost 0.545784, {'classification_error_evaluator': 0.1875}
- Pass 0, Batch 600, Cost 0.731662, {'classification_error_evaluator': 0.328125}
- ```
- ```
- ```
- Pass 49, Batch 0, Cost 0.415184, {'classification_error_evaluator': 0.09375}
- Pass 49, Batch 100, Cost 0.067616, {'classification_error_evaluator': 0.0}
- Pass 49, Batch 200, Cost 0.161415, {'classification_error_evaluator': 0.046875}
- Pass 49, Batch 300, Cost 0.202667, {'classification_error_evaluator': 0.046875}
- Pass 49, Batch 400, Cost 0.336043, {'classification_error_evaluator': 0.140625}
- Pass 49, Batch 500, Cost 0.290948, {'classification_error_evaluator': 0.125}
- Pass 49, Batch 600, Cost 0.223433, {'classification_error_evaluator': 0.109375}
- Pass 49, Batch 700, Cost 0.217345, {'classification_error_evaluator': 0.0625}
- Pass 49, Batch 800, Cost 0.163140, {'classification_error_evaluator': 0.046875}
- Pass 49, Batch 900, Cost 0.203645, {'classification_error_evaluator': 0.078125}
- Test with Pass 49, Cost 0.033639, {'classification_error_evaluator': 0.008100000210106373}
- Best pass is 48, testing Avgcost is 0.0313018567383
- The classification accuracy is 99.28%
- Label of image/infer_3.png is: 3
- real 5m3.151s
- user 4m0.052s
- sys 1m8.084s
来源: http://www.cnblogs.com/charlotte77/p/7712856.html