1.Transformer的word embedding、position embedding、编码器子注意力的掩码

已于 2022-10-12 20:21:56 修改
阅读量1.8k 收藏 6
点赞数 3
分类专栏： deep学习 文章标签： transformer 深度学习 pytorch
于 2022-10-11 17:58:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44846755/article/details/127233200
版权

来源

B站up：deep_thoughts
https://www.bilibili.com/video/BV1cP4y1V7GF/?spm_id_from=333.1007.top_right_bar_window_history.content.click&vd_source=46b0ded1b361f3be84555a12b5121509

目录


Transformer的词向量、位置编码、编码器子注意力的掩码的原理，并用pytorch实现。
首先4个常用的导入

embedding类似于一个字典，里面是英文，src是需要查找的英文在字典中的位置，
src_embedding_table是对应的英文内容。

word embedding

1.序列建模：source和target，里面的字符是单词索引
2.创建embedding_table，1中的索引表示对应table的位置，0留给padding
3.创建src_embedding_table或tgt_embedding_table

第2步

batch_size = 2

生成src_len、tgt_len

src_len=torch.randint(2,5,(batch_size,))
tgt_len=torch.randint(2,5,(batch_size,))

使其固定

src_len = torch.Tensor([2,4]).to(torch.int32)
tgt_len = torch.Tensor([4,3]).to(torch.int32)

此时设置单词最大数为8

#单词索引构成的句子，即每个句子里是单词所在的索引数
#src_seq：[tensor([7, 4]), tensor([2, 1, 5, 4])]
#tgt_seq：[tensor([4, 4, 4, 3]), tensor([5, 7, 6])]
src_seq = [torch.randint(1,max_num_src_words,(L,))for L in src_len]
tgt_seq = [torch.randint(1,max_num_tgt_words,(L,))for L in tgt_len]

L分别取2，4，取2是长度为2的一个元组，取4是长度为4的一个元组
因为长度不一样，需要进行padding，使其对齐。
使用F.pad()补齐，F.pad(补齐对象，（左边几个零，后面几个零）)，默认补0
生成的是一个列表，里面两个元素

src_seq = [F.pad(torch.randint(1,max_num_src_words,(L,)),(0,max(src_len)-L))for L in src_len]
tgt_seq = [F.pad(torch.randint(1,max_num_tgt_words,(L,)),(0,max(tgt_len)-L))for L in tgt_len]

src_seq:[tensor([5, 3, 0, 0, 0]), tensor([4, 2, 1, 5, 0])]
tgt_seq:[tensor([6, 3, 1, 5, 0]), tensor([1, 2, 5, 0, 0])]
进行拼接
使用torch.cat()拼接

src_seq = torch.cat([torch.unsqueeze(F.pad(torch.randint(1,max_num_src_words,(L,)),(0,max(src_len)-L)),0)for L in src_len])
tgt_seq = torch.cat([torch.unsqueeze(F.pad(torch.randint(1,max_num_tgt_words,(L,)),(0,max(tgt_len)-L)),0)for L in tgt_len])

src_seq:[tensor([5, 3, 0, 0, 0]), tensor([4, 2, 1, 5, 0])]
src_seq【2，5】=》【1，2，5】
由列表变成了一个张量

第3步

nn.Embedding(嵌入大小，)、

print(src_embedding_table)
print(src_embedding_table.weight)
print(src_seq)
print(src_embedding)

src_seq中索引是几，就是src_embedding_table中的第几行。

在这里插入图片描述

代码

batch_size = 2

#单词表大小
#单词对应的索引数的最大值
max_num_src_words = 8
max_num_tgt_words = 8
#每一个单词的大小
model_dim=8

#序列最大长度
#一整个句子的最大长度
max_src_seq_len=5
max_tgt_seq_len=5


src_len = torch.Tensor([2,4]).to(torch.int32)
tgt_len = torch.Tensor([4,3]).to(torch.int32) 

#单词索引构成源句子和目标句子，即每个句子里是单词所在的索引数。构建batch，做了padding，默认值为0
#L分别取2，4，取2是长度为2的一个元组，取4是长度为4的一个元组
#src_seq：[tensor([7, 4]), tensor([2, 1, 5, 4])]
#tgt_seq：[tensor([4, 4, 4, 3]), tensor([5, 7, 6])]
src_seq = torch.cat([torch.unsqueeze(F.pad(torch.randint(1,max_num_src_words,(L,)),(0,max(src_len)-L)),0)for L in src_len])
tgt_seq = torch.cat([torch.unsqueeze(F.pad(torch.randint(1,max_num_tgt_words,(L,)),(0,max(tgt_len)-L)),0)for L in tgt_len])

#构造embedding
#一个单词对应一行，从1开始，pad的0，所以0行对应pad
#每一行一个embedding向量，每个单词索引是几，我们就取第几行
src_embedding_table=nn.Embedding(max_num_src_words+1,model_dim)
tgt_embedding_table=nn.Embedding(max_num_tgt_words+1,model_dim)
src_embedding=src_embedding_table(src_seq)
tgt_embedding=tgt_embedding_table(tgt_seq)

positiona embedding

在这里插入图片描述

pos_mat=torch.arange(max_position_len).reshape(-1,1)
i_mat=torch.pow(10000,torch.arange(0,model_dim,2).reshape(1,-1)/model_dim)
print(pos_mat)
print(i_mat)

在这里插入图片描述

pe_embedding_table[:,::2]=torch.sin(pos_mat/i_mat)
pe_embedding_table[:,1::2]=torch.cos(pos_mat/i_mat)

偶数列：
在这里插入图片描述
奇数列：
在这里插入图片描述


pe_embedding=nn.Embedding(max_position_len,model_dim)
pe_embedding.weight=nn.Parameter(pe_embedding_table,requires_grad=False)

print(pe_embedding_table)
print(pe_embedding)
print(pe_embedding.weight)

在这里插入图片描述

src_pos=[torch.arange(max(src_len))for _ in src_len]
tgt_pos=[torch.arange(max(tgt_len))for _ in tgt_len]

src_pos_embedding=pe_embedding(src_pos)
tgt_pos_embedding=pe_embedding(tgt_pos)

TypeError: embedding(): argument ‘indices’ (position 2) must be Tensor, not list
torch.Tensor()只能转换单个元素

#构造position embedding
pos_mat=torch.arange(max_position_len).reshape(-1,1)
i_mat=torch.pow(10000,torch.arange(0,model_dim,2).reshape(1,-1)/model_dim)
pe_embedding_table=torch.zeros(max_position_len,model_dim)
pe_embedding_table[:,::2]=torch.sin(pos_mat/i_mat)
pe_embedding_table[:,1::2]=torch.cos(pos_mat/i_mat)


#改写了pe_embedding
pe_embedding=nn.Embedding(max_position_len,model_dim)
pe_embedding.weight=nn.Parameter(pe_embedding_table,requires_grad=False)

src_pos=torch.Tensor(torch.cat([torch.unsqueeze(torch.arange(max(src_len)),0)for _ in src_len]))
tgt_pos=torch.Tensor(torch.cat([torch.unsqueeze(torch.arange(max(tgt_len)),0)for _ in tgt_len]))

src_pos_embedding=pe_embedding(src_pos)
tgt_pos_embedding=pe_embedding(tgt_pos)

valid_encoder_pos=torch.unsqueeze(torch.cat([torch.unsqueeze(F.pad(torch.ones(L),(0,max(src_len)-L)),0)for L in src_len]),2)
v=torch.cat([torch.unsqueeze(F.pad(torch.ones(L),(0,max(src_len)-L)),0)for L in src_len])
#两个矩阵相乘可以得到两两之间的关联性
valid_encoder_pos_matrix=torch.bmm(valid_encoder_pos,valid_encoder_pos.transpose(1,2))
print(v)
print(valid_encoder_pos)
print(valid_encoder_pos.shape)
print(src_len)
print(valid_encoder_pos_matrix)

对于该句子，前面有俩单词，第一行是第一个单词对其他位置的关联性，由于剩下两个是pad的0，所以相关性为0。
在这里插入图片描述

invalid_encoder_pos_matrix=1-valid_encoder_pos_matrix
# True代表这个位置我们需要对它mask
mask_encoder_self_attention=invalid_encoder_pos_matrix.to(torch.bool)

print(invalid_encoder_pos_matrix)
print(mask_encoder_self_attention)

在这里插入图片描述

valid_encoder_pos=torch.unsqueeze(torch.cat([torch.unsqueeze(F.pad(torch.ones(L),(0,max(src_len)-L)),0)for L in src_len]),2)

#两个矩阵相乘可以得到两两之间的关联性
valid_encoder_pos_matrix=torch.bmm(valid_encoder_pos,valid_encoder_pos.transpose(1,2))
invalid_encoder_pos_matrix=1-valid_encoder_pos_matrix
# True代表这个位置我们需要对它mask
mask_encoder_self_attention=invalid_encoder_pos_matrix.to(torch.bool)

score=torch.randn(batch_size,max(src_len),max(src_len))
masked_score=score.masked_fill(mask_encoder_self_attention,-1e9)
prob=F.softmax(masked_score,-1)

print(score)
print(masked_score)
print(prob)

masked_fill（mask，value），mask是元素为布尔值的张量（Tensor），把true位置填充value值。

在这里插入图片描述

代码

import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F


batch_size = 2

#单词表大小
#单词对应的索引数的最大值
max_num_src_words = 8
max_num_tgt_words = 8
#每一个单词的大小
model_dim=8

#序列最大长度
#一整个句子的最大长度,一个句子最多拥有的单词数
max_src_seq_len=5
max_tgt_seq_len=5
max_position_len=5


src_len = torch.Tensor([2,4]).to(torch.int32)
tgt_len = torch.Tensor([4,3]).to(torch.int32) 

#单词索引构成源句子和目标句子，即每个句子里是单词所在的索引数。构建batch，做了padding，默认值为0
#L分别取2，4，取2是长度为2的一个元组，取4是长度为4的一个元组
#src_seq：[tensor([7, 4]), tensor([2, 1, 5, 4])]
#tgt_seq：[tensor([4, 4, 4, 3]), tensor([5, 7, 6])]
src_seq = torch.cat([torch.unsqueeze(F.pad(torch.randint(1,max_num_src_words,(L,)),(0,max(src_len)-L)),0)for L in src_len])
tgt_seq = torch.cat([torch.unsqueeze(F.pad(torch.randint(1,max_num_tgt_words,(L,)),(0,max(tgt_len)-L)),0)for L in tgt_len])

#构造embedding
#一个单词对应一行，从1开始，pad的0，所以0行对应pad
#每一行一个embedding向量，每个单词索引是几，我们就取第几行
src_embedding_table=nn.Embedding(max_num_src_words+1,model_dim)
tgt_embedding_table=nn.Embedding(max_num_tgt_words+1,model_dim)
src_embedding=src_embedding_table(src_seq)
tgt_embedding=tgt_embedding_table(tgt_seq)

#构造position embedding
pos_mat=torch.arange(max_position_len).reshape(-1,1)
i_mat=torch.pow(10000,torch.arange(0,model_dim,2).reshape(1,-1)/model_dim)
pe_embedding_table=torch.zeros(max_position_len,model_dim)
pe_embedding_table[:,::2]=torch.sin(pos_mat/i_mat)
pe_embedding_table[:,1::2]=torch.cos(pos_mat/i_mat)


#改写了pe_embedding
pe_embedding=nn.Embedding(max_position_len,model_dim)
pe_embedding.weight=nn.Parameter(pe_embedding_table,requires_grad=False)

src_pos=torch.Tensor(torch.cat([torch.unsqueeze(torch.arange(max(src_len)),0)for _ in src_len]))
tgt_pos=torch.Tensor(torch.cat([torch.unsqueeze(torch.arange(max(tgt_len)),0)for _ in tgt_len]))

src_pos_embedding=pe_embedding(src_pos)
tgt_pos_embedding=pe_embedding(tgt_pos)

# #softmax演示，scaled的重要性
# alpha1=0.1
# alpha2=10
# score=torch.randn(5)
# prob1=F.softmax(score*alpha1,-1)
# prob2=F.softmax(score*alpha2,-1)
# def softmax_fun(score):
#     return F.softmax(score,-1)
# jaco_mat1=torch.autograd.functional.jacobian(softmax_fun,score*alpha1)
# jaco_mat2=torch.autograd.functional.jacobian(softmax_fun,score*alpha2)

# 构造encoder的self-attention mask,就是一个关系矩阵，没有因果
# mask的shape：[batch_size,max_src_len,max_src_len],值为1或负无穷，负无穷经过softmax变为0，1相乘维持不变
# valid_encoder_pos：[2,4]=>[2,1,4]
valid_encoder_pos=torch.unsqueeze(torch.cat([torch.unsqueeze(F.pad(torch.ones(L),(0,max(src_len)-L)),0)for L in src_len]),2)

#两个矩阵相乘可以得到两两之间的关联性
valid_encoder_pos_matrix=torch.bmm(valid_encoder_pos,valid_encoder_pos.transpose(1,2))
invalid_encoder_pos_matrix=1-valid_encoder_pos_matrix
# True代表这个位置我们需要对它mask
mask_encoder_self_attention=invalid_encoder_pos_matrix.to(torch.bool)

score=torch.randn(batch_size,max(src_len),max(src_len))
masked_score=score.masked_fill(mask_encoder_self_attention,-1e9)
prob=F.softmax(masked_score,-1)

print(score)
print(masked_score)
print(prob)

decoder

# step 6:构造decoder self-attention的mask
tril_matrix=[torch.tril(torch.ones(L,L))for L in tgt_len]
print(tril_matrix)

在这里插入图片描述
这里的1表示有特殊字符。
对于第一行，解码器的输入给一个特殊字符，解码器的输入与输出有一个shift，输入往左shift一位，刚好和输出有一个偏移。
对于第二行，解码器的输入给一个特殊字符和第一个字符，预测下一个字符。

代码

import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F


batch_size = 2

#单词表大小
#单词对应的索引数的最大值
max_num_src_words = 8
max_num_tgt_words = 8
#每一个单词的大小
model_dim=8

#序列最大长度
#一整个句子的最大长度,一个句子最多拥有的单词数
max_src_seq_len=5
max_tgt_seq_len=5
max_position_len=5


src_len = torch.Tensor([2,4]).to(torch.int32)
tgt_len = torch.Tensor([4,3]).to(torch.int32) 

# step 1:
#单词索引构成源句子和目标句子，即每个句子里是单词所在的索引数。构建batch，做了padding，默认值为0
#L分别取2，4，取2是长度为2的一个元组，取4是长度为4的一个元组
#src_seq：[tensor([7, 4]), tensor([2, 1, 5, 4])]
#tgt_seq：[tensor([4, 4, 4, 3]), tensor([5, 7, 6])]
src_seq = torch.cat([torch.unsqueeze(F.pad(torch.randint(1,max_num_src_words,(L,)),(0,max(src_len)-L)),0)for L in src_len])
tgt_seq = torch.cat([torch.unsqueeze(F.pad(torch.randint(1,max_num_tgt_words,(L,)),(0,max(tgt_len)-L)),0)for L in tgt_len])

## step 2:构造word embedding
#一个单词对应一行，从1开始，pad的0，所以0行对应pad
#每一行一个embedding向量，每个单词索引是几，我们就取第几行
src_embedding_table=nn.Embedding(max_num_src_words+1,model_dim)
tgt_embedding_table=nn.Embedding(max_num_tgt_words+1,model_dim)
src_embedding=src_embedding_table(src_seq)
tgt_embedding=tgt_embedding_table(tgt_seq)

#step 3:构造position embedding
pos_mat=torch.arange(max_position_len).reshape(-1,1)
i_mat=torch.pow(10000,torch.arange(0,model_dim,2).reshape(1,-1)/model_dim)
pe_embedding_table=torch.zeros(max_position_len,model_dim)
pe_embedding_table[:,::2]=torch.sin(pos_mat/i_mat)
pe_embedding_table[:,1::2]=torch.cos(pos_mat/i_mat)


#改写了pe_embedding
pe_embedding=nn.Embedding(max_position_len,model_dim)
pe_embedding.weight=nn.Parameter(pe_embedding_table,requires_grad=False)

src_pos=torch.Tensor(torch.cat([torch.unsqueeze(torch.arange(max(src_len)),0)for _ in src_len]))
tgt_pos=torch.Tensor(torch.cat([torch.unsqueeze(torch.arange(max(tgt_len)),0)for _ in tgt_len]))

src_pos_embedding=pe_embedding(src_pos)
tgt_pos_embedding=pe_embedding(tgt_pos)

# #softmax演示，scaled的重要性
# alpha1=0.1
# alpha2=10
# score=torch.randn(5)
# prob1=F.softmax(score*alpha1,-1)
# prob2=F.softmax(score*alpha2,-1)
# def softmax_fun(score):
#     return F.softmax(score,-1)
# jaco_mat1=torch.autograd.functional.jacobian(softmax_fun,score*alpha1)
# jaco_mat2=torch.autograd.functional.jacobian(softmax_fun,score*alpha2)

# step 4:构造encoder的self-attention mask,就是一个关系矩阵，没有因果
# mask的shape：[batch_size,max_src_len,max_src_len],值为1或负无穷，负无穷经过softmax变为0，1相乘维持不变
# valid_encoder_pos：[2,4]=>[2,1,4]
valid_encoder_pos=torch.unsqueeze(torch.cat([torch.unsqueeze(F.pad(torch.ones(L),(0,max(src_len)-L)),0)for L in src_len]),2)

#两个矩阵相乘可以得到两两之间的关联性
valid_encoder_pos_matrix=torch.bmm(valid_encoder_pos,valid_encoder_pos.transpose(1,2))
invalid_encoder_pos_matrix=1-valid_encoder_pos_matrix
# True代表这个位置我们需要对它mask
mask_encoder_self_attention=invalid_encoder_pos_matrix.to(torch.bool)

score=torch.randn(batch_size,max(src_len),max(src_len))
masked_score=score.masked_fill(mask_encoder_self_attention,-1e9)
prob=F.softmax(masked_score,-1)

#step 5：构造intra-attention的mask
# Q @ K^T shape:[batch_size,tgt_seq_len,src_seq_len]
valid_decoder_pos=torch.unsqueeze(torch.cat([torch.unsqueeze(F.pad(torch.ones(L),(0,max(tgt_len)-L)),0)for L in tgt_len]),2)

valid_cross_pos_matrix=torch.bmm(valid_decoder_pos,valid_encoder_pos.transpose(1,2))
invalid_cross_pos_matrix=1-valid_cross_pos_matrix
mask_cross_attention=invalid_cross_pos_matrix.to(torch.bool)

score=torch.randn(batch_size,max(tgt_len),max(src_len))
masked_cross_score=score.masked_fill(mask_cross_attention,-1e9)
prob2=F.softmax(masked_cross_score,-1)

# step 6:构造decoder self-attention的mask
valid_decoder_tril_matrix=torch.cat([torch.unsqueeze(F.pad(torch.tril(torch.ones(L,L)),(0,max(tgt_len)-L,0,max(tgt_len)-L)),0)for L in tgt_len],0)
invalid_decoder_tril_matrix=1-valid_decoder_tril_matrix
invalid_decoder_tril_matrix=invalid_decoder_tril_matrix.to(torch.bool)

score=torch.randn(batch_size,max(tgt_len),max(tgt_len))
masked_score=score.masked_fill(invalid_decoder_tril_matrix,-1e9)
prob=F.softmax(masked_score,-1)

# 构建scaled self-attention
# Q,K,V shape:[batch_size*num_head,seq_len,model_dim/num_head]
def scaled_dot_product_attention(Q,K,V,attn_mask):
    score=torch.bmm(Q,K.transpose(-2,-1))/torch.sqrt(model_diml_dim)
    masked_score=score.masked_fill(attn_mask,-1e9)
    prob=F.softmax(masked_score,-1)
    context=torch.bmm(prob,V)
    return context
派大星的最爱海绵宝宝
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
快过HugeCTR：用OneFlow轻松实现大型推荐系统引擎
OneFlow深度学习框架
02-07 596
一、简介 Wide & Deep Learning （以下简称 WDL）是解决点击率预估（CTR Prediction）问题比较重要的模型。WDL 在训练时，也面临着点击率预估领域存在的两个挑战：巨大的词表（Embedding Table），以及大量的数据吞吐。 业界比较有影响力的包含了 WDL 解决方案及评测结果的项目有 HugeCTR，该框架通过模型并行、三级流水线等技巧，解决了以上问题。在2020年 MLPerf 评测中，英伟达用 HugeCTR 实现了当时最快的 WDL 模型。 英伟达 Bl
【Transformer系列】深入浅出理解Embedding（词嵌入）
IT菜鸟
09-15 1万+
【Transformer系列】深入浅出理解Embedding（词嵌入）
从零开始了解transformer的机制|第一章：word embedding
weixin_73179708的博客
08-17 436
首先要对输入的词汇进行处理。那我们就要想一下：怎么表达词汇能够让机器看得懂呢？朴素的想法，我们可能会开一个向量，向量的长度就是所有词汇的总和。向量中每个位置代表一个词（例如第一个位置代表abandon，第二个位置代表an）然后abandon这个词就用（1,0,0...）表示，an这个词就用（0,1,0...）来表示。例如：所谓word-embedding。就是：把每个单词变成一个多维的数字向量。你可以把这个向量想象成是词汇空间里的一个点，而每个维度代表了某种词汇特性，比如语义（意义）或者上下文关系。
深入浅出ChatGPT：揭秘Transformer的Embedding层精华
最新发布
aibishe的博客
06-09 115
_biz=MzU3OTgyMjM3MA==&mid=2247484353&idx=1&sn=452b5e450b9eba799ba9b024099a2e87&chksm=fd61758cca16fc9aab3f99af1ce9662f1e029799f90e9f5fc30feff2a038bbca9a9c5298c47b&scene=21#wechat_redirect](/ “第三篇：要真正入门AI，OpenAI的官方Prompt工程指南肯定还不够，您必须了解的强大方法论和框架”)
Transformer详解之Embedding、Positional Encoding层（面向初学者）
qq_41018669的博客
09-17 1万+
1.Embedding层介绍 在理解Embedding层之前，我们需要关注于文本数据的特点，举例："我爱北京天安门"，我们在做文本数据处理得时候，传统的汉字是没有办法做运算的，大家时刻要记住，计算机在处理任何数据的基础，就是能够进行运算。为了解决汉字运算的问题，提出了将汉字进行编码（或叫文本张量表示）的思想。目前主流的编码方式有one-hot编码及word Embedding。下面就两种编码进行介绍，其中穿插关于word2vec的理解。 1.1 one-hot编码 该编...
【Transformer系列（4）】Transformer模型结构超详细解读
路人贾的博客
04-20 9505
Transformer模型结构超级详细的解读，一文带你了解什么是Transformer，小白入门必看！
Transformer为什么要有pos embedding
qq_37938547的博客
05-11 1632
前几天面试面试官问了我一个问题，Transformer的编码部分用的是attention，那么它会不会在编码后几个单词的时候丢失掉前面的信息？Transformer为什么要有位置信息？想summary一下，小白一枚。 首先，个人感觉LSTM有点像串行结构，其最明显的特点是按单词顺序一个一个进行编码的，比如我在人民广场吃炸鸡： input：[w1,w2,w3,w4,w5…w9] 但是在进行编码的时候隐状态h（t）的计算必须等到前t-1个隐变量计算完毕后才会开始计算，所以有点像串行结构。那么为什么LSTM模型后
从Word Embedding到Bert模型—自然语言处理中的预训练技术发展史
11-19
Transformer由Google在2017年的论文《Attention is All You Need》中提出，摒弃了传统的RNN和CNN，采用自注意力机制，实现了并行计算，大大提高了训练效率。然后，OpenAI的GPT（Generative Pre-trained Transformer...
大白话Bert-掌握最前沿Embedding结构
06-20
BERT模型基于Transformer架构，Transformer由自注意力机制和前馈神经网络组成，这种架构允许模型同时考虑输入序列的全局信息。BERT的核心创新在于引入了“掩码语言模型”（Masked Language Modeling, MLM）和“下一...
chinese_xlnet_base_L-12_H-768_A-12.zip
06-07
首先，XLNet的核心理念是对自回归（Autoregressive）和自编码（Autoencoding）的双向依赖关系进行建模，解决了Transformer模型在处理长序列信息时存在的局限性。通过引入自回归预测的目标和掩码机制，XLNet能够利用...
基于不同深度学习框架实现中文文本分类.zip
03-28
3. Transformer：以自注意力机制为核心，解决了RNN的并行计算难题，成为当前NLP领域的主流模型。 4. BERT（Bidirectional Encoder Representations from Transformers）：预训练语言模型，通过掩码语言模型和下一句...
Meta AI 发布 data2vec！统一模态的新里程碑！ .pdf
08-12
1. **文本模态**：使用token embedding，即对单词或词块进行编码。 2. **图像模态**：受到Vision Transformer（ViT）的启发，将图像分割成patches，并进行线性变换。 3. **语音模态**：利用多层一维卷积处理波形，以...
【Transformer论文模型细致讲解】
Ye_meng_li的博客
11-29 5569
Transformer是谷歌在2017年6月提出，发表在NIPS2017上。论文地址 Attention Is All You Need。 Transformer主体框架是一个encoder-decoder结构，去掉了RNN序列结构，完全基于attention和全连接。在WMT2014英语翻译德语任务上，bleu值达到了28.4，达到当时的SOTA。其总体结构如下所示 1.首先是Encoder 我们将Encoder分为两个部分，一个是输入层embedding，另一个是编码层，也就是左边放方框框里面的东西
transformer算法嵌入Embedding示例
benben044的专栏
06-27 1692
transformer中融入外置embedding的示例
Transformer模型详解（图解最完整版）
热门推荐
qq_38410428的博客
01-08 2万+
前言 Transformer由论文《Attention is All You Need》提出，现在是谷歌云TPU推荐的参考模型。论文相关的Tensorflow的代码可以从GitHub获取，其作为Tensor2Tensor包的一部分。哈佛的NLP团队也实现了一个基于PyTorch的版本，并注释该论文。 在本文中，我们将试图把模型简化一点，并逐一介绍里面的核心概念，希望让普通读者也能轻易理解。 Attention is All You Need：Attention Is All You Need 1.Trans
word embedding各种方法总结
xiaoxiaoqian0519的博客
01-11 1640
word2vec word2vec是一个工具，背后的模型是CBOW或者Skip-gram，并且使用了Hierarchical Softmax或者Negative Sampling这些训练的优化方法。 GloVe 1、首先根据语料库创建一个共现矩阵，其中每一个元素代表单词和上下文词再特定的上下文窗口内共同出现的次数，并且GloVe还提供了decreasing weighting，就是基于两个词在上下文窗口中的距离d，去给一个权重1/d，也就是距离远的两个词，占总计数的权重就小； 2、构建词向量和共现矩阵之间的
总结一下word embedding
weixin_45885232的博客
04-03 1198
在NLP中，词向量是最基础的一部分，所谓词向量就是词在空间的一个映射向量表示。实现词向量的方式有word2vec， BERT，K-BERT等，还有一部分是用CNN实现. word2vec word2vec有两种不同的词向量生成模式，一种是CBOW（character box of word）另一种是Skip-temp模型，CBOW是利用前后词判断当前词，Skip是利用当前词判断前后词。 CBOW可以理解为，输入的www，求其前后相关的最大概率，即P(w)=P(Context(w)∣w)P(w)=P(Con
自然语言处理中的Transformer和BERT
Zhangbei_的博客
12-23 1万+
2018年马上就要过去，回顾深度学习在今年的进展，让人印象最深刻的就是谷歌提出的应用于自然语言处理领域的BERT解决方案，BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding（https://arxiv.org/abs/1810.04805）。BERT解决方案刷新了各大NLP任务的榜单，在各...
Transformer中的相对位置编码(Relative Position Embedding)
chenf1995的博客
02-18 9687
本篇preview：回顾transformer中绝对位置编码（absolute position embedding）相对位置编码方法详解和公式推导相对位置编码代码实现 回顾transformer中绝对位置编码（absolute position embedding） 在transformer的实现中，所有的input tokens是无序的，是没法像RNN的方法一样学到token之间的位置顺序关系，但是自然语言一定是有语序在里面的，所以原始的transformer的代码实现里就提供了一种非常简单的位置编码，
假定transformer的解码器结构是掩码多头注意力、残差连接和层正则化1、多头交叉注意力、残差连接和层正则化2、前馈网络、残差连接和层正则化3、解码输出，一共七层。以I like this lecture四个词的输入序列为例，输出为其中文翻译。假没词的embedding维度为10，编码器和解码均使用8个头的自注力模块。参考以上transformer解码器结构，自定义所需变量和符号，分别对这七个模块的输入输出和处理过程进行具体分析（包括矩阵的维度等）。注意，除了四个词外，<begin>为初始值，因此注意力矩阵是5*10的
06-08
4. 对掩码注意力分数矩阵进行 softmax 操作，得到注意力权重矩阵 $W \in \mathbb{R}^{5 \times 5}$，其中 $W_{ij}$ 表示在解码器的第 $i$ 个位置时对编码器的第 $j$ 个位置的注意力权重。 5. 对每个头 $j$，计算其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值