怎麼開發一個LSTM模型來生成形狀？（附程式碼）

AMiner學術頭條發表於2019-03-04
模型

LSTM是一種時間遞迴神經網路，適合於處理和預測時間序列中間隔和延遲相對較長的重要事件。在自然語言處理、語言識別等一系列的應用上都取得了很好的效果。

《Long Short Term Memory Networks with Python》是澳大利亞機器學習專家Jason Brownlee的著作，裡面詳細介紹了LSTM模型的原理和使用。

該書總共分為十四個章節，具體如下：

第一章：什麼是LSTMs？

第二章：怎麼樣訓練LSTMs？

第三章：怎麼樣準備LSTMs的資料？

第四章：怎麼樣在Keras中開發LSTMs？

第五章：序列預測建模

第六章：如何開發一個Vanilla LSTM模型？

第七章：怎麼樣開發Stacked LSTMs？

第八章：開發CNN LSTM模型（本期內容）

第九章：開發Encoder-Decoder LSTMs

第十章：開發Bidirectional LSTMs

第十一章：開發生成LSTMs（本期內容）

第十二章：診斷和除錯LSTMs（下週一發布）

第十三章：怎麼樣用LSTMs做預測？

第十四章：更新LSTMs模型

本文的作者對此書進行了翻譯整理之後，分享給大家，本文是第十期內容。

第一期內容為：一萬字純乾貨|機器學習博士手把手教你入門LSTM（附程式碼資料）

第二期內容為：乾貨推薦|如何基於時間的反向傳播演算法來訓練LSTMs？

第三期內容為：乾貨推薦|如何準備用於LSTM模型的資料並進行序列預測？（附程式碼）

第四期內容為：機器學習博士帶你入門|一文學會如何在Keras中開發LSTMs（附程式碼）

第五期內容為：初學者如何避免在序列預測問題中遇到的陷阱？

第六期內容為：如何開發和評估Vanilla LSTM模型？

第七期內容為：博士帶你學LSTM|怎麼樣開發Stacked LSTMs？（附程式碼）

第八期內容為：博士帶你學LSTM|手把手教你開發CNN LSTM模型，並應用在Keras中（附程式碼）

第九期內容為：博士帶你學LSTM|開發Encoder-Decoder LSTM模型的簡單教程（附程式碼）

第十期內容為：博士帶你學LSTM|開發Bidirectional LSTM模型的簡單教程（附程式碼）

我們還將繼續推出一系列的文章來介紹裡面的詳細內容，和大家一起來共同學習。

11.0 前言

11.0.1 課程目標

本課程的目標是學習怎麼樣開發LSTMs。完成本課程之後，你將會學習到：

  • LSTMs怎麼樣可以被用於生成模型；

  • 怎麼樣把形狀繪製作為序列生成問題；

  • 怎麼開發一個LSTM模型來生成形狀。

11.0.2 課程概覽

本課程被分為7個部分。它們是：

  1. Generative LSTM；

  2. 形狀生成問題；

  3. 定義和編譯模型；

  4. 擬合模型；

  5. 用模型做預測；

  6. 評估模型；

  7. 完成例子。

讓我們開始吧！

11.1 Generative LSTM

11.1.1 生成模型

LSTM可以用作生成模型。給定序列資料的大語料庫，例如文字文件，可以設計LSTM模型來學習語料庫的一般結構屬性，並且當給定種子輸入時，可以生成代表原始語料庫的新序列。

在自然語言處理領域中，開發一種概括語料庫模型的問題稱為語言建模。語言模型可以在詞語級工作，並學習文件中單詞之間的概率關係，以便準確地完成句子並生成完全新的句子。在其最具有挑戰性的語言模型中，在字元級工作，從字元序列中學習，並一次生成一個字元的新序列。

字元級語言模型的目標是來預測序列中的下一個字元。

— Generating Text with Recurrent Neural Networks, 2011.

儘管有更多的挑戰，一個字元級模型新增的靈活性允許新的字元被生成，增加標點符號，並且生成文字資料中可能存在的任何其他結構。

在一個時刻預測一個字元是從序列生成的角度來說是更有趣的，因為它允許網路發明新的單詞和字串。

— Generating Sequences With Recurrent Neural Networks, 2013.

語言建模是目前為止研究最多的Generative LSTM應用，可能是因為使用標準資料集可以對模型效能進行量化和比較。這種方法以及被用來在一組有趣的語言建模問題上生成文字，例如：

  • 生成維基百科文章（包括標記）；

  • 從生成像莎士比亞這樣的偉大的作者的作品片段；

  • 生成技術手稿（包括標記）；

  • 生成計算機原始碼；

  • 生成文章標題。

結果的質量各不相同，例如，標記或原始碼可能需要人工干預來渲染或編譯。然而，結果令人印象深刻。該方法也已應用於不同的領域，其中現在的序列資訊的大語料庫是可用的，並且可以一步一步生成新的序列，例如：

  • 手寫體生成；

  • 音樂生成；

  • 語音生成；

11.1.2 結構和實現

一個Generative LSTM不是真正的體系結構，它更多地是關於LSTM預測模型學習和使用模型的角度的改變。我們可以想象地使用任何LSTM體系結構作為生成模型。在這種情況下，我們使用一個簡單的Vanilla LSTM。

怎麼開發一個LSTM模型來生成形狀？（附程式碼）

圖 1.1 Vanilla LSTM情況下，Generative LSTTM結構

在字元級語言模型的情況下，所有可能字元的字母都是固定的。一個one hot編碼既用於學習輸入序列，又用於預測輸出序列。一個一對一的模型用於預測每個輸入時間步長的一個步驟。這意味著輸入序列可能需要專門的處理，以便被向量化或格式化，以便有意識地訓練有監督的模型。例如，給定序列：

“hello world”

表 11.1 字元序列的例子

一個資料集可能需要被構建成例如：

'h' => 'e' 
'e' => 'l' 
'l' => 'l' 
 ...

表 11.2 如one-to-one模型的字元序列的例子

這可以作為一個時間步長樣本的資料集來呈現，這可以相當限制網路（例如，沒有BPTT）。或者，它可以被向量化為many-to-one個時間步長模型的固定長度的輸入序列，例如：

[ 'h' , 'e' , 'l' ] => 'l' 
[ 'e' , 'l' , 'l' ] => 'o' 
[ 'l' , 'l' , 'o' ] => ' '
... 

表 11.3 many-to-one模型的字元序列的例子

或者，一個one-to-many時間步長模型的一個固定長度的輸出序列。

'h' => [ 'e' , 'l' , 'l' ] 
'e' => [ 'l' , 'l' , 'o' ]
'l' => [ 'l' , 'o' , ' '] 
...

表 11.4 one-to-many模型的字元序列的例子

或者這些方法的一些變化。注意，在進行預測時，需要相同的向量化表示，這意味著預測的字元將需要作為後續樣本的輸入。這在實現上可能是相當笨拙的。網路的內部形狀可能需要仔細管理，可能在輸入序列中的選擇位置（例如段落、頁面或章節結束）重置，而不是在每個輸入序列的末尾重置。

11.2 形狀生成問題

我們可以將產生隨機形狀的問題分解為序列生成問題。我們可以把一個矩形化成順時針方向的點序列，在二維空間中有4個點：

  • Bottom Left(BL):[0, 0]

  • Bottom Right(BR):[1, 0]

  • Top Right(TR):[1, 1]

  • Top Left(TL):[0, 1]

每個座標可以作為一個時間步長，x軸和y軸中的每一個代表單獨的特徵。從[0, 0]開始，任務是繪製具有一致寬度和高度的矩形的其餘4個點。我們將把這個問題看做是一個座標生成問題，例如one-to-one序列預測問題。給定座標，預測下一個座標。然後給定在最後一步預測的座標，預測下一個座標等扥。

[0,0] => [x1, y1] 
[x1,y1] => [x2, y2] 
[x2,y2] => [x3, y3]

表 11.5 作為一個one-to-one模型做座標預測的例子

怎麼開發一個LSTM模型來生成形狀？（附程式碼）

圖 11.2 基於one-to-one預測模型的形狀生成問題

我們可以通過生成隨機矩陣來訓練模型，並使模型預測後續座標。從[0, 0]預測第一座標是不可能的，並且從寬度預測高度也是不可能的，但是我們相信，只要重複暴露於整個矩形，模型就可以學習如何繪製具有一致寬度和高度的新矩形。在Python中實現這一過程涉及三個步驟：

  1. 生成隨機矩形；

  2. 繪製矩形；

  3. 矩形到序列；

11.2.1 生成隨機矩形

我們可以使用random()函式來生成0到1之間的隨機數。給定一個矩形，我們可以使用random()函式來定義矩形的寬度和高度。

width, height = random(), random()

表 11.6 生成隨機寬度和高度的例子

然後，我們可以使用寬度和高度來定義矩形的4個點，從順時針方向從x=0，y=0開始。

[0.0, 0.0] 
[width, 0.0] 
[width, height] 
[0.0, height]

表 11.7 隨機矩形的座標序列的例子

下面的函式，叫做random_rectangle()，產生了一個隨機矩陣並返回一個二維點的列表。

from random import random
# generate a rectangle with random width and height
def random_rectangle():
    width, height = random(), random()
    points = list()
    # bottom left
    points.append([0.0, 0.0])
    #  bottom right
    points.append([width, 0.0])
    # top right
    points.append([width, height])
    # top left
    points.append([0.0, height])
    return points
rect = random_rectangle()
print(rect)

表 11.8 生成隨機矩陣的例子

執行示例建立一個隨機矩陣並列印出座標。你生成的特定的隨機矩陣將有所不同。

[[0.0, 0.0], [0.7541960995182183, 0.0], [0.7541960995182183, 0.9971807822173515], [0.0, 0.9971807822173515]]

表 11.9 生成隨機矩陣輸出的例子

11.2.2 顯示矩陣

我們選擇一個二維形狀生成，主要是因為我們可以視覺化結果。因此，我們需要一種容易地繪製矩形的方法，它要麼隨機生成，要麼由模型預測。我們可以使用Matplotlib庫來繪製座標路徑。

這涉及為形狀定義一個路徑，包括座標列表和路徑移動的形狀。座標列表將是我們隨機生成的座標列表，其中新增第一個座標到列表的末尾以閉合多邊形。路徑是一系列的運動，如MOVETO指令啟動序列，LINETO指令連線點，以及CLOSEPOLY指令來閉合多邊形。

# close the rectangle path 
rect.append(rect[0]) 
# define path 
codes = [Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY] 
path = Path(rect, codes)

表 11.10 將矩形左邊轉換成形狀的例子

我們可以從路徑定義一個PathPatch並將其直接在Matplotlib畫圖上畫出來。

axis = pyplot.gca() 
patch = PathPatch(path)
# add shape to plot 
axis.add_patch(patch)

表 11.11 顯示一個形狀的例子

下面的函式叫做plot_rectangle()將一個4個矩形點的列表作為輸入，並繪製並顯示該圖。軸的邊界被調整以確保形狀在0-1的範圍內很好地被保持。

from matplotlib import pyplot
from matplotlib.patches import PathPatch
from matplotlib.path import Path
# plot a rectangle
def plot_rectangle(rect):
    # close the rectangle path
    rect.append(rect[0])
    # define path
    codes = [Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY]
    path = Path(rect, codes)
    axis = pyplot.gca()
    patch = PathPatch(path)
    # add shape to plot
    axis.add_patch(patch)
    axis.set_xlim(-0.1,1.1)
    axis.set_ylim(-0.1,1.1)
    pyplot.show()

表 11.12 顯示一個矩形的函式

下面的例子展示了顯示隨機生成矩形的例子。

from random import random
from matplotlib import pyplot
from matplotlib.patches import PathPatch
from matplotlib.path import Path
# generate a rectangle with random width and height
def random_rectangle():
    width, height = random(), random()
    points = list()
    # bottom left
    points.append([0.0, 0.0])
    # bottom right
    points.append([width, 0.0])
    # top right
    points.append([width, height])
    # top left
    points.append([0.0, height])
    return points
# plot a rectangle
def plot_rectangle(rect):
    # close the rectangle path
    rect.append(rect[0])
    # define path
    codes = [Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY]
    path = Path(rect, codes)
    axis = pyplot.gca()
    patch = PathPatch(path)
    # add shape to plot
    axis.add_patch(patch)
    axis.set_xlim(-0.1,1.1)
    axis.set_ylim(-0.1,1.1)
    pyplot.show()
rect = random_rectangle()
plot_rectangle(rect)

表 11.13 生成和顯示一個矩形的例子

執行例子生成一個隨機矩形並將其繪製到螢幕上。生成的特定矩形將在每次程式碼執行時發生變化。

怎麼開發一個LSTM模型來生成形狀？（附程式碼） 圖 11.3 顯示隨機矩陣

11.2.3 矩陣到序列

最後，我們需要將2D座標的序列從隨機生成的矩形轉換成我們可以用來訓練LSTM模型的東西。給定矩形的4個點的序列：

[BL, BR, TR, TL]

表 11.14 矩形的點序列的例子

我們可以生成具有1個時間步長和一個特徵的3個例子，如下：

[BL] => [BR]
[BR] => [TR]
[TR] => [TL]

表 11.15 one-to-one模型的一個序列的點的例子

下面的函式叫做get_samples()將會生成一個新的隨機矩形並將其轉換成一個資料集的3個例子：

# generate input and output sequences for one random rectangle
def get_samples():
    # generate rectangle
    rect = random_rectangle()
    X, y = list(), list()
    # create input output pairs for each coordinate
    for i in range(1, len(rect)):
        X.append(rect[i-1])
        y.append(rect[i])
    # convert input sequence shape to have 1 time step and 2 features
    X, y = array(X), array(y)
    X = X.reshape((X.shape[0], 1, 2))
    return X, y

表 11.16 生成一個隨機矩形並返回一個序列點的函式

下面的例子顯示了這個函式。

from random import random
from numpy import array
# generate a rectangle with random width and height
def random_rectangle():
    width, height = random(), random()
    points = list()
    # bottom left
    points.append([0.0, 0.0])
    # bottom right
    points.append([width, 0.0])
    # top right
    points.append([width, height])
    # top left
    points.append([0.0, height]
    return points
# generate input and output sequences for one random rectangle
def get_samples():
    # generate rectangle
    rect = random_rectangle()
    X, y = list(), list()
    # create input output pairs for each coordinate
    for i in range(1, len(rect)):
        X.append(rect[i-1])
        y.append(rect[i])
    # convert input sequence shape to have 1 time step and 2 features
    X, y = array(X), array(y)
    X = X.reshape((X.shape[0], 1, 2))
    return X, y
X, y = get_samples()
for i in range(X.shape[0]):
    print(X[i][0], '=>', y[i])

表 11.17 生成一個矩形並將其準備為LSTM模型的例子

執行這個例子顯示了輸入和輸出座標的每個例子。每次執行示例時，特定座標將變化。

[ 0.  0.] => [ 0.44680225  0.        ]
[ 0.44680225  0.        ] => [ 0.44680225  0.87292771]
[ 0.44680225  0.87292771] => [ 0.          0.87292771]

表 11.18 生成一個矩形並將其準備給LSTM模型的輸出的例子

11.3 定義和編譯模型

現在我們已經準備好了一個LSTM模型來解決形狀預測的問題。該模型將預期1個時間步長輸入，每一個具有2個特徵的x座標軸和y座標軸。我們將在LSTM隱藏層中使用10個儲存單元。大容量則不需要管這個問題，10個單元的設定是從一次次的嘗試和錯誤中來的。

model = Sequential() 
  1. model.add(LSTM(10, input_shape=(1, 2)))

表 11.19 新增輸入層的例子

網路的輸出是由x和y值組成的單個座標。我們將使用具有2個神經元和線性啟用函式的Dense層。

model.add(Dense(2, activation= 'linear' ))

表 11.20 新增輸出層的例子

該模型最小化了平均絕對誤差（mae）損失函式，並利用Adam優化演算法對網路權值進行了計算。下面列出了完成的模型的定義。

# define model 
model = Sequential()
model.add(LSTM(10, input_shape=(1, 2)))
model.add(Dense(2, activation= linear ))
model.compile(loss= 'mae' , optimizer= adam )
print(model.summary())

表 11.21 定義和編譯Generative LSTM模型的例子

執行例子列印模型結構的總結。我們可以看到模型確實是很小的。

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
  1. lstm_1 (LSTM)                (None, 10)                520       
_________________________________________________________________

dense_1 (Dense)              (None, 2)                 22        
=================================================================

Total params: 542
  2. Trainable params: 542
  3. Non-trainable params: 0

_________________________________________________________________

None

表 11.22 從定義和編譯Generative LSTM輸出的例子

11.4 擬合模型

該模型可以通過一次生成一個序列並使用它們來更新模型權重來擬合。每個序列由3個樣本組成，在該模型的末尾，模型權重將被更新，並且每個LSTM單元的內部狀態將被重置。這允許模型的記憶體集中在每個二進位制序列的特定輸入值上。生成的樣本數代表訓練週期epoch的代理；在這裡，我們將使用25000個隨機生成的矩形點序列。這種配置是在經過一次次的實驗和反覆嘗試後發現的。樣本的順序很重要，因此樣本的混洗被關閉。

  1. # fit model 
  2. 

  3. for i in range(25000): 
    X, y = get_samples()
    model.fit(X, y, epochs=1, verbose=2, shuffle=False)

表 11.23 擬合一個編譯了的Generative LSTM的例子

在最後一個週期的時候擬合模型列印損失。

Epoch 1/1
 - 0s - loss: 0.3404
Epoch 1/1
 - 0s - loss: 0.2813
Epoch 1/1
 - 0s - loss: 0.1133
Epoch 1/1
 - 0s - loss: 0.1091
Epoch 1/1
 - 0s - loss: 0.0847
Epoch 1/1
 - 0s - loss: 0.1837
Epoch 1/1
 - 0s - loss: 0.2099
Epoch 1/1
 - 0s - loss: 0.2659
 Epoch 1/1
 - 0s - loss: 0.1562
Epoch 1/1
 - 0s - loss: 0.1360
Epoch 1/1
 - 0s - loss: 0.2088
Epoch 1/1
 - 0s - loss: 0.3155
Epoch 1/1
 - 0s - loss: 0.1470

表 11.24 擬合一個編譯了的Generative LSTM輸出的例子

11.5 用模型進行預測

一旦模型擬合，我們就可以使用它來生成新的矩形。我們可以用通過將矩形的起點定義為[0, 0]，以此作為輸入來獲得下一個預測座標。這是矩形的寬度。

# use [0,0] to seed the generation process 
last = array([0.0,0.0]).reshape((1, 1, 2)) 
# predict the next coordinate
yhat = model.predict(last, verbose=0)

表 11.25 預測矩形寬度的例子

然後，我們可以使用預測座標作為輸入來預測下一點。這將定義矩形的高度。

# use this output as input for the next prediction 
last = yhat.reshape((1, 1, 2)) 
# predict the next coordinate
yhat = model.predict(last, verbose=0)

表 11.26 預測矩形高度的例子

然後，該過程再重複一次，以產生剩餘的座標，該座標預期與已經在第三點中定義的寬度和高度保持一致。下面的函式名generate_rectangle()包裹了這個函式，並使用擬合模型生成一個新的矩形，然後返回點列表。

# use a fit LSTM model to generate a new rectangle from scratch
def generate_rectangle(model):
    rect = list()
    # use [0,0] to seed the generation process
    last = array([0.0,0.0]).reshape((1, 1, 2))
    rect.append([[y for y in x] for x in last[0]][0])
    # generate the remaining 3 coordinates
    for i in range(3):
        # predict the next coordinate
        yhat = model.predict(last, verbose=0)
        # use this output as input for the next prediction
        last = yhat.reshape((1, 1, 2))
        # store coordinate
        rect.append([[y for y in x] for x in last[0]][0])
    return rect

表 11.27 函式從零開始生成一個矩形

我們可以使用這個函式來進行預測，然後使用先前定義的函式plot_rectangle()來顯示結果。

# generate new shapes from scratch 
rect = generate_rectangle(model) 
plot_rectangle(rect)

表 11.28 從零開始生成一個矩形的函式

執行例子生成一個矩形並將其顯示在螢幕上。我們可以看到，矩形在寬度和高度的比例保持一致上確實做了很合理的工作。生成的特定矩形將在每次程式碼執行時發生變化。

怎麼開發一個LSTM模型來生成形狀？（附程式碼） 圖 11.4 顯示由Generative LSTM模型生成的矩形

11.6 評估模型

評估一個Generative LSTM模型是困難的。在這種情況下，我們對生成的形狀（矩形）有很好的期望，可以定量和定性地進行評價。在許多問題中，情況困難並非如此，你可能不得不依靠定性的評價。

我們可以通過視覺化實現對矩形的定性評價。一下是在不同的數量的訓練之後生成的矩形的示例，以顯示隨著訓練例子的增肌，模型的學習能力的定性改進。

怎麼開發一個LSTM模型來生成形狀？（附程式碼） 圖 11.5 通過100個例項生成LSTM模型生成的矩形圖

怎麼開發一個LSTM模型來生成形狀？（附程式碼） 圖 11.6 通過500個例項生成LSTM模型生成的矩形圖

怎麼開發一個LSTM模型來生成形狀？（附程式碼） 圖 11.7 通過1000個例項生成LSTM模型生成的矩形圖

怎麼開發一個LSTM模型來生成形狀？（附程式碼） 圖 11.7 通過5000個例項生成LSTM模型生成的矩形圖

怎麼開發一個LSTM模型來生成形狀？（附程式碼） 圖 11.7 通過10000個例項生成LSTM模型生成的矩形圖

11.7 完整例子

完整的程式碼列表提供如下給你做參考：

from random import random
from numpy import array
from matplotlib import pyplot
from matplotlib.patches import PathPatch
from matplotlib.path import Path
from keras.models import Sequential
from keras.layers import LSTM
from keras.layers import Dense
  1. # generate a rectangle with random width and height
def random_rectangle():
    width, height = random(), random()
    points = list()
    # bottom left
    points.append([0.0, 0.0])
    # bottom right
    points.append([width, 0.0])
    # top right
    points.append([width, height])
    # top left
    points.append([0.0, height])
    return points
# plot a rectangle
  2. def plot_rectangle(rect):
    # close the rectangle path
    rect.append(rect[0])
    # define path
    codes = [Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY]
    path = Path(rect, codes)
    axis = pyplot.gca()
    patch = PathPatch(path)
    # add shape to plot
    axis.add_patch(patch)
    axis.set_xlim(-0.1,1.1)
    axis.set_ylim(-0.1,1.1)
    pyplot.show()
# generate input and output sequences for one random rectangle
def get_samples():
    # generate rectangle
    rect = random_rectangle()
    X, y = list(), list()
    # create input output pairs for each coordinate
    for i in range(1, len(rect)):
        X.append(rect[i-1])
        y.append(rect[i])
    # convert input sequence shape to have 1 time step and 2 features
    X, y = array(X), array(y)
    X = X.reshape((X.shape[0], 1, 2))
    return X, y
# use a fit LSTM model to generate a new rectangle from scratch
def generate_rectangle(model):
    rect = list()
    # use [0,0] to seed the generation process
    last = array([0.0,0.0]).reshape((1, 1, 2))
    rect.append([[y for y in x] for x in last[0]][0])
    # generate the remaining 3 coordinates
    for i in range(3):
        # predict the next coordinate
        yhat = model.predict(last, verbose=0)
        # use this output as input for the next prediction
        last = yhat.reshape((1, 1, 2))
        # store coordinate
        rect.append([[y for y in x] for x in last[0]][0])
    return rect
# define model
model = Sequential()
model.add(LSTM(10, input_shape=(1, 2)))
model.add(Dense(2, activation= 'linear' ))
model.compile(loss= 'mae' , optimizer= 'adam' )
print(model.summary())
# fit model
for i in range(25000):
    X, y = get_samples()
    model.fit(X, y, epochs=1, verbose=2, shuffle=False)
# generate new shapes from scratch
rect = generate_rectangle(model)
plot_rectangle(rect)

表 11.29 生成模型在矩形生成問題上的例子

11.8 擴充套件閱讀

本章節提供了一些用於擴充套件閱讀的資源。

11.8.1 論文

-Generating Text with Recurrent Neural Networks, 2011.

  • Generating Sequences With Recurrent Neural Networks, 2013.

  • TTS Synthesis with Bidirectional LSTM based Recurrent Neural Networks, 2014.

  • A First Look at Music Composition using LSTM Recurrent Neural Networks, 2002.

  • Jazz Melody Generation from Recurrent Network Learning of Several Human Melodies, 2005.

11.8.2 文章

  • The Unreasonable Effectiveness of Recurrent Neural Networks, 2015.

11.8.3 APIs

  • Python random API.

  • Matplotlib Path API.

  • Matplotlib Patch API.

11.9 擴充套件

你想更加深入地瞭解Generative LSTM嗎？本章節列出了本課中一些具有挑戰性的擴充套件。

  • 列出5個其他問題的例子，而不是其他的語言模型，Generative LSTM可以被使用。

  • 設計並執行實驗以比較模型大小（神經元數）與定性模型學習能力（影象）。

  • 更新示例，使得隨機矩陣由更多的點組成（例如，在中間寬度的點和矩形的中高度），然後調諧LSTM以獲得良好的技能。

  • 開發一個函式來估計矩形誤差在寬度和高度不一致的情況下，在擬合生成LSTM時用作損失函式和度量。

  • 更新示例以學習不同的形狀，例如圓、星型或十字。

11.10 總結

在本課程中，我們學習到了怎麼樣開發一個Generative LSTM模型。特別地，你學習到了：

  • LSTMs怎麼樣可以被用於生成模型；

  • 怎麼樣把形狀繪製作為序列生成問題；

  • 怎麼開發一個LSTM模型來生成形狀。

在下一課中，你將會學到怎麼樣充分利用LSTM模型。

相關文章