Dataloader de Pytorch

O Dataloader de Pytorch é um recurso útil que mantém seus dados organizados e simplifica o seu pipeline de aprendizado de máquina. Ele nos permite iterar os dados, gerenciar lotes e embaralhar as amostras para evitar o excesso de ajuste. Passaremos pela implementação do Dataloader em Pytorch neste artigo. Antes disso, passaremos pelas terminologias básicas que usaremos ao implementar o carregador de dados. Começaremos com o conjunto de dados MNIST da moda com Pytorch. Mais tarde, usaremos o Dataloader com nosso conjunto de dados personalizado.

O que é Pytorch?

O Pytorch é uma estrutura de aprendizado profundo de código aberto para a construção de arquiteturas de rede e outras técnicas de alto nível como RNN, CNN e LSTM. É utilizado por pesquisadores, empresas e comunidades de ML e IA.

O grupo de pesquisa de inteligência artificial do Facebook é principalmente responsável por seu desenvolvimento.

O que é Tensor (abordagem baseada em matemática)?

Exercer uma força em uma superfície e observar como ela desvia em diferentes direções. Você pode antecipar que se mova na mesma direção que a força, mas isso nem sempre acontece; A razão para isso é que o material não é uniforme em todas as direções; Pode ter alguma estrutura, como um cristal ou camadas. Uma força, que é um vetor, é o seu ponto de partida. (As direções x, y e z têm três componentes.) Você recebe um vetor de deflexão (movimento em x, y e z). A força, no entanto, está na direção inversa do movimento! Vamos fingir que a resposta é proporcional à força, o que significa dobrar a força duas vezes o movimento. Isso é chamado de "reação linear.”

Como você pode colocar tudo isso em termos matemáticos? Com um tensor, é claro. Considere um tensor como um instrumento matemático que pega um vetor (como a força) e retorna um novo vetor (o movimento). Os tensores só são necessários quando os dois vetores estão apontando em direções opostas.

Iterações, lotes, epocs. O que eles são em termos de redes neurais?

O número de iterações (denotadas por n aqui) é o número de vezes que um lote de instâncias de treinamento estima o gradiente e atualiza os parâmetros da rede neural.

O tamanho do lote B refere -se a quantas instâncias de treinamento são empregadas em uma única iteração. Isso geralmente é usado quando o número de instâncias de treinamento é bastante grande e geralmente é eficaz dividir todos os dados em mini-lotes. Cada lote tem o tamanho: 1< B < N.

Para usar os dados completos de treinamento uma vez, é preciso n (N/B) iterações. Isso é o que é uma época. Então (N/B)*E, onde E é o número de épocas, é o número total de vezes que os parâmetros são alterados.

Existem três tipos de descida de gradiente. Há uma troca entre eles, pois se pode dar uma boa precisão, mas é lenta. Por outro lado, um é mais rápido, mas não garante uma boa precisão:

N = b, uma época é igual a uma iteração no modo de lote.

Modo Mini-lote: 1 < B < N, with N/B iterations per epoch.

B = 1, uma época leva n iterações no modelo estocástico de descida de gradiente.

Implementando o Dataloader no conjunto de dados de moda mnist

Carregando o conjunto de dados MNIST da moda da Pytorch

Fashion-Mnist é um conjunto de dados de imagem que inclui 60.000 treinamento e 10.000 instâncias de teste. Cada exemplo inclui uma imagem de escala de cinza de 28 x 28 com uma etiqueta de uma das dez categorias. Abaixo estão alguns parâmetros que você satisfaz ao carregar o conjunto de dados.

raiz: Este é o diretório em que o conjunto de dados é salvo.

trem: indica que os dados treinados ou testados devem ser carregados.

download: Se os dados não estiverem disponíveis no Root, eles serão baixados pela Internet.

Transforme e Target_transform: Esses parâmetros especificam o recurso e as transformações do rótulo.

importação de tocha
FromTorch.útil.DataImport DataSet
DATASETOS DE FROMOTCHVISIONIMPORT
FromTorChVision.transformsimportTotensor
importMatPlotLib.pyplotasplt
trem = conjuntos de dados.FashionMnist (
root = "Dados",
trem = verdadeiro,
download = true,
transform = totensor ()
)
teste = conjuntos de dados.FashionMnist (
root = "Dados",
trem = falso,
download = true,
transform = totensor ()
)

Personalizado Conjunto de dados de seus arquivos

importos
importar pandas como PD
da Torchvision.IO Importread_image
# Criar classe para conjunto de dados personalizado
ClassCustomDataset (DataSet):
# Inicialize o conjunto de dados
def__init __ (self, anotações, img_dir, trans = nenhum, target_trans = nenhum):
auto.Rótulos = Pd.read_csv (anotações)
auto.img_dir = img_dir
auto.trans = trans
auto.Target_trans = Target_trans
# função para retornar o comprimento dos dados
def__len __ (self):
Returnlen (self.etiquetas)
# função para obter amostra no indicador determinado
def__getItem __ (self, índice):
caminho = os.caminho.Junte -se (self.img_dir, self.Rótulos.ILOC [índice, 0])
img = read_image (caminho)
etiqueta = self.Rótulos.ILOC [índice, 1]
se você mesmo.trans:
img = self.trans (img)
se você mesmo.Target_trans:
etiqueta = self.Target_trans (etiqueta)
returnImg, etiqueta

No código acima, vemos três métodos importantes:

__iniciar__: Esta função é chamada quando o objeto do conjunto de dados é criado. Ambas as transformadas, assim como o diretório que contêm as imagens e o arquivo de anotações, são configuradas.

__len__: Esta função retorna o comprimento do conjunto de dados ou o número de amostras no conjunto de dados.

__getItem__: Este método nos dá a amostra presente em um índice.

Treinamento com Dataloader

Armazene os dados nos carregadores de dados. Os carregadores de dados são iteráveis ​​que permitem que você passe as amostras uma de cada vez no momento do treinamento e até embaralhem os dados depois que todos os lotes são processados.

da tocha.útil.Importar dados Dataloader
TRAIN_LOADER = DATALOADER (TRINH, BATCH_SIZE = 32, Shuffle = True)
test_loader = dataloader (teste, batch_size = 32, shuffle = true)

Itera o Dataloader

# Exibir imagem e etiqueta.
TRAIN_FEATURES, TRIN_LABELS = AIXTENCIO (ITER (TRAIN_LOADER))
print (f "apresenta a forma do lote atual é Train_Features.tamanho()")
Print (F "Formulário dos rótulos da forma atual em lote é Train_labels.tamanho()")
IMG = TRIN_FEATURES [0].espremer()
etiqueta = trens_labels [0]
plt.imshow (img, cmap = "cinza")
plt.mostrar()
Print (F "Label: Label")

Saída

Apresenta a forma do lote atual é tocha.Tamanho ([32, 1, 28, 28])

Os rótulos formas da forma atual do lote é tocha.Tamanho ([32])

Etiqueta: 5

Cada iteração no código acima retorna um lote de recursos de treinamento e rótulos de treinamento para cada iteração. Para evitar o excesso de ajuste, os dados são embaralhados depois que todos os lotes foram processados.

Implementando o carregador de dados em um conjunto de dados personalizado

# importar as bibliotecas que usaremos
importação de tocha
FromTorch.útil.DataImport DataSet
FromTorch.útil.DataImportDataloader
# Definindo a classe do conjunto de dados
ClassDataSets (conjunto de dados):
# Inicializando o conjunto de dados aqui
def__init __ (self):
números = lista (intervalo (0, 20, 1))
auto.dados = números
# Obtenha o comprimento do conjunto de dados aqui
def__len __ (self):
Returnlen (self.dados)
# Pegue o item em um índice
def__getItem __ (self, índice):
retornar.Dados [índice]
# Crie um objeto da classe Data_Set
DataSet = DataSets ()
# Implementando o carregador de dados no conjunto de dados e especificando os parâmetros
Dataloader = Dataloader (DataSet, batch_size = 5, shuffle = true)
fori, lote em enumerado (Dataloader):
Imprimir (eu, lote)

Saída

0 tensor ([0, 4, 9, 15, 14]))
1 Tensor ([11, 16, 12, 3, 10])
2 Tensor ([6, 8, 2, 17, 1])
3 Tensor ([7, 18, 5, 13, 19]))

Conclusão

Passamos pela implementação do Dataloader de Pytorch para gerenciar o treinamento de nossos dados. Agora percebemos a facilidade com que podemos gerenciar os lotes, arrastar, iteração de nossos conjuntos de dados usando Dataloader. Isso ajuda a uma melhor análise de nossos modelos e, finalmente, os melhore.