Un paquete de guía

import torch
from torch import nn
from torch.nn import functional as F
import dltools

1.1 Importar datos de entrenamiento

batch_size, num_steps = 32, 35
# 更改了默认的文件下载方式，需要将 article 文件放入该文件夹
train_iter, vocab = dltools.load_data_time_machine(batch_size, num_steps)

1.2 Construyendo una red neuronal

num_hiddens = 256
# 构造了一个具有256个隐藏神经单元的单隐藏层的循环神经网络
rnn_layer = nn.RNN(len(vocab), num_hiddens)

Se construye una capa de red neuronal recurrente (RNN) con las siguientes características:

num_hiddens = 256: Esta línea de código define la cantidad de unidades ocultas en la capa RNN , es decir, la cantidad de neuronas dentro de la capa RNN. En este ejemplo, se establece en 256, lo que significa que la capa RNN tendrá 256 unidades neuronales ocultas.
nn.RNN(len(vocab), num_hiddens): Esta línea de código crea una instancia de la capa RNN. Sus parámetros son los siguientes:
- len(vocab): Esta es la dimensión característica de los datos de entrada . En una red neuronal recurrente, los datos de entrada suelen ser una secuencia y la entrada en cada paso de tiempo es un vector. len(vocab)Representa el tamaño del vocabulario, que representa el número de entradas posibles en cada paso de tiempo de la secuencia. En las tareas de procesamiento del lenguaje natural, el tamaño del vocabulario suele corresponder al número de palabras diferentes en el vocabulario.
- num_hiddens: Este es el número de unidades ocultas dentro de la capa RNN , que es 256 según el valor previamente definido.

En resumen, este código crea una capa RNN de una sola capa oculta con 256 unidades neuronales ocultas . Esta capa RNN se puede utilizar para procesar datos de secuencia, como datos de texto, donde cada paso de tiempo puede corresponder a una palabra en un vocabulario o una representación incrustada de una palabra.

1.3 Inicializar estado oculto

# 初始化隐藏状态
state = torch.zeros((1, batch_size, num_hiddens))

Se crea un tensor de todos ceros como estado oculto . La forma del tensor es (1, batch_size, num_hiddens)donde:

1Indica el número de pasos de tiempo, lo que se inicializa aquí es el estado oculto de un paso de tiempo inicial.
batch_sizeRepresenta el tamaño del lote, es decir, el número de muestras procesadas a la vez.
num_hiddensRepresenta el número de unidades ocultas en cada paso de tiempo, es decir, la dimensión del estado oculto.

2. Construya una red neuronal recurrente completa

# 构建一个完整的循环神经网络
class RNNModel(nn.Module):
    def __init__(self, rnn_layer, vocab_size, **kwargs):
        super().__init__(**kwargs)
        self.rnn = rnn_layer
        self.vocab_size = vocab_size
        self.num_hiddens = self.rnn.hidden_size
        
        if not self.rnn.bidirectional:
            self.num_directions = 1
            self.linear = nn.Linear(self.num_hiddens, self.vocab_size)
        else:
            self.num_directions = 2
            self.linear = nn.Linear(self.num_hiddens * 2, self.vocab_size)
            
    # 前向传播
    def forward(self, inputs, state):
        X = F.one_hot(inputs.T.long(), self.vocab_size)
        X = X.to(torch.float32)
        Y, state = self.rnn(X, state)
        
        output = self.linear(Y.reshape(-1, Y.shape[-1]))
        return output, state
    
    # 初始化隐藏状态
    def begin_state(self, device, batch_size=1):
        return torch.zeros((self.num_directions * self.rnn.num_layers, batch_size, self.num_hiddens), device=device)

Esta sección define una RNNModelclase de modelo de PyTorch denominada , que es un modelo de red neuronal recurrente (RNN) para procesar datos de secuencia.

__init__Método: este es el constructor de la clase y se utiliza para inicializar los distintos componentes del modelo. Aquí se realizó el siguiente trabajo:
- super().__init__(**kwargs) Se llama al constructor de la clase principal para garantizar que el modelo se inicialice correctamente.
- self.rnn = rnn_layerAlmacena la capa RNN entrante .
- self.vocab_size = vocab_sizeSe almacena el tamaño del vocabulario .
- self.num_hiddens = self.rnn.hidden_sizeObtuvo el tamaño del estado oculto de la capa RNN .
- Dependiendo de si el RNN es bidireccional , opcionalmente se crea una capa lineal que asigna la salida del RNN a un espacio del tamaño de un vocabulario. En el caso de un RNN bidireccional, las dimensiones de la entrada son el doble del tamaño del estado oculto.
forwardMétodo : este método define el proceso de propagación hacia adelante . Acepta entradas inputsy el estado oculto actual state. En pase hacia adelante, hace lo siguiente:
- Úselo F.one_hotpara convertir la entrada inputsa una codificación one-hot para que coincida con el tamaño del vocabulario. Luego conviértalo en un tensor flotante.
- Pase los datos de entrada y el estado oculto a la capa RNN para obtener la salida Yy el nuevo estado ocultostate .
- Cambie la salida de RNN Ya un tensor bidimensional , luego self.linearasignelo a un espacio del tamaño de un vocabulario a través de una capa lineal y devuelva el resultado de salida.
begin_state Método: este método se utiliza para inicializar el estado oculto y devolver un tensor todo cero cuya forma depende de la cantidad de capas RNN, la cantidad de direcciones, la cantidad de unidades ocultas y el tamaño del lote.

2.1 Crear una instancia del modelo

# 在训练前，跑下模型
device = dltools.try_gpu()
net = RNNModel(rnn_layer, vocab_size=len(vocab))
net = net.to(device)

Creó un objeto RNNModel que acepta un rnn_layer y un tamaño de vocabulario como parámetros. Finalmente mueve el modelo al dispositivo previamente determinado.

Tres entrenamientos de ejecución.

# 训练
num_epochs, lr = 200, 0.1
dltools.train_ch8(net, train_iter, vocab, lr, num_epochs, device)

3.1 Ejecutar predicciones

dltools.predict_ch8('time traveller', 10, net, vocab, device)

02-pytorch implementa RNN