PaddlePaddle-百度深度学习入门教程

百度深度学习 PaddlePaddle

此前在百度举办的深度学习开发者峰会上,百度深度学习平台 PaddlePaddle 首次曝光了其中文名 —— 飞桨,意为快速划动的桨,寓意期望这个平台能够实现快速成长。波波写本篇笔记的目的并不在于做个完整的教程,让大家全部学会,而是能让普通小白能够快速入门,毕竟作为我个人来讲也根本没那么多精力去做这样的课程。好在百度官方也给出了相关文档,初学者很容易入门。

首先我们通过一张全景图看下平台的整体架构。看不清的可以下载下来看。

分布式深度学习平台 PaddlePaddle

通过全景图我们可以看到工具组件包括 PaddleHub 迁移学习、PARL 强化学习、AutoDL Design 自动化网络结构设计,核心框架中的模型库 PaddleNLP、PaddleCV,训练模块中的大规模分布式训练和工业级数据处理,预测模块的 Paddle Serving 和 PaddleSlim。

废话不多说,教大家安装一下吧。这个安装波波选择的是centos环境下的编译安装,为啥选这个呢?因为波波平时开发一些软件的时候习惯用PHP开发,编译安装之后,相关深度学习可以在各个开发语言中公用。比如PHP网站中就可以开发手写字体识别,视频内容检测,包括之前波波做的词性分析等等,当然了大家也可以选择其他方式,无所谓。

1、检查环境:(若需做图像识别请提前安装好OpenCV>>安装教程

  1. uname -m && cat /etc/*release
  2. yum update
  3. yum install -y epel-release

2、安装依赖:

  1. yum install -y bzip2
  2. yum install -y make
  3. yum install python-devel
  4. yum install python-pip

3、编译安装:

  1. git clone https://github.com/PaddlePaddle/Paddle.git
  2. cd Paddle
  3. mkdir build && cd build
  4. cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release
  5. cd /paddle/build/python/dist
  6. pip install (whl包的名字)

4、验证成功:

  1. //进入python解释器输入
  2. import paddle.fluid as fluid
  3. fluid.install_check.run_check()

如果出现Your Paddle Fluid is installed succesfully!,说明您已成功安装。

下面我们可以做个简单的数字识别。参考源码:

  1. import os
  2. from PIL import Image
  3. import numpy
  4. import paddle
  5. import paddle.fluid as fluid
  6. BATCH_SIZE = 64
  7. PASS_NUM = 5
  8. def loss_net(hidden, label):
  9.     prediction = fluid.layers.fc(input=hidden, size=10, act='softmax')
  10.     loss = fluid.layers.cross_entropy(input=prediction, label=label)
  11.     avg_loss = fluid.layers.mean(loss)
  12.     acc = fluid.layers.accuracy(input=prediction, label=label)
  13.     return prediction, avg_loss, acc
  14. def multilayer_perceptron(img, label):
  15.     img = fluid.layers.fc(input=img, size=200, act='tanh')
  16.     hidden = fluid.layers.fc(input=img, size=200, act='tanh')
  17.     return loss_net(hidden, label)
  18. def softmax_regression(img, label):
  19.     return loss_net(img, label)
  20. def convolutional_neural_network(img, label):
  21.     conv_pool_1 = fluid.nets.simple_img_conv_pool(
  22.         input=img,
  23.         filter_size=5,
  24.         num_filters=20,
  25.         pool_size=2,
  26.         pool_stride=2,
  27.         act="relu")
  28.     conv_pool_1 = fluid.layers.batch_norm(conv_pool_1)
  29.     conv_pool_2 = fluid.nets.simple_img_conv_pool(
  30.         input=conv_pool_1,
  31.         filter_size=5,
  32.         num_filters=50,
  33.         pool_size=2,
  34.         pool_stride=2,
  35.         act="relu")
  36.     return loss_net(conv_pool_2, label)
  37. def train(nn_type,
  38.           use_cuda,
  39.           save_dirname=None,
  40.           model_filename=None,
  41.           params_filename=None):
  42.     if use_cuda and not fluid.core.is_compiled_with_cuda():
  43.         return
  44.     img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
  45.     label = fluid.layers.data(name='label', shape=[1], dtype='int64')
  46.     if nn_type == 'softmax_regression':
  47.         net_conf = softmax_regression
  48.     elif nn_type == 'multilayer_perceptron':
  49.         net_conf = multilayer_perceptron
  50.     else:
  51.         net_conf = convolutional_neural_network
  52.     prediction, avg_loss, acc = net_conf(img, label)
  53.     test_program = fluid.default_main_program().clone(for_test=True)
  54.     optimizer = fluid.optimizer.Adam(learning_rate=0.001)
  55.     optimizer.minimize(avg_loss)
  56.     def train_test(train_test_program, train_test_feed, train_test_reader):
  57.         acc_set = []
  58.         avg_loss_set = []
  59.         for test_data in train_test_reader():
  60.             acc_np, avg_loss_np = exe.run(
  61.                 program=train_test_program,
  62.                 feed=train_test_feed.feed(test_data),
  63.                 fetch_list=[acc, avg_loss])
  64.             acc_set.append(float(acc_np))
  65.             avg_loss_set.append(float(avg_loss_np))
  66.         # get test acc and loss
  67.         acc_val_mean = numpy.array(acc_set).mean()
  68.         avg_loss_val_mean = numpy.array(avg_loss_set).mean()
  69.         return avg_loss_val_mean, acc_val_mean
  70.     place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
  71.     exe = fluid.Executor(place)
  72.     train_reader = paddle.batch(
  73.         paddle.reader.shuffle(paddle.dataset.mnist.train(), buf_size=500),
  74.         batch_size=BATCH_SIZE)
  75.     test_reader = paddle.batch(
  76.         paddle.dataset.mnist.test(), batch_size=BATCH_SIZE)
  77.     feeder = fluid.DataFeeder(feed_list=[img, label], place=place)
  78.     exe.run(fluid.default_startup_program())
  79.     main_program = fluid.default_main_program()
  80.     epochs = [epoch_id for epoch_id in range(PASS_NUM)]
  81.     lists = []
  82.     step = 0
  83.     for epoch_id in epochs:
  84.         for step_id, data in enumerate(train_reader()):
  85.             metrics = exe.run(
  86.                 main_program,
  87.                 feed=feeder.feed(data),
  88.                 fetch_list=[avg_loss, acc])
  89.             if step % 100 == 0:
  90.                 print("Pass %d, Batch %d, Cost %f" % (step, epoch_id,
  91.                                                       metrics[0]))
  92.             step += 1
  93.         # test for epoch
  94.         avg_loss_val, acc_val = train_test(
  95.             train_test_program=test_program,
  96.             train_test_reader=test_reader,
  97.             train_test_feed=feeder)
  98.         print("Test with Epoch %d, avg_cost: %s, acc: %s" %
  99.               (epoch_id, avg_loss_val, acc_val))
  100.         lists.append((epoch_id, avg_loss_val, acc_val))
  101.         if save_dirname is not None:
  102.             fluid.io.save_inference_model(
  103.                 save_dirname, ["img"], [prediction],
  104.                 exe,
  105.                 model_filename=model_filename,
  106.                 params_filename=params_filename)
  107.     # find the best pass
  108.     best = sorted(lists, key=lambda list: float(list[1]))[0]
  109.     print('Best pass is %s, testing Avgcost is %s' % (best[0], best[1]))
  110.     print('The classification accuracy is %.2f%%' % (float(best[2]) * 100))
  111. def infer(use_cuda,
  112.           save_dirname=None,
  113.           model_filename=None,
  114.           params_filename=None):
  115.     if save_dirname is None:
  116.         return
  117.     place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
  118.     exe = fluid.Executor(place)
  119.     def load_image(file):
  120.         im = Image.open(file).convert('L')
  121.         im = im.resize((28, 28), Image.ANTIALIAS)
  122.         im = numpy.array(im).reshape(1, 1, 28, 28).astype(numpy.float32)
  123.         im = im / 255.0 * 2.0 - 1.0
  124.         return im
  125.     cur_dir = os.path.dirname(os.path.realpath(__file__))
  126.     tensor_img = load_image(cur_dir + '/image/infer_3.png')
  127.     inference_scope = fluid.core.Scope()
  128.     with fluid.scope_guard(inference_scope):
  129.         # Use fluid.io.load_inference_model to obtain the inference program desc,
  130.         # the feed_target_names (the names of variables that will be feeded
  131.         # data using feed operators), and the fetch_targets (variables that
  132.         # we want to obtain data from using fetch operators).
  133.         [inference_program, feed_target_names,
  134.          fetch_targets] = fluid.io.load_inference_model(
  135.              save_dirname, exe, model_filename, params_filename)
  136.         # Construct feed as a dictionary of {feed_target_name: feed_target_data}
  137.         # and results will contain a list of data corresponding to fetch_targets.
  138.         results = exe.run(
  139.             inference_program,
  140.             feed={feed_target_names[0]: tensor_img},
  141.             fetch_list=fetch_targets)
  142.         lab = numpy.argsort(results)
  143.         print("Inference result of image/infer_3.png is: %d" % lab[0][0][-1])
  144. def main(use_cuda, nn_type):
  145.     model_filename = None
  146.     params_filename = None
  147.     save_dirname = "recognize_digits_" + nn_type + ".inference.model"
  148.     # call train() with is_local argument to run distributed train
  149.     train(
  150.         nn_type=nn_type,
  151.         use_cuda=use_cuda,
  152.         save_dirname=save_dirname,
  153.         model_filename=model_filename,
  154.         params_filename=params_filename)
  155.     infer(
  156.         use_cuda=use_cuda,
  157.         save_dirname=save_dirname,
  158.         model_filename=model_filename,
  159.         params_filename=params_filename)
  160. if __name__ == '__main__':
  161.     use_cuda = False
  162.     # predict = 'softmax_regression' # uncomment for Softmax
  163.     # predict = 'multilayer_perceptron' # uncomment for MLP
  164.     predict = 'convolutional_neural_network'  # uncomment for LeNet5
  165.     main(use_cuda=use_cuda, nn_type=predict)

今天的笔记就先分享这么多,以后有空的时间再说,同时大家也可以参考官方开发文档:http://paddlepaddle.org/documentation/docs/zh/1.4/beginners_guide/basics/recognize_digits/README.cn.html

 

波波

发表评论

您必须 登录 才能发表留言!