开发 C++ 算子¶

3.1 算子 Yaml 文件配置¶

在 paddle/phi/api/yaml/ops.yaml 和 paddle/phi/api/yaml/backward.yaml 文件中对算子进行描述及定义，在框架编译时会根据 YAML 文件中的配置自动生成 C++ 端的相关代码接口以及内部实现（详见下文 8.1 Paddle 基于 Yaml 配置自动生成算子代码的逻辑解读 小节的介绍），下面主要以 paddle.trace 为例介绍算子的 Yaml 配置规则：

paddle/phi/api/yaml/ops.yaml 中 trace 相关配置：

- op : trace
  args : (Tensor x, int offset = 0, int axis1 = 0, int axis2 = 1)
  output : Tensor(out)
  infer_meta :
    func : TraceInferMeta
  kernel :
    func : trace
  backward : trace_grad

paddle/phi/api/yaml/backward.yaml 中 trace 相关配置：

- backward_op : trace_grad
  forward : trace (Tensor x, int offset, int axis1, int axis2) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, int offset, int axis1, int axis2)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : trace_grad
    data_type : x
  no_need_buffer : x

ops.yaml 和 backward.yaml 分别对算子的前向和反向进行配置，首先 ops.yaml 中前向算子的配置规则如下：

3.2 实现 InferMeta 函数¶

InferMeta 函数是根据输入参数，推断算子输出 Tensor 基本信息的函数，推断的信息包括输出 Tensor 的 shape、data type，同时它也承担了检查输入数据维度、类型等是否合法的功能。

说明：InferMeta 与 kernel 共同组成了一个算子的运算过程。InferMeta 在 kernel 前执行，用于维度、数据类型等信息的计算处理，这些信息在没有具体数据时依然可以通过输入参数完成输出结果的信息推导（例如两个维度为 2x3 的张量相加，输出结果的维度也一定是 2x3），可以利用这些信息优化训练过程中资源的分配和使用，kernel 中也不再需要专门推导这些信息。kernel 则用于具体数据的逻辑计算，为 InferMeta 函数推导得到的张量填充具体的结果值。

trace 算子的 InferMeta 函数 实现如下：

void TraceInferMeta(
    const MetaTensor& x, int offset, int axis1, int axis2, MetaTensor* out) {
  int dim1 = axis1;
  int dim2 = axis2;

  auto x_dims = x.dims();

  int dim1_ = dim1 < 0 ? x_dims.size() + dim1 : dim1;
  int dim2_ = dim2 < 0 ? x_dims.size() + dim2 : dim2;

  PADDLE_ENFORCE_GE(
      x_dims.size(),
      2,
      phi::errors::OutOfRange(
          "Input's dim is out of range (expected at least 2, but got %ld).",
          x_dims.size()));
  PADDLE_ENFORCE_LT(
      dim1_,
      x_dims.size(),
      phi::errors::OutOfRange(
          "Attr(dim1) is out of range (expected to be in range of [%ld, "
          "%ld], but got %ld).",
          -(x_dims.size()),
          (x_dims.size() - 1),
          dim1));
  PADDLE_ENFORCE_LT(
      dim2_,
      x_dims.size(),
      phi::errors::OutOfRange(
          "Attr(dim2) is out of range (expected to be in range of [%ld, "
          "%ld], but got %ld).",
          -(x_dims.size()),
          (x_dims.size() - 1),
          dim2));
  PADDLE_ENFORCE_NE(
      dim1_,
      dim2_,
      phi::errors::InvalidArgument("The dimensions should not be identical "
                                   "%ld vs %ld.",
                                   dim1,
                                   dim2));

  auto sizes = vectorize(x_dims);
  if (x_dims.size() == 2) {
    sizes.clear();
    sizes.push_back(1);
  } else {
    sizes.erase(sizes.begin() + std::max(dim1_, dim2_));
    sizes.erase(sizes.begin() + std::min(dim1_, dim2_));
  }
  out->set_dims(phi::make_ddim(sizes));
  out->set_dtype(x.dtype());
}

其中，MetaTensor是对底层异构 Tensor 的抽象封装，仅支持对底层 Tensor 的维度、数据类型、布局等属性进行读取和设置，具体方法请参考 meta_tensor.h。

InferMeta 的实现位置

InferMeta 的文件放置规则（paddle/phi/infermeta 目录下，以 Tensor 输入个数为判定标准）：

• nullary.h：没有输入 Tensor 参数的函数

• unary.h：仅有一个输入 Tensor 参数的函数

• binary.h：有两个输入 Tensor 参数的函数

• ternary.h：有三个输入 Tensor 参数的函数

• multiary.h：有三个以上输入 Tensor 或者输入为vector<Tensor>的函数

• backward.h：反向算子的 InferMeta 函数一律在此文件中，不受前序规则限制

InferMeta 的编译时与运行时

在静态图模型中，InferMeta操作在 编译时(compile time)和运行时(run time) 都会被调用，在 compile time 时，由于真实的维度未知，框架内部用 -1 来表示，在 run time 时，用实际的维度表示，因此维度的值在 compile time 和 run time 时可能不一致，如果存在维度的判断和运算操作，InferMeta 就需要区分 compile time 和 run time。

对于此类 InferMeta 函数，需要在 InferMeta 函数声明的参数列表末尾增加 MetaConfig 参数，例如：

void ConcatInferMeta(const std::vector<MetaTensor*>& x,
                     const Scalar& axis_scalar,
                     MetaTensor* out,
                     MetaConfig config = MetaConfig());

然后在函数体中，使用 config.is_runtime 判断处于编译时还是运行时。

具体地，以下两种情况（检查、运算）需要区分 compile time 和 run time。

• 检查：

如以下代码：

int i = xxx;
PADDLE_ENFORCE_GT(x.dims()[i] , 10)

在 compile time 的时候，x.dims()[i] 可能等于 -1，导致这个 PADDLE_ENFORCE_GT 报错退出。

如果用了以下 paddle 中定义的宏进行判断，都需要注意区分 compile time 和 run time。

PADDLE_ENFORCE_EQ (x.dims()[i] , 10)
PADDLE_ENFORCE_NE (x.dims()[i] , 10)
PADDLE_ENFORCE_GT (x.dims()[i] , 10)
PADDLE_ENFORCE_GE (x.dims()[i] , 10)
PADDLE_ENFORCE_LT (x.dims()[i] , 10)
PADDLE_ENFORCE_LE (x.dims()[i] , 10)

• 运算：

如以下代码:

auto x_dim = x.dims();
int i = xxx;
y_dim[0] = x_dim[i] + 10

在 compile time 的时候，x_dim[i] 可能等于 -1，得到的 y_dim[0] 等于 9，是不符合逻辑的。

如果用到了类似以下的运算操作，都需要区分 compile time 和 run time：

y_dim[i] = x_dim[i] + 10
y_dim[i] = x_dim[i] - 10
y_dim[i] = x_dim[i] * 10
y_dim[i] = x_dim[i] / 10
y_dim[i] = x_dim[i] + z_dim[i]

处理的标准：

• 检查： compile time 的时候不判断维度等于 -1 的情况，但在 runtime 的时候检查

• 运算： -1 和其他数做任何运算都要等于 -1

参考代码：

• 判断的实现方法可以参考 SigmoidCrossEntropyWithLogitsInferMeta，SigmoidCrossEntropyWithLogits 要求 X 和 labels 的两个输入，除了最后一维以外，其他的维度完全一致。

  bool check = true;
  if ((!config.is_runtime) &&
      (phi::product(x_dims) <= 0 || phi::product(labels_dims) <= 0)) {
    check = false;
  }

  if (check) {
    PADDLE_ENFORCE_EQ(
        phi::slice_ddim(x_dims, 0, rank),
        phi::slice_ddim(labels_dims, 0, rank),
        phi::errors::InvalidArgument(
            "Input(X) and Input(Label) shall have the same shape "
            "except the last dimension. But received: the shape of "
            "Input(X) is [%s], the shape of Input(Label) is [%s].",
            x_dims,
            labels_dims));
  }

• 运算的实现可以参考 ConcatInferMeta，concat 在 InferShape 判断时，调用ComputeAndCheckShape，除了进行 concat 轴之外，其他的维度完全一致；在生成 output 的维度时，把 concat 轴的维度求和，其他的维度和输入保持一致。

  const size_t n = inputs_dims.size();
  auto out_dims = inputs_dims[0];
  size_t in_zero_dims_size = out_dims.size();
  for (size_t i = 1; i < n; i++) {
    PADDLE_ENFORCE_EQ(
        inputs_dims[i].size(),
        out_dims.size(),
        phi::errors::InvalidArgument("The shape of input[0] and input[%d] "
                                    "is expected to be equal."
                                    "But received input[0]'s shape = "
                                    "[%s], input[%d]'s shape = [%s].",
                                    i,
                                    inputs_dims[0],
                                    i,
                                    inputs_dims[i]));
    for (size_t j = 0; j < in_zero_dims_size; j++) {
      if (j == axis) {
        if (is_runtime) {
          out_dims[axis] += inputs_dims[i][j];
        } else {
          if (inputs_dims[i][j] == -1 || out_dims[j] == -1) {
            out_dims[axis] = -1;
          } else {
            out_dims[axis] += inputs_dims[i][j];
          }
        }
      } else {
        bool check_shape =
            is_runtime || (inputs_dims[0][j] > 0 && inputs_dims[i][j] > 0);
        if (check_shape) {
          // check all shape in run time
          PADDLE_ENFORCE_EQ(inputs_dims[0][j],
                            inputs_dims[i][j],
                            phi::errors::InvalidArgument(
                                "The %d-th dimension of input[0] and input[%d] "
                                "is expected to be equal."
                                "But received input[0]'s shape = "
                                "[%s], input[%d]'s shape = [%s].",
                                j,
                                i,
                                inputs_dims[0],
                                i,
                                inputs_dims[i]));
        }
        if (!is_runtime && out_dims[j] == -1 && inputs_dims[i][j] > 0) {
          out_dims[j] = inputs_dims[i][j];
        }
      }
    }
  }

4.1 Kernels 目录结构¶

新增算子 Kernel 在 paddle/phi/kernels 目录中完成，基本目录结构如下：

paddle/phi/kernels
./ (根目录放置设备无关的 kernel 声明和实现)
./cpu（仅放置 cpu 后端的 kernel 实现）
./gpu（仅放置 gpu 后端的 kernel 实现）
./xpu（仅放置百度 kunlun 后端的 kernel 实现）
./gpudnn
./funcs（放置一些支持多设备的、在多个 kernel 中使用的公共 functor 和 functions）
...

一般情况下，新增算子仅需要关注 kernels 根目录及 kernel 所支持设备的子目录即可：

• kernels 根目录，放置设备无关的 kernel.h 和 kernel.cc

  • 例如，一个 kernel 除了一些简单的设备无关的 C++ 逻辑，关键计算逻辑均是复用已有的 kernel 函数实现的，那么这个 kernel 实现是天然能够适配所有设备及后端的，所以它的声明和实现均直接放置到 kernels 目录下即可。

• kernels 下一级子目录，原则上按照后端分类按需新建，放置特定后端的 kernel 实现代码。

下面给出两种典型 kernel 新增时文件放置位置的说明（假设算子名为xxx）：

• 新增与设备无关的 kernel

  该类 kernel 实现与所有硬件设备无关，只需要一份代码实现，可参考 reshape kernel。其新增文件及目录包括：

  • paddle/phi/kernels/xxx_kernel.h

  • paddle/phi/kernels/xxx_kernel.cc

  如果是反向 kernel，则使用 grad_kernel 后缀即可：

  • paddle/phi/kernels/xxx_grad_kernel.h

  • paddle/phi/kernels/xxx_grad_kernel.cc

• 新增与设备相关、且 CPU & GPU 分别实现的 kernel

  还有部分 kernel 的实现，CPU 和 GPU 上逻辑不同，此时没有共同实现的代码，需要区分 CPU 和 GPU 硬件。 CPU 的实现位于paddle/phi/kernels/cpu 目录下； GPU 的实现位于paddle/phi/kernels/gpu 下，可参考 dot kernel，cast kernel 等。其新增文件及目录包括：

  • paddle/phi/kernels/xxx_kernel.h

  • paddle/phi/kernels/cpu/xxx_kernel.cc

  • paddle/phi/kernels/gpu/xxx_kernel.cu

    相应地，反向 kernel 新增文件为：

  • paddle/phi/kernels/xxx_grad_kernel.h

  • paddle/phi/kernels/cpu/xxx_grad_kernel.cc

  • paddle/phi/kernels/gpu/xxx_grad_kernel.cu

4.2 Kernel 写法¶

namespace phi {
template <typename T, typename Context>
void TraceKernel(const Context& dev_ctx,
                 const DenseTensor& x,
                 int offset,
                 int axis1,
                 int axis2,
                 DenseTensor* out);
}

#include ...
#include "paddle/phi/kernels/elementwise_add_kernel.h"
#include "paddle/phi/kernels/elementwise_multiply_kernel.h"

template <typename T, typename Context>
void LinearKernel(const Context& dev_ctx,
                  const DenseTensor& x,
                  const DenseTensor& w,
                  const DenseTensor& b,
                  DenseTensor* out) {
  dev_ctx.template Alloc<T>(out);         // 为 out 分配内存
  MultiplyKernel<T>(dev_ctx, x, w, out);  // 复用 MultiplyKernel
  AddKernel<T>(dev_ctx, out, b, out);     // 复用 AddKernel
}

template <typename T, typename Context>
void TraceKernel(const Context& dev_ctx,
                 const DenseTensor& x,
                 int offset,
                 int axis1,
                 int axis2,
                 DenseTensor* out) {
  auto* out_data = dev_ctx.template Alloc<T>(out);

  const DenseTensor diag =
      funcs::Diagonal<T, Context>(dev_ctx, &x, offset, axis1, axis2);
  if (diag.numel() > 0) {
    auto x = phi::EigenMatrix<T>::Reshape(diag, diag.dims().size() - 1);
    auto output = phi::EigenVector<T>::Flatten(*out);
    auto reduce_dim = Eigen::array<int, 1>({1});
    output.device(*dev_ctx.eigen_device()) = x.sum(reduce_dim);
    out->Resize(out->dims());
  } else {
    std::fill(out_data, out_data + out->numel(), static_cast<T>(0));
  }
}

#include "paddle/phi/kernels/empty_kernel.h"
#include "paddle/phi/kernels/expand_kernel.h"

  // Tensor broadcast to 'out' and temp 'x_bst'
  IntArray x_bst_dims(x_bst_dims_vec);
  DenseTensor x_bst = phi::Empty<T, Context>(dev_ctx, x_bst_dims);
  const T* x_bst_data = x_bst.data<T>();
  ExpandKernel<T, Context>(dev_ctx, x, x_bst_dims, &x_bst);

PD_REGISTER_KERNEL(trace,
                   CPU,
                   ALL_LAYOUT,
                   phi::TraceKernel,
                   float,
                   double,
                   int,
                   int64_t,
                   phi::dtype::float16,
                   phi::dtype::complex<float>,
                   phi::dtype::complex<double>) {}

4.3 编译测试¶

实现完算子 kernel 之后，建议先编译测试一下，编译成功之后，再继续后面的步骤。

详细的编译环境准备和执行流程可参考 从源码编译，下面简单介绍几个主要步骤。 在 Paddle 代码目录下创建并切换到 build 目录：

mkdir build && cd build

执行cmake命令，具体选项可参考 从源码编译 中的介绍，下面的命令为编译 Python3.7，GPU 版本，带测试，Release 版本的 Paddle。

cmake .. -DPY_VERSION=3.7 -DWITH_GPU=ON -DWITH_TESTING=ON -DCMAKE_BUILD_TYPE=Release

在build目录下，运行下面命令可以进行编译整个 paddle：

make -j$(nproc)

**注意：**新增算子后请重新执行cmake命令，然后再执行make命令编译 paddle。

6.1 C++ 算子单元测试¶

算子单元测试继承自 OpTest。各项具体的单元测试在TestTraceOp里完成。测试算子，需要：

1. 在setUp函数定义输入、输出，以及相关的属性参数，并生成随机的输入数据。

2. 在 Python 脚本中实现与前向算子相同的计算逻辑，得到输出值，与算子前向计算的输出进行对比。

3. 反向计算已经自动集成进测试框架，直接调用相应接口即可。

import paddle
import unittest
import numpy as np
from op_test import OpTest


class TestTraceOp(OpTest):
    # 配置 op 信息以及输入输出等参数
    def setUp(self):
        self.op_type = "trace"
        self.python_api = paddle.trace
        self.init_config()
        self.outputs = {'Out': self.target}

    # 测试前向输出结果
    def test_check_output(self):
        self.check_output(check_eager=True)

    # 测试反向梯度输出
    def test_check_grad(self):
        self.check_grad(['Input'], 'Out', check_eager=True)

    def init_config(self):
        # 生成随机的输入数据
        self.case = np.random.randn(20, 6).astype('float64')
        self.inputs = {'Input': self.case}
        self.attrs = {'offset': 0, 'axis1': 0, 'axis2': 1}
        self.target = np.trace(self.inputs['Input'])

• setUp 函数实现

  • self.op_type = "trace" : 定义类型，与算子定义的名称相同。

  • self.python_api = paddle.trace : 定义 python api，与 python 调用接口一致。

  • self.inputs : 定义输入，类型为numpy.array，并初始化。

  • self.outputs : 定义输出，并在 Python 脚本中完成与算子同样的计算逻辑，返回 Python 端的计算结果。

• 前向算子单测

  • test_check_output 中会对算子的前向计算结果进行测试，对比参考的结果为 setUp 中 self.outputs提供的数据。check_eager=True表示开启新动态图（eager 模式）单测，check_eager默认为False

• 反向算子单测

  • test_check_grad中调用check_grad使用数值法检测梯度正确性和稳定性。

    • 第一个参数['Input'] : 指定对输入变量Input做梯度检测。

    • 第二个参数'Out' : 指定前向网络最终的输出目标变量Out。

    • 第三个参数check_eager : check_eager=True 表示开启新动态图（eager 模式）单测，check_eager 默认为False。

  • 对于存在多个输入的反向算子测试，需要指定只计算部分输入梯度的 case

    • 例如，test_elementwise_sub_op.py 中的test_check_grad_ingore_x和test_check_grad_ingore_y分支用来测试只需要计算一个输入梯度的情况

    • 此处第三个参数 max_relative_error：指定检测梯度时能容忍的最大错误值。

  def test_check_grad_ingore_x(self):
      self.check_grad(
          ['Y'], 'Out', max_relative_error=0.005, no_grad_set=set("X"))
  
  def test_check_grad_ingore_y(self):
      self.check_grad(
          ['X'], 'Out', max_relative_error=0.005, no_grad_set=set('Y'))
  

6.2 Python API 单元测试¶

Python API 也需要编写相关的单测进行测试，详见 开发 API Python 端。

其他有关单元测试添加的注意事项请参考 Op 开发手册 及 API 单测开发及验收规范。

6.3 运行单元测试¶

python/paddle/fluid/tests/unittests/ 目录下新增的 test_*.py 单元测试会被自动加入工程进行编译。

请注意，运行单元测试测时需要编译整个工程，并且编译时需要打开WITH_TESTING。

参考上述【4.3 编译测试】小节，编译成功后，在build目录下执行下面的命令来运行单元测试：

make test ARGS="-R test_trace_op -V"

或者执行:

ctest -R test_trace_op -V

7.1 报错检查¶

实现算子时检查数据的合法性需要使用 PADDLE_ENFORCE 以及 PADDLE_ENFORCE_EQ 等宏定义，基本格式如下：

PADDLE_ENFORCE(表达式, 错误提示信息)
PADDLE_ENFORCE_EQ(比较对象 A, 比较对象 B, 错误提示信息)

如果表达式为真，或者比较对象 A=B，则检查通过，否则会终止程序运行，向用户反馈相应的错误提示信息。 为了确保提示友好易懂，开发者需要注意其使用方法。

总体原则： 任何使用了 PADDLE_ENFORCE 与 PADDLE_ENFORCE_XX 检查的地方，必须有详略得当的备注解释！错误提示信息不能为空！

报错提示信息书写建议：

1. [required] 哪里错了？为什么错了？

   • 例如：ValueError: Mismatched label shape

2. [optional] 期望的输入是什么样的？实际的输入是怎样的？

   • 例如：Expected labels dimension=1. Received 4.

3. [optional] 能否给出修改意见？

   • 例如：Suggested Fix:If your classifier expects one-hot encoding label,check your n_classes argument to the estimatorand/or the shape of your label.Otherwise, check the shape of your label.

更详细的报错检查规范介绍请参考 《Paddle 报错信息文案书写规范》。

7.2 算子兼容性问题¶

对算子的修改需要考虑兼容性问题，要保证算子修改之后，之前的模型都能够正常加载及运行，即新版本的 Paddle 预测库能成功加载运行旧版本训练的模型。所以，需要保证算子当前的所有输入输出参数不能被修改（文档除外）或删除，可以新增参数，但是新增的 Tensor 类型变量需要设置为 optional，非 Tensor 变量需要设置默认值。更多详细内容请参考 OP 修改规范：Input/Output/Attribute 只能做兼容修改 。

7.3 显存优化¶

- op : reshape
  args : (Tensor x, IntArray shape)
  output : Tensor(out)
  ...
  inplace : (x -> out)

- backward_op : trace_grad
  forward : trace (Tensor x, int offset, int axis1, int axis2) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, int offset, int axis1, int axis2)
  output : Tensor(x_grad)
  ...
  no_need_buffer : x

7.4 性能优化¶

7.5 稀疏梯度参数更新方法¶

目前稀疏梯度在做更新的时候会先对梯度做 merge，即对相同参数的梯度做累加，然后做参数以及附加参数（如 velocity）的更新。

7.6 混合设备调用¶

由于 GPU 是异步执行的，当 CPU 调用返回之后，GPU 端可能还没有真正的执行，所以如果在算子中创建了 GPU 运行时需要用到的临时变量，当 GPU 开始运行的时候，该临时变量可能在 CPU 端已经被释放，这样可能会导致 GPU 计算出错。

关于 GPU 中的一些同步和异步操作：

The following device operations are asynchronous with respect to the host:
    Kernel launches;
    Memory copies within a single device's memory;
    Memory copies from host to device of a memory block of 64 KB or less;
    Memory copies performed by functions that are suffixed with Async;
    Memory set function calls.

关于 cudaMemCpy 和 cudaMemCpyAsync 注意事项：

• 如果数据传输是从 GPU 端到非页锁定的 CPU 端，数据传输将是同步，即使调用的是异步拷贝操作。

• 如果数据传输是从 CPU 端到 CPU 端，数据传输将是同步的，即使调用的是异步拷贝操作。

更多内容可参考：Asynchronous Concurrent Execution，API synchronization behavior

7.7 算子数值稳定性问题¶

有些算子存在数值稳定性问题，出现数值稳定性的主要原因程序在多次运行时，对浮点型数据施加操作的顺序可能不同，进而导致最终计算结果不同。而 GPU 是通过多线程并行计算的方式来加速计算的，所以很容易出现对浮点数施加操作的顺序不固定现象。

目前发现 cudnn 中的卷积操作、cudnn 中的 MaxPooling、CUDA 中 CudaAtomicXX、ParallelExecutor 的 Reduce 模式下参数梯度的聚合等操作运行结果是非确定的。

为此 Paddle 中添加了一些 FLAGS，比如使用 FLAGS_cudnn_deterministic 来强制 cudnn 使用确定性算法、FLAGS_cpu_deterministic 强制 CPU 端的计算使用确定性方法。

7.8 算子的数学公式¶

如果算子有数学公式，一定要在代码中将数学公式写明，并在 Python API 的 Doc 中显示，因为用户在对比不同框架的计算结果时可能需要了解 Paddle 对算子是怎么实现的。

7.9 LoD 在算子内部的传导规范¶

LoD 是 Paddle 框架用来表示变长序列数据的属性，除了仅支持输入是 padding data 的算子外，所有算子的实现都要考虑 LoD 的传导问题。

根据算子的计算过程中是否用到 LoD，我们可以将涉及到 LoD 传导问题的算子分为两类: LoD-Transparent 与 LoD-Based。

这两类算子的 LoD 传导需要考虑前向和反向两个过程。

（1）前向传导

在前向传导过程，与输入的 LoD 相比较，算子输出的 LoD 可能出现不变、改变和消失这三种情况：

• 不变：适用于所有的 LoD-Transparent 算子与部分的 LoD-Based 算子。可以在InferMeta 中调用 ShareLoD() 直接将输入 Var 的 LoD 共享给输出 Var, 可参考 lstm_op; 如果有多个输入且都可能存在 LoD 的情况，通常默认共享第一个输入, 例如 elementwise_ops forward；

• 改变：适用于部分 LoD-Based 算子。在实现 OpKernel 时需考虑输出 LoD 的正确计算，真实的 LoD 在前向计算结束后才能确定，此时仍需要在InferMeta 中调用 ShareLoD()，以确保 CompileTime 时对 LoD Level 做了正确的传导，可参考 sequence_expand_op；

• 消失：适用于输出不再是序列数据的 LoD-Based 算子。此时不用再考虑前向的 LoD 传导问题，可参考 sequence_pool_op；

其它重要的注意事项：

• 实现 LoD-Based 算子时，需要处理好 LoD 传导的边界情况，例如对长度为零的输入的支持，并完善相应的单测，单测 case 覆盖空序列出现在 batch 开头、中间和末尾等位置的情况，可参考 test_lstm_op.py

• 对 LoD Level 有明确要求的算子，推荐的做法是在 InferMeta 中即完成 LoD Level 的检查，例如 sequence_pad_op。

（2）反向传导

通常来讲，算子的某个输入 Var 所对应的梯度 GradVar 的 LoD 应该与 Var 自身相同，所以应直接将 Var 的 LoD 共享给 GradVar，可以参考 elementwise ops 的 backward。

8.1 Paddle 基于 Yaml 配置自动生成算子代码的逻辑解读¶

Paddle 支持动态图和静态图两种模式，在 YAML 配置文件中完成算子基本属性的定义后，需要进行解析并分别生成动态图和静态图所对应的算子代码逻辑，从而将算子接入框架的执行体系。基于 YAML 配置的算子代码自动生成示意图，如下所示。

说明：当开发者添加一个新的 C++ 算子时，只需要完成下图中 Kernel、算子定义 Yaml 配置文件和 Python API 三个绿色框中的代码开发，其余橙色部分都会通过自动代码生成来完成，从而将新增算子接入飞桨框架中。

如前文所述，算子开发时通过 YAML 配置文件对算子进行描述及定义，包括前向 paddle/phi/api/yaml/ops.yaml 和反向 paddle/phi/api/yaml/backward.yaml。动态图和静态图两种模式的执行流程不同，具体如下所示：

• 动态图中自动生成的代码包括从 Python API 到计算 Kernel 间的各层调用接口实现，从底层往上分别为：

  • C++ API：一套与 Python API 参数对齐的 C++ 接口（只做逻辑计算，不支持自动微分），内部封装了底层 kernel 的选择和调用等逻辑，供上层灵活使用。

    • 注：前向算子生成 C++ API 头文件和实现代码分别为 paddle/phi/api/include/api.h和paddle/phi/api/lib/api.cc，反向算子生成的头文件和实现代码分别为 paddle/phi/api/backward/backward_api.h,paddle/phi/api/lib/backward_api.cc。

  • 动态图前向函数与反向节点（Autograd API）：在 C++ API 的基础上进行了封装，组成一个提供自动微分功能的 C++函数接口。

    • 注：生成的相关代码在 paddle/fluid/eager/api/generated/eager_generated 目录下。

  • Python-C 函数：将支持自动微分功能的 C++ 的函数接口（Autograd API）暴露到 Python 层供 Python API 调用。

    • 注：生成的 Python-C 接口代码在 paddle/fluid/pybind/eager_op_function.cc 中。

• 静态图的执行流程与动态图不同，所以生成的代码也与动态图有较大差异。

静态图由于是先组网后计算，Python API 主要负责组网，算子的调度和 kernel 计算由静态图执行器来完成，因此自动生成的代码是将配置文件中的算子信息注册到框架内供执行器调度，主要包括 OpMaker（静态图中定义算子的输入、输出以及属性等信息）和REGISTER_OPERATOR（将算子名称以及 OpMaker 等信息进行注册）等静态图算子注册组件，具体的代码逻辑可参考 paddle/fluid/operators/generated_op.cc。

注意：由于代码自动生成在编译时进行，所以查看上述生成代码需要先完成 框架的编译。