本文对Pytorch中创建随机数Tensor的一些常用方法进行总结，主要包括

  • randn
  • randn_like
  • rand
  • rand_like
  • randint
  • randint_like

1 torch.randn

形式

torch.randn(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False)

功能

返回一个均值为o，方差为1的符合正态分布的形状为size的随机数填充的Tensor。

参数

  • size：定义输出张量形状的整数序列，列表或者元祖
  • dtype：输出张量的数据类型
  • layout：输出张量的布局
  • device：输出张量的设备，如CPU或者CUDA
  • require_grad：如果为真，autograd应该在返回的张量上记录操作。默认值：False。
  • pin_memory：如果为真，则返回的张量将分配到固定内存中。仅适用于CPU张量。默认值：False。

使用示例

import torch

if __name__ == '__main__':
    a = torch.randn(2, 2)
    print(a)

    b = torch.randn(size=(2, 2))
    print(b)

输出

tensor([[ 1.8956, -0.8104],
        [-1.4132,  0.6851]])
tensor([[-0.0448, -0.0469],
        [-0.1450, -2.4475]])

2 torch.randn_like

形式

torch.randn_like(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format)

功能

返回一个与input张量size相同，均值为o，方差为1的符合正态分布的随机数填充的Tensor。

参数

  • input：需要检测size的输入张量
  • dtype：输出张量的数据类型
  • layout：输出张量的布局
  • device：输出张量的设备，如CPU或者CUDA
  • require_grad：如果为真，autograd应该在返回的张量上记录操作。默认值：False。
  • memory_format：输出张量的内存格式

使用示例

import torch

if __name__ == '__main__':
    a = torch.eye(4)
    print(a)

    b = torch.randn_like(a)
    print(b)

输出

tensor([[1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.],
        [0., 0., 0., 1.]])
tensor([[-0.4519, -1.3703,  1.2359, -1.2844],
        [ 0.9674, -0.8321,  0.0218,  1.1582],
        [ 0.2429,  0.2481, -0.8332,  1.1218],
        [-0.7720, -0.4556, -0.7187, -1.0111]])

3 torch.rand

形式

torch.rand(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False)

功能

返回一个均匀分布在[0,1)区间的形状为size的随机数填充的Tensor。

参数

  • size：定义输出张量形状的整数序列，列表或者元祖
  • dtype：输出张量的数据类型
  • layout：输出张量的布局
  • device：输出张量的设备，如CPU或者CUDA
  • require_grad：如果为真，autograd应该在返回的张量上记录操作。默认值：False。
  • pin_memory：如果为真，则返回的张量将分配到固定内存中。仅适用于CPU张量。默认值：False。

使用示例

import torch

if __name__ == '__main__':
    a = torch.rand(2, 2)
    print(a)

    b = torch.rand(size=(2, 2))
    print(b)

输出

tensor([[0.8743, 0.7553],
        [0.2865, 0.0855]])
tensor([[0.0394, 0.9032],
        [0.9975, 0.1686]])

4 torch.rand_like

形式

torch.rand_like(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format)

功能

返回一个与input张量size相同，均匀分布在[0,1)区间的随机数填充的Tensor。

参数

  • input：需要检测size的输入张量
  • dtype：输出张量的数据类型
  • layout：输出张量的布局
  • device：输出张量的设备，如CPU或者CUDA
  • require_grad：如果为真，autograd应该在返回的张量上记录操作。默认值：False。
  • memory_format：输出张量的内存格式

使用示例

import torch

if __name__ == '__main__':
    a = torch.eye(4)
    print(a)

    b = torch.rand_like(a)
    print(b)

输出

tensor([[1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.],
        [0., 0., 0., 1.]])
tensor([[0.3027, 0.8182, 0.0203, 0.3121],
        [0.9693, 0.2909, 0.2630, 0.9446],
        [0.0036, 0.8017, 0.6602, 0.8106],
        [0.7111, 0.6369, 0.4642, 0.0651]])

5 torch.randint

形式

torch.randint(low=0, high, size, \*, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

功能

返回一个均匀分布在最低值为low，最高值为high，形状为size的随机数Tensor

参数

  • low：最低值，默认为0
  • high：最高值
  • size：定义输出张量形状的整数序列，列表或者元祖
  • dtype：输出张量的数据类型
  • layout：输出张量的布局
  • device：输出张量的设备，如CPU或者CUDA
  • require_grad：如果为真，autograd应该在返回的张量上记录操作。默认值：False。

使用示例

import torch

if __name__ == '__main__':
    b = torch.randint(0, 10, size=(2, 2))
    print(b)

输出

tensor([[5, 8],
        [2, 3]])

6 torch.randint_like

形式

torch.randint_like(input, low=0, high, \*, dtype=None, layout=torch.strided, device=None, requires_grad=False, memory_format=torch.preserve_format)

功能

返回一个均匀分布在最低值为low，最高值为high，形状与输入张量input相同的随机数Tensor

参数

  • input：需检测形状的输入张量
  • low：最低值，默认为0
  • high：最高值
  • dtype：输出张量的数据类型
  • layout：输出张量的布局
  • device：输出张量的设备，如CPU或者CUDA
  • require_grad：如果为真，autograd应该在返回的张量上记录操作。默认值：False。
  • memory_format：输出张量的内存格式

使用示例

import torch

if __name__ == '__main__':
    a = torch.eye(4)
    print(a)

    b = torch.randint_like(a, 1, 10)
    print(b)

输出

tensor([[1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.],
        [0., 0., 0., 1.]])
tensor([[1., 2., 9., 6.],
        [3., 1., 8., 2.],
        [6., 3., 1., 8.],
        [5., 3., 5., 3.]])