【机器学习】pytorch 常用函数解析

Linux猿

已于 2024-07-28 21:23:13 修改

阅读量1k

点赞数 31

文章标签：机器学习人工智能 LSTM RNN 循环神经网络情感分析

于 2024-07-28 09:26:52 首次发布

本文链接：https://blog.csdn.net/nyist_zxp/article/details/140578459

版权

1.5 nn.CrossEntropyLoss

1.6 torch.save

1.7 torch.load

1.8 nn.functional

1.9 nn.functional.softmax

本文主要对 pytorch 中用到的函数进行介绍，本文会不断更新~

一、基本函数介绍

1.1 nn.Module 类

我们自己定义模型的时候，通常继承 nn.Module 类，然后重写 nn.Module 中的方法，nn.Module 的主要方法如下所示。

class Module(object):
    def __init__(self):
    def forward(self, *input):
 
    def add_module(self, name, module):
    def cuda(self, device=None):
    def cpu(self):
    def __call__(self, *input, **kwargs):
    def parameters(self, recurse=True):
    def named_parameters(self, prefix='', recurse=True):
    def children(self):
    def named_children(self):
    def modules(self):  
    def named_modules(self, memo=None, prefix=''):
    def train(self, mode=True):
    def eval(self):
    def zero_grad(self):
    def __repr__(self):
    def __dir__(self):
    #......还有一部分，此处未列出

自定义模型一般重写 __init__ 和 forward 函数。

1.2 nn.Embedding

nn.Embedding(num_embeddings, embedding_dim)

（1）参数

num_embeddings ：嵌入字典的大小，也可以理解为该模型可以表示词的数量；

embedding_size：表示嵌入向量的维度。

nn.Embedding 层的本质是一个查找表，它将输入的每个索引映射到一个固定大小的向量，可以理解为每个词都有一个固定的向量。这个映射表在初始化时会随机生成，然后在训练过程中通过反向传播进行优化。

（2）主要步骤

初始化：在初始化时，nn.Embedding 会创建一个大小为 (num_embeddings, embedding_dim)的权重矩阵。这些权重是嵌入层的参数，会在训练过程中更新；

前向传播：在前向传播过程中，nn.Embedding 层会将输入的索引映射到权重矩阵的相应行，从而得到对应的嵌入向量；

反向传播：在训练过程中，嵌入层的权重矩阵会根据损失函数的梯度进行更新。这使得嵌入向量能够捕捉到输入的语义信息。

（3）nn.Embedding 原理

nn.Embedding 的核心是一个查找表，其大小为 (num_embeddings,embedding_dim)，每一行代表一个词或索引的嵌入向量。在向量化时，输入的索引被用来查找嵌入向量，假设输入是 [1, 2, 3]，则输出是权重矩阵（num_embeddings,embedding_dim）中第 1、2、3 行的向量。

下面通过一个例子进行说明。

import torch
import torch.nn as nn

# 创建 Embedding 层
num_embeddings = 10  # 词汇表大小
embedding_dim = 3    # 嵌入向量的维度
embedding_layer = nn.Embedding(num_embeddings, embedding_dim)

# 输入
input_indices = torch.LongTensor([1, 2, 3, 4])

# 转换为嵌入向量
output_vectors = embedding_layer(input_indices)

# 输出
print("input_indices:", input_indices)
print("output_vectors:", output_vectors)

输出如下所示。

(chat6b) D:\code\ChatGLM-6B-main>python test.py
input_indices: tensor([1, 2, 3, 4])
output_vectors: tensor([[-0.3269, -1.2620,  0.0695],
        [-1.6919, -1.6591, -0.7417],
        [ 2.0479,  0.9768,  1.4318],
        [-0.7075,  1.1718,  0.7530]], grad_fn=<EmbeddingBackward0>)

(chat6b) D:\code\ChatGLM-6B-main>

输出一共包含四个向量，每行表示一个。

1.3 nn.LSTM

长短时记忆网络（LSTM）是一种特殊的循环神经网络，它通过引入一种称为“记忆单元”的结构来克服传统 RNN 的缺点。

LSTM 处理每个词（Xi）的过程如下所示。

其中，C(t-1) 和 h(t-1) 是处理 t-1 个词时输出的细胞单元和隐藏单元，LSTM 最初始会初始化 C(0)和 h(0) 用于第一个词的输入，每个词经过 LSTM 处理后都会输出 Ci 和 hi。

如果是处理多个词如下所示。

LSTM 函数如下所示。

output, (h_n, c_n) = torch.nn.LSTM(input_size,
                                   hidden_size,
                                   num_layers=1,
                                   bias=True,
                                   batch_first=False,
                                   dropout=0.0,
                                   bidirectional=False,
                                   proj_size=0,
                                   device=None,
                                   dtype=None)

主要参数解析

输入参数：

input_size: 输入数据的特征维数，通常就是 embedding_dim(词向量的维度)；

输出参数：

output: 包含了整个序列中所有时间步的隐藏状态 ht, output = [h_1, h_2, ……, h_i, ……hT]，因为保留了每个时间步的信息，所以对于序列生成、机器翻译等任务非常有用。

h_n: LSTM 在最后一个时间步的隐藏状态，对于某些需要关注最终状态的任务（例如，分类任务，LSTM 处理完序列后仅使用最后一个时间步的状态）非常有用。

c_n: 细胞状态帮助LSTM捕捉和保留长时依赖性，避免梯度消失和梯度爆炸问题。

1.4 nn.Linear

nn.Linear 是神经网络的线性层，可以看作是通过一个二维矩阵做了一个转换。

torch.nn.Linear(in_features,  # 输入的神经元个数
                out_features, # 输出神经元个数
                bias=True     # 是否包含偏置
                )

nn.Linear 对输入执行线性变换，如下所示。

其中，X 表示输入，Y 表示输出，b 为偏置。

下面来看一个例子。

import torch
from torch import nn


input = torch.Tensor([1, 2, 3]) # 样本有 3 个特征
model = nn.Linear(3, 2) # 输入特征数为 3，输出特征数为 2
print("model = ", model)
# nn.Linear 权重
for param in model.parameters():
    print(param)

output = model(input)
print(output)

输出如下所示。

model =  Linear(in_features=3, out_features=2, bias=True)
Parameter containing:
tensor([[-0.4270,  0.0396,  0.2899],
        [-0.4481,  0.4071,  0.4366]], requires_grad=True)
Parameter containing:
tensor([-0.1091,  0.3018], requires_grad=True)
tensor([0.4128, 1.9777], grad_fn=<ViewBackward0>)

X(1x3)= [1,2,3], W(3x2) = [[-0.4270, 0.0396, 0.2899], [-0.4481, 0.4071, 0.4366]]的转置，b = [-0.1091, 0.3018]，可以手动计算最后的结果，例如：0.4128 = -0.4270 * 1 + 0.0396 * 2 + 0.2899*3 - 0.1091，同理也可以计算 1.9777。

1.5 nn.CrossEntropyLoss

交叉熵（Cross-Entropy）是一种用于比较真实标签和预测标签概率之间差异的度量，交叉熵通常用作损失函数，用于衡量模型预测与真实标签之间的差异，尤其在分类任务中广泛使用。

交叉熵越小，模型预测越准确。当模型的预测与真实标签完全一致时，交叉熵达到最小值为 0。

import torch
import torch.nn as nn
from torch.nn.functional import one_hot

output = torch.randn(4, 3)  # 模型预测，4 个样本，3 分类
print('output:\n', output)

target = torch.tensor([1, 2, 0, 1])  # 真实标签值
target1 = target
# 实际上不需要转换为 one_hot，这里测试证明了这一点
target = one_hot(target, num_classes=3)
target = target.to(dtype=torch.float)
crossentropyloss = nn.CrossEntropyLoss()
output_loss = crossentropyloss(output, target)
output_loss1 = crossentropyloss(output, target1)

print('output_loss:\n', output_loss)
print('output_loss1:\n', output_loss1)

顺便测试了下是否需要转换为 one_hat。

1.6 torch.save

torch.save() 的主要作用就是将 PyTorch 对象（如模型、张量等）保存到磁盘上，以文件的形式进行存储。如果想使用训练后的模型，从磁盘上加载即可。

torch.save(model,保存路径)  # 保存整个模型
torch.save(model.state_dict(), 保存路径) # 只保存模型参数

CrossEntropyLoss() 损失函数结合了 nn.LogSoftmax() 和 nn.NLLLoss() 两个函数。它在做分类训练的时候是非常有用的。

1.7 torch.load

torch.load() 函数用于加载磁盘上模型文件。

 torch.load(模型路径)

1.8 nn.functional

nn.functional 是 PyTorch 中一个重要的模块，它包含了许多用于构建神经网络的函数。与 nn.Module 不同，nn.functional 中的函数不具有可学习的参数。

这些函数通常用于执行各种非线性操作、损失函数、激活函数等。这个模块的主要优势是它的计算效率和灵活性，因为它允许你以函数的方式直接调用这些操作，而不需要创建额外的层。

1.9 nn.functional.softmax

softmax 有两种形式。

torch.nn.Softmax(input, dim)
torch.nn.functional.softmax(input, dim)

下面主要对 torch.nn.functional.softmax 进行介绍。

对 n 维输入张量运用 softmax 函数，将张量的每个元素缩放到（0,1）区间且和为1。

softmax(input, dim=None, _stacklevel=3, dtype=None)

主要参数：

input : 输入的张量；

dim : 指明维度，dim=0表示按列计算；dim=1表示按行计算。默认dim的方法已经弃用了，最好声明dim，否则会警告。

softmax 公式如下所示。

下面来看一个例子。

import torch
import torch.nn.functional as F
 
input = torch.Tensor([[1, 2, 3, 4],[1, 2, 3, 4]])
 
output1 = F.softmax(input, dim=0) #对每一列进行softmax
print(output1)
 
output2 = F.softmax(input, dim=1) #对每一行进行softmax
print(output2)

输出如下所示。

tensor([[0.5000, 0.5000, 0.5000, 0.5000],
        [0.5000, 0.5000, 0.5000, 0.5000]])
tensor([[0.0321, 0.0871, 0.2369, 0.6439],
        [0.0321, 0.0871, 0.2369, 0.6439]])

分别对输入张量的列和行进行了 softmax。

后续更新：torch.randn、torch.tensor、one_hot、torch.LongTensor

参考链接：

[1] Pytorch nn.Linear()的基本用法与原理详解及全连接层简介_nn.linear()作用-CSDN博客

[2] pytorch教程之nn.Module类详解——使用Module类来自定义模型-CSDN博客

[3] torch.nn - PyTorch中文文档

[4] pytorch nn.Embedding 用法和原理_pytorch nn.embedding 设置初始化函数-CSDN博客

[5] Pytorch nn.Linear()的基本用法与原理详解及全连接层简介_nn.linear()作用-CSDN博客

[6] https://www.cnblogs.com/wanghui-garcia/p/10675588.html

[7] PyTorch `nn.functional` 模块详解：探索神经网络的魔法工具箱_torch.nn.functional-CSDN博客

[8] Pytorch CrossEntropyLoss() 原理和用法详解-CSDN博客

[9] https://www.cnblogs.com/peixu/p/13194801.html