Notas de estudio de redes neuronales 9: comprensión del modelo LSTM y GRU y análisis de código en redes neuronales recurrentes

Directorio de artículos de la serie

Referencia de vídeo de LSTM

Video de referencia GRU

---

---

prefacio

Recurrent Neural Network (RNN) es una red neuronal para procesar datos de secuencias. En comparación con la red neuronal general, puede manejar los datos del cambio de secuencia. Por ejemplo, el significado de una palabra tendrá diferentes significados debido al diferente contenido mencionado anteriormente, y RNN puede resolver bien esos problemas.
LSTM es un tipo de RNN, que puede resolver el problema de la desaparición del gradiente y la explosión del gradiente en el proceso de entrenamiento de secuencia larga de RNN. Cuando una secuencia es lo suficientemente larga, será difícil para RNN transferir información de pasos de tiempo anteriores a tiempos posteriores. LSTM puede aprender información dependiente a largo plazo y recordar información de pasos de tiempo anteriores, por lo que puede asociarse con el contexto.
A diferencia de RNN, RNN quiere recordar toda la información y no le importa si es útil o no. LSTM diseña una celda de memoria, que funciona como una función de detección y tiene la función de seleccionar la memoria, que se utiliza para seleccionar y recordar información importante, para filtrar el ruido e información no importante para reducir la carga de memoria. Su apariencia resuelve el problema de la distorsión del gradiente. Además, la velocidad de convergencia de RNN es mucho más rápida que la de RNN ordinaria.

El concepto central de LSTM es el estado de la celda y la estructura de "puerta". El estado de la celda es equivalente a la ruta de transmisión de información, por lo que la información se puede transmitir en la conexión en serie. Puede considerarlo como la "memoria" de la red. Teóricamente, el estado de la celda puede transportar información relevante durante todo el proceso de secuencia.

GRU (Gate Recurrent Unit) es un tipo de red neuronal recurrente (RNN), que puede resolver los problemas de RNN que no pueden ser memoria a largo plazo y gradiente en backpropagation. Es similar a LSTM, pero es más simple que LSTM y fácil entrenar. Es muy similar a LSTM En comparación con LSTM, GRU elimina el estado de la celda y usa el estado oculto para transmitir información. Contiene solo dos puertas: la puerta de actualización y la puerta de reinicio.

GRU es una variante de LSTM y también se propone para resolver problemas como la memoria a largo plazo y el gradiente en la retropropagación. En muchos casos, GRU y LSTM tienen casi el mismo rendimiento, pero el cálculo de GRU es más simple y fácil de implementar.

1. Estructura del modelo LSTM

estructura RNN

estructura LSTM

El modelo LSTM se compara con el modelo RNN:

1. $X_{}$La complejidad de la estructura del modelo de la posición varía mucho
2. LSTM tiene dos salidas, RNN tiene solo una salida

Ponga $X_{}$Sácalo por separado, donde
$C$ significa celda de memoria, la fórmula es Cell State
$h$ significa estado
$X$ significa contenido nuevo
$\sigma$ representa la unidad de puerta
$F_{}$Forget Gate, la fórmula es Forget Gate
$i_{}$Puerta de entrada, la fórmula es Puerta de entrada
$o_{}$Puerta de salida, la fórmula es Puerta de salida

frente $F_{}$，$i_{}$，$o_{}$Se puede encontrar que sus leyes son $s(W\times X_{}+W\times h_{t-}+b)$ tipo. De acuerdo con el diagrama de estructura del modelo anterior, se puede encontrar que$(X_{},h{}_{}-1)$ se ingresará en la puerta σ, por lo que los valores X y h de las tres puertas son los mismos. A través de$(X_{},h{}_{}-1)$ Se pueden calcular$F_{}$，$i_{}$，$\tilde{C}$y $o_{}$. donde $tanh$ es la función de activación y cada elemento de su vector de salida está entre -1~1,$W,b$ es el parámetro de cada neurona de puerta, que se aprenderá durante el proceso de entrenamiento.

1. Forget Gate : decide qué información se debe descartar o conservar. La información del estado oculto anterior y la información de entrada actual se pasan a la función sigmoide al mismo tiempo, y el valor de salida está entre 0 y 1. Cuanto más cerca de 0 significa que debe descartarse, y cuanto más cerca de 1 significa que debe conservarse. ft se obtendrá f_t$F_{}$con entrada $C_{t-}$Multiplica, es decir, multiplicación de vectores.
2. Puertas de entrada : las puertas de entrada se utilizan para actualizar el estado de la celda. Primero, la información del estado oculto de la capa anterior y la información de la entrada actual se pasan a la función sigmoide. Ajuste el valor entre 0~1 para decidir qué información actualizar. 0 significa sin importancia, 1 significa importante, $i_{}$valor. En segundo lugar, la información del estado oculto de la capa anterior y la información de la entrada actual deben pasarse a la función tanh para crear un nuevo vector de valor candidato y obtener $\tilde{C}$valor. Finalmente, el valor de salida de sigmoid y el valor de salida de tanh $i_{}$y $\tilde{C}$Multiplicación, es decir, multiplicación de vectores, donde el valor de salida de sigmoid determinará qué información en el valor de salida de tanh es importante y debe conservarse. La información a retener se agregará a la salida obtenida por la puerta de olvido, y finalmente una nueva celda de memoria $C_{}=(f_{}⨀C_{t-})+({yo}_{}⨀\tilde{C})$
3. Puerta de salida : la puerta de salida se utiliza para determinar el valor del siguiente estado oculto, que contiene la información de la entrada anterior. Primero, pasamos el estado oculto anterior y la entrada actual a la función sigmoide, y luego pasamos el estado de celda recién obtenido a la función tanh. Finalmente, la salida de tanh se multiplica por la salida de sigmoid, es decir, la multiplicación de vectores, para determinar la información que debe llevar el estado oculto. Luego use el estado oculto como salida de la celda actual, y use el nuevo estado de celda y el nuevo estado oculto $h_{}$pasó al siguiente paso de tiempo. Es decir, las celdas de memoria recién obtenidas $C_{}$Pase tanh para el cálculo del peso ${metro}_{}=yo\left(mayor\right){}_{})$ , entonces$o_{}$Según el peso ${metro}_{}$Calcule el nuevo estado oculto $h_{}=o_{}⨀{metro}_{}$, para controlar qué parte debe generarse y qué parte es la respuesta que necesitamos.

2. Estructura del modelo GRU

Expresión de fórmula:

$z_{}=s(W_x\times X_{}+W_h\times h_{t-}+b_{})$
$r_{}=s(W_x\times X_{}+W_{hora}\times h_{t-}+b_{})$
${\tilde{h}}_{}=Inglés(W\_{}_x\times X_{}+W_{}\times (r_{}⨀h_{t-})+b_{})$
$h_{}=(1-z_{})⨀h_{t-}+z_{}⨀{\tilde{h}}_{}$

GRU solo tiene dos puertas. La combinación de la puerta de entrada y la puerta de olvido en LSTM se denomina puerta de actualización. La fórmula es $z_{}$, mientras que otra fórmula llamada puerta de reinicio es $r_{}$.
Se puede observar que las fórmulas de las dos puertas también son $s(W\times X_{}+W\times h_{t-}+b)$ tipo, pero aquí${\tilde{h}}_{}$y C de LSTM $\tilde{C}$Diferente, LSTM's $\tilde{C}$es por $h_{t-},X_{}$Compuesto de, mientras que GRU's ${\tilde{h}}_{}$viene dada por $（r_{}⨀h_{t-}),X_{}$consiste en. donde $tanh$ es la función de activación y cada elemento de su vector de salida está entre -1~1,$W,b$ es el parámetro de cada neurona de puerta, que se aprenderá durante el proceso de entrenamiento.

1. actualizar puerta $z_{}$: Un mecanismo que juega un papel de atención, utilizado para controlar el grado en que la información del estado del momento anterior se lleva al estado actual, es decir, la puerta de actualización ayuda al modelo a decidir cuánta información pasada pasar al futuro. , en términos simples, se utiliza para actualizar la memoria.
2. restablecer puerta $r_{}$: El mecanismo que juega un papel en el olvido, determina cómo combinar la nueva información de entrada con los recuerdos anteriores, controla cuánta información pasada olvidar, hace que el estado oculto olvide cualquier información que no esté relacionada con las predicciones en el futuro y también permite la construcción de una representación más estrecha.

3. Comparación entre GRU y LSTM

ventaja:

1. En comparación con LSTM, GRU tiene menos puertas de salida, sus parámetros son menores que LSTM y la cantidad de cálculo es menor que LSTM. Es más simple, más fácil de implementar y puede entrenar el modelo más rápido;
2. GRU tiene solo dos puertas, LSTM tiene tres puertas, GRU es más fácil de controlar los parámetros y más fácil de ajustar;

defecto:

1. GRU no tiene una capacidad de memoria tan fuerte como LSTM, y para problemas de dependencia a largo plazo, LSTM es estrictamente más fuerte que GRU porque puede contar fácilmente infinitamente, mientras que GRU no puede. Esta es la razón por la que las GRU no pueden aprender lenguajes simples, que los LSTM pueden aprender;
2. GRU no tiene tantos parámetros como LSTM y es propenso a fallar.

4. Implementación del código

1. código GRU

Del aprendizaje profundo práctico

import torch
from torch import nn
from d2l import torch as d2l

batch_size, num_steps = 32, 35
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)

def get_params(vocab_size, num_hiddens, device):
    num_inputs = num_outputs = vocab_size

    def normal(shape):
        return torch.randn(size=shape, device=device)*0.01

    def three():
        # torch.normal：返回一个张量，包含从给定参数num_inputs, num_hiddens的离散正态分布中抽取随机数
        # torch.zeros：创建num_hiddens大小的维度，里面元素全部填充为0device输出张量的设备
        return (normal((num_inputs, num_hiddens)),
                normal((num_hiddens, num_hiddens)),
                torch.zeros(num_hiddens, device=device))

    # 初始化模型参数，定义更新门z_t、重置门r_t和隐藏态h_t公式的训练参数
    # 通过def three()给这些参数定义随机数和和0矩阵
    W_xz, W_hz, b_z = three()  # 更新门参数
    W_xr, W_hr, b_r = three()  # 重置门参数
    W_xh, W_hh, b_h = three()  # 候选隐状态参数

    # 输出层参数
    W_hq = normal((num_hiddens, num_outputs))
    b_q = torch.zeros(num_outputs, device=device)

    # requires_grad：附加梯度，设置参数为True，程序将会追踪所有对于该张量的操作
    # 当完成计算后通过调用 .backward()，自动计算所有的梯度， 这个张量的所有梯度将会自动积累到 .grad 属性。
    params = [W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q]
    for param in params:
        param.requires_grad_(True)
    return params

# 定义隐状态的初始化函数，返回一个形状为（批量大小，隐藏单元个数）的张量，张量的值全部为零
def init_gru_state(batch_size, num_hiddens, device):
    return (torch.zeros((batch_size, num_hiddens), device=device),)

def gru(inputs, state, params):
    # 使用的是有梯度的训练参数
    W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q = params
    H, = state
    outputs = []

    # 公式的复现
    # torch.sigmoid将样本值映射到0到1之间。
    for X in inputs:
        Z = torch.sigmoid((X @ W_xz) + (H @ W_hz) + b_z)
        R = torch.sigmoid((X @ W_xr) + (H @ W_hr) + b_r)
        H_tilda = torch.tanh((X @ W_xh) + ((R * H) @ W_hh) + b_h)
        H = Z * H + (1 - Z) * H_tilda
        Y = H @ W_hq + b_q
        outputs.append(Y)
    # torch.cat：将两个张量按指定维度拼接在一起
    return torch.cat(outputs, dim=0), (H,)

vocab_size, num_hiddens, device = len(vocab), 256, d2l.try_gpu()
num_epochs, lr = 500, 1
model = d2l.RNNModelScratch(len(vocab), num_hiddens, device, get_params,
                            init_gru_state, gru)
d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device)