paddle(二)

一、优化器

1.SGD/SGDOptimizer
SGD 是实现 随机梯度下降 的一个 Optimizer 子类，是 梯度下降 大类中的一种方法。 当需要训练大量样本的时候，往往选择 SGD 来使损失函数更快的收敛。

2.Momentum/MomentumOptimizer

Momentum 优化器在 SGD 基础上引入动量，减少了随机梯度下降过程中存在的噪声问题。

3. Adagrad/AdagradOptimizer
Adagrad 优化器可以针对不同参数样本数不平均的问题，自适应地为各个参数分配不同的学习率。4.RMSPropOptimizer

RMSProp优化器 ，是一种自适应调整学习率的方法， 主要解决使用Adagrad后，模型训练中后期学习率急剧下降的问题。

5.Adam/AdamOptimizer
Adam 的优化器是一种自适应调整学习率的方法， 适用于大多非 凸优化 、大数据集和高维空间的场景。在实际应用中，Adam 是最为常用的一种优化方法。

6.Adamax/AdamaxOptimizer
Adamax 是 Adam 算法的一个变体，对学习率的上限提供了一个更简单的范围，使学习率的边界范围更简单。

7.DecayedAdagrad/ DecayedAdagradOptimizer
DecayedAdagrad 优化器，可以看做是引入了衰减速率的 Adagrad 算法，解决使用Adagrad后，模型训练中后期学习率急剧下降的问题。

8. Ftrl/FtrlOptimizer
FtrlOptimizer 优化器结合了 FOBOS算法 的高精度与 RDA算法 的稀疏性，是目前效果非常好的一种 Online Learning 算法。

9.ModelAverage
ModelAverage 优化器，在训练中通过窗口来累计历史 parameter，在预测时使用取平均值后的paramet，整体提高预测的精度。

 

二、反向传播

fluid.layers.fc 全连接层

fluid.backward.append_backward 反向传播，一般用户无需手动调用。

fluid.backward.gradients 将反向传播的梯度传到输入

import paddle.fluid as fluid

x = fluid.data(name='x', shape=[None,2,8,8], dtype='float32')
x.stop_gradient=False
y = fluid.layers.conv2d(x, 4, 1, bias_attr=False)
y = fluid.layers.relu(y)
y = fluid.layers.conv2d(y, 4, 1, bias_attr=False)
y = fluid.layers.relu(y)
z = fluid.gradients([y], x)
print(z)

三、结果评估

fluid.metrics.Precision 精确度，用来衡量二分类中召回真值和召回值的比例。

import paddle.fluid as fluid
import numpy as np

metric = fluid.metrics.Precision()

# 生成预测值和标签

preds = [[0.1], [0.7], [0.8], [0.9], [0.2],
         [0.2], [0.3], [0.5], [0.8], [0.6]]

labels = [[0], [1], [1], [1], [1],
          [0], [0], [0], [0], [0]]

preds = np.array(preds)
labels = np.array(labels)

metric.update(preds=preds, labels=labels)
precision = metric.eval()

print("expected precision: %.2f and got %.2f" % ( 3.0 / 5.0, precision))

正确率: Accuracy ，用来衡量二分类中召回真值和总样本数的比例。需要注意的是，准确率和正确率的定义是不同的，可以类比于误差分析中的 Variance 和 Bias 。

import paddle.fluid as fluid
# 假设有batch_size = 128
batch_size=128
accuracy_manager = fluid.metrics.Accuracy()
# 假设第一个batch的准确率为0.9
batch1_acc = 0.9
accuracy_manager.update(value = batch1_acc, weight = batch_size)
print("expect accuracy: %.2f, get accuracy: %.2f" % (batch1_acc, accuracy_manager.eval()))
# 假设第二个batch的准确率为0.8
batch2_acc = 0.8
accuracy_manager.update(value = batch2_acc, weight = batch_size)
#batch1和batch2的联合准确率为(batch1_acc * batch_size + batch2_acc * batch_size) / batch_size / 2
print("expect accuracy: %.2f, get accuracy: %.2f" % ((batch1_acc * batch_size + batch2_acc * batch_size) / batch_size / 2, accuracy_manager.eval()))
#重置accuracy_manager
accuracy_manager.reset()
#假设第三个batch的准确率为0.8
batch3_acc = 0.8
accuracy_manager.update(value = batch3_acc, weight = batch_size)
print("expect accuracy: %.2f, get accuracy: %.2f" % (batch3_acc, accuracy_manager.eval()))

召回率: Recall ，用来衡量二分类中召回值和总样本数的比例。准确率和召回率的选取相互制约，实际模型中需要进行权衡

AUC: Area Under Curve， 适用于二分类的分类模型评估，用来计算 ROC曲线的累积面积。Auc 通过python计算实现，如果关注性能，可以使用 fluid.layers.auc 代替。

平均准确度: Average Precision ，常用在Faster R-CNN和SSD等物体检测任务中。在不同召回条件下，计算了准确率的平均值。

四、模型的保存与加载

模型的保存与加载主要涉及到如下八个API： 

fluid.io.save_vars、fluid.io.save_params、fluid.io.save_persistables、fluid.io.save_inference_model、

fluid.io.load_vars、fluid.io.load_params、fluid.io.load_persistables 和 fluid.io.load_inference_model。

save_inference_model ，load_inference_model

import paddle.fluid as fluid
main_prog = fluid.Program()
startup_prog = fluid.Program()
with fluid.program_guard(main_prog, startup_prog):
    data = fluid.layers.data(name="img", shape=[64, 784], append_batch_size=False)
    w = fluid.layers.create_parameter(shape=[784, 200], dtype='float32', name='fc_w')
    b = fluid.layers.create_parameter(shape=[200], dtype='float32', name='fc_b')
    hidden_w = fluid.layers.matmul(x=data, y=w)
    hidden_b = fluid.layers.elementwise_add(hidden_w, b)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(startup_prog)

# 示例一：用vars来指定加载变量。
path = "./my_paddle_vars"
var_list = [w, b]
fluid.io.save_vars(executor=exe, dirname=path, vars=var_list,
                   filename="vars_file")
fluid.io.load_vars(executor=exe, dirname=path, vars=var_list,
                   filename="vars_file")
# 加载w和b。它们被保存在'var_file'的文件中，所在路径为 "./my_paddle_model" 。

# 示例二：通过predicate来筛选加载变量。
def name_has_fc(var):
    res = "fc" in var.name
    return res

param_path = "./my_paddle_model"
fluid.io.save_vars(executor=exe, dirname=param_path, main_program=main_prog, vars=None, predicate=name_has_fc)
fluid.io.load_vars(executor=exe, dirname=param_path, main_program=main_prog, vars=None, predicate=name_has_fc)

exe = fluid.Executor(fluid.CPUPlace())
path = "./infer_model"
fluid.io.save_inference_model(dirname=path, feeded_var_names=['img'],
    target_vars=[predict_var], executor=exe)

exe = fluid.Executor(fluid.CPUPlace())
path = "./infer_model"
[inference_program, feed_target_names, fetch_targets] =
    fluid.io.load_inference_model(dirname=path, executor=exe)
results = exe.run(inference_program,
              feed={feed_target_names[0]: tensor_img},
              fetch_list=fetch_targets)

五、执行引擎

Executor:支持单GPU、多GPU以及CPU运行。在Executor构造时，需要传入设备。参数:place (fluid.CPUPlace()|fluid.CUDAPlace(N))

ParallelExecutor 是以数据并行的方式在多个节点上分别执行 Program 的执行器。用户可以通过Python脚本驱动 ParallelExecutor 执行

分布式

同步

config = fluid.DistributeTranspilerConfig()
# 配置策略config
config.slice_var_up = False
t = fluid.DistributeTranspiler(config=config)
t.transpile(trainer_id,
            program=main_program,
            pservers="192.168.0.1:6174,192.168.0.2:6174",
            trainers=1,
            sync_mode=True)

 异步

config = fluid.DistributeTranspilerConfig()
# 配置策略config
config.slice_var_up = False
t = fluid.DistributeTranspiler(config=config)
t.transpile(trainer_id,
            program=main_program,
            pservers="192.168.0.1:6174,192.168.0.2:6174",
            trainers=1,
            sync_mode=False)