算法问题整理（一）

网络资料整理个人学习，感谢各位大神！（若侵则删）

问题1: Transformer和LSTM

	Transformer	LSTM
结构	基于注意力机制（self-attention）的模型，通过同时处理整个序列的信息	基于递归的循环神经网络。旨在解决传统RNN在处理长序列时遇到的梯度消失和梯度爆炸问题。LSTM通过引入门控机制（包括输入门、遗忘门和输出门）来控制信息的流动，从而实现对长期依赖关系的有效捕捉。
特性	Transformer则具有强大的并行化能力和全局信息捕捉能力，适用于处理大规模序列数据；在处理大规模机器翻译或文本摘要等任务时，Transformer可能更具优势	LSTM通过门控机制有效捕捉长期依赖关系，适用于处理长序列数据；在处理长文本或语音等序列数据时，LSTM可能是一个更好的选择
优缺点	优点： 并行化能力强：Transformer的并行化能力非常强，可以显著提高模型的训练速度。 全局信息捕捉：通过自注意力机制，Transformer能够同时关注序列中的所有位置，从而捕捉全局信息。 长期依赖捕捉：虽然Transformer没有显式的循环结构，但自注意力机制使其能够捕捉长期依赖关系。 缺点： 计算复杂度：Transformer的计算复杂度较高，特别是当序列长度较长时，其计算量会显著增加。 位置信息：Transformer本身不包含位置信息，需要通过额外的位置编码来补充。	优点： 长期依赖捕捉：LSTM通过门控机制能够有效捕捉序列中的长期依赖关系，特别适用于处理长序列数据。 缓解梯度消失/爆炸：门控机制有助于缓解梯度消失和梯度爆炸问题，使LSTM能够更好地处理长序列数据。 缺点： 计算复杂度：LSTM在每个时间步都需要进行一系列的门控操作，导致计算复杂度较高。 并行化能力：由于LSTM的循环结构，其并行化能力相对较弱，限制了模型的训练速度。

问题2: Transfomer结构简介

左边是编码器部分，主要作用是将原始输入数据编码成计算机能理解的高维抽象表示。

编码器由 N = 6 个相同的堆叠层组成。 每层有两个子层。 第一个子层是多头自注意力机制，第二个子层是简单的全连接前馈网络，并对输入采用残差连接，然后进行层归一化。 即每个子层的输出为LayerNorm(x + Sublayer(x))，其中Sublayer(x)是子层本身实现的函数。

它的结构是多头注意力机制+全连接神经网络。此外用了残差连接（Residualconnection），将输入和多头注意力层或全连接神经网络的输出相加，再传递给下一层，避免梯度递减的问题。

右边是解码器的部分，主要作用是利用高维表示信息生成目标序列。

解码器也是由 N = 6 个相同的堆叠层组成。 除了每个编码器层中的两个子层之外，解码器还插入第三个子层，该子层对编码器堆叠的输出执行多头注意力。 与编码器类似，在每个子层周围采用残差连接，然后进行层归一化，这里还修改了解码器堆叠层中的自注意力子层，以防止位置关注后续位置。 这种掩蔽与输出嵌入偏移一个位置的事实相结合，确保位置 i 的预测只能依赖于小于 i 的位置处的已知输出。

掩码多头自注意力（Masked-Multi-head self attention），即在计算注意力得分时，模型只能关注生成内容的当前位置之前的信息，避免未来信息的泄漏。

问题3: 手撕多头自注意力机制代码

import torch
import torch.nn as nn
import math
 
class MultiHeadSelfAttention(nn.Module):
    """
    多头注意力模块，用于实现transformer模型中的注意力机制。
    
    参数:
        model_dim: 模型维度，即输入和输出的向量维度。
        num_heads: 注意力头的数量。
        dropout_rate: Dropout率，防止模型过拟合，默认为0.1。
    """
    def __init__(self, model_dim, num_heads, dropout_rate=0.1):
        super(MultiHeadSelfAttention, self).__init__()
        self.model_dim = model_dim
        self.num_heads = num_heads
        self.head_dim = model_dim // num_heads
        assert model_dim % num_heads == 0, "model_dim 必须能整除注意力头的数量。"
        self.query_projection = nn.Linear(model_dim, model_dim)
        self.key_projection = nn.Linear(model_dim, model_dim)
        self.value_projection = nn.Linear(model_dim, model_dim)
        self.output = nn.Linear(model_dim, model_dim)
        self.dropout = nn.Dropout(dropout_rate)
        self.softmax = nn.Softmax(dim=-1)
    
    def forward(self, inputs, attention_mask=None, target=None):
        """
        前向传播函数。
        参数：
        - inputs: 输入张量，形状为(batch_size, sequence_length, model_dim)。
        - mask: 掩码张量，形状为(batch_size, sequence_length, sequence_length)。
        返回：
        - output: 输出张量，形状为(batch_size, sequence_length, model_dim)。
        """
        
        batch_size, sequence_length, _ = inputs.shape
 
        # 对Query、Key和Value进行线性变换
        querys = self.query_projection(inputs)
        keys = self.key_projection(inputs)
        values = self.value_projection(inputs)
 
        # 进行矩阵分割以实现多头注意力
        querys = querys.reshape(batch_size, sequence_length, self.num_heads, self.head_dim).transpose(1, 2)
        keys = keys.reshape(batch_size, sequence_length, self.num_heads, self.head_dim).transpose(1, 2)
        values = values.reshape(batch_size, sequence_length, self.num_heads, self.head_dim).transpose(1, 2)
 
        # 计算scaled dot-product attention,考虑注意力掩码
        attention_scores = torch.matmul(querys, keys.transpose(-2, -1)) / math.sqrt(self.head_dim)
        if attention_mask is not None:
            attention_mask = attention_mask.unsqueeze(1).unsqueeze(2).expand(-1, self.num_heads, sequence_length, -1)
            attention_scores = attention_scores.masked_fill(attention_mask == 0, float('-inf'))
        attention_probs = self.softmax(attention_scores)
        #应用训练阶段的dropout
        if target is not None:
            attention_probs = self.dropout(attention_probs) 
        attention_weights = torch.matmul(attention_probs, values).transpose(1, 2).reshape(batch_size, sequence_length, self.model_dim)
        output = self.output(attention_weights)
        return output, attention_probs
           
# 使用示例：
model_dim = 512
num_heads = 8
mask_attention = torch.IntTensor([[ 1 if i < 8 else 0 for i in range(10) ]])
attention_layer = MultiHeadSelfAttention(model_dim, num_heads)
inputs = torch.randn(1, 10, model_dim)  # 假设我们有一个批次大小为1，序列长度为10，模型维度为512的输入
outputs, attention_weight= attention_layer(inputs