PyTorch学习笔记（五）

3.随机值生成函数

3.1 torch.bernouli()函数

torch.bernoulli() 是 PyTorch 中的一个函数，它用于生成符合伯努利分布的随机数。伯努利分布是一个离散型概率分布，描述了一个随机变量只有两种可能的结果：0 或 1。

torch.bernoulli() 的基本语法如下：

torch.bernoulli(input, generator=None, out=None)
1

参数：

• input：一个张量，其中每个元素都表示伯努利分布的成功概率。这个张量应该包含介于 0 和 1 之间的值。
• generator：一个可选的伪随机数生成器。
• out：一个可选的输出张量。

返回值：

• 一个与输入张量形状相同的张量，其中每个元素都是根据对应输入概率从伯努利分布中随机生成的 0 或 1。

示例：

import torch

# 创建一个张量，其中包含伯努利分布的成功概率
probabilities = torch.tensor([0.1, 0.5, 0.9])

# 使用 torch.bernoulli() 生成随机数
samples = torch.bernoulli(probabilities)

print(samples)
1
2
3
4
5
6
7
8
9

输出可能是：

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

在这个示例中，我们创建了一个包含三个元素的张量 probabilities，每个元素都表示伯努利分布的成功概率。然后，我们使用 torch.bernoulli() 生成了一个与 probabilities 形状相同的张量 samples，其中每个元素都是根据对应概率从伯努利分布中随机生成的 0 或 1。

3.2 torch.cauchy() 函数

torch.cauchy() 是 PyTorch 中用于生成服从柯西分布（Cauchy distribution）的随机样本的函数。与 torch.cauchy_() 不同，torch.cauchy() 不会修改任何已存在的张量，而是返回一个新的张量，其中包含从柯西分布中抽取的随机样本。

函数的基本使用格式如下：

torch.cauchy(median=0, scale=1, size=None, out=None)
1

参数解释：

• median（中位数）：柯西分布的位置参数，它决定了分布的中心位置。默认值为 0。
• scale（尺度）：柯西分布的尺度参数，它决定了分布的宽度或分散程度。默认值为 1。
• size：输出张量的形状。可以是一个整数或一个整数元组，用于指定生成的张量的维度。
• out：一个可选参数，用于指定输出的张量。如果提供了这个参数，函数将直接在 out 中填充结果，并返回 out。

柯西分布是一个连续型概率分布，其特点是具有长长的“尾巴”，这意味着它经常会产生远离均值的极端值。在数学上，柯西分布是由中位数（位置参数）和尺度参数定义的。

示例：

import torch  
  
# 生成一个形状为 (3,) 的一维张量，其中的元素来自柯西分布  
# 中位数为 0，尺度为 1  
tensor = torch.cauchy(median=0, scale=1, size=(3,))  
print(tensor)
1
2
3
4
5
6

输出将是一个形状为 (3,) 的一维张量，其中的元素是从中位数为 0、尺度为 1 的柯西分布中随机抽取的。每次运行这段代码时，由于随机性，输出的具体值可能会有所不同。

如果你想要直接修改一个已存在的张量而不是创建一个新的张量，你可以使用 torch.cauchy_() 函数，它会将结果直接填充到提供的 out 参数中（如果提供了的话）。但在大多数情况下，使用 torch.cauchy() 就足够了，因为它会返回一个新的张量，不会影响到其他张量。

3.3 torch.exponential()函数

在PyTorch中，torch.exponential() 函数用于生成具有指数分布的随机数。指数分布是一种连续概率分布，通常用于描述事件发生之间的时间间隔，如无线电波的到达时间间隔。

torch.exponential() 的函数签名如下：

torch.exponential(lambda=1.0, size=None, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor
1

参数说明：

• lambda：指数分布的率参数（rate parameter），即平均发生率的倒数。默认为1.0。
• size：输出张量的大小。例如，size=(3, 4) 会生成一个3行4列的二维张量。
• generator：用于生成随机数的生成器。
• out：可选参数，输出张量。
• dtype：返回张量的数据类型。
• layout：返回张量的内存布局。
• device：返回张量所在的设备。
• requires_grad：如果设置为True，则返回的张量将需要梯度，用于计算梯度

import torch

# 生成一个形状为 (2, 3) 的张量，其中的元素服从 λ=2 的指数分布
tensor = torch.exponential(lambda=2, size=(2, 3))

print(tensor)
1
2
3
4
5
6

执行这段代码会输出一个形状为 (2, 3) 的张量，其中的每个元素都是从 λ=2 的指数分布中随机抽取的。

3.4 torch.normal()

torch.normal(mean, std, *, size=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=Fal
1

在PyTorch中，torch.normal 函数用于生成满足正态（高斯）分布的随机数。这个函数有几个参数，下面是它们的详细说明：

• mean (均值，float类型，可选) - 生成的正态分布的均值。默认值为0。

• std (标准差，float类型，可选) - 生成的正态分布的标准差。默认值为1。

• size (张量形状，tuple[int]类型，可选) - 输出张量的形状。例如，size=(3,) 会生成一个包含3个随机数的1维张量，size=(2, 3) 会生成一个2x3的2维张量。如果不指定，则默认生成一个标量（即一个随机数）。

• out (输出张量，Tensor类型，可选) - 可选参数，用于指定输出张量。如果提供了这个参数，函数将在这个张量上就地执行操作并返回它。
  * dtype (数据类型，torch.dtype类型，可选) - 输出张量的数据类型。默认使用torch.float32。

• device (设备，torch.device类型，可选) - 输出张量所在的设备（例如，CPU或GPU）。默认使用当前默认设备。

• requires_grad (是否需要梯度，bool类型，可选) - 如果设置为True，则生成的张量将需要计算梯度，这对于构建计算图以进行自动微分是有用的。默认值为False。

这里是一个torch.normal的使用示例，展示了如何使用不同的参数：

import torch

# 生成一个标量随机数，均值为0，标准差为1
scalar = torch.normal()
print(scalar)

# 生成一个包含5个随机数的1维张量，均值为0，标准差为1
vector = torch.normal(mean=0, std=1, size=(5,))
print(vector)

# 生成一个2x3的2维张量，均值为3，标准差为2
matrix = torch.normal(mean=3, std=2, size=(2, 3))
print(matrix)

# 指定输出张量的数据类型和设备
tensor = torch.normal(mean=1, std=0.5, size=(4,), dtype=torch.float64, device='cuda')
print(tensor)

# 在一个已有的张量上就地生成随机数
output = torch.empty(3, dtype=torch.float32)
torch.normal(mean=0.5, std=1.5, out=output)
print(output)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

请注意，torch.normal 函数默认生成满足标准正态分布的随机数（均值为0，标准差为1）。你可以通过调整mean和std参数来改变这些参数的值。此外，你还可以通过size参数来指定输出张量的形状。

3.5 torch.rand()

torch.rand 函数的签名如下：

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

下面是各个参数的详细解释：

• *size (int… or Tuple[int]…, optional): 输出张量的形状。这是一个整数或者整数元组，用于定义输出张量的维度。如果不指定，将返回一个标量（即0维张量）。

• out (Tensor, optional): 输出张量。如果提供，函数将在这个张量上就地执行操作并返回它。这个张量必须具有与期望输出形状兼容的形状。

• dtype (torch.dtype, optional): 返回张量的数据类型。如果未指定，将使用当前默认数据类型（torch.get_default_dtype()）。

• layout (torch.layout, optional): 返回张量的内存布局。默认为 torch.strided。

• device (torch.device, optional): 返回张量所在的设备。默认为当前设备（torch.device(‘cuda’ if torch.cuda.is_available() else ‘cpu’)）。

• requires_grad (bool, optional): 如果设置为 True，则生成的张量将需要计算梯度，这对于自动微分是必需的。默认为 False。

torch.rand 函数用于生成满足均匀分布 (U(0, 1)) 的随机数，即每个随机数都是在0和1之间（包含0但不包含1）均匀分布的。size 参数用于指定输出张量的形状，而其他参数如 dtype、device 和 requires_grad 则用于控制输出张量的其他属性。

以下是一个使用 torch.rand 的简单示例：

import torch

# 生成一个形状为 (2, 3) 的张量，元素来自均匀分布 U(0, 1)
tensor = torch.rand(2, 3)
print(tensor)

# 生成一个标量（0维张量）
scalar = torch.rand()
print(scalar)

# 指定数据类型和设备
tensor_on_gpu = torch.rand(5, 5, dtype=torch.float64, device='cuda')
print(tensor_on_gpu)

# 在一个已有的张量上就地生成随机数
output = torch.empty(4, 4)
torch.rand(4, 4, out=output)
print(output)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在这个示例中，torch.rand 被用来生成不同形状和属性的张量。通过使用 out 参数，可以在一个已存在的张量上就地生成随机数，覆盖原有的数据。

3.6 torch.rand 函数

torch.randn 函数的签名如下：

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

这里是每个参数的说明：

• *size (int… or Tuple[int]…, optional): 输出张量的形状。这是一个整数序列或者整数元组，用于定义输出张量的维度。如果不指定，将返回一个标量（即0维张量）。
• out (Tensor, optional): 输出张量。如果提供，函数将在这个张量上就地执行操作并返回它。这个张量必须具有与期望输出形状兼容的形状。
• dtype (torch.dtype, optional): 返回张量的数据类型。如果未指定，将使用默认的浮点数据类型（通常是 torch.float32）。
• layout (torch.layout, optional): 返回张量的内存布局。默认为 torch.strided。
• device (torch.device, optional): 返回张量所在的设备。默认为当前设备（torch.device(‘cuda’ if torch.cuda.is_available() else ‘cpu’)）。
• requires_grad (bool, optional): 如果设置为 True，则生成的张量将需要计算梯度，这对于自动微分是必需的。默认为 False。

torch.randn 函数用于生成满足标准正态分布（均值为0，标准差为1）的随机数。输出张量的形状由 size 参数指定。与 torch.rand 不同，torch.randn 生成的是正态分布的随机数，而不是均匀分布的随机数。

下面是一个使用 torch.randn 的简单示例：

import torch

# 生成一个形状为 (2, 3) 的张量，元素来自标准正态分布 N(0, 1)
tensor = torch.randn(2, 3)
print(tensor)

# 生成一个标量（0维张量）
scalar = torch.randn()
print(scalar)

# 指定数据类型和设备
tensor_on_gpu = torch.randn(5, 5, dtype=torch.float64, device='cuda')
print(tensor_on_gpu)

# 在一个已有的张量上就地生成随机数
output = torch.empty(4, 4)
torch.randn(4, 4, out=output)
print(output)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在这个示例中，torch.randn 被用来生成不同形状和属性的张量。通过使用 out 参数，可以在一个已存在的张量上就地生成随机数，覆盖原有的数据。