2月14日學習內容2：循環神經網絡

來源：伯禹學習平臺

普適逼近定理

深度學習思想簡介

深度學習定義

循環神經網絡從零實現

#數據讀取
import torch
import torch.nn as nn
import time
import math
import sys
sys.path.append("/home/kesci/input")
import d2l_jay9460 as d2l
(corpus_indices, char_to_idx, idx_to_char, vocab_size) = d2l.load_data_jay_lyrics()
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
#定義one-hot向量
#x:一維向量，其中每一個元素都是一個字符的索引,維度爲n
#n_class:字典的大小
#指定返回想練個數值類型 
#函數最終返回值爲一個nxn_calss的矩陣
def one_hot(x, n_class, dtype=torch.float32):
    result = torch.zeros(x.shape[0], n_class, dtype=dtype, device=x.device)  # 全零矩陣shape: (n, n_class)
    #先把x的類型改爲long，再把x形狀修改爲nx1，然後把對應位置改寫爲數值1
    result.scatter_(1, x.long().view(-1, 1), 1)  # scatter功能：result[i, x[i, 0]] = 1。
    return result#最終每一行都是一個one_hot向量
    
x = torch.tensor([0, 2])
x_one_hot = one_hot(x, vocab_size)
print(x_one_hot)
print(x_one_hot.shape)
print(x_one_hot.sum(axis=1))
#我們每次採樣的小批量的形狀是（批量大小, 時間步數）。下面的函數將這樣的小批量變換成數個形狀爲（批量大小, 詞典大小）的矩陣，矩陣個數等於時間步數。也就是說，時間步的輸入爲，其中n爲批量大小，d爲詞向量大小，即one-hot向量長度（詞典大小）。
def to_onehot(X, n_class):
    return [one_hot(X[:, i], n_class) for i in range(X.shape[1])]

X = torch.arange(10).view(2, 5)
inputs = to_onehot(X, vocab_size)
print(len(inputs), inputs[0].shape)
#初始化參數模型
num_inputs, num_hiddens, num_outputs = vocab_size, 256, vocab_size
# num_inputs: d
# num_hiddens: h, 隱藏單元的個數是超參數
# num_outputs: q

def get_params():
    def _one(shape):
        param = torch.zeros(shape, device=device, dtype=torch.float32)
        nn.init.normal_(param, 0, 0.01)
        return torch.nn.Parameter(param)

    # 隱藏層參數
    W_xh = _one((num_inputs, num_hiddens))
    W_hh = _one((num_hiddens, num_hiddens))
    b_h = torch.nn.Parameter(torch.zeros(num_hiddens, device=device))
    # 輸出層參數
    W_hq = _one((num_hiddens, num_outputs))
    b_q = torch.nn.Parameter(torch.zeros(num_outputs, device=device))
    return (W_xh, W_hh, b_h, W_hq, b_q)
#定義模型
#rnn的前向計算
def rnn(inputs, state, params):
    # inputs和outputs皆爲num_steps個形狀爲(batch_size, vocab_size)的矩陣
    W_xh, W_hh, b_h, W_hq, b_q = params
    H, = state#狀態初始值
    outputs = []
    for X in inputs:
        H = torch.tanh(torch.matmul(X, W_xh) + torch.matmul(H, W_hh) + b_h)
        Y = torch.matmul(H, W_hq) + b_q
        outputs.append(Y)
    return outputs, (H,)
#函數init_rnn_state初始化隱藏變量，這裏的返回值是一個元組。
def init_rnn_state(batch_size, num_hiddens, device):
    return (torch.zeros((batch_size, num_hiddens), device=device), )
#做個簡單的測試來觀察輸出結果的個數（時間步數），以及第一個時間步的輸出層輸出的形狀和隱藏狀態的形狀。
print(X.shape)
print(num_hiddens)
print(vocab_size)
state = init_rnn_state(X.shape[0], num_hiddens, device)
inputs = to_onehot(X.to(device), vocab_size)
params = get_params()
outputs, state_new = rnn(inputs, state, params)
print(len(inputs), inputs[0].shape)
print(len(outputs), outputs[0].shape)
print(len(state), state[0].shape)
print(len(state_new), state_new[0].shape)
#裁剪梯度
#params:模型參數
#theta:預設閾值
#device:設備
def grad_clipping(params, theta, device):
    norm = torch.tensor([0.0], device=device)#記錄所有參數梯度的L2範數，初始值爲0	
    for param in params:
        norm += (param.grad.data ** 2).sum()
    norm = norm.sqrt().item()
    if norm > theta:
        for param in params:
            param.grad.data *= (theta / norm)
#定義預測函數
#給定參數params,前綴prefix,預測後num_chars的字符
def predict_rnn(prefix, num_chars, rnn, params, init_rnn_state,
                num_hiddens, vocab_size, device, idx_to_char, char_to_idx):
    state = init_rnn_state(1, num_hiddens, device)
    output = [char_to_idx[prefix[0]]]   # output記錄prefix加上預測的num_chars個字符
    for t in range(num_chars + len(prefix) - 1):
        # 將上一時間步的輸出作爲當前時間步的輸入
        X = to_onehot(torch.tensor([[output[-1]]], device=device), vocab_size)
        # 計算輸出和更新隱藏狀態
        (Y, state) = rnn(X, state, params)
        # 下一個時間步的輸入是prefix裏的字符或者當前的最佳預測字符
        if t < len(prefix) - 1:
            output.append(char_to_idx[prefix[t + 1]])
        else:
            output.append(Y[0].argmax(dim=1).item())
    return ''.join([idx_to_char[i] for i in output])
#測試
predict_rnn('分開', 10, rnn, params, init_rnn_state, num_hiddens, vocab_size,
            device, idx_to_char, char_to_idx)
#困惑度
#困惑度是對交叉熵損失函數做指數運算後得到的值。特別地，最佳情況下，模型總是把標籤類別的概率預測爲1，此時困惑度爲1；最壞情況下，模型總是把標籤類別的概率預測爲0，此時困惑度爲正無窮；基線情況下，模型總是預測所有類別的概率都相同，此時困惑度爲類別個數。顯然，任何一個有效模型的困惑度必須小於類別個數。在本例中，困惑度必須小於詞典大小vocab_size。
#定義模型訓練函數

#跟之前章節的模型訓練函數相比，這裏的模型訓練函數有以下幾點不同：

#使用困惑度評價模型。
#在迭代模型參數前裁剪梯度。
#對時序數據採用不同採樣方法將導致隱藏狀態初始化的不同。
def train_and_predict_rnn(rnn, get_params, init_rnn_state, num_hiddens,
                          vocab_size, device, corpus_indices, idx_to_char,
                          char_to_idx, is_random_iter, num_epochs, num_steps,
                          lr, clipping_theta, batch_size, pred_period,
                          pred_len, prefixes):
    if is_random_iter:#選擇採用方法
        data_iter_fn = d2l.data_iter_random
    else:
        data_iter_fn = d2l.data_iter_consecutive
    params = get_params()
    loss = nn.CrossEntropyLoss()

    for epoch in range(num_epochs):
        if not is_random_iter:  # 如使用相鄰採樣，在epoch開始時初始化隱藏狀態
            state = init_rnn_state(batch_size, num_hiddens, device)
        l_sum, n, start = 0.0, 0, time.time()
        data_iter = data_iter_fn(corpus_indices, batch_size, num_steps, device)
        for X, Y in data_iter:
            if is_random_iter:  # 如使用隨機採樣，在每個小批量更新前初始化隱藏狀態
                state = init_rnn_state(batch_size, num_hiddens, device)
            else:  # 否則需要使用detach函數從計算圖分離隱藏狀態
                for s in state:
                    s.detach_()
            # inputs是num_steps個形狀爲(batch_size, vocab_size)的矩陣
            inputs = to_onehot(X, vocab_size)
            # outputs有num_steps個形狀爲(batch_size, vocab_size)的矩陣
            (outputs, state) = rnn(inputs, state, params)
            # 拼接之後形狀爲(num_steps * batch_size, vocab_size)
            outputs = torch.cat(outputs, dim=0)
            # Y的形狀是(batch_size, num_steps)，轉置後再變成形狀爲
            # (num_steps * batch_size,)的向量，這樣跟輸出的行一一對應
            y = torch.flatten(Y.T)
            # 使用交叉熵損失計算平均分類誤差
            l = loss(outputs, y.long())
            #反向傳播
            # 梯度清0
            if params[0].grad is not None:
                for param in params:
                    param.grad.data.zero_()
            l.backward()
            grad_clipping(params, clipping_theta, device)  # 裁剪梯度
            d2l.sgd(params, lr, 1)  # 因爲誤差已經取過均值，梯度不用再做平均
            l_sum += l.item() * y.shape[0]
            n += y.shape[0]

        if (epoch + 1) % pred_period == 0:
            print('epoch %d, perplexity %f, time %.2f sec' % (
                epoch + 1, math.exp(l_sum / n), time.time() - start))
            for prefix in prefixes:
                print(' -', predict_rnn(prefix, pred_len, rnn, params, init_rnn_state,
                    num_hiddens, vocab_size, device, idx_to_char, char_to_idx))

時間步的輸入爲其中n爲批量大小，d爲詞向量大小，即one-hot向量長度（詞典大小）。