吳恩達DeepLearning.ai的Sequence model做業Dinosaurus Island

 

目錄

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)
    loss = get_initial_loss(vocab_size, dino_names)
    
    # Build list of all dinosaur names (training examples).
    with open("dinos.txt") as f:
        examples = f.readlines()
    examples = [x.lower().strip() for x in examples]
    
    # Shuffle list of all dinosaur names
    np.random.seed(0)
    np.random.shuffle(examples)
    
    # Initialize the hidden state of your LSTM
    a_prev = np.zeros((n_a, 1))
    
    # Optimization loop
    for j in range(num_iterations):
        
        ### START CODE HERE ###
        
        # Set the index `idx` (see instructions above)
        index = j % len(examples)
        
        # Set the input X (see instructions above)
        single_example = examples[index]
        single_example_chars = [ch for ch in single_example]
        single_example_ix = [char_to_ix[ch] for ch in single_example_chars] 
        X = [None] + single_example_ix 
        
        # Set the labels Y (see instructions above)
        ix_newline = char_to_ix["\n"]
        Y = X[1:] + [ix_newline]
        
        # Perform one optimization step: Forward-prop -> Backward-prop -> Clip -> Update parameters
        # Choose a learning rate of 0.01
        curr_loss, gradients, a_prev = optimize(X, Y, a_prev, parameters)
        
        ### END CODE HERE ###
        
        # Use a latency trick to keep the loss smooth. It happens here to accelerate the training.
        loss = smooth(loss, curr_loss)

        # Every 2000 Iteration, generate "n" characters thanks to sample() to check if the model is learning properly
        if j % 2000 == 0:
            
            print('Iteration: %d, Loss: %f' % (j, loss) + '\n')
            
            # The number of dinosaur names to print
            seed = 0
            for name in range(dino_names):
                
                # Sample indices and print them
                sampled_indices = sample(parameters, char_to_ix, seed)
                print_sample(sampled_indices, ix_to_char)
                
                seed += 1  # To get the same result (for grading purposes), increment the seed by one. 
      
            print('\n')
        
    return parameters

運行如下代碼，你應該觀察到模型在第一次迭代時輸出看似隨機的字符。 通過數千次迭代後，你的模型應該學會生成看起來合理的名稱。

 

parameters = model(data, ix_to_char, char_to_ix)

 

輸出可能像是如下這樣的:

Iteration: 34000, Loss: 22.447230

Onyxipaledisons

Kiabaeropa

Lussiamang

Pacaeptabalsaurus

Xosalong

Eiacoteg

Troia

 

4. 結論

 

你能夠看到，在訓練即將結束時，你的算法已開始生成合理的恐龍名稱。剛開始時，它會生成隨機字符，可是到最後，你會看到恐龍名字的結尾很酷。當運行完代碼後，它會生成一個酷炫的名字: Mangosaurus!