torch.nn.Transformer

作者：一键难忘520 | 2024-07-31 11:02:42

踩

torch.nn.transformer

文章目录

Transformer
TransformerEncoder
TransformerDecoder
TransformerEncoderLayer
TransformerDecoderLayer
MultiheadAttention

Transformer

def __init__(self, d_model: int = 512, nhead: int = 8, num_encoder_layers: int = 6, 
			 num_decoder_layers: int = 6, dim_feedforward: int = 2048, 
			 dropout: float = 0.1, activation: str = "relu", custom_encoder: 
			 Optional[Any] = None, custom_decoder: Optional[Any] = None) 
			 -> None:
1
2
3
4
5

常用参数	解释
d_model	表示每个数据的维度，例如：一个单词 Embedding 维度是512（默认值）
nhead	Encoder 和 Decoder 部分多头注意力机制的头数
num_encoder_layers	Encoder 部分层数
num_decoder_layers	Decoder 部分层数
dim_feedforward	Feedforward 部分的维度
activation	激活函数，可使用 “gelu”

def forward(self, src: Tensor, tgt: Tensor, 
			src_mask: Optional[Tensor] = None, 
			tgt_mask: Optional[Tensor] = None,
			memory_mask: Optional[Tensor] = None, 
			src_key_padding_mask: Optional[Tensor] = None,
			tgt_key_padding_mask: Optional[Tensor] = None, 
			memory_key_padding_mask: Optional[Tensor] = None) 
			-> Tensor:
1
2
3
4
5
6
7
8

参数	解释
src	Encoder 的输入，维度为（S,N,E）
tgt	Decoder 的输入，维度为（T,N,E）
src_mask	Encoder 的 attention 处理时，使用在score上面的mask矩阵，维度为（S,S）
tgt_mask	Decoder 的 attention 处理时，使用在score上面的mask矩阵，维度为（T,T）
memory_mask	使用 Encoder 生成的矩阵在 Decoder 中的 attention 处理时，使用在score上面的mask矩阵，维度为（T,S）
src_key_padding_mask	维度为（N,S）
tgt_key_padding_mask	维度为（N,T）
memory_key_padding_mask	维度为（N,S）

暂时没研究明白key_padding_mask的作用是什么，如果有知道的可以给我讲讲嘛？

注：S 是 Encoder 部分输入句子的长度；T 是 Decoder 部分输入句子的长度；N 是 batch 长度；E 是特征值的维度，也就是 Embedding 过程中每个词表示的维度

def generate_square_subsequent_mask(self, sz: int) -> Tensor:
1

返回一个上三角为负无穷的矩阵

[In] : nn.Transformer().generate_square_subsequent_mask(5)
[Out]：
tensor([[0., -inf, -inf, -inf, -inf],
        [0., 0., -inf, -inf, -inf],
        [0., 0., 0., -inf, -inf],
        [0., 0., 0., 0., -inf],
        [0., 0., 0., 0., 0.]])
1
2
3
4
5
6
7

TransformerEncoder

def __init__(self, encoder_layer, num_layers, norm=None):
1

参数
encoder_layer	单层模型，将该模型重复添加到 ModuleList 中，次数为 num_layers
num_layers	Encoder 层数
norm	Encoder 最终结果进行一次规范化处理模型

def forward(self, src: Tensor, 
			mask: Optional[Tensor] = None, 
			src_key_padding_mask: Optional[Tensor] = None) 
			-> Tensor:
1
2
3
4

参数
src	Encoder 输入
mask	注意力机制中的mask，也就是 Transformer 中的 src_mask
src_key_padding_mask	Transformer 中的 src_key_padding_mask

TransformerDecoder

def __init__(self, decoder_layer, num_layers, norm=None):

def forward(self, tgt: Tensor, memory: Tensor, 
			tgt_mask: Optional[Tensor] = None,
            memory_mask: Optional[Tensor] = None, 
            tgt_key_padding_mask: Optional[Tensor] = None,
            memory_key_padding_mask: Optional[Tensor] = None) -> Tensor:
1
2
3
4
5
6
7

与 TransformerEncoder 和 Transformer 相似，不赘述

TransformerEncoderLayer

def __init__(self, d_model, nhead, dim_feedforward=2048, 
			 dropout=0.1, activation="relu"):
			
def forward(self, src: Tensor, 
			src_mask: Optional[Tensor] = None, 
			src_key_padding_mask: Optional[Tensor] = None) -> Tensor:
1
2
3
4
5
6

与 TransformerEncoder 和 Transformer 相似，不赘述

TransformerDecoderLayer

def __init__(self, d_model, nhead, dim_feedforward=2048, 
			 dropout=0.1, activation="relu"):

def forward(self, tgt: Tensor, memory: Tensor, 
			tgt_mask: Optional[Tensor] = None, 
			memory_mask: Optional[Tensor] = None,
			tgt_key_padding_mask: Optional[Tensor] = None, 
			memory_key_padding_mask: Optional[Tensor] = None)
			-> Tensor:
1
2
3
4
5
6
7
8
9

与 TransformerEncoder 和 Transformer 相似，不赘述

MultiheadAttention

def __init__(self, embed_dim, num_heads, dropout=0., 
			 bias=True, add_bias_kv=False, add_zero_attn=False, 
			 kdim=None, vdim=None):
1
2
3

参数
embed_dim	表示每个数据的维度（与d_model相同），例如：一个单词 Embedding 维度是512（默认值）
num_heads	多头注意力机制的数量
dropout	dropout 层的权值
bias	是否使用bias
kdim & vdim	K,Q,V 矩阵的维度，默认使用 embed_dim

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】