Como baixar o conjunto de dados MNIST usando Python
Se você estiver interessado em aprender aprendizado de máquina, especialmente aprendizado profundo, talvez já tenha ouvido falar do conjunto de dados MNIST. É um dos conjuntos de dados mais populares e amplamente utilizados para treinar e testar vários sistemas de processamento e reconhecimento de imagens. Neste artigo, você aprenderá o que é o conjunto de dados MNIST, por que ele é útil para aprendizado de máquina e como baixá-lo usando três bibliotecas Python diferentes: NumPy, Scikit-learn e TensorFlow Datasets.
download mnist dataset python
O que é o conjunto de dados MNIST?
O conjunto de dados MNIST significa Modified National Institute of Standards and Technology database. É um grande banco de dados de dígitos manuscritos que contém 60.000 imagens de treinamento e 10.000 imagens de teste. Cada imagem é uma imagem em tons de cinza de tamanho 28 x 28 pixels, com um dígito de 0 a 9 escrito nela. O conjunto de dados foi criado remixando as amostras dos conjuntos de dados originais do NIST, que foram coletados de funcionários do American Census Bureau e alunos do ensino médio. O conjunto de dados MNIST é considerado uma referência para avaliar o desempenho de vários modelos de aprendizado de máquina em tarefas de classificação de imagens.
Por que é útil para aprendizado de máquina?
O conjunto de dados MNIST é útil para aprendizado de máquina porque fornece uma maneira simples e fácil de começar a processar e reconhecer imagens. O conjunto de dados é pequeno o suficiente para caber na memória, mas grande o suficiente para representar uma variedade de estilos e padrões de caligrafia. O conjunto de dados também é bem balanceado, o que significa que cada dígito tem aproximadamente o mesmo número de imagens nos conjuntos de treinamento e teste. O conjunto de dados é ideal para iniciantes que desejam aprender a criar, treinar e testar modelos de aprendizado de máquina usando bibliotecas Python.
Como acessá-lo usando bibliotecas Python?
Existem muitas bibliotecas Python que podem ajudá-lo a acessar e manipular o conjunto de dados MNIST.Neste artigo, vamos nos concentrar em três deles: NumPy, Scikit-learn e TensorFlow Datasets. Essas bibliotecas são amplamente utilizadas para computação científica, aprendizado de máquina e aprendizado profundo, respectivamente. Eles fornecem diferentes maneiras de carregar, explorar e visualizar o conjunto de dados MNIST. Vamos ver como eles funcionam em detalhes.
Baixando o conjunto de dados MNIST com NumPy
Instalando o NumPy
NumPy é uma biblioteca numérica de código aberto que pode ser usada para executar várias operações matemáticas em arrays e matrizes. É uma das bibliotecas de computação científica mais usadas e frequentemente usada por cientistas de dados para análise de dados. Para instalar o NumPy, você pode usar o comando pip em seu terminal ou prompt de comando:
pip instalar numpy
Se você já possui o NumPy instalado, pode pular esta etapa.
Carregando o conjunto de dados MNIST do NumPy
Para carregar o conjunto de dados MNIST do NumPy, você precisa baixar quatro arquivos deste . Esses arquivos são:
train-images-idx3-ubyte.gz: imagens do conjunto de treinamento (9912422 bytes)
train-labels-idx1-ubyte.gz: rótulos do conjunto de treinamento (28881 bytes)
t10k-images-idx3-ubyte.gz: imagens do conjunto de teste (1648877 bytes)
t10k-labels-idx1-ubyte.gz : rótulos de conjunto de teste (4542 bytes)
Depois de baixar esses arquivos, você precisa descompactá-los e colocá-los em uma pasta chamada "mnist" em seu diretório de trabalho atual. Você pode usar qualquer ferramenta para descompactar os arquivos, como 7-Zip ou WinRAR. Em seguida, você pode usar o seguinte código Python para carregar o conjunto de dados MNIST do NumPy:
import numpy as np import gzip # Defina uma função para ler os dados dos arquivos def read_data(images_file, labels_file): # Abra os arquivos e leia os bytes com gzip.open(images_file, 'rb') as f: images_data = f.read() with gzip.open(labels_file, 'rb') as f: labels_data = f.read() # Converta os bytes para numpy arrays images = np.frombuffer(image s_data, dtype=np.uint8, offset=16) labels = np.frombuffer(labels_data, dtype=np.uint8, offset=8) # Reformule os arrays para a forma desejada images = images.reshape(-1, 28, 28) labels = labels.reshape(-1) # Retorna as imagens e labels arrays return images, labels # Define os nomes dos arquivos train_images_file = 'mnist/train-images- idx3-ubyte.gz' train_labels_file = 'mnist/train-labels-idx1-ubyte.gz' test_images_file = 'mnist/t10k-images-idx3-ubyte.gz' test_labels_file = 'mnist/t10k-labels-idx1-ubyte.gz' # Carregue os dados usando a função train_images, train_labels = read_data( train_images_file, train_labels_file) test_images, test_labels = read_data(test_images_file, test_labels_file)
Explorando a estrutura e a forma dos dados
Agora que carregamos o conjunto de dados MNIST do NumPy, podemos explorar sua estrutura e forma. Podemos usar o atributo de forma de matrizes numpy para verificar as dimensões dos dados. Também podemos usar a função type para verificar o tipo de dados dos arrays. Aqui está um exemplo:
# Imprima a forma e o tipo da matriz de imagens do trem print(train_images.shape) print(type(train_images)) # Imprima a forma e o tipo da matriz de etiquetas do trem print(train_labels.shape) print(type(train_labels)) # Imprima a forma e o tipo da matriz de imagens de teste print(test_images.shape) print(type(test_images)) # Imprima a forma e o tipo da matriz de etiquetas de teste print(test_labels.shape) print(type(test) _rótulos))
A saída deve ficar assim:
(60000, 28, 28)
(60000,)
(10000, 28, 28)
(10000,)
Como podemos ver, a matriz de imagens do trem tem uma forma de (60000, 28, 28), o que significa que contém 60.000 imagens de tamanho 28 x 28 pixels.A matriz de rótulos do trem tem uma forma de (60000,), o que significa que contém 60.000 rótulos correspondentes a cada imagem. O mesmo se aplica às matrizes de imagens e rótulos de teste, exceto que elas contêm 10.000 amostras cada. O tipo de dados de todas as matrizes é numpy.ndarray, que é um objeto de matriz multidimensional que pode armazenar dados numéricos com eficiência.
Visualizando algumas imagens de amostra
Para visualizar algumas imagens de amostra do conjunto de dados MNIST, podemos usar a biblioteca matplotlib.pyplot. Esta biblioteca fornece várias funções para plotar e exibir gráficos e imagens. Para instalar matplotlib.pyplot, você pode usar o comando pip em seu terminal ou prompt de comando:
pip instalar matplotlib
Se você já tiver o matplotlib.pyplot instalado, pode pular esta etapa.
Para plotar algumas imagens de amostra do conjunto de dados MNIST, podemos usar a função imshow de matplotlib.pyplot. Esta função recebe um array como entrada e o exibe como uma imagem. Também podemos usar a função subplots para criar vários gráficos em uma figura. Aqui está um exemplo:
import matplotlib.pyplot as plt # Defina uma função para plotar algumas imagens de amostra def plot_images(images, labels): # Crie uma figura com 2 linhas e 5 colunas fig, axes = plt.subplots(2, 5) # Percorra cada subplot e plote uma imagem com seu rótulo para i in range(2): for j in range(5): # Obtenha um índice aleatório do array de imagens index = np.random.randint(len(images)) # Plote a imagem na posição (i,j) axes[i,j].imshow(images[index], cmap='gray') # Defina o título como o rótulo da imagem axes[i,j].set_title (labels[index]) # Remova os marcadores e rótulos dos eixos axes[i,j].set_xticks([]) axes[i,j].set_yticks([]) # Mostre a figura plt.show() # Plote algumas imagens de amostra from the train set plot_images(train_images, train_labels) # Plote algumas imagens de amostra do conjunto de teste plot_images(test_images, test_labels)
A saída deve ficar assim:
Como podemos ver, as imagens são em tons de cinza e mostram diferentes dígitos manuscritos de 0 a 9. Os rótulos também são exibidos como títulos de cada subtrama. Podemos observar que alguns dígitos são fáceis de reconhecer, enquanto outros são mais difíceis ou ambíguos.
Baixando o conjunto de dados MNIST com Scikit-learn
Instalando o Scikit-learn
O Scikit-learn é uma biblioteca de aprendizado de máquina de código aberto que fornece várias ferramentas e algoritmos para análise de dados, pré-processamento, extração de recursos, classificação, regressão, agrupamento e muito mais. É uma das bibliotecas de aprendizado de máquina mais usadas e frequentemente usada por cientistas de dados para construir e avaliar modelos de aprendizado de máquina. Para instalar o Scikit-learn, você pode usar o comando pip em seu terminal ou prompt de comando:
pip instalar scikit-learn
Se você já tiver o Scikit-learn instalado, pode pular esta etapa.
Carregando o conjunto de dados MNIST do Scikit-learn
Para carregar o conjunto de dados MNIST do Scikit-learn, você pode usar a função fetch_openml do módulo sklearn.datasets. Essa função pode buscar qualquer conjunto de dados do repositório OpenML, que é uma plataforma online para compartilhamento e colaboração em conjuntos de dados e tarefas de aprendizado de máquina. O conjunto de dados MNIST está disponível no OpenML com o nome "mnist_784". Você pode usar o seguinte código Python para carregar o conjunto de dados MNIST do Scikit-learn:
from sklearn.datasets import fetch_openml # Carrega o conjunto de dados MNIST do OpenML mnist = fetch_openml('mnist_784') # Imprime o tipo e as chaves do objeto mnist print(type(mnist)) print(mnist.keys())
A saída deve ficar assim:
dict_keys(['data', 'target', 'frame', 'categories', 'feature_names', 'target_names', 'details', 'url'])
Como podemos ver, o objeto mnist é um objeto Bunch, que é um objeto semelhante a um dicionário que contém vários atributos relacionados ao conjunto de dados. Os mais importantes são:
data: uma matriz numpy de forma (70000, 784) que contém os valores de pixel de cada imagem como um vetor achatado.
target: uma matriz numpy de forma (70000,) que contém os rótulos de cada imagem como strings.
quadro: um quadro de dados pandas de forma (70000, 785) que contém os dados e o destino como colunas.
categorias: um dicionário que mapeia cada nome de recurso categórico para uma lista de valores possíveis.
feature_names: uma lista de strings que contém os nomes de cada feição (pixel).
target_names: uma lista de strings que contém os nomes de cada classe de destino (dígito).
details: um dicionário que contém metadados sobre o conjunto de dados, como nome, descrição, citação, etc.
url: uma string que contém a URL do conjunto de dados no OpenML.
Explorando a estrutura e a forma dos dados
Agora que carregamos o conjunto de dados MNIST do Scikit-learn, podemos explorar sua estrutura e forma. Podemos usar o atributo de forma de arrays numpy e dataframes de pandas para verificar as dimensões dos dados. Também podemos usar a função type para verificar o tipo de dados dos arrays e dataframes. Aqui está um exemplo:
# Imprima a forma e o tipo da matriz de dados print(mnist.data.shape) print(type(mnist.data)) # Imprima a forma e o tipo da matriz de destino print(mnist.target.shape) print(type(mnist.target)) # Imprima a forma e o tipo do frame dataframe print(mnist.frame.shape) print(type(mnist.frame))
A saída deve ficar assim:
(70000, 784)
(70000,)
(70000, 785)
Como podemos ver, a matriz de dados tem uma forma de (70000, 784), o que significa que contém 70.000 imagens de tamanho 28 x 28 pixels, mas achatadas em um vetor de 784 elementos. A matriz de destino tem uma forma de (70000,), o que significa que contém 70.000 rótulos correspondentes a cada imagem. O quadro de dados do quadro tem uma forma de (70000, 785), o que significa que contém os dados e o destino como colunas, com uma coluna extra para o índice.O tipo de dados de todos os arrays e dataframes é numpy.ndarray ou pandas.core.frame.DataFrame, que são estruturas de dados eficientes e flexíveis para armazenar e manipular dados numéricos.
Visualizando algumas imagens de amostra
Para visualizar algumas imagens de amostra do conjunto de dados MNIST, podemos usar a biblioteca matplotlib.pyplot novamente. No entanto, desta vez, precisamos remodelar a matriz de dados de volta à sua forma de imagem original de 28 x 28 pixels antes de plotá-la. Podemos usar a função reshape do numpy para fazer isso. Aqui está um exemplo:
import matplotlib.pyplot as plt # Defina uma função para plotar algumas imagens de amostra def plot_images(data, target): # Crie uma figura com 2 linhas e 5 colunas fig, axes = plt.subplots(2, 5) # Percorra cada subplot e plote uma imagem com seu rótulo para i in range(2): for j in range(5): # Obtenha um índice aleatório do array de dados index = np.random.randint(len(data)) # Resha pe o array de dados para sua forma de imagem original image = data[index].reshape(28, 28) # Plote a imagem na posição (i,j) axes[i,j].imshow(image, cmap='gray') # Defina o título como o rótulo da imagem axes[i,j].set_title(target[index]) # Remova os marcadores e rótulos dos eixos axes[i,j].set_xticks([]) axes[i,j]. set_yticks([]) # Mostra a figura plt.show() # Plota algumas imagens de amostra dos arrays de dados e alvo plot_images(mnist.data, mnist.target)
A saída deve ficar assim:
Como podemos ver, as imagens são em tons de cinza e mostram diferentes dígitos manuscritos de 0 a 9. Os rótulos também são exibidos como títulos de cada subtrama. Podemos observar que alguns dígitos são fáceis de reconhecer, enquanto outros são mais difíceis ou ambíguos.
Baixando o conjunto de dados MNIST com conjuntos de dados do TensorFlow
Como instalar conjuntos de dados do TensorFlow
O TensorFlow Datasets é uma biblioteca de código aberto que fornece vários conjuntos de dados para o TensorFlow e outras estruturas de aprendizado de máquina. É uma das bibliotecas de aprendizado profundo mais usadas e frequentemente usada por cientistas de dados para construir e treinar redes neurais. Para instalar conjuntos de dados do TensorFlow, você pode usar o comando pip em seu terminal ou prompt de comando:
pip instalar tensorflow-datasets
Se você já tiver conjuntos de dados do TensorFlow instalados, pode pular esta etapa.
Carregando o conjunto de dados MNIST dos conjuntos de dados do TensorFlow
Para carregar o conjunto de dados MNIST dos conjuntos de dados do TensorFlow, você pode usar a função load do módulo tfds. Essa função pode carregar qualquer conjunto de dados do catálogo TensorFlow Datasets, que é uma coleção de conjuntos de dados prontos para uso para aprendizado de máquina. O conjunto de dados MNIST está disponível nos conjuntos de dados do TensorFlow com o nome "mnist". Você pode usar o seguinte código Python para carregar o conjunto de dados MNIST dos conjuntos de dados do TensorFlow:
import tensorflow_datasets as tfds # Carrega o conjunto de dados MNIST de TensorFlow Datasets mnist = tfds.load('mnist') # Imprime o tipo e as chaves do objeto mnist print(type(mnist)) print(mnist.keys())
A saída deve ficar assim:
dict_keys(['teste', 'treinar'])
Como podemos ver, o objeto mnist é um dicionário que contém duas chaves: test e train. Essas chaves correspondem a dois objetos tf.data.Dataset que contêm os conjuntos de teste e treinamento do conjunto de dados MNIST, respectivamente. Um objeto tf.data.Dataset é uma abstração de alto nível que representa uma sequência de elementos, onde cada elemento consiste em um ou mais componentes (recursos). Um objeto tf.data.Dataset pode ser usado para criar pipelines de entrada eficientes para modelos de aprendizado de máquina.
Explorando a estrutura e a forma dos dados
Agora que carregamos o conjunto de dados MNIST dos conjuntos de dados do TensorFlow, podemos explorar sua estrutura e forma. Podemos usar a função take de tf.data.Dataset para obter um elemento de amostra de cada conjunto. Também podemos usar a função type para verificar o tipo de dados de cada elemento.Aqui está um exemplo:
# Obtenha um elemento de amostra do conjunto de teste test_element = next(iter(mnist['test'].take(1))) # Imprima o tipo e as chaves do elemento de teste print(type(test_element)) print(test_element.keys()) # Obtenha um elemento de amostra do conjunto de trem train_element = next(iter(mnist['train'].take(1))) # Imprima o tipo e as chaves do elemento train print(type(train_element)) print(train_ele ment.keys())
A saída deve ficar assim:
dict_keys(['imagem', 'rótulo'])
dict_keys(['imagem', 'rótulo'])
Como podemos ver, cada elemento é um dicionário que contém duas chaves: image e label. Essas chaves correspondem a dois objetos tensorflow.Tensor que contêm os valores de pixel e o rótulo de cada imagem, respectivamente. Um objeto tensorflow.Tensor é uma matriz multidimensional que pode armazenar dados numéricos de vários tipos e formas. Um objeto tensorflow.Tensor pode ser usado para executar várias operações e cálculos para modelos de aprendizado de máquina.
# Imprime a forma e o tipo do tensor da imagem print(test_element['image'].shape) print(type(test_element['image'])) # Imprime a forma e o tipo do tensor da etiqueta print(test_element['label'].shape) print(type(test_element['label']))
A saída deve ficar assim:
(28, 28, 1)
()
Como podemos ver, o tensor da imagem tem uma forma de (28, 28, 1), o que significa que contém uma imagem de tamanho 28 x 28 pixels com um canal (escala de cinza). O tensor de rótulo tem uma forma de (), o que significa que contém um valor escalar (o dígito). O tipo de dados de ambos os tensores é tensorflow.python.framework.ops.EagerTensor, que é um objeto tensor que pode ser avaliado imediatamente sem construir um gráfico computacional.
Visualizando algumas imagens de amostra
Para visualizar algumas imagens de amostra do conjunto de dados MNIST, podemos usar a biblioteca matplotlib.pyplot novamente. No entanto, desta vez, precisamos converter o tensor da imagem em um array numpy antes de plotá-lo. Podemos usar a função numpy do tensorflow para fazer isso. Aqui está um exemplo:
import matplotlib.pyplot as plt # Defina uma função para plotar algumas imagens de amostra def plot_images(data): # Crie uma figura com 2 linhas e 5 colunas fig, axes = plt.subplots(2, 5) # Percorra cada subtrama e plote uma imagem com seu rótulo para i in range(2): for j in range(5): # Obtenha um elemento de amostra do elemento de dados = next(iter(data.take(1))) # Converta o tensor da imagem em um array numpy image = element['image'].numpy() # Plote a imagem na posição (i,j) axes[i,j].imshow(image.squeeze(), cmap='gray') # Defina o título como o rótulo da imagem axes[i,j].set_title(element['label'].numpy()) # Remova os marcadores e rótulos dos eixos axes[i,j].set_xticks([]) axes[i,j].set _yticks([]) # Mostra a figura plt.show() # Plota algumas imagens de amostra do conjunto de teste plot_images(mnist['test']) # Plota algumas imagens de amostra do conjunto de trem plot_images(mnist['train'])
A saída deve ficar assim:
Como podemos ver, as imagens são em tons de cinza e mostram diferentes dígitos manuscritos de 0 a 9. Os rótulos também são exibidos como títulos de cada subtrama. Podemos observar que alguns dígitos são fáceis de reconhecer, enquanto outros são mais difíceis ou ambíguos.
Conclusão
Neste artigo, você aprendeu como baixar o conjunto de dados MNIST usando três bibliotecas Python diferentes: NumPy, Scikit-learn e TensorFlow Datasets. Você também aprendeu a explorar e visualizar a estrutura de dados e a forma de cada biblioteca. Você pode usar qualquer uma dessas bibliotecas para acessar e manipular o conjunto de dados MNIST para seus projetos de aprendizado de máquina. No entanto, cada biblioteca tem suas próprias vantagens e desvantagens, dependendo de suas necessidades e preferências. Aqui estão algumas recomendações para o aprendizado adicional:
Se você quiser aprender mais sobre NumPy, você pode conferir isso que cobre os fundamentos das matrizes e operações NumPy.
Se você quiser aprender mais sobre o Scikit-learn, você pode conferir este que abrange os fundamentos dos modelos e pipelines de aprendizado de máquina do Scikit-learn.
Se você quiser saber mais sobre os conjuntos de dados do TensorFlow, confira este que abrange os fundamentos do aprendizado de máquina e aprendizado profundo com Python.
Esperamos que você tenha gostado deste artigo e aprendido algo novo. Se você tiver alguma dúvida ou feedback, sinta-se à vontade para deixar um comentário abaixo. Feliz aprendizado!
perguntas frequentes
Qual é a diferença entre o conjunto de dados MNIST e o conjunto de dados Fashion MNIST?
O conjunto de dados Fashion MNIST é uma variante do conjunto de dados MNIST que contém imagens de itens de vestuário em vez de dígitos manuscritos. Tem a mesma estrutura e tamanho do conjunto de dados MNIST, mas é mais desafiador e realista para tarefas de classificação de imagens. Você pode baixar o conjunto de dados Fashion MNIST usando as mesmas bibliotecas Python que o conjunto de dados MNIST, mas com um nome diferente: "fashion_mnist".
Como posso dividir o conjunto de dados MNIST em conjuntos de treinamento, validação e teste?
Existem diferentes maneiras de dividir o conjunto de dados MNIST em conjuntos de treinamento, validação e teste, dependendo da biblioteca Python que você usa. Por exemplo, com NumPy, você pode usar a função np.split para dividir os dados e as matrizes de destino em diferentes subconjuntos. Com o Scikit-learn, você pode usar a função train_test_split do módulo sklearn.model_selection para dividir os dados e as matrizes de destino em subconjuntos aleatórios. Com os conjuntos de dados do TensorFlow, você pode usar a função as_dataset com o argumento split para obter diferentes subconjuntos dos dados como objetos tf.data.Dataset.
Como posso normalizar ou padronizar o conjunto de dados MNIST?
Normalizar ou padronizar o conjunto de dados MNIST significa dimensionar os valores de pixel de cada imagem para um determinado intervalo ou distribuição.Isso pode ajudar a melhorar o desempenho e a convergência dos modelos de aprendizado de máquina. Existem diferentes maneiras de normalizar ou padronizar o conjunto de dados MNIST, dependendo da biblioteca Python que você usa. Por exemplo, com NumPy, você pode usar a função np.divide para dividir cada valor de pixel por 255, que os escalará para o intervalo [0, 1]. Com o Scikit-learn, você pode usar as classes StandardScaler ou MinMaxScaler do módulo sklearn.preprocessing para transformar cada valor de pixel para ter média zero e variação de unidade ou para um determinado intervalo, respectivamente. Com conjuntos de dados do TensorFlow, você pode usar a função map com uma função lambda personalizada para aplicar qualquer operação de dimensionamento a cada tensor de imagem.
Como posso aumentar ou transformar o conjunto de dados MNIST?
Aumentar ou transformar o conjunto de dados MNIST significa aplicar algumas alterações aleatórias ou determinísticas a cada imagem, como rotação, translação, dimensionamento, inversão, corte, ruído etc. Isso pode ajudar a aumentar a diversidade e a robustez dos modelos de aprendizado de máquina. Existem diferentes maneiras de aumentar ou transformar o conjunto de dados MNIST, dependendo da biblioteca Python que você usa. Por exemplo, com NumPy, você pode usar as funções np.rot90, np.flip, np.pad, np.random.normal para girar, inverter, pad ou adicionar ruído a cada matriz de imagem, respectivamente. Com o Scikit-learn, você pode usar as classes RandomRotation, RandomTranslation, RandomResizedCrop do módulo sklearn.preprocessing.image para aplicar rotação, translação ou recorte aleatório a cada matriz de imagem, respectivamente. Com conjuntos de dados do TensorFlow, você pode usar a função map com uma função lambda personalizada ou uma função predefinida do módulo tf.image para aplicar qualquer operação de aumento ou transformação a cada tensor de imagem.
Como posso salvar ou exportar o conjunto de dados MNIST?
Salvar ou exportar o conjunto de dados MNIST significa armazená-lo em um formato de arquivo que pode ser usado por outros aplicativos ou plataformas. Existem diferentes maneiras de salvar ou exportar o conjunto de dados MNIST, dependendo da biblioteca Python que você usa.Por exemplo, com NumPy, você pode usar as funções np.save ou np.savetxt para salvar cada array como um arquivo binário ou de texto, respectivamente. Com o Scikit-learn , você pode usar as funções dump ou dumps do módulo sklearn.externals.joblib para salvar cada array como pickle ou string, respectivamente. Com conjuntos de dados do TensorFlow, você pode usar a função as_numpy para converter cada objeto tf.data.Dataset em uma matriz numpy e, em seguida, usar qualquer um dos métodos acima para salvá-lo. Como alternativa, você pode usar a função tf.data.experimental.save para salvar cada objeto tf.data.Dataset como um formato TensorFlow SavedModel. 0517a86e26
Comments