add/update func avg_pool1d avg_pool2d avg_pool3d doc

add func blackman_window doc add func bounding_box_decode bounding_box_encode doc add func expand doc add tensor to/bool/float/half/int/long doc add tensor expand doc add func check_valid/cholesky/cholesky_inverse doc add tensor cholesky/cholesky_inverse doc
2022-10-19 14:06:30 +08:00 · 2022-10-19 14:06:30 +08:00 · 763dee47b7
parent 9986f13a48
commit 763dee47b7
21 changed files with 430 additions and 26 deletions
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.bool.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.bool.rst
@ -0,0 +1,9 @@
+mindspore.Tensor.bool
+=====================
+
+.. py:method:: mindspore.Tensor.bool()
+
+    将输入Tensor转换为 `bool` 类型，其中Tensor中的值为0时，则为False；非0时，则为True。
+
+    返回：
+        Tensor，其数据类型为 `bool`。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.cholesky.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.cholesky.rst
@ -0,0 +1,28 @@
+mindspore.Tensor.cholesky
+=========================
+
+.. py:method:: mindspore.Tensor.cholesky(upper=False)
+
+   计算对称正定矩阵 :math:`A` 或对称正定矩阵批次的Cholesky分解。
+
+    如果 `upper` 为True，则返回的矩阵 :math:`U` 为上三角矩阵，分解形式为：
+
+    .. math::
+        A = U^TU
+
+    如果 `upper` 为False，则返回的矩阵 :math:`L` 为下三角矩阵，分解形式为：
+
+    .. math::
+        A = LL^T
+
+    参数：
+        - **upper** (bool) - 返回上三角矩阵/下三角矩阵的标志。True为上三角矩阵，False为下三角矩阵。默认值：False。
+
+    返回：
+        Tensor，shape和数据类型与输入相同。
+
+    异常：
+        - **TypeError** - 如果 `upper` 不是bool。
+        - **TypeError** - 当前Tensor的数据类型既不是float32，也不是float64。
+        - **ValueError** - 当前Tensor不是批处理方。
+        - **ValueError** - 如果Tensor不是对称正定矩阵。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.cholesky_inverse.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.cholesky_inverse.rst
@ -0,0 +1,29 @@
+mindspore.Tensor.cholesky_inverse
+=================================
+
+.. py:method:: mindspore.Tensor.cholesky_inverse(upper=False)
+
+    计算对称正定矩阵的逆矩阵。
+
+    如果 `upper` 为False，则返回的矩阵 :math:`U` 为下三角矩阵，输出的结果：
+
+    .. math::
+        inv = (UU^{T})^{-1}
+
+    如果 `upper` 为True，则返回的矩阵 :math:`U` 为上三角矩阵，输出的结果：
+
+    .. math::
+        inv = (U^{T}U)^{-1}
+
+    .. note::
+       当前Tensor必须是一个上三角矩阵或者下三角矩阵。
+
+    参数：
+        - **upper** (bool) - 返回上三角矩阵/下三角矩阵的标志。True为上三角矩阵，False为下三角矩阵。默认值：False。
+
+    返回：
+        Tensor，shape和数据类型与输入相同。
+
+    异常：
+        - **TypeError** - 当前Tensor的数据类型既不是float32，也不是float64。
+        - **ValueError** - 当前Tensor的维度不等于2。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.expand.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.expand.rst
@ -0,0 +1,23 @@
+mindspore.Tensor.expand
+=======================
+
+.. py:method:: mindspore.Tensor.expand(size)
+
+    返回一个当前Tensor的新视图，其中单维度扩展到更大的尺寸。
+
+    .. note::
+        将 `-1` 作为维度的 `size` 意味着不更改该维度的大小。张量也可以扩展到更大的维度，新的维度会附加在前面。对于新的维度，`size` 不能设置为-1。
+
+    参数：
+        - **size** (Tensor) - Tensor的新shape。
+
+    返回：
+        Tensor，其大小为 `size` 。
+
+    异常：
+        - **TypeError** - 如果 `size` 的数据类型不是int16、int32或int64。
+        - **ValueError** - 如果 `size` 的长度小于当前Tensor的shape的大小。
+        - **ValueError** - 如果 `size` 不是一个1D Tensor。
+        - **ValueError** - 如果 `size` 不等于 维度不为1的当前Tensor的shape。
+        - **ValueError** - 如果 `size` 小于0。
+        - **ValueError** - 如果输出的元素数量超过1000000。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.float.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.float.rst
@ -0,0 +1,9 @@
+mindspore.Tensor.float
+======================
+
+.. py:method:: mindspore.Tensor.float()
+
+    将输入Tensor转换为 `float32` 类型。
+
+    返回：
+        Tensor，其数据类型为 `float32`。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.half.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.half.rst
@ -0,0 +1,9 @@
+mindspore.Tensor.half
+=====================
+
+.. py:method:: mindspore.Tensor.half()
+
+    将输入Tensor转换为 `float16` 类型。
+
+    返回：
+        Tensor，其数据类型为 `float16`。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.int.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.int.rst
@ -0,0 +1,9 @@
+mindspore.Tensor.int
+====================
+
+.. py:method:: mindspore.Tensor.int()
+
+    将输入Tensor转换为 `int32` 类型，其中Tensor中的值为浮点数时，则会丢弃小数部分。
+
+    返回：
+        Tensor，其数据类型为 `int32`。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.long.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.long.rst
@ -0,0 +1,9 @@
+mindspore.Tensor.long
+=====================
+
+.. py:method:: mindspore.Tensor.long()
+
+    将输入Tensor转换为 `int64` 类型，其中Tensor中的值为浮点数时，则会丢弃小数部分。
+
+    返回：
+        Tensor，其数据类型为 `int64`。
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.to.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.to.rst
@ -0,0 +1,15 @@
+mindspore.Tensor.to
+===================
+
+.. py:method:: mindspore.Tensor.to(dtype)
+
+    执行Tensor类型的转换。
+
+    参数：
+        - **dtype** (dtype.Number) - 输出张量的有效数据类型，只允许常量值。
+
+    返回：
+        Tensor，其数据类型为 `dtype`。
+
+    异常：
+        - **TypeError** -如果 `dtype` 不是数值类型。
--- a/docs/api/api_python/ops/mindspore.ops.func_avg_pool1d.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_avg_pool1d.rst
@ -0,0 +1,37 @@
+mindspore.ops.avg_pool1d
+========================
+
+.. py:function:: mindspore.ops.avg_pool1d(input_x, kernel_size=1, stride=1, padding=0, ceil_mode=False, count_include_pad=True)
+
+    对输入的多维数据进行一维平均池化运算。
+
+    在输入Tensor上应用1D average pooling，可被视为1D输入平面。
+
+    一般地，输入的shape为 :math:`(N_{in}, C_{in}, L_{in})` ，输出 :math:`(L_{in})` 维度的区域平均值。给定 `kernel_size` 为 :math:`ks = l_{ker}` 和 `stride` 为 :math:`s = s_0` ，运算如下：
+
+    .. math::
+        \text{output}(N_i, C_j, l) = \frac{1}{l_{ker}} \sum_{n=0}^{l_{ker}-1}
+        \text{input}(N_i, C_j, s_0 \times l + n)
+
+    .. warning::
+        - `kernel_size` 取值为[1, 255]范围内的正整数，`stride` 的取值为[1, 63]范围内的正整数。
+
+    参数：
+        - **input_x** (Tensor) - 输入shape为 :math:`(N, C_{in}, L_{in})` 的Tensor。
+        - **kernel_size** (int) - 指定池化核尺寸大小。默认值：1。
+        - **stride** (int) - 池化操作的移动步长，可以是单个整数表示高度和宽度方向的移动步长，或者整数tuple分别表示高度和宽度方向的移动步长。默认值：1。
+        - **padding** (Union(int, tuple[int])) - 池化填充长度。可以是一个整数表示在左右方向的填充长度，或者包含两个整数的tuple，分别表示在左右方向的填充长度。默认值：0。
+        - **ceil_mode** (bool) - 如果为True，用ceil代替floor来计算输出的shape。默认值：False。
+        - **count_include_pad** (bool) - 如果为True，平均计算将包括零填充。默认值：True。
+
+    返回：
+        Tensor，shape为 :math:`(N, C_{out}, L_{out})` 。
+
+    异常：
+        - **TypeError** - `input_x` 不是一个Tensor。
+        - **TypeError** - `kernel_size` 或 `stride` 不是int。
+        - **TypeError** - `ceil_mode` 或 `count_include_pad` 不是bool。
+        - **ValueError** - `input_x` 的shape长度不等于3。
+        - **ValueError** - `kernel_size` 或 `stride` 小于1。
+        - **ValueError** - `padding` 不是int或者tuple的长度不等于2。
+        - **ValueError** - `padding` 的值小于0。
--- a/docs/api/api_python/ops/mindspore.ops.func_avg_pool2d.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_avg_pool2d.rst
@ -1,40 +1,40 @@
 mindspore.ops.avg_pool2d
 ========================

-.. py:function:: mindspore.ops.avg_pool2d(x, kernel_size=1, strides=1, pad_mode='valid', data_format='NCHW')
+.. py:function:: mindspore.ops.avg_pool2d(input_x, kernel_size=1, stride=1, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=0)

    对输入的多维数据进行二维平均池化运算。

    在输入Tensor上应用2D average pooling，可被视为2D输入平面。

-    一般地，输入的shape为 :math:`(N_{in}, C_{in}, H_{in}, W_{in})` ，输出 :math:`(H_{in}, W_{in})` 维度的区域平均值。给定 `kernel_size` 为 :math:`(k_{h}, k_{w})` 和 `strides` ，运算如下：
+    一般地，输入的shape为 :math:`(N_{in}, C_{in}, H_{in}, W_{in})` ，输出 :math:`(H_{in}, W_{in})` 维度的区域平均值。给定 `kernel_size` 为 :math:`(k_{h}, k_{w})` 和 `stride` ，运算如下：

    .. math::
        \text{output}(N_i, C_j, h, w) = \frac{1}{k_{h} * k_{w}} \sum_{m=0}^{k_{h}-1} \sum_{n=0}^{k_{w}-1}
-        \text{input}(N_i, C_j, strides[0] \times h + m, strides[1] \times w + n)
+        \text{input}(N_i, C_j, stride[0] \times h + m, stride[1] \times w + n)

    .. warning::
-        - 支持全局池化。
-        - 在Ascend上，`kernel_size` 的高度和宽度取值为[1, 255]范围内的正整数。其高度和宽度相乘小于256。
-        - 由于指令限制，`strides` 的取值为[1, 63]范围内的正整数。
+        - `kernel_size` 取值为[1, 255]范围内的正整数，`stride` 的取值为[1, 63]范围内的正整数。

    参数：
-        - **x** (Tensor) - 输入shape为 :math:`(N, C_{in}, H_{in}, W_{in})` 的Tensor。
+        - **input_x** (Tensor) - 输入shape为 :math:`(N, C_{in}, H_{in}, W_{in})` 的Tensor。
        - **kernel_size** (Union[int, tuple[int]]) - 指定池化核尺寸大小，可以是单个整数表示池化核高度和宽度，或者整数tuple分别表示池化核高度和宽度。默认值：1。
-        - **strides** (Union[int, tuple[int]]) - 池化操作的移动步长，可以是单个整数表示高度和宽度方向的移动步长，或者整数tuple分别表示高度和宽度方向的移动步长。默认值：1。
-        - **pad_mode** (str) - 指定池化填充模式，取值为'same'或'valid'，不区分大小写。默认值：'valid'。
-
-          - **same** - 输出的高度和宽度分别与输入向上整除 `strides` 后的值相同。
-          - **valid** - 在不填充的前提下返回有效计算所得的输出。不满足计算的多余像素会被丢弃。
-
-        - **data_format** (str) - 指定输入和输出的数据格式。取值为'NHWC'或'NCHW'。默认值：'NCHW'。
+        - **stride** (Union[int, tuple[int]]) - 池化操作的移动步长，可以是单个整数表示高度和宽度方向的移动步长，或者整数tuple分别表示高度和宽度方向的移动步长。默认值：1。
+        - **padding** (Union(int, tuple[int])) - 池化填充长度。可以是一个整数表示在上下左右方向的填充长度，或者包含四个整数的tuple，分别表示在上下左右方向的填充长度。默认值：0。
+        - **ceil_mode** (bool) - 如果为True，用ceil代替floor来计算输出的shape。默认值：False。
+        - **count_include_pad** (bool) - 如果为True，平均计算将包括零填充。默认值：True。
+        - **divisor_override** (int) - 如果指定了该值，它将在平均计算中用作除数，否则将使用 `kernel_size` 作为除数。默认值：0。

    返回：
-        Tensor，shape为 :math:`(N,C_{out},H_{out},W_{out})` 。
+        Tensor，shape为 :math:`(N, C_{out}, H_{out}, W_{out})` 。

    异常：
-        - **TypeError** - `kernel_size` 或 `strides` 既不是int也不是tuple。
-        - **ValueError** - `kernel_size` 或 `strides` 小于1。
-        - **ValueError** - `pad_mode` 既不是'valid'，也不是'same'，不区分大小写。
-        - **ValueError** - `data_format` 既不是'NCHW'也不是'NHWC'。
-        - **ValueError** - `x` 的shape长度不等于4。
+        - **TypeError** - `input_x` 不是一个Tensor。
+        - **TypeError** - `kernel_size` 或 `stride` 既不是int也不是tuple。
+        - **TypeError** - `ceil_mode` 或 `count_include_pad` 不是bool。
+        - **TypeError** - `divisor_override` 不是int。
+        - **ValueError** - `input_x` 的shape长度不等于4。
+        - **ValueError** - `kernel_size` 或 `stride` 小于1。
+        - **ValueError** - `kernel_size` 或 `stride` 是长度不等于2的tuple。
+        - **ValueError** - `padding` 不是int或者tuple的长度不等于4。
+        - **ValueError** - `padding` 的值小于0。
--- a/docs/api/api_python/ops/mindspore.ops.func_avg_pool3d.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_avg_pool3d.rst
@ -0,0 +1,41 @@
+mindspore.ops.avg_pool3d
+========================
+
+.. py:function:: mindspore.ops.avg_pool3d(input_x, kernel_size=1, stride=1, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=0)
+
+    对输入的多维数据进行三维平均池化运算。
+
+    在输入Tensor上应用3D average pooling，可被视为3D输入平面。
+
+    一般地，输入的shape为 :math:`(N, C, D_{in}, H_{in}, W_{in})` ，输出 :math:`(D_{in}, H_{in}, W_{in})` 维度的区域平均值。给定 `kernel_size` 为 :math:`ks = (d_{ker}, h_{ker}, w_{ker})` 和 `stride` 为 :math:`s = (s_0, s_1, s_2)`，运算如下：
+
+    .. math::
+        \text{output}(N_i, C_j, d, h, w) =
+        \frac{1}{d_{ker} * h_{ker} * w_{ker}} \sum_{l=0}^{d_{ker}-1} \sum_{m=0}^{h_{ker}-1} \sum_{n=0}^{w_{ker}-1}
+        \text{input}(N_i, C_j, s_0 \times d + l, s_1 \times h + m, s_2 \times w + n)
+
+    .. warning::
+        - `kernel_size` 取值为[1, 255]范围内的正整数，`stride` 的取值为[1, 63]范围内的正整数。
+
+    参数：
+        - **input_x** (Tensor) - 输入shape为 :math:`(N, C, D_{in}, H_{in}, W_{in})` 的Tensor，数据类型为float16和float32。
+        - **kernel_size** (Union[int, tuple[int]]) - 指定池化核尺寸大小，可以是单个整数表示池化核深度、高度、宽度，或者整数tuple分别表示池化核深度、高度、宽度。默认值：1。
+        - **stride** (Union[int, tuple[int]]) - 池化操作的移动步长，可以是单个整数表示深度、高度、宽度方向的移动步长，或者整数tuple分别表示深度、高度、深度方向的移动步长。默认值：1。
+        - **padding** (Union(int, tuple[int])) - 池化填充长度。可以是一个整数表示在头尾上下左右方向的填充长度，或者包含六个整数的tuple，分别表示在头尾上下左右方向的填充长度。默认值：0。
+        - **ceil_mode** (bool) - 如果为True，用ceil代替floor来计算输出的shape。默认值：False。
+        - **count_include_pad** (bool) - 如果为True，平均计算将包括零填充。默认值：True。
+        - **divisor_override** (int) - 如果指定了该值，它将在平均计算中用作除数，否则将使用 `kernel_size` 作为除数。默认值：0。
+
+    返回：
+        Tensor，shape为 :math:`(N, C, D_{out}, H_{out}, W_{out})` ，数据类型与 `input_x` 一致。
+
+    异常：
+        - **TypeError** - `input_x` 不是一个Tensor。
+        - **TypeError** - `kernel_size` 或 `stride` 或 `padding` 既不是int也不是tuple。
+        - **TypeError** - `ceil_mode` 或 `count_include_pad` 不是bool。
+        - **TypeError** - `divisor_override` 不是int。
+        - **ValueError** - `input_x` 的shape长度不等于5。
+        - **ValueError** - `kernel_size` 或 `stride` 的值不是正整数。
+        - **ValueError** - `kernel_size` 或 `stride` 是长度不等于3的tuple。
+        - **ValueError** - `padding` 是tuple时，其长度不等于6。
+        - **ValueError** - `padding` 的值小于0。
--- a/docs/api/api_python/ops/mindspore.ops.func_blackman_window.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_blackman_window.rst
@ -0,0 +1,29 @@
+mindspore.ops.blackman_window
+=============================
+
+.. py:function:: mindspore.ops.blackman_window(window_length, periodic=True, dtype=mstype.float32)
+
+    布莱克曼窗口函数。
+
+    `window_length` 是一个Tensor，控制返回的窗口大小，其数据类型必须是整数。特别的，当 `window_length` 为1时，返回的窗口只包含一个值，为 `1` 。`periodic` 决定返回的窗口是否会删除对称窗口的最后一个重复值，并准备用作带函数的周期窗口。因此，如果 `periodic` 为True，the :math:`N` 为 :math:`window\_length + 1`。
+
+    .. math::
+        w[n] = 0.42 - 0.5 cos(\frac{2\pi n}{N - 1}) + 0.08 cos(\frac{4\pi n}{N - 1})
+
+        \text{where : N is the full window size.}
+
+    参数：
+        - **window_length** (Tensor) - 返回窗口的大小，数据类型为int32，int64。输入数据的值为[0,1000000]的整数。
+        - **periodic** (bool) - 如果为True，返回一个窗口作为周期函数使用。如果为False，返回一个对称窗口。默认值：True。
+        - **dtype** (mindspore.dtype) - 输出数据类型，目前只支持float16、float32和float64。默认值：mindspore.float32。
+
+    返回：
+        1D Tensor，大小为 `window_length` ，数据类型与 `dtype` 一致。
+
+    异常：
+        - **TypeError** - `window_length` 不是Tensor。
+        - **TypeError** - `periodic` 不是bool。
+        - **TypeError** - `dtype` 不是float16、float32、float64。
+        - **TypeError** - `window_length` 的数据类型不是int32、int64。
+        - **ValueError** - `window_length` 的值不在[0, 1000000]。
+        - **ValueError** - `window_length` 的维度不等于0。
--- a/docs/api/api_python/ops/mindspore.ops.func_bounding_box_decode.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_bounding_box_decode.rst
@ -0,0 +1,24 @@
+mindspore.ops.bounding_box_decode
+=================================
+
+.. py:function:: mindspore.ops.bounding_box_decode(anchor_box, deltas, max_shape, means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0), wh_ratio_clip=0.016)
+
+    解码边界框位置信息。
+
+    算子的功能是计算偏移量，此算子将偏移量转换为Bbox，用于在后续图像中标记目标等。
+
+    参数：
+        - **anchor_box** (Tensor) - 锚框。锚框的shape必须为 :math:`(n, 4)` 。
+        - **deltas** (Tensor) - 框的增量。它的shape与 `anchor_box` 相同。
+        - **means** (tuple) - 计算 `deltas` 的均值。默认值：（0.0, 0.0, 0.0, 0.0, 0.0）。
+        - **stds** (tuple) - 计算 `deltas` 的标准差。默认值：（1.0, 1.0, 1.0, 1.0）。
+        - **max_shape** (tuple) - 解码框计算的上限值。
+        - **wh_ratio_clip** (float) - 解码框计算的宽高比限制。默认值：0.016。
+
+    返回：
+        Tensor，解码框。它的数据类型和shape与 `anchor_box` 相同。
+
+    异常：
+        - **TypeError** - 如果 `means` 、 `stds` 或 `max_shape` 不是tuple。
+        - **TypeError** - 如果 `wh_ratio_clip` 不是float。
+        - **TypeError** - 如果 `anchor_box` 或 `deltas` 不是Tensor。
--- a/docs/api/api_python/ops/mindspore.ops.func_bounding_box_encode.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_bounding_box_encode.rst
@ -0,0 +1,21 @@
+mindspore.ops.bounding_box_encode
+=================================
+
+.. py:function:: mindspore.ops.bounding_box_encode(anchor_box, groundtruth_box, means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0))
+
+    编码边界框位置信息。
+
+    算子的功能是计算预测边界框和真实边界框之间的偏移，并将此偏移作为损失变量。
+
+    参数：
+        - **anchor_box** (Tensor) - 锚框。锚框的shape必须为 :math:`(n, 4)` 。
+        - **groundtruth_box** (Tensor) - 真实边界框。它的shape与锚框相同。
+        - **means** (tuple) - 计算编码边界框的均值。默认值：（0.0, 0.0, 0.0, 0.0, 0.0）。
+        - **stds** (tuple) - 计算增量的标准偏差。默认值：（1.0、1.0、1.0、1.0）。
+
+    返回：
+        Tensor，编码边界框。数据类型和shape与输入 `anchor_box` 相同。
+
+    异常：
+        - **TypeError** - 如果 `means` 或 `stds` 不是tuple。
+        - **TypeError** - 如果 `anchor_box` 或 `groundtruth_box` 不是Tensor。
--- a/docs/api/api_python/ops/mindspore.ops.func_check_valid.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_check_valid.rst
@ -0,0 +1,22 @@
+mindspore.ops.check_valid
+=========================
+
+.. py:function:: mindspore.ops.check_valid(bboxes, img_metas)
+
+    检查边界框。
+
+    检查边界框的交叉数据和数据边界是否有效。
+
+    .. warning::
+        指定有效边界 `(长度 * 比率, 宽度 * 比率)` 。
+
+    参数：
+        - **bboxes** (Tensor) - shape大小为 :math:`(N, 4)` 。:math:`N` 表示边界框的数量， `4` 表示 `x0` 、`x1` 、`y0` 、`y` 。数据类型必须是float16或float32。
+        - **img_metas** (Tensor) - 原始图片的信息 `(长度, 宽度, 比率)` ，需要指定有效边界为 `(长度 * 比率, 宽度 * 比率)` 。数据类型必须是float16或float32。
+        
+    返回：
+        Tensor，shape为 :math:`(N,)` ，类型为bool，需要指出边界框是否在图片内。`True` 表示在，`False` 表示不在。
+
+    异常：
+        - **TypeError** - 如果 `bboxes` 或者 `img_metas` 不是Tensor。
+        - **TypeError** - 如果 `bboxes` 或者 `img_metas` 的数据类型既不是float16，也不是float32。
--- a/docs/api/api_python/ops/mindspore.ops.func_cholesky.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_cholesky.rst
@ -0,0 +1,30 @@
+mindspore.ops.cholesky
+======================
+
+.. py:function:: mindspore.ops.cholesky(input_x, upper=False)
+
+    计算对称正定矩阵 :math:`A` 或对称正定矩阵批次的Cholesky分解。
+
+    如果 `upper` 为True，则返回的矩阵 :math:`U` 为上三角矩阵，分解形式为：
+
+    .. math::
+        A = U^TU
+
+    如果 `upper` 为False，则返回的矩阵 :math:`L` 为下三角矩阵，分解形式为：
+   
+    .. math::
+        A = LL^T 
+
+    参数：
+        - **input_x** (Tensor) - shape大小为 :math:`(*, N, N)` ，其中 :math:`*` 是零个或多个由对称正定矩阵组成的批处理维，数据类型为float32或float64。
+        - **upper** (bool) - 是否返回上三角矩阵还是下三角矩阵的标志。默认值：False。
+
+    返回：
+        Tensor，shape和数据类型与 `input_x` 相同。
+
+    异常：
+        - **TypeError** - 如果 `upper` 不是bool。
+        - **TypeError** - 如果 `input_x` 的数据类型既不是float32，也不是float64。
+        - **TypeError** - 如果 `input_x` 不是Tensor。
+        - **ValueError** - 如果 `input_x` 不是批处理方。
+        - **ValueError** - 如果 `input_x` 不是对称正定矩阵。
--- a/docs/api/api_python/ops/mindspore.ops.func_cholesky_inverse.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_cholesky_inverse.rst
@ -0,0 +1,31 @@
+mindspore.ops.cholesky_inverse
+==============================
+
+.. py:function:: mindspore.ops.cholesky_inverse(input_x, upper=False)
+
+    计算对称正定矩阵的逆矩阵。
+
+    如果 `upper` 为False，则返回的矩阵 :math:`U` 为下三角矩阵，输出的结果：
+
+    .. math::
+        inv = (UU^{T})^{-1}
+
+    如果 `upper` 为True，则返回的矩阵 :math:`U` 为上三角矩阵，输出的结果：
+   
+    .. math::
+        inv = (U^{T}U)^{-1}
+
+    .. note::
+       输入Tensor必须是一个上三角矩阵或者下三角矩阵。    
+
+    参数：
+        - **input_x** (Tensor) - 输入Tensor，数据类型为float32或float64。
+        - **upper** (bool) - 是否返回上三角矩阵还是下三角矩阵的标志。默认值：False。
+
+    返回：
+        Tensor，shape和数据类型与 `input_x` 相同。
+
+    异常：
+        - **TypeError** - 如果 `input_x` 不是Tensor。
+        - **TypeError** - 如果 `input_x` 的数据类型既不是float32，也不是float64。
+        - **ValueError** - 如果 `input_x` 的维度不等于2。
--- a/docs/api/api_python/ops/mindspore.ops.func_expand.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_expand.rst
@ -0,0 +1,26 @@
+mindspore.ops.expand
+====================
+
+.. py:function:: mindspore.ops.expand(input_x, size)
+
+    返回一个当前张量的新视图，其中单维度扩展到更大的尺寸。
+
+    .. note::
+        将 `-1` 作为维度的 `size` 意味着不更改该维度的大小。张量也可以扩展到更大的维度，新的维度会附加在前面。对于新的维度，`size` 不能设置为-1。
+
+    参数：
+        - **input_x** (Tensor) - 输入Tensor，shape为 :math:`(x_1, x_2, ..., x_R)` 。
+        - **size** (Tensor) - `input_x` 的新shape大小。
+
+    返回：
+        Tensor，其大小为 `size` 。
+
+    异常：
+        - **TypeError** - 如果 `input_x` 或者 `size` 不是Tensor。
+        - **TypeError** - 如果 `size` 的数据类型不是int16、int32或int64。
+        - **ValueError** - 如果 `size` 的长度小于 `input_x` shape的大小。
+        - **ValueError** - 如果 `size` 不是一个1D Tensor。
+        - **ValueError** - 如果 `size` 不等于 维度不为1的 `input_x` 的shape。
+        - **ValueError** - 如果 `size` 小于0。
+        - **ValueError** - 如果输出的元素数量超过1000000。
+       
--- a/mindspore/python/mindspore/common/tensor.py
+++ b/mindspore/python/mindspore/common/tensor.py
@ -5973,6 +5973,7 @@ class Tensor(Tensor_):
    def bool(self):
        r"""
        Converts input tensor dtype to `bool`.
+        If the value in tensor is zero, it will be `False`, otherwise it will be `True`.

        Returns:
            Tensor, converted to the `bool` dtype.
@ -6032,7 +6033,7 @@ class Tensor(Tensor_):

    def int(self):
        r"""
-        Converts input tensor dtype to `int32`.
+        Converts input tensor dtype to `int32`. If the value in tensor is float or half, the decimal will be discarded.

        Returns:
            Tensor, converted to the `int32` dtype.
@ -6052,7 +6053,7 @@ class Tensor(Tensor_):

    def long(self):
        r"""
-        Converts input tensor dtype to `int64`.
+        Converts input tensor dtype to `int64`. If the value in tensor is float or half, the decimal will be discarded.

        Returns:
            Tensor, converted to the `int64` dtype.
@ -6374,6 +6375,8 @@ class Tensor(Tensor_):

    def expand(self, size):
        r"""
+        Returns a new view of the self tensor with singleton dimensions expanded to a larger size.
+
        Note:
            Passing -1 as the `size` for a dimension means not changing the size of that dimension. Tensor can be
            also expanded to a larger number of dimensions, and the new ones will be appended at the front.
--- a/mindspore/python/mindspore/ops/function/nn_func.py
+++ b/mindspore/python/mindspore/ops/function/nn_func.py
@ -225,8 +225,8 @@ def avg_pool1d(input_x, kernel_size=1, stride=1, padding=0, ceil_mode=False, cou
        padding (Union(int, tuple[int])): The pad value to be filled. If `padding` is an integer, the paddings of left
            and right are the same, equal to pad. If `padding` is a tuple of `2` integers, the padding of left and right
            equal to `padding[0]` and `padding[1]` correspondingly. Default: 0.
-        ceil_mode: If True, apply ceil instead of floor to compute the output shape. Default: False.
-        count_include_pad: If True, include the zero-padding in the averaging calculation. Default: True.
+        ceil_mode (bool): If True, apply ceil instead of floor to compute the output shape. Default: False.
+        count_include_pad (bool): If True, include the zero-padding in the averaging calculation. Default: True.

    Outputs:
        Tensor of shape :math:`(N, C_{out}, L_{out})`.
@ -318,8 +318,8 @@ def avg_pool2d(input_x, kernel_size=1, stride=1, padding=0, ceil_mode=False, cou
            paddings of top, bottom, left and right are the same, equal to pad. If `padding` is a tuple of `4` integers,
            the padding of top, bottom, left and right equal to `padding[0]`, `padding[1]`, `padding[2]` and
            `padding[3]` correspondingly. Default: 0.
-        ceil_mode: If True, apply ceil instead of floor to compute the output shape. Default: False.
-        count_include_pad: If True, include the zero-padding in the averaging calculation. Default: True.
+        ceil_mode (bool): If True, apply ceil instead of floor to compute the output shape. Default: False.
+        count_include_pad (bool): If True, include the zero-padding in the averaging calculation. Default: True.
        divisor_override (int): If specified, it will be used as divisor in the averaging calculation, otherwise
            `kernel_size` will be used. Default: 0.