• 快速开始
    • 快速安装
    • 快速使用
    • 运行线性回归模型

    快速开始

    快速安装

    PaddlePaddle支持使用pip快速安装， 执行下面的命令完成CPU版本的快速安装：

    1. pip install -U paddlepaddle

    如需安装GPU版本的PaddlePaddle，执行下面的命令完成GPU版本的快速安装:

    1. pip install -U paddlepaddle-gpu

    同时请保证您参考NVIDIA官网，已经正确配置和安装了显卡驱动，CUDA 9 ，cuDNN 7.3 ，NCCL2 等依赖，其他更加详细的安装信息请参考：安装说明

    快速使用

    首先，您需要导入fluid库

    1. import paddle.fluid as fluid
    • Tensor操作下面几个简单的案例，可以帮助您快速了解Fluid：

    1.使用Fluid创建5个元素的一维数组，其中每个元素都为1

    1. # 定义数组维度及数据类型，可以修改shape参数定义任意大小的数组
    2. data = fluid.layers.ones(shape=[5], dtype='int64')
    3. # 在CPU上执行运算
    4. place = fluid.CPUPlace()
    5. # 创建执行器
    6. exe = fluid.Executor(place)
    7. # 执行计算
    8. ones_result = exe.run(fluid.default_main_program(),
    9.                         # 获取数据data
    10.                         fetch_list=[data],
    11.                         return_numpy=True)
    12. # 输出结果
    13. print(ones_result[0])

    可以得到结果：

    1. [1 1 1 1 1]

    2.使用Fluid将两个数组按位相加

    1. # 调用 elementwise_op 将生成的一维数组按位相加
    2. add = fluid.layers.elementwise_add(data,data)
    3. # 定义运算场所
    4. place = fluid.CPUPlace()
    5. exe = fluid.Executor(place)
    6. # 执行计算
    7. add_result = exe.run(fluid.default_main_program(),
    8.                  fetch_list=[add],
    9.                  return_numpy=True)
    10. # 输出结果
    11. print (add_result[0])

    可以得到结果：

    1. [2 2 2 2 2]

    3.使用Fluid转换数据类型

    1. # 将一维整型数组，转换成float64类型
    2. cast = fluid.layers.cast(x=data, dtype='float64')
    3. # 定义运算场所执行计算
    4. place = fluid.CPUPlace()
    5. exe = fluid.Executor(place)
    6. cast_result = exe.run(fluid.default_main_program(),
    7.                  fetch_list=[cast],
    8.                  return_numpy=True)
    9. # 输出结果
    10. print(cast_result[0])

    可以得到结果：

    1. [1. 1. 1. 1. 1.]

    运行线性回归模型

    通过上面的小例子，相信您已经对如何使用Fluid操作数据有了一定的了解，那么试着创建一个test.py，并粘贴下面的代码吧。

    这是一个简单的线性回归模型，来帮助我们快速求解4元一次方程。

    1. #加载库
    2. import paddle.fluid as fluid
    3. import numpy as np
    4. #生成数据
    5. np.random.seed(0)
    6. outputs = np.random.randint(5, size=(10, 4))
    7. res = []
    8. for i in range(10):
    9.         # 假设方程式为 y=4a+6b+7c+2d
    10.         y = 4*outputs[i][0]+6*outputs[i][1]+7*outputs[i][2]+2*outputs[i][3]
    11.         res.append([y])
    12. # 定义数据
    13. train_data=np.array(outputs).astype('float32')
    14. y_true = np.array(res).astype('float32')
    15.  
    16. #定义网络
    17. x = fluid.layers.data(name="x",shape=[4],dtype='float32')
    18. y = fluid.layers.data(name="y",shape=[1],dtype='float32')
    19. y_predict = fluid.layers.fc(input=x,size=1,act=None)
    20. #定义损失函数
    21. cost = fluid.layers.square_error_cost(input=y_predict,label=y)
    22. avg_cost = fluid.layers.mean(cost)
    23. #定义优化方法
    24. sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.05)
    25. sgd_optimizer.minimize(avg_cost)
    26. #参数初始化
    27. cpu = fluid.CPUPlace()
    28. exe = fluid.Executor(cpu)
    29. exe.run(fluid.default_startup_program())
    30. ##开始训练，迭代500次
    31. for i in range(500):
    32.         outs = exe.run(
    33.                 feed={'x':train_data,'y':y_true},
    34.                 fetch_list=[y_predict.name,avg_cost.name])
    35.         if i%50==0:
    36.                 print ('iter={:.0f},cost={}'.format(i,outs[1][0]))
    37. #存储训练结果
    38. params_dirname = "result"
    39. fluid.io.save_inference_model(params_dirname, ['x'], [y_predict], exe)
    40.  
    41. # 开始预测
    42. infer_exe = fluid.Executor(cpu)
    43. inference_scope = fluid.Scope()
    44. # 加载训练好的模型
    45. with fluid.scope_guard(inference_scope):
    46.         [inference_program, feed_target_names,
    47.          fetch_targets] = fluid.io.load_inference_model(params_dirname, infer_exe)
    48.  
    49. # 生成测试数据
    50. test = np.array([[[9],[5],[2],[10]]]).astype('float32')
    51. # 进行预测
    52. results = infer_exe.run(inference_program,
    53.                                                 feed={"x": test},
    54.                                                 fetch_list=fetch_targets)
    55. # 给出题目为 【9,5,2,10】 输出y=4*9+6*5+7*2+10*2的值
    56. print ("9a+5b+2c+10d={}".format(results[0][0]))
    1. 得到结果：
    2.  
    3.     9a+5b+2c+10d=[99.946]

    输出结果应是一个近似等于100的值，每次计算结果略有不同。