深入浅出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，则区间为 [ 0 , s t a r t ) [0, start) [0,start)。默认值为 0 0 0。
• 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。默认值为 1 1 1。
• 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]

函数实现

defarange(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 isNone:
        dtype ='int64'if end isNone:
        end = start
        start =0

    out_shape =Noneif(notisinstance(start, Variable)andnotisinstance(end, Variable)andnotisinstance(step, Variable)):
        out_shape =[int(math.ceil((end - start)/ step))]ifnotisinstance(dtype, core.VarDesc.VarType):
        dtype = convert_np_dtype_to_dtype_(dtype)ifnotisinstance(start, Variable):with device_guard("cpu"):
            start = fill_constant([1], dtype, start, force_cpu=True)elif start.dtype != dtype:
        start = paddle.cast(start, dtype)ifnotisinstance(end, Variable):with device_guard("cpu"):
            end = fill_constant([1], dtype, end, force_cpu=True)elif end.dtype != dtype:
        end = paddle.cast(end, dtype)ifnotisinstance(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 =Truereturn 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 =Trueif out_shape isnotNone:
        out.desc.set_shape(out_shape)return out