创建操作续

torch.zeroslike(input,dtype=None,layout=None,requiresgrad=False,memoryformat=torch.preserveformat)->Tensor

返回填满标量0的张量。参数同torch.zeros()

参数

• input（Tensor）：决定输出张量的size
• dtype（可选参数）：默认None，值同输入数据的类型
• layout（可选参数）：默认None，值同输入数据的layout
• device（可选参数）：略
• requires_grad（bool，可选参数）：略
• memoryformat（torch.memoryformat，可选参数）：指定返回张量的内存格式，默认是torch.preserve_format

例子

    >>> input = torch.empty(2, 3)

    >>> torch.zeros_like(input)

    tensor([[ 0.,  0.,  0.],

            [ 0.,  0.,  0.]])

torch.ones(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

返回全是1的张量。

参数

• size
• out
• dtype
• layout
• device
• requires_grad

例子

    >>> torch.ones(2, 3)

    tensor([[ 1.,  1.,  1.],

            [ 1.,  1.,  1.]])


    >>> torch.ones(5)

    tensor([ 1.,  1.,  1.,  1.,  1.])

torch.oneslike(input, dtype=None, layout=None, device=None, requiresgrad=False, memoryformat=torch.preserveformat) → Tensor

返回一个值全是标量1的张量。

参数

• input
• dtype
• layout
• device
• requires_grad
• memory_format

例子

    >>> input = torch.empty(2, 3)

    >>> torch.ones_like(input)

    tensor([[ 1.,  1.,  1.],

            [ 1.,  1.,  1.]])

说一下zeros与zeroslike和类似函数的区别。zeros是指定输出张量的形状size，然后返回张量，zeroslike则是根据一个张量，返回这个张量形状的张量。ones和ones_like类似

torch.arange(start=0, end, step=1, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

返回一个1维的张量，张量的大小是(end-start)÷step的值。如果step的值是一个浮点数，为了避免出现错误，可以在end上加上一个很小的值ε。

参数

• start（数字）：默认0
• end（数字）：必须指定
• step（步长）：默认1
• dtype：略
• layout
• device
• requires_grad

例子

    >>> torch.arange(5)

    tensor([ 0,  1,  2,  3,  4])

    >>> torch.arange(1, 4)

    tensor([ 1,  2,  3])

    >>> torch.arange(1, 2.5, 0.5)

    tensor([ 1.0000,  1.5000,  2.0000])

torch.range(start=0, end, step=1, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

被torch.arange()代替了，不建议使用

参数

• out：输出张量，其他参数同torch.arange()，略。

例子

    >>> torch.range(1, 4)

    tensor([ 1.,  2.,  3.,  4.])

    >>> torch.range(1, 4, 0.5)

    tensor([ 1.0000,  1.5000,  2.0000,  2.5000,  3.0000,  3.5000,  4.0000])

torch.linspace(start, end, steps=100, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

返回一个以start和end均分的等距点集张量，1维，steps代表分割的数。参数：

• start：点集的开始
• end：点集的结束
• step：start和end间数个数，默认100
• out：输出张量，其他参数略

例子

    >>> torch.linspace(3, 10, steps=5)

    tensor([  3.0000,   4.7500,   6.5000,   8.2500,  10.0000])

    >>> torch.linspace(-10, 10, steps=5)

    tensor([-10.,  -5.,   0.,   5.,  10.])

    >>> torch.linspace(start=-10, end=10, steps=5)

    tensor([-10.,  -5.,   0.,   5.,  10.])

    >>> torch.linspace(start=-10, end=10, steps=1)

    tensor([-10.])