Conjuntos de dados e DataLoaders personalizados
torch.utils.data.Dataset, __len__/__getitem__, DataLoader, transformações e aumento de dados.
Conjuntos de dados e DataLoaders personalizados é uma aula grátis de Learn AI with Python no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn AI with Python, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn AI with Python inclui 4 aulas no total.
Fornecendo dados a um modelo
O treinamento precisa de uma forma eficiente de ler, transformar e agrupar dados em lotes. O PyTorch fornece duas abstrações: conjunto de dados (sabe como buscar uma amostra) e DataLoader (agrupa as amostras em lotes e as embaralha).
from torch.utils.data import Dataset, DataLoaderA interface do conjunto de dados
Uma subclasse personalizada de Dataset deve implementar dois métodos: __len__ (quantas amostras existem) e __getitem__ (retorna a amostra em um índice). O PyTorch chama esses métodos para buscar os dados.
Implementando __len__
__len__ informa ao PyTorch o tamanho do conjunto de dados, para que ele saiba quantos índices existem e quantos lotes uma época contém.
class ImageDataset(Dataset):
def __init__(self, paths, labels):
self.paths = paths
self.labels = labels
def __len__(self):
return len(self.paths)Implementando __getitem__
__getitem__ carrega e retorna uma amostra (e seu rótulo) dado um índice. É aqui que você abre um arquivo de imagem e o converte em um tensor.
from PIL import Image
def __getitem__(self, idx):
img = Image.open(self.paths[idx]).convert("RGB")
label = self.labels[idx]
return img, labelPor que usar transformações?
As imagens brutas variam em tamanho e intervalo de pixels. As transformações as padronizam: redimensionam para uma forma fixa, convertem-nas em um tensor e normalizam os valores dos pixels para que o modelo treine de forma estável.
from torchvision import transformstransforms.Compose
transforms.Compose encadeia várias transformações em um único fluxo de processamento aplicado na ordem. Um encadeamento típico é Resize, depois ToTensor e, por fim, 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])
])Entendendo as transformações
Resize fixa o tamanho espacial; ToTensor converte uma imagem PIL em um tensor e escala os pixels para [0,1]; Normalize desloca e escala cada canal para média zero e variância unitária, o que acelera a convergência.
Aplicando transformações no conjunto de dados
Passe a transformação para o conjunto de dados e aplique-a dentro de __getitem__, para que cada amostra seja pré-processada de forma consistente ao ser obtida.
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]Encapsulando em um DataLoader
O DataLoader transforma um conjunto de dados em um iterável de lotes. Defina batch_size para controlar o número de amostras por etapa e shuffle=True para randomizar a ordem a cada época (algo importante no treinamento).
dataset = ImageDataset(paths, labels, tf)
loader = DataLoader(dataset, batch_size=32, shuffle=True)num_workers para obter velocidade
num_workers cria subprocessos paralelos para carregar e transformar dados enquanto a GPU treina, ocultando a latência de entrada e saída. Um valor como 4 geralmente mantém a GPU ocupada, em vez de fazê-la esperar.
loader = DataLoader(
dataset,
batch_size=32,
shuffle=True,
num_workers=4
)Percorrendo os lotes
Percorra o DataLoader em um ciclo para obter tensores agrupados em lotes. Cada iteração produz (images, labels), em que images tem a forma [batch_size, channels, H, W], pronta para o modelo.
for images, labels in loader:
print(images.shape) # torch.Size([32, 3, 224, 224])
breakVerificação rápida
Teste seu conhecimento sobre o fluxo de processamento de dados.
Recapitulação: conjuntos de dados e DataLoaders
Você criou um Dataset personalizado com __len__ e __getitem__, pré-processou imagens usando transforms.Compose (Resize, ToTensor, Normalize) e o encapsulou em um DataLoader com batch_size, shuffle e num_workers para fornecer lotes ao modelo com eficiência.
Perguntas Frequentes
A aula “Conjuntos de dados e DataLoaders personalizados” é grátis?
Sim — o texto completo de “Conjuntos de dados e DataLoaders personalizados” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn AI with Python, atualize para CoddyKit PRO. O curso de Learn AI with Python inclui 4 aulas no total.
O que vou aprender em “Conjuntos de dados e DataLoaders personalizados”?
torch.utils.data.Dataset, __len__/__getitem__, DataLoader, transformações e aumento de dados. Você pratica Learn AI with Python com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Learn AI with Python?
Nenhuma experiência prévia é necessária. Learn AI with Python no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Conjuntos de dados e DataLoaders personalizados”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Learn AI with Python?
Sim. Cada aula de Learn AI with Python inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Tensores PyTorch e Autograd
- Conjuntos de dados e DataLoaders personalizados
- Construção e treinamento de CNNs com PyTorch
- Detecção de objetos com YOLOv8