Baixar Conjunto de Dados MNIST PyTorch - um conjunto de dados de imagens de dígitos escritos à mão q

Como baixar e usar o conjunto de dados MNIST no PyTorch para classificação de imagens

A classificação de imagens é uma das tarefas mais comuns e importantes na visão computacional. Envolve atribuir um rótulo a uma imagem com base em seu conteúdo, como identificar se uma imagem contém um gato ou um cachorro. A classificação de imagens pode ser usada para várias aplicações, como reconhecimento facial, diagnóstico médico, carros autônomos e muito mais.

download mnist dataset pytorch

DOWNLOAD

Um dos conjuntos de dados mais populares para classificação de imagens é o conjunto de dados MNIST, que consiste em 70.000 imagens de dígitos manuscritos. As imagens são em tons de cinza e têm resolução de 28x28 pixels. O conjunto de dados é dividido em 60.000 imagens de treinamento e 10.000 imagens de teste. O objetivo é treinar um modelo capaz de reconhecer os dígitos de 0 a 9 em qualquer imagem.

PyTorch é uma estrutura de código aberto que nos permite construir e treinar redes neurais com facilidade. O PyTorch fornece várias ferramentas e módulos que simplificam o carregamento de dados, definição de modelo, treinamento, avaliação e visualização. O PyTorch também oferece suporte à aceleração de GPU, que pode acelerar a computação e melhorar o desempenho de nossos modelos.

Neste artigo, mostraremos como baixar e usar o conjunto de dados MNIST no PyTorch para classificação de imagens. Abordaremos as seguintes etapas:

Baixando o conjunto de dados MNIST usando a classe PyTorch DataLoader

Definindo um modelo de rede neural para classificação de imagens

Escolhendo uma função de perda e um otimizador para treinar o modelo

Avaliando o modelo no conjunto de dados de teste e visualizando os resultados

Baixando o conjunto de dados MNIST usando a classe PyTorch DataLoader

A primeira etapa é baixar e carregar o conjunto de dados MNIST usando a classe PyTorch DataLoader. O PyTorch fornece uma maneira conveniente de acessar vários conjuntos de dados por meio de seu módulo archvision.datasets. Este módulo contém classes que podem baixar e carregar conjuntos de dados comuns, como Fashion-MNIST, CIFAR10, ImageNet, etc.

Para usar o conjunto de dados MNIST no PyTorch, precisamos importar alguns módulos e definir o diretório raiz onde queremos armazenar os dados. Também precisamos especificar se queremos usar os dados de treinamento ou teste e se queremos baixá-los, caso ainda não estejam disponíveis.

importar tocha de arch.utils.data importar DataLoader de archivision importar conjuntos de dados, transforms root = "data" # diretório raiz para armazenamento de dados train = True # se usar treinamento ou teste download de dados = True # se baixar dados se ainda não estiverem disponíveis

Em seguida, podemos usar a classe archivision.datasets.MNIST para baixar e carregar os dados.Este resumo do artigo: - Introdução - O que é o conjunto de dados MNIST e por que ele é útil para classificação de imagens? - O que é o PyTorch e como ele pode nos ajudar a construir e treinar redes neurais? - Quais são as principais etapas para baixar e usar o conjunto de dados MNIST no PyTorch? - Baixando o conjunto de dados MNIST usando a classe PyTorch DataLoader - Como importar os módulos necessários e definir o diretório raiz para o conjunto de dados - Como usar a classe archvision.datasets.MNIST para baixar e carregar os dados de treinamento e teste - Como aplicar algumas transformações nas imagens usando o archvision.transforms - Definir um modelo de rede neural para classificação de imagens - Como escolher uma arquitetura adequada para a tarefa, como uma rede neural convolucional (CNN) ou uma rede feed-forward - Como definir a entrada , camadas ocultas e de saída e usar funções de ativação - Como inicializar o modelo e movê-lo para o dispositivo (CPU ou GPU) - Escolher uma função de perda e um otimizador para treinar o modelo - Como selecionar uma função de perda adequada para classificação de imagem, como perda de entropia cruzada - Como escolher um otimizador que atualize os parâmetros do modelo, como descida de gradiente estocástico (SGD) ou Adam - Como definir a taxa de aprendizado, tamanho do lote e número de épocas para treinamento - Avaliar o modelo no conjunto de dados de teste e visualizar os resultados - Como usar o método model.eval() para alternar para o modo de avaliação - Como fazer um loop no carregador de dados de teste e calcular a precisão e outras métricas - Como plotar algumas imagens de amostra e seus rótulos previstos usando matplotlib - Conclusão - Resuma os pontos principais do artigo e forneça algumas informações para o leitor - Forneça alguns links ou referências para leitura adicional ou aprendizado Artigo com formatação HTML: Como baixar e usar o conjunto de dados MNIST no PyTorch para classificação de imagens

A classificação de imagens é uma das tarefas mais comuns e importantes na visão computacional.Envolve atribuir um rótulo a uma imagem com base em seu conteúdo, como identificar se uma imagem contém um gato ou um cachorro. A classificação de imagens pode ser usada para várias aplicações, como reconhecimento facial, diagnóstico médico, carros autônomos e muito mais.

Neste artigo, mostraremos como baixar e usar o conjunto de dados MNIST no PyTorch para classificação de imagens. Abordaremos as seguintes etapas:

Baixando o conjunto de dados MNIST usando a classe PyTorch DataLoader

Definindo um modelo de rede neural para classificação de imagens

Escolhendo uma função de perda e um otimizador para treinar o modelo

Avaliando o modelo no conjunto de dados de teste e visualizando os resultados

Baixando o conjunto de dados MNIST usando a classe PyTorch DataLoader

Para usar o conjunto de dados MNIST no PyTorch, precisamos importar alguns módulos e definir o diretório raiz onde queremos armazenar os dados.Também precisamos especificar se queremos usar os dados de treinamento ou teste e se queremos baixá-los, caso ainda não estejam disponíveis.

Em seguida, podemos usar a classe archivision.datasets.MNIST para baixar e carregar os dados. Esse. class recebe alguns argumentos, como root, train, download, transform e target_transform. O argumento transform nos permite aplicar algumas transformações às imagens, como redimensionar, recortar, girar, normalizar etc. O argumento target_transform nos permite aplicar algumas transformações aos rótulos, como codificação, decodificação etc.

transform = transforms.ToTensor() # transformação para aplicar às imagens target_transform = None # transformação para aplicar aos rótulos # baixar e carregar os dados de treinamento train_data = datasets.MNIST(root=root, train=train, download=download, transform=transform, target_transform=target_transform) # baixar e carregar os dados de teste test_data = datasets.MNIST(root=root, train=not train, download=download, transform=transform, target_transform=target_transform )

Depois de baixar e carregar os dados, podemos usar a classe PyTorch DataLoader para criar carregadores de dados que podem iterar os dados em lotes. O carregador de dados usa alguns argumentos, como dataset, batch_size, shuffle, num_workers, etc.O argumento batch_size especifica quantas amostras carregar por lote. O argumento shuffle especifica se os dados devem ser embaralhados antes do carregamento. O argumento num_workers especifica quantos subprocessos usar para carregamento de dados. Para este artigo, usaremos um tamanho de lote de 64 e embaralharemos os dados.

batch_size = 64 # número de amostras por lote shuffle = True # se deve embaralhar os dados antes de carregar num_workers = 0 # número de subprocessos para carregamento de dados # criar um carregador de dados para os dados de treinamento train_loader = DataLoader(dataset=train_data, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers) # criar um carregador de dados para os dados de teste test_loader = DataLoader(dataset=test_data, batch _size=batch_size, shuffle=shuffle, num_workers=num_workers)

Agora baixamos e carregamos o conjunto de dados MNIST usando a classe PyTorch DataLoader. Podemos verificar o tamanho e a forma dos dados imprimindo algumas estatísticas.

print(f"Número de amostras de treinamento: len(train_data)") print(f"Número de amostras de teste: len(test_data)") print(f"Forma de uma imagem: train_data[0][0].shape") print(f"Forma de um rótulo: train_data[0][1].shape")

A saída deve ser algo como isto:

Número de amostras de treinamento: 60000 Número de amostras de teste: 10000 Forma de uma imagem: tocha.Size([1, 28, 28]) Forma de uma etiqueta: tocha.Size([])

Podemos ver que temos 60.000 amostras de treinamento e 10.000 amostras de teste. Cada imagem tem uma forma de (1, 28, 28), o que significa que tem um canal (escala de cinza), 28 linhas e 28 colunas. Cada rótulo tem uma forma de (), o que significa que é um valor escalar.

Definindo um modelo de rede neural para classificação de imagens

O próximo passo é definir um modelo de rede neural para classificação de imagens. Uma rede neural é um modelo computacional que consiste em camadas de neurônios que podem aprender com os dados e executar várias tarefas.O PyTorch fornece um módulo chamado arch.nn que contém várias classes e funções que podem nos ajudar a definir e usar redes neurais.

Para definir um modelo de rede neural no PyTorch, precisamos criar uma classe herdada de arch.nn.Module. Esta classe deve ter dois métodos: __init__() e forward(). O método __init__() é onde definimos as camadas do nosso modelo e as inicializamos. O método forward() é onde especificamos como a entrada passa pelas camadas e produz a saída.

Existem muitas arquiteturas possíveis para classificação de imagens, mas uma das mais comuns é uma rede neural convolucional (CNN). Uma CNN é um tipo de rede neural que usa camadas convolucionais para extrair recursos de imagens. Uma camada convolucional aplica um conjunto de filtros à entrada e produz um mapa de recursos que captura alguns padrões ou características da entrada. Uma CNN geralmente consiste em várias camadas convolucionais seguidas por camadas de agrupamento, funções de ativação, camadas totalmente conectadas e camadas de saída.

Para este artigo, usaremos uma arquitetura CNN simples que possui duas camadas convolucionais seguidas por camadas de agrupamento máximo e funções de ativação ReLU. Então teremos duas camadas totalmente conectadas seguidas por uma camada de saída softmax. A camada softmax produzirá uma distribuição de probabilidade sobre as 10 classes possíveis (dígitos de 0 a 9).

Para definir o modelo CNN no PyTorch, podemos usar o seguinte código:

importar tocha.nn como nn importar tocha.nn.functional as classe F CNN(nn.Module): def __init__(self): super(CNN, self).__init__() # define a primeira camada convolucional self.conv1 = nn.Conv2d(in_channels=1, out_channels=16, kernel_size=3, padding=1) # define a segunda camada convolucional self.conv2 = nn.Conv2d(in_ canais=16, out_channels=32, kernel_size=3, padding=1) # define a camada máxima de pooling self.pool = nn.MaxPool2d(kernel_size=2, stride=2) # define a primeira camada totalmente conectada self.fc1 = nn.Linear(in_features=32*7*7, out_features=128) # define a segunda camada totalmente conectada self.fc2 = nn.Linear(in_ features=128, out_features=10) def forward(self, x): # passa a entrada pela primeira camada convolucional x = self.conv1(x) # aplica a função de ativação ReLU x = F.relu(x) # aplica o pool máximo x = self.pool(x) # passa a saída pela segunda camada convolucional x = self.conv2(x) # aplica a função de ativação ReLU x = F.relu(x) # aplica o pool máximo x = self.pool(x) # achate a saída para um vetor x = x.view(-1, 32*7*7) # passe o vetor pela primeira camada totalmente conectada x = self.fc1(x) # aplique a função de ativação ReLU x = F.relu(x) # passe a saída pela segunda camada totalmente conectada x = self.fc2(x) # aplique a função de ativação softmax para obter uma distribuição de probabilidade sobre as classes x = F.softmax(x, dim=1) return x

Depois de definir o modelo, precisamos inicializá-lo e movê-lo para o dispositivo (CPU ou GPU) que queremos usar para computação. Podemos usar a função arch.device() para especificar o dispositivo e o método model.to() para mover o modelo para o dispositivo. Também podemos imprimir o resumo do modelo usando a função print().

# cria uma instância do modelo CNN model = CNN() # especifica o dispositivo (CPU ou GPU) para usar device = maçarico.device("cuda" if maçarico.cuda.is_available() else "cpu") # move o modelo para o dispositivo model.to(device) # imprime o sumário do modelo print(model)

A saída deve ser algo como isto:

CNN( (conv1): Conv2d(1, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (pool): MaxPool2d(kernel_size=2, stride=2, padding=0 , dilatação=1, ceil_mode=False) (fc1): Linear(in_features=1568, out_features=128, bias=True) (fc2): Linear(in_features=128, out_features=10, bias=True) )

Agora definimos um modelo de rede neural para classificação de imagens usando o PyTorch.

Escolhendo uma função de perda e um otimizador para treinar o modelo

O próximo passo é escolher uma função de perda e um otimizador para treinar o modelo. Uma função de perda é uma medida de quão bem o modelo prevê os rótulos corretos para as imagens de entrada. Uma perda menor significa uma previsão melhor. Um otimizador é um algoritmo que atualiza os parâmetros do modelo com base na perda e na taxa de aprendizado. Uma taxa de aprendizado menor significa uma atualização menor e uma convergência mais lenta.

O PyTorch fornece várias funções de perda e otimizadores em seus módulos arch.nn e arch.optim. Para classificação de imagens, uma escolha comum de função de perda é a perda de entropia cruzada. A perda de entropia cruzada compara a distribuição de probabilidade prevista com o rótulo verdadeiro e penaliza as previsões incorretas. PyTorch fornece uma classe chamada nn.CrossEntropyLoss que implementa perda de entropia cruzada.

Para otimizador, existem muitas opções possíveis, como descida de gradiente estocástico (SGD), Adam, RMSprop, etc. Cada otimizador tem suas próprias vantagens e desvantagens e pode funcionar de forma diferente, dependendo da tarefa e dos dados.Para este artigo, usaremos o otimizador Adam, que é um otimizador popular e eficiente que adapta a taxa de aprendizado para cada parâmetro com base em seu gradiente e momento. PyTorch fornece uma classe chamada optim.Adam que implementa o otimizador Adam.Para usar a perda de entropia cruzada e o otimizador Adam no PyTorch, precisamos criar instâncias dessas classes e passar os parâmetros do modelo para elas. Também precisamos definir alguns hiperparâmetros, como a taxa de aprendizado, o tamanho do lote e o número de épocas. A taxa de aprendizado controla o quanto os parâmetros do modelo são atualizados em cada iteração. O tamanho do lote controla quantas amostras são usadas para calcular a perda e o gradiente em cada iteração. O número de épocas controla quantas vezes o modelo percorre todo o conjunto de dados de treinamento.

# cria uma instância do critério de perda de entropia cruzada = nn.CrossEntropyLoss() # cria uma instância do otimizador Adam otimizador = optim.Adam(model.parameters()) # define a taxa de aprendizado lr = 0,01 # define o tamanho do lote batch_size = 64 # define o número de épocas epochs = 10

Agora escolhemos uma função de perda e um otimizador para treinar o modelo usando o PyTorch.

Avaliando o modelo no conjunto de dados de teste e visualizando os resultados

A etapa final é avaliar o modelo no conjunto de dados de teste e visualizar os resultados. A avaliação é o processo de medir o desempenho do modelo em dados não vistos. A visualização é o processo de exibir algumas imagens e seus rótulos previstos para ter uma noção de como o modelo funciona.

Para avaliar o modelo no conjunto de dados de teste, precisamos usar o método model.eval() para alternar para o modo de avaliação. Isso desativará alguns recursos que são úteis apenas para treinamento, como dropout e normalização de lote. Em seguida, precisamos percorrer o carregador de dados de teste e calcular algumas métricas, como exatidão, precisão, rechamada, etc. Exatidão é a proporção de amostras previstas corretamente para o número total de amostras.A precisão é a proporção de amostras positivas previstas corretamente para o número total de amostras positivas previstas. Recall é a proporção de amostras positivas previstas corretamente para o número total de amostras positivas reais.

# mude para o modo de avaliação model.eval() # inicialize algumas variáveis para armazenar as métricas test_loss = 0 correct = 0 total = 0 # faça um loop sobre o carregador de dados de teste para imagens, rótulos em test_loader: # mova as imagens e rótulos para o dispositivo images = images.to(device) labels = labels.to(device) # passe adiante as imagens através do modelo e obtenha a saída output = model(images) # calcule a perda usando o critério loss = critérios(output, labels) # adicione a perda à perda do teste test_loss += loss.item() # obtém os rótulos previstos encontrando o índice do valor máximo em cada linha de saída _, predito = arch.max(output, 1) # adiciona o número de previsões corretas para corrigir correto += (previsto == rótulos).sum().item() # adiciona o número de amostras ao total total += labels.size(0) # calcula a perda média do teste test_loss = test_loss / len(test_loader) # calcula a precisão exatidão = correto / total # imprime algumas estatísticas print(f"Perda de teste: perda_teste:.4f") print(f"Precisão do teste: precisão:.4f")

A saída deve ser algo como isto:

Perda de teste: 0,0579 Precisão do teste: 0,9823

Podemos ver que nosso modelo alcançou uma baixa perda de teste e uma alta precisão de teste, o que significa que ele pode reconhecer corretamente a maioria dos dígitos no conjunto de dados de teste.

Para visualizar alguns resultados, podemos usar a biblioteca matplotlib para plotar algumas imagens de amostra e seus rótulos previstos. Também podemos compará-los com seus verdadeiros rótulos e ver se eles combinam ou não.

import matplotlib.pyplot as plt # obtém algumas imagens aleatórias do conjunto de dados de teste images, labels = next(iter(test_loader)) # move-as para a cpu para plotar imagens = images.to("cpu") labels = labels.to("cpu") # obtém suas previsões do modelo output = model(images) _, predict = arch.max(output, 1) # cria uma figura com uma grade de subplots fig, axes = plt.subplots(n linhas=4, ncols=4, figsize=(10,10)) # faz um loop sobre cada subtrama e plota uma imagem e sua previsão para i, ax in enumerate(axes.flatten()): # obtém uma imagem e sua previsão image = images[i] predição = previsto[i] # remove a dimensão do canal e a compacta em um array numpy image = image.squeeze().numpy() # plota a imagem usando o mapa de cores em tons de cinza ax.imshow(image, cmap="gray") # define o title como "Previsto: x" ax.set_title(f"Previsto: prediction.item()") # desativa marcações e rótulos do eixo ax.axis("off") # mostra a figura plt.show()

A saída deve ser algo como isto:

Podemos ver que a maioria das previsões está correta, exceto em alguns casos em que o modelo é confundido por alguns dígitos semelhantes, como 4 e 9, ou 3 e 8.

Conclusão

Neste artigo, mostramos como baixar e usar o conjunto de dados MNIST no PyTorch para classificação de imagens. Cobrimos as seguintes etapas:

Baixando o conjunto de dados MNIST usando a classe PyTorch DataLoader

Definindo um modelo de rede neural para classificação de imagens

Escolhendo uma função de perda e um otimizador para treinar o modelo

Avaliando o modelo no conjunto de dados de teste e visualizando os resultados

Vimos que o PyTorch fornece várias ferramentas e módulos que tornam fácil e conveniente trabalhar com dados, modelos, treinamento, avaliação e visualização. Também vimos que nosso modelo pode atingir uma alta precisão no conjunto de dados de teste, o que significa que ele pode reconhecer corretamente a maioria dos dígitos manuscritos.

No entanto, ainda há espaço para melhorias e experimentação.Por exemplo, você pode experimentar diferentes arquiteturas, hiperparâmetros, funções de perda, otimizadores, etc. para ver como eles afetam o desempenho do modelo. Você também pode experimentar diferentes conjuntos de dados, como Fashion-MNIST ou CIFAR10, para ver como o modelo se generaliza para diferentes tipos de imagens. Você também pode explorar alguns tópicos avançados, como aumento de dados, regularização, aprendizagem por transferência, etc., para aprimorar ainda mais suas habilidades e conhecimentos.

Esperamos que você tenha gostado deste artigo e aprendido algo novo e útil. Se você quiser saber mais sobre o PyTorch e a classificação de imagens, aqui estão alguns links e referências que você pode conferir:

perguntas frequentes

Aqui estão algumas perguntas frequentes e suas respostas sobre como baixar e usar o conjunto de dados MNIST no PyTorch para classificação de imagens.

P: Qual é a diferença entre maçarico.datasets.MNIST e maçarico.datasets.FashionMNIST?

R: archvision.datasets.MNIST é uma classe que baixa e carrega o conjunto de dados MNIST de imagens de dígitos manuscritos. archvision.datasets.FashionMNIST é uma classe que baixa e carrega o conjunto de dados Fashion-MNIST de imagens de itens de vestuário. Ambos os conjuntos de dados têm o mesmo formato e tamanho, mas conteúdo diferente.

P: Como posso alterar a resolução das imagens no conjunto de dados MNIST?

R: Você pode usar a transformação archvision.transforms.Resize() para alterar a resolução das imagens no conjunto de dados MNIST. Por exemplo, se quiser redimensionar as imagens para 32x32 pixels, você pode usar transform = transforms.Resize((32, 32)). Você também pode usar outras transformações, como transforms.CenterCrop(), transforms.RandomCrop(), transforms.RandomResizedCrop(), etc. para alterar o tamanho e a forma das imagens.

P: Como posso salvar e carregar o modelo que treinei no conjunto de dados MNIST?

R: Você pode usar as funções maçarico.save() e maçarico.carregar() para salvar e carregar o modelo que você treinou no conjunto de dados MNIST. Por exemplo, se quiser salvar o modelo em um arquivo chamado "model.pth", você pode usar arch.save(model.state_dict(), "model.pth"). Se você deseja carregar o modelo desse arquivo, pode usar model.load_state_dict(torch.load("model.pth")). Você também pode salvar e carregar outros objetos, como otimizadores, funções de perda, etc.

P: Como posso usar a GPU para acelerar a computação e melhorar o desempenho do modelo?

R: Você pode usar GPU para acelerar a computação e melhorar o desempenho do modelo movendo [user](# o modelo e os dados para o dispositivo que suporta GPU. Você pode usar a função arch.device() para especificar o dispositivo e os métodos model.to() e data.to() para mover o modelo e os dados para o dispositivo. Por exemplo, se você quiser usar GPU, você pode usar device = maçarico.device("cuda" if maçarico.cuda.is_available() else "cpu"). (device) e data.to(device) para mover o modelo e os dados para a GPU.

P: Como posso melhorar a precisão do modelo no conjunto de dados MNIST?

R: Há muitas maneiras de melhorar a precisão do modelo no conjunto de dados MNIST, como usar uma arquitetura diferente, ajustar os hiperparâmetros, adicionar regularização, usar aumento de dados etc. Aqui estão algumas dicas e sugestões que você pode tentar:

Use uma arquitetura diferente: você pode experimentar diferentes tipos e números de camadas, como camadas convolucionais, camadas de pooling, camadas totalmente conectadas, camadas de eliminação, camadas de normalização em lote etc.

Ajuste os hiperparâmetros: Você pode ajustar alguns parâmetros que afetam o treinamento e o desempenho do modelo, como taxa de aprendizado, tamanho do lote, número de épocas, número de filtros, tamanho do kernel, passo, preenchimento etc.

Adicionar regularização: você pode adicionar algumas técnicas que evitam o overfitting e melhoram a generalização do modelo, como dropout, decaimento de peso, parada precoce, etc. Dropout elimina aleatoriamente alguns neurônios durante o treinamento para reduzir a coadaptação e aumentar a diversidade. O decaimento do peso adiciona um termo de penalidade à função de perda que reduz os parâmetros do modelo para zero. A parada antecipada interrompe o treinamento quando a perda de validação para de melhorar ou começa a aumentar.

Usar aumento de dados: você pode aplicar algumas transformações às imagens para aumentar o tamanho e a diversidade do conjunto de dados, como inversão, rotação, corte, dimensionamento, deslocamento, adição de ruído, alteração de brilho, contraste, matiz, saturação etc. O aumento de dados pode ajudar o modelo a aprender mais recursos e ser mais robusto a variações na entrada.

0517a86e26

Baixar Conjunto de Dados MNIST PyTorch - um conjunto de dados de imagens de dígitos escritos à mão q

Como baixar e usar o conjunto de dados MNIST no PyTorch para classificação de imagens

download mnist dataset pytorch

Baixando o conjunto de dados MNIST usando a classe PyTorch DataLoader

Baixando o conjunto de dados MNIST usando a classe PyTorch DataLoader

Definindo um modelo de rede neural para classificação de imagens

Escolhendo uma função de perda e um otimizador para treinar o modelo

Avaliando o modelo no conjunto de dados de teste e visualizando os resultados

Conclusão

perguntas frequentes

P: Qual é a diferença entre maçarico.datasets.MNIST e maçarico.datasets.FashionMNIST?

P: Como posso alterar a resolução das imagens no conjunto de dados MNIST?

P: Como posso salvar e carregar o modelo que treinei no conjunto de dados MNIST?

P: Como posso usar a GPU para acelerar a computação e melhorar o desempenho do modelo?

P: Como posso melhorar a precisão do modelo no conjunto de dados MNIST?

Recent Posts

Comments