高级网站开发工程师考试题网站申请qq

高级网站开发工程师考试题,网站申请qq,乌海品牌网站建设,建网站联系上下文嵌入向量#xff08;contextualized embedding#xff09; 示例#xff1a;处理句子 I love AI步骤1: 初始化设置步骤2: 输入嵌入和位置编码步骤3: 生成Q、K、V矩阵步骤4: 注意力计算#xff08;详细过程#xff09;步骤5: 合并多头输出步骤6: 残差连接…上下文嵌入向量contextualized embedding示例处理句子 I love AI步骤1: 初始化设置步骤2: 输入嵌入和位置编码步骤3: 生成Q、K、V矩阵步骤4: 注意力计算详细过程步骤5: 合并多头输出步骤6: 残差连接和层归一化步骤7: 前馈神经网络步骤8: 第二个残差连接和层归一化步骤9: 完整流程总结可视化流程这节我们展示从输入嵌入向量(input embedding)到上下文嵌入向量(contextualized embedding)的完整过程。我们将用一个简化版的Transformer层来处理一个短句。示例处理句子 “I love AI”步骤1: 初始化设置importtorchimporttorch.nnasnnimporttorch.nn.functionalasFimportmath# 设置超参数d_model12# 嵌入维度通常为768这里简化n_heads3# 注意力头数通常为12d_kd_model//n_heads# 每个头的维度 12/3 4seq_len3# 句子长度I, love, AIbatch_size1# 批大小vocab_size1000# 词汇表大小查看值变化print(f模型配置: d_model{d_model}, n_heads{n_heads}, d_k{d_k})print(f输入序列: I love AI (长度{seq_len}))输出将模型配置为: d_model12, n_heads3, d_k4输入序列: ‘I love AI’ (长度3)步骤2: 输入嵌入和位置编码classEmbeddingsWithPosition(nn.Module):嵌入层 位置编码def__init__(self,vocab_size,d_model):super().__init__()self.token_embeddingnn.Embedding(vocab_size,d_model)self.position_embeddingnn.Embedding(1000,d_model)# 最大位置defforward(self,token_ids):# token_ids: [batch, seq_len] [1, 3]# 示例token_ids tensor([[10, 20, 30]])# 步骤1生成位置索引 positionstorch.arange(token_ids.size(1)).unsqueeze(0)# token_ids.size(1) 3序列长度# torch.arange(3) tensor([0, 1, 2])# .unsqueeze(0) 增加batch维度 tensor([[0, 1, 2]])positionspositions.expand_as(token_ids)# positions: [[0, 1, 2]]# token_ids: [[10, 20, 30]] 形状相同# expand_as复制到batch维度 仍然是 [[0, 1, 2]]# 步骤2获取词嵌入 token_embedsself.token_embedding(token_ids)# token_embeds.shape [1, 3, 12]# 过程从词嵌入矩阵中查找第10、20、30行的向量# 步骤3获取位置嵌入 pos_embedsself.position_embedding(positions)# pos_embeds.shape [1, 3, 12]# 过程从位置嵌入矩阵中查找第0、1、2行的向量# 步骤4相加 returntoken_embedspos_embeds# 形状仍为 [1, 3, 12]# 创建嵌入层embeddingsEmbeddingsWithPosition(vocab_size,d_model)# 假设token IDs: I10, love20, AI30input_idstorch.tensor([[10,20,30]])# [1, 3]# 获得输入嵌入input_embeddingsembeddings(input_ids)# [1, 3, 12]查看值变化print(步骤1: 输入嵌入 位置编码)print(f输入形状:{input_embeddings.shape})print(f输入值示例第一个token:)print(input_embeddings[0,0].detach().numpy().round(3))print()输出输入嵌入 位置编码输入形状: torch.Size([1, 3, 12])输入值示例第一个token:[ 1.252 0.676 -0.077 -0.821 -0.958 -1.387 1.118 0.18 -0.108 -2.223 0.748 0.784]nn.Embedding(vocab_size, d_model)就是创建了一个 (vocab_size, d_model) 的可训练矩阵专门用于将整数索引映射为稠密向量。与 nn.Linear 的区别 nn.Linear 是做矩阵乘法 偏置而 nn.Embedding 是纯粹的索引查找。不过从数学上看用一个one-hot向量乘以嵌入矩阵结果就是索引查找。因此Embedding层可以看作是一个没有偏置、输入为one-hot向量的Linear层的高效实现。self.token_embedding(token_ids)本质上就是在查找或索引每个token_id对应的嵌入向量。这里需要解释下self.position_embedding nn.Embedding(1000, d_model)位置不是固定的嘛比如0,1,2为什么还要用训练矩阵位置编号0,1,2,…只告诉你第几个但可训练的位置嵌入告诉你这个位置通常有什么作用。类比位置编号 你的学号20230012023002…→ 只是个编号位置嵌入 你的座位特点前排学霸区、后排休息区、靠窗风景位→ 有实际意义为什么需要学习不同任务情感分析中句首重要机器翻译中每个位置都重要不同语言中文动词靠前英文动词位置灵活不同长度第10个字在短文中是结尾在长文中是开头模型自己发现规律让数据告诉模型什么位置重要self.position_embedding和self.token_embedding的列数维度必须一致但行数数量可以不同步骤3: 生成Q、K、V矩阵classMultiHeadAttention(nn.Module):def__init__(self,d_model,n_heads):super().__init__()self.d_modeld_model self.n_headsn_heads self.d_kd_model//n_heads# Q、K、V的线性变换self.W_Qnn.Linear(d_model,d_model)self.W_Knn.Linear(d_model,d_model)self.W_Vnn.Linear(d_model,d_model)self.W_Onn.Linear(d_model,d_model)defgenerate_qkv(self,x):生成Q、K、V矩阵batch_size,seq_len,_x.shape# 线性变换得到Q、K、VQself.W_Q(x)# [batch, seq_len, d_model]Kself.W_K(x)# [batch, seq_len, d_model]Vself.W_V(x)# [batch, seq_len, d_model]# 重塑为多头格式 [batch, seq_len, n_heads, d_k]QQ.view(batch_size,seq_len,self.n_heads,self.d_k)KK.view(batch_size,seq_len,self.n_heads,self.d_k)VV.view(batch_size,seq_len,self.n_heads,self.d_k)returnQ,K,V# 创建注意力层attentionMultiHeadAttention(d_model,n_heads)# 生成Q、K、VQ,K,Vattention.generate_qkv(input_embeddings)查看值变化print(生成Q、K、V矩阵)print(fQ形状:{Q.shape})# [1, 3, 3, 4]print(fK形状:{K.shape})print(fV形状:{V.shape})print()# 查看第一个token的第一个头的Q、K、V值print(第一个tokenI在第一个头的表示:)print(fQ (查询向量):{Q[0,0,0].detach().numpy().round(3)})print(fK (键向量):{K[0,0,0].detach().numpy().round(3)})print(fV (值向量):{V[0,0,0].detach().numpy().round(3)})print()输出生成Q、K、V矩阵Q形状: torch.Size([1, 3, 3, 4])K形状: torch.Size([1, 3, 3, 4])V形状: torch.Size([1, 3, 3, 4])第一个token‘I’在第一个头的表示:Q (查询向量): [ 1.16 0.105 -1.654 -1.009]K (键向量): [ 1.78 -0.608 1.395 2.054]V (值向量): [-0.301 0.126 -1.675 0.474]步骤4: 注意力计算详细过程defcompute_attention(Q,K,V,maskNone):计算缩放点积注意力batch_size,seq_len,n_heads,d_kQ.shape# 1. 计算Q和K的点积# 维度: [batch, n_heads, seq_len, d_k] × [batch, n_heads, d_k, seq_len]# 结果: [batch, n_heads, seq_len, seq_len]K_tK.transpose(2,3)# 转置最后两个维度scorestorch.matmul(Q,K_t)/math.sqrt(d_k)# 2. 应用softmax得到注意力权重ifmaskisnotNone:scoresscores.masked_fill(mask0,-1e9)attention_weightsF.softmax(scores,dim-1)# 3. 用注意力权重加权V# [batch, n_heads, seq_len, seq_len] × [batch, n_heads, seq_len, d_k]# 结果: [batch, n_heads, seq_len, d_k]weighted_Vtorch.matmul(attention_weights,V)returnweighted_V,attention_weights# 调整维度顺序: [batch, seq_len, n_heads, d_k] - [batch, n_heads, seq_len, d_k]Q_permQ.permute(0,2,1,3)K_permK.permute(0,2,1,3)V_permV.permute(0,2,1,3)# 计算注意力weighted_V,attention_weightscompute_attention(Q_perm,K_perm,V_perm)查看值变化print( 注意力计算)print(f注意力输出形状:{weighted_V.shape})print(f注意力权重形状:{attention_weights.shape})print(\n注意力权重矩阵第一个头:)print(行 查询token (关注者))print(列 键token (被关注者))print(attention_weights[0,0].detach().numpy().round(3))print(\n解释: 每个token如何关注其他token)foriinrange(seq_len):token_name[I,love,AI][i]weightsattention_weights[0,0,i].detach().numpy()print(f{token_name} 的关注分布:{weights.round(3)})print()输出注意力计算注意力输出形状: torch.Size([1, 3, 3, 4])注意力权重形状: torch.Size([1, 3, 3, 3])注意力权重矩阵第一个头:行 查询token (关注者)列 键token (被关注者)[[0.245 0.644 0.111][0.391 0.275 0.334][0.412 0.281 0.307]]解释: 每个token如何关注其他token‘I’ 的关注分布: [0.245 0.644 0.111]‘love’ 的关注分布: [0.391 0.275 0.334]‘AI’ 的关注分布: [0.412 0.281 0.307]步骤5: 合并多头输出defcombine_heads(weighted_V,batch_size,seq_len,d_model):合并多个注意力头的输出# 当前形状: [batch, n_heads, seq_len, d_k]# 目标形状: [batch, seq_len, d_model]# 1. 转置回 [batch, seq_len, n_heads, d_k]weighted_Vweighted_V.permute(0,2,1,3).contiguous()# 2. 合并最后两个维度combinedweighted_V.view(batch_size,seq_len,d_model)returncombined# 合并多头multi_head_outputcombine_heads(weighted_V,batch_size,seq_len,d_model)查看值变化print( 合并多头输出)print(f合并后形状:{multi_head_output.shape})print(f第一个token合并后表示:{multi_head_output[0,0].detach().numpy().round(3)})print()# 通过输出线性层attention_outputattention.W_O(multi_head_output)print( 注意力子层输出线性变换)print(f注意力子层输出形状:{attention_output.shape})print(f第一个token输出:{attention_output[0,0].detach().numpy().round(3)})print()输出合并多头输出合并后形状: torch.Size([1, 3, 12])第一个token合并后表示: [-0.26 -0.52 -0.104 0.536 -0.23 0.92 -0.151 0.235 -0.375 -0.657 0.072 0.791]注意力子层输出线性变换注意力子层输出形状: torch.Size([1, 3, 12])第一个token输出: [ 0.014 0.172 0.23 0.118 -0.232 0.185 -0.274 0.207 -0.297 -0.075 0.644 -0.492]步骤6: 残差连接和层归一化classLayerNorm(nn.Module):简化版层归一化def__init__(self,features,eps1e-6):super().__init__()self.gammann.Parameter(torch.ones(features))self.betann.Parameter(torch.zeros(features))self.epsepsdefforward(self,x):meanx.mean(-1,keepdimTrue)stdx.std(-1,keepdimTrue)returnself.gamma*(x-mean)/(stdself.eps)self.beta# 残差连接residualinput_embeddingsattention_output# 层归一化layer_norm1LayerNorm(d_model)norm_output1layer_norm1(residual)查看值变化print( 残差连接 层归一化)print(f残差连接: 输入嵌入 注意力输出)print(f归一化后形状:{norm_output1.shape})print(f第一个token归一化后:{norm_output1[0,0].detach().numpy().round(3)})print()输出残差连接 层归一化残差连接: 输入嵌入 注意力输出归一化后形状: torch.Size([1, 3, 12])第一个token归一化后: [ 2.259 -0.111 -0.147 0.104 -0.085 -0.475 -0.026 0.058 -1.686 0.4250.97 -1.286]步骤7: 前馈神经网络classFeedForwardNetwork(nn.Module):前馈神经网络def__init__(self,d_model,d_ff48):# d_ff通常是d_model的4倍super().__init__()self.linear1nn.Linear(d_model,d_ff)self.linear2nn.Linear(d_ff,d_model)self.activationnn.ReLU()defforward(self,x):returnself.linear2(self.activation(self.linear1(x)))# 前馈网络ffnFeedForwardNetwork(d_model,d_ff48)ffn_outputffn(norm_output1)查看值变化print(前馈神经网络)print(fFFN输出形状:{ffn_output.shape})print(fFFN内部维度: d_model{d_model}→ d_ff48 → d_model{d_model})print(f第一个token FFN输出:{ffn_output[0,0].detach().numpy().round(3)})print()输出前馈神经网络FFN输出形状: torch.Size([1, 3, 12])FFN内部维度: d_model12 → d_ff48 → d_model12第一个token FFN输出: [-0.285 -0.161 -0.256 0.26 -0.139 -0.164 0.041 0.24 0.065 -0.145 -0.022 -0.098]步骤8: 第二个残差连接和层归一化# 第二次残差连接final_residualnorm_output1ffn_output# 第二次层归一化layer_norm2LayerNorm(d_model)context_embeddingslayer_norm2(final_residual)查看值变化print( 最终残差连接 层归一化)print(→ 得到上下文嵌入向量!)print(f上下文嵌入向量形状:{context_embeddings.shape})print(f第一个token的上下文嵌入:{context_embeddings[0,0].detach().numpy().round(3)})print()输出最终残差连接 层归一化→ 得到上下文嵌入向量!上下文嵌入向量形状: torch.Size([1, 3, 12])第一个token的上下文嵌入: [ 2.097 -0.224 -0.359 0.433 -0.175 -0.602 0.073 0.365 -1.619 0.346 1.038 -1.373]步骤9: 完整流程总结classTransformerBlock(nn.Module):完整的Transformer块def__init__(self,d_model,n_heads,d_ffNone):super().__init__()ifd_ffisNone:d_ffd_model*4self.attentionMultiHeadAttention(d_model,n_heads)self.norm1LayerNorm(d_model)self.norm2LayerNorm(d_model)self.ffnFeedForwardNetwork(d_model,d_ff)defforward(self,x):完整的前向传播print(*60)print(Transformer块完整流程:)print(*60)# 1. 输入print(f1. 输入嵌入:{x.shape})# 2. 注意力机制Q,K,Vself.attention.generate_qkv(x)print(f2. 生成Q/K/V:{Q.shape})# 3. 计算注意力Q_permQ.permute(0,2,1,3)K_permK.permute(0,2,1,3)V_permV.permute(0,2,1,3)weighted_V,attn_weightscompute_attention(Q_perm,K_perm,V_perm)print(f3. 注意力计算:{weighted_V.shape})# 4. 合并多头batch_size,seq_lenx.shape[:2]multi_headcombine_heads(weighted_V,batch_size,seq_len,self.attention.d_model)attention_outputself.attention.W_O(multi_head)print(f4. 注意力子层输出:{attention_output.shape})# 5. 残差连接 层归一化residual1xattention_output norm1_outputself.norm1(residual1)print(f5. 第一个残差连接层归一化:{norm1_output.shape})# 6. 前馈网络ffn_outputself.ffn(norm1_output)print(f6. 前馈网络:{ffn_output.shape})# 7. 最终输出final_residualnorm1_outputffn_output context_embeddingsself.norm2(final_residual)print(f7. 最终输出上下文嵌入:{context_embeddings.shape})returncontext_embeddings# 运行完整流程print(\n*60)print(完整流程演示)print(*60)transformer_blockTransformerBlock(d_model,n_heads)context_embeddingstransformer_block(input_embeddings)print(\n*60)print(最终结果对比)print(*60)print(\n输入嵌入无上下文:)print(input_embeddings[0,0].detach().numpy().round(3))print(\n上下文嵌入有关联信息:)print(context_embeddings[0,0].detach().numpy().round(3))print(\nV矩阵注意力机制的输入:)print(V[0,0,0].detach().numpy().round(3))print(\n结论: V ≠ 上下文嵌入向量)print(- V: 是注意力计算中的值矩阵)print(- 上下文嵌入: 经过完整Transformer层处理后的结果)可视化流程完整Transformer层流程: 输入嵌入 [1, 3, 12] ↓ ┌─────────────────────────────────┐ │ 生成Q、K、V │ │ - 线性变换 │ │ - 分割多头: [1, 3, 3, 4] │ └─────────────────────────────────┘ ↓ ┌─────────────────────────────────┐ │ 注意力计算 │ │ Q·K^T / √d_k → softmax → 权重 │ │ 权重 × V → 加权输出 │ └─────────────────────────────────┘ ↓ ┌─────────────────────────────────┐ │ 合并多头输出 │ │ [1, 3, 3, 4] → [1, 3, 12] │ │ 线性变换 │ └─────────────────────────────────┘ ↓ ┌─────────────────────────────────┐ │ 残差连接 层归一化 │ │ output norm(x attention(x))│ └─────────────────────────────────┘ ↓ ┌─────────────────────────────────┐ │ 前馈神经网络 │ │ d_model → d_ff → d_model │ └─────────────────────────────────┘ ↓ ┌─────────────────────────────────┐ │ 残差连接 层归一化 │ │ output norm(x FFN(x)) │ └─────────────────────────────────┘ ↓ 上下文嵌入向量 [1, 3, 12]