Datasets y DataLoaders personalizados
torch.utils.data.Dataset, __len__/__getitem__, DataLoader, transforms y aumento de datos.
Datasets y DataLoaders personalizados es una lección gratuita de Learn AI with Python en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn AI with Python, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn AI with Python incluye 4 lecciones en total.
Introducción de datos en un modelo
El entrenamiento necesita una forma eficiente de leer, transformar y agrupar los datos por lotes. PyTorch proporciona dos abstracciones: Dataset (sabe cómo obtener una muestra) y DataLoader (las agrupa y las mezcla).
from torch.utils.data import Dataset, DataLoaderLa interfaz Dataset
Una subclase personalizada de Dataset debe implementar dos métodos: __len__ (cuántas muestras contiene) y __getitem__ (devuelve la muestra situada en un índice). PyTorch los llama para extraer los datos.
Implementación de __len__
__len__ indica a PyTorch el tamaño del conjunto de datos, para que sepa cuántos índices existen y cuántos lotes contiene una época.
class ImageDataset(Dataset):
def __init__(self, paths, labels):
self.paths = paths
self.labels = labels
def __len__(self):
return len(self.paths)Implementación de __getitem__
__getitem__ carga y devuelve una muestra (y su etiqueta) a partir de un índice. Aquí es donde abre un archivo de imagen y lo convierte en un tensor.
from PIL import Image
def __getitem__(self, idx):
img = Image.open(self.paths[idx]).convert("RGB")
label = self.labels[idx]
return img, label¿Por qué usar transformaciones?
Las imágenes sin procesar varían en tamaño y rango de píxeles. Las transformaciones las estandarizan: cambian su tamaño a una forma fija, las convierten en tensores y normalizan los valores de los píxeles para que el modelo entrene de forma estable.
from torchvision import transformstransforms.Compose
transforms.Compose encadena varias transformaciones en una única canalización que se aplica en orden. Una cadena habitual es Resize, después ToTensor y luego Normalize.
tf = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])Comprensión de las transformaciones
Resize fija el tamaño espacial; ToTensor convierte una imagen PIL en un tensor y escala los píxeles al intervalo [0,1]; Normalize desplaza y escala cada canal para obtener media cero y varianza unitaria, lo que acelera la convergencia.
Aplicación de transformaciones en el Dataset
Pase la transformación al conjunto de datos y aplíquela dentro de __getitem__ para preprocesar todas las muestras de forma coherente a medida que se obtienen.
class ImageDataset(Dataset):
def __init__(self, paths, labels, transform):
self.paths, self.labels, self.transform = paths, labels, transform
def __getitem__(self, idx):
img = Image.open(self.paths[idx]).convert("RGB")
return self.transform(img), self.labels[idx]Envolver en un DataLoader
El DataLoader convierte un Dataset en un iterable de lotes. Establezca batch_size para controlar cuántas muestras hay en cada paso y shuffle=True para aleatorizar el orden en cada época, algo importante durante el entrenamiento.
dataset = ImageDataset(paths, labels, tf)
loader = DataLoader(dataset, batch_size=32, shuffle=True)num_workers para acelerar el proceso
num_workers crea subprocesos paralelos para cargar y transformar datos mientras la GPU entrena, ocultando la latencia de E/S. Un valor como 4 suele mantener la GPU ocupada en lugar de hacerla esperar.
loader = DataLoader(
dataset,
batch_size=32,
shuffle=True,
num_workers=4
)Iteración sobre lotes
Recorra el DataLoader para obtener tensores agrupados por lotes. Cada iteración produce (images, labels), donde images tiene la forma [batch_size, channels, H, W], lista para el modelo.
for images, labels in loader:
print(images.shape) # torch.Size([32, 3, 224, 224])
breakComprobación rápida
Ponga a prueba sus conocimientos sobre canalizaciones de datos.
Repaso: Datasets y DataLoaders
Creó un Dataset personalizado con __len__ y __getitem__, preprocesó imágenes mediante transforms.Compose (Resize, ToTensor y Normalize) y lo envolvió en un DataLoader con batch_size, shuffle y num_workers para proporcionar lotes al modelo de forma eficiente.
Preguntas frecuentes
¿La lección «Datasets y DataLoaders personalizados» es gratis?
Sí — el texto completo de «Datasets y DataLoaders personalizados» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn AI with Python, actualiza a CoddyKit PRO. El curso de Learn AI with Python incluye 4 lecciones en total.
¿Qué aprenderé en «Datasets y DataLoaders personalizados»?
torch.utils.data.Dataset, __len__/__getitem__, DataLoader, transforms y aumento de datos. Practicas Learn AI with Python con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Learn AI with Python?
No se requiere experiencia previa. Learn AI with Python en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Datasets y DataLoaders personalizados»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Learn AI with Python?
Sí. Cada lección de Learn AI with Python incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Tensores y Autograd de PyTorch
- Datasets y DataLoaders personalizados
- Construcción y entrenamiento de CNN con PyTorch
- Detección de objetos con YOLOv8