实用指南：Transformer模型：深度解析自然语言处理的革命性架构

news/2025/10/14 8:32:13/文章来源:https://www.cnblogs.com/ljbguanli/p/19139911

实用指南：Transformer模型：深度解析自然语言处理的革命性架构

前言

自2017年由Google研究人员在论文《Attention Is All You Need》中提出以来，Transformer模型已经彻底改变了自然语言处理（NLP）的格局。 它摒弃了以往NLP任务中广泛使用的循环神经网络（RNN）和卷积神经网络（CNN）结构，完全基于自注意力（Self-Attention）机制来捕捉输入和输出之间的全局依赖关系。 这种创新的架构不仅在机器翻译等任务上取得了当时最先进的性能，更重要的是，其固有的并行计算能力极大地提升了训练效率，为后续BERT、GPT等大规模预训练语言模型的诞生奠定了基础。

本文将对Transformer模型进行全面而深入的解析，从其核心架构、关键组件到具体实现，并提供详细的代码示例以供参考，旨在为读者构建一个对Transformer模型完整而清晰的认知。

一、 Transformer的整体架构：编码器-解码器的演进

与许多序列到序列（Sequence-to-Sequence）模型类似，Transformer在宏观上依然沿用了编码器-解码器（Encoder-Decoder）的架构。

在原始论文中，编码器和解码器都不是单一的组件，而是由N个（论文中N=6）相同的层堆叠而成。 这种堆叠结构使得模型能够学习从低阶到高阶、从简单到复杂的特征表示。

image.png

编码器的输出会作为每一个解码器层的输入之一，这使得解码器在生成输出时能够利用到完整的输入序列信息。 接下来，我们将深入剖析构成这些编码器和解码器的核心组件。

二、 核心机制：深入理解Transformer的构建模块

Transformer的强大能力源于其内部精巧的组件设计。我们将逐一解析这些模块，并附上相应的代码实现。

2.1 词嵌入（Word Embedding）与位置编码（Positional Encoding）

词嵌入（Word Embedding）

和大多数NLP模型一样，Transformer的第一步是将输入的离散词元（tokens）转换为连续的向量表示，即词嵌入。这通常通过一个可学习的嵌入层（Embedding Layer）来实现。每个词元会被映射到一个固定维度的向量（在Transformer论文中，这个维度d_model被设为512）。

位置编码（Positional Encoding）

Transformer架构本身不包含任何循环或卷积操作，这意味着它无法直接捕捉序列中词元的顺序信息。 如果不引入位置信息，模型看到的就是一堆无序的词，这对于理解语言是致命的。为了解决这个问题，研究者们引入了“位置编码”的概念。

位置编码是一个与词嵌入维度相同的向量，它包含了词元在序列中的绝对或相对位置信息。这个位置编码向量会与对应的词嵌入向量相加，作为模型编码器和解码器最底层的输入。 这样，模型就能间接地利用到序列的顺序信息。

原始论文中使用了一种基于正弦和余弦函数的固定位置编码方法，其公式如下：

PE(pos,2i)=sin⁡(pos/100002i/dmodel) PE_{(pos, 2i)} = \sin(pos / 10000^{2i / d_{\text{model}}}) PE(pos,2i)​=sin(pos/100002i/dmodel​)
PE(pos,2i+1)=cos⁡(pos/100002i/dmodel) PE_{(pos, 2i+1)} = \cos(pos / 10000^{2i / d_{\text{model}}}) PE(pos,2i+1)​=cos(pos/100002i/dmodel​)

其中，pos是词元在序列中的位置，i是编码向量中的维度索引。 这种设计使得每个位置都有一个独特的编码，并且模型可以学习到词元间的相对位置关系，因为对于任意固定的偏移量k，PE_{pos+k}都可以被PE_{pos}线性表示。

PyTorch 代码实现：

import torch
import torch.nn as nn
import math
class PositionalEncoding(nn.Module):
def __init__(self, d_model, dropout=0.1, max_len=5000):
super(PositionalEncoding, self).__init__()
self.dropout = nn.Dropout(p=dropout)
# 初始化一个足够长的位置编码矩阵
pe = torch.zeros(max_len, d_model)
# 创建一个代表位置的张量 [max_len, 1]
position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
# 计算除数项，用于不同频率的正弦/余弦函数
div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
# 为偶数维度应用sin函数
pe[:, 0::2] = torch.sin(position * div_term)
# 为奇数维度应用cos函数
pe[:, 1::2] = torch.cos(position * div_term)
# 增加一个batch维度，使其能够与输入批次相加
pe = pe.unsqueeze(0)
# 将pe注册为模型的buffer，这样它就不会被视为模型参数，但会随模型移动（例如.to(device)）
self.register_buffer('pe', pe)
def forward(self, x):
"""
x: [batch_size, seq_len, d_model]
"""
# 将位置编码加到输入嵌入上
# self.pe[:, :x.size(1)] 确保位置编码的长度与输入序列的长度匹配
x = x + self.pe[:, :x.size(1)]
return self.dropout(x)
# 示例
d_model = 512
vocab_size = 1000
seq_len = 100
batch_size = 32
embedding = nn.Embedding(vocab_size, d_model)
pos_encoder = PositionalEncoding(d_model)
# 模拟输入
input_tokens = torch.randint(0, vocab_size, (batch_size, seq_len))
input_embedding = embedding(input_tokens)
# 添加位置编码
final_input = pos_encoder(input_embedding)
print(final_input.shape)  # torch.Size([32, 100, 512])
2.2 自注意力机制（Self-Attention Mechanism）

自注意力机制是Transformer模型的核心。 它允许模型在处理一个序列中的某个词元时，能够权衡序列中所有其他词元的重要性，并动态地调整当前词元的表示。

从数学上讲，注意力机制可以描述为一个将查询（Query）和一组键值对（Key-Value pairs）映射到输出的函数。 输出是值的加权和，其中分配给每个值的权重是通过查询与相应键的兼容性函数计算得出的。

在自注意力中，Query、Key和Value都来自同一个输入序列。 对于输入序列中的每一个词元的嵌入向量，我们都会通过乘以三个独立的可学习权重矩阵（WQ、WK、WV）来生成对应的Query向量（q）、Key向量（k）和Value向量（v）。

image.png

计算过程可以分解为以下步骤：

  1. 计算注意力分数（Attention Score）: 对于一个给定的q，我们计算它与序列中所有k的点积。这个分数决定了在编码当前词元时，我们应该对其他词元投入多少关注。
  2. 缩放（Scaling）: 将计算出的分数除以d_k（Key向量的维度）的平方根。 这一步是为了防止在d_k较大时点积结果过大，导致softmax函数进入梯度极小的区域，从而使得训练过程更加稳定。
  3. Softmax: 对缩放后的分数应用softmax函数，将其转换为概率分布。这些概率值（权重）的和为1。
  4. 加权求和: 将每个v向量乘以其对应的softmax权重，然后将所有加权后的向量相加，得到该位置的自注意力输出。

整个过程可以用一个公式概括，即“缩放点积注意力”（Scaled Dot-Product Attention）：

Attention(Q,K,V)=softmax(QKTdk)V \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V Attention(Q,K,V)=softmax(dk​​QKT​)V

PyTorch 代码实现 (缩放点积注意力):

import torch.nn.functional as F
def scaled_dot_product_attention(q, k, v, mask=None):
"""
计算缩放点积注意力
q: [batch_size, n_heads, seq_len, d_k]
k: [batch_size, n_heads, seq_len, d_k]
v: [batch_size, n_heads, seq_len, d_v]
mask: [batch_size, 1, 1, seq_len] or [batch_size, 1, seq_len, seq_len]
"""
d_k = q.size(-1)
# 1. 计算注意力分数: (Q * K^T) / sqrt(d_k)
scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k)
# 2. 应用掩码 (如果提供)
if mask is not None:
# 将掩码中为0的位置填充为一个非常小的负数，这样在softmax后会趋近于0
scores = scores.masked_fill(mask == 0, -1e9)
# 3. 计算softmax得到注意力权重
p_attn = F.softmax(scores, dim=-1)
# 4. 加权求和
return torch.matmul(p_attn, v), p_attn
2.3 多头注意力机制（Multi-Head Attention）

与其只进行一次注意力计算，Transformer的作者发现将模型维度d_model拆分成h个“头”（heads），并为每个头独立地学习Q、K、V的投影（线性变换），然后并行地执行注意力计算会更有益。 这就是多头注意力机制。

多头注意力机制允许模型在不同的表示子空间中共同关注来自不同位置的信息。 每个头可以学习到不同方面的语义关联。例如，一个头可能关注语法依赖，而另一个头可能关注语义上的相似性。

计算过程：

  1. 将输入的Q, K, V（初始时，它们都是相同的输入嵌入）分别通过h个独立的线性层，投影成h组低维度的q_i, k_i, v_i。
  2. 对这h组q_i, k_i, v_i并行地执行缩放点积注意力计算，得到h个输出head_i。
  3. 将这h个输出head_i拼接（Concatenate）起来。
  4. 将拼接后的结果再通过一个最终的线性层进行一次投影，得到多头注意力的最终输出。

这个过程可以表示为：

MultiHead(Q,K,V)=Concat(head1,…,headh)WO \text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \dots, \text{head}_h)W^O MultiHead(Q,K,V)=Concat(head1​,…,headh​)WO
where headi=Attention(QWiQ,KWiK,VWiV) \text{where head}_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V) where headi​=Attention(QWiQ​,KWiK​,VWiV​)

在论文中，h被设为8，每个头的d_k和d_v被设为d_model / h = 512 / 8 = 64。

PyTorch 代码实现：

class MultiHeadAttention(nn.Module):
def __init__(self, d_model, n_heads):
super(MultiHeadAttention, self).__init__()
assert d_model % n_heads == 0
self.d_model = d_model
self.n_heads = n_heads
self.d_k = d_model // n_heads # d_k = d_q
self.d_v = d_model // n_heads
# 定义Q, K, V和输出的线性层
self.W_q = nn.Linear(d_model, d_model)
self.W_k = nn.Linear(d_model, d_model)
self.W_v = nn.Linear(d_model, d_model)
self.W_o = nn.Linear(d_model, d_model)
def forward(self, q, k, v, mask=None):
"""
q, k, v: [batch_size, seq_len, d_model]
mask: 掩码
"""
batch_size = q.size(0)
# 1. 线性投影并切分成多个头
# [batch_size, seq_len, d_model] -> [batch_size, n_heads, seq_len, d_k]
q_s = self.W_q(q).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
k_s = self.W_k(k).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
v_s = self.W_v(v).view(batch_size, -1, self.n_heads, self.d_v).transpose(1, 2)
# 2. 对每个头应用缩放点积注意力
# context: [batch_size, n_heads, seq_len, d_v], attn: [batch_size, n_heads, seq_len, seq_len]
context, attn = scaled_dot_product_attention(q_s, k_s, v_s, mask=mask)
# 3. 拼接多头输出并进行最终的线性变换
# [batch_size, n_heads, seq_len, d_v] -> [batch_size, seq_len, d_model]
context = context.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model)
output = self.W_o(context)
return output, attn
2.4 前馈神经网络（Position-wise Feed-Forward Networks）

在每个编码器和解码器层中，多头注意力子层的输出会经过一个逐位置的前馈神经网络（FFN）。 这个FFN由两个线性变换和一个ReLU激活函数组成。

FFN(x)=max⁡(0,xW1+b1)W2+b2 \text{FFN}(x) = \max(0, xW_1 + b_1)W_2 + b_2 FFN(x)=max(0,xW1​+b1​)W2​+b2​

这个操作是“逐位置”的，意味着它独立地应用于序列中的每个位置（每个词元的表示向量），但层与层之间不共享参数。 它的作用是对注意力子层提取的特征进行非线性变换，增加模型的表示能力。在论文中，输入和输出的维度d_model是512，而中间层的维度d_ff是2048。

PyTorch 代码实现：

class PositionwiseFeedForward(nn.Module):
def __init__(self, d_model, d_ff):
super(PositionwiseFeedForward, self).__init__()
self.fc1 = nn.Linear(d_model, d_ff)
self.fc2 = nn.Linear(d_ff, d_model)
self.relu = nn.ReLU()
def forward(self, x):
"""
x: [batch_size, seq_len, d_model]
"""
return self.fc2(self.relu(self.fc1(x)))
2.5 残差连接（Residual Connections）与层归一化（Layer Normalization）

为了构建更深层次的网络并有效训练，Transformer在每个子层（多头注意力和FFN）的周围都使用了残差连接，然后进行层归一化（Add & Norm）。

残差连接: 源自ResNet，它将子层的输入直接加到子层的输出上。 这样做可以有效地缓解深度神经网络中的梯度消失问题，使得信息和梯度能够更容易地在网络中传播。 其操作为 x + Sublayer(x)。

层归一化（Layer Normalization）: 与批量归一化（Batch Normalization）不同，层归一化是对每个样本在特征维度上进行归一化，而不是对一个批次在样本维度上进行。 这使得它独立于批次大小，在NLP任务中表现更稳定。其作用是稳定训练过程，加速模型收敛。

PyTorch 代码实现 (Add & Norm):

class LayerNorm(nn.Module):
def __init__(self, features, eps=1e-6):
super(LayerNorm, self).__init__()
# gamma 和 beta 是可学习的仿射变换参数
self.gamma = nn.Parameter(torch.ones(features))
self.beta = nn.Parameter(torch.zeros(features))
self.eps = eps
def forward(self, x):
"""
x: [batch_size, seq_len, d_model]
"""
# 在最后一个维度（特征维度）上计算均值和方差
mean = x.mean(-1, keepdim=True)
std = x.std(-1, keepdim=True)
# 归一化并应用仿射变换
return self.gamma * (x - mean) / (std + self.eps) + self.beta

这个组件通常会包装在子层外部，例如：norm(x + sublayer(x))。

三、 编码器（Encoder）的完整结构

通过组合上述模块，我们可以构建一个完整的编码器层。每个编码器层包含两个主要的子层：

  1. 多头自注意力（Multi-Head Self-Attention）
  2. 逐位置前馈神经网络（Position-wise Feed-Forward Network）

每个子层都包裹在“Add & Norm”组件中。

编码器则是由N个这样的编码器层堆叠而成。 底层编码器的输入是词嵌入和位置编码的和，而其他编码器的输入则是其前一层编码器的输出。

PyTorch 代码实现 (编码器层与编码器):

class EncoderLayer(nn.Module):
def __init__(self, d_model, n_heads, d_ff):
super(EncoderLayer, self).__init__()
self.enc_self_attn = MultiHeadAttention(d_model, n_heads)
self.pos_ffn = PositionwiseFeedForward(d_model, d_ff)
self.layernorm1 = LayerNorm(d_model)
self.layernorm2 = LayerNorm(d_model)
self.dropout = nn.Dropout(0.1)
def forward(self, enc_inputs, enc_self_attn_mask):
"""
enc_inputs: [batch_size, src_len, d_model]
enc_self_attn_mask: [batch_size, 1, src_len, src_len]
"""
# 1. 多头自注意力 + Add & Norm
# 在自注意力中，q, k, v 都来自 enc_inputs
attn_output, _ = self.enc_self_attn(enc_inputs, enc_inputs, enc_inputs, enc_self_attn_mask)
# 残差连接和层归一化
enc_inputs = self.layernorm1(enc_inputs + self.dropout(attn_output))
# 2. 前馈神经网络 + Add & Norm
ffn_output = self.pos_ffn(enc_inputs)
# 残差连接和层归一化
enc_outputs = self.layernorm2(enc_inputs + self.dropout(ffn_output))
return enc_outputs
class Encoder(nn.Module):
def __init__(self, vocab_size, d_model, n_layers, n_heads, d_ff):
super(Encoder, self).__init__()
self.src_emb = nn.Embedding(vocab_size, d_model)
self.pos_emb = PositionalEncoding(d_model)
self.layers = nn.ModuleList([EncoderLayer(d_model, n_heads, d_ff) for _ in range(n_layers)])
def forward(self, enc_inputs):
"""
enc_inputs: [batch_size, src_len]
"""
# 1. 输入嵌入和位置编码
enc_outputs = self.src_emb(enc_inputs)
enc_outputs = self.pos_emb(enc_outputs)
# 2. 创建Padding Mask
# 这个掩码用于在自注意力中忽略padding部分的词元
enc_self_attn_mask = (enc_inputs != 0).unsqueeze(1).unsqueeze(2) # 假设0是PAD token的索引
# 3. 堆叠编码器层
for layer in self.layers:
enc_outputs = layer(enc_outputs, enc_self_attn_mask)
return enc_outputs

四、 解码器（Decoder）的完整结构

解码器的目标是生成输出序列。它的结构与编码器层相似，但有两点关键不同，这体现在它包含了三个子层。

  1. 带掩码的多头自注意力（Masked Multi-Head Self-Attention）: 这是解码器的第一个子层。由于在生成第i个词时，模型只能看到第i个词之前（包括第i个词）的输出，而不能看到未来的信息，因此需要一个“掩码”来阻止向左的信息流。 这个掩码会屏蔽掉注意力分数矩阵上三角部分（对应未来的位置）。

  2. 编码器-解码器注意力（Encoder-Decoder Attention）: 这是解码器的第二个子层，有时也称为“交叉注意力”（Cross-Attention）。 在这一层中，Query（Q）来自前一个解码器子层（带掩码的自注意力层）的输出，而Key（K）和Value（V）则来自编码器最终的输出。 这使得解码器在生成每个词元时，都能关注到输入序列的所有部分，从而决定当前最相关的信息是什么。

  3. 逐位置前馈神经网络（Position-wise Feed-Forward Network）: 与编码器中的FFN完全相同。

同样，每个子层也都包裹在“Add & Norm”组件中。

PyTorch 代码实现 (解码器层与解码器):

def get_attn_subsequence_mask(seq):
"""
创建一个上三角矩阵形式的掩码，用于解码器的自注意力。
seq: [batch_size, tgt_len]
"""
attn_shape = [seq.size(0), seq.size(1), seq.size(1)]
# 创建一个对角线及以下为1，以上为0的矩阵
subsequence_mask = torch.triu(torch.ones(attn_shape), diagonal=1).byte()
return subsequence_mask == 0 # 反转，使有效部分为True
class DecoderLayer(nn.Module):
def __init__(self, d_model, n_heads, d_ff):
super(DecoderLayer, self).__init__()
self.dec_self_attn = MultiHeadAttention(d_model, n_heads)
self.dec_enc_attn = MultiHeadAttention(d_model, n_heads)
self.pos_ffn = PositionwiseFeedForward(d_model, d_ff)
self.layernorm1 = LayerNorm(d_model)
self.layernorm2 = LayerNorm(d_model)
self.layernorm3 = LayerNorm(d_model)
self.dropout = nn.Dropout(0.1)
def forward(self, dec_inputs, enc_outputs, dec_self_attn_mask, dec_enc_attn_mask):
"""
dec_inputs: [batch_size, tgt_len, d_model]
enc_outputs: [batch_size, src_len, d_model]
dec_self_attn_mask: [batch_size, 1, tgt_len, tgt_len] (结合了padding mask和subsequence mask)
dec_enc_attn_mask: [batch_size, 1, tgt_len, src_len] (padding mask for encoder output)
"""
# 1. 带掩码的多头自注意力 + Add & Norm
self_attn_output, _ = self.dec_self_attn(dec_inputs, dec_inputs, dec_inputs, dec_self_attn_mask)
dec_inputs = self.layernorm1(dec_inputs + self.dropout(self_attn_output))
# 2. 编码器-解码器注意力 + Add & Norm
# Q来自解码器，K, V来自编码器
enc_attn_output, _ = self.dec_enc_attn(dec_inputs, enc_outputs, enc_outputs, dec_enc_attn_mask)
dec_inputs = self.layernorm2(dec_inputs + self.dropout(enc_attn_output))
# 3. 前馈神经网络 + Add & Norm
ffn_output = self.pos_ffn(dec_inputs)
dec_outputs = self.layernorm3(dec_inputs + self.dropout(ffn_output))
return dec_outputs
class Decoder(nn.Module):
def __init__(self, vocab_size, d_model, n_layers, n_heads, d_ff):
super(Decoder, self).__init__()
self.tgt_emb = nn.Embedding(vocab_size, d_model)
self.pos_emb = PositionalEncoding(d_model)
self.layers = nn.ModuleList([DecoderLayer(d_model, n_heads, d_ff) for _ in range(n_layers)])
def forward(self, dec_inputs, enc_inputs, enc_outputs):
"""
dec_inputs: [batch_size, tgt_len]
enc_inputs: [batch_size, src_len] (用于创建dec_enc_attn_mask)
enc_outputs: [batch_size, src_len, d_model]
"""
# 1. 目标序列嵌入和位置编码
dec_outputs = self.tgt_emb(dec_inputs)
dec_outputs = self.pos_emb(dec_outputs)
# 2. 创建掩码
# Padding mask for decoder self-attention
dec_self_attn_pad_mask = (dec_inputs != 0).unsqueeze(1).unsqueeze(2)
# Subsequence mask for decoder self-attention
dec_self_attn_subsequence_mask = get_attn_subsequence_mask(dec_inputs)
# 结合两种掩码
dec_self_attn_mask = dec_self_attn_pad_mask & dec_self_attn_subsequence_mask
# Padding mask for encoder-decoder attention
dec_enc_attn_mask = (enc_inputs != 0).unsqueeze(1).unsqueeze(3)
# 3. 堆叠解码器层
for layer in self.layers:
dec_outputs = layer(dec_outputs, enc_outputs, dec_self_attn_mask, dec_enc_attn_mask)
return dec_outputs

五、 最终输出与模型整合

解码器堆栈的输出是一个浮点数向量序列。为了将其转换为最终的输出词元概率，需要经过最后两个步骤：

  1. 线性层（Linear Layer）: 一个全连接层，其权重与词嵌入层共享（这是一个常用的技巧，可以减少模型参数），将解码器输出的d_model维向量投影到词汇表大小（vocab_size）的维度。这个输出通常被称为“logits”。
  2. Softmax层: 对logits应用softmax函数，将其转换为每个词元的概率分布。 概率最高的词元就是该时间步的预测输出。

现在，我们可以将编码器、解码器和最后的线性层整合在一起，构建完整的Transformer模型。

PyTorch 代码实现 (完整Transformer):

class Transformer(nn.Module):
def __init__(self, src_vocab_size, tgt_vocab_size, d_model, n_layers, n_heads, d_ff):
super(Transformer, self).__init__()
self.encoder = Encoder(src_vocab_size, d_model, n_layers, n_heads, d_ff)
self.decoder = Decoder(tgt_vocab_size, d_model, n_layers, n_heads, d_ff)
self.projection = nn.Linear(d_model, tgt_vocab_size)
def forward(self, enc_inputs, dec_inputs):
"""
enc_inputs: [batch_size, src_len]
dec_inputs: [batch_size, tgt_len]
"""
# 编码器处理输入
enc_outputs = self.encoder(enc_inputs)
# 解码器处理目标序列和编码器输出
dec_outputs = self.decoder(dec_inputs, enc_inputs, enc_outputs)
# 最终线性投影
dec_logits = self.projection(dec_outputs) # [batch_size, tgt_len, tgt_vocab_size]
# 返回每个位置的logits，通常在计算损失时会内部应用softmax
return dec_logits.view(-1, dec_logits.size(-1))

六、 总结与展望

Transformer模型的提出是自然语言处理领域的一个里程碑。它通过创新的自注意力机制，成功地解决了RNN在处理长距离依赖和并行计算方面的瓶颈。 其核心思想——通过注意力机制动态地构建序列中任意两个位置之间的关联——被证明是极其有效的。

Transformer的关键创新点可以总结为：

  • 完全基于注意力: 摒弃了循环和卷积结构，完全依赖自注意力机制处理序列数据。
  • 多头注意力: 从不同子空间捕捉信息，增强了模型的表达能力。
  • 位置编码: 解决了非顺序架构中如何引入序列顺序信息的问题。
  • 高效的并行计算: 相比RNN的顺序计算模式，Transformer的计算可以高度并行化，极大地缩短了训练时间。

正是这些突破性的设计，使得训练更大、更深、更复杂的语言模型成为可能，直接催生了BERT、GPT、T5等一系列强大的预训练模型，它们在文本分类、情感分析、机器翻译、文本生成等几乎所有NLP任务中都取得了显著的成果，并持续推动着人工智能技术的发展。 Transformer架构的成功也启发了其在计算机视觉、语音识别等其他领域的应用，展现了其作为一种通用特征提取器的巨大潜力。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/936586.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

联合训练

联合训练

联合训练1.Educational Codeforces Round 183 A：取模 B：贪心思路有点问题，感谢队友教学对于问题，关注整体而不是过程，即对于操作，重要的不是操作，而是采用操作发生了什么，带来什么影响，以及多个状态叠加影响(…
阅读更多...
生成式AI基础设施面临网络攻击威胁：企业安全新挑战

生成式AI基础设施面临网络攻击威胁：企业安全新挑战

根据Gartner最新研究，29%的企业生成式AI应用在过去一年遭受网络攻击，32%企业遭遇提示结构漏洞利用，62%企业成为深度伪造攻击受害者。文章分析了Chatbot助手的安全脆弱性及防护建议。GenAI-Infrastruktur anfllig fr…
阅读更多...
vxe-table 利用配置 ajax 方式自动请求资料，适用于简单场景的列表

vxe-table 利用配置 ajax 方式自动请求资料，适用于简单场景的列表

vxe-table 利用配置 ajax 方式自动请求资料，适用于简单场景的列表2025-10-14 08:12 tlnshuju 阅读(0) 评论(0) 收藏 举报pre { white-space: pre !important; word-wrap: normal !important; overflow-x: auto !i…
阅读更多...
实用指南：SQL Server从入门到项目实践（超值版）读书笔记 27

实用指南：SQL Server从入门到项目实践（超值版）读书笔记 27

实用指南：SQL Server从入门到项目实践（超值版）读书笔记 27pre { white-space: pre !important; word-wrap: normal !important; overflow-x: auto !important; display: block !important; font-family: "Cons…
阅读更多...
VMware ESXi 9.0.1.0 macOS Unlocker OEM BIOS 2.7 H3C 新华三 定制版

VMware ESXi 9.0.1.0 macOS Unlocker OEM BIOS 2.7 H3C 新华三 定制版

VMware ESXi 9.0.1.0 macOS Unlocker & OEM BIOS 2.7 H3C 新华三 定制版VMware ESXi 9.0.1.0 macOS Unlocker & OEM BIOS 2.7 H3C 新华三 定制版 VMware ESXi 9.0.1.0 macOS Unlocker & OEM BIOS 2.7 标准…
阅读更多...
LGP8866 [NOIP 2022] 喵了个喵 学习笔记

LGP8866 [NOIP 2022] 喵了个喵 学习笔记

LGP8866 [NOIP 2022] 喵了个喵 学习笔记 \(\texttt{Luogu Link}\) 前言 史。无需多言。 本笔记也许参考了这篇题解。对于一道构造题来说，此解析写的确实认真负责，配最高赞。 题意简述 小 \(\texttt{E}\) 喜欢上了一款…
阅读更多...
大数据毕业设计选题推荐-基于大材料的全国饮品门店数据可视化分析系统-Hadoop-Spark-数据可视化-BigData

大数据毕业设计选题推荐-基于大材料的全国饮品门店数据可视化分析系统-Hadoop-Spark-数据可视化-BigData

pre { white-space: pre !important; word-wrap: normal !important; overflow-x: auto !important; display: block !important; font-family: "Consolas", "Monaco", "Courier New", …
阅读更多...
edge每次打开不是用自己的账户，还要选择一次

edge每次打开不是用自己的账户，还要选择一次

原因：有一个“用户配置1”，被当作默认配置了，删除后，就能够用自己的账户自动登录了。
阅读更多...
LibreOffice Impress播放不出视频的解决方法

LibreOffice Impress播放不出视频的解决方法

https://codecguide.com/download_k-lite_codec_pack_basic.htm 下载安装这里的 K-Lite Codec Pack Basic 就可以了。 参考资料： https://wiki.documentfoundation.org/Media_Support/Windows
阅读更多...
pypdfium2 PDFium 的python 包装

pypdfium2 PDFium 的python 包装

pypdfium2 PDFium 的python 包装pypdfium2 是对于PDFium的python 包装,官方说明处理任务性能可以接近PyMuPDF 说明 pypdfium2 内部基于了ctypesgen 包装（相比原始进行了自己的扩展），生成python 绑定的代码，这样可以…
阅读更多...
VMware ESXi 9.0.1.0 macOS Unlocker OEM BIOS 2.7 Inspur 浪潮 定制版

VMware ESXi 9.0.1.0 macOS Unlocker OEM BIOS 2.7 Inspur 浪潮 定制版

VMware ESXi 9.0.1.0 macOS Unlocker & OEM BIOS 2.7 Inspur 浪潮 定制版VMware ESXi 9.0.1.0 macOS Unlocker & OEM BIOS 2.7 Inspur 浪潮 定制版 VMware ESXi 9.0.1.0 macOS Unlocker & OEM BIOS 2.7 标…
阅读更多...
Exchange 异常关机后无法登录owa/ecp 以及ems无法连接远程服务器

Exchange 异常关机后无法登录owa/ecp 以及ems无法连接远程服务器

登陆owa ecp页面，能显示输入用户名密码界面，输入后报网页已丢失 服务器上用ems连接服务器，报 New-PSSession : [exchange.test.com] 连接到远程服务器 exchange.test.com 失败，并显示以下错误消息: [ClientAccessS…
阅读更多...
【GitHub每日速递 251014】Claude Code：用自然语言命令让编码快到飞起！

【GitHub每日速递 251014】Claude Code：用自然语言命令让编码快到飞起！

原文: https://mp.weixin.qq.com/s/Th2Dg9G4O4wMD-QDHcW84A Claude Code：用自然语言命令让编码快到飞起！ Claude Code是一个基于自然语言交互的智能终端编程助手工具。简单讲，它能理解你的代码库，通过对话帮你写代…
阅读更多...
新项目完结，Ai Agent 智能体、拖拉拽编排！

新项目完结，Ai Agent 智能体、拖拉拽编排！

作者：小傅哥 博客：https://bugstack.cn沉淀、分享、成长，让自己和他人都能有所收获！😄大家好，我是技术UP主小傅哥。 这是一套综合前后端 + Dev-Ops，基于 Spring Ai 框架实现，Ai Agent 智能体。耗时7个多月，3…
阅读更多...
硅谷大佬揭秘创业者成功法则

硅谷大佬揭秘创业者成功法则

Ben Horowitz的创业故事让人震撼：18个月内把公司从2万营收做到7.5亿估值上市。这位硅谷大佬分享的经验，颠覆了很多人对创业的认知。 💡 三个核心观点让人印象深刻：真正的创业者都是被逼出来的。Ben说得很直接：&q…
阅读更多...
2025年南通宠物医院最新权威推荐榜：专业诊疗与暖心服务口碑之选

2025年南通宠物医院最新权威推荐榜：专业诊疗与暖心服务口碑之选

2025年南通宠物医院最新权威推荐榜：专业诊疗与暖心服务口碑之选随着宠物经济的蓬勃发展，越来越多的家庭选择养宠作为生活的一部分。然而，宠物健康问题也随之而来，选择一家可靠的宠物医院显得尤为重要。为了帮助筛选…
阅读更多...
2025年10月学校家具定制厂家最新推荐排行榜，课桌椅，宿舍床，图书馆家具，教室家具公司推荐！

2025年10月学校家具定制厂家最新推荐排行榜，课桌椅，宿舍床，图书馆家具，教室家具公司推荐！

2025年10月学校家具定制厂家最新推荐排行榜：课桌椅、宿舍床、图书馆家具、教室家具公司推荐随着教育行业的不断发展，学校家具的需求也在逐年增长。优质的学校家具不仅能够提升学生的学习体验，还能为学校的整体形象加…
阅读更多...
2025年10月螺杆泵厂家最新推荐排行榜，单螺杆泵，双螺杆泵，三螺杆泵，高效耐用品质之选！

2025年10月螺杆泵厂家最新推荐排行榜，单螺杆泵，双螺杆泵，三螺杆泵，高效耐用品质之选！

2025年10月螺杆泵厂家最新推荐排行榜，单螺杆泵，双螺杆泵，三螺杆泵，高效耐用品质之选！引言螺杆泵作为一种重要的流体输送设备，在化工、石油、食品、制药等行业中有着广泛的应用。随着技术的不断进步和市场需求的变…
阅读更多...
2025年恒温恒湿系统厂家最新推荐榜单，精加工车间/厂房/美术馆/仓库/计算机房/档案室/工业/工厂车间恒温恒湿系统公司推荐

2025年恒温恒湿系统厂家最新推荐榜单，精加工车间/厂房/美术馆/仓库/计算机房/档案室/工业/工厂车间恒温恒湿系统公司推荐

2025年恒温恒湿系统厂家最新推荐榜单，精加工车间/厂房/美术馆/仓库/计算机房/档案室/工业/工厂车间恒温恒湿系统公司推荐随着工业和科技的不断发展，恒温恒湿系统在各个领域的应用越来越广泛。无论是精加工车间、厂房…
阅读更多...
2025年会议系统厂家最新推荐排行榜，专业音视频会议系统，智能会议解决方案，高清视频会议系统公司推荐！

2025年会议系统厂家最新推荐排行榜，专业音视频会议系统，智能会议解决方案，高清视频会议系统公司推荐！

2025年会议系统厂家最新推荐排行榜，专业音视频会议系统，智能会议解决方案，高清视频会议系统公司推荐！随着数字化转型的加速，企业对高效、智能的会议系统需求日益增长。专业的音视频会议系统和智能会议解决方案成为…
阅读更多...
最新文章

Copyright @ 2022~2023