安装

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple paddlepaddle==1.6.3

快速上手

导入paddle的fluid包，设置全局变量

$ python
>>> import paddle.fluid as fluid    # 导入
>>> place = fluid.CPUPlace()   # 定义CPU环境
>>> exe = fluid.Executor(place)   # 创建执行器

创建tensor

>>> tensor = fluid.layers.ones(shape=[5], dtype='int64')  # 定义Tensor向量
>>> tensor
name: "fill_constant_0.tmp_0"
type {
  type: LOD_TENSOR
  lod_tensor {
    tensor {
      data_type: INT64
      dims: 5
    }
  }
}
persistable: false

>>> data = exe.run(fluid.default_main_program(), fetch_list=[data])  # 执行器run一下就可以取出数据
>>> data
[array([1, 1, 1, 1, 1], dtype=int64)]
>>> type(data)
<class 'list'>
>>> type(data[0])   # 默认是numpy数据
<class 'numpy.ndarray'>

tensor相加（按位）

>>> tensor1 = fluid.layers.ones([5], 'int64')
>>> tensor2 = fluid.layers.ones([5], 'int64')
>>> sum = fluid.layers.elementwise_add(tensor1, tensor2)
>>> result = exe.run(fluid.default_main_program(), fetch_list=[sum])
>>> result
[array([2, 2, 2, 2, 2], dtype=int64)]

tensor转换数据类型

>>> tensor = fluid.layers.ones([5], 'int64')
>>> f_tensor = fluid.layers.cast(tensor, 'float64')  # 转换数据类型
>>> tensor
name: "fill_constant_0.tmp_0"
type {
  type: LOD_TENSOR
  lod_tensor {
    tensor {
      data_type: INT64
      dims: 5
    }
  }
}
persistable: false

>>> f_tensor
name: "cast_0.tmp_0"
type {
  type: LOD_TENSOR
  lod_tensor {
    tensor {
      data_type: FP64
      dims: 5
    }
    lod_level: 0
  }
}
persistable: false

>>> exe.run(fluid.default_main_program(), fetch_list=[tensor, f_tensor])
[array([1, 1, 1, 1, 1], dtype=int64), array([1., 1., 1., 1., 1.])]

常用OP

op：operator操作算子，比如上一节中的cast，ones都算。
paddle常用的op很多都在fluid.layers里

fluid.layers.data：定义tensor变量
fluid.layers.square_error_cost：求两个batch数据的平方差
fluid.layers.mean：求batch的均值
fluid.optimizer.SGD：优化器，类似的还有Adam等

更常见的接口见：TensorFlow-Fluid常用接口对应表

短小精悍的程序来展示paddle如何完成一次训练，拟合四元一次方程的值。

# coding: utf-8
#加载库
import paddle.fluid as fluid
import numpy as np

#生成数据
np.random.seed(0) # 固定随机种子，方便复现
outputs = np.random.randint(low=0, high=5, size=(10, 4))  # 10个 a, b, c, d 参数
res = []
for i in range(10):
    # 假设方程式为 y = 4a + 6b + 7c + 2d
    y = 4*outputs[i][0] + 6*outputs[i][1] + 7*outputs[i][2] + 2*outputs[i][3]
    res.append([y])

# 定义数据 输入数据和label
train_data=np.array(outputs).astype('float32')
y_true = np.array(res).astype('float32')

#定义网络
x = fluid.layers.data(name="x",shape=[4],dtype='float32') # x 变量
y = fluid.layers.data(name="y",shape=[1],dtype='float32') # y 变量
y_predict = fluid.layers.fc(input=x,size=1,act=None)

#定义损失函数
cost = fluid.layers.square_error_cost(input=y_predict,label=y)
avg_cost = fluid.layers.mean(cost)

#定义优化方法
sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.05)
sgd_optimizer.minimize(avg_cost)

#参数初始化
cpu = fluid.CPUPlace()
exe = fluid.Executor(cpu)
exe.run(fluid.default_startup_program())

##############################################
#开始训练，迭代500次
for i in range(500):
    outs = exe.run(feed={'x':train_data,'y':y_true},
                   fetch_list=[y_predict.name,avg_cost.name])
    if i%50==0:
        print ('iter={:.0f}, cost={}'.format(i,outs[1][0]))
#存储训练结果
params_dirname = "result"
fluid.io.save_inference_model(dirname=params_dirname, 
                              feeded_var_names=['x'],  # 需要输入的变量名称
                              target_vars=[y_predict], 
                              executor=exe)

##############################################
# 开始预测
infer_exe = fluid.Executor(cpu)
inference_scope = fluid.Scope()
# 加载训练好的模型
with fluid.scope_guard(inference_scope):
    [inference_program, feed_target_names, fetch_targets] = \
        fluid.io.load_inference_model(dirname=params_dirname, 
                                      executor=infer_exe)
print("feed_target_names: {}".format(feed_target_names)) # 打印输入变量的名称

# 生成测试数据
test = np.array([[[9],[5],[2],[10]]]).astype('float32')
# 进行预测
results = infer_exe.run(inference_program,
                        feed={"x": test},
                        fetch_list=fetch_targets)
# 给出题目为 【9,5,2,10】 输出y=4*9+6*5+7*2+10*2的值
print ("inference: 9a + 5b + 2c + 10d = {}".format(results[0][0]))

运行程序，自动完成（1）生成数据（2）定义网络（3）训练保存（4）加载预测的流程。

$ python start.py
iter=0, cost=1305.5911865234375
iter=50, cost=0.13385649025440216
iter=100, cost=0.05532369762659073
iter=150, cost=0.022923115640878677
iter=200, cost=0.009497975930571556
iter=250, cost=0.003935434389859438
iter=300, cost=0.0016306063625961542
iter=350, cost=0.0006756152724847198
iter=400, cost=0.00027995515847578645
iter=450, cost=0.00011598169658100232
feed_target_names: ['x']
inference: 9a + 5b + 2c + 10d = [99.94348]

$ ls
result   start.py

$ ls result
__model__ fc_0.b_0  fc_0.w_0