目錄
1 問題設定

 

• 1.1 資料集和預處理
• 1.2 概覽整個模型

 

2. 建立模型模組

 

• 2.1 在優化迴圈中梯度裁剪
• 2.2 取樣

 

3. 構建語言模型

 

• 3.1 梯度下降
• 3.2 訓練模型

 

4. 結論

 

    本文是DeepLearning.ai的第五門課作業: Character level language model - Dinosaurus Island   1 問題設定   歡迎來到恐龍島！ 6500萬年前，恐龍就已經存在，並且在這種任務下它們又回來了。你負責一項特殊任務。領先的生物學研究人員正在創造新的恐龍品種，並將它們帶入地球，而你的工作就是為這些恐龍起名字。如果恐龍不喜歡它的名字，它可能會發瘋，所以請明智地選擇！ 幸運的是，你已經學習了一些深度學習，你將用它來節省時間。你的助手已收集了他們可以找到的所有恐龍名稱的列表，並將其編譯到此資料集中。要建立新的恐龍名稱，你將構建一個字元級語言模型來生成新名稱。你的演算法將學習不同的名稱模式，並隨機生成新名稱。希望該演算法可以使你和你的團隊免受恐龍的憤怒！ 完成此作業，你將學到：

• 如何儲存文字資料以使用RNN進行處理
• 如何通過在每個時間步取樣預測並將其傳遞給下一個RNN單元來合成數據
• 如何構建字元級文字生成迴圈神經網路
• 為什麼剪裁漸變很重要

我們將首先載入rnn_utils中為你提供的一些功能。具體來說，你可以訪問rnn_forward和rnn_backward之類的功能，這些功能與你在上一個作業中實現的功能等效。 import numpy as np from utils import * import random import pprint   1.1 資料集和預處理   以下程式碼做了三件事:

1. 讀取恐龍名稱的資料集
2. 建立唯一字元列表（例如a-z）
3. 計算資料集和詞彙量。

data = open('dinos.txt', 'r').read() # 載入資料集 
data= data.lower() # 將所有資料變小寫 
chars = list(set(data)) # 建立唯一字元列表，data中用了什麼字元 
data_size, vocab_size = len(data), len(chars) # 資料集的大小和詞彙量 
print('There are %d total characters and %d unique characters in your data.' % (data_size, vocab_size))

char_to_ix：在下面的單元格中，我們建立一個python字典（即雜湊表），以將每個字元對映到0-26之間的索引。 ix_to_char：我們還建立了第二個python字典，該字典將每個索引映射回相應的字元。 這將幫你找出softmax層的概率分佈輸出中哪個索引對應於哪個字元。 chars = sorted(chars) print(chars)

['\n', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

char_to_ix = { ch:i for i,ch in enumerate(chars) } ix_to_char = { i:ch for i,ch in enumerate(chars) } pp = pprint.PrettyPrinter(indent=4) # 格式化輸出 pp.pprint(ix_to_char)

{ 0: '\n', 1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6: 'f', 7: 'g', 8: 'h', 9: 'i', 10: 'j', 11: 'k', 12: 'l', 13: 'm', 14: 'n', 15: 'o', 16: 'p', 17: 'q', 18: 'r', 19: 's', 20: 't', 21: 'u', 22: 'v', 23: 'w', 24: 'x', 25: 'y', 26: 'z'}

  1.2 概覽整個模型   你的模型將具有以下結構：

• 初始化引數
• 執行優化迴圈
• 前向傳播以計算損失函式
• 向後傳播根據損失函式計算梯度
• 梯度裁剪以避免梯度爆炸
• 使用梯度下降規則更新你的引數

• 返回學習到的引數

• 每一個時間步長, RNN都會根據之前的字元來預測下一個字元是什麼。
• 資料集 \mathbf{X} = (x^{\langle 1 \rangle}, x^{\langle 2 \rangle}, ..., x^{\langle T_x \rangle}) 是訓練集中的字元列表。
• \mathbf{Y} = (y^{\langle 1 \rangle}, y^{\langle 2 \rangle}, ..., y^{\langle T_x \rangle}) 是相同的字元列表，但是向前移動了一個字元。
• 每個時間步長 t, y^{\langle t \rangle} = x^{\langle t+1 \rangle}. 在時間 t 處的預測值和時間 t + 1 處的輸入值相同.

  2. 建立模型模組   在這一部分中，你將構建整個模型的兩個重要模組：

• 梯度裁剪：避免梯度爆炸
• 取樣：一種用於生成字元的技術

然後，你將應用這兩個功能來構建模型。   2.1 在優化迴圈中梯度裁剪   在本節中，你將實現在優化迴圈中呼叫的clip函式。 梯度爆炸

• 當梯度值非常大時，稱為“梯度爆炸”。
• 梯度爆炸使訓練過程更加困難，因為更新可能太大，以至於在反向傳播過程中“overshoot”了最佳值。

回想一下，你的總迴圈結構通常包括：

• 向前傳播
• 計算成本函式
• 向後傳播
• 引數更新

在更新引數之前，你需要執行梯度裁剪，以確保梯度不“爆炸”。   梯度裁剪   在下面的練習中，你將實現一個函式clip，該函式接受梯度字典，並在需要時返回梯度的裁剪版本。

• 剪下漸變有多種方法。
• 我們將使用簡單的按元素裁剪程式，其中將梯度向量的每個元素裁剪為位於某個範圍[-N，N]之間。
• 例如，如果N = 10
• 元素的取值範圍是[-10，10]
• 如果任何在梯度向量中大於10的元素，則將其設定為10。
• 如果任何在梯度向量中小於-10的元素，則將其設定為-10。
• 如果任何在-10到10之間的元素，則它們保持原始值。

在遇到“梯度爆炸”問題情況下，帶和不帶梯度裁剪的梯度下降的視覺化圖。 返回字典“ gradients”的剪裁梯度。

def clip(gradients, maxValue):
'''
Clips the gradients' values between minimum and maximum.

Arguments:
gradients -- a dictionary containing the gradients "dWaa", "dWax", "dWya", "db", "dby"
maxValue -- everything above this number is set to this number, and everything less than -maxValue is set to -maxValue

Returns:
gradients -- a dictionary with the clipped gradients.
'''

dWaa, dWax, dWya, db, dby = gradients['dWaa'], gradients['dWax'], gradients['dWya'], gradients['db'], gradients['dby']

### START CODE HERE ###
# clip to mitigate exploding gradients, loop over [dWax, dWaa, dWya, db, dby]. (≈2 lines)
for gradient in [dWax, dWaa, dWya, db, dby]:
np.clip(gradient, -maxValue, maxValue, out=gradient)
### END CODE HERE ###

# gradients = {"dWaa": dWaa, "dWax": dWax, "dWya": dWya, "db": db, "dby": dby}

return gradients

  2.2 取樣   現在假設你的模型已經過訓練，你想生成新文字（字元），下圖說明了生成過程： 在這張照片中，我們假設模型已經過訓練。 我們在第一個時間步長中傳入x^{\langle 1\rangle} = \vec{0}，然後讓網路一次取樣一個字元。 練習: 執行下面的 sample函式來取樣字元，你需要4步:

• Step 1: 輸入0的 "dummy" 向量x^{\langle 1 \rangle} = \vec{0}.
• 這是我們生成任何字元之前的預設輸入。 我們還設定了 a^{\langle 0 \rangle} = \vec{0}

 

• Step 2: 執行一次向前傳播即可獲得 a^{\langle 1 \rangle} 和 \hat{y}^{\langle 1 \rangle}. 這裡是公式:

隱藏狀態:
啟用:
預測:

• 關於 的一些細節:
• 注意 是一個概率向量 (softmax) (它的每個元素值在0到1之間，且總和為1).
• 表示由“ i”索引的字元是下一個字元的概率。
• 我們提供了 softmax() 函式供你使用.

額外的提示

• x^{\langle 1 \rangle} 在程式碼中是 x.當建立one-hot向量時，請建立一個由零的組成numpy陣列，其中行數等於唯一字元數，列數等於1。 它是2D而不是1D陣列。
• a^{\langle 0 \rangle} 在程式碼中是a_prev. 它是一個由零組成的numpy陣列，其中行數為 n_ {a} ，列數為1。它也是2D陣列。 通過獲取 W_ {aa} 中的列數來得到 n_ {a} （這些數字必須匹配，以便矩陣乘法W_{aa}a^{\langle t \rangle}起作用 。
• a ^ {\ langle 0 \ rangle} 在程式碼中為a_prev。
• numpy.dot
• numpy.tanh

用2維而不是1維

• 你可能想知道為什麼我們強調x^{\langle 1 \rangle}和a^{\langle 0 \rangle}是2D陣列而不是1D向量。
• 對於numpy中的矩陣乘法，如果將2D矩陣與1D向量相乘，則最終得到1D陣列。
• 當我們將兩個陣列相加時，期望它們具有相同形狀，這將成為一個問題。
• 當兩個具有不同維數的陣列加在一起時，Python將會執行“廣播broadcasts”。
• 這是一些示例程式碼，顯示了使用1D和2D陣列之間的區別。

import numpy as np 
matrix1 = np.array([[1,1],[2,2],[3,3]]) # (3,2) 
matrix2 = np.array([[0],[0],[0]]) # (3,1) 
vector1D = np.array([1,1]) # (2,) 
vector2D = np.array([[1],[1]]) # (2,1) 
np.dot(matrix1,vector1D) # 2D 和 1D 陣列相乘: 結果是1D陣列 [2 4 6] 
np.dot(matrix1,vector2D) # 2D 和 2D 陣列相乘: 結果是2D陣列 [[2], [4], [6]] 
np.dot(matrix1,vector2D) + matrix2 # (3 x 1) 向量和(3 x 1)向量相加是(3 x 1) 向量，這個是我們想要的。 [[2] [4] [6]] 
np.dot(matrix1,vector1D) + matrix2 # (3,) 向量和(3 x 1)向量相加，這會在第二維上廣播1D的陣列，這不是我們想要的！

 

• Step 3: 抽樣:
• 注意我們已經有了y^{\langle t+1 \rangle}, 我們想選擇恐龍名稱中的下一個字母。如果我們選擇最有可能的情況，那麼在給定起始字母的情況下，模型將始終產生相同的結果。
• 為了使結果更有趣，我們將使用np.random.choice選擇可能但並非總是相同的下一個字母。

 

• 取樣是從一組值中選擇一個值，其中每個值都有一定概率被選擇。
• 取樣使我們能夠生成隨機的序列值。
• 根據\hat{y}^{\langle t+1 \rangle }中的概率分佈選擇下一個字元的索引。
• 這就意味著如果\hat{y}^{\langle t+1 \rangle }_i = 0.16, 你將以16％的概率選擇索引“ i”。
• 你可以檢視np.random.choice.

這裡有個例子np.random.choice(): np.random.seed(0) probs = np.array([0.1, 0.0, 0.7, 0.2]) idx = np.random.choice([0, 1, 2, 3] p = probs)

• 這就意味著你會根據分佈來選擇索引:

P(index = 0) = 0.1, P(index = 1) = 0.0, P(index = 2) = 0.7, P(index = 3) = 0.2.

• 注意p的值是1D向量。
• 注意 \hat{y}^{\langle t+1 \rangle}在程式碼中用 y 表示, 它是2維陣列。

• Step 4: 更新 x^{\langle t \rangle }
• sample()函式的最後一步就是更新變數x, 它當前儲存的是 x^{\langle t \rangle }, 換成x^{\langle t + 1 \rangle }.
• 你將選擇作為預測字元相對應的one-hot向量來代表x^{\langle t + 1 \rangle }。
• 你將接著在步驟1中向前傳播x^{\langle t + 1 \rangle }，並繼續重複該過程直到獲得“ \n”字元，它表明你已經到達恐龍名稱的末尾。

# GRADED FUNCTION: sample

def sample(parameters, char_to_ix, seed):
    """
    Sample a sequence of characters according to a sequence of probability distributions output of the RNN

    Arguments:
    parameters -- python dictionary containing the parameters Waa, Wax, Wya, by, and b. 
    char_to_ix -- python dictionary mapping each character to an index.
    seed -- used for grading purposes. Do not worry about it.

    Returns:
    indices -- a list of length n containing the indices of the sampled characters.
    """
    
    # Retrieve parameters and relevant shapes from "parameters" dictionary
    Waa, Wax, Wya, by, b = parameters['Waa'], parameters['Wax'], parameters['Wya'], parameters['by'], parameters['b']
    vocab_size = by.shape[0]
    n_a = Waa.shape[1]
    
    ### START CODE HERE ###
    # Step 1: Create the a zero vector x that can be used as the one-hot vector 
    # representing the first character (initializing the sequence generation). (≈1 line)
    x = np.zeros((vocab_size, 1)) # 可以看看上面為什麼這裡是二維
    # Step 1': Initialize a_prev as zeros (≈1 line)
    a_prev = np.zeros((n_a, 1))
    
    # Create an empty list of indices, this is the list which will contain the list of indices of the characters to generate (≈1 line)
    indices = []
    
    # idx is the index of the one-hot vector x that is set to 1
    # All other positions in x are zero.
    # We will initialize idx to -1
    idx = -1 
    
    # Loop over time-steps t. At each time-step:
    # sample a character from a probability distribution 
    # and append its index (`idx`) to the list "indices". 
    # We'll stop if we reach 50 characters 
    # (which should be very unlikely with a well trained model).
    # Setting the maximum number of characters helps with debugging and prevents infinite loops. 
    counter = 0
    newline_character = char_to_ix['\n']
    
    while (idx != newline_character and counter != 50):
        
        # Step 2: Forward propagate x using the equations (1), (2) and (3)
        a = np.tanh(np.dot(Wax, x) + np.dot(Waa, a_prev) + b)
        z = np.dot(Wya, a) + by
        y = softmax(z)
        
        # for grading purposes
        np.random.seed(counter+seed) 
        
        # Step 3: Sample the index of a character within the vocabulary from the probability distribution y
        # (see additional hints above)
        idx = np.random.choice(list(range(vocab_size)), p=y.ravel())

        # Append the index to "indices"
        indices.append(idx)
        
        # Step 4: Overwrite the input x with one that corresponds to the sampled index `idx`.
        # (see additional hints above)
        x = np.zeros((vocab_size, 1))
        x[idx] = 1
        
        # Update "a_prev" to be "a"
        a_prev = a
        
        # for grading purposes
        seed += 1
        counter +=1
        
    ### END CODE HERE ###

    if (counter == 50):
        indices.append(char_to_ix['\n'])
    
    return indices

 

3. 構建語言模型 3.1 梯度下降 現在是時候建立用於文字生成的字元級語言模型了。

• 在本節中，你將實現一個函式，該函式執行一步隨機梯度下降（帶有修剪的梯度）。
• 你將一次檢視一個訓練示例，因此優化演算法將是隨機梯度下降。

提醒一下，這是RNN常見優化迴圈的步驟:

• 通過RNN向前傳播以計算損耗
• 隨時間向後傳播以計算相對於引數的損耗梯度
• 梯度裁剪
• 使用梯度下降更新引數

Exercise: 實施優化過程（隨機梯度下降的一步） 已提供以下函式:

def rnn_forward(X, Y, a_prev, parameters):
    """ Performs the forward propagation through the RNN and computes the cross-entropy loss.
    It returns the loss' value as well as a "cache" storing values to be used in backpropagation."""
    ....
    return loss, cache

def rnn_backward(X, Y, parameters, cache):
    """ Performs the backward propagation through time to compute the gradients of the loss with respect
    to the parameters. It returns also all the hidden states."""
    ...
    return gradients, a

def update_parameters(parameters, gradients, learning_rate):
    """ Updates parameters using the Gradient Descent Update Rule."""
    ...
    return parameters
Recall that you previously implemented the clip function:

def clip(gradients, maxValue)
    """Clips the gradients' values between minimum and maximum."""
    ...
    return gradients

• 請注意，即使parameters不是optimize函式的返回值之一，parameters字典中的權重和偏差也會通過優化進行更新。引數字典通過引用傳遞到函式中，因此即使在函式外部訪問該字典，對字典的更改也會對引數字典做出更改。
• Python字典和列表是“按引用傳遞”，這意味著，如果將字典傳遞給函式並在函式內修改字典，則這將更改同一字典。

def optimize(X, Y, a_prev, parameters, learning_rate = 0.01):
    """
    Execute one step of the optimization to train the model.
    
    Arguments:
    X -- list of integers, where each integer is a number that maps to a character in the vocabulary.
    Y -- list of integers, exactly the same as X but shifted one index to the left.
    a_prev -- previous hidden state.
    parameters -- python dictionary containing:
                        Wax -- Weight matrix multiplying the input, numpy array of shape (n_a, n_x)
                        Waa -- Weight matrix multiplying the hidden state, numpy array of shape (n_a, n_a)
                        Wya -- Weight matrix relating the hidden-state to the output, numpy array of shape (n_y, n_a)
                        b --  Bias, numpy array of shape (n_a, 1)
                        by -- Bias relating the hidden-state to the output, numpy array of shape (n_y, 1)
    learning_rate -- learning rate for the model.
    
    Returns:
    loss -- value of the loss function (cross-entropy)
    gradients -- python dictionary containing:
                        dWax -- Gradients of input-to-hidden weights, of shape (n_a, n_x)
                        dWaa -- Gradients of hidden-to-hidden weights, of shape (n_a, n_a)
                        dWya -- Gradients of hidden-to-output weights, of shape (n_y, n_a)
                        db -- Gradients of bias vector, of shape (n_a, 1)
                        dby -- Gradients of output bias vector, of shape (n_y, 1)
    a[len(X)-1] -- the last hidden state, of shape (n_a, 1)
    """
    
    ### START CODE HERE ###
    
    # Forward propagate through time (≈1 line)
    loss, cache = rnn_forward(X, Y, a_prev, parameters)
    
    # Backpropagate through time (≈1 line)
    gradients, a = rnn_backward(X, Y, parameters, cache)
    
    # Clip your gradients between -5 (min) and 5 (max) (≈1 line)
    gradients = clip(gradients, 5)
    
    # Update parameters (≈1 line)
    parameters = update_parameters(parameters, gradients, learning_rate)
    
    ### END CODE HERE ###
    
    return loss, gradients, a[len(X)-1]

 

3.2 訓練模型

• 給定恐龍名稱資料集，我們將資料集的每一行（一個名稱）用作一個訓練樣本。
• 每100步隨機梯度下降，你將抽樣10個隨機選擇的名稱，以檢視演算法的執行情況。
• 請記住要對資料集進行混洗，以便隨機梯度下降以隨機順序訪問樣本。

鍛鍊：按照說明進行操作並實現model（）。當examples[index]包含一個恐龍名稱（字串）以建立示例（X，Y）時，可以使用以下方法： 將索引idx設定為樣本列表

• 使用for迴圈，在“示例”列表中瀏覽經過排序的恐龍名稱列表。
• 如果有100個示例，並且for迴圈將索引從100開始遞增，請考慮如何使索引迴圈回到0，以便我們可以在j為100、101，等等
• 提示：101除以100為零，餘數為1。
• ％是python中的模運算子。

從示例列表中提取一個示例 *single_example：使用你先前設定的idx索引從示例列表中獲取一個單詞。

def model(data, ix_to_char, char_to_ix, num_iterations = 35000, n_a = 50, dino_names = 7, vocab_size = 27):
    """
    Trains the model and generates dinosaur names. 
    
    Arguments:
    data -- text corpus
    ix_to_char -- dictionary that maps the index to a character
    char_to_ix -- dictionary that maps a character to an index
    num_iterations -- number of iterations to train the model for
    n_a -- number of units of the RNN cell
    dino_names -- number of dinosaur names you want to sample at each iteration. 
    vocab_size -- number of unique characters found in the text (size of the vocabulary)
    
    Returns:
    parameters -- learned parameters
    """
    
    # Retrieve n_x and n_y from vocab_size
    n_x, n_y = vocab_size, vocab_size
    
    # Initialize parameters
    parameters = initialize_parameters(n_a, n_x, n_y)
    
    # Initialize loss (this is required because we want to smooth our loss)
    los