Fundamentos de PyTorch

1

Clasificación de Texto con PyTorch y TorchText

2

Creación de modelos con PyTorch para IA moderna

3

Clasificación de Texto con PyTorch y Redes Neuronales Recurrentes

4

Manipulación de Tensores en PyTorch: Escalares a Multidimensionales

5

Debugging de Tensores en PyTorch: Tipos, Formas y Dispositivos

6

Operaciones entre Arrays NumPy y Tensores PyTorch

Quiz: Fundamentos de PyTorch

Estructura de modelo de deep learning en PyTorch

7

Regresión Lineal con PyTorch: Creación y Entrenamiento de Modelos

8

Regresión Lineal en PyTorch: Creación y Primeras Predicciones

9

Regresión Lineal con PyTorch: Pérdidas y Optimizadores

10

Visualización de pérdidas en entrenamiento con PyTorch

11

Predicciones con PyTorch usando CPU y graficación de resultados

Quiz: Estructura de modelo de deep learning en PyTorch

Redes neuronales con PyTorch

12

Clasificación de Texto con PyTorch y TorchText

13

Tokenización y Creación de Vocabulario con Torch Text

14

Creación de Data Loaders en PyTorch: Procesa Grandes Datasets Eficazmente

15

Modelo de Clasificación de Texto en PyTorch: Creación y Entrenamiento

16

Optimización de Modelos de Clasificación en Python

17

Creación y uso de funciones de evaluación en modelos de aprendizaje

18

Optimización y Funciones de Pérdida en Deep Learning

19

Entrenamiento de Modelos con PyTorch: Optimización y Validación

20

Inferencia de Modelos con PyTorch 2.0 y Torch Compile

21

Guardar y cargar modelos en PyTorch con checkpoints

22

Subir Modelos a JoggingFace: Repositorios y Comunidad Platzi

23

Optimización de modelos en PyTorch: carga y gestión de checkpoints

Quiz: Redes neuronales con PyTorch

Cierre del curso

24

Manejo de Tensores y Modelos con PyTorch

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Creación de Data Loaders en PyTorch: Procesa Grandes Datasets Eficazmente

14/24
Recursos

¿Qué es un Data Loader y cuál es su función en PyTorch?

Los Data Loaders en PyTorch son herramientas esenciales para el procesamiento eficiente de grandes conjuntos de datos. Estos permiten dividir datasets extensos en pequeños lotes llamados "batches". Esta estrategia no solo optimiza el uso de la memoria, sino que también faciilta el paralelismo a través de múltiples GPUs, si es necesario. Al dividir el dataset, los Data Loaders permiten que el entrenamiento de modelos sea más manejable y escalable.

¿Cómo se define un Data Loader en PyTorch?

Para definir un Data Loader en PyTorch, se requieren importar ciertas librerías y planificar varios pasos. A continuación, se expone cómo proceder:

  1. Importación de la librería:

    from torch.utils.data import DataLoader
    

    Esto permite el acceso al objeto DataLoader para su uso posterior.

  2. Definición del dataset: Se utiliza un dataset de entrenamiento, en este caso un iterador llamado trainIter del dataset DBpedia, especificando su uso para el set de entrenamiento:

    trainIter = DBpedia(split='train')
    
  3. Creación del Data Loader: Aquí se establece el tamaño del lote, se elige si se quiere aleatorizar la secuencia de los datos (shuffling) y se selecciona una función collate:

    data_loader = DataLoader(dataset=trainIter, batch_size=8, shuffle=False, collate_fn=collateBatch)
    

¿Cómo definimos una función collate para recopilar los datos?

La función collate, denominada aquí collateBatch, es crucial para combinar los datos de los lotes. Esta función permite agrupar diferentes elementos del dataset en un único tensor manejable. A continuación se explica cómo implementarla:

  1. Configuración del dispositivo: Determina si se usará CPU o GPU (CUDA) según la disponibilidad.

    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    
  2. Definición de collateBatch: Desarrollar una función collateBatch para procesar cada lote.

    def collateBatch(batch):
        label_list, text_list, offsets = [], [], [0]
        for (_label, _text) in batch:
            label_list.append(label_pipeline(_label))
            processed_text = torch.tensor(text_pipeline(_text), dtype=torch.int64)
            text_list.append(processed_text)
            offsets.append(processed_text.size(0) + offsets[-1])
        
        label_list = torch.tensor(label_list, dtype=torch.int64).to(device)
        text_list = torch.cat(text_list).to(device)
        offsets = torch.tensor(offsets[:-1]).to(device)
        return label_list, text_list, offsets
    
    • Listas vacías: Se declaran listas vacías label_list, text_list, y una lista offsets inicializada en 0.
    • Recorrido de batch: Se itera sobre cada texto, obteniendo y procesando etiquetas y textos para almacenarlos adecuadamente.
    • Transformación a tensores: Las listas se convierten a tensores adecuados para PyTorch y se llevan al dispositivo correspondiente (CPU o CUDA).

¿Cómo mejora la suma acumulativa cumsum el manejo de datos?

La función cumsum en PyTorch proporciona la suma acumulativa de los elementos a lo largo de una dimensión especificada. En este contexto, se utiliza para determinar los puntos de inicio de cada nuevo texto dentro del tensor de datos concatenados. Este método es vital para gestionar adecuadamente el flujo de datos en estructuras de texto:

  • Función cumsum:
    offsets = torch.tensor(offsets[:-1]).cumsum(dim=0).to(device)
    
    Al aplicar cumsum, se asegura que cada elemento en offsets indique el comienzo del siguiente texto en la fila de datos concatenados.

El uso de Data Loaders es una técnica poderosa que merece ser dominada para optimizar el rendimiento en proyectos de machine learning y deep learning. Aprender y practicar su implementación expandirá tus habilidades y te permitirá abordar proyectos más avanzados con confianza. ¡Sigue aprendiendo e investigando!

Aportes 4

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Para preparar un `DataLoader` en PyTorch, primero necesitas un conjunto de datos adecuado y luego crear un `DataLoader` que pueda iterar sobre ese conjunto de datos en mini-batches. El `DataLoader` es una herramienta muy útil que permite manejar la carga de datos, la aleatorización y el agrupamiento de muestras. Aquí te muestro cómo puedes hacerlo utilizando un conjunto de datos de texto, como el de AG News, y cómo crear un `DataLoader`: \### Paso 1: Importar las librerías necesarias ```python import torch from torchtext.datasets import AG\_NEWS from torchtext.data.utils import get\_tokenizer from torch.utils.data import DataLoader from torchtext.vocab import build\_vocab\_from\_iterator ``` \### Paso 2: Cargar el conjunto de datos ```python \# Cargar el conjunto de datos AG News train\_iter = AG\_NEWS(split='train') ``` \### Paso 3: Crear un tokenizador y construir el vocabulario ```python \# Crear un tokenizador tokenizador = get\_tokenizer('basic\_english') \# Función para generar tokens def yield\_tokens(data\_iter): for \_, texto in data\_iter: yield tokenizador(texto) \# Construir el vocabulario vocab = build\_vocab\_from\_iterator(yield\_tokens(train\_iter), specials=\["\<unk>"]) vocab.set\_default\_index(vocab\["\<unk>"]) ``` \### Paso 4: Preparar los datos para el DataLoader Para usar el `DataLoader`, necesitas definir cómo quieres convertir cada texto en una secuencia de índices basada en el vocabulario. Esto puede implicar la conversión de textos en tensores. ```python \# Cargar de nuevo el conjunto de datos para que esté fresco train\_iter = AG\_NEWS(split='train') \# Función para convertir texto en índices de vocabulario def process\_text(text): return torch.tensor(\[vocab\[token] for token in tokenizador(text)], dtype=torch.int64) \# Crear una lista de tuplas (texto procesado, etiqueta) data = \[(process\_text(text), label) for label, text in train\_iter] ``` \### Paso 5: Crear el DataLoader ```python \# Crear un DataLoader batch\_size = 16 # Puedes ajustar el tamaño del batch data\_loader = DataLoader(data, batch\_size=batch\_size, shuffle=True) \# Ejemplo de iterar sobre el DataLoader for batch in data\_loader: texts, labels = batch print("Batch de textos:", texts) print("Batch de etiquetas:", labels) break # Solo mostramos el primer batch ``` \### Resumen 1\. \*\*Cargar el conjunto de datos:\*\* Puedes utilizar cualquier conjunto de datos de texto compatible. 2\. \*\*Tokenizar y construir vocabulario:\*\* Convierte los textos en índices que el modelo puede entender. 3\. \*\*Preparar los datos:\*\* Asegúrate de que cada texto está representado como un tensor. 4\. \*\*Crear el DataLoader:\*\* Esto facilita el procesamiento por lotes y la aleatorización. Esto te permitirá gestionar fácilmente tus datos durante el entrenamiento del modelo en PyTorch.
```python device = torch.device( "cuda" if torch.cuda.is_available() else "cpu") #cambiar de cpu a gpu de forma manual #Batch de textos 8 def collate_batch(batch): label_list=[] #etiqueta text_list=[] # textos batch offsets=[0] # posicion de incio for (_label, _text) in batch: label_list.append(label_pipeline(_label)) processed_text = torch.tensor(texto_pipeline(_text),dtype=torch.int64) text_list.append(processed_text) offsets.apped(processed_text.size(0)) label_list = torch.tensor(label_list, dtype=torch.int64) offsets = torch.tensor(offsets[:-1]).cumsum(dim=0) #delimite text_list = torch.cat(text_list) return label_list.to(device), text_list.to(device), offsets.to(device) ```device = torch.device( "cuda" if torch.cuda.is\_available() else "cpu") #cambiar de cpu a gpu de forma manual#Batch de textos 8def collate\_batch(batch):  label\_list=\[]   #etiqueta  text\_list=\[]    # textos batch  offsets=\[0]     # posicion de incio    for (\_label, \_text) in batch:    label\_list.append(label\_pipeline(\_label))    processed\_text = torch.tensor(texto\_pipeline(\_text),dtype=torch.int64)    text\_list.append(processed\_text)    offsets.apped(processed\_text.size(0))   label\_list = torch.tensor(label\_list, dtype=torch.int64)  offsets = torch.tensor(offsets\[:-1]).cumsum(dim=0) #delimite  text\_list = torch.cat(text\_list)  return label\_list.to(device), text\_list.to(device), offsets.to(device)
No se puede leer el codigo tan abajo por la barra de reproduccion.
🤔 el loop de `collate_batch` en list comprehension, quizas solo sea necesario definir la lista `offsets` antes `label_list = [label_pipeline(_label) for _label, _text in batch]` `text_list = [torch.tensor(texto_pipeline(_text), dtype=torch.int64) for _label, _text in batch]` `offsets = [processed_text.size(0) for processed_text in text_list]`