Hola, mundo en PyTorch

Notas adicionales:

import torch
import torch.nn as nn


class TextClassifier(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim):
        super().__init__()

        # Capa de embedding para mapear índices de palabras a vectores de embeddings
        self.embedding = nn.Embedding(vocab_size, embedding_dim)

        # Capa LSTM para procesar los embeddings y obtener estados ocultos
        self.rnn = nn.LSTM(embedding_dim, hidden_dim, num_layers=2, batch_first=True)

        # Capa lineal para proyectar el último estado oculto en la salida final
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, text):
        # Obtener los embeddings de las palabras
        embedded = self.embedding(text)

        # Propagar los embeddings a través de la capa LSTM
        output, (hidden, cell) = self.rnn(embedded)

        # Seleccionar el último estado oculto como estado final
        final_hidden = hidden[-1]

        # Pasar el estado final a través de la capa lineal para obtener la salida final
        return self.fc(final_hidden)


# Parámetros del modelo
vocab_size = 10000
embedding_dim = 100
hidden_dim = 256
output_dim = 2

# Crear instancia del modelo
model = TextClassifier(vocab_size, embedding_dim, hidden_dim, output_dim)

# Imprimir la estructura del modelo
print(model)

Respuesta esperada:

TextClassifier(
  (embedding): Embedding(10000, 100)
  (rnn): LSTM(100, 256, num_layers=2, batch_first=True)
  (fc): Linear(in_features=256, out_features=2, bias=True)
)

Process finished with exit code 0

Expliquemos el código paso a paso:

1. Se importan las bibliotecas necesarias: torch para el uso de PyTorch y torch.nn para las capas y funciones de redes neuronales.

2. Se define la clase TextClassifier, que es una subclase de nn.Module, la cual es la base para definir modelos de PyTorch.

3. En el método __init__ de la clase TextClassifier, se definen los componentes del modelo. Los parámetros que recibe son:

   • vocab_size: Tamaño del vocabulario, es decir, la cantidad de palabras únicas en el corpus de texto.
   • embedding_dim: Dimensión de los vectores de embeddings. Cada palabra será representada por un vector de esta dimensión.
   • hidden_dim: Dimensión de los estados ocultos de la capa LSTM.
   • output_dim: Dimensión de la salida del clasificador.
   • En el cuerpo del método, se definen tres capas:
   • self.embedding: Una capa de embedding (nn.Embedding) que mapea cada índice de palabra a un vector de embeddings de tamaño embedding_dim.
   • self.rnn: Una capa LSTM (nn.LSTM) que recibe los embeddings y produce secuencias de estados ocultos. Tiene num_layers=2 capas LSTM apiladas y batch_first=True indica que la entrada se proporcionará en el formato (batch_size, sequence_length, input_size).
   • self.fc: Una capa lineal (nn.Linear) que proyecta el último estado oculto de la capa LSTM (hidden_dim) en la dimensión de salida (output_dim).

4. En el método forward de la clase TextClassifier, se define cómo se propagan los datos a través del modelo. El parámetro text representa las secuencias de palabras de entrada.

   • Primero, los embeddings de las palabras se obtienen utilizando self.embedding y se almacenan en embedded.
   • A continuación, embedded se pasa a través de la capa LSTM (self.rnn) y se obtienen output, hidden y cell. output contiene los estados ocultos de todas las palabras de la secuencia, mientras que hidden y cell contienen los estados finales de la capa LSTM.
   • El último estado oculto hidden[-1] se selecciona como el estado oculto final y se pasa a través de la capa lineal (self.fc) para obtener la salida final del clasificador.
   • La salida final se devuelve.

5. A continuación, se definen los parámetros para construir una instancia del modelo. vocab_size se establece en 10000, embedding_dim en 100, hidden_dim en 256 y output_dim en 2.

6. Se crea una instancia del modelo TextClassifier utilizando los parámetros definidos.

7. Finalmente, se imprime el modelo creado. Esto mostrará la estructura del modelo, incluyendo las capas y sus dimensiones.

Les compartos algunas definiciones de los parametros que se necesitan para crear una red neuronal LSTM en Pytorch

1. input_size: Especifica la dimensión del espacio de características de entrada. Indica el tamaño del vector de características de cada elemento de la secuencia de entrada. Por ejemplo, si cada elemento de la secuencia de entrada es un vector de 10 dimensiones, input_size sería igual a 10.

2. hidden_size: Define la dimensión del espacio de características ocultas. Determina el número de unidades de memoria en la capa LSTM. Cuanto mayor sea el valor de hidden_size, más capacidad tendrá la capa para capturar patrones complejos en los datos, pero también requerirá más recursos computacionales. Es un hiperparámetro que debes ajustar según las necesidades y la complejidad del problema.

3. num_layers: Indica el número de capas LSTM apiladas una encima de la otra. Puedes tener una sola capa LSTM o múltiples capas apiladas para construir una red LSTM más profunda. Las capas LSTM adicionales pueden ayudar al modelo a aprender representaciones jerárquicas y patrones de mayor complejidad en los datos.

4. batch_first: Un valor booleano que indica el formato de entrada y salida de los datos. Si se establece en True, los datos se esperan en el formato (batch_size, sequence_length, input_size), lo que significa que la dimensión del lote se coloca en primer lugar. Si se establece en False, el formato esperado es (sequence_length, batch_size, input_size). Esto depende de cómo estén estructurados tus datos y cómo prefieras trabajar con ellos.

Cuesta bastante seguir la clase, en el sentido de saber hacia donde se quiere ir, más allá de lo obvio que se comenta en la clase.

Yo cómo alguien con una mente muy dispersa y con muy poca tolerancia a la frustración recomiendo mucho tomarse su tiempo en cada clase, aprovechar que se está trabajando desde las primeras e ir preguntando a ChatGpt sobre porque puso esa linea de código o hacia dónde se quiere ir, me hace avanzar más lento pero de verdad cuándo acabas te da un sentido de satisfacción enorme saber si estás aprendiendo y que no solamente acabas los videos por acabarlos, y además que puedes reutilizar el bosquejo general del código en algún otro proyecto una vez que lo entiendes mejor