深入浅出PaddlePaddle函数——paddle.arange

分类目录：《深入浅出PaddlePaddle函数》总目录
相关文章：
· 深入浅出TensorFlow2函数——tf.range
· 深入浅出Pytorch函数——torch.arange
· 深入浅出PaddlePaddle函数——paddle.arange

语法

paddle.arange(start=0, end=None, step=1, dtype=None, name=None)

当dtype表示浮点类型时，为了避免浮点计算误差，建议给end加上一个极小值epsilon，使边界可以更加明确。

返回值

返回以步长step均匀分隔给定数值区间[start , end)的一维张量，数据类型为dtype。

参数

• start： [float/int/Tensor] 区间起点（且区间包括此值）。当start类型是Tensor时，则应为形状为[1]且数据类型为int32、int64、float32、float64的Tensor。如果仅指定start，而end为None，则区间为。默认值为。
• end：[可选，float/int/Tensor] 区间终点（且通常区间不包括此值）。当end类型是Tensor时，是形状为[1]且数据类型为int32、int64、float32、float64的Tensor。默认值为None。
• step：[可选，float/int/Tensor] 均匀分割的步长。当step类型是Tensor时，是形状为[1]且数据类型为int32、int64、float32、float64的Tensor。默认值为。
• dtype： [可选，str/np.dtype] 输出Tensor的数据类型，支持int32、int64、float32、float64。当该参数值为None时，输出Tensor的数据类型为int64。默认值为None。
• name： [可选，str] 具体用法参见Name，一般无需设置，默认值为None。

实例

import paddle

out1 = paddle.arange(5)              # [0, 1, 2, 3, 4]
out2 = paddle.arange(3, 9, 2.0)      # [3, 5, 7]

# use 4.999 instead of 5.0 to avoid floating point rounding errors
out3 = paddle.arange(4.999, dtype='float32')
# [0., 1., 2., 3., 4.]

start_var = paddle.to_tensor([3])
out4 = paddle.arange(start_var, 7)
# [3, 4, 5, 6]

函数实现

def arange(start=0, end=None, step=1, dtype=None, name=None):
    """
    Returns a 1-D Tensor with spaced values within a given interval.
    Values are generated into the half-open interval [``start``, ``end``) with
    the ``step``. (the interval including ``start`` but excluding ``end``).
    If ``dtype`` is float32 or float64, we advise adding a small epsilon to
    ``end`` to avoid floating point rounding errors when comparing against ``end``.
    Parameters:
        start(float|int|Tensor): Start of interval. The interval includes this
            value. If ``end`` is None, the half-open interval is [0, ``start``).
            If ``start`` is a Tensor, it is a 1-D Tensor with shape [1], with
            data type int32, int64, float32, float64. Default is 0.
        end(float|int|Tensor, optional): End of interval. The interval does not
            include this value. If ``end`` is a Tensor, it is a 1-D Tensor with
            shape [1], with data type int32, int64, float32, float64. If ``end``
            is None, the half-open interval is [0, ``start``). Default is None.
        step(float|int|Tensor, optional): Spacing between values. For any out,
            it is the istance between two adjacent values, out[i+1] - out[i].
            If ``step`` is a Tensor, it is a 1-D Tensor with shape [1], with
            data type int32, int64, float32, float64. Default is 1.
        dtype(str|np.dtype, optional): The data type of the
            output tensor. Supported data types: int32, int64, float32, float64.
            If ``dytpe`` is None, the data type is float32. Default is None.
        name (str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None.
    Returns:
        Tensor: A 1-D Tensor with values from the interval [``start``, ``end``)
        taken with common difference ``step`` beginning from ``start``. Its
        data type is set by ``dtype``.
    Examples:
        .. code-block:: python
            import paddle
            out1 = paddle.arange(5)
            # [0, 1, 2, 3, 4]
            out2 = paddle.arange(3, 9, 2.0)
            # [3, 5, 7]
            # use 4.999 instead of 5.0 to avoid floating point rounding errors
            out3 = paddle.arange(4.999, dtype='float32')
            # [0., 1., 2., 3., 4.]
            start_var = paddle.to_tensor([3])
            out4 = paddle.arange(start_var, 7)
            # [3, 4, 5, 6]
    """
    if dtype is None:
        dtype = 'int64'
    if end is None:
        end = start
        start = 0

    out_shape = None
    if (
        not isinstance(start, Variable)
        and not isinstance(end, Variable)
        and not isinstance(step, Variable)
    ):
        out_shape = [int(math.ceil((end - start) / step))]

    if not isinstance(dtype, core.VarDesc.VarType):
        dtype = convert_np_dtype_to_dtype_(dtype)

    if not isinstance(start, Variable):
        with device_guard("cpu"):
            start = fill_constant([1], dtype, start, force_cpu=True)
    elif start.dtype != dtype:
        start = paddle.cast(start, dtype)

    if not isinstance(end, Variable):
        with device_guard("cpu"):
            end = fill_constant([1], dtype, end, force_cpu=True)
    elif end.dtype != dtype:
        end = paddle.cast(end, dtype)

    if not isinstance(step, Variable):
        with device_guard("cpu"):
            step = fill_constant([1], dtype, step, force_cpu=True)
    elif step.dtype != dtype:
        step = paddle.cast(step, dtype)

    if in_dygraph_mode():
        return _C_ops.arange(start, end, step, dtype, _current_expected_place())

    if _in_legacy_dygraph():
        out = _legacy_C_ops.range(start, end, step)
        out.stop_gradient = True
        return out

    check_dtype(
        dtype, 'dtype', ['float32', 'float64', 'int32', 'int64'], 'range/arange'
    )
    helper = LayerHelper('range', **locals())
    out = helper.create_variable_for_type_inference(dtype, shape=out_shape)
    helper.append_op(
        type='range',
        inputs={'Start': start, 'End': end, 'Step': step},
        outputs={'Out': out},
    )
    out.stop_gradient = True
    if out_shape is not None:
        out.desc.set_shape(out_shape)
    return out