00. Getting Started with PyTorch

A classe Dataloader do PyTorch¶

A classe Dataloader do PyTorch é uma classe muito importante que permite carregar dados em lotes ou seja ela é usada para alimentar os dados que foi representado noDataclass e carerga estes dados no modelo da Rede Neural, isso a torna muito útil para o contexto de Deep Learning. Vamos explorar as mínucias para entender como ela funciona e como podemos utiliza-la para otimizar o processo de treinamento de nossos modelos.

Importando a classe Dataloader¶

Para importar a classe Dataloader, podemos usar o seguinte comando:

from torch.utils.data import DataLoader

Usando a classe Dataloader¶

Para criar um carregador de dados(DataLoader), a primeira coisa que devemos fazer é criar um objeto ou uma instância da classe DataLoader e passar alguns argumentos existentes no construtor da classe. Sendo eles:

• dataset: O conjunto de dados para o qual você deseja criar o DataLoader.
• batch_size: O tamanho de cada lote de dados que irá alimentar o modelo.
• shuffle: Se queremos embaralhar os dados enquanto alimentamos o modelo Se nao for especificado, o padrão é False Geralmente usamos True quando estamos treinando o modelo, mas False durante a validação e teste.
• num_workers: O número de threads(processos) que queremos usar para carregar os dados em paralelo.

Exemplo:¶

Neste exemplo, vamos criar primeiramente um objeto DataLoader chamado sample_dataloader e vamos passar como argumento o conjunto de dados que queremos carregar que chamamos de sample_dataset e vamos especificar um batch_size de 32 itens por "batelada" e sem embaralhá-los.

Obs: Nós também podemos passar outros argumentos para o DataLoader, como por exemplo sampler que é um objeto da classe Sampler que é responsável por amostrar os dados de uma forma específicada, além deste argumento podemos passar outros ainda mais complexos que sao específicos para cada casa de uso.

In [3]:

import torch
from torch.utils.data import DataLoader
sample_dataloader = DataLoader(dataset="sample_dataset", batch_size=32, shuffle=False,num_workers=4)

import torch from torch.utils.data import DataLoader sample_dataloader = DataLoader(dataset="sample_dataset", batch_size=32, shuffle=False,num_workers=4)

Entendendo como o DataLoader funciona¶

Instanciar ou criar um objeto DataLoader, nos retorna um objeto que é um iterador sobre o conjunto de dados ou seja um iteravél. Este iteravél é executado no conjunto de dados e retorna um lote de dados a cada iteração. Portanto, em cada iteracao, um lote itens(dados) será retornado, e estes serao os dados que alimentarao a rede neural.

Mas como o DataLoader faz isso?

Bom, para fazer isso o DataLoader utiliza alguns métodos built-in que são os métodos __getitem__() ou __iter__() dependendo de como criamos ou melhor definimos lá na classe DataClass. Portanto, é necessário que cada DataClass seja ela implementada ou as fornecidas pelo core do Pytorch, é de extrema importância cada uma das DataClass tenha algum destes 2 métodos implementados.

No exemplo que vimos anteriormente podemos perceber algumas coisas que sao importantes de serem observadas sao:

1. Nós criamos o objeto sample_dataloader para alimentar o modelo sample_dataset.
2. sample_dataloader é um objeto iterador que será executado em sample_dataset.
3. Em cada iteracao de sample_dataloader um lote de 32 itens é retornado. E entao este lote irá alimentar o modelo da rede neural.
4. sample_dataloader internamente faz uso dos métodos __getitem__() ou __iter__() dependendo de como criamos ou melhor definimos lá na classe DataClass.

Criando um carregador de dados (DataLoader)¶

Normalmente criamos os carregadores de dados(DataLoader) de maneira separadas para alimentar o modelo, mas como assim separados? Bom normalmente quando trabalhamos com Deep Learning, Machine Learning e etc, nós particionamos ou quebramos o dataset em 3 partes que chamamos de train, test e val (treino, teste e validacao), isso serve justamente para ver o quao bom este modelo que acabou de ser treinado é, pois iremos ver a capacidade de generalização do modelo com dados que ele nunca viu, isso é muito importante para otimizar o processo de treinamento e evitar o overfitting.

Logo, ao separarmos o dataset em 3 partes, normalmente eles estarao em 3 diretorios diferentes, e sendo assim, precisamos criar um carregador para cada um destas partes do dataset e portanto, o uso de diferentes carregadores de dados neste caso é necessário. Da mesma forma, embaralhar os dados pode ser útil ao treinar o modelo, mas pode não ser necessário durante os processos de validação e teste, vamos ver como poderiamos fazer isso:

In [4]:

train_dataloader = DataLoader("train_dataset", batch_size = 32, shuffle = True)
val_dataloader = DataLoader("val_dataset", batch_size = 32, shuffle = False)
test_dataloader = DataLoader("test_dataset", batch_size = 32, shuffle = False)

train_dataloader = DataLoader("train_dataset", batch_size = 32, shuffle = True) val_dataloader = DataLoader("val_dataset", batch_size = 32, shuffle = False) test_dataloader = DataLoader("test_dataset", batch_size = 32, shuffle = False)