Skip to content

Random sampling

随机抽样

译者：ApacheCN

torch.manual_seed(seed)

设置用于生成随机数的种子。返回torch._C.Generator对象。

参数： 种子 (int） - 所需种子。 
torch.initial_seed()

返回用于生成随机数的初始种子，如Python long。

torch.get_rng_state()

将随机数生成器状态返回为torch.ByteTensor。

torch.set_rng_state(new_state)

设置随机数生成器状态。

Parameters: new_state (torch.ByteTensor） - 理想状态 
torch.default_generator = <torch._C.Generator object>

torch.bernoulli(input, *, generator=None, out=None) → Tensor

从伯努利分布中绘制二进制随机数(0或1）。

input张量应该是包含用于绘制二进制随机数的概率的张量。因此，input中的所有值必须在以下范围内： 。

输出张量的 元素将根据input中给出的 概率值绘制值 。

返回的out张量仅具有值0或1，并且与input具有相同的形状。

out可以有整数dtype，但是：attr input必须有浮点dtype。

参数：

  • 输入 (Tensor） - 伯努利分布的概率值的输入张量
  • out (Tensor， 任选） - 输出张量

例：

>>> a = torch.empty(3, 3).uniform_(0, 1)  # generate a uniform random matrix with range [0, 1]
>>> a
tensor([[ 0.1737,  0.0950,  0.3609],
 [ 0.7148,  0.0289,  0.2676],
 [ 0.9456,  0.8937,  0.7202]])
>>> torch.bernoulli(a)
tensor([[ 1.,  0.,  0.],
 [ 0.,  0.,  0.],
 [ 1.,  1.,  1.]])

>>> a = torch.ones(3, 3) # probability of drawing "1" is 1
>>> torch.bernoulli(a)
tensor([[ 1.,  1.,  1.],
 [ 1.,  1.,  1.],
 [ 1.,  1.,  1.]])
>>> a = torch.zeros(3, 3) # probability of drawing "1" is 0
>>> torch.bernoulli(a)
tensor([[ 0.,  0.,  0.],
 [ 0.,  0.,  0.],
 [ 0.,  0.,  0.]])


torch.multinomial(input, num_samples, replacement=False, out=None) → LongTensor

返回张量，其中每行包含从位于张量input的相应行中的多项概率分布中采样的num_samples索引。

注意

input的行不需要求和为一(在这种情况下我们使用值作为权重），但必须是非负的，有限的并且具有非零和。

根据每个样本的时间(第一个样本放在第一列中）从左到右排序指数。

如果input是矢量，out是大小为num_samples的矢量。

如果input是具有m行的矩阵，则out是形状矩阵 。

如果更换为True，则更换样品。

如果没有，则绘制它们而不替换它们，这意味着当为一行绘制样本索引时，不能再为该行绘制它。

这意味着num_samples必须低于input长度(或者input的列数，如果它是矩阵）的约束。

Parameters:

  • 输入 (Tensor） - 包含概率的输入张量
  • num_samples (int） - 要抽取的样本数量
  • 替代 (bool， 可选） - 是否与替换有关
  • out (Tensor， 任选） - 输出张量

Example:

>>> weights = torch.tensor([0, 10, 3, 0], dtype=torch.float) # create a tensor of weights
>>> torch.multinomial(weights, 4)
tensor([ 1,  2,  0,  0])
>>> torch.multinomial(weights, 4, replacement=True)
tensor([ 2,  1,  1,  1])


torch.normal()

torch.normal(mean, std, out=None) → Tensor

返回从单独的正态分布中提取的随机数的张量，其中给出了均值和标准差。

mean 是一个张量，具有每个输出元素正态分布的均值

std 是一个张量，每个输出元素的正态分布的标准差

mean 和 std 的形状不需要匹配，但每个张量中的元素总数需要相同。

Note

当形状不匹配时， mean 的形状用作返回输出张量的形状

Parameters:

  • 意味着 (tensor) - 每个元素的张量意味着
  • std (Tensor） - 每元素标准差的张量
  • out (Tensor， 任选） - 输出张量

Example:

>>> torch.normal(mean=torch.arange(1., 11.), std=torch.arange(1, 0, -0.1))
tensor([  1.0425,   3.5672,   2.7969,   4.2925,   4.7229,   6.2134,
 8.0505,   8.1408,   9.0563,  10.0566])


torch.normal(mean=0.0, std, out=None) → Tensor

与上面的函数类似，但是所有绘制元素之间共享均值。

Parameters:

  • 意味着 (漂浮 ， 任选） - 所有分布的均值
  • std (Tensor） - 每元素标准差的张量
  • out (Tensor， 任选） - 输出张量

Example:

>>> torch.normal(mean=0.5, std=torch.arange(1., 6.))
tensor([-1.2793, -1.0732, -2.0687,  5.1177, -1.2303])


torch.normal(mean, std=1.0, out=None) → Tensor

与上述功能类似，但标准偏差在所有绘制元素之间共享。

Parameters:

  • 意味着 (tensor) - 每个元素的张量意味着
  • std (float， 可选） - 所有分布的标准差
  • out (Tensor， 任选） - 输出张量

Example:

>>> torch.normal(mean=torch.arange(1., 6.))
tensor([ 1.1552,  2.6148,  2.6535,  5.8318,  4.2361])


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

从区间 上的均匀分布返回填充随机数的张量

张量的形状由变量参数sizes定义。

Parameters:

  • sizes (int ... ) - 定义输出张量形状的整数序列。可以是可变数量的参数，也可以是列表或元组之类的集合。
  • out (Tensor， 任选） - 输出张量
  • dtype (torch.dtype ，可选） - 返回张量的所需数据类型。默认值：if None，使用全局默认值(参见 torch.set_default_tensor_type())。
  • 布局 (torch.layout ，可选） - 返回Tensor的理想布局。默认值：torch.strided。
  • 设备 (torch.device ，可选） - 返回张量的所需设备。默认值：如果None，则使用当前设备作为默认张量类型(参见 torch.set_default_tensor_type())。 device将是CPU张量类型的CPU和CUDA张量类型的当前CUDA设备。
  • requires_grad (bool， 可选） - 如果autograd应该记录对返回张量的操作。默认值：False。

Example:

>>> torch.rand(4)
tensor([ 0.5204,  0.2503,  0.3525,  0.5673])
>>> torch.rand(2, 3)
tensor([[ 0.8237,  0.5781,  0.6879],
 [ 0.3816,  0.7249,  0.0998]])


torch.rand_like(input, dtype=None, layout=None, device=None, requires_grad=False) → Tensor

返回与input大小相同的张量，该张量用间隔 上的均匀分布填充随机数。 torch.rand_like(input)相当于torch.rand(input.size(), dtype=input.dtype, layout=input.layout, device=input.device)。

Parameters:

  • 输入 (Tensor） - input的大小将决定输出张量的大小
  • dtype (torch.dtype ，可选） - 返回的Tensor的理想数据类型。默认值：if None，默认为input的dtype。
  • 布局 (torch.layout ，可选） - 返回张量的理想布局。默认值：if None，默认为input的布局。
  • 设备 (torch.device ，可选） - 返回张量的所需设备。默认值：如果None，默认为input的设备。
  • requires_grad (bool， 可选） - 如果autograd应该记录对返回张量的操作。默认值：False。
torch.randint(low=0, high, size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

返回填充了在low(包括）和high(不包括）之间统一生成的随机整数的张量。

张量的形状由变量参数size定义。

Parameters:

  • 低 (int， 任选） - 从分布中得出的最小整数。默认值：0。
  • 高 (int） - 高于从分布中提取的最高整数。
  • 大小 (元组) - 定义输出张量形状的元组。
  • out (Tensor， 任选） - 输出张量
  • dtype (torch.dtype ，可选） - 返回张量的所需数据类型。默认值：if None，使用全局默认值(参见 torch.set_default_tensor_type())。
  • 布局 (torch.layout ，可选） - 返回Tensor的理想布局。默认值：torch.strided。
  • 设备 (torch.device ，可选） - 返回张量的所需设备。默认值：如果None，则使用当前设备作为默认张量类型(参见 torch.set_default_tensor_type())。 device将是CPU张量类型的CPU和CUDA张量类型的当前CUDA设备。
  • requires_grad (bool， 可选） - 如果autograd应该记录对返回张量的操作。默认值：False。

Example:

>>> torch.randint(3, 5, (3,))
tensor([4, 3, 4])

>>> torch.randint(10, (2, 2))
tensor([[0, 2],
 [5, 5]])

>>> torch.randint(3, 10, (2, 2))
tensor([[4, 5],
 [6, 7]])


torch.randint_like(input, low=0, high, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

返回与Tensor input具有相同形状的张量，填充在low(包括）和high(不包括）之间均匀生成的随机整数。

Parameters:

  • 输入 (Tensor） - input的大小将决定输出张量的大小
  • 低 (int， 任选） - 从分布中得出的最小整数。默认值：0。
  • 高 (int） - 高于从分布中提取的最高整数。
  • dtype (torch.dtype ，可选） - 返回的Tensor的理想数据类型。默认值：if None，默认为input的dtype。
  • 布局 (torch.layout ，可选） - 返回张量的理想布局。默认值：if None，默认为input的布局。
  • 设备 (torch.device ，可选） - 返回张量的所需设备。默认值：如果None，默认为input的设备。
  • requires_grad (bool， 可选） - 如果autograd应该记录对返回张量的操作。默认值：False。
torch.randn(*sizes, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

返回一个填充了正态分布中随机数的张量，其均值为0和方差1(也称为标准正态分布）。

The shape of the tensor is defined by the variable argument sizes.

Parameters:

  • sizes (int ... ) - 定义输出张量形状的整数序列。可以是可变数量的参数，也可以是列表或元组之类的集合。
  • out (Tensor， 任选） - 输出张量
  • dtype (torch.dtype ，可选） - 返回张量的所需数据类型。默认值：if None，使用全局默认值(参见 torch.set_default_tensor_type())。
  • 布局 (torch.layout ，可选） - 返回Tensor的理想布局。默认值：torch.strided。
  • 设备 (torch.device ，可选） - 返回张量的所需设备。默认值：如果None，则使用当前设备作为默认张量类型(参见 torch.set_default_tensor_type())。 device将是CPU张量类型的CPU和CUDA张量类型的当前CUDA设备。
  • requires_grad (bool， 可选） - 如果autograd应该记录对返回张量的操作。默认值：False。

Example:

>>> torch.randn(4)
tensor([-2.1436,  0.9966,  2.3426, -0.6366])
>>> torch.randn(2, 3)
tensor([[ 1.5954,  2.8929, -1.0923],
 [ 1.1719, -0.4709, -0.1996]])


torch.randn_like(input, dtype=None, layout=None, device=None, requires_grad=False) → Tensor

返回与input具有相同大小的张量，该张量用正态分布中的随机数填充，均值为0且方差为1. torch.randn_like(input)等效于torch.randn(input.size(), dtype=input.dtype, layout=input.layout, device=input.device)。

Parameters:

  • 输入 (Tensor） - input的大小将决定输出张量的大小
  • dtype (torch.dtype ，可选） - 返回的Tensor的理想数据类型。默认值：if None，默认为input的dtype。
  • 布局 (torch.layout ，可选） - 返回张量的理想布局。默认值：if None，默认为input的布局。
  • 设备 (torch.device ，可选） - 返回张量的所需设备。默认值：如果None，默认为input的设备。
  • requires_grad (bool， 可选） - 如果autograd应该记录对返回张量的操作。默认值：False。
torch.randperm(n, out=None, dtype=torch.int64, layout=torch.strided, device=None, requires_grad=False) → LongTensor

返回从0到n - 1的整数的随机排列。

Parameters:

  • n (int） - 上限(不包括）
  • out (Tensor， 任选） - 输出张量
  • dtype (torch.dtype ，可选） - 返回张量的所需数据类型。默认值：torch.int64。
  • 布局 (torch.layout ，可选） - 返回Tensor的理想布局。默认值：torch.strided。
  • 设备 (torch.device ，可选） - 返回张量的所需设备。默认值：如果None，则使用当前设备作为默认张量类型(参见 torch.set_default_tensor_type())。 device将是CPU张量类型的CPU和CUDA张量类型的当前CUDA设备。
  • requires_grad (bool， 可选） - 如果autograd应该记录对返回张量的操作。默认值：False。

Example:

>>> torch.randperm(4)
tensor([2, 1, 0, 3])

就地随机抽样

Tensors还定义了一些更多的就地随机抽样函数。点击查看他们的文档：

回到顶部