元學(xué)習(xí) 是目前機(jī)器學(xué)習(xí)領(lǐng)域一個令人振奮的研究趨勢，它解決的是學(xué)習(xí)如何學(xué)習(xí)的問題。

傳統(tǒng)的機(jī)器學(xué)習(xí)研究模式是：獲取特定任務(wù)的大型數(shù)據(jù)集，然后用這個數(shù)據(jù)集從頭開始訓(xùn)練模型。很明顯，這和人類利用以往經(jīng)驗，僅僅通過少量樣本就迅速完成學(xué)習(xí)的情況相差甚遠(yuǎn)。

因為人類學(xué)習(xí)了「如何學(xué)習(xí)」。

在這篇文章中，我將從一個非常直觀的 元學(xué)習(xí) 簡介入手，從它最早的起源一直談到如今的 元學(xué)習(xí) 研究現(xiàn)狀。然后，我會從頭開始，在 PyTorch 中實現(xiàn)一個 元學(xué)習(xí) 模型，同時會分享一些從該項目中學(xué)到的經(jīng)驗教訓(xùn)。

首先，什么是學(xué)習(xí)？

我們先來簡單了解一下，當(dāng)我們訓(xùn)練一個用來實現(xiàn)貓狗圖像分類的簡單 神經(jīng)網(wǎng)絡(luò) 時，到底發(fā)生了什么。假設(shè)我們現(xiàn)在有一張貓的圖像，以及對應(yīng)的表示「這是一只貓」的標(biāo)簽。為簡潔起見，我做了一個簡單的動畫來展示訓(xùn)練的過程。

（圖注） 神經(jīng)網(wǎng)絡(luò) 訓(xùn)練過程的單步。該網(wǎng)絡(luò)用來實現(xiàn)貓狗圖像分類。

反向傳播是 神經(jīng)網(wǎng)絡(luò) 訓(xùn)練中很關(guān)鍵的一步。因為 神經(jīng)網(wǎng)絡(luò) 執(zhí)行的計算和損失函數(shù)都是可微函數(shù)，因此我們能夠求出網(wǎng)絡(luò)中每一個參數(shù)所對應(yīng)的梯度，進(jìn)而減少 神經(jīng)網(wǎng)絡(luò) 當(dāng)前給出的預(yù)測標(biāo)簽與真實/目標(biāo)標(biāo)簽之間的差異（這個差異是用損失函數(shù)度量的）。在反向傳播完成后，就可以使用優(yōu)化器來計算模型的更新參數(shù)了。而這正是使 神經(jīng)網(wǎng)絡(luò) 的訓(xùn)練更像是一門「藝術(shù)」而不是科學(xué)的原因：因為有太多的優(yōu)化器和優(yōu)化設(shè)置（超參數(shù)）可供選擇了。

我們把該「單個訓(xùn)練步」放在一張圖中展示，如下所示：

現(xiàn)在，訓(xùn)練圖像是一只:cat2:，表示圖像是一只貓的標(biāo)簽是 :small_red_triangle:。最大的這些 △ 表示我們的 神經(jīng)網(wǎng)絡(luò) ，里面的 ■ 表示參數(shù)和梯度，標(biāo)有 L 的四邊形表示損失函數(shù)，標(biāo)有 O 的四邊形表示優(yōu)化器。

完整的學(xué)習(xí)過程就是不斷地重復(fù)這個優(yōu)化步，直到 神經(jīng)網(wǎng)絡(luò) 中的參數(shù)收斂到一個不錯的結(jié)果上。

上圖表示 神經(jīng)網(wǎng)絡(luò) 的訓(xùn)練過程的三步， 神經(jīng)網(wǎng)絡(luò) （用最大的 △ 表示）用于實現(xiàn)貓狗圖像分類。

元學(xué)習(xí)

元學(xué)習(xí) 的思想是學(xué)習(xí)「學(xué)習(xí)（訓(xùn)練）」過程。

元學(xué)習(xí) 有好幾種實現(xiàn)方法，不過本文談到的兩種「學(xué)習(xí)『學(xué)習(xí)』過程」的方法和上文介紹的方式很類似。

在我們的訓(xùn)練過程中，具體而言，可以學(xué)習(xí)到兩點：

• 神經(jīng)網(wǎng)絡(luò) 的初始參數(shù)（圖中的藍(lán)色■）；

• 優(yōu)化器的參數(shù)（粉色的★）。

我會介紹將這兩點結(jié)合的情況，不過這里的每一點本身也非常有趣，而且可獲得到簡化、加速以及一些不錯的理論結(jié)果。

現(xiàn)在，我們有兩個部分需要訓(xùn)練：

• 用「模型（M）」這個詞來指代我們之前的 神經(jīng)網(wǎng)絡(luò) ，現(xiàn)在也可以將其理解為一個低級網(wǎng)絡(luò)。有時，人們也會用「優(yōu)化對象（optimizee）」或者「學(xué)習(xí)器（learner）」來稱呼它。該模型的權(quán)重在圖中用 ■ 表示。

• 用「優(yōu)化器（O）」或者「 元學(xué)習(xí) 器」來指代用于更新低級網(wǎng)絡(luò)（即上述模型）權(quán)重的高級模型。優(yōu)化器的權(quán)重在圖中用 ★ 表示。

如何學(xué)習(xí)這些元參數(shù)？

事實上，我們可以將訓(xùn)練過程中的元損失的梯度反向傳播到初始的模型權(quán)重和/或優(yōu)化器的參數(shù)。

現(xiàn)在，我們有了兩個嵌套的訓(xùn)練過程：優(yōu)化器/ 元學(xué)習(xí) 器上的元訓(xùn)練過程，其中（元）前向傳輸包含模型的多個訓(xùn)練步：我們之前見過的前饋、反向傳播以及優(yōu)化步驟。

現(xiàn)在我們來看看元訓(xùn)練的步驟：

元訓(xùn)練步（訓(xùn)練優(yōu)化器 O）包含 3 個模型（M）的訓(xùn)練步。

在這里，元訓(xùn)練過程中的單個步驟是橫向表示的。它包含模型訓(xùn)練過程中的兩個步驟（在元前饋和元反向傳播的方格中縱向表示），模型的訓(xùn)練過程和我們之前看到的訓(xùn)練過程完全一樣。

可以看到，元前向傳輸?shù)妮斎胧窃谀Ｐ陀?xùn)練過程中依次使用的一列樣本/標(biāo)簽（或一列批次）。

元訓(xùn)練步中的輸入是一列樣本（:cat2:、:dog2:）及其對應(yīng)的標(biāo)簽（:small_red_triangle:、:small_red_triangle_down:）。

我們應(yīng)該如何使用元損失來訓(xùn)練 元學(xué)習(xí) 器呢？在訓(xùn)練模型時，我們可以直接將模型的預(yù)測和目標(biāo)標(biāo)簽做比較，得到誤差值。

在訓(xùn)練 元學(xué)習(xí) 器時，我們可以用元損失來度量 元學(xué)習(xí) 器在目標(biāo)任務(wù)——訓(xùn)練模型——上的表現(xiàn)。

一個可行的方法是在一些訓(xùn)練數(shù)據(jù)上計算模型的損失：損失越低，模型就越好。最后，我們可以計算出元損失，或者直接將模型訓(xùn)練過程中已經(jīng)計算得到的損失結(jié)合在一起（例如，把它們直接加起來）。

我們還需要一個元優(yōu)化器來更新優(yōu)化器的權(quán)重，在這里，問題就變得很「meta」了：我們可以用另一個 元學(xué)習(xí) 器來優(yōu)化當(dāng)前的 元學(xué)習(xí) 器……不過最終，我們需要人為選擇一個優(yōu)化器，例如 SGD 或者 ADAM（不能像「turtles all the way down」一樣（注：turtles all the way down 這里大概是說，「不能一個模型套一個模型，這樣無限的套下去」）。

這里給出一些備注，它們對于我們現(xiàn)在要討論的實現(xiàn)而言非常重要：

• 二階導(dǎo)數(shù)：將元損失通過模型的梯度進(jìn)行反向傳播時，需要計算導(dǎo)數(shù)的導(dǎo)數(shù)，也就是二階導(dǎo)數(shù)（在最后一個動畫中的元反向傳播部分，這是用綠色的 ▲ 穿過綠色的 ■ 來表示的）。我們可以使用 TensorFlow 或 PyTorch 等現(xiàn)代框架來計算二階導(dǎo)數(shù)，不過在實踐中，我們通常不考慮二階導(dǎo)數(shù)，而只是通過模型權(quán)重進(jìn)行反向傳播（元反向傳播圖中的黃色 ■），以降低復(fù)雜度。

• 坐標(biāo)共享：如今，深度學(xué)習(xí)模型中的參數(shù)數(shù)量非常多（在 NLP 任務(wù)中，很容易就有將近 3000 萬 ～２億個參數(shù)）。當(dāng)前的 GPU 內(nèi)存無法將這么多參數(shù)作為單獨(dú)輸入傳輸給優(yōu)化器。我們經(jīng)常采用的方法是「坐標(biāo)共享」（coordinate sharing），這表示我們?yōu)橐粋�參數(shù)設(shè)計一個優(yōu)化器，然后將其復(fù)制到所有的參數(shù)上（具體而言，將它的權(quán)重沿著模型參數(shù)的輸入維度進(jìn)行共享）。在這個方法中， 元學(xué)習(xí) 器的參數(shù)數(shù)量和模型中的參數(shù)數(shù)量之間并沒有函數(shù)關(guān)系。如果 元學(xué)習(xí) 器是一個記憶網(wǎng)絡(luò)，如 RNN，我們依然可以令模型中的每個參數(shù)都具有單獨(dú)的隱藏狀態(tài)，以保留每個參數(shù)的單獨(dú)變化情況。

在 PyTorch 中實現(xiàn) 元學(xué)習(xí)

我們來嘗試寫些代碼，看看真實情況如何吧。

現(xiàn)在我們有了一個模型，它包含一個我們想要進(jìn)行訓(xùn)練的權(quán)重集合，我們將使用該集合解決這兩項任務(wù)：

• 在元前饋步驟中：我們使用這個模型計算（損失函數(shù)的）梯度，并作為優(yōu)化器的輸入來更新模型參數(shù)；

• 在元反向傳播步驟中：我們使用這個模型作為反向傳播優(yōu)化器參數(shù)梯度（從元損失中計算得到）的路徑。

在 PyTorch 中完成這個任務(wù)最簡單的方法是：使用兩個一樣的模塊來表示模型，每個任務(wù)一個。我們把存儲元前饋步驟中使用的模型梯度的模塊稱為前向模型（forward model），把元反向傳播步驟中將參數(shù)存儲為反向傳播優(yōu)化器梯度的連續(xù)路徑的模塊稱為后向模型（backward model）。

兩個模塊之間會使用共享的 Tensor，以防止重復(fù)占用內(nèi)存（Tensor 是內(nèi)存中真正有意義的部分）；但同時，也會保留各自的 Variable，以明確區(qū)分模型的梯度和 元學(xué)習(xí) 器的梯度。

PyTorch 中的一個簡單 元學(xué)習(xí) 器類

在 PyTorch 中共享張量非常直接：只需要更新 Variable 類中的指針，讓它們指向相同的 Tensor 就可以了。但如果模型已經(jīng)是內(nèi)存優(yōu)化模型，例如 AWD-LSTM 或 AWD-QRNN 這類共享 Tensors（輸入和輸出嵌入）的算法時，我們就會遇到問難。這時，我們在更新兩個模塊中的模型參數(shù)時，需要很小心，以確保我們保留的指針是正確的。

在這里給出一個實現(xiàn)方法：設(shè)置一個簡單的輔助程序來完成遍歷參數(shù)的任務(wù)，并返回更新 Parameter 指針（而不只是 Tensor）所需的全部信息，并保持共享參數(shù)同步。

以下是一個實現(xiàn)函數(shù)：

def get_params(module, memo=None, pointers=None):
    """ Returns an iterator over PyTorch module parameters that allows to update parameters
        (and not only the data).
    ! Side effect: update shared parameters to point to the first yield instance
        (i.e. you can update shared parameters and keep them shared)
    Yields:
        (Module, string, Parameter): Tuple containing the parameter's module, name and pointer
    """
    if memo is None:
        memo = set()
        pointers = {}
    for name, p in module._parameters.items():
        if p not in memo:
            memo.add(p)
            pointers[p] = (module, name)
            yield module, name, p
        elif p is not None:
            prev_module, prev_name = pointers[p]
            module._parameters[name] = prev_module._parameters[prev_name] # update shared parameter pointer
    for child_module in module.children():
        for m, n, p in get_params(child_module, memo, pointers):
            yield m, n, p

通過這個函數(shù)，我們可以嵌入任何模型，并且很整潔地遍歷 元學(xué)習(xí) 器的模型參數(shù)。

現(xiàn)在，我們來寫一個簡單的 元學(xué)習(xí) 器類。我們的優(yōu)化器是一個模塊：在前饋階段，它可以將前向模型（及其梯度）和后向模型作為輸入接受，并遍歷它們的參數(shù)來更新后向模型中的參數(shù)，同時允許元梯度反向傳播（通過更新 Parameter 指針，而不僅僅是 Tensor 指針）。

class MetaLearner(nn.Module):
    """ Bare Meta-learner class
        Should be added: intialization, hidden states, more control over everything
    """
    def __init__(self, model):
        super(MetaLearner, self).__init__()
        self.weights = Parameter(torch.Tensor(1, 2))

    def forward(self, forward_model, backward_model):
        """ Forward optimizer with a simple linear neural net
        Inputs:
            forward_model: PyTorch module with parameters gradient populated
            backward_model: PyTorch module identical to forward_model (but without gradients)
              updated at the Parameter level to keep track of the computation graph for meta-backward pass
        """
        f_model_iter = get_params(forward_model)
        b_model_iter = get_params(backward_model)
        for f_param_tuple, b_param_tuple in zip(f_model_iter, b_model_iter): # loop over parameters
            # Prepare the inputs, we detach the inputs to avoid computing 2nd derivatives (re-pack in new Variable)
            (module_f, name_f, param_f) = f_param_tuple
            (module_b, name_b, param_b) = b_param_tuple
            inputs = Variable(torch.stack([param_f.grad.data, param_f.data], dim=-1))
            # Optimization step: compute new model parameters, here we apply a simple linear function
            dW = F.linear(inputs, self.weights).squeeze()
            param_b = param_b + dW
            # Update backward_model (meta-gradients can flow) and forward_model (no need for meta-gradients).
            module_b._parameters[name_b] = param_b
            param_f.data = param_b.data

這樣一來，我們就可以像在第一部分中看到的那樣來訓(xùn)練優(yōu)化器了。以下是一個簡單的要點示例，展示了前文描述的元訓(xùn)練過程：

def train(forward_model, backward_model, optimizer, meta_optimizer, train_data, meta_epochs):  """ Train a meta-learner  Inputs:    forward_model, backward_model: Two identical PyTorch modules (can have shared Tensors)    optimizer: a neural net to be used as optimizer (an instance of the MetaLearner class)    meta_optimizer: an optimizer for the optimizer neural net, e.g. ADAM    train_data: an iterator over an epoch of training data    meta_epochs: meta-training steps  To be added: intialization, early stopping, checkpointing, more control over everything  """  for meta_epoch in range(meta_epochs): # Meta-training loop (train the optimizer)    optimizer.zero_grad()    losses = []    for inputs, labels in train_data:   # Meta-forward pass (train the model)      forward_model.zero_grad()         # Forward pass      inputs = Variable(inputs)      labels = Variable(labels)      output = forward_model(inputs)      loss = loss_func(output, labels)  # Compute loss      losses.append(loss)      loss.backward()                   # Backward pass to add gradients to the forward_model      optimizer(forward_model,          # Optimizer step (update the models)                backward_model)    meta_loss = sum(losses)             # Compute a simple meta-loss    meta_loss.backward()                # Meta-backward pass    meta_optimizer.step()               # Meta-optimizer step

避免內(nèi)存爆炸——隱藏狀態(tài)記憶

有時，我們想要學(xué)習(xí)一個可在非常龐大的（可能有幾千萬個參數(shù)的）模型上運(yùn)行的優(yōu)化器；同時，我們還希望可以在大量步驟上實現(xiàn)元訓(xùn)練，以得到優(yōu)質(zhì)梯度；就像我們在論文《Meta-Learning a Dynamical Language Model》中所實現(xiàn)的那樣。

在實踐中，這意味著，我們想要在元前饋中包含一個很長的訓(xùn)練過程，以及很多時間步；同時我們還需要將每一步的參數(shù)（黃色■）和梯度（綠色■）保存在內(nèi)存中，這些參數(shù)和梯度會在元反向傳播中使用到。

我們?nèi)绾卧诓蛔?GPU 內(nèi)存爆炸的情況下做到這一點呢？

一個辦法是，使用梯度檢查點（gradient checkpointing）來用內(nèi)存換取計算，這個方法也叫「隱藏狀態(tài)記憶」（Hidden State Memorization）。在我們的案例中，梯度檢查點表示，將我們連續(xù)計算的元前饋和元反向傳播切分成片段。

來自 Open AI 的 Yaroslav Bulatov 有一篇很好的介紹梯度檢查點的文章，如果你感興趣，可以了解一下：

Fitting larger networks into memory（https://medium.com/@yaroslavvb/fitting-larger-networks-into-memory-583e3c758ff9）

這篇文章非常長，所以我沒有給出一個完整的梯度檢查點代碼示例，建議大家使用已經(jīng)很完善的 TSHadley 的 PyTorch 實現(xiàn)，以及當(dāng)前還在開發(fā)的梯度檢查點的 PyTorch 本地實現(xiàn)。

元學(xué)習(xí) 中的其他方法

元學(xué)習(xí) 中還有另外兩個很有前景的研究方向，但本文沒有時間來討論了。在這里我給出一些提示，這樣，當(dāng)你知道了它們大致的原理后，就可以自己查閱相關(guān)資料了：

• 循環(huán) 神經(jīng)網(wǎng)絡(luò) ：我們之前給出了 神經(jīng)網(wǎng)絡(luò) 的標(biāo)準(zhǔn)訓(xùn)練過程。還有一個方法：將連續(xù)的任務(wù)作為一個輸入序列，然后建立一個循環(huán)模型，并用它提取、構(gòu)建一個可用于新任務(wù)的序列表征。在這種方法中，對于某個帶有記憶或注意力的循環(huán) 神經(jīng)網(wǎng)絡(luò) ，我們通常只使用一個訓(xùn)練過程。這個方法的效果也很不錯，尤其是當(dāng)你設(shè)計出適合任務(wù)的嵌入時。最近的這篇 SNAIL 論文是一個很好的例子：A Simple Neural Attentive Meta-Learner（https://openreview.net/forum?id=B1DmUzWAW）。

• 強(qiáng)化學(xué)習(xí)：優(yōu)化器在元前饋過程中完成的計算和循環(huán) 神經(jīng)網(wǎng)絡(luò) 的計算過程很類似：在輸入序列（學(xué)習(xí)過程中模型的權(quán)重序列和梯度序列）上重復(fù)使用相同的參數(shù)。在真實場景下，這表示我們會遇到循環(huán) 神經(jīng)網(wǎng)絡(luò) 經(jīng)常遇到的一個問題：一旦模型出錯，就很難返回安全路徑，因為我們并沒有訓(xùn)練模型從訓(xùn)練誤差中恢復(fù)的能力；同時，當(dāng)遇到一個比 元學(xué)習(xí) 過程中使用的序列更長的序列時，模型難以泛化。為了解決這些問題，我們可以求助于強(qiáng)化學(xué)習(xí)方法，讓模型學(xué)習(xí)一個和當(dāng)前訓(xùn)練狀態(tài)相關(guān)的動作策略。

自然語言處理中的 元學(xué)習(xí)

元學(xué)習(xí) 和用于自然語言處理（NLP）的 神經(jīng)網(wǎng)絡(luò) 模型（如循環(huán) 神經(jīng)網(wǎng)絡(luò) ）之間有一個非常有趣的相似之處。在上一段中，我們曾提到：

用于優(yōu)化 神經(jīng)網(wǎng)絡(luò) 模型的 元學(xué)習(xí) 器的行為和循環(huán) 神經(jīng)網(wǎng)絡(luò) 類似。

和 RNN 類似， 元學(xué)習(xí) 器會提取一系列模型訓(xùn)練過程中的參數(shù)和梯度作為輸入序列，并根據(jù)這個輸入序列計算得到一個輸出序列（更新后的模型參數(shù)序列）。

我們的論文《Meta-Learning a Dynamical Language Model》中詳細(xì)論述了該相似性，并研究了將 元學(xué)習(xí) 器用于 神經(jīng)網(wǎng)絡(luò) 語言模型中，以實現(xiàn)中期記憶：經(jīng)過學(xué)習(xí)， 元學(xué)習(xí) 器能夠在標(biāo)準(zhǔn) RNN（如 LSTM）的權(quán)重中，編碼中期記憶（除了短期記憶在 LSTM 隱藏狀態(tài)中的傳統(tǒng)編碼方式以外）。

我們的 元學(xué)習(xí) 語言模型由 3 層記憶層級組成，自下而上分別是：標(biāo)準(zhǔn) LSTM、用于更新 LSTM 權(quán)重以存儲中期記憶的 元學(xué)習(xí) 器，以及一個長期靜態(tài)記憶。

我們發(fā)現(xiàn)， 元學(xué)習(xí) 語言模型可以通過訓(xùn)練來編碼最近輸入的記憶，就像一篇維基百科文章的開始部分對預(yù)測文章的結(jié)尾部分非常有幫助一樣。

上圖中的曲線展示了在給定一篇維基百科文章開始部分的情況下（A, …, H 是連續(xù)的維基百科文章），模型預(yù)測文章詞匯的效果。單詞顏色表示的意思相同：藍(lán)色表示更好，紅色表示更差。當(dāng)模型在閱讀一篇文章時，它從文章的開始部分進(jìn)行學(xué)習(xí)，讀到結(jié)尾部分的時候，它的預(yù)測效果也變得更好了（更多細(xì)節(jié)，請閱讀我們的論文）。

以上是我對 元學(xué)習(xí) 的介紹，希望對大家有所幫助！

參考文獻(xiàn)

1. ^ (https://medium.com/huggingface/from-zero-to-research-an-introduction-to-meta-learning-8e16e677f78a#afeb) As such, meta-learning can be seen as a generalization of「transfer learning」and is related to the techniques for fine-tuning model on a task as well as techniques for hyper-parameters optimization. There was an interesting workshop on meta-learning (https://nips.cc/Conferences/2017/Schedule?showEvent=8767) at NIPS 2017 last December.

2. ^ (https://medium.com/huggingface/from-zero-to-research-an-introduction-to-meta-learning-8e16e677f78a#dc5a) Of course in a real training we would be using a mini-batch of examples.

3. ^ (https://medium.com/huggingface/from-zero-to-research-an-introduction-to-meta-learning-8e16e677f78a#e0bb) More precisely:「most of」these operations are differentiable.

4. ^ (https://medium.com/huggingface/from-zero-to-research-an-introduction-to-meta-learning-8e16e677f78a#d640) Good blog posts introducing the relevant literature are the BAIR posts: Learning to learn (http://bair.berkeley.edu/blog/2017/07/18/learning-to-learn/) by Chelsea Finn and Learning to Optimize with Reinforcement Learning (http://bair.berkeley.edu/blog/2017/09/12/learning-to-optimize-with-rl/) by Ke Li.

5. ^ (https://medium.com/huggingface/from-zero-to-research-an-introduction-to-meta-learning-8e16e677f78a#930c) Good examples of learning the model initial parameters are Model-Agnostic Meta-Learning (https://arxiv.org/abs/1703.03400) of UC Berkeley and its recent developments (https://openreview.net/forum?id=BJ_UL-k0b) as well as the Reptile algorithm (https://blog.openai.com/reptile/) of OpenAI. A good example of learning the optimizer』s parameters is the Learning to learn by gradient descent by gradient descent (https://arxiv.org/abs/1606.04474) paper of DeepMind. A paper combining the two is the work Optimization as a Model for Few-Shot Learning (https://openreview.net/forum?id=rJY0-Kcll) by Sachin Ravi and Hugo Larochelle. An nice and very recent overview can be found in Learning Unsupervised Learning Rules (https://arxiv.org/abs/1804.00222).

6. ^ (https://medium.com/huggingface/from-zero-to-research-an-introduction-to-meta-learning-8e16e677f78a#d094) Similarly to the way we back propagate through time in an unrolled recurrent network.

7. ^ (https://medium.com/huggingface/from-zero-to-research-an-introduction-to-meta-learning-8e16e677f78a#725d) Initially described in DeepMind』s Learning to learn by gradient descent by gradient descent (https://arxiv.org/abs/1606.04474) paper.

8. ^ (https://medium.com/huggingface/from-zero-to-research-an-introduction-to-meta-learning-8e16e677f78a#4e23) We are using coordinate-sharing in our meta-learner as mentioned earlier. In practice, it means we simply iterate over the model parameters and apply our optimizer broadcasted on each parameters (no need to flatten and gather parameters like in L-BFGS for instance).

9. ^ (https://medium.com/huggingface/from-zero-to-research-an-introduction-to-meta-learning-8e16e677f78a#d029) There is a surprising under-statement of how important back-propagating over very long sequence can be to get good results. The recent paper An Analysis of Neural Language Modeling at Multiple Scales (https://arxiv.org/abs/1803.08240) from Salesforce research is a good pointer in that direction.

10. ^ (https://medium.com/huggingface/from-zero-to-research-an-introduction-to-meta-learning-8e16e677f78a#6c6f) Gradient checkpointing is described for example in Memory-Efficient Backpropagation Through Time (https://arxiv.org/abs/1606.03401) and the nice blog post (https://medium.com/@yaroslavvb/fitting-larger-networks-into-memory-583e3c758ff9) of Yaroslav Bulatov.

原文鏈接： https://medium.com/huggingface/from-zero-to-research-an-introduction-to-meta-learning-8e16e677f78a

 

來自：https://www.jiqizhixin.com/articles/meta-learning-intro

 

標(biāo)簽： 安全 代碼 網(wǎng)絡(luò)

版權(quán)申明：本站文章部分自網(wǎng)絡(luò)，如有侵權(quán)，請聯(lián)系：west999com@outlook.com
特別注意：本站所有轉(zhuǎn)載文章言論不代表本站觀點！
本站所提供的圖片等素材，版權(quán)歸原作者所有，如需使用，請與原作者聯(lián)系。