Como baixar o conjunto de dados MNIST usando o PyTorch
O conjunto de dados MNIST é uma grande coleção de dígitos manuscritos que é amplamente utilizado para treinar e testar vários sistemas de processamento de imagem e aprendizado de máquina. Ele contém 60.000 imagens de treinamento e 10.000 imagens de teste, cada uma com tamanho de 28x28 pixels. O conjunto de dados também está disponível em diferentes formatos, como CSV, PNG ou IDX.
PyTorch é uma estrutura de código aberto que fornece uma interface flexível e fácil de usar para criar modelos de aprendizagem profunda. O PyTorch também oferece um rico conjunto de ferramentas e bibliotecas para carregar e processar dados, como Torchvision, Torchtext e Torchaudio. Essas bibliotecas fornecem acesso conveniente a muitos conjuntos de dados populares, como MNIST, CIFAR10, IMDB ou LibriSpeech.
download mnist pytorch
Neste tutorial, você aprenderá como baixar o conjunto de dados MNIST usando o PyTorch e como aplicar algumas transformações básicas para preparar os dados para o seu modelo. Você também aprenderá como criar carregadores de dados que podem gerar lotes de dados para treinamento e teste. Ao final deste tutorial, você será capaz de:
Baixe o conjunto de dados MNIST usando archvision.datasets.MNIST
Carregue e transforme as imagens e rótulos usando o archvision.transforms
Crie carregadores de dados usando o arch.utils.data.DataLoader
Iterar sobre os carregadores de dados e visualizar algumas amostras
Para seguir este tutorial, você precisará de:
Python 3.8 ou superior
PyTorch 2.0 ou superior
Torchvision 0.15 ou superior
Matplotlib 3.4 ou superior
Uma conexão de internet funcionando
Baixando o conjunto de dados MNIST
A maneira mais fácil de baixar o conjunto de dados MNIST usando PyTorch é usar a classe archivision.datasets.MNIST. Essa classe herda de arch.utils.data.Dataset, que é uma classe abstrata que representa um conjunto de dados. A classe MNIST implementa dois métodos: __len__(), que retorna o número de amostras no conjunto de dados, e __getitem__(), que retorna uma amostra (imagem e rótulo) dado um índice.
Para criar uma instância da classe MNIST, você precisa especificar três argumentos: root, train e download. O argumento raiz é uma string que especifica o diretório raiz onde os arquivos do conjunto de dados serão armazenados. O argumento train é um booleano que indica se você deseja criar um conjunto de dados do conjunto de treinamento (True) ou do conjunto de teste (False). O argumento de download é um booleano que indica se você deseja baixar o conjunto de dados da Internet, caso ainda não esteja presente no diretório raiz.
Por exemplo, para criar um conjunto de dados do conjunto de treinamento e baixá-lo, se necessário, você pode usar o seguinte código:
importar archvision.datasets como conjuntos de dados mnist_train = datasets.MNIST(root='data', train=True, download=True)
Isso criará uma pasta chamada 'data' em seu diretório de trabalho atual e baixará quatro arquivos: train-images-idx3-ubyte.gz, train-labels-idx1-ubyte.gz, t10. k-images-idx3-ubyte.gz e t10k-labels-idx1-ubyte.gz. Estes são arquivos compactados que contêm as imagens e rótulos em formato binário. A classe MNIST irá descompactá-los automaticamente e carregá-los na memória quando você acessar o conjunto de dados.
Para verificar a integridade e a existência dos arquivos baixados, você pode usar os métodos maçarico.datasets.utils.check_integrity e maçarico.datasets.utils.check_exists. Esses métodos retornam True se os arquivos forem válidos e presentes e False caso contrário. Por exemplo, para verificar a integridade do arquivo train-images-idx3-ubyte, você pode usar o seguinte código:
importar archivision.datasets.utils como utils file_path = 'data/MNIST/raw/train-images-idx3-ubyte' md5 = 'f68b3c2dcbeaaa9fbdd348bbdeb94873' print(utils.check_integrity(file_path, md5))
Isso imprimirá True se o arquivo tiver o hash md5 correto e False caso contrário. Da mesma forma, para verificar a existência do arquivo train-labels-idx1-ubyte, você pode usar o seguinte código:
file_path = 'data/MNIST/raw/train-labels-idx1-ubyte' print(utils.check_exists(file_path))
Isso imprimirá True se o arquivo existir no caminho especificado e False caso contrário.
Carregando e transformando o conjunto de dados MNIST
Depois de baixar o conjunto de dados MNIST, você pode querer aplicar algumas transformações às imagens e rótulos antes de alimentá-los em seu modelo. Por exemplo, você pode querer converter as imagens de objetos PIL.Image em objetos arch.Tensor, normalizar os valores de pixel ou redimensionar as imagens para um tamanho diferente.
Para aplicar transformações ao conjunto de dados MNIST, você pode usar os argumentos transform e target_transform da classe MNIST. O argumento transform é um callable que recebe uma imagem como entrada e retorna uma imagem transformada. O argumento target_transform é um callable que usa um rótulo como entrada e retorna um rótulo transformado. Você pode passar qualquer função ou objeto que implemente o método __call__ como uma transformação.
Uma das maneiras mais convenientes de criar transformações é usar o módulo archvision.transforms. Este módulo fornece uma variedade de transformações predefinidas que podem ser aplicadas a imagens e rótulos, como corte, inversão, rotação, preenchimento, dimensionamento etc.
Para aplicar várias transformações sequencialmente, você pode usar o archvision.transforms.Compose. Esta é uma classe que recebe uma lista de transformações como entrada e retorna uma transformação composta que as aplica uma a uma. Por exemplo, para criar uma transformação que converte uma imagem em um tensor, normaliza seus valores de pixel e redimensiona para 32x32 pixels, você pode usar o seguinte código:
importar archivision.transforms as transforms transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)), transforms.Resize((32, 32)) ])
A transformação transforms.ToTensor() converte um objeto PIL.Image ou numpy.ndarray em um objeto arch.Tensor com forma (C, H, W), onde C é o número de canais (1 para imagens em tons de cinza), H é a altura e W é a largura. Os valores de pixel são dimensionados para o intervalo [0, 1].
A transformação transforms.Normalize(mean, std) normaliza uma imagem de tensor com média e desvio padrão. Os argumentos mean e std são sequências de números que correspondem ao número de canais na imagem. Os valores de pixel são subtraídos pela média e divididos pelo padrão para cada canal.
A transformação transforms.Resize(size) redimensiona uma imagem para o tamanho especificado. O argumento size pode ser um int ou uma tupla de ints. Se for um int, é interpretado como a menor aresta da imagem. Se for uma tupla de inteiros, é interpretado como (altura, largura).
Para aplicar essa transformação ao conjunto de dados MNIST, você pode passá-la como um argumento para a classe MNIST. Por exemplo, para criar um conjunto de dados do conjunto de teste e aplicar a transformação, você pode usar o seguinte código:
mnist_test = datasets.MNIST(root='data', train=False, download=True, transform=transform)
Isso criará um conjunto de dados que contém imagens de tensor com forma (1, 32, 32) e valores de pixel normalizados e rótulos inteiros de 0 a 9.
Criando DataLoaders para o conjunto de dados MNIST
Depois de criar e transformar o conjunto de dados MNIST, convém criar carregadores de dados que possam gerar lotes de dados para treinar e testar seu modelo. Um carregador de dados é um objeto que pode iterar sobre um conjunto de dados e retornar um lote de dados a cada iteração. Um lote é uma tupla de tensores que contém um subconjunto de imagens e rótulos do conjunto de dados.
Para criar carregadores de dados para o conjunto de dados MNIST, você pode usar a classe arch.utils.data.DataLoader. Essa classe recebe um conjunto de dados como entrada e retorna um carregador de dados como saída. O carregador de dados tem vários argumentos que controlam como os dados são agrupados e embaralhados. Alguns dos argumentos mais importantes são:
batch_size: o número de amostras por lote. O valor padrão é 1.
shuffle: um booleano que indica se os dados devem ser embaralhados antes do lote. O valor padrão é falso.
num_workers: o número de subprocessos a serem usados para carregamento de dados. O valor padrão é 0, o que significa que os dados serão carregados no processo principal.
Por exemplo, para criar carregadores de dados para os conjuntos de treinamento e teste com um tamanho de lote de 64, shuffle ativado e quatro trabalhadores, você pode usar o seguinte código:
importar arch.utils.data como dados train_loader = data.DataLoader(mnist_train, batch_size=64, shuffle=True, num_workers=4) test_loader = data.DataLoader(mnist_test, batch_size=64, shuffle=True, num_workers=4)
Isso criará dois carregadores de dados que podem gerar lotes de 64 imagens e rótulos em cada iteração. As imagens terão formato (64, 1, 32, 32) e os rótulos terão formato (64).
Iterando sobre os DataLoaders e visualizando alguns exemplos
Para iterar sobre os carregadores de dados e acessar os lotes de dados, você pode usar um loop for ou uma função next. Por exemplo, para obter o primeiro lote de dados do train_loader, você pode usar o seguinte código:
imagens, rótulos = next(iter(train_loader))
Isso atribuirá dois tensores às imagens e rótulos das variáveis. O tensor de imagens terá forma (64, 1, 32, 32) e conterá os valores de pixel de 64 imagens. O tensor de rótulos terá forma (64) e conterá os rótulos correspondentes de 64 imagens.
Para visualizar algumas amostras do lote, você pode usar o matplotlib.pyplot.imshow ou o archvision.utils.make_grid. A função imshow pega uma imagem como entrada e a exibe em um gráfico. A função make_grid recebe um lote de imagens como entrada e retorna uma única imagem que contém uma grade de imagens. Por exemplo, para exibir quatro imagens do lote junto com seus rótulos, você pode usar o seguinte código:
importar matplotlib.pyplot como plt importar archivision.utils como utils grid = utils.make_grid(images[:4], nrow=2) plt.imshow(grid.permute(1, 2, 0)) plt.title('Labels: ' + ' '.join(str(labels[:4].numpy()))) plt.show()
Isso criará uma imagem de grade com duas linhas e duas colunas, contendo quatro imagens do lote. Ele também exibirá os rótulos dessas imagens no título do gráfico. Você deve ver algo assim:
Conclusão
Neste tutorial, você aprendeu como baixar o conjunto de dados MNIST usando PyTorch e como aplicar algumas transformações básicas para preparar os dados para seu modelo. Você também aprendeu a criar carregadores de dados que podem gerar lotes de dados para treinar e testar seu modelo. Você também aprendeu como iterar sobre os carregadores de dados e visualizar algumas amostras dos lotes.
O conjunto de dados MNIST é um ótimo recurso para aprender e experimentar sistemas de processamento de imagem e aprendizado de máquina. O PyTorch fornece uma maneira conveniente e flexível de acessar e manipular esse conjunto de dados usando suas ferramentas e bibliotecas. Você pode usar este tutorial como ponto de partida para criar seus próprios modelos usando PyTorch e MNIST.
Se você quiser saber mais sobre o PyTorch e seus recursos, confira alguns dos seguintes recursos:
[Bem-vindo aos Tutoriais do PyTorch](^1^): Uma coleção de tutoriais que cobrem vários tópicos e níveis do PyTorch, como visão, texto, áudio, produção, etc.
[Recursos PyTorch](^2^): Uma página que lista vários recursos para desenvolvedores PyTorch, como documentos, fóruns, exemplos, cursos, etc.
[Aprenda o básico](^3^): um guia passo a passo para criar um fluxo de trabalho de ML completo com o PyTorch, desde o carregamento de dados até o salvamento de modelos.
Esperamos que você tenha gostado deste tutorial e aprendido algo novo. Se você tiver algum comentário ou pergunta, sinta-se à vontade para deixar um comentário abaixo ou entre em contato conosco em nosso fórum [PyTorch Discuss]( Gostaríamos muito de ouvir de você e ajudá-lo com sua jornada PyTorch.
perguntas frequentes
Aqui estão algumas perguntas e respostas frequentes sobre como baixar o conjunto de dados MNIST usando o PyTorch:
P: Como posso baixar o conjunto de dados MNIST em um formato diferente, como CSV ou PNG?
R: Você pode usar a função archivision.datasets.utils.download_and_extract_archive para baixar e extrair qualquer arquivo compactado que contenha o conjunto de dados MNIST em um formato diferente. Você pode encontrar alguns links para formatos alternativos do conjunto de dados MNIST [aqui](
P: Como posso aplicar diferentes transformações aos conjuntos de treinamento e teste?
R: Você pode criar instâncias diferentes da classe archvision.transforms.Compose e passá-las como argumentos para o argumento transform da classe MNIST. Por exemplo, você pode aplicar técnicas de aumento de dados, como corte ou inversão aleatórios, ao conjunto de treinamento e não ao conjunto de teste.
P: Como posso alterar o número de classes ou amostras no conjunto de dados MNIST?
R: Você pode usar a classe archvision.datasets.VisionDataset para criar um conjunto de dados personalizado que herda da classe MNIST e substitui alguns de seus métodos. Por exemplo, você pode substituir o método __len__() para retornar um número diferente de amostras ou o método __getitem__() para retornar um número diferente de classes.
P: Como posso acelerar o processo de carregamento de dados?
R: Você pode usar o argumento num_workers da classe arch.utils.data.DataLoader para aumentar o número de subprocessos que carregam os dados em paralelo. Você também pode usar o argumento pin_memory para ativar a fixação de memória, que copia os dados da memória da CPU para a memória da GPU mais rapidamente.
P: Como posso salvar e carregar o conjunto de dados MNIST?
R: Você pode usar as funções maçarico.save e maçarico.carregar para salvar e carregar o conjunto de dados MNIST como um objeto maçarico.Tensor. Alternativamente, você pode usar as funções maçarico.datasets.utils.save_image e archivision.datasets.utils.read_image para salvar e carregar imagens individuais como objetos PIL.Image.
0517a86e26
Comments