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

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

 

你想把广告放到这里吗？

发表评论

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