pytorch的基础函数

[torch.arange]

是 PyTorch 中的一个函数，用于生成一个一维的张量（tensor），其中包含从起始值（包括）到结束值（不包括）的等差数列。这个函数非常类似于 Python 的内置 range 函数，但是生成的是 PyTorch 张量而不是 Python 列表。

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

start (int，可选) – 序列的起始值。默认为 0。
end (int) – 序列的结束值，但不包括该值。
step (int，可选) – 序列中两个值之间的间隔。默认为 1。
out (Tensor，可选) – 输出张量。
dtype (torch.dtype，可选) – 返回张量的数据类型。
layout (torch.layout，可选) – 返回张量的布局。
device (torch.device，可选) – 返回张量的设备。
requires_grad (bool，可选) – 如果设置为 True，则张量将需要梯度计算。默认为 False。
[clone()]
在 PyTorch 中，A.clone() 用于创建一个与原始张量 A 具有相同数据的新张量 B。这意味着 B 是 A 的一个副本，它们包含相同的值，但是是两个独立的对象，存储在不同的内存位置。对 B 的任何修改都不会影响 A，反之亦然。

import torch  
  
# 创建一个张量 A  
A = torch.tensor([1, 2, 3, 4])  
  
# 使用 clone() 方法创建 A 的一个副本 B  
B = A.clone()  
  
# 修改 B 的值  
B[0] = 100  
  
# 输出 A 和 B 的值，以确认它们是否独立  
print(A)  # 输出：tensor([1, 2, 3, 4])  
print(B)  # 输出：tensor([100, 2, 3, 4])

[sum()]
在PyTorch中，A.sum()是一个操作，用于计算张量A中所有元素的和。这个操作会沿着张量的所有维度进行求和，除非指定了特定的维度。
例如，如果A是一个一维张量（类似于一个向量），A.sum()会返回张量中所有元素的和。

import torch  
  
A = torch.tensor([1, 2, 3, 4, 5])  
sum_of_A = A.sum()  
print(sum_of_A)  # 输出：15

如果A是一个二维张量（类似于一个矩阵），A.sum()会返回矩阵中所有元素的和。

A = torch.tensor([[1, 2, 3],  
                   [4, 5, 6]])  
sum_of_A = A.sum()  
print(sum_of_A)  # 输出：21

如果想要沿着特定的维度求和这需要给一个dim参数

A = torch.tensor([[1, 2, 3],  
                   [4, 5, 6]])  
sum_along_rows = A.sum(dim=0)  # 沿着行（第一个维度）求和  
print(sum_along_rows)  # 输出：tensor([5, 7, 9])

sum_along_cols = A.sum(dim=1)  # 沿着列（第二个维度）求和  
print(sum_along_cols)  # 输出：tensor([ 6, 15])

[numel()]
在PyTorch中，A.numel() 是一个方法，用于返回张量 A 中元素的总数。这个方法计算张量中所有维度大小的乘积，从而得出元素的总数。

A = torch.tensor([[1, 2, 3],  
                   [4, 5, 6]])  
num_elements = A.numel()  
print(num_elements)  # 输出：6

[torch.dot()]
torch.dot() 函数用于计算两个一维张量（向量）的点积（dot product）。点积是对应元素相乘后的和。如果尝试对更高维度的张量使用 torch.dot()，将会抛出错误，因为 torch.dot() 只适用于一维张量。

import torch  
  
# 创建两个一维张量  
a = torch.tensor([1.0, 2.0, 3.0])  
b = torch.tensor([4.0, 5.0, 6.0])  
  
# 计算点积  
dot_product = torch.dot(a, b)  
print(dot_product)  # 输出：32.0

[detach()]
detach() 是一个方法，用于从当前计算图中分离一个张量（Tensor），并返回一个新的张量，该张量将不再需要计算其梯度。换句话说，它创建了一个与原始张量共享相同数据但不需要跟踪其计算历史的张量。
当你在PyTorch中进行自动微分时，每个张量都有一个与之相关的计算图，该图描述了如何计算该张量。这个计算图对于反向传播（backpropagation）是必需的，因为它允许我们计算梯度。然而，在某些情况下，你可能想要使用张量的值，但不希望它参与到梯度计算中。这时，detach() 方法就很有用。

x.grad.zero_()
y = x * x
u = y.detach()
z = u * x

z.sum().backward()
x.grad == u

这里u就不再是x的函数

[torch.normal]

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

mean (Tensor)：正态分布的均值。
std (Tensor)：正态分布的标准差。
out (Tensor, optional)：输出张量。

[nn.Sequential]
nn.Sequential 是 PyTorch 中 torch.nn 模块提供的一个容器，它包含了有序排列的模块（或层），并且以线性的方式执行这些模块。在 nn.Sequential 中定义的层会按照它们在构造函数中传入的顺序被添加到计算图中，并且会按照相同的顺序执行前向传播。

使用 nn.Sequential 可以简化模型的构建过程，因为它允许你通过简单的顺序组合来构建网络，而不需要显式地定义 forward 方法。这对于简单的网络结构特别有用。

import torch  
from torch import nn  
  
# 定义一个简单的网络  
model = nn.Sequential(  
    nn.Linear(in_features=784, out_features=128),  
    nn.ReLU(),  
    nn.Linear(in_features=128, out_features=10),  
    nn.Softmax(dim=1)  
)  
  
# 创建一个随机的输入张量  
input_tensor = torch.randn(1, 784)  
  
# 进行前向传播  
output_tensor = model(input_tensor)  
  
# 输出结果  
print(output_tensor)