pytorch里常用操作（持续更新）

对不起我脑子不太记事儿每次变换都得想想想所以干脆汇总一下算了，当然也有一些不是torch包里面的但是没有关系hhh 官方文档里有一堆不太常用的，这里整理的都是自己比较常用的

张量操作

torch.tensor：从Python列表或NumPy数组创建张量

torch.zeros/ones：创建全零/一张量

torch.zeros（10，4）就是创建[10,4]的全零张量

torch.rand：创建随机张量

torch.cat：沿指定维度拼接张量

torch.stack：在新的维度上堆叠张量

torch.stack(tensors, dim=0, out=None)

• tensors：要堆叠的输入张量的列表或元组。
• dim：指定要堆叠的新维度的索引。默认是0。
• out：可选参数，用于指定结果张量的输出

 e.g

假设我们有两个张量 tensor1 和 tensor2，它们的形状都是 (3, 4)，并且我们想将它们堆叠在一个新的维度上，创建一个新的形状为 (2, 3, 4) 的张量。

# 创建两个张量
tensor1 = torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
tensor2 = torch.tensor([[-1, -2, -3, -4], [-5, -6, -7, -8], [-9, -10, -11, -12]])
 
# 使用torch.stack将它们堆叠在一个新的维度上
stacked_tensor = torch.stack((tensor1, tensor2), dim=0)

torch.reshape：改变张量的形状。

torch.transpose：交换张量的维度。

torch.transpose(input, dim0, dim1)

• input：要进行维度交换的输入张量。
• dim0：要交换的第一个维度的索引。
• dim1：要交换的第二个维度的索引。

假设我们有一个形状为 (3, 4) 的张量，现在想要交换它的维度，创建一个新的张量，使其形状为 (4, 3)。

# 创建一个形状为 (3, 4) 的张量
input_tensor = torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
 
# 使用 torch.transpose 进行维度交换
transposed_tensor = torch.transpose(input_tensor, 0, 1)

torch.arange: 用于创建一个包含指定范围内的数值的一维张量

# 开始，结尾，间隔；和索引比较像

arr = torch.arange(10,100,10) #[10, 20, 30, 40, 50, 60, 70, 80, 90]

torch.meshgrid: 网格图

根据提供的x，y轴的范围得到一张网格的里面的点的xy坐标

torch.flatten(tensor,dim) : 把tensor压缩，dim表示压缩的维度

torch.unsqueeze:在张量中插入新的维度

new_tensor = torch.unsqueeze(input, dim)

• input 是要插入新维度的输入张量。
• dim 是要插入新维度的位置，通常是一个非负整数。

y = torch.tensor([[1, 2], [3, 4],[5, 6]]) # torch.Size[3,2]
y_new_1 = torch.unsqueeze(y, 0) #torch.Size[1, 3, 2]
y_new_2 = torch.unsqueeze(y, 1) # torch.Size[3, 1, 2]
y_new_3 = torch.unsqueeze(y, 2) # torch.Size[3, 2, 1]

一些非torch包的操作

[:, :, :None]最后一维扩一维

A；2d，B:1d B[i*cols+j] = A[i,j] 把二阶张量变成一阶

permute(): 矩阵转置

数学操作

torch.add/sub：张量相加/减

torch.mul/div：张量相乘/除

torch.sum：计算张量的和

torch.mean：计算张量的平均值

torch.max/min：找到张量中的最大/小值

torch.abs：计算张量的绝对值

torch.exp：计算输入张量中元素的指数（exponential）

x = torch.tensor([1.0, 2.0, 3.0])

exp_x = torch.exp(x)     # [e^1.0, e^2.0, e^3.0]

索引和切片

tensor[idx]：根据索引获取张量中的元素。
tensor[start:end]：切片操作。
tensor[:, 1]：选取指定列。
tensor[condition]：使用布尔条件进行索引。

自动求导

torch.autograd.Variable：创建自动求导的变量。
backward()：计算梯度。
grad：访问梯度值。
no_grad()：上下文管理器，用于禁用梯度计算。

神经网络模块

torch.nn.Module：创建神经网络模块

torch.nn.Linear：定义全连接层

这个层通常用于神经网络中，用来实现从输入到输出的线性变换，其中包括权重矩阵和偏置项。

# 创建一个 Linear 层
input_size = 10
output_size = 5
linear_layer = nn.Linear(input_size, output_size)
 
# 随机生成一个输入张量
input_data = torch.randn(1, input_size)  # 这里创建一个形状为 (1, input_size) 的随机输入张量
 
# 使用线性层进行前向传播
output = linear_layer(input_data)
 
# 查看权重和偏置
weights = linear_layer.weight
bias = linear_layer.bias
 
print("输入张量：", input_data)
print("输出张量：", output)
print("权重矩阵：", weights)
print("偏置项：", bias)

这个示例中，首先创建了一个 nn.Linear 层，指定输入特征的数量和输出特征的数量。然后，随机生成一个输入张量 input_data，并通过将其传递给 linear_layer 来进行前向传播。线性层会应用权重矩阵和偏置项，生成输出张量。

nn.Linear 层在神经网络中通常用于连接不同层之间的神经元，执行线性变换的作用，帮助网络学习数据的特征表示。

torch.nn.Conv2d：定义卷积层

torch.nn.ReLU：ReLU激活函数

torch.nn.CrossEntropyLoss：交叉熵损失函数

torch.nn.optim：包含各种优化器，如SGD、Adam等

torch.nn.LayerNorm:用于层归一化

层归一化是一种用于神经网络的正则化技术，有助于加速训练和提高模型的鲁棒性。输入输出的形状并不会改变

import torch
import torch.nn as nn
 
# 创建一个 LayerNorm 层
input_size = 10
layer_norm = nn.LayerNorm(input_size)
 
# 随机生成一个输入张量
input_data = torch.randn(1, input_size)  # 创建一个形状为 (1, input_size) 的随机输入张量
 
# 使用 LayerNorm 层进行前向传播
output = layer_norm(input_data)
 
print("输入张量：", input_data)
print("LayerNorm 后的输出张量：", output) #shape[1,input_size]

torch.nn.Parameter：将张量标记为模型参数（可训练的参数）

将张量封装为 torch.nn.Parameter 对象后，它会被自动注册为模型的可训练参数，并在反向传播（backpropagation）期间更新它的值。这对于构建神经网络模型非常有用，因为神经网络的权重和偏置通常需要在训练期间进行优化。

# 创建一个普通的张量
tensor_data = torch.tensor([1.0, 2.0, 3.0])

# 将张量包装为一个模型参数·1                                                                                               
parameter = nn.Parameter(tensor_data)

# 打印参数
print(parameter) #Parameter containing: tensor([1., 2., 3.], requires_grad=True)

一起使用的是register_buffer

用于将张量注册为模型的缓冲区（buffer）

 注册为缓冲区的张量不会被视为模型的可训练参数，也不会在反向传播期间更新。它们用于保存模型的固定状态信息，例如统计信息（均值、方差等）、预训练的权重或任何其他不需要进行梯度更新的张量。

register_buffer 的主要作用是将这些张量添加到模型的状态字典中，以便在保存和加载模型时一并保存和加载。这对于确保模型的一致性和可重现性非常有用。

class CustomModel(nn.Module):
    def __init__(self):
        super(CustomModel, self).__init__()
 
        # 创建一个常量张量作为缓冲区
        self.register_buffer('constant_tensor', torch.tensor([1.0, 2.0, 3.0]))
 
# 创建模型实例
model = CustomModel()
 
# 打印模型缓冲区
for name, buffer in model.named_buffers():
    print(name, buffer)

torch.nn.MultiheadAttention:实现多头注意力机制

多头注意力机制允许模型同时关注输入中的不同部分，以提高模型性能

定义多头注意力模块
- embed_dim: 输入的维度
- num_heads: 头的数量，用于并行处理不同部分的注意力
- dropout: 可选的丢弃率

attention = nn.MultiheadAttention(embed_dim, num_heads, dropout=0.1)
 
# 输入数据 (query, key, value)，通常是三个相同形状的张量
query = torch.randn(seq_length, batch_size, embed_dim)
key = torch.randn(seq_length, batch_size, embed_dim)
value = torch.randn(seq_length, batch_size, embed_dim)
 
# 调用多头注意力模块
output, attention_weights = attention(query, key, value)
 
# output 是注意力机制的输出，attention_weights 是注意力权重

e.g 

import torch
import torch.nn as nn
 
# 定义多头注意力模块
embed_dim = 128
num_heads = 4
attention = nn.MultiheadAttention(embed_dim, num_heads)
 
# 输入数据 (query, key, value)
seq_length = 10
batch_size = 32
query = torch.randn(seq_length, batch_size, embed_dim)
key = torch.randn(seq_length, batch_size, embed_dim)
value = torch.randn(seq_length, batch_size, embed_dim)
 
# 调用多头注意力模块
output, attention_weights = attention(query, key, value)
 
print("Output shape:", output.shape)
print("Attention weights shape:", attention_weights.shape)

数据加载和处理

torch.utils.data.Dataset：创建自定义数据集。

torch.utils.data.DataLoader：数据加载器。

transforms模块：用于数据预处理和转换。