PyTorch学习笔记（四）

2.8 torch.logspace函数讲解

torch.logspace 函数在 PyTorch 中用于生成一个在对数尺度上均匀分布的张量（tensor）。这意味着张量中的元素是按照对数间隔排列的，而不是线性间隔。这对于创建在数值上跨越多个数量级的序列特别有用，例如，在机器学习模型的超参数搜索中，我们可能想要测试不同数量级的学习率。

torch.logspace 函数的原型如下：

torch.logspace(start, end, steps=100, base=10.0, 
dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

1
2
3
4

参数解释：

start：序列的起始值（以底数为底的对数）。
end：序列的结束值（以底数为底的对数）。
steps：生成的样本数量，默认是 100。
base：对数的底数，默认是 10.0。这意味着 start 和 end 是以 10 为底的对数值。
如果是以自然对数（以 e 为底）为间隔，则设置 base=math.e。
dtype：返回张量的数据类型，如果未提供，则推断数据类型。
layout：返回张量的内存布局，默认是 torch.strided。
device：返回张量所在的设备，例如 CPU 或 GPU。
requires_grad：如果设置为 True，则张量将需要梯度，用于反向传播。
1
2
3
4
5
6
7
8
9

使用 torch.logspace 的例子：

import torch

# 创建一个从 10^1 到 10^3（即 10 到 1000）之间，包含 5 个元素的张量，底数为 10
tensor = torch.logspace(1.0, 3.0, 5, base=10.0)

print(tensor)
1
2
3
4
5
6

输出可能类似于：

tensor([  10.,   32.,  100.,  316., 1000.])
1

在这个例子中，start=1.0 对应于底数为 10 的 10（即 10^1），end=3.0 对应于底数为 10 的 1000（即 10^3）。steps=5 表示我们希望生成 5 个元素。结果是一个包含 5 个元素的张量，这些元素在 10 到 1000 之间，按照对数尺度均匀分布。

注意，当 steps 参数很大时，最后一个元素可能会略微超过 end 值，因为对数间隔不是严格的均匀分布。同样，当 steps 参数很小时，第一个元素可能会略微小于 start 值。

2.9 torch.ones函数

在PyTorch中，torch.ones 函数用于创建一个所有元素都设置为1的张量（Tensor）。这个函数接受与 torch.eye 类似的参数，允许你指定张量的形状（即行数和列数）。

下面是如何使用 torch.ones 创建一个全1张量的示例：

import torch

# 创建一个3x3的全1矩阵
ones_matrix = torch.ones(3, 3)

print(ones_matrix)
1
2
3
4
5
6

输出将是：

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

在这个例子中，torch.ones(3, 3) 创建了一个3x3的矩阵，其中所有元素都是1。
如果你想要创建一个不是方阵的全1张量，你可以分别指定行数和列数：

# 创建一个2x3的全1矩阵
ones_matrix_non_square = torch.ones(2, 3)

print(ones_matrix_non_square)
1
2
3
4

输出将是：

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

在这个例子中，torch.ones(2, 3) 创建了一个2x3的矩阵，其中所有元素都是1。
同样，你也可以通过 dtype 参数指定张量的数据类型：

# 创建一个3x3的全1矩阵，数据类型为int64
ones_matrix_int = torch.ones(3, 3, dtype=torch.int64)

print(ones_matrix_int)
1
2
3
4

这将输出一个3x3的矩阵，其中所有元素都是1，并且数据类型是torch.int64。
请注意，由于 torch.int64 是整数类型，所有元素将被设置为1，而不是浮点数1.0。如果你想要创建浮点数的全1张量，你应该使用 torch.float32 或 torch.float64（默认为 torch.float32）作为数据类型。

2.10 torch.rand函数

在PyTorch中，torch.rand 函数用于创建一个给定形状的张量（Tensor），其中每个元素都是从均匀分布 U(0, 1) 中随机抽取的。这意味着所有元素的值都在0到1之间（包括0但不包括1）。

下面是如何使用 torch.rand 创建一个随机张量的示例：

import torch

# 创建一个3x3的随机张量
random_tensor = torch.rand(3, 3)

print(random_tensor)
1
2
3
4
5
6

输出将是一个3x3的矩阵，其中的每个元素都是随机生成的，并且值在0到1之间：

tensor([[0.1234, 0.5678, 0.9101],
        [0.2345, 0.6789, 0.1230],
        [0.3456, 0.7890, 0.4567]])
1
2
3

请注意，每次调用 torch.rand 时都会生成一个新的随机张量，即使形状和大小相同。
如果你想要创建一个具有特定数据类型的随机张量，可以使用 dtype 参数。例如，要创建一个浮点数为 torch.float64 类型的随机张量，可以这样做：

random_tensor_double = torch.rand(3, 3, dtype=torch.float64)
print(random_tensor_double)
1
2

2.11 torch.randn函数

在PyTorch中，torch.randn 函数用于创建一个给定形状的张量（Tensor），其中每个元素都是从标准正态分布（均值为0，标准差为1）中随机抽取的。这意味着生成的张量中的值将遵循正态分布，并且平均来说，大部分值将接近0，但会有一些正值和负值。

下面是如何使用 torch.randn 创建一个随机张量的示例：

import torch

# 创建一个3x3的随机张量，元素来自标准正态分布
random_tensor = torch.randn(3, 3)

print(random_tensor)
1
2
3
4
5
6

输出将是一个3x3的矩阵，其中的每个元素都是随机生成的，并且符合标准正态分布：

tensor([[ 0.1234, -0.5678,  0.9101],
        [-0.2345,  0.6789, -0.1230],
        [ 0.3456, -0.7890,  0.4567]])
1
2
3

torch.randn 在深度学习和统计建模中特别有用，因为它可以帮助你生成符合正态分布的随机初始权重和偏差，这些权重和偏差在训练神经网络时通常会得到更好的性能。

2.12 torch.zeros函数

在PyTorch中，torch.zeros 函数用于创建一个所有元素都设置为0的张量（Tensor）。这个函数接受一个形状参数，允许你指定张量的维度。

下面是如何使用 torch.zeros 创建一个全0张量的示例：

import torch

# 创建一个3x3的全0矩阵
zeros_matrix = torch.zeros(3, 3)

print(zeros_matrix)
1
2
3
4
5
6

输出将是：

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

在这个例子中，torch.zeros(3, 3) 创建了一个3x3的矩阵，其中所有元素都是0。

你可以创建任意维度的全0张量，只需要提供相应的维度参数即可：

# 创建一个2维的全0张量，形状为 (4, 5)
zeros_tensor = torch.zeros(4, 5)

print(zeros_tensor)
1
2
3
4

输出将是：

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

如果你想要指定张量的数据类型，可以使用 dtype 参数：

# 创建一个3x3的全0矩阵，数据类型为float64
zeros_matrix_float64 = torch.zeros(3, 3, dtype=torch.float64)

print(zeros_matrix_float64)
1
2
3
4

输出将是：

tensor([[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]], dtype=torch.float64)
        
1
2
3
4