No tienes acceso a esta clase

¬°Contin√ļa aprendiendo! √önete y comienza a potenciar tu carrera

Hola, mundo en PyTorch

3/24
Recursos

Aportes 6

Preguntas 1

Ordenar por:

¬ŅQuieres ver m√°s aportes, preguntas y respuestas de la comunidad?

o inicia sesión.

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.

estoy creando nueva arquitectura de Deep learning inspirada en los modelos Transformers donde el sistema aprende a recordar lo que ya ha hecho y utiliza esta información para sus futuras predicciones y para su aprendizaje, por el momento llevo solo la teoría estoy aprendiendo.

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

Clase de 13 min de videos, pero de 1 hora de pr√°ctica Buen video!!