Python如何構建單層LSTM模型

這篇“Python如何構建單層LSTM模型”文章的知識點大部分人都不太理解，所以小編給大家總結了以下內容，內容詳細，步驟清晰，具有一定的借鑒價值，希望大家閱讀完這篇文章能有所收獲，下面我們一起來看看這篇“Python如何構建單層LSTM模型”文章吧。

1. 獲取訓練原始數據

以下代碼從 jdk-tokens.txt 文件中讀取令牌并將其切片以適合我的桌面的硬件功能。就我而言，我只使用了代碼中顯示的代碼的 20%。

path = "./jdk-tokens.txt"
filetext = open(path).read().lower()
 
# slice the whole string to overcome memory limitation
slice = len(filetext)/5  
slice = int (slice)
filetext = filetext[:slice]
 
tokenized = filetext.split()
 
print('# of tokens:', len(tokenized))

2. 建立索引來定位令牌

LSTM 輸入只理解數字。將標記轉換為數字的一種方法是為每個標記分配一個唯一的整數。例如，如果代碼中有 1000 個唯一令牌，我們可以為 1000 個令牌中的每一個分配一個唯一編號。下面的代碼構建了一個包含 [“public” : 0 ] [ “static” : 1 ], ... ] 等條目的字典。還生成反向字典用于解碼 LSTM 的輸出。

uniqueTokens = sorted(list(set(tokenized)))
print('total # of unique tokens:', len(uniqueTokens))
token_indices = dict((c, i) for i, c in enumerate(uniqueTokens))
indices_token = dict((i, c) for i, c in enumerate(uniqueTokens))

3. 準備帶標簽的訓練序列

在這里，我們以 10 個標記的半冗余序列剪切文本。每個序列是一個訓練樣本，每個令牌序列的標簽是下一個令牌。

NUM_INPUT_TOKENS = 10
step = 3
sequences = []
next_token = []
 
for i in range(0, len(tokenized) - NUM_INPUT_TOKENS, step):
    sequences.append(tokenized[i: i + NUM_INPUT_TOKENS])
    next_token.append(tokenized[i + NUM_INPUT_TOKENS])
 
print('nb sequences:', len(sequences))

4. 向量化訓練數據

我們首先創建兩個矩陣，然后為每個矩陣賦值。一種用于特征，一種用于標簽。len(sequences) 是訓練樣本的總數。

X = np.zeros((len(sequences), NUM_INPUT_TOKENS, len(uniqueTokens)), \
             dtype=np.bool)
y = np.zeros((len(sequences), len(uniqueTokens)), dtype=np.bool)
for i, sentence in enumerate(sequences):
    for t, char in enumerate(sentence):
        X[i, t, token_indices[char]] = 1
    y[i, token_indices[next_token[i]]] = 1

5. 構建單層 LSTM 模型

我們正在構建一個如下所示的網絡：

此外，堆疊兩個 LSTM 層非常簡單，如下面的注釋代碼所示。

下面的代碼定義了神經網絡的結構。該網絡包含一層具有 128 個隱藏單元的 LSTM。input_shape 參數指定輸入序列的長度和每次輸入的維度。Dense() 實現output = activation(dot(input, kernel) + bias)。這里的輸入是 LSTM 層的輸出。激活函數由行 Activation('softmax') 指定。Optimizer 是優化函數。您可能熟悉邏輯回歸中常用的一種，即隨機梯度下降。最后一行指定了成本函數。在這種情況下，我們使用“categorical_crossentropy”。

model = Sequential()
 
# 1-layer LSTM
#model.add(LSTM(128, input_shape=(NUM_INPUT_TOKENS, len(uniqueTokens))))
 
# 2-layer LSTM
model.add(LSTM(128,return_sequences=True, \
               input_shape=(NUM_INPUT_TOKENS, len(uniqueTokens))))
model.add(LSTM(128))
 
model.add(Dense(len(uniqueTokens)))
model.add(Activation('softmax'))
 
optimizer = RMSprop(lr=0.01)
model.compile(loss='categorical_crossentropy', optimizer=optimizer)
print(model.summary())

6.訓練模型和生成Java代碼

上面，我還包含了堆疊另一層 LSTM 并使其成為 2 層 LSTM RNN 的代碼。

sample 函數用于從概率數組中采樣一個索引。例如，給定 preds=[0.5,0.2,0.3] 和默認溫度，函數返回索引 0 的概率為 0.5、1 的概率為 0.2 或 2 的概率為 0.3。它用于避免一遍又一遍地生成相同的句子。我們希望看到 AI 程序員可以編寫的一些不同的代碼序列。

def sample(preds, temperature=1.0):
    # helper function to sample an index from a probability array
    preds = np.asarray(preds).astype('float64')
    preds = np.log(preds) / temperature
    exp_preds = np.exp(preds)
    preds = exp_preds / np.sum(exp_preds)
    probas = np.random.multinomial(1, preds, 1)
    return np.argmax(probas)
 
# train the model, output generated code after each iteration
for iteration in range(1, 60):
    print()
    print('-' * 50)
    print('Iteration', iteration)
    model.fit(X, y, batch_size=128, epochs=1)
 
    start_index = random.randint(0, len(tokenized) - NUM_INPUT_TOKENS - 1)
 
    for diversity in [0.2, 0.5, 1.0, 1.2]:
        print()
        print('----- diversity:', diversity)
 
        generated = [] #''
        sequence = tokenized[start_index: start_index + NUM_INPUT_TOKENS]
 
        generated=list(sequence)
 
        print('----- Generating with seed: "' + ' '.join(sequence) + '"-------')
        sys.stdout.write(' '.join(generated))
 
        for i in range(100):
            x = np.zeros((1, NUM_INPUT_TOKENS, len(uniqueTokens)))
            for t, char in enumerate(sequence):
                x[0, t, token_indices[char]] = 1.
 
            preds = model.predict(x, verbose=0)[0]
            next_index = sample(preds, diversity)
            next_pred_token = indices_token[next_index]
 
            generated.append(next_pred_token)
            sequence = sequence[1:]
            sequence.append(next_pred_token)
 
            sys.stdout.write(next_pred_token+" ")
            sys.stdout.flush()
        print()

7. 結果

訓練模型需要幾個小時。我在第 40 次迭代時停止，生成的代碼如下所示：

----- Generating with seed: "true ) ; } else { boolean result = definesequals"-------
true ) ; } else { boolean result = definesequals
( ) . substring ( 1 , gradients . get ( p ) ; } 
if ( val . null || ( npoints == null ) ? new void . bitlength ( ) + prefixlength ) ; 
for ( int i = 0 ; i < num ; i ++ ) } break ; } 
if ( radix result = != other . off ) ; 
int endoff = b . append ( buf , 0 , len + 1 ) ; digits ++ ] ;

代碼生成看起來比以前基于字符的方法生成的代碼要好得多。請注意，為了便于閱讀，我添加了換行符。我們可以看到 LSTM 很好地捕獲了循環和條件，代碼開始變得更有意義。例如，“for ( int i = 0 ; i < num ; i ++ )” 是一個完美的 Java for循環。如果調整參數（如 NUM_INPUT_CHARS 和 STEP）并訓練更長時間，可能會得到更好的結果。隨意嘗試。

以上就是關于“Python如何構建單層LSTM模型”這篇文章的內容，相信大家都有了一定的了解，希望小編分享的內容對大家有幫助，若想了解更多相關的知識內容，請關注億速云行業資訊頻道。