Alexander Rush作者

Transformer注解及PyTorch实现(上)

原文:http://nlp.seas.harvard.edu/2018/04/03/attention.html 作者:Alexander Rush 译者:哈工大SCIR 赵正宇

"Attention is All You Need"[1] 一文中提出的Transformer网络结构最近引起了很多人的关注。Transformer不仅能够明显地提升翻译质量,还为许多NLP任务提供了新的结构。虽然原文写得很清楚,但实际上大家普遍反映很难正确地实现。

所以我们为此文章写了篇注解文档,并给出了一行行实现的Transformer的代码。本文档删除了原文的一些章节并进行了重新排序,并在整个文章中加入了相应的注解。此外,本文档以Jupyter notebook的形式完成,本身就是直接可以运行的代码实现,总共有400行库代码,在4个GPU上每秒可以处理27,000个tokens。

想要运行此工作,首先需要安装PyTorch[2]。这篇文档完整的notebook文件及依赖可在github[3] 或 Google Colab[4]上找到。

需要注意的是,此注解文档和代码仅作为研究人员和开发者的入门版教程。这里提供的代码主要依赖OpenNMT[5]实现,想了解更多关于此模型的其他实现版本可以查看Tensor2Tensor[6] (tensorflow版本) 和 Sockeye[7](mxnet版本)

  • Alexander Rush (@harvardnlp[8] or srush@seas.harvard.edu)

准备工作

  1. # !pip install http://download.pytorch.org/whl/cu80/torch-0.3.0.post4-cp36-cp36m-linux_x86_64.whl numpy matplotlib spacy torchtext seaborn

  1. import numpy as np

  2. import torch

  3. import torch.nn as nn

  4. import torch.nn.functional as F

  5. import math, copy, time

  6. from torch.autograd import Variable

  7. import matplotlib.pyplot as plt

  8. import seaborn

  9. seaborn.set_context(context="talk")

  10. %matplotlib inline

内容目录

准备工作

背景

模型结构

    - Encoder和Decoder

        - Encoder

        - Decoder

        - Attention

        - Attention在模型中的应用

    - Position-wise前馈网络

    - Embedding和Softmax 

    - 位置编码

    - 完整模型

(由于原文篇幅过长,其余部分在下篇)

训练

    - 批和掩码

    - 训练循环

    - 训练数据和批处理

    - 硬件和训练进度

    - 优化器

    - 正则化

        - 标签平滑

第一个例子

    - 数据生成

    - 损失计算

    - 贪心解码

真实示例

    - 数据加载

    - 迭代器

    - 多GPU训练

    - 训练系统附加组件:BPE,搜索,平均

结果

    - 注意力可视化

结论

本文注解部分都是以引用的形式给出的,主要内容都是来自原文。

背景

减少序列处理任务的计算量是一个很重要的问题,也是Extended Neural GPU、ByteNet和ConvS2S等网络的动机。上面提到的这些网络都以CNN为基础,并行计算所有输入和输出位置的隐藏表示。 在这些模型中,关联来自两个任意输入或输出位置的信号所需的操作数随位置间的距离增长而增长,比如ConvS2S呈线性增长,ByteNet呈现以对数形式增长,这会使学习较远距离的两个位置之间的依赖关系变得更加困难。而在Transformer中,操作次数则被减少到了常数级别。

Self-attention有时候也被称为Intra-attention,是在单个句子不同位置上做的Attention,并得到序列的一个表示。它能够很好地应用到很多任务中,包括阅读理解、摘要、文本蕴涵,以及独立于任务的句子表示。端到端的网络一般都是基于循环注意力机制而不是序列对齐循环,并且已经有证据表明在简单语言问答和语言建模任务上表现很好。

据我们所知,Transformer是第一个完全依靠Self-attention而不使用序列对齐的RNN或卷积的方式来计算输入输出表示的转换模型。

模型结构

目前大部分比较热门的神经序列转换模型都有Encoder-Decoder结构[9]。Encoder将输入序列 映射到一个连续表示序列 。对于编码得到的,Decoder每次解码生成一个符号,直到生成完整的输出序列:。对于每一步解码,模型都是自回归的[10],即在生成下一个符号时将先前生成的符号作为附加输入。

  1. class EncoderDecoder(nn.Module):

  2.    """

  3.    A standard Encoder-Decoder architecture. Base for this and many

  4.    other models.

  5.    """

  6.    def __init__(self, encoder, decoder, src_embed, tgt_embed, generator):

  7.        super(EncoderDecoder, self).__init__()

  8.        self.encoder = encoder

  9.        self.decoder = decoder

  10.        self.src_embed = src_embed

  11.        self.tgt_embed = tgt_embed

  12.        self.generator = generator

  13.    def forward(self, src, tgt, src_mask, tgt_mask):

  14.        "Take in and process masked src and target sequences."

  15.        return self.decode(self.encode(src, src_mask), src_mask,

  16.                            tgt, tgt_mask)

  17.    def encode(self, src, src_mask):

  18.        return self.encoder(self.src_embed(src), src_mask)

  19.    def decode(self, memory, src_mask, tgt, tgt_mask):

  20.        return self.decoder(self.tgt_embed(tgt), memory, src_mask, tgt_mask)

  1. class Generator(nn.Module):

  2.    "Define standard linear + softmax generation step."

  3.    def __init__(self, d_model, vocab):

  4.        super(Generator, self).__init__()

  5.        self.proj = nn.Linear(d_model, vocab)

  6.    def forward(self, x):

  7.        return F.log_softmax(self.proj(x), dim=-1)

Transformer的整体结构如下图所示,在Encoder和Decoder中都使用了Self-attention, Point-wise和全连接层。Encoder和decoder的大致结构分别如下图的左半部分和右半部分所示。

Encoder和Decoder

Encoder

Encoder由N=6个相同的层组成。

  1. def clones(module, N):

  2.    "Produce N identical layers."

  3.    return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])

  1. class Encoder(nn.Module):

  2.    "Core encoder is a stack of N layers"

  3.    def __init__(self, layer, N):

  4.        super(Encoder, self).__init__()

  5.        self.layers = clones(layer, N)

  6.        self.norm = LayerNorm(layer.size)

  7.    def forward(self, x, mask):

  8.        "Pass the input (and mask) through each layer in turn."

  9.        for layer in self.layers:

  10.            x = layer(x, mask)

  11.        return self.norm(x)

我们在每两个子层之间都使用了残差连接(Residual Connection) [11]和归一化 [12]。

  1. class LayerNorm(nn.Module):

  2.    "Construct a layernorm module (See citation for details)."

  3.    def __init__(self, features, eps=1e-6):

  4.        super(LayerNorm, self).__init__()

  5.        self.a_2 = nn.Parameter(torch.ones(features))

  6.        self.b_2 = nn.Parameter(torch.zeros(features))

  7.        self.eps = eps

  8.    def forward(self, x):

  9.        mean = x.mean(-1, keepdim=True)

  10.        std = x.std(-1, keepdim=True)

  11.        return self.a_2 * (x - mean) / (std + self.eps) + self.b_2

也就是说,每个子层的输出为 ,其中  是由子层自动实现的函数。我们在每个子层的输出上使用Dropout,然后将其添加到下一子层的输入并进行归一化。

为了能方便地使用这些残差连接,模型中所有的子层和Embedding层的输出都设定成了相同的维度,即

  1. class SublayerConnection(nn.Module):

  2.    """

  3.    A residual connection followed by a layer norm.

  4.    Note for code simplicity the norm is first as opposed to last.

  5.    """

  6.    def __init__(self, size, dropout):

  7.        super(SublayerConnection, self).__init__()

  8.        self.norm = LayerNorm(size)

  9.        self.dropout = nn.Dropout(dropout)

  10.    def forward(self, x, sublayer):

  11.        "Apply residual connection to any sublayer with the same size."

  12.        return x + self.dropout(sublayer(self.norm(x)))

每层都有两个子层组成。第一个子层实现了“多头”的 Self-attention,第二个子层则是一个简单的Position-wise的全连接前馈网络。

  1. class EncoderLayer(nn.Module):

  2.    "Encoder is made up of self-attn and feed forward (defined below)"

  3.    def __init__(self, size, self_attn, feed_forward, dropout):

  4.        super(EncoderLayer, self).__init__()

  5.        self.self_attn = self_attn

  6.        self.feed_forward = feed_forward

  7.        self.sublayer = clones(SublayerConnection(size, dropout), 2)

  8.        self.size = size

  9.    def forward(self, x, mask):

  10.        "Follow Figure 1 (left) for connections."

  11.        x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, mask))

  12.        return self.sublayer[1](x, self.feed_forward)

Decoder

Decoder也是由N=6个相同层组成。

  1. class Decoder(nn.Module):

  2.    "Generic N layer decoder with masking."

  3.    def __init__(self, layer, N):

  4.        super(Decoder, self).__init__()

  5.        self.layers = clones(layer, N)

  6.        self.norm = LayerNorm(layer.size)

  7.    def forward(self, x, memory, src_mask, tgt_mask):

  8.        for layer in self.layers:

  9.            x = layer(x, memory, src_mask, tgt_mask)

  10.        return self.norm(x)

除了每个编码器层中的两个子层之外,解码器还插入了第三种子层对编码器栈的输出实行“多头”的Attention。 与编码器类似,我们在每个子层两端使用残差连接进行短路,然后进行层的规范化处理。

  1. class DecoderLayer(nn.Module):

  2.    "Decoder is made of self-attn, src-attn, and feed forward (defined below)"

  3.    def __init__(self, size, self_attn, src_attn, feed_forward, dropout):

  4.        super(DecoderLayer, self).__init__()

  5.        self.size = size

  6.        self.self_attn = self_attn

  7.        self.src_attn = src_attn

  8.        self.feed_forward = feed_forward

  9.        self.sublayer = clones(SublayerConnection(size, dropout), 3)

  10.    def forward(self, x, memory, src_mask, tgt_mask):

  11.        "Follow Figure 1 (right) for connections."

  12.        m = memory

  13.        x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, tgt_mask))

  14.        x = self.sublayer[1](x, lambda x: self.src_attn(x, m, m, src_mask))

  15.        return self.sublayer[2](x, self.feed_forward)

我们还修改解码器中的Self-attention子层以防止当前位置Attend到后续位置。这种Masked的Attention是考虑到输出Embedding会偏移一个位置,确保了生成位置的预测时,仅依赖小于的位置处的已知输出,相当于把后面不该看到的信息屏蔽掉。

  1. def subsequent_mask(size):

  2.    "Mask out subsequent positions."

  3.    attn_shape = (1, size, size)

  4.    subsequent_mask = np.triu(np.ones(attn_shape), k=1).astype('uint8')

  5.    return torch.from_numpy(subsequent_mask) == 0

下面的Attention mask图显示了允许每个目标词(行)查看的位置(列)。在训练期间,当前解码位置的词不能Attend到后续位置的词。

  1. plt.figure(figsize=(5,5))

  2. plt.imshow(subsequent_mask(20)[0])

  3. None

Attention

Attention函数可以将Query和一组Key-Value对映射到输出,其中Query、Key、Value和输出都是向量。 输出是值的加权和,其中分配给每个Value的权重Query与相应Key的兼容函数计算。

我们称这种特殊的Attention机制为"Scaled Dot-Product Attention"。输入包含维度为Query和Key,以及维度为的Value。 我们首先分别计算Query与各个Key的点积,然后将每个点积除以,最后使用Softmax函数来获得Key的权重

在具体实现时,我们可以以矩阵的形式进行并行运算,这样能加速运算过程。具体来说,将所有的Query、Key和Value向量分别组合成矩阵,这样输出矩阵可以表示为:

  1. def attention(query, key, value, mask=None, dropout=None):

  2.    "Compute 'Scaled Dot Product Attention'"

  3.    d_k = query.size(-1)

  4.    scores = torch.matmul(query, key.transpose(-2, -1)) \

  5.             / math.sqrt(d_k)

  6.    if mask is not None:

  7.        scores = scores.masked_fill(mask == 0, -1e9)

  8.    p_attn = F.softmax(scores, dim = -1)

  9.    if dropout is not None:

  10.        p_attn = dropout(p_attn)

  11.    return torch.matmul(p_attn, value), p_attn          

两种最常用的Attention函数是加和Attention[13]和点积(乘积)Attention,我们的算法与点积Attention很类似,但是  的比例因子不同。加和Attention使用具有单个隐藏层的前馈网络来计算兼容函数。虽然两种方法理论上的复杂度是相似的,但在实践中,点积Attention的运算会更快一些,也更节省空间,因为它可以使用高效的矩阵乘法算法来实现。

虽然对于较小的,这两种机制的表现相似,但在不放缩较大的时,加和Attention要优于点积Attention[14]。我们怀疑,对于较大的,点积大幅增大,将Softmax函数推向具有极小梯度的区域(为了阐明点积变大的原因,假设是独立的随机变量,平均值为,方差,这样他们的点积为 ,同样是均值为方差为)。为了抵消这种影响,我们用来缩放点积。

“多头”机制能让模型考虑到不同位置的Attention,另外“多头”Attention可以在不同的子空间表示不一样的关联关系,使用单个Head的Attention一般达不到这种效果。

其中参数矩阵为, ,  和

我们的工作中使用个Head并行的Attention,对每一个Head来说有,总计算量与完整维度的单个Head的Attention很相近。

  1. class MultiHeadedAttention(nn.Module):

  2.    def __init__(self, h, d_model, dropout=0.1):

  3.        "Take in model size and number of heads."

  4.        super(MultiHeadedAttention, self).__init__()

  5.        assert d_model % h == 0

  6.        # We assume d_v always equals d_k

  7.        self.d_k = d_model // h

  8.        self.h = h

  9.        self.linears = clones(nn.Linear(d_model, d_model), 4)

  10.        self.attn = None

  11.        self.dropout = nn.Dropout(p=dropout)

  12.    def forward(self, query, key, value, mask=None):

  13.        "Implements Figure 2"

  14.        if mask is not None:

  15.            # Same mask applied to all h heads.

  16.            mask = mask.unsqueeze(1)

  17.        nbatches = query.size(0)

  18.        # 1) Do all the linear projections in batch from d_model => h x d_k

  19.        query, key, value = \

  20.            [l(x).view(nbatches, -1, self.h, self.d_k).transpose(1, 2)

  21.             for l, x in zip(self.linears, (query, key, value))]

  22.        # 2) Apply attention on all the projected vectors in batch.

  23.        x, self.attn = attention(query, key, value, mask=mask,

  24.                                 dropout=self.dropout)

  25.        # 3) "Concat" using a view and apply a final linear.

  26.        x = x.transpose(1, 2).contiguous() \

  27.             .view(nbatches, -1, self.h * self.d_k)

  28.        return self.linears[-1](x)

Attention在模型中的应用

Transformer中以三种不同的方式使用了“多头”Attention:

1) 在"Encoder-Decoder Attention"层,Query来自先前的解码器层,并且Key和Value来自Encoder的输出。Decoder中的每个位置Attend输入序列中的所有位置,这与Seq2Seq模型中的经典的Encoder-Decoder Attention机制[15]一致。

2) Encoder中的Self-attention层。在Self-attention层中,所有的Key、Value和Query都来同一个地方,这里都是来自Encoder中前一层的输出。Encoder中当前层的每个位置都能Attend到前一层的所有位置。

3) 类似的,解码器中的Self-attention层允许解码器中的每个位置Attend当前解码位置和它前面的所有位置。这里需要屏蔽解码器中向左的信息流以保持自回归属性。具体的实现方式是在缩放后的点积Attention中,屏蔽(设为)Softmax的输入中所有对应着非法连接的Value。

Position-wise前馈网络

除了Attention子层之外,Encoder和Decoder中的每个层都包含一个全连接前馈网络,分别地应用于每个位置。其中包括两个线性变换,然后使用ReLU作为激活函数

虽然线性变换在不同位置上是相同的,但它们在层与层之间使用不同的参数。这其实是相当于使用了两个内核大小为1的卷积。这里设置输入和输出的维数为,内层的维度为

  1. class PositionwiseFeedForward(nn.Module):

  2.    "Implements FFN equation."

  3.    def __init__(self, d_model, d_ff, dropout=0.1):

  4.        super(PositionwiseFeedForward, self).__init__()

  5.        self.w_1 = nn.Linear(d_model, d_ff)

  6.        self.w_2 = nn.Linear(d_ff, d_model)

  7.        self.dropout = nn.Dropout(dropout)

  8.    def forward(self, x):

  9.        return self.w_2(self.dropout(F.relu(self.w_1(x))))

Embedding和Softmax

与其他序列转换模型类似,我们使用预学习的Embedding将输入Token序列和输出Token序列转化为维向量。我们还使用常用的预训练的线性变换和Softmax函数将解码器输出转换为预测下一个Token的概率。在我们的模型中,我们在两个Embedding层和Pre-softmax线性变换之间共享相同的权重矩阵,类似于[16]。在Embedding层中,我们将这些权重乘以

  1. class Embeddings(nn.Module):

  2.    def __init__(self, d_model, vocab):

  3.        super(Embeddings, self).__init__()

  4.        self.lut = nn.Embedding(vocab, d_model)

  5.        self.d_model = d_model

  6.    def forward(self, x):

  7.        return self.lut(x) * math.sqrt(self.d_model)

位置编码

由于我们的模型不包含递归和卷积结构,为了使模型能够有效利用序列的顺序特征,我们需要加入序列中各个Token间相对位置或Token在序列中绝对位置的信息。在这里,我们将位置编码添加到编码器和解码器栈底部的输入Embedding。由于位置编码与Embedding具有相同的维度,因此两者可以直接相加。其实这里还有许多位置编码可供选择,其中包括可更新的和固定不变的[17]。

在此项工作中,我们使用不同频率的正弦和余弦函数:

其中是位置,是维度。 也就是说,位置编码的每个维度都对应于一个正弦曲线,其波长形成从的等比级数。我们之所以选择了这个函数,是因为我们假设它能让模型很容易学会Attend相对位置,因为对于任何固定的偏移量, 可以表示为的线性函数。

此外,在编码器和解码器堆栈中,我们在Embedding与位置编码的加和上都使用了Dropout机制。在基本模型上,我们使用的比率。

  1. class PositionalEncoding(nn.Module):

  2.    "Implement the PE function."

  3.    def __init__(self, d_model, dropout, max_len=5000):

  4.        super(PositionalEncoding, self).__init__()

  5.        self.dropout = nn.Dropout(p=dropout)

  6.        # Compute the positional encodings once in log space.

  7.        pe = torch.zeros(max_len, d_model)

  8.        position = torch.arange(0, max_len).unsqueeze(1)

  9.        div_term = torch.exp(torch.arange(0, d_model, 2) *

  10.                             -(math.log(10000.0) / d_model))

  11.        pe[:, 0::2] = torch.sin(position * div_term)

  12.        pe[:, 1::2] = torch.cos(position * div_term)

  13.        pe = pe.unsqueeze(0)

  14.        self.register_buffer('pe', pe)

  15.    def forward(self, x):

  16.        x = x + Variable(self.pe[:, :x.size(1)],

  17.                         requires_grad=False)

  18.        return self.dropout(x)

如下所示,位置编码将根据位置添加正弦曲线。曲线的频率和偏移对于每个维度是不同的。

  1. plt.figure(figsize=(15, 5))

  2. pe = PositionalEncoding(20, 0)

  3. y = pe.forward(Variable(torch.zeros(1, 100, 20)))

  4. plt.plot(np.arange(100), y[0, :, 4:8].data.numpy())

  5. plt.legend(["dim %d"%p for p in [4,5,6,7]])

  6. None

我们也尝试了使用预学习的位置Embedding,但是发现这两个版本的结果基本是一样的。我们选择了使用正弦曲线版本的实现,因为使用此版本能让模型能够处理大于训练语料中最大序列长度的序列。

完整模型

下面定义了连接完整模型并设置超参的函数。

  1. def make_model(src_vocab, tgt_vocab, N=6,

  2.               d_model=512, d_ff=2048, h=8, dropout=0.1):

  3.    "Helper: Construct a model from hyperparameters."

  4.    c = copy.deepcopy

  5.    attn = MultiHeadedAttention(h, d_model)

  6.    ff = PositionwiseFeedForward(d_model, d_ff, dropout)

  7.    position = PositionalEncoding(d_model, dropout)

  8.    model = EncoderDecoder(

  9.        Encoder(EncoderLayer(d_model, c(attn), c(ff), dropout), N),

  10.        Decoder(DecoderLayer(d_model, c(attn), c(attn),

  11.                             c(ff), dropout), N),

  12.        nn.Sequential(Embeddings(d_model, src_vocab), c(position)),

  13.        nn.Sequential(Embeddings(d_model, tgt_vocab), c(position)),

  14.        Generator(d_model, tgt_vocab))

  15.    # This was important from their code.

  16.    # Initialize parameters with Glorot / fan_avg.

  17.    for p in model.parameters():

  18.        if p.dim() > 1:

  19.            nn.init.xavier_uniform(p)

  20.    return model

  1. # Small example model.

  2. tmp_model = make_model(10, 10, 2)

  3. None

参考链接

[1] https://arxiv.org/abs/1706.03762

[2] https://pytorch.org/

[3] https://github.com/harvardnlp/annotated-transformer

[4] https://drive.google.com/file/d/1xQXSv6mtAOLXxEMi8RvaW8TW-7bvYBDF/view?usp=sharing

[5] http://opennmt.net

[6] https://github.com/tensorflow/tensor2tensor

[7] https://github.com/awslabs/sockeye

[8] https://twitter.com/harvardnlp

[9] https://arxiv.org/abs/1409.0473

[10] https://arxiv.org/abs/1308.0850

[11] https://arxiv.org/abs/1512.03385

[12] https://arxiv.org/abs/1607.06450

[13] https://arxiv.org/abs/1409.0473

[14] https://arxiv.org/abs/1703.03906

[15] https://arxiv.org/abs/1609.08144

[16] https://arxiv.org/abs/1608.05859

[17] https://arxiv.org/pdf/1705.03122.pdf

本期责任编辑:张伟男

本期编辑:刘元兴

哈工大SCIR
哈工大SCIR

哈尔滨工业大学社会计算与信息检索研究中心

工程正则化优化器模型前馈网络NLP激活函数PyTorchTransformer
6
相关数据
激活函数技术

在 计算网络中, 一个节点的激活函数定义了该节点在给定的输入或输入的集合下的输出。标准的计算机芯片电路可以看作是根据输入得到"开"(1)或"关"(0)输出的数字网络激活函数。这与神经网络中的线性感知机的行为类似。 一种函数(例如 ReLU 或 S 型函数),用于对上一层的所有输入求加权和,然后生成一个输出值(通常为非线性值),并将其传递给下一层。

权重技术

线性模型中特征的系数,或深度网络中的边。训练线性模型的目标是确定每个特征的理想权重。如果权重为 0,则相应的特征对模型来说没有任何贡献。

Dropout技术

神经网络训练中防止过拟合的一种技术

自注意力技术

自注意力(Self-attention),有时也称为内部注意力,它是一种涉及单序列不同位置的注意力机制,并能计算序列的表征。自注意力在多种任务中都有非常成功的应用,例如阅读理解、摘要概括、文字蕴含和语句表征等。自注意力这种在序列内部执行 Attention 的方法可以视为搜索序列内部的隐藏关系,这种内部关系对于翻译以及序列任务的性能非常重要。

参数技术

在数学和统计学裡,参数(英语:parameter)是使用通用变量来建立函数和变量之间关系(当这种关系很难用方程来阐述时)的一个数量。

注意力机制技术

我们可以粗略地把神经注意机制类比成一个可以专注于输入内容的某一子集(或特征)的神经网络. 注意力机制最早是由 DeepMind 为图像分类提出的,这让「神经网络在执行预测任务时可以更多关注输入中的相关部分,更少关注不相关的部分」。当解码器生成一个用于构成目标句子的词时,源句子中仅有少部分是相关的;因此,可以应用一个基于内容的注意力机制来根据源句子动态地生成一个(加权的)语境向量(context vector), 然后网络会根据这个语境向量而不是某个固定长度的向量来预测词。

张量技术

张量是一个可用来表示在一些矢量、标量和其他张量之间的线性关系的多线性函数,这些线性关系的基本例子有内积、外积、线性映射以及笛卡儿积。其坐标在 维空间内,有 个分量的一种量,其中每个分量都是坐标的函数,而在坐标变换时,这些分量也依照某些规则作线性变换。称为该张量的秩或阶(与矩阵的秩和阶均无关系)。 在数学里,张量是一种几何实体,或者说广义上的“数量”。张量概念包括标量、矢量和线性算子。张量可以用坐标系统来表达,记作标量的数组,但它是定义为“不依赖于参照系的选择的”。张量在物理和工程学中很重要。例如在扩散张量成像中,表达器官对于水的在各个方向的微分透性的张量可以用来产生大脑的扫描图。工程上最重要的例子可能就是应力张量和应变张量了,它们都是二阶张量,对于一般线性材料他们之间的关系由一个四阶弹性张量来决定。

映射技术

映射指的是具有某种特殊结构的函数,或泛指类函数思想的范畴论中的态射。 逻辑和图论中也有一些不太常规的用法。其数学定义为:两个非空集合A与B间存在着对应关系f,而且对于A中的每一个元素x,B中总有有唯一的一个元素y与它对应,就这种对应为从A到B的映射,记作f:A→B。其中,y称为元素x在映射f下的象,记作:y=f(x)。x称为y关于映射f的原象*。*集合A中所有元素的象的集合称为映射f的值域,记作f(A)。同样的,在机器学习中,映射就是输入与输出之间的对应关系。

规范化技术

规范化:将属性数据按比例缩放,使之落入一个小的特定区间,如-1.0 到1.0 或0.0 到1.0。 通过将属性数据按比例缩放,使之落入一个小的特定区间,如0.0到1.0,对属性规范化。对于距离度量分类算法,如涉及神经网络或诸如最临近分类和聚类的分类算法,规范化特别有用。如果使用神经网络后向传播算法进行分类挖掘,对于训练样本属性输入值规范化将有助于加快学习阶段的速度。对于基于距离的方法,规范化可以帮助防止具有较大初始值域的属性与具有较小初始值域的属相相比,权重过大。有许多数据规范化的方法,包括最小-最大规范化、z-score规范化和按小数定标规范化。

查询技术

一般来说,查询是询问的一种形式。它在不同的学科里涵义有所不同。在信息检索领域,查询指的是数据库和信息系统对信息检索的精确要求

正则化技术

当模型的复杂度增大时,训练误差会逐渐减小并趋向于0;而测试误差会先减小,达到最小值后又增大。当选择的模型复杂度过大时,过拟合现象就会发生。这样,在学习时就要防止过拟合。进行最优模型的选择,即选择复杂度适当的模型,以达到使测试误差最小的学习目的。

序列到序列技术

优化器技术

优化器基类提供了计算梯度loss的方法,并可以将梯度应用于变量。优化器里包含了实现了经典的优化算法,如梯度下降和Adagrad。 优化器是提供了一个可以使用各种优化算法的接口,可以让用户直接调用一些经典的优化算法,如梯度下降法等等。优化器(optimizers)类的基类。这个类定义了在训练模型的时候添加一个操作的API。用户基本上不会直接使用这个类,但是你会用到他的子类比如GradientDescentOptimizer, AdagradOptimizer, MomentumOptimizer(tensorflow下的优化器包)等等这些算法。

推荐文章
暂无评论
暂无评论~