當(dāng)前位置：首頁 > 人文社科 > 生活经验 >内容正文

生活经验

“Attention is All You Need 翻译

發(fā)布時間：2023/11/28 生活经验 28 豆豆

生活随笔收集整理的這篇文章主要介紹了 “Attention is All You Need 翻译小編覺得挺不錯的,現(xiàn)在分享給大家,幫大家做個參考.

            <p><img src="output_0_0.png" alt="png"></p>

“Attention is All You Need”[1]一文中提出的Transformer網(wǎng)絡(luò)結(jié)構(gòu)最近引起了很多人的關(guān)注。Transformer不僅能夠明顯地提升翻譯質(zhì)量，還為許多NLP任務(wù)提供了新的結(jié)構(gòu)。雖然原文寫的很清楚，但實際上大家普遍反映很難正確地實現(xiàn)。

所以我們?yōu)榇宋恼聦懥似⒔馕臋n，并給出了一行行實現(xiàn)的Transformer的代碼。本文檔刪除了原文的一些章節(jié)并進行了重新排序，并在整個文章中加入了相應(yīng)的注解。此外，本文檔以Jupyter notebook的形式完成，本身就是直接可以運行的代碼實現(xiàn)，總共有400行庫代碼，在4個GPU上每秒可以處理27,000個tokens。

想要運行此工作，首先需要安裝PyTorch[2]。這篇文檔完整的notebook文件及依賴可在github[3]或 Google Colab[4]上找到。

需要注意的是，此注解文檔和代碼僅作為研究人員和開發(fā)者的入門版教程。這里提供的代碼主要依賴OpenNMT[5]實現(xiàn)，想了解更多關(guān)于此模型的其他實現(xiàn)版本可以查看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

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

內(nèi)容目錄

本文注解部分都是以引用的形式給出的，主要內(nèi)容都是來自原文。

背景

減少序列處理問題的計算量是一個很重要的問題，也是Extended Neural GPU，ByteNet和ConvS2S等網(wǎng)絡(luò)的動機。上面提到的這些網(wǎng)絡(luò)都以CNN為基礎(chǔ)，并行計算所有輸入和輸出位置的隱藏表示。在這些模型中，關(guān)聯(lián)來自兩個任意輸入或輸出位置的信號所需的操作數(shù)隨位置間的距離增長而增長，比如ConvS2S呈線性增長，ByteNet呈線以對數(shù)形式增長，這會使學(xué)習(xí)較遠距離的兩個位置之間的依賴關(guān)系變得更加困難。而在Transformer中，操作次數(shù)則被減少到了常數(shù)級別。

self-attention有時候也被稱為intra-attention，是在單個句子不同位置上做的attention，并得到序列的一個表示。它能夠很好地應(yīng)用到很多任務(wù)中，包括閱讀理解、摘要、文本蘊涵，以及獨立于任務(wù)的句子表示。端到端的網(wǎng)絡(luò)一般都是基于循環(huán)注意力機制而不是序列對齊循環(huán)，并且已經(jīng)有證據(jù)表明在簡單語言問答和語言建模任務(wù)上表現(xiàn)很好。

據(jù)我們所知，Transformer是第一個完全依靠self-attention而不使用序列對齊的RNN或卷積的方式來計算輸入輸出表示的轉(zhuǎn)換模型。

模型結(jié)構(gòu)

目前大部分比較熱門的神經(jīng)序列轉(zhuǎn)換模型都有encoder-decoder結(jié)構(gòu)[9]。Encoder將輸入序列$(x_1, …, x_n)$ 映射到一個連續(xù)表示序列 $\mathbf{z} = (z_1, …, z_n)$。對于編碼得到的$\mathbf{z}$，decoder每次解碼生成一個符號，直到生成完整的輸出序列：$(y_1,…,y_m)$。對于每一步解碼，模型都是自回歸的[10]，即在生成下一個符號時將先前生成的符號作為附加輸入。

class EncoderDecoder(nn.Module):
    """
    A standard Encoder-Decoder architecture. Base for this and many 
    other models.
    """
    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):
        "Take in and process masked src and target sequences."
        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):
    "Define standard linear + softmax generation step."
    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的整體結(jié)構(gòu)如下圖所示，在encoder和decoder中都使用了self-attention, point-wise和全連接層。Encoder和decoder的大致結(jié)構(gòu)分別如下圖的左半部分和右半部分所示。

Encoder和Decoder

Encoder

Encoder由N=6個相同的層組成。

1
2
3

def clones(module, N):
    "Produce N identical layers."
    return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])

class Encoder(nn.Module):
    "Core encoder is a stack of N layers"
    def __init__(self, layer, N):
        super(Encoder, self).__init__()
        self.layers = clones(layer, N)
        self.norm = LayerNorm(layer.size)
        
    def forward(self, x, mask):
        "Pass the input (and mask) through each layer in turn."
        for layer in self.layers:
            x = layer(x, mask)
        return self.norm(x)

我們在每兩個子層之間都使用了直連層(residual connection) [11]和歸一化層 [12]。

class LayerNorm(nn.Module):
    "Construct a layernorm module (See citation for details)."
    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

也就是說，每個子層的輸出為 $\mathrm{LayerNorm}(x + \mathrm{Sublayer}(x))$，其中 $\mathrm{Sublayer}(x)$ 是由子層自動實現(xiàn)的函數(shù)。我們在每個子層的輸出上使用dropout，然后將其添加到下一子層的輸入并進行規(guī)范化。
為了能方便地使用這些直連邊，模型中所有的子層和embedding層的輸出都設(shè)定成了相同的維度，即$d_{\text{model}}=512$。

class SublayerConnection(nn.Module):
    """
    A residual connection followed by a layer norm.
    Note for code simplicity the norm is first as opposed to last.
    """
    def __init__(self, size, dropout):
        super(SublayerConnection, self).__init__()
        self.norm = LayerNorm(size)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x, sublayer):
        "Apply residual connection to any sublayer with the same size."
        return x + self.dropout(sublayer(self.norm(x)))

每層都有兩個子層組成。第一個子層實現(xiàn)了“多頭”的 self-attention，第二個子層則是一個簡單的position-wise的全連接前饋網(wǎng)絡(luò)。

class EncoderLayer(nn.Module):
    "Encoder is made up of self-attn and feed forward (defined below)"
    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):
        "Follow Figure 1 (left) for connections."
        x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, mask))
        return self.sublayer[1](x, self.feed_forward)

Decoder

Decoder也是由N=6個相同層組成。

class Decoder(nn.Module):
    "Generic N layer decoder with masking."
    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)

除了每個編碼器層中的兩個子層之外，解碼器還插入了第三種子層對編碼器棧的輸出實行“多頭”的attention。與編碼器類似，我們在每個子層兩端使用residual connection進行短路，然后進行層的規(guī)范化處理。

class DecoderLayer(nn.Module):
    "Decoder is made of self-attn, src-attn, and feed forward (defined below)"
    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):
        "Follow Figure 1 (right) for connections."
        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)

我們還修改解碼器中的self-attention子層以防止當(dāng)前位置attend到后續(xù)位置。這種masked的attention是考慮到輸出embedding會偏移一個位置，確保了生成位置$i$的預(yù)測時，僅依賴小于$i$的位置處的已知輸出，相當(dāng)于把后面不該看到的信息屏蔽掉。

def subsequent_mask(size):
    "Mask out subsequent 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

下面的attention mask圖顯示了允許每個目標詞（行）查看的位置（列）。在訓(xùn)練期間，當(dāng)前解碼位置的詞不能attend到后續(xù)位置的詞。

1
2
3

plt.figure(figsize=(5,5))
plt.imshow(subsequent_mask(20)[0])
None

Attention

Attention函數(shù)可以將query和一組key-value對映射到輸出，其中query、key、value和輸出都是向量。輸出是值的加權(quán)和，其中分配給每個value的權(quán)重由query與相應(yīng)key的兼容函數(shù)計算。

我們稱這種特殊的attention機制為"Scaled Dot-Product Attention"。輸入包含維度為$d_k$的query和key，以及維度為$d_v$的value。我們首先分別計算query與各個key的點積，然后將每個點積除以$\sqrt{d_k}$，最后使用softmax函數(shù)來獲得key的權(quán)重。

在具體實現(xiàn)時，我們可以以矩陣的形式進行并行運算，這樣能加速運算過程。具體來說，將所有的query、key和value向量分別組合成矩陣$Q$、$K$和$V$，這樣輸出矩陣可以表示為：

$$
\mathrm{Attention}(Q, K, V) = \mathrm{softmax}(\frac{QK^T}{\sqrt{d_k}})V
$$

def attention(query, key, value, mask=None, dropout=None):
    "Compute 'Scaled Dot Product Attention'"
    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

兩種最常用的attention函數(shù)是加和attention [13]和點積（乘積）attention，我們的算法與點積attention很類似，但是 $\frac{1}{\sqrt{d_k}}$ 的比例因子不同。加和attention使用具有單個隱藏層的前饋網(wǎng)絡(luò)來計算兼容函數(shù)。雖然兩種方法理論上的復(fù)雜度是相似的，但在實踐中，點積attention的運算會更快一些，也更節(jié)省空間，因為它可以使用高效的矩陣乘法算法來實現(xiàn)。

雖然對于較小的$d_k$，這兩種機制的表現(xiàn)相似，但在不放縮較大的$d_k$時，加和attention要優(yōu)于點積attention [14]。我們懷疑，對于較大的$d_k$，點積大幅增大，將softmax函數(shù)推向具有極小梯度的區(qū)域（為了闡明點積變大的原因，假設(shè)$q$和$k$是獨立的隨機變量，平均值為$0$，方差$1$，這樣他們的點積為 $q \cdot k = \sum_{i=1}^{d_k} q_ik_i$，同樣是均值為$0$方差為$d_k$）。為了抵消這種影響，我們用$\frac{1}{\sqrt{d_k}}$來縮放點積。

“多頭”機制能讓模型考慮到不同位置的attention，另外“多頭”attention可以在不同的子空間表示不一樣的關(guān)聯(lián)關(guān)系，使用單個head的attention一般達不到這種效果。

$$
\mathrm{MultiHead}(Q, K, V) = \mathrm{Concat}(\mathrm{head_1}, …, \mathrm{head_h})W^O \
\text{這里的}~\mathrm{head_i} = \mathrm{Attention}(QW^Q_i, KW^K_i, VW^V_i)
$$

其中參數(shù)矩陣為$W^Q_i \in \mathbb{R}^{d_{\text{model}} \times d_k}$, $W^K_i \in \mathbb{R}^{d_{\text{model}} \times d_k}$, $W^V_i \in \mathbb{R}^{d_{\text{model}} \times d_v}$ and $W^O \in \mathbb{R}^{hd_v \times d_{\text{model}}}$。

我們的工作中使用$h=8$個head并行的attention，對每一個head來說有$d_k=d_v=d_{\text{model}}/h=64$，總計算量與完整維度的單個head的attention很相近。

class MultiHeadedAttention(nn.Module):
    def __init__(self, h, d_model, dropout=0.1):
        "Take in model size and number of heads."
        super(MultiHeadedAttention, self).__init__()
        assert d_model % h == 0
        # We assume d_v always equals 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):
        "Implements Figure 2"
        if mask is not None:
            # Same mask applied to all h heads.
            mask = mask.unsqueeze(1)
        nbatches = query.size(0)
        
        # 1) Do all the linear projections in batch from 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) Apply attention on all the projected vectors in batch. 
        x, self.attn = attention(query, key, value, mask=mask, 
                                 dropout=self.dropout)
        
        # 3) "Concat" using a view and apply a final linear. 
        x = x.transpose(1, 2).contiguous() \
             .view(nbatches, -1, self.h * self.d_k)
        return self.linears[-1](x)

Attention在模型中的應(yīng)用

Transformer中以三種不同的方式使用了“多頭”attention：

在"encoder-decoder attention"層，query來自先前的解碼器層，并且key和value來自encoder的輸出。Decoder中的每個位置attend輸入序列中的所有位置，這與Seq2Seq模型中的經(jīng)典的encoder-decoder attention機制[15]一致。
Encoder中的self-attention層。在self-attention層中，所有的key、value和query都來同一個地方，這里都是來自encoder中前一層的輸出。Encoder中當(dāng)前層的每個位置都能attend到前一層的所有位置。
類似的，解碼器中的self-attention層允許解碼器中的每個位置attend當(dāng)前解碼位置和它前面的所有位置。這里需要屏蔽解碼器中向左的信息流以保持自回歸屬性.具體的實現(xiàn)方式是在縮放后的點積attention中，屏蔽（設(shè)為$-\infty$）softmax的輸入中所有對應(yīng)著非法連接的value。

Position-wise前饋網(wǎng)絡(luò)

除了attention子層之外，encoder和decoder中的每個層都包含一個全連接前饋網(wǎng)絡(luò)，分別地應(yīng)用于每個位置。其中包括兩個線性變換，然后使用ReLU作為激活函數(shù)。

$$
\mathrm{FFN}(x)=\max(0, xW_1 + b_1) W_2 + b_2
$$

雖然線性變換在不同位置上是相同的，但它們在層與層之間使用不同的參數(shù)。這其實是相當(dāng)于使用了兩個內(nèi)核大小為1的卷積。這里設(shè)置輸入和輸出的維數(shù)為$d_{\text{model}}=512$，內(nèi)層的維度為$d_{ff}=2048$。

class PositionwiseFeedForward(nn.Module):
    "Implements FFN equation."
    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))))

Embedding和Softmax

與其他序列轉(zhuǎn)換模型類似，我們使用預(yù)學(xué)習(xí)的embedding將輸入token序列和輸出token序列轉(zhuǎn)化為$d_{\text{model}}$維向量。我們還使用常用的預(yù)訓(xùn)練的線性變換和softmax函數(shù)將解碼器輸出轉(zhuǎn)換為預(yù)測下一個token的概率。在我們的模型中，我們在兩個embedding層和pre-softmax線性變換之間共享相同的權(quán)重矩陣，類似于[16]。在embedding層中，我們將這些權(quán)重乘以$\sqrt{d_{\text{model}}}$。

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)

位置編碼

由于我們的模型不包含遞歸和卷積結(jié)構(gòu)，為了使模型能夠有效利用序列的順序特征，我們需要加入序列中各個token間相對位置或token在序列中絕對位置的信息。在這里，我們將位置編碼添加到編碼器和解碼器棧底部的輸入embedding。由于位置編碼與embedding具有相同的維度$d_{\text{model}}$，因此兩者可以直接相加。其實這里還有許多位置編碼可供選擇，其中包括可更新的和固定不變的[17]。

在此項工作中，我們使用不同頻率的正弦和余弦函數(shù)：

$$
PE_{(pos,2i)} = sin(pos / 10000^{2i/d_{\text{model}}})
$$

$$
PE_{(pos,2i+1)} = cos(pos / 10000^{2i/d_{\text{model}}})
$$

其中$pos$是位置，$i$是維度。也就是說，位置編碼的每個維度都對應(yīng)于一個正弦曲線，其波長形成從$2\pi$到$10000 \cdot 2\pi$的等比級數(shù)。我們之所以選擇了這個函數(shù)，是因為我們假設(shè)它能讓模型很容易學(xué)會attend相對位置，因為對于任何固定的偏移量$k$, $PE_{pos+k}$可以表示為$PE_{pos}$的線性函數(shù)。

此外，在編碼器和解碼器堆棧中，我們在embedding與位置編碼的加和上都使用了dropout機制。在基本模型上，我們使用$P_{drop}=0.1$的比率。

class PositionalEncoding(nn.Module):
    "Implement the PE function."
    def __init__(self, d_model, dropout, max_len=5000):
        super(PositionalEncoding, self).__init__()
        self.dropout = nn.Dropout(p=dropout)
        
        # Compute the positional encodings once in log space.
        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)

如下所示，位置編碼將根據(jù)位置添加正弦曲線。曲線的頻率和偏移對于每個維度是不同的。

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

我們也嘗試了使用預(yù)學(xué)習(xí)的位置embedding，但是發(fā)現(xiàn)這兩個版本的結(jié)果基本是一樣的。我們選擇了使用正弦曲線版本的實現(xiàn)，因為使用此版本能讓模型能夠處理大于訓(xùn)練語料中最大序列長度的序列。

完整模型

下面定義了連接完整模型并設(shè)置超參的函數(shù)。

def make_model(src_vocab, tgt_vocab, N=6, 
               d_model=512, d_ff=2048, h=8, dropout=0.1):
    "Helper: Construct a model from hyperparameters."
    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))
    
    # This was important from their code. 
    # Initialize parameters with Glorot / fan_avg.
    for p in model.parameters():
        if p.dim() > 1:
            nn.init.xavier_uniform(p)
    return model

1
2
3

# Small example model.
tmp_model = make_model(10, 10, 2)
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

            <hr><!-- Pager --><ul class="pager"><li class="previous"><a href="/2019/03/19/共指消解論文-ACL2018/" data-toggle="tooltip" data-placement="top" title="ACL2018論文閱讀 (一)">← Previous Post</a></li><li class="next"><a href="/2018/10/09/升級Mojave后iterm2打開變慢/" data-toggle="tooltip" data-placement="top" title="【Mac】升級Mojave后iterm2打開變慢">Next Post →</a></li></ul><!-- duoshuo Share start --><!-- 多說 Share end--><!-- 多說評論框 start --><!-- 多說評論框 end --><!-- disqus comment start --><!-- disqus comment end --></div>

總結(jié)

以上是生活随笔為你收集整理的“Attention is All You Need 翻译的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。

attention

上一篇：用python下载文件的若干种方法汇总
下一篇：基本运算的意义奇思