paddle¶
paddle 目录下包含 tensor、device、framework 相关 API 以及某些高层 API。具体如下:
稀疏 API 相关
tensor 数学操作¶
API 名称  |  
           API 功能  |  
          
|---|---|
| 
             |  
           绝对值函数  |  
          
| 
             |  
           相位角函数  |  
          
| 
             |  
           arccosine 函数  |  
          
| 
             |  
           Tensor 逐元素相加  |  
          
| 
             |  
           对输入的一至多个 Tensor 求和  |  
          
| 
             |  
           计算输入 Tensor x 和 y 的乘积,将结果乘以标量 alpha,再加上 input 与 beta 的乘积,得到输出  |  
          
| 
             |  
           对指定维度上的 Tensor 元素进行逻辑与运算  |  
          
| 
             |  
           逐个检查输入 Tensor x 和 y 的所有元素是否均满足 ∣x−y∣≤atol+rtol×∣y∣  |  
          
| 
             |  
           逐个检查输入 Tensor x 和 y 的所有元素是否满足 ∣x−y∣≤atol+rtol×∣y∣  |  
          
| 
             |  
           对指定维度上的 Tensor 元素进行逻辑或运算  |  
          
| 
             |  
           arcsine 函数  |  
          
| 
             |  
           arctangent 函数  |  
          
| 
             |  
           arctangent2 函数  |  
          
| 
             |  
           向上取整运算函数  |  
          
| 
             |  
           将输入的所有元素进行剪裁,使得输出元素限制在[min, max]内  |  
          
| 
             |  
           逐元素计算 Tensor 的共轭运算  |  
          
| 
             |  
           余弦函数  |  
          
| 
             |  
           双曲余弦函数  |  
          
| 
             |  
           按照元素计算两个输入 Tensor 的 copysign 大小,由数值和符号组成,其数值部分来自于第一个 Tensor 中的元素,符号部分来自于第二个 Tensor 中的元素。  |  
          
| 
             |  
           沿给定的轴 axis 统计非零元素的数量  |  
          
| 
             |  
           沿给定 axis 计算 Tensor x 的累加和  |  
          
| 
             |  
           沿给定 axis 计算 Tensor x 的累计最大值  |  
          
| 
             |  
           沿给定 axis 计算 Tensor x 的累计最小值  |  
          
| 
             |  
           沿给定 dim 计算 Tensor x 的累乘  |  
          
| 
             |  
           逐元素计算输入 x 的 digamma 函数值  |  
          
| 
             |  
           逐元素相除算子  |  
          
| 
             |  
           返回 x==y 逐元素比较 x 和 y 是否相等,相同位置的元素相同则返回 True,否则返回 False  |  
          
| 
             |  
           如果所有相同位置的元素相同返回 True,否则返回 False  |  
          
| 
             |  
           逐元素计算 Erf 激活函数  |  
          
| 
             |  
           逐元素进行以自然数 e 为底指数运算  |  
          
| 
             |  
           逐元素进行 exp(x)-1 运算  |  
          
| 
             |  
           向下取整函数  |  
          
| 
             |  
           逐元素整除算子,输入 x 与输入 y 逐元素整除,并将各个位置的输出元素保存到返回结果中  |  
          
| 
             |  
           返回 x 与 y 逐元素的最大值构成的新 Tensor,若遇任一 NaN,取另一值;两 NaN 则取首 NaN  |  
          
| 
             |  
           返回 x 与 y 逐元素的最小值构成的新 Tensor,若遇任一 NaN,取另一值;两 NaN 则取首 NaN  |  
          
| 
             |  
           计算正则化上不完全伽玛函数  |  
          
| 
             |  
           计算正则化下不完全伽玛函数  |  
          
| 
             |  
           逐元素计算输入 x 的伽马函数的绝对值的自然对数  |  
          
| 
             |  
           逐元素地返回 x>=y 的逻辑值  |  
          
| 
             |  
           逐元素地返回 x>y 的逻辑值  |  
          
| 
             |  
           逐元素地对 x 计算由 y 中的对应元素决定的赫维赛德阶跃函数  |  
          
| 
             |  
           在控制流程中用来让 x 的数值增加 value  |  
          
| 
             |  
           计算两个 Tensor 的克罗内克积  |  
          
| 
             |  
           逐元素地返回 x<=y 的逻辑值  |  
          
| 
             |  
           逐元素地返回 x<y 的逻辑值  |  
          
| 
             |  
           计算输入 x 的 gamma 函数的自然对数并返回  |  
          
| 
             |  
           Log 激活函数(计算自然对数)  |  
          
| 
             |  
           Log10 激活函数(计算底为 10 的对数)  |  
          
| 
             |  
           计算 Log1p(加一的自然对数)结果  |  
          
| 
             |  
           计算   |  
          
| 
             |  
           计算 x 的指数的前缀和的对数  |  
          
| 
             |  
           逐元素的对 x 和 y 进行逻辑与运算  |  
          
| 
             |  
           逐元素的对 X Tensor 进行逻辑非运算  |  
          
| 
             |  
           逐元素的对 X 和 Y 进行逻辑或运算  |  
          
| 
             |  
           逐元素的对 X 和 Y 进行逻辑异或运算  |  
          
| 
             |  
           计算 logit 结果  |  
          
| 
             |  
           返回区间 \([base^{start}, base^{stop}]\) 内固定数量的对数均匀分布的值  |  
          
| 
             |  
           逐元素的对 x 和 y 进行按位与运算  |  
          
| 
             |  
           逐元素的对 X Tensor 进行按位取反运算  |  
          
| 
             |  
           逐元素的对 X 和 Y 进行按位或运算  |  
          
| 
             |  
           逐元素的对 X 和 Y 进行按位异或运算  |  
          
| 
             |  
           逐元素的对 X 和 Y 进行按位算术(或逻辑)左移  |  
          
| 
             |  
           逐元素的对 X 和 Y 进行按位算术(或逻辑)右移  |  
          
| 
             |  
           沿着 axis 计算 x 的以 e 为底的指数的和的自然对数  |  
          
| 
             |  
           对指定维度上的 Tensor 元素求最大值运算  |  
          
| 
             |  
           对指定维度上的 Tensor 元素求最大值运算  |  
          
| 
             |  
           逐元素对比输入的两个 Tensor,并且把各个位置更大的元素保存到返回结果中  |  
          
| 
             |  
           沿 axis 计算 x 的平均值  |  
          
| 
             |  
           沿给定的轴 axis 计算 x 中元素的中位数  |  
          
| 
             |  
           沿给定的轴 axis 忽略 NAN 元素计算 x 中元素的中位数  |  
          
| 
             |  
           对指定维度上的 Tensor 元素求最小值运算  |  
          
| 
             |  
           对指定维度上的 Tensor 元素求最小值运算  |  
          
| 
             |  
           逐元素对比输入的两个 Tensor,并且把各个位置更小的元素保存到返回结果中  |  
          
| 
             |  
           用于两个输入矩阵的相乘  |  
          
| 
             |  
           计算两个输入矩阵的内积  |  
          
| 
             |  
           计算两个输入矩阵的外积  |  
          
| 
             |  
           从每个输入 Tensor 中选择特定行构造输出 Tensor  |  
          
| 
             |  
           逐元素相乘算子  |  
          
| 
             |  
           计算 x 乘以 2 的 y 次幂  |  
          
| 
             |  
           计算多元伽马函数的对数  |  
          
| 
             |  
           替换 x 中的 NaN、+inf、-inf 为指定值  |  
          
| 
             |  
           沿给定的轴   |  
          
| 
             |  
           沿   |  
          
| 
             |  
           沿给定的轴   |  
          
| 
             |  
           计算给定轴上的元素之和,并将非数字元素(NaNs)视为 0  |  
          
| 
             |  
           计算输入 x 的相反数并返回  |  
          
| 
             |  
           逐元素将 x 之后的下一个浮点值返回  |  
          
| 
             |  
           逐元素地返回 x!=y 的逻辑值  |  
          
| 
             |  
           指数算子,逐元素计算 x 的 y 次幂  |  
          
| 
             |  
           对指定维度上的 Tensor 元素进行求乘积运算  |  
          
| 
             |  
           对输入 Tensor 取倒数  |  
          
| 
             |  
           将输入中的数值四舍五入到最接近的整数数值  |  
          
| 
             |  
           rsqrt 激活函数  |  
          
| 
             |  
           缩放算子  |  
          
| 
             |  
           对输入 x 中每个元素进行正负判断  |  
          
| 
             |  
           对输入 x 的每个元素符号位进行判断  |  
          
| 
             |  
           对输入 x 中每个元素进行正负判断,对于复数则输出单位向量  |  
          
| 
             |  
           计算输入的正弦值  |  
          
| 
             |  
           计算输入的归一化 sinc 值  |  
          
| 
             |  
           双曲正弦函数  |  
          
| 
             |  
           计算输入的算数平方根  |  
          
| 
             |  
           逐元素取平方运算  |  
          
| 
             |  
           stanh 激活函数  |  
          
| 
             |  
           沿给定的轴 axis 计算 x 中元素的标准差  |  
          
| 
             |  
           逐元素相减算子  |  
          
| 
             |  
           逐元素取模算子  |  
          
| 
             |  
           对指定维度上的 Tensor 元素进行求和运算  |  
          
| 
             |  
           三角函数 tangent  |  
          
| 
             |  
           tanh 激活函数  |  
          
| 
             |  
           计算输入 Tensor 在指定平面上的对角线元素之和  |  
          
| 
             |  
           沿给定的轴 axis 计算 x 中元素的方差  |  
          
| 
             |  
           根据给定的轴 axis 返回输入 Tensor 的局部视图  |  
          
| 
             |  
           对输入 Tensor 每个元素的小数部分进行截断  |  
          
| 
             |  
           得到输入 Tensor 每个元素的小数部分  |  
          
| 
             |  
           计算 Log1p(加一的自然对数)结果  |  
          
| 
             |  
           根据 axis 和 index 获取输入 Tensor 的对应元素  |  
          
| 
             |  
           根据 axis 和 index 放置 value 值至输入 Tensor  |  
          
| 
             |  
           基于给定的 weight 计算 x 与 y 的线性插值  |  
          
| 
             |  
           沿着指定维度对输入 Tensor 计算 n 阶的前向差值  |  
          
| 
             |  
           将元素从弧度的角度转换为度  |  
          
| 
             |  
           将元素从度的角度转换为弧度  |  
          
| 
             |  
           计算两个输入的按元素绝对值的最大公约数  |  
          
| 
             |  
           计算两个输入的按元素绝对值的最小公倍数  |  
          
| 
             |  
           计算输入 Tensor 的逆误差函数  |  
          
| 
             |  
           反双曲余弦函数  |  
          
| 
             |  
           反双曲正弦函数  |  
          
| 
             |  
           反双曲正切函数  |  
          
| 
             |  
           输出给定索引处的输入元素,结果与 index 的形状相同  |  
          
| 
             |  
           用于把一个浮点数分解为尾数和指数的函数  |  
          
| 
             |  
           在指定维度上对输入实现 trapezoid rule 算法。使用累积求和函数 sum  |  
          
| 
             |  
           在指定维度上对输入实现 trapezoid rule 算法。使用累积求和函数 cumsum  |  
          
| 
             |  
           对输入 Tensor 每个元素计算第一类零阶修正贝塞尔函数  |  
          
| 
             |  
           对输入 Tensor 每个元素计算第一类指数缩放的零阶修正贝塞尔函数  |  
          
| 
             |  
           对输入 Tensor 每个元素计算第一类一阶修正贝塞尔函数  |  
          
| 
             |  
           对输入 Tensor 每个元素计算第一类指数缩放的一阶修正贝塞尔函数  |  
          
| 
             |  
           对输入 Tensor 每个元素计算多伽马函数  |  
          
| 
             |  
           对输入 直角三角形的直角边 Tensor x, y, 计算其斜边  |  
          
| 
             |  
           对输入 Tensor 计算长度为 r 的情况下的所有组合  |  
          
| 
             |  
           根据 axis 和 index(整数) 填充 value 值至输入 Tensor  |  
          
| 
             |  
           对 x 在某些维度上求和,使其结果与 target 的 shape 一致  |  
          
tensor 数学操作原位(inplace)版本¶
API 名称  |  
           API 功能  |  
          
|---|---|
| 
             |  
           Inplace 版本的 remainder API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 abs API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 bernoulli API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 tanh API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 erf API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 erfinv API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 add API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 put_along_axis API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 ceil API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 clip API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 copysign API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 exp API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 expm1 API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 flatten API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 floor API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 gammaincc API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 gammainc API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 gammaln API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 reciprocal API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 round API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 rsqrt API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 scale API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 sqrt API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 square API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 sin API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 sinc API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 sinh API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 subtract API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 tan API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 cos API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 atan API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 acos API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 uniform API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 lerp API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 hypot API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 multigammaln API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 masked_fill API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 masked_scatter API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 index_fill API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 bitwise_left_shift API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 bitwise_right_shift API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 log_normal API,对输入 x 采用 Inplace 策略  |  
          
tensor 逻辑操作¶
API 名称  |  
           API 功能  |  
          
|---|---|
| 
             |  
           测试变量是否为空  |  
          
| 
             |  
           用来测试输入对象是否是 paddle.Tensor  |  
          
| 
             |  
           返回输入 tensor 的每一个值是否为 Finite(既非 +/-INF 也非 +/-NaN )  |  
          
| 
             |  
           测试输入 x 的每一个值是否在 test_x 中  |  
          
| 
             |  
           返回输入 tensor 的每一个值是否为 +/-INF  |  
          
| 
             |  
           返回输入 tensor 的每一个值是否为 +/-NaN  |  
          
| 
             |  
           返回输入 tensor 的每一个值是否为 +INF  |  
          
| 
             |  
           返回输入 tensor 的每一个值是否为 -INF  |  
          
| 
             |  
           返回输入 tensor 的每一个值是否为实数类型  |  
          
tensor 属性相关¶
API 名称  |  
           API 功能  |  
          
|---|---|
| 
             |  
           返回一个 iinfo 对象,该对象包含了输入的整数类 paddle.dtype 的各种相关的数值信息  |  
          
| 
             |  
           返回一个 finfo 对象,该对象包含了输入的整数类 paddle.dtype 的各种相关的数值信息  |  
          
| 
             |  
           返回一个包含输入复数 Tensor 的虚部数值的新 Tensor  |  
          
| 
             |  
           返回一个包含输入复数 Tensor 的实部数值的新 Tensor  |  
          
| 
             |  
           获得输入 Tensor 或 SelectedRows 的 shape  |  
          
| 
             |  
           判断输入 tensor 的数据类型是否为复数类型  |  
          
| 
             |  
           判断输入 tensor 的数据类型是否为整数类型  |  
          
| 
             |  
           返回对 x_shape 大小的 Tensor 和 y_shape 大小的 Tensor 做 broadcast 操作后得到的 shape  |  
          
| 
             |  
           判断输入 Tensor 的数据类型是否为浮点类型  |  
          
tensor 创建相关¶
API 名称  |  
           API 功能  |  
          
|---|---|
| 
             |  
           返回以步长 step 均匀分隔给定数值区间[start, end)的 1-D Tensor,数据类型为 dtype  |  
          
| 
             |  
           如果 x 是向量(1-D Tensor),则返回带有 x 元素作为对角线的 2-D 方阵;如果 x 是矩阵(2-D Tensor),则提取 x 的对角线元素,以 1-D Tensor 返回。  |  
          
| 
             |  
           创建一个 Tensor,其在指定的 2D 平面(由   |  
          
| 
             |  
           如果 x 是一维 Tensor,则返回带有 x 元素作为对角线的二维方阵;如果 x 是大于等于二维的 Tensor,则返回一个二维 Tensor,其对角线元素为 x 在连续维度展开得到的一维 Tensor 的元素。  |  
          
| 
             |  
           创建形状大小为 shape 并且数据类型为 dtype 的 Tensor  |  
          
| 
             |  
           根据 x 的 shape 和数据类型 dtype 创建未初始化的 Tensor  |  
          
| 
             |  
           构建二维 Tensor(主对角线元素为 1,其他元素为 0)  |  
          
| 
             |  
           创建形状大小为 shape 并且数据类型为 dtype 的 Tensor  |  
          
| 
             |  
           创建一个和 x 具有相同的形状并且数据类型为 dtype 的 Tensor  |  
          
| 
             |  
           返回一个 Tensor,Tensor 的值为在区间 start 和 stop 上均匀间隔的 num 个值,输出 Tensor 的长度为 num  |  
          
| 
             |  
           对每个 Tensor 做扩充操作  |  
          
| 
             |  
           返回一个长度为 1 并且元素值为输入 x 元素个数的 Tensor  |  
          
| 
             |  
           创建形状为 shape 、数据类型为 dtype 且值全为 1 的 Tensor  |  
          
| 
             |  
           返回一个和 x 具有相同形状的数值都为 1 的 Tensor  |  
          
| 
             |  
           Paddle 中最为基础的数据结构  |  
          
| 
             |  
           通过已知的 data 来创建一个 tensor  |  
          
| 
             |  
           将 paddle Tensor 转化为 python list  |  
          
| 
             |  
           创建形状为 shape 、数据类型为 dtype 且值全为 0 的 Tensor  |  
          
| 
             |  
           返回一个和 x 具有相同的形状的全零 Tensor,数据类型为 dtype 或者和 x 相同  |  
          
| 
             |  
           给定实部和虚部,返回一个复数 Tensor  |  
          
| 
             |  
           创建一个参数,该参数是一个可学习的变量, 拥有梯度并且可优化  |  
          
| 
             |  
           对输入 Tensor   |  
          
| 
             |  
           一个 reader 的装饰器。返回的 reader 将输入 reader 的数据打包成指定的 batch_size 大小的批处理数据(不推荐使用)  |  
          
| 
             |  
           对于给定的模   |  
          
| 
             |  
           生成范德蒙德矩阵。  |  
          
tensor 元素查找相关¶
API 名称  |  
           API 功能  |  
          
|---|---|
| 
             |  
           沿 axis 计算输入 x 的最大元素的索引  |  
          
| 
             |  
           沿 axis 计算输入 x 的最小元素的索引  |  
          
| 
             |  
           对输入变量沿给定轴进行排序,输出排序好的数据的相应索引,其维度和输入相同  |  
          
| 
             |  
           对输入 x 中的元素进行批量抽样  |  
          
| 
             |  
           沿着指定轴 axis 对输入 x 进行索引  |  
          
| 
             |  
           在指定的轴上查找第 k 小的元素和其对应所在的索引信息  |  
          
| 
             |  
           返回一个 1-D 的 Tensor, Tensor 的值是根据 mask 对输入 x 进行选择的  |  
          
| 
             |  
           返回输入 x 中非零元素的坐标  |  
          
| 
             |  
           对输入变量沿给定轴进行排序,输出排序好的数据,其维度和输入相同  |  
          
| 
             |  
           将根据给定的 values 在 sorted_sequence 的最后一个维度查找合适的索引  |  
          
| 
             |  
           将根据给定的一维 Tensor sorted_sequence 返回输入 x 对应的桶索引。  |  
          
| 
             |  
           沿着可选的 axis 查找 topk 最大或者最小的结果和结果所在的索引信息  |  
          
| 
             |  
           返回一个根据输入 condition, 选择 x 或 y 的元素组成的多维 Tensor  |  
          
tensor 初始化相关¶
API 名称  |  
           API 功能  |  
          
|---|---|
| 
             |  
           将输入 Tensor 或 numpy 数组拷贝至输出 Tensor  |  
          
tensor random 相关¶
API 名称  |  
           API 功能  |  
          
|---|---|
| 
             |  
           以输入 x 为概率,生成一个伯努利分布(0-1 分布)的 Tensor,输出 Tensor 的形状和数据类型与输入 x 相同  |  
          
| 
             |  
           以输入 count 为总实验次数, prob 为实验成功的概率,生成一个二项分布的 Tensor  |  
          
| 
             |  
           返回符合对数正态分布(对应正态分布的均值为 mean ,标准差为 std)的随机 Tensor  |  
          
| 
             |  
           以输入 x 为概率,生成一个多项分布的 Tensor  |  
          
| 
             |  
           返回符合正态分布(均值为 mean ,标准差为 std 的正态随机分布)的随机 Tensor  |  
          
| 
             |  
           返回符合均匀分布的,范围在[0, 1)的 Tensor  |  
          
| 
             |  
           返回服从均匀分布的、范围在[low, high)的随机 Tensor  |  
          
| 
             |  
           返回一个和 x 具有相同形状的服从均匀分布的、范围在[low, high)的随机 Tensor,数据类型为 dtype 或者和 x 相同。  |  
          
| 
             |  
           返回符合标准正态分布(均值为 0,标准差为 1 的正态随机分布)的随机 Tensor  |  
          
| 
             |  
           返回一个数值在 0 到 n-1、随机排列的 1-D Tensor  |  
          
| 
             |  
           设置全局默认 generator 的随机种子  |  
          
| 
             |  
           返回数值服从范围[min, max)内均匀分布的随机 Tensor  |  
          
| 
             |  
           返回符合标准正态分布(均值为 0,标准差为 1 的正态随机分布)的随机 Tensor,形状为 shape,数据类型为 dtype  |  
          
| 
             |  
           返回服从泊松分布的随机 Tensor,输出 Tensor 的形状和数据类型与输入 x 相同  |  
          
tensor 线性代数相关¶
API 名称  |  
           API 功能  |  
          
|---|---|
| 
             |  
           统计输入 Tensor 中元素的出现次数  |  
          
| 
             |  
           对输入 x 及输入 y 进行矩阵相乘  |  
          
| 
             |  
           计算 Tensor x 和 y 在 axis 维度上的向量积(叉积)  |  
          
| 
             |  
           计算 (x-y) 的 p 范数(p-norm)  |  
          
| 
             |  
           计算向量的内积  |  
          
| 
             |  
           计算输入 Tensor 的直方图  |  
          
| 
             |  
           计算输入多维 Tensor 的直方图  |  
          
| 
             |  
           计算两个 Tensor 的乘积,遵循完整的广播规则  |  
          
| 
             |  
           计算矩阵 x 和向量 vec 的乘积  |  
          
| 
             |  
           计算输入 Tensor 的维度(秩)  |  
          
| 
             |  
           对小于等于 2 维的 Tensor 进行数据转置  |  
          
| 
             |  
           返回输入矩阵 input 的下三角部分,其余部分被设为 0  |  
          
| 
             |  
           返回行数和列数已知的二维矩阵中下三角矩阵元素的行列坐标  |  
          
| 
             |  
           返回输入矩阵 input 的上三角部分,其余部分被设为 0  |  
          
| 
             |  
           返回输入矩阵在给定对角线右上三角部分元素坐标  |  
          
| 
             |  
           计算两组输入集合 x, y 中每对之间的 p 范数  |  
          
| 
             |  
           计算输入形状为 N x M 的 Tensor 中 N 个向量两两组合(pairwise)的 p 范数  |  
          
| 
             |  
           计算沿轴的 p 范数  |  
          
tensor 元素操作相关(如:转置,reshape 等)¶
API 名称  |  
           API 功能  |  
          
|---|---|
| 
             |  
           根据 shape 指定的形状广播 x ,广播后, x 的形状和 shape 指定的形状一致  |  
          
| 
             |  
           对一组输入 Tensor 进行广播操作, 输入应符合广播规范  |  
          
| 
             |  
           将输入的 x 的数据类型转换为 dtype 并输出  |  
          
| 
             |  
           将输入 Tensor 分割成多个子 Tensor  |  
          
| 
             |  
           对输入沿 axis 轴进行联结,返回一个新的 Tensor  |  
          
| 
             |  
           根据偏移量(offsets)和形状(shape),裁剪输入(x)Tensor  |  
          
| 
             |  
           根据 shape 指定的形状扩展 x ,扩展后, x 的形状和 shape 指定的形状一致  |  
          
| 
             |  
           根据 y 的形状扩展 x ,扩展后, x 的形状和 y 的形状相同  |  
          
| 
             |  
           根据给定的 start_axis 和 stop_axis 将连续的维度展平  |  
          
| 
             |  
           沿指定轴反转 n 维 tensor  |  
          
| 
             |  
           沿 axes 指定的平面将 n 维 tensor 旋转 90 度 k 次  |  
          
| 
             |  
           根据索引 index 获取输入 x 的指定 axis 维度的条目,并将它们拼接在一起  |  
          
| 
             |  
           paddle.gather 的高维推广  |  
          
| 
             |  
           在保持输入 x 数据不变的情况下,改变 x 的形状  |  
          
| 
             |  
           将输入转换为张量并返回至少为   |  
          
| 
             |  
           将输入转换为张量并返回至少为   |  
          
| 
             |  
           将输入转换为张量并返回至少为   |  
          
| 
             |  
           沿着指定维度 axis 对输入 x 进行循环滚动,当元素移动到最后位置时,会从第一个位置重新插入  |  
          
| 
             |  
           通过基于 updates 来更新选定索引 index 上的输入来获得输出  |  
          
| 
             |  
           根据 index ,将 updates 添加到一个新的张量中,从而得到输出的 Tensor  |  
          
| 
             |  
           通过对 Tensor 中的单个值或切片应用稀疏加法,从而得到输出的 Tensor  |  
          
| 
             |  
           根据分片(shard)的偏移量重新计算分片的索引  |  
          
| 
             |  
           沿多个轴生成 input 的切片  |  
          
| 
             |  
           沿着 axes 将 value 矩阵的值嵌入到 x 矩阵  |  
          
| 
             |  
           将输入 Tensor 分割成多个子 Tensor  |  
          
| 
             |  
           将输入 Tensor 分割成多个子 Tensor,允许不等分  |  
          
| 
             |  
           将输入 Tensor 沿第零个维度分割成多个子 Tensor  |  
          
| 
             |  
           将输入 Tensor 沿第一个维度分割成多个子 Tensor  |  
          
| 
             |  
           将输入 Tensor 沿第二个维度分割成多个子 Tensor  |  
          
| 
             |  
           删除输入 Tensor 的 Shape 中尺寸为 1 的维度  |  
          
| 
             |  
           沿 axis 轴对输入 x 进行堆叠操作  |  
          
| 
             |  
           沿多个轴生成 x 的切片  |  
          
| 
             |  
           根据参数 repeat_times 对输入 x 的各维度进行复制  |  
          
| 
             |  
           根据 perm 对输入的多维 Tensor 进行数据重排  |  
          
| 
             |  
           移动 Tensor 的轴,根据移动之后的轴对输入的多维 Tensor 进行数据重排  |  
          
| 
             |  
           沿多个轴对输入的 x 和 y 进行 Tensor 缩并操作  |  
          
| 
             |  
           将输入 Tensor 按照指定的维度分割成多个子 Tensor  |  
          
| 
             |  
           返回 Tensor 按升序排序后的独有元素  |  
          
| 
             |  
           返回无连续重复元素的 Tensor  |  
          
| 
             |  
           向输入 Tensor 的 Shape 中一个或多个位置(axis)插入尺寸为 1 的维度  |  
          
| 
             |  
           将单个 dim 为 D 的 Tensor 沿 axis 轴 unpack 为 num 个 dim 为 (D-1) 的 Tensor  |  
          
| 
             |  
           将实数 Tensor 转为复数 Tensor  |  
          
| 
             |  
           将复数 Tensor 转为实数 Tensor  |  
          
| 
             |  
           沿 axis 轴对输入 x 的元素进行复制  |  
          
| 
             |  
           沿着指定轴 axis 将 index 中指定位置的 x 与 value 相加,并写入到结果 Tensor 中的对应位置  |  
          
| 
             |  
           构造一个与 x 完全相同的 Tensor,并依据 indices 中指定的索引将 value 的值对应的放置其中,随后输出  |  
          
| 
             |  
           将输入 Tensor 沿指定轴 axis 上的维度展成 shape 形状  |  
          
| 
             |  
           使用特定的 shape、stride、offset,返回 x 的一个 view Tensor  |  
          
| 
             |  
           使用特定的 shape 或者 dtype,返回 x 的一个 view Tensor  |  
          
| 
             |  
           使用 other 的 shape,返回 x 的一个 view Tensor  |  
          
| 
             |  
           返回 x 的一个 view Tensor。以滑动窗口式提取 x 的值  |  
          
| 
             |  
           根据 mask 信息,将 value 中的值填充到 x 中 mask 对应为 True 的位置。  |  
          
| 
             |  
           根据 mask 信息,将 value 中的值逐个填充到 x 中 mask 对应为 True 的位置。  |  
          
| 
             |  
           根据给定的轴 axis 和偏移量 offset,将张量 y 的值填充到张量 x 中  |  
          
| 
             |  
           沿着指定轴 axis 将 index 中指定位置的 x 的值填充为 value  |  
          
| 
             |  
           沿水平轴堆叠输入 x 中的所有张量。  |  
          
| 
             |  
           沿垂直轴堆叠输入 x 中的所有张量。  |  
          
| 
             |  
           沿水平轴堆叠输入 x 中的所有张量。  |  
          
| 
             |  
           沿垂直轴堆叠输入 x 中的所有张量。  |  
          
| 
             |  
           沿深度轴堆叠输入 x 中的所有张量。  |  
          
tensor 元素操作相关原位(inplace)版本¶
API 名称  |  
           API 功能  |  
          
|---|---|
| 
             |  
           Inplace 版本的 index_add API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           依据索引   |  
          
| 
             |  
           Inplace 版本的 reshape API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 scatter API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 squeeze API,对输入 x 采用 Inplace 策略  |  
          
| 
             |  
           Inplace 版本的 unsqueeze API,对输入 x 采用 Inplace 策略  |  
          
爱因斯坦求和¶
API 名称  |  
           API 功能  |  
          
|---|---|
| 
             |  
           根据爱因斯坦标记对多个 Tensor 进行爱因斯坦求和  |  
          
framework 相关¶
API 名称  |  
           API 功能  |  
          
|---|---|
| 
             |  
           一个设备描述符,指定 CPUPlace 则 Tensor 将被自动分配在该设备上,并且模型将会运行在该设备上  |  
          
| 
             |  
           一个设备描述符,它所指代的页锁定内存由 CUDA 函数 cudaHostAlloc() 在主机内存上分配,主机的操作系统将不会对这块内存进行分页和交换操作,可以通过直接内存访问技术访问,加速主机和 GPU 之间的数据拷贝  |  
          
| 
             |  
           一个设备描述符,表示一个分配或将要分配 Tensor 的 GPU 设备  |  
          
| 
             |  
           通过数据并行模式执行动态图模型  |  
          
| 
             |  
           一个设备描述符,指 NCPUPlace 则 Tensor 将被自动分配在该设备上,并且模型将会运行在该设备上  |  
          
| 
             |  
           关闭 Paddle 系统信号处理方法  |  
          
| 
             |  
           关闭静态图模式  |  
          
| 
             |  
           创建一个上下文来启用动态图梯度计算  |  
          
| 
             |  
           开启静态图模式  |  
          
| 
             |  
           得到当前全局的 dtype  |  
          
| 
             |  
           获取指定设备的随机数生成器的所有随机状态。  |  
          
| 
             |  
           对于每个 inputs ,计算所有 outputs 相对于其的梯度和  |  
          
| 
             |  
           查看 paddle 当前是否在动态图模式中运行  |  
          
| 
             |  
           用于设置模型(继承自   |  
          
| 
             |  
           从指定路径载入可以在 paddle 中使用的对象实例  |  
          
| 
             |  
           创建一个上下文来禁用动态图梯度计算  |  
          
| 
             |  
           创建一个参数属性对象  |  
          
| 
             |  
           将对象实例 obj 保存到指定的路径中  |  
          
| 
             |  
           设置默认的全局 dtype。  |  
          
| 
             |  
           设置默认的全局设备生成器状态。  |  
          
| 
             |  
           创建启用或禁用动态图梯度计算的上下文  |  
          
| 
             |  
           判断当前动态图下是否启用了计算梯度模式。  |  
          
| 
             |  
           设置 paddle 中 Tensor 的打印配置选项  |  
          
device 相关¶
API 名称  |  
           API 功能  |  
          
|---|---|
| 
             |  
           获取 cuda 随机数生成器的状态信息  |  
          
| 
             |  
           设置 cuda 随机数生成器的状态信息  |  
          
高层 API 相关¶
API 名称  |  
           API 功能  |  
          
|---|---|
| 
             |  
           一个具备训练、测试、推理的神经网络  |  
          
| 
             |  
           打印网络的基础结构和参数信息  |  
          
| 
             |  
           打印网络的基础结构和参数信息  |  
          
环境变量 FLAGS 相关¶
API 名称  |  
           API 功能  |  
          
|---|---|
| 
             |  
           获取指定的 Paddle 环境变量 FLAGS 状态。详情请查看 环境变量 FLAGS  |  
          
| 
             |  
           设置 Paddle 环境变量 FLAGS,详情请查看 环境变量 FLAGS  |