前语

Transform这玩意的大名我想就不必我多说了。那么咱们今日要做的便是对Transform架构进行了解，而且运用Pytorch进行一个编写完结。（其实这边博文的话很早之前就差不多写好了，可是话我本人喜爱做一个系列就一向没发布）由于描绘的是一种架构，因而好消息是，关于新的理论部分没有啥要求。可是坏消息是，需求必定的前期知识储备。咱们这边仍是拿到NLP使命来进行打开，虽然Transform这个玩意作为一个架构不只仅在NLP领域进行应用在CV领域等等也在用，可是一开端的来源仍是这个NLP这边来的，一条时间线可以留意一下便是2017提出了Transform，2018 Bert出来了，2020 GPT3都出来了。最近ChatGPT都杀疯了。只能说时代改变太快，从大二入坑差不多一年了，还在水里爬。OK，废话不多少咱们开端吧，那么在开端之前的话，咱们希望你已经阅读了这篇博文：还在调API写所谓的AI“女友”，唠了唠了，教你根据python咱们“new”一个（深度学习）由于会有一些古怪的比方来自这儿，当然假如对应Seq2Seq有必定了解或许做过相似的使命的话，那么welcome here！

整体架构

整体

首要Transform的整体架构的话其实十分明晰明晰

整个Transform架构的话其实和咱们的Seq2Seq是相似的，都是经过Encoder到Decoder终究输出一组概率假定咱们仍是文本的一个生成使命的话，例如AI机器人，言语翻译，再或许说是从一个信号序列到另一个信号序列的改变。不过里边关于传入的参数的处理是不太相同的。一起相对咱们原先构建的根据GRU树立的SEQ2SEQ网络来说，其实完结的话会更简略一点，在原先最大的应战在于对各个输出，输入维度的一个判别和编写，难点在于对循环神经网络的了解，由于调试的坑都在这边，也便是Decoder部分。可是在今日的Transform傍边，会友好许多，难点在留意力机制的编写部分以及对它的一个了解。

使命运用

OK，那么咱们现在对Transform进行了一个简略的预览，那么现在咱们来看看咱们怎样运用Transform架构，怎样运用这个模型。咱们那个闲聊的机器人的来说吧，咱们本来是这样的：

咱们运用了两个循环神经网络来充当编码器，解码器，一起由于咱们在解码的过程中需求逆向过程来一个词一个词的去生成语句，因而咱们还需求手写decoder的一个循环过程，然后便是对里边参数的张狂调整，终究在转化为一组概率，假定输入的语句是1×10而且假定有100种词，也便是不同的词语+标点有100个，那么终究咱们得到的玩意是1x10x100的一个概率矩阵。然后咱们经过概率矩阵去生成一个语句。这个是咱们本来的一个流程。

那么在运用Transform的话，有什么差异呢？答，整体上来说其实差异不大。咱们其实仅仅把Seq2Seq给换成了transform，更加精确一点其实是，咱们把本来GRU给换成了transform傍边的编码器和解码器。也便是这两个家伙：

再形象一点便是，咱们把GRU或许LSTM这种循环神经网络给换成了这种带有留意力机制的编解码器。而且咱们关于编码器和解码器傍边彼此交融的方位也不太相同。那么这个时分咱们可以引出咱们本文傍边的第一个问题了，那便是说，为什么咱们可以运用到这个东西，来替代RNN结构。

输入部分

Embedding

OK，现在咱们带着第一个问题来看到咱们的输入部分：

首要咱们可以看到一开端关于输入需求先进行Embedding操作，这个操作的话，是咱们惯例的一个操作，那么紧接着还有一个PositionEncoding的一个操作。那么关于Embedding的操作咱们可以了解，意图便是为了可以把一个文本，例如一个语句10个词语构成，那么就变成10xembedding_dim的一个向量。详细的代码也简略是这样的：

class Embeddings(nn.Module):
    def __init__(self,dim,vocab):
        super(Embeddings,self).__init__()
        self.em = nn.Embedding(vocab,dim)
        self.dim = dim
    def forward(self,x):
        return self.em(x)*math.sqrt(self.dim)

Position Encoding

why

那么PositionEncoding是什么东西呢？OK，这儿咱们先来回忆一下假如咱们运用RNN的话咱们有什么特色，或许说咱们本来为什么要运用GRU或许LSTM这种RNN结构呢？是由于，词语的方位之间是有联络的对吧。词和词之间不是独立的，而存在一种联络，例如“我爱你”和“你爱我”这是不同意思，前者或许是你作为舔狗，后者或许是别舔你。因而咱们采用了RNN这种结构，主要是由于词语之间的一种联络。那么问题来了必定只要一种解决计划不？显然不是，假如咱们有一种方法咱们可以直接把词语之间的一种方位联络也直接表明出来的话，那么理论上来说咱们可以替代到刚刚的RNN的作用。

那么PositionEncodeing显然看名字就知道做的便是这种作业。

完结

OK，咱们这边先来看到是怎样完结的：

"""
担任完结对语句中每一个方位信息进行一个编码
编码之后的维度是[seq_len,dim]
"""
class PostitionEncoding(nn.Module):
    def __init__(self,dim,dropout,max_len=5000):
        super(PostitionEncoding,self).__init__()
        """
        dropout让部分神经元失去作用（其实便是让某些
        神经元的梯度消失，让输入中的X矩阵部分为0
        """
        self.dropout = nn.Dropout(p=dropout)
        pe = torch.zeros(max_len,dim)
        #初始化肯定方位矩阵
        postition = torch.arange(0,max_len).unsqueeze(-1)
        #界说一个变幻矩阵
        div_matrix = torch.exp(torch.arange(0,dim,2)*-(math.log(10000)/dim))
        #进行奇数偶数方位的别离赋值
        pe[:,0::2] = torch.sin(postition*div_matrix)
        pe[:,1::2] = torch.cos(postition*div_matrix)
        pe = pe.unsqueeze(0)
        #pe,不参加模型的梯度运算,因而需求将pe注册为buffer
        self.register_buffer('pe',pe)
    def forward(self,x):
        """
        :param x: embedding 后的x
        :return:
        """
        x = x+Variable(self.pe[:,:x.size(1)],requires_grad=False)
        return self.dropout(x)

这部分的完结是这样的：

运用到一个方位信息矩阵pe,这个矩阵一开端咱们设置的足够大，而且作为一个定量（不参加梯度核算）
界说一个变幻矩阵，意图是为了对pe的维度进行变幻
确认语句傍边的词序，由于咱们输入的东西是batch_size,seq_len,dim的一个语句，词本身在语句中便是有序的因而：postition = torch.arange(0,max_len).unsqueeze(-1) 便是词的一个序号（在语句中）
此刻变幻矩阵和position矩阵进行运算，然后赋值给到pe,这个方位信息矩阵。
将方位信息和本来的embedding后的信息进行累加处理，让数据具有方位信息

这儿的话或许第一个魔幻的当地来了，为什么这样处理之后就具有了方位信息。这儿问题的话其实是整个神经网络算法的魔幻之处，咱们这样处理的信息的确和方位有联络，可是详细是什么联络咱们是不知道的，这个只能改到神经网络自己去“学习”表明，也便是常说的解说才能比较差的一种情况，仅仅说咱们希望是这种作用，而且试验的表现上这种解说行得通。

那么在这儿的话还需求留意的是这个，咱们有两个当地是有这样的处理的：

留意部分

之后的话咱们来看到这个留意了机制部分：

这个玩意看架构图也知道是整个transform傍边比较重要的一个当地了，根本上一个架构满是留意力机制，然后张狂传递。

留意力机制/自留意力

OK，现在咱们来看到这个留意力机制。其实这个留意了机制的话，不要想得很复杂，它里边其实就三个东西：Query,Key,Value 然后经过特其他核算之后得到一种权重，然后和咱们输入的X进行一个核算，让X傍边的某些值扩大或许缩小，从而影响到咱们神经网络里边的权重，由于咱们现有的神经网络结构，都是对参数W进行一个核算求导的，影响W的是咱们X的一个值。可以这样了解咱们的留意力机制便是，X影响到了部分W，然后W再影响道下一个batch的X，然后在反过来影响到W，W不再是紊乱的，W的缩放呈现处理一种散布所便是所谓的一种留意力的表现。横竖大约是这种意思吧，咱们不太需求关怀这个。

那么咱们先直接来看到这个公式还有架构吧：

首要它的核算公式是这样的：

有四个变量，Q，K，V还有Dk。这几个是啥咱们待会再来说，那么在咱们的网络结构里边是这样的：

这个时分咱们在来解说一下这个Q，K，V是啥。

Q：query，假定咱们在做一个文本的特征提取，假定给一个文本，叫你提取出里边的要害词，那么Query便是咱们输入的文本
K： key，是咱们输入的一些要害信息。
V： value，是网络生成的

那么这块的话咱们可以发现便是说Query和Key应该是知道的，Value是咱们终究希望得到的。假定咱们在做一个语文作业。咱们的希望是AI可以做出来，于是咱们输入Query，也便是标题，之后咱们有一个参阅答案Key，或许说是参阅提示。现在在学习的过程中，咱们是不知道怎样做的，最好的方式是找几个例题去做一下，于是咱们拿到Query和Key，自己在生成Value也便是解题，然后在去对一下大约的答案，看看自己有没有get到题意图要害点。那么类比一下，get题意图要害点，不是题意图要害信息嘛，不便是文本中的主要要害呗，也便是要害特征呗，那么这个不便是留意力机制的意图呗。

这个的话，咱们先直接看到代码：

    @staticmethod
    def attention(query,key,value,mask=None,dropout=None):
        """
        :param query:
        :param key:
        :param value:
        :param mask: 掩码
        :param dropout: 传入dropout对象
        :return:
        """
        """
        当Q=K=V时，此刻attention便是传说中的self-attention
        """
        #这儿的dim其实便是embedding里边的dim
        dim = query.siez(-1)
        #参照核算公式进行核算
        sorces = torch.matmul(query,key.transpose(-2,-1)/math.sqrt(dim))
        if(mask is not None):
            """
            Q,K,V-->[batch_size,seq_len,embedding_dim]
            与mask里边的0进行对应，假如是0，那么替换为很小的数字
            在sorces的对应方位上
            [seq_len,seq_len]
            """
            sorces = sorces.masked_fill(mask==0,-1e9)
        p_attn = F.softmax(sorces,dim=-1)
        if(dropout is not None):
            p_attn = dropout(p_attn)
        #完结乘法，并反馈query的attention
        return torch.matmul(p_attn,value),p_attn

（mask是啥，先不管）OK，现在咱们知道了留意力机制，而且咱们知道便是说，咱们的Key和Value理论上来说应该要持平，或许尽或许持平，换一句话说，咱们希望是输入的Key和咱们的Value可以持平。那么自留意力机制是啥呢，其实很简略便是Q=K=V，啥玩意呢，便是Key按道理假定是按照刚刚的比如的话，Key是提示，是答案，那么假如没有给答案不就自己做了呗，答案便是标题也便是说没给提示，要自己做。大约就这样了解吧。

掩码

作用

之后的话，咱们可以发现在代码傍边还有mask，这种东西，那么这个是啥呢。

掩代表讳饰，码便是咱们张量中的数值，它的尺度不定，里边一般只要1和0的元素，代表方位被讳饰或许不被讳饰，至于是0方位被讳饰仍是1方位被讳饰可以自界说，因而它的作用便是让另外一个张量中的一些数值被讳饰，也可以说被替换,它的表现形式是一个张量。

在transformer中, 掩码张量的主要作用在应用attention时，有一些生成的attention张量中的值核算有或许已知了未来信息而得到的，未来信息被看到是由于训练时会把整个输出成果都一次性进行Embedding，可是理论上解码器的的输出却不是一次就能发生终究成果的，而是一次次经过上一次成果综合得出的，因而，未来的信息或许被提前利用. 所以，咱们会进行讳饰。

这个看起来比较笼统，咱们直接来看到它的生成的代码怎样来的：

    @staticmethod
    def subsequent_mask(size):
        attn_shape = (1,size,size)
        subsequent_mask = np.triu(np.ones(attn_shape),k=1).astype('uint8')
        return torch.from_numpy(1-subsequent_mask)

这个东西呢，便是用来生成掩码的东西，那么运转完之后的作用是啥呢，假定咱们生成的是4×4的一个掩码，那么作用便是这样的：

其他的当地是0。那么这个玩意有作用，或许为啥长这个姿态呢。什么叫做未来的张量呢？未来的信息？咱们这儿的话，咱们来回到咱们用GRU来生成语句的时分是怎样做的：

本来在生成语句的时分，咱们是一步一步去生成的对吧，也便是说，当时的+上一个生成的词语来进行推导生成。也便是这样一步一步来生成的：

也便是说在生成当时的词语的时分，咱们不或许拿到后边的词语的信息来进行生成。

可是现在是什么情况。现在咱们没有这样的循环结构。咱们是直接一个语句，一个语句一切的特征都给出来了，也便是咱们是直接一个张量巨细为[batch_size,seq_len,embedding_dim]的玩意过往来不断生成这样的词语的。可是不可否认的是在一次一次运算的过程中，咱们是希望词语也是一个一个生成的，由于这样才合理啊，你不或许知道你还没有说的话吧，或许还没有想到的话吧，这个肯定是有次第的。那么掩码的作用此刻就不言而喻了，为了这种次第性。换一句话说掩码用来模仿RNN结构的次第性质。至此，用RNN结构的关于词语的方位特征，词语的次第特征都进行了简要替代。

怎样作业

OK，现在咱们再来看到掩码大约是怎样作业的，这个时分咱们再回到attention的代码傍边：

        if(mask is not None):
            """
            Q,K,V-->[batch_size,seq_len,embedding_dim]
            与mask里边的0进行对应，假如是0，那么替换为很小的数字
            在sorces的对应方位上
            [seq_len,seq_len]
            """
            sorces = sorces.masked_fill(mask==0,-1e9)

其实答案已经在注释了给出来了，QKV的维度正如咱们的这个注释所说，当进行运算之后的话，source的维度变成了[seq_len,seq_len]，此刻按照下三角矩阵，咱们把mask傍边为0的用很小的值来替换，这样的话，对应方位的信息就很小了。之后在进行矩阵运算

return torch.matmul(p_attn,value),p_attn

复原维度而且得到处理之后的X，和attn的一个权重。

形状解说

那么这个时分的话，咱们也可以来解说另一个问题便是为什么，是有一个偏移的。咱们假定只要一个语句进入，也便是假定现在都是二维的张量进入网络，之后咱们进行运算之后咱们的source大约应该是这样的：

假定这个现在是咱们的source矩阵，假定刚好source运算完毕之后，下三角也是1，上三角是其他数值，可是和mask运算之后应该是这样的。它的巨细是seq_len x seq_len。或许是max_len x max_len。它的话这样了解，纵坐标是代表咱们知道的词，便是输入，横坐标要的是咱们要生成或许转化的信息，由于神经网络便是对信息不断转化提取码，对那个feature对吧。此刻生成第一个的时分，第一个肯定是要已知的。生成第二个的时分，3,4未来的就看不到了，大约便是下图的作用：

这块的话其实也是模仿那种RNN按照次第提取信息的过程，后边的信息是逐步看到的。

完好完结

OK，现在咱们来看到一个完结。这儿的话我把这个玩意封装到了一个东西类傍边，由于后边会运用到：


class Utils(object):
    def __init__(self):
        pass
    @staticmethod
    def subsequent_mask(size):
        attn_shape = (1,size,size)
        subsequent_mask = np.triu(np.ones(attn_shape),k=1).astype('uint8')
        return torch.from_numpy(1-subsequent_mask)
    @staticmethod
    def attention(query,key,value,mask=None,dropout=None):
        """
        :param query:
        :param key:
        :param value:
        :param mask: 掩码
        :param dropout: 传入dropout对象
        :return:
        """
        """
        当Q=K=V时，此刻attention便是传说中的self-attention
        """
        #这儿的dim其实便是embedding里边的dim
        dim = query.siez(-1)
        #参照核算公式进行核算
        sorces = torch.matmul(query,key.transpose(-2,-1)/math.sqrt(dim))
        if(mask is not None):
            """
            Q,K,V-->[batch_size,seq_len,embedding_dim]
            与mask里边的0进行对应，假如是0，那么替换为很小的数字
            在sorces的对应方位上
            [seq_len,seq_len]
            """
            sorces = sorces.masked_fill(mask==0,-1e9)
        p_attn = F.softmax(sorces,dim=-1)
        if(dropout is not None):
            p_attn = dropout(p_attn)
        #完结乘法，并反馈query的attention
        return torch.matmul(p_attn,value),p_attn
    @staticmethod
    def clone(module,N):
        """
        :param module: 方针网络
        :param N: 克隆个数
        :return:
        """
        return nn.ModuleList(
            [copy.deepcopy(module) for _ in range(N)]
        )

多头留意力完结

之后的话便是咱们多头留意力完结了，也便是这个破玩意：

其实啥是多头留意力呢，其实很好了解，便是在根本留意力的基础上，咱们把一个数据拆分为不同维度，对不同维度的数据进行别离留意力机制，然后做兼并即可。

也便是说咱们输入的数据是，一开端咱们经过embedding和position encodinh之后，咱们的数据应该是[batch_size,seq_len,embedding_dim]，假定咱们区分8个头，那么其实便是把这个数据区分为[batch_size,seq_len,head,embedding_dim//head]，然后终究两个维度进入留意力机制呗。

代码完结是这样的：

class MultiHeadedAttention(nn.Module):
    def __init__(self,head,dim,drop=0.3):
        """
        :param head: 多少个头（其实便是dim区分多少份）
        :param dim:
        :param drop:
        """
        super(MultiHeadedAttention,self).__init__()
        assert dim%head==0,"head的数量设置不合理"
        self.d_k = dim//head
        self.head = head
        self.dim = dim
        self.liners = Utils.clone(nn.Linear(self.dim,self.dim),4)
        self.attn = None
        self.drop = nn.Dropout(drop)
    def forward(self,query,key,value,mask=None):
        if(mask is not None):
            #扩大mask,因而此刻加了一个头，张量多了一个维度
            mask = mask.unsqueeze(1)
        batch_size = query.size(0)
        #进行核算,这个-1，其实是语句的每一个词
        query,key,value = [
            model(x).view(batch_size,-1,self.head,self.d_k).transpose(1,2)
            for model,x in zip(self.liners,(query,key,value))
        ]
        x,self.attn = Utils.attention(query,key,value,dropout=self.drop)
        #此刻做兼并
        x = x.transpose(1,2).contiguous().view(
            batch_size,-1,self.dim
        )
        return self.liners[-1](x)

Norm处理

之后的话咱们看到咱们的结构还有这个：

那么这个的话咱们要完结一：

class LayerNorm(nn.Module):
    def __init__(self,dim,eps=1e-6):
        """
        :param dim: embedding_dim
        :param eps: 放置除以0
        """
        super(LayerNorm,self).__init__()
        self.eps = eps
        self.a = nn.Parameter(torch.ones(dim))
        self.b = nn.Parameter(torch.zeros(dim))
    def forward(self,x):
        mean = x.mean(-1,keepdim=True)
        std = x.std(-1,keepdim=True)
        return self.a*(x-mean)/(std+self.eps)+self.b

那么到这儿的话，咱们的留意力部分其实就差不多了。

FeedForward 以及衔接

之后咱们再看到这个：

咱们要把这个也完结了，然后咱们就可以拼装咱们的编码器了。

这个其实好办：

这个是咱们的FeedForward

class PositionwiseFeedForward(nn.Module):
    def __init__(self,dim,d_h,drop=0.3):
        super(PositionwiseFeedForward,self).__init__()
        self.l1 = nn.Linear(dim,d_h)
        self.l2 = nn.Linear(d_h,dim)
        self.dropout = nn.Dropout(drop)
    def forward(self,x):
        x = F.leaky_relu(self.l1(x))
        return self.l2(self.dropout(x))

之后是咱们的衔接部分，便是这些杂乱无章的线：

class SubLayerConnection(nn.Module):
    def __init__(self,dim,dropout=0.3):
        super(SubLayerConnection,self).__init__()
        self.norm = LayerNorm(dim)
        self.dropout = nn.Dropout(dropout)
    def forward(self,x,sublayer):
        return x+self.dropout(sublayer(self.norm(x)))

编码器

OK，现在咱们根本的编码里边需求的组件就做好了，咱们现在拼装一下：

class Encoder(nn.Module):
    def __init__(self,layer,N):
        """
        :param layer: 多少层的编码器
        :param N: 多少个编码器
        """
        super(Encoder,self).__init__()
        self.layers = Utils.clone(layer,N)
        self.norm = LayerNorm(layer.dim)
    def forward(self,x,mask):
        for layer in self.layers:
            x = layer(x,mask)
        return self.norm(x)

解码器

之后的话是咱们的解码器，这个东西和咱们的编码器其实有点相似，仅仅中心的输入。

中心层

这儿咱们先界说一下中心层，由于这个东西需求承受咱们编码器传递过来的值：

class DecoderLayer(nn.Module):
    def __init__(self,dim,self_attn,src_attn,feed_forward,dropout):
        """
        :param dim:
        :param self_attn: 自留意力机制 Q=K=V
        :param src_attn: 惯例留意力机制  Q!=K=V
        :param feed_forward:
        :param dropout:
        """
        super(DecoderLayer,self).__init__()
        self.dim = dim
        self.self_attn = self_attn
        self.src_attn = src_attn
        self.feed_forward = feed_forward
        self.sublayer = Utils.clone(SubLayerConnection(dim,dropout),3)
    def forward(self,x,memory,source_mask,target_mask):
        """
        :param x: 上一层输入
        :param memory: 编码层的语义(编码器输出）
        :param source_mask: 数据源的掩码
        :param target_mask: 方针数据的掩码
        :return:
        """
        m = memory
        x = self.sublayer[0](x,lambda x:self.self_attn(x,x,x,target_mask))
        x = self.sublayer[1](x,lambda x:self.src_attn(x,m,m,source_mask))
        #终究一个衔接结构
        return self.sublayer[2](x,self.feed_forward)

拼装

之后的话，咱们在拼装一下：

class Decoder(nn.Module):
    def __init__(self,layer,N):
        super(Decoder,self).__init__()
        self.layers = Utils.clone(layer,N)
        self.norm = LayerNorm(layer.dim)
    def forward(self,x,memery,source_mask,target_mask):
        for layer in self.layers:
            x = layer(x,memery,source_mask,target_mask)
        return self.norm(x)

输出层

终究是咱们的输出层，也便是这个：

这个的话，咱们叫它生成器，由于咱们终究的确是需求它生成咱们的语句，终究输出的也是概率嘛。

class Generator(nn.Module):
    """
    没错终究也是做一个概率猜测，选择最大的那一个，然后由词语组成语句输出
    """
    def __init__(self,dim,vocab_size):
        super(Generator,self).__init__()
        self.l = nn.Linear(dim,vocab_size)
    def forward(self,x):
        return F.log_softmax(self.l(x),dim=-1)

至于生成语句的处理手段，这个咱们在那个开头AI小姐姐的博文说了，咱们还有一种方式优化。

模型拼装

终究来到咱们关于模型部分的拼装。没错便是这个大图：

这个的话就简略了，由于咱们已经拼装好了各个组件。

class Model(object):
    @staticmethod
    def make_model(source_vocab,target_vocab,N=6,
                   dim=512,d_ff=2048,head=8,max_len=5000,
                   dropout=0.30):
        """
        :param source_vocab: 词汇数量
        :param target_vocab: 词汇数量
        :param N: 编码器/解码器多少个层
        :param dim: embedding_dim
        :param d_ff: 线性层多少个隐藏节点
        :param head: 多头留意力机制多少个头
        :param max_len: 语句的最大长度
        :param dropout:
        :return:
        """
        co = copy.deepcopy
        attn = MultiHeadedAttention(head,dim)
        pf = PositionwiseFeedForward(dim,d_ff,dropout)
        position = PostitionEncoding(dim,dropout,max_len)
        model = EncoderDecoder(
            Encoder(EncoderLayer(dim,co(attn),co(pf),dropout),N),
            Decoder(DecoderLayer(dim,co(attn),co(attn),co(pf),dropout),N),
            nn.Sequential(Embeddings(dim,source_vocab),co(position)),
            nn.Sequential(Embeddings(dim,target_vocab),co(position)),
            Generator(dim,target_vocab)
        )
        return model

到此咱们整个模型就构建完结了，然后运用的话仍是老规矩，当做Seq2Seq即可。当然相同的，作为一个饱受检测的模型，这个也是有完结好的第三方库的，没错不需求自己手写。

总结

okey~大约这个其实便是transform架构吧，总的来说，按照我的解读其实便是十分巧妙的对RNN可以带来的一些特征进行交融，而且作用还很好。当然整个架构给我的感觉其实便是“堆料，希望”。

堆料是啥意思呢：便是用了许多处理计划呗。希望是啥意思，便是这些计划，解说性更多是用希望来表明。举个比如：

before：我以为A和B之间还有一种联络我需求知道–>树立模型—>做试验，不断推导证明–>找出A和B之前切当的联络以及处理计划–>得到定论（可解说性的过程+完好的数学模型+推导证明）

now: 我以为A和B之间存在一种联络我需求知道–>将A和B的数据进行处理衔接整合（很粗略的模型）—>NN—->Expect could NN find some Relationships –>试验后作用如同达到了预期—>得到定论（这样做希望是这样实际上目前这样解说正确）

仅仅挑款没啥意思。

前沿系列–Transform架构[架构分析+代码实现]

前语

整体架构

整体

使命运用

输入部分

Embedding

Position Encoding

why

完结

留意部分

留意力机制/自留意力

掩码

作用

怎样作业

形状解说

完好完结

多头留意力完结

Norm处理

FeedForward 以及衔接

编码器

解码器

中心层

拼装

输出层

模型拼装

总结

作者信息

推广

前沿系列–Transform架构[架构分析+代码实现]

前语

整体架构

整体

使命运用

输入部分

Embedding

Position Encoding

why

完结

留意部分

留意力机制/自留意力

掩码

作用

怎样作业

形状解说

完好完结

多头留意力完结

Norm处理

FeedForward 以及衔接

编码器

解码器

中心层

拼装

输出层

模型拼装

总结

相关文章

对话Robin Marx：HTTP/3和QUIC将带来重大机遇和挑战

用ChatGPT来了解ChatGPT

15755字，解锁MySQL性能优化新姿势

关于推动可追溯代码来源的计划

作者信息

推广