目录

一、基本函数介绍

1.1 nn.Module 类

1.2 nn.Embedding

1.3 nn.LSTM

1.4 nn.Linear

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

后续更新~

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