【Pytorch】带注释的Transformer (各个部件的实现及应用实例)_pytorch transformer src_mask-程序员宅基地

技术标签: Powered by 金山文档  深度学习  pytorch  transformer  预训练语言模型(Transformer、BERT、GPT等)  

from IPython.display import Image
Image(filename='images/aiayn.png')

在过去的一年里,很多人都在关注“Attention is All You Need”中的变形金刚。除了在翻译质量上产生重大改进外,它还为许多其他 NLP 任务提供了新的架构。论文本身写得很清楚,但传统观点认为要正确实施是相当困难的。

在这篇文章中,我以逐行实现的形式展示了该论文的“注释”版本。我重新排序并删除了原始论文中的某些部分,并在整个过程中添加了评论。本文档本身是一个工作笔记本,应该是一个完全可用的实现。总共有 400 行库代码,可以在 4 个 GPU 上每秒处理 27,000 个令牌。

要继续学习,您首先需要安装 PyTorch。完整的笔记本也可以在 github或带有免费 GPU 的 Google Colab上获得。

预赛

# !pip install http://download.pytorch.org/whl/cu80/torch-0.3.0.post4-cp36-cp36m-linux_x86_64.whl numpy matplotlib spacy torchtext seaborn 
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import math, copy, time
from torch.autograd import Variable
import matplotlib.pyplot as plt
import seaborn
seaborn.set_context(context="talk")
%matplotlib inline

背景

减少顺序计算的目标也构成了扩展神经 GPU、ByteNet 和 ConvS2S 的基础,它们都使用卷积神经网络作为基本构建块,为所有输入和输出位置并行计算隐藏表示。在这些模型中,将来自两个任意输入或输出位置的信号相关联所需的操作数量随着位置之间的距离而增加,ConvS2S 呈线性增长,ByteNet 呈对数增长。这使得学习远距离位置之间的依赖关系变得更加困难。在 Transformer 中,这被减少到恒定数量的操作,尽管由于平均注意力加权位置而以降低有效分辨率为代价,我们用多头注意力抵消了这种影响。

自注意力,有时称为内部注意力,是一种将单个序列的不同位置相关联以计算序列表示的注意力机制。自注意力已成功用于各种任务,包括阅读理解、抽象摘要、文本蕴含和学习与任务无关的句子表示。端到端记忆网络基于循环注意力机制而不是序列对齐循环,并且已被证明在简单语言问答和语言建模任务上表现良好。

然而,据我们所知,Transformer 是第一个完全依赖自注意力来计算其输入和输出表示而不使用序列对齐 RNN 或卷积的转导模型。

模型架构

大多数有竞争力的神经序列转导模型都具有编码器-解码器结构(引用)。在这里,编码器映射符号表示的输入序列(x1,…,xn)到一系列连续的表示z=(z1,…,zn) 鉴于z,解码器然后生成一个输出序列 (y1,…,ym)一次一个元素的符号。在每个步骤中,模型都是自回归的 (引用),在生成下一步时将先前生成的符号作为附加输入使用。

class EncoderDecoder(nn.Module):
    """
    标准的编码器-解码器架构。这个和许多的基础其他型号
    """
    def __init__(self, encoder, decoder, src_embed, tgt_embed, generator):
        super(EncoderDecoder, self).__init__()
        self.encoder = encoder
        self.decoder = decoder
        self.src_embed = src_embed
        self.tgt_embed = tgt_embed
        self.generator = generator
        
    def forward(self, src, tgt, src_mask, tgt_mask):
        "接收并处理掩蔽的 src 和 target 序列。"
        return self.decode(self.encode(src, src_mask), src_mask,
                            tgt, tgt_mask)
    
    def encode(self, src, src_mask):
        return self.encoder(self.src_embed(src), src_mask)
    
    def decode(self, memory, src_mask, tgt, tgt_mask):
        return self.decoder(self.tgt_embed(tgt), memory, src_mask, tgt_mask)
class Generator(nn.Module):
    "定义标准 linear + softmax 生成步长。"
    def __init__(self, d_model, vocab):
        super(Generator, self).__init__()
        self.proj = nn.Linear(d_model, vocab)

    def forward(self, x):
        return F.log_softmax(self.proj(x), dim=-1)

Transformer 遵循这种整体架构,为编码器和解码器使用堆叠式自注意力层和逐点全连接层,分别如图 1 的左半部分和右半部分所示。

Image(filename='images/ModalNet-21.png')

编码器和解码器堆栈

编码器

编码器由一堆栈N=6 相同的图层。

def clones(module, N):
    "产生 N 个相同的层。"
    return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])
class Encoder(nn.Module):
    " 核心编码器是 N 层的堆栈"
    def __init__(self, layer, N):
        super(Encoder, self).__init__()
        self.layers = clones(layer, N)
        self.norm = LayerNorm(layer.size)
        
    def forward(self, x, mask):
        " 依次将输入(和掩码)传递给每一层。"
        for layer in self.layers:
            x = layer(x, mask)
        return self.norm(x)

我们在两个子层中的每一个周围都 使用了一个残差连接(引用) ,然后是层归一化(引用)

class LayerNorm(nn.Module):
    " 构造层范数模块(详见引文)."
    def __init__(self, features, eps=1e-6):
        super(LayerNorm, self).__init__()
        self.a_2 = nn.Parameter(torch.ones(features))
        self.b_2 = nn.Parameter(torch.zeros(features))
        self.eps = eps

    def forward(self, x):
        mean = x.mean(-1, keepdim=True)
        std = x.std(-1, keepdim=True)
        return self.a_2 * (x - mean) / (std + self.eps) + self.b_2

即每个子层的输出为LayerNorm(x+Sublayer(x)),Sublayer(x) 是子层自己实现的功能。我们将 dropout (引用)应用于每个子层的输出,然后再将其添加到子层输入并进行归一化。

为了促进这些残差连接,模型中的所有子层以及嵌入层都产生维度的输出d模型=512�模型=512.

class SublayerConnection(nn.Module):
    """
    残差连接后跟层范数。
    请注意,为了简化代码,规范是第一个而不是最后一个。
    """
    def __init__(self, size, dropout):
        super(SublayerConnection, self).__init__()
        self.norm = LayerNorm(size)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x, sublayer):
        "将剩余连接应用于具有相同大小的任何子层。"
        return x + self.dropout(sublayer(self.norm(x)))

每一层都有两个子层。第一个是多头自注意力机制,第二个是简单的位置全连接前馈网络。

class EncoderLayer(nn.Module):
    "Encoder由self-attn和feed forward组成(定义如下)"
    def __init__(self, size, self_attn, feed_forward, dropout):
        super(EncoderLayer, self).__init__()
        self.self_attn = self_attn
        self.feed_forward = feed_forward
        self.sublayer = clones(SublayerConnection(size, dropout), 2)
        self.size = size

    def forward(self, x, mask):
        "按照图 1(左)进行连接。"
        x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, mask))
        return self.sublayer[1](x, self.feed_forward)

解码器

解码器也是由一堆栈 N=6 相同的图层。

class Decoder(nn.Module):
    " 带掩码的通用 N 层解码器。"
    def __init__(self, layer, N):
        super(Decoder, self).__init__()
        self.layers = clones(layer, N)
        self.norm = LayerNorm(layer.size)
        
    def forward(self, x, memory, src_mask, tgt_mask):
        for layer in self.layers:
            x = layer(x, memory, src_mask, tgt_mask)
        return self.norm(x)

除了每个编码器层中的两个子层之外,解码器还插入了第三个子层,它对编码器堆栈的输出执行多头注意力。与编码器类似,我们在每个子层周围使用残差连接,然后进行层归一化。

class DecoderLayer(nn.Module):
    " 解码器由 self-attn、src-attn 和前馈(定义如下)组成"
    def __init__(self, size, self_attn, src_attn, feed_forward, dropout):
        super(DecoderLayer, self).__init__()
        self.size = size
        self.self_attn = self_attn
        self.src_attn = src_attn
        self.feed_forward = feed_forward
        self.sublayer = clones(SublayerConnection(size, dropout), 3)
 
    def forward(self, x, memory, src_mask, tgt_mask):
        " 按照图 1(右)进行连接。"
        m = memory
        x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, tgt_mask))
        x = self.sublayer[1](x, lambda x: self.src_attn(x, m, m, src_mask))
        return self.sublayer[2](x, self.feed_forward)

我们还修改了解码器堆栈中的自我注意子层,以防止位置关注后续位置。这种掩蔽与输出嵌入偏移一个位置的事实相结合,确保了对位置的预测我我只能依赖于位置小于的已知输出我我.

def subsequent_mask(size):
    " 掩盖后续 positions."
    attn_shape = (1, size, size)
    subsequent_mask = np.triu(np.ones(attn_shape), k=1).astype('uint8')
    return torch.from_numpy(subsequent_mask) == 0
注意掩码下方显示了允许每个 tgt 词(行)查看(列)的位置。在训练过程中,为了注意未来的单词,单词被阻止了。
plt.figure(figsize=(5,5))
plt.imshow(subsequent_mask(20)[0])
None

注意力

注意力函数可以描述为将查询和一组键值对映射到输出,其中查询、键、值和输出都是向量。输出计算为值的加权和,其中分配给每个值的权重由查询与相应键的兼容性函数计算。

我们将我们的特别注意力称为“缩放点积注意力”。输入由维度的查询和键组成dk, 和尺寸值dv. 我们用所有键计算查询的点积,将每个键除以 √dk,并应用 softmax 函数来获取值的权重。

Image(filename='images/ModalNet-19.png')

在实践中,我们同时计算一组查询的注意力函数,将它们打包成一个矩阵Q. 键和值也一起打包成矩阵KV. 我们将输出矩阵计算为:

def attention(query, key, value, mask=None, dropout=None):
    "计算'缩放点积注意力'"
    d_k = query.size(-1)
    scores = torch.matmul(query, key.transpose(-2, -1)) \
             / math.sqrt(d_k)
    if mask is not None:
        scores = scores.masked_fill(mask == 0, -1e9)
    p_attn = F.softmax(scores, dim = -1)
    if dropout is not None:
        p_attn = dropout(p_attn)
    return torch.matmul(p_attn, value), p_attn

两种最常用的注意力函数是加法注意力 (引用)和点积(乘法)注意力。点积注意力与我们的算法相同,除了缩放因子1/√dk. 附加注意使用具有单个隐藏层的前馈网络计算兼容性函数。虽然两者在理论上的复杂性相似,但点积注意力在实践中速度更快且空间效率更高,因为它可以使用高度优化的矩阵乘法代码来实现。

而对于较小的值dk这两种机制的表现相似,加法注意力优于点积注意力,而无需缩放更大的值 dk (引用)。我们怀疑对于大值dk,点积的幅度变大,将 softmax 函数推入梯度极小的区域(为了说明为什么点积变大,假设qk是具有均值的独立随机变量0和方差1. 然后他们的点积,q⋅k=∑dki=1qiki, 有均值0和方差 dk). 为了抵消这种影响,我们将点积缩放为 1/√dk..

Image(filename='images/ModalNet-20.png')

多头注意力允许模型共同关注来自不同位置的不同表示子空间的信息。对于单个注意力头,平均可以抑制这种情况。

投影是参数矩阵

在这项工作中,我们雇用h=8平行的注意层,或头部。对于其中的每一个,我们使用dk=dv=dmodel/h=64. 由于每个头的维数减少,总计算成本与具有全维的单头注意力相似。

class MultiHeadedAttention(nn.Module):
    def __init__(self, h, d_model, dropout=0.1):
        "考虑模型大小和头数。"
        super(MultiHeadedAttention, self).__init__()
        assert d_model % h == 0
        # 我们假设 d_v 总是等于 d_k
        self.d_k = d_model // h
        self.h = h
        self.linears = clones(nn.Linear(d_model, d_model), 4)
        self.attn = None
        self.dropout = nn.Dropout(p=dropout)
        
    def forward(self, query, key, value, mask=None):
        " 实现图 2"
        if mask is not None:
            # 相同的面具适用于所有 h 头。
            mask = mask.unsqueeze(1)
        nbatches = query.size(0)
        
        # 1) 从 d_model => h x d_k 中批量进行所有线性投影
        query, key, value = \
            [l(x).view(nbatches, -1, self.h, self.d_k).transpose(1, 2)
             for l, x in zip(self.linears, (query, key, value))]
        
        # 2)批量关注所有投影向量。
        x, self.attn = attention(query, key, value, mask=mask, 
                                 dropout=self.dropout)
        
        #  3)使用视图“Concat”并应用最终线性。
        x = x.transpose(1, 2).contiguous() \
             .view(nbatches, -1, self.h * self.d_k)
        return self.linears[-1](x)

注意力在我们模型中的应用

Transformer 以三种不同的方式使用多头注意力:1)在“编码器-解码器注意力”层中,查询来自前一个解码器层,记忆键和值来自编码器的输出。这允许解码器中的每个位置都参与输入序列中的所有位置。这模仿了序列到序列模型中典型的编码器-解码器注意力机制,例如 (引用)

2)编码器包含自注意力层。在自注意力层中,所有的键、值和查询都来自同一个地方,在这种情况下,是编码器中前一层的输出。编码器中的每个位置都可以关注编码器上一层中的所有位置。

3)类似地,解码器中的自注意力层允许解码器中的每个位置关注解码器中直到并包括该位置的所有位置。我们需要防止解码器中的左向信息流以保持自回归特性。我们通过屏蔽(设置为−∞−∞) softmax 输入中对应于非法连接的所有值。

位置前馈网络

除了注意力子层之外,我们的编码器和解码器中的每一层都包含一个完全连接的前馈网络,该网络分别且相同地应用于每个位置。这由两个线性变换组成,中间有一个 ReLU 激活。

虽然线性变换在不同位置是相同的,但它们在层与层之间使用不同的参数。另一种描述方式是将其作为内核大小为 1 的两个卷积。输入和输出的维数是dmodel=512, 内层有维度dff=2048.

class PositionwiseFeedForward(nn.Module):
    " 实现 FFN 方程。"
    def __init__(self, d_model, d_ff, dropout=0.1):
        super(PositionwiseFeedForward, self).__init__()
        self.w_1 = nn.Linear(d_model, d_ff)
        self.w_2 = nn.Linear(d_ff, d_model)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        return self.w_2(self.dropout(F.relu(self.w_1(x))))

Embeddings和 Softmax

与其他序列转导模型类似,我们使用学习嵌入将输入标记和输出标记转换为维度向量 dmodel. 我们还使用通常学习的线性变换和 softmax 函数将解码器输出转换为预测的下一个标记概率。在我们的模型中,我们在两个嵌入层和 pre-softmax 线性变换之间共享相同的权重矩阵,类似于 (引用)。在嵌入层中,我们将这些权重乘以√dmodel.

class Embeddings(nn.Module):
    def __init__(self, d_model, vocab):
        super(Embeddings, self).__init__()
        self.lut = nn.Embedding(vocab, d_model)
        self.d_model = d_model

    def forward(self, x):
        return self.lut(x) * math.sqrt(self.d_model)

位置编码

由于我们的模型不包含递归和卷积,为了让模型利用序列的顺序,我们必须注入一些关于标记在序列中的相对或绝对位置的信息。为此,我们将“位置编码”添加到编码器和解码器堆栈底部的输入嵌入中。位置编码具有相同的维度 dmodel作为嵌入,以便可以将两者相加。位置编码有很多选择,学习的和固定的 (引用)

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

是位置和我我是维度。也就是说,位置编码的每个维度对应一个正弦曲线。波长从10000⋅2π. 我们选择这个函数是因为我们假设它可以让模型很容易地学会通过相对位置参与,因为对于任何固定的偏移量k,PEpos+k可以表示为线性函数PEpos.

此外,我们将 dropout 应用于编码器和解码器堆栈中的嵌入和位置编码的总和。对于基础模型,我们使用一个比率Pdrop=0.1.

class PositionalEncoding(nn.Module):
    " 实现PE功能。"
    def __init__(self, d_model, dropout, max_len=5000):
        super(PositionalEncoding, self).__init__()
        self.dropout = nn.Dropout(p=dropout)
        
        # 在对数空间中计算一次位置编码。
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2) *
                             -(math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0)
        self.register_buffer('pe', pe)
        
    def forward(self, x):
        x = x + Variable(self.pe[:, :x.size(1)], 
                         requires_grad=False)
        return self.dropout(x)
下面的位置编码将添加一个基于位置的正弦波。波的频率和偏移对于每个维度都是不同的。
plt.figure(figsize=(15, 5))
pe = PositionalEncoding(20, 0)
y = pe.forward(Variable(torch.zeros(1, 100, 20)))
plt.plot(np.arange(100), y[0, :, 4:8].data.numpy())
plt.legend(["dim %d"%p for p in [4,5,6,7]])
None

我们还尝试使用学习到的位置嵌入 (引用)来代替,发现这两个版本产生了几乎相同的结果。我们选择正弦版本是因为它可以让模型推断出比训练期间遇到的序列长度更长的序列长度。

完整模型

在这里,我们定义了一个接受超参数并生成完整模型的函数。
def make_model(src_vocab, tgt_vocab, N=6, 
               d_model=512, d_ff=2048, h=8, dropout=0.1):
    "Helper:从超参数构建模型。"
    c = copy.deepcopy
    attn = MultiHeadedAttention(h, d_model)
    ff = PositionwiseFeedForward(d_model, d_ff, dropout)
    position = PositionalEncoding(d_model, dropout)
    model = EncoderDecoder(
        Encoder(EncoderLayer(d_model, c(attn), c(ff), dropout), N),
        Decoder(DecoderLayer(d_model, c(attn), c(attn), 
                             c(ff), dropout), N),
        nn.Sequential(Embeddings(d_model, src_vocab), c(position)),
        nn.Sequential(Embeddings(d_model, tgt_vocab), c(position)),
        Generator(d_model, tgt_vocab))
    
    # 这对他们的代码很重要。
    # 使用 Glorot / fan_avg 初始化参数。
    for p in model.parameters():
        if p.dim() > 1:
            nn.init.xavier_uniform(p)
    return model
#  小示例模型。
tmp_model=make_model(10,10,2)
None

训练

本节描述了我们模型的训练机制。

我们暂时停下来介绍一些训练标准编码器解码器模型所需的工具。首先,我们定义一个批处理对象,其中包含用于训练的 src 和目标句子,以及构建掩码。

批次和掩蔽

class Batch:
    "用于在训练期间使用掩码保存一批数据的对象。"
    def __init__(self, src, trg=None, pad=0):
        self.src = src
        self.src_mask = (src != pad).unsqueeze(-2)
        if trg is not None:
            self.trg = trg[:, :-1]
            self.trg_y = trg[:, 1:]
            self.trg_mask = \
                self.make_std_mask(self.trg, pad)
            self.ntokens = (self.trg_y != pad).data.sum()
    
    @staticmethod
    def make_std_mask(tgt, pad):
        "创建一个掩码来隐藏填充和未来的单词。"
        tgt_mask = (tgt != pad).unsqueeze(-2)
        tgt_mask = tgt_mask & Variable(
            subsequent_mask(tgt.size(-1)).type_as(tgt_mask.data))
        return tgt_mask
接下来我们创建一个通用的训练和评分函数来跟踪损失。我们传入了一个通用的损失计算函数,该函数也处理参数更新。

训练循环

def run_epoch(data_iter, model, loss_compute):
    " 标准训练和记录功能"
    start = time.time()
    total_tokens = 0
    total_loss = 0
    tokens = 0
    for i, batch in enumerate(data_iter):
        out = model.forward(batch.src, batch.trg, 
                            batch.src_mask, batch.trg_mask)
        loss = loss_compute(out, batch.trg_y, batch.ntokens)
        total_loss += loss
        total_tokens += batch.ntokens
        tokens += batch.ntokens
        if i % 50 == 1:
            elapsed = time.time() - start
            print("Epoch Step: %d Loss: %f Tokens per Sec: %f" %
                    (i, loss / batch.ntokens, tokens / elapsed))
            start = time.time()
            tokens = 0
    return total_loss / total_tokens

训练数据和批处理

我们在标准的 WMT 2014 英德数据集上进行了训练,该数据集包含大约 450 万个句子对。句子使用字节对编码进行编码,它具有约 37000 个标记的共享源-目标词汇表。对于英语-法语,我们使用了明显更大的 WMT 2014 英语-法语数据集,该数据集由 3600 万个句子组成,并将标记拆分为 32000 个单词词汇表。

句子对按近似序列长度分批在一起。每个训练批次包含一组句子对,其中包含大约 25000 个源标记和 25000 个目标标记。

我们将使用 torch 文本进行批处理。这将在下面更详细地讨论。在这里,我们在 torchtext 函数中创建批次,以确保填充到最大批次大小的批次大小不超过阈值(如果我们有 8 个 gpus,则为 25000)。
global max_src_in_batch, max_tgt_in_batch
def batch_size_fn(new, count, sofar):
    " 继续增加批次并计算令牌总数 + 填充。"
    global max_src_in_batch, max_tgt_in_batch
    if count == 1:
        max_src_in_batch = 0
        max_tgt_in_batch = 0
    max_src_in_batch = max(max_src_in_batch,  len(new.src))
    max_tgt_in_batch = max(max_tgt_in_batch,  len(new.trg) + 2)
    src_elements = count * max_src_in_batch
    tgt_elements = count * max_tgt_in_batch
    return max(src_elements, tgt_elements)

硬件和时间表

我们在一台配备 8 个 NVIDIA P100 GPU 的机器上训练我们的模型。对于我们使用整篇论文中描述的超参数的基础模型,每个训练步骤大约需要 0.4 秒。我们对基本模型进行了总共 100,000 步或 12 小时的训练。对于我们的大模型,步进时间为 1.0 秒。大模型训练了 300,000 步(3.5 天)。

优化器

我们使用 Adam 优化器(引用) β1=0.9, β2=0.98和ϵ=10^−9. 我们根据以下公式在训练过程中改变学习率:

这对应于第一个线性增加学习率warmupsteps训练步数,然后按步数的平方根反比按比例减少。我们用了 warmupsteps=4000.

注意:这部分非常重要。需要使用此模型设置进行训练。
class NoamOpt:
    "实现rate的 Optim 包装器。"
    def __init__(self, model_size, factor, warmup, optimizer):
        self.optimizer = optimizer
        self._step = 0
        self.warmup = warmup
        self.factor = factor
        self.model_size = model_size
        self._rate = 0
        
    def step(self):
        " 更新参数和rate"
        self._step += 1
        rate = self.rate()
        for p in self.optimizer.param_groups:
            p['lr'] = rate
        self._rate = rate
        self.optimizer.step()
        
    def rate(self, step = None):
        " 在上面实现`lrate`"
        if step is None:
            step = self._step
        return self.factor * \
            (self.model_size ** (-0.5) *
            min(step ** (-0.5), step * self.warmup ** (-1.5)))
        
def get_std_opt(model):
    return NoamOpt(model.src_embed[0].d_model, 2, 4000,
            torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9))
该模型针对不同模型大小和优化超参数的曲线示例。
# Three settings of the lrate hyperparameters.
opts = [NoamOpt(512, 1, 4000, None), 
        NoamOpt(512, 1, 8000, None),
        NoamOpt(256, 1, 4000, None)]
plt.plot(np.arange(1, 20000), [[opt.rate(i) for opt in opts] for i in range(1, 20000)])
plt.legend(["512:4000", "512:8000", "256:4000"])
None

正则化

标签平滑

在训练过程中,我们采用了价值标签平滑ϵls=0.1 (引用)。这会伤害困惑度,因为模型会变得更加不确定,但会提高准确性和 BLEU 分数。

我们使用 KL div 损失实现标签平滑。我们没有使用单一的目标分布,而是创建了一个分布,该分布具有 confidence 正确的单词,其余的 smoothing 质量分布在整个词汇表中。
class LabelSmoothing(nn.Module):
    " 实施标签平滑."
    def __init__(self, size, padding_idx, smoothing=0.0):
        super(LabelSmoothing, self).__init__()
        self.criterion = nn.KLDivLoss(size_average=False)
        self.padding_idx = padding_idx
        self.confidence = 1.0 - smoothing
        self.smoothing = smoothing
        self.size = size
        self.true_dist = None
        
    def forward(self, x, target):
        assert x.size(1) == self.size
        true_dist = x.data.clone()
        true_dist.fill_(self.smoothing / (self.size - 2))
        true_dist.scatter_(1, target.data.unsqueeze(1), self.confidence)
        true_dist[:, self.padding_idx] = 0
        mask = torch.nonzero(target.data == self.padding_idx)
        if mask.dim() > 0:
            true_dist.index_fill_(0, mask.squeeze(), 0.0)
        self.true_dist = true_dist
        return self.criterion(x, Variable(true_dist, requires_grad=False))
在这里,我们可以看到一个示例,说明如何根据置信度将质量分配给单词。
# 标签平滑的例子。
crit = LabelSmoothing(5, 0, 0.4)
predict = torch.FloatTensor([[0, 0.2, 0.7, 0.1, 0],
                             [0, 0.2, 0.7, 0.1, 0], 
                             [0, 0.2, 0.7, 0.1, 0]])
v = crit(Variable(predict.log()), 
         Variable(torch.LongTensor([2, 1, 0])))

# 显示系统期望的目标分布。
plt.imshow(crit.true_dist)
None
如果模型对给定的选择非常有信心,标签平滑实际上会开始惩罚模型。
crit = LabelSmoothing(5, 0, 0.1)
def loss(x):
    d = x + 3 * 1
    predict = torch.FloatTensor([[0, x / d, 1 / d, 1 / d, 1 / d],
                                 ])
    #print(predict)
    return crit(Variable(predict.log()),
                 Variable(torch.LongTensor([1]))).data[0]
plt.plot(np.arange(1, 100), [loss(x) for x in range(1, 100)])
None

第一个例子

我们可以从尝试一个简单的复制任务开始。给定来自小词汇表的一组随机输入符号,目标是生成回那些相同的符号。

综合数据

def data_gen(V, batch, nbatches):
    " 为 src-tgt 复制任务生成随机数据。"
    for i in range(nbatches):
        data = torch.from_numpy(np.random.randint(1, V, size=(batch, 10)))
        data[:, 0] = 1
        src = Variable(data, requires_grad=False)
        tgt = Variable(data, requires_grad=False)
        yield Batch(src, tgt, 0)

损失计算

class SimpleLossCompute:
    " 一个简单的损失计算和训练函数。"
    def __init__(self, generator, criterion, opt=None):
        self.generator = generator
        self.criterion = criterion
        self.opt = opt
        
    def __call__(self, x, y, norm):
        x = self.generator(x)
        loss = self.criterion(x.contiguous().view(-1, x.size(-1)), 
                              y.contiguous().view(-1)) / norm
        loss.backward()
        if self.opt is not None:
            self.opt.step()
            self.opt.optimizer.zero_grad()
        return loss.data[0] * norm

贪心解码

# 训练简单的复制任务。
V = 11
criterion = LabelSmoothing(size=V, padding_idx=0, smoothing=0.0)
model = make_model(V, V, N=2)
model_opt = NoamOpt(model.src_embed[0].d_model, 1, 400,
        torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9))

for epoch in range(10):
    model.train()
    run_epoch(data_gen(V, 30, 20), model, 
              SimpleLossCompute(model.generator, criterion, model_opt))
    model.eval()
    print(run_epoch(data_gen(V, 30, 5), model, 
                    SimpleLossCompute(model.generator, criterion, None)))
Epoch Step: 1 Loss: 3.023465 Tokens per Sec: 403.074173
Epoch Step: 1 Loss: 1.920030 Tokens per Sec: 641.689380
1.9274832487106324
Epoch Step: 1 Loss: 1.940011 Tokens per Sec: 432.003378
Epoch Step: 1 Loss: 1.699767 Tokens per Sec: 641.979665
1.657595729827881
Epoch Step: 1 Loss: 1.860276 Tokens per Sec: 433.320240
Epoch Step: 1 Loss: 1.546011 Tokens per Sec: 640.537198
1.4888023376464843
Epoch Step: 1 Loss: 1.682198 Tokens per Sec: 432.092305
Epoch Step: 1 Loss: 1.313169 Tokens per Sec: 639.441857
1.3485562801361084
Epoch Step: 1 Loss: 1.278768 Tokens per Sec: 433.568756
Epoch Step: 1 Loss: 1.062384 Tokens per Sec: 642.542067
0.9853351473808288
Epoch Step: 1 Loss: 1.269471 Tokens per Sec: 433.388727
Epoch Step: 1 Loss: 0.590709 Tokens per Sec: 642.862135
0.5686767101287842
Epoch Step: 1 Loss: 0.997076 Tokens per Sec: 433.009746
Epoch Step: 1 Loss: 0.343118 Tokens per Sec: 642.288427
0.34273059368133546
Epoch Step: 1 Loss: 0.459483 Tokens per Sec: 434.594030
Epoch Step: 1 Loss: 0.290385 Tokens per Sec: 642.519464
0.2612409472465515
Epoch Step: 1 Loss: 1.031042 Tokens per Sec: 434.557008
Epoch Step: 1 Loss: 0.437069 Tokens per Sec: 643.630322
0.4323212027549744
Epoch Step: 1 Loss: 0.617165 Tokens per Sec: 436.652626
Epoch Step: 1 Loss: 0.258793 Tokens per Sec: 644.372296
0.27331129014492034
为简单起见,此代码使用贪婪解码预测翻译。
def greedy_decode(model, src, src_mask, max_len, start_symbol):
    memory = model.encode(src, src_mask)
    ys = torch.ones(1, 1).fill_(start_symbol).type_as(src.data)
    for i in range(max_len-1):
        out = model.decode(memory, src_mask, 
                           Variable(ys), 
                           Variable(subsequent_mask(ys.size(1))
                                    .type_as(src.data)))
        prob = model.generator(out[:, -1])
        _, next_word = torch.max(prob, dim = 1)
        next_word = next_word.data[0]
        ys = torch.cat([ys, 
                        torch.ones(1, 1).type_as(src.data).fill_(next_word)], dim=1)
    return ys

model.eval()
src = Variable(torch.LongTensor([[1,2,3,4,5,6,7,8,9,10]]) )
src_mask = Variable(torch.ones(1, 1, 10) )
print(greedy_decode(model, src, src_mask, max_len=10, start_symbol=1))
    1     2     3     4     5     6     7     8     9    10
[torch.LongTensor of size 1x10]

一个真实世界的例子

现在我们考虑使用 IWSLT 德语-英语翻译任务的真实示例。该任务比论文中考虑的 WMT 任务小得多,但它说明了整个系统。我们还展示了如何使用多 GPU 处理使其真正快速。
#!pip install torchtext spacy
#!python -m spacy download en
#!python -m spacy download de

数据加载

我们将使用 torchtext 和 spacy 加载数据集以进行标记化。
# 用于数据加载。
from torchtext import data, datasets

if True:
    import spacy
    spacy_de = spacy.load('de')
    spacy_en = spacy.load('en')

    def tokenize_de(text):
        return [tok.text for tok in spacy_de.tokenizer(text)]

    def tokenize_en(text):
        return [tok.text for tok in spacy_en.tokenizer(text)]

    BOS_WORD = '<s>'
    EOS_WORD = '</s>'
    BLANK_WORD = "<blank>"
    SRC = data.Field(tokenize=tokenize_de, pad_token=BLANK_WORD)
    TGT = data.Field(tokenize=tokenize_en, init_token = BOS_WORD, 
                     eos_token = EOS_WORD, pad_token=BLANK_WORD)

    MAX_LEN = 100
    train, val, test = datasets.IWSLT.splits(
        exts=('.de', '.en'), fields=(SRC, TGT), 
        filter_pred=lambda x: len(vars(x)['src']) <= MAX_LEN and 
            len(vars(x)['trg']) <= MAX_LEN)
    MIN_FREQ = 2
    SRC.build_vocab(train.src, min_freq=MIN_FREQ)
    TGT.build_vocab(train.trg, min_freq=MIN_FREQ)
批处理对速度很重要。我们想要非常均匀地划分批次,并具有绝对最小的填充。为此,我们必须对默认的 torchtext 批处理进行一些修改。此代码修补了它们的默认批处理,以确保我们搜索足够多的句子以找到紧密的批处理。

迭代器

class MyIterator(data.Iterator):
    def create_batches(self):
        if self.train:
            def pool(d, random_shuffler):
                for p in data.batch(d, self.batch_size * 100):
                    p_batch = data.batch(
                        sorted(p, key=self.sort_key),
                        self.batch_size, self.batch_size_fn)
                    for b in random_shuffler(list(p_batch)):
                        yield b
            self.batches = pool(self.data(), self.random_shuffler)
            
        else:
            self.batches = []
            for b in data.batch(self.data(), self.batch_size,
                                          self.batch_size_fn):
                self.batches.append(sorted(b, key=self.sort_key))

def rebatch(pad_idx, batch):
    " 修复 torchtext 中的顺序以匹配我们的"
    src, trg = batch.src.transpose(0, 1), batch.trg.transpose(0, 1)
    return Batch(src, trg, pad_idx)

多 GPU 训练

最后,为了真正以快速训练为目标,我们将使用多 GPU。此代码实现多 GPU 单词生成。它不是特定于变压器的,所以我不会详细介绍。这个想法是将训练时的单词生成分成多个块,以便在许多不同的 GPU 上并行处理。我们使用 pytorch 并行原语来做到这一点:
  • replicate - 将模块拆分到不同的 GPU 上。

  • scatter - 将批次拆分到不同的 GPU 上

  • parallel_apply - 将模块应用于不同 GPU 上的批次

  • gather - 将分散的数据拉回到一个 GPU 上。

  • nn.DataParallel - 一个特殊的模块包装器,在评估之前调用所有这些。

# 如果对 multigpu 不感兴趣,请跳过。
class MultiGPULossCompute:
    "多 GPU 损失计算和训练函数。"
    def __init__(self, generator, criterion, devices, opt=None, chunk_size=5):
        # 发送到不同的GPU。
        self.generator = generator
        self.criterion = nn.parallel.replicate(criterion, 
                                               devices=devices)
        self.opt = opt
        self.devices = devices
        self.chunk_size = chunk_size
        
    def __call__(self, out, targets, normalize):
        total = 0.0
        generator = nn.parallel.replicate(self.generator, 
                                                devices=self.devices)
        out_scatter = nn.parallel.scatter(out, 
                                          target_gpus=self.devices)
        out_grad = [[] for _ in out_scatter]
        targets = nn.parallel.scatter(targets, 
                                      target_gpus=self.devices)

        # 将生成分成块。
        chunk_size = self.chunk_size
        for i in range(0, out_scatter[0].size(1), chunk_size):
            # 预测分布
            out_column = [[Variable(o[:, i:i+chunk_size].data, 
                                    requires_grad=self.opt is not None)] 
                           for o in out_scatter]
            gen = nn.parallel.parallel_apply(generator, out_column)

            # 计算损失。 
            y = [(g.contiguous().view(-1, g.size(-1)), 
                  t[:, i:i+chunk_size].contiguous().view(-1)) 
                 for g, t in zip(gen, targets)]
            loss = nn.parallel.parallel_apply(self.criterion, y)

            # 求和并归一化损失
            l = nn.parallel.gather(loss, 
                                   target_device=self.devices[0])
            l = l.sum()[0] / normalize
            total += l.data[0]

            #  transformer输出的反向传播损失
            if self.opt is not None:
                l.backward()
                for j, l in enumerate(loss):
                    out_grad[j].append(out_column[j][0].grad.data.clone())

        # 反向传播通过transformer的所有损失。            
        if self.opt is not None:
            out_grad = [Variable(torch.cat(og, dim=1)) for og in out_grad]
            o1 = out
            o2 = nn.parallel.gather(out_grad, 
                                    target_device=self.devices[0])
            o1.backward(gradient=o2)
            self.opt.step()
            self.opt.optimizer.zero_grad()
        return total * normalize
现在我们创建模型、标准、优化器、数据迭代器和并行化
# 要使用的 GPU
devices = [0, 1, 2, 3]
if True:
    pad_idx = TGT.vocab.stoi["<blank>"]
    model = make_model(len(SRC.vocab), len(TGT.vocab), N=6)
    model.cuda()
    criterion = LabelSmoothing(size=len(TGT.vocab), padding_idx=pad_idx, smoothing=0.1)
    criterion.cuda()
    BATCH_SIZE = 12000
    train_iter = MyIterator(train, batch_size=BATCH_SIZE, device=0,
                            repeat=False, sort_key=lambda x: (len(x.src), len(x.trg)),
                            batch_size_fn=batch_size_fn, train=True)
    valid_iter = MyIterator(val, batch_size=BATCH_SIZE, device=0,
                            repeat=False, sort_key=lambda x: (len(x.src), len(x.trg)),
                            batch_size_fn=batch_size_fn, train=False)
    model_par = nn.DataParallel(model, device_ids=devices)
None
现在我们训练模型。我会尝试一些预热步骤,但其他一切都使用默认参数。在具有 4 个 Tesla V100 的 AWS p3.8xlarge 上,它以每秒约 27,000 个令牌的速度运行,批量大小为 12,000

训练系统

#!wget https://s3.amazonaws.com/opennmt-models/iwslt.pt
if False:
    model_opt = NoamOpt(model.src_embed[0].d_model, 1, 2000,
            torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9))
    for epoch in range(10):
        model_par.train()
        run_epoch((rebatch(pad_idx, b) for b in train_iter), 
                  model_par, 
                  MultiGPULossCompute(model.generator, criterion, 
                                      devices=devices, opt=model_opt))
        model_par.eval()
        loss = run_epoch((rebatch(pad_idx, b) for b in valid_iter), 
                          model_par, 
                          MultiGPULossCompute(model.generator, criterion, 
                          devices=devices, opt=None))
        print(loss)
else:
    model = torch.load("iwslt.pt")
一旦训练完成,我们就可以解码模型以生成一组翻译。这里我们简单翻译验证集中的第一句话。这个数据集非常小,所以贪婪搜索的翻译相当准确。
for i, batch in enumerate(valid_iter):
    src = batch.src.transpose(0, 1)[:1]
    src_mask = (src != SRC.vocab.stoi["<blank>"]).unsqueeze(-2)
    out = greedy_decode(model, src, src_mask, 
                        max_len=60, start_symbol=TGT.vocab.stoi["<s>"])
    print("Translation:", end="\t")
    for i in range(1, out.size(1)):
        sym = TGT.vocab.itos[out[0, i]]
        if sym == "</s>": break
        print(sym, end =" ")
    print()
    print("Target:", end="\t")
    for i in range(1, batch.trg.size(0)):
        sym = TGT.vocab.itos[batch.trg.data[i, 0]]
        if sym == "</s>": break
        print(sym, end =" ")
    print()
    break
Translation:	<unk> <unk> . In my language , that means , thank you very much . 
Gold:	<unk> <unk> . It means in my language , thank you very much . 

附加组件:BPE、搜索、平均

所以这主要涵盖了变压器模型本身。我们没有明确涵盖四个方面。 我们还在OpenNMT-py 中实现了所有这些附加功能。
1)BPE/Word-piece:我们可以先用一个库把数据预处理成subword单元。请参见 Rico Sennrich 的 subword-nmt 实现。这些模型会将训练数据转换为如下所示:

Die Protokoll datei kann heimlich per E-Mail oder FTP an einen bestimmte n Empfänger gesendet werden。

2)共享嵌入:当使用具有共享词汇表的 BPE 时,我们可以在源/目标/生成器之间共享相同的权重向量。有关详细信息,请参阅 (引用) 。要将其添加到模型中,只需执行以下操作:
if False:
    model.src_embed[0].lut.weight = model.tgt_embeddings[0].lut.weight
    model.generator.lut.weight = model.tgt_embed[0].lut.weight
3) 束搜索:这有点太复杂了,无法在这里介绍。 有关 pytorch 实现,请参阅 OpenNMT-py 。
4)模型平均:论文平均最后 k 个检查点以创建集成效果。如果我们有一堆模型,我们可以在事后这样做:
def average(model, models):
    " 平均模型转化为模型 "
    for ps in zip(*[m.params() for m in [model] + models]):
        p[0].copy_(torch.sum(*ps[1:]) / len(ps[1:]))

结果

在 WMT 2014 英德翻译任务中,大 transformer 模型(表 2 中的 Transformer (big))比之前报告的最佳模型(包括集成)高出 2.0 BLEU 以上,建立了一个新的 state-of-the-艺术 BLEU 得分为 28.4。该模型的配置列在表 3 的最后一行。在 8 个 P100 GPU 上训练耗时 3.5 天。甚至我们的基础模型也超过了之前发布的所有模型和集成,其训练成本仅为任何竞争模型的一小部分。

在 WMT 2014 英法翻译任务中,我们的大模型获得了 41.0 的 BLEU 分数,优于之前发布的所有单一模型,训练成本不到之前最先进技术的 1/4模型。为英语到法语训练的 Transformer(大)模型使用辍学率 Pdrop = 0.1,而不是 0.3。

Image(filename="images/results.png")
我们在这里编写的代码是基本模型的一个版本。这里有这个系统的完全训练版本 (示例模型)
通过上一节中的附加扩展,OpenNMT-py 复制在 EN-DE WMT 上达到 26.9。在这里,我已将这些参数加载到我们的重新实现中。
!wgethttps://s3.amazonaws.com/opennmt-models/en-de-model.pt
model,SRC,TGT=torch.load("en-de-model.pt")
model.eval()
sent = "▁The ▁log ▁file ▁can ▁be ▁sent ▁secret ly ▁with ▁email ▁or ▁FTP ▁to ▁a ▁specified ▁receiver".split()
src = torch.LongTensor([[SRC.stoi[w] for w in sent]])
src = Variable(src)
src_mask = (src != SRC.stoi["<blank>"]).unsqueeze(-2)
out = greedy_decode(model, src, src_mask, 
                    max_len=60, start_symbol=TGT.stoi["<s>"])
print("Translation:", end="\t")
trans = "<s> "
for i in range(1, out.size(1)):
    sym = TGT.itos[out[0, i]]
    if sym == "</s>": break
    trans += sym + " "
print(trans)
Translation:    <s> ▁Die ▁Protokoll datei ▁kann ▁ heimlich ▁per ▁E - Mail ▁oder ▁FTP ▁an ▁einen ▁bestimmte n ▁Empfänger ▁gesendet ▁werden . 

注意力可视化

即使使用贪心解码器,翻译看起来也很不错。我们可以进一步可视化它,看看每一层注意力都发生了什么
tgt_sent = trans.split()
def draw(data, x, y, ax):
    seaborn.heatmap(data, 
                    xticklabels=x, square=True, yticklabels=y, vmin=0.0, vmax=1.0, 
                    cbar=False, ax=ax)
    
for layer in range(1, 6, 2):
    fig, axs = plt.subplots(1,4, figsize=(20, 10))
    print("Encoder Layer", layer+1)
    for h in range(4):
        draw(model.encoder.layers[layer].self_attn.attn[0, h].data, 
            sent, sent if h ==0 else [], ax=axs[h])
    plt.show()
    
for layer in range(1, 6, 2):
    fig, axs = plt.subplots(1,4, figsize=(20, 10))
    print("Decoder Self Layer", layer+1)
    for h in range(4):
        draw(model.decoder.layers[layer].self_attn.attn[0, h].data[:len(tgt_sent), :len(tgt_sent)], 
            tgt_sent, tgt_sent if h ==0 else [], ax=axs[h])
    plt.show()
    print("Decoder Src Layer", layer+1)
    fig, axs = plt.subplots(1,4, figsize=(20, 10))
    for h in range(4):
        draw(model.decoder.layers[layer].self_attn.attn[0, h].data[:len(tgt_sent), :len(sent)], 
            sent, tgt_sent if h ==0 else [], ax=axs[h])
    plt.show()
Encoder Layer 2
Encoder Layer 4
Encoder Layer 6
Decoder Self Layer 2
Decoder Src Layer 2
Decoder Self Layer 4
Decoder Src Layer 4
Decoder Self Layer 6
Decoder Src Layer 6
版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/sikh_0529/article/details/128968946

智能推荐

PTA 7-5 成绩排序_把成绩单按分数从高到低的顺序进行排序并输出,成绩之间有一个空格,最后的成绩后没-程序员宅基地

该文章是关于对班里学生某门课程成绩进行排序的问题。要求对班里的学生按照成绩从高到低排序输出。输入包括学生数目和每个学生的成绩,输出为按成绩从高到低的排序结果。

Elasticsearch 解决集群 Yellow 与 Red 的问题_es yellow删除索引-程序员宅基地

文章浏览阅读963次。集群健康度分片健康红:至少有一个主分片没有分配黄:至少有一个副本没有分配绿:主副本分片全部正常分配索引健康:最差的分片的状态集群健康:最差的索引的状态Health 相关的 APIGET _cluster/health集群的状态(检查 节点数量)GET _cluster/health?level=indices所有索引的健康状态 (查看有问题的索引GET _cluster/health/my_index单个索引的健康状态(查看具体的索引)GET _cl_es yellow删除索引

关于图片大小的理解_图片数据像素点占比多少-程序员宅基地

文章浏览阅读559次。A:透明度R:红色G:绿B:蓝Bitmap.Config ARGB_4444:每个像素占四位,即A=4,R=4,G=4,B=4,那么一个像素点占4+4+4+4=16位 Bitmap.Config ARGB_8888:每个像素占四位,即A=8,R=8,G=8,B=8,那么一个像素点占8+8+8+8=32位Bitmap.Config RGB_565:每个像素占四位,即R=5,G_图片数据像素点占比多少

Ueditor自定义上传文件通过SpringMVC上传图片到FTP_ueditor 上传图片 spring-程序员宅基地

文章浏览阅读512次。一、修改Ueditor的config.json的文档图片访问路径前缀改成FTP对外暴露的访问地址"imageUrlPrefix": "http://192.168.85.98:8280/up/"二、初始化Ueditor时绑定自定义文件上传方法<!-- 富文本编辑器 --><div id="content"> <script id="edit..._ueditor 上传图片 spring

STM32芯片的DFU编程及相关话题_syscfg_memoryremapconfig( syscfg_memoryremap_sram -程序员宅基地

文章浏览阅读2.2k次。相当部分的 STM32芯片都带USB模块,有时我们会考虑利用STM32芯片的USB模块进行程序代码的下载或升级。USB协议中有专门针对设备固件升级的类协议,即可以通过DFU类协议进行产品固件的加载或更新。 关于STM32产品的DFU程序下载和升级,ST官方有相关的资料文档。可以去www.stmcu.com.cn 或者去www.st.com 搜索DFUse下载相关资料。_syscfg_memoryremapconfig( syscfg_memoryremap_sram )作用是什么;

关于利用shell实现ftp_shell标本实现ftp-程序员宅基地

文章浏览阅读904次。过去,我是在写expect脚本来实现自动登陆并上传下载文件。不过略感不顺。参考文档:http://blog.chinaunix.net/uid-20526681-id-3549245.html现在有一个好的方法cd 到本地你要上传或下载的目录中ftp -niv &lt;&lt; EOFopen ip_addressuser username passwordasciiput filen..._shell标本实现ftp

随便推点

BERT跨模态之后:占领了视觉常识推理任务榜单TOP 2!-程序员宅基地

文章浏览阅读388次。星标/置顶小屋,带你解锁最萌最前沿的NLP、搜索与推荐技术文 | 小鹿鹿lulu编 | YY前言由于 BERT-like 模型在 NLP 领域上的成功,研究者们开始尝试将其应用到更为复杂..._bert进行知识推理

Java微笔记(7)-程序员宅基地

文章浏览阅读45次。String 类常用方法注意点:字符串 str 中字符的索引从0开始,范围为 0 到 str.length()-1使用 indexOf 进行字符或字符串查找时,如果匹配返回位置索引;如果没有匹配结果,返回 -1使用 substring(beginIndex , endIndex) 进行字符串截取时,包括 beginIndex 位置的字符,不包括 endIndex 位置的字符“==” ...

AMA回顾|ENVELOP 将在本周首次部署,十月将有大动作_envelop上了几个平台-程序员宅基地

文章浏览阅读334次。9月29日,ENVELOP项目在Crypto Horses社区举办了AMA活动,与5万多位社群成员分享了项目进展。项目CEOAlex Shedogubov与大家积极互动交流,一起探讨项目发展与治理。嘉宾及项目介绍Hi there! I am Alex Shedogubov and I am a CEO in ENVELOP. I manage the project and the product development. I have more than 8 years of mana..._envelop上了几个平台

Python中的f字符串的用法_python f-程序员宅基地

文章浏览阅读3.4w次,点赞26次,收藏131次。Python中的f字符串的用法:要在字符串中插入变量的值,可在前引号前加上字母f,再将要插入的变量放在花括号内。举例子如下:first_name="ada"last_name="lovelace"full_name=f"{first_name}{last_name}"print(f"Hello,{full_name.title()}!")打印结果为:Hello,Ada Lovelace!还可以使用f字符串来创建消息,再把整条消息赋给变量:举例子:first_name=_python f

如何在react-native实现自定义的垂直方向跑马灯_react-native-anchor-carousel 竖向-程序员宅基地

文章浏览阅读2.9k次。项目需求是需要实现一个垂直方向的跑马灯轮播,早期采用react-native-swiper解决方案,此方案在ios端正常使用,在android端不能使用,所有果断放弃。第二方案打算使用ant-mobile的Carousel组件,import { Carousel, WingBlank } from 'antd-mobile';import { Text } from 'react-nat..._react-native-anchor-carousel 竖向

无线电A类考试试题_a类无线电考试卷-程序员宅基地

文章浏览阅读2k次,点赞2次,收藏2次。[I]LK0001[Q]我国现行法律体系中专门针对无线电管理的最高法律文件及其立法机关是:[A]中华人民共和国无线电管理条例,国务院和中央军委[B]中华人民共和国无线电管理办法,工业和信息化部[C]中华人民共和国电信条例,国务院[D]中华人民共和国业余无线电台管理办法,工业和信息化部[P][I]LK0002[Q]我国现行法律体系中专门针对业余无线电台管理的最高法律文件及其立法机关是:[A]业余无线电台管理办法,工业和信息化部[B]个人业余无线电台管理暂行办法,国家体委和国家无委[C]业_a类无线电考试卷

推荐文章

热门文章

相关标签