S40L12 – Um classificador simples de dígitos

html
Construindo uma Rede Neural Simples para Classificação de Dígitos com Keras e MNIST

Índice

    Introdução às Redes Neurais para Classificação de Dígitos
    Compreendendo o Conjunto de Dados MNIST
    Configurando o Ambiente
    Carregando e Explorando o Conjunto de Dados MNIST
    Pré-processamento de Dados: Remodelagem e Codificação One-Hot
    Construindo o Modelo de Rede Neural com Keras
        
            Arquitetura do Modelo
            Explicação das Camadas
        
    
    Compilando o Modelo: Função de Perda e Otimizador
    Treinando o Modelo: Ajuste e Validação
    Avaliando o Modelo: Precisão e Previsões
    Visualizando a Estrutura da Rede Neural
    Otimização do Treinamento: Utilizando GPUs
    Conclusão




Introdução às Redes Neurais para Classificação de Dígitos 
As redes neurais revolucionaram a maneira como as máquinas interpretam e analisam dados, especialmente no domínio do reconhecimento de imagens. A classificação de dígitos, onde o objetivo é identificar com precisão dígitos manuscritos, serve como um exemplo quintessencial para iniciantes compreenderem os fundamentos das redes neurais. Ao aproveitar bibliotecas populares como Keras e conjuntos de dados como MNIST, construir um classificador de dígitos eficaz torna-se acessível e educacional.

Compreendendo o Conjunto de Dados MNIST 
O MNIST (Modified National Institute of Standards and Technology) é um pilar na comunidade de aprendizado de máquina. Ele compreende 70.000 imagens em escala de cinza de dígitos manuscritos (0-9), cada uma com tamanho de 28x28 pixels. O conjunto de dados é dividido em 60.000 imagens de treinamento e 10.000 imagens de teste, tornando-o ideal para treinar e validar modelos de aprendizado de máquina.

Características Principais do MNIST:

    Tamanho: 70.000 imagens (60k treinamento, 10k teste)
    Dimensões das Imagens: 28x28 pixels
    Classes: 10 (dígitos de 0 a 9)
    Escala de Cinza: Cada valor de pixel varia de 0 (preto) a 255 (branco)


Configurando o Ambiente 
Antes de mergulhar no processo de construção do modelo, é essencial configurar o ambiente de desenvolvimento. Certifique-se de ter o Python instalado e considere usar ambientes como Anaconda para gerenciar pacotes e dependências de forma eficiente.

Bibliotecas Necessárias:

    NumPy: Para operações numéricas
    Matplotlib: Para visualização de dados
    Keras: Para construir e treinar redes neurais
    Scikit-learn: Para utilitários de pré-processamento
    Pandas: Para manipulação de dados


Comandos de Instalação:




		
		
			
			
Java
			
			pip install numpy matplotlib keras scikit-learn pandas
			
				
					
				
					1
				
						pip install numpy matplotlib keras scikit-learn pandas
					
				
			
		



Carregando e Explorando o Conjunto de Dados MNIST 
O Keras simplifica o processo de acesso ao conjunto de dados MNIST através de seu módulo datasets. Veja como você pode carregar e inspecionar os dados:





		
		
			
			
Java
			
			import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist

# Carrega dados de dígitos manuscritos MNIST
(X_train, y_train), (X_test, y_test) = mnist.load_data()

print(X_train.shape)  # Saída: (60000, 28, 28)
print(X_test.shape)   # Saída: (10000, 28, 28)
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
 
# Carrega dados de dígitos manuscritos MNIST
(X_train, y_train), (X_test, y_test) = mnist.load_data()
 
print(X_train.shape)  # Saída: (60000, 28, 28)
print(X_test.shape)   # Saída: (10000, 28, 28)
					
				
			
		



Saída:




		
		
			
			
Java
			
			(60000, 28, 28)
(10000, 28, 28)
			
				
					
				
					1
2
				
						(60000, 28, 28)
(10000, 28, 28)
					
				
			
		



Isso revela que há 60.000 imagens de treinamento e 10.000 imagens de teste, cada uma com dimensões de 28x28 pixels.

Visualizando Imagens de Amostra
Para ter uma ideia dos dados, vamos visualizar uma imagem de amostra:





		
		
			
			
Java
			
			img = X_train[250].reshape(28,28)
plt.imshow(img, cmap="gray")
plt.title(f"Sample Digit Label: {y_train[250]}")
plt.show()
			
				
					
				
					1
2
3
4
				
						img = X_train[250].reshape(28,28)
plt.imshow(img, cmap="gray")
plt.title(f"Sample Digit Label: {y_train[250]}")
plt.show()
					
				
			
		



Saída:


Nota: A imagem real exibirá um dígito manuscrito correspondente ao rótulo.

Pré-processamento de Dados: Remodelagem e Codificação One-Hot 
O pré-processamento de dados é uma etapa crucial nos fluxos de trabalho de aprendizado de máquina. Para redes neurais, é essencial formatar os dados de maneira apropriada e codificar os rótulos.

Remodelagem dos Dados
Redes neurais requerem dados de entrada em uma forma específica. Para o conjunto de dados MNIST, vamos achatar as imagens de 28x28 pixels em uma matriz 1D de 784 elementos.





		
		
			
			
Java
			
			from keras.utils import to_categorical

# Remodela e normaliza os dados das imagens
X_train = X_train.reshape(60000, 28, 28).astype('float32') / 255
X_test = X_test.reshape(10000, 28, 28).astype('float32') / 255
			
				
					
				
					1
2
3
4
5
				
						from keras.utils import to_categorical
 
# Remodela e normaliza os dados das imagens
X_train = X_train.reshape(60000, 28, 28).astype('float32') / 255
X_test = X_test.reshape(10000, 28, 28).astype('float32') / 255
					
				
			
		



Codificação One-Hot dos Rótulos
A codificação one-hot transforma rótulos categóricos em uma matriz binária, o que é mais adequado para treinamento.





		
		
			
			
Java
			
			# Codifica os rótulos usando one-hot
y_train = to_categorical(y_train, num_classes=10)
y_test = to_categorical(y_test, num_classes=10)

print(y_train.shape)  # Saída: (60000, 10)
print(y_test.shape)   # Saída: (10000, 10)
			
				
					
				
					1
2
3
4
5
6
				
						# Codifica os rótulos usando one-hot
y_train = to_categorical(y_train, num_classes=10)
y_test = to_categorical(y_test, num_classes=10)
 
print(y_train.shape)  # Saída: (60000, 10)
print(y_test.shape)   # Saída: (10000, 10)
					
				
			
		



Saída:




		
		
			
			
Java
			
			(60000, 10)
(10000, 10)
			
				
					
				
					1
2
				
						(60000, 10)
(10000, 10)
					
				
			
		



Isso indica que cada rótulo agora está representado como um vetor binário de 10 dimensões.

Construindo o Modelo de Rede Neural com Keras 
O Keras oferece uma API amigável para construir e treinar redes neurais. Vamos construir um modelo Sequencial simples composto por várias camadas densas.

Arquitetura do Modelo 
Abaixo está uma visão geral de alto nível da estrutura do modelo:

    Camada Flatten: Converte os dados de imagem 2D em uma matriz 1D.
    Camada Densa 1: 100 neurônios com ativação sigmoid.
    Camada Densa 2: 144 neurônios com ativação sigmoid.
    Camada de Saída: 10 neurônios (um para cada dígito) com ativação softmax.


Explicação das Camadas 

    Camada Flatten: Transforma os dados de entrada de uma matriz 2D (28x28) para um vetor 1D (784) para alimentar as camadas densas.
    Camadas Densas: São camadas totalmente conectadas onde cada neurônio recebe entrada de todos os neurônios da camada anterior. As funções de ativação introduzem não-linearidade:
        
            Ativação Sigmoid: Produz valores entre 0 e 1, útil para classificação binária, mas menos comum em camadas ocultas para problemas multiclasse.
            Ativação Softmax: Converte as saídas da camada final em distribuições de probabilidade sobre as 10 classes.
        
    


Construindo o Modelo:




		
		
			
			
Java
			
			from keras.models import Sequential
from keras.layers import Dense, Flatten

# Cria um modelo de Rede Neural simples
model = Sequential()
model.add(Flatten(input_shape=(28,28)))
model.add(Dense(100, activation='sigmoid'))
model.add(Dense(144, activation='sigmoid'))
model.add(Dense(10, activation='softmax'))
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						from keras.models import Sequential
from keras.layers import Dense, Flatten
 
# Cria um modelo de Rede Neural simples
model = Sequential()
model.add(Flatten(input_shape=(28,28)))
model.add(Dense(100, activation='sigmoid'))
model.add(Dense(144, activation='sigmoid'))
model.add(Dense(10, activation='softmax'))
					
				
			
		



Resumo do Modelo
Para visualizar a estrutura do modelo e os parâmetros:





		
		
			
			
Java
			
			model.summary()
			
				
					
				
					1
				
						model.summary()
					
				
			
		



Saída:




		
		
			
			
Java
			
			Model: "sequential_1"
_______________________________________________________________
Layer (type)                 Output Shape              Param #   
===============================================================
flatten_1 (Flatten)          (None, 784)               0         
_______________________________________________________________
dense_3 (Dense)              (None, 100)               78500     
_______________________________________________________________
dense_4 (Dense)              (None, 144)               14444     
_______________________________________________________________
dense_5 (Dense)              (None, 10)                1450      
===============================================================
Total params: 94,494
Trainable params: 94,494
Non-trainable params: 0
_______________________________________________________________
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						Model: "sequential_1"
_______________________________________________________________
Layer (type)                 Output Shape              Param #   
===============================================================
flatten_1 (Flatten)          (None, 784)               0         
_______________________________________________________________
dense_3 (Dense)              (None, 100)               78500     
_______________________________________________________________
dense_4 (Dense)              (None, 144)               14444     
_______________________________________________________________
dense_5 (Dense)              (None, 10)                1450      
===============================================================
Total params: 94,494
Trainable params: 94,494
Non-trainable params: 0
_______________________________________________________________
					
				
			
		



Este resumo fornece insights sobre a forma de saída de cada camada e o número de parâmetros a serem treinados.

Compilando o Modelo: Função de Perda e Otimizador 
Antes de treinar, o modelo precisa ser compilado com uma função de perda específica e um otimizador.

    Função de Perda: Mede o quão bem as previsões do modelo correspondem aos rótulos reais.
        
            Entropia Cruzada Categórica: Adequada para problemas de classificação multiclasse.
        
    
    Otimizador: Atualiza os pesos do modelo para minimizar a função de perda.
        
            Otimizador Adam: Um método eficiente de descida de gradiente estocástico que adapta a taxa de aprendizado.
        
    


Compilando o Modelo:




		
		
			
			
Java
			
			model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc'])
			
				
					
				
					1
				
						model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc'])
					
				
			
		



Treinando o Modelo: Ajuste e Validação 
O treinamento envolve alimentar o modelo com dados e permitir que ele aprenda padrões através de múltiplas épocas.

    Épocas: Número de vezes que todo o conjunto de dados é passado pela rede.
    Dados de Validação: Usados para avaliar o desempenho do modelo em dados não vistos após cada época.


Processo de Treinamento:




		
		
			
			
Java
			
			history = model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))
			
				
					
				
					1
				
						history = model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))
					
				
			
		



Saída de Exemplo:




		
		
			
			
Java
			
			Epoch 1/10
1875/1875 [==============================] - 4s 2ms/step - loss: 0.9009 - acc: 0.7596 - val_loss: 0.3685 - val_acc: 0.8892
...
Epoch 10/10
1875/1875 [==============================] - 4s 2ms/step - loss: 0.2251 - acc: 0.9314 - val_loss: 0.2267 - val_acc: 0.9303
			
				
					
				
					1
2
3
4
5
				
						Epoch 1/10
1875/1875 [==============================] - 4s 2ms/step - loss: 0.9009 - acc: 0.7596 - val_loss: 0.3685 - val_acc: 0.8892
...
Epoch 10/10
1875/1875 [==============================] - 4s 2ms/step - loss: 0.2251 - acc: 0.9314 - val_loss: 0.2267 - val_acc: 0.9303
					
				
			
		



Ao final de 10 épocas, o modelo alcança aproximadamente 93% de precisão nos conjuntos de treinamento e validação, indicando um modelo de bom desempenho.

Avaliando o Modelo: Precisão e Previsões 
Após o treinamento, é crucial avaliar o desempenho do modelo e fazer previsões em novos dados.

Fazendo Previsões




		
		
			
			
Java
			
			# Fazendo previsões no conjunto de teste
predictions = model.predict(X_test)
			
				
					
				
					1
2
				
						# Fazendo previsões no conjunto de teste
predictions = model.predict(X_test)
					
				
			
		



Cada previsão consiste em uma distribuição de probabilidade sobre as 10 classes. Para determinar a classe prevista:





		
		
			
			
Java
			
			import numpy as np

# Converte probabilidades para rótulos de classe
predicted_classes = np.argmax(predictions, axis=1)
true_classes = np.argmax(y_test, axis=1)
			
				
					
				
					1
2
3
4
5
				
						import numpy as np
 
# Converte probabilidades para rótulos de classe
predicted_classes = np.argmax(predictions, axis=1)
true_classes = np.argmax(y_test, axis=1)
					
				
			
		



Visualizando Previsões
Vamos visualizar algumas imagens de teste junto com seus rótulos verdadeiros e previstos:





		
		
			
			
Java
			
			import matplotlib.pyplot as plt

def plot_prediction(index):
    img = X_test[index].reshape(28,28)
    plt.imshow(img, cmap="gray")
    plt.title(f"True Label: {true_classes[index]} | Predicted: {predicted_classes[index]}")
    plt.show()

# Plotando a primeira imagem de teste
plot_prediction(0)

# Plotando outra amostra
plot_prediction(25)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						import matplotlib.pyplot as plt
 
def plot_prediction(index):
    img = X_test[index].reshape(28,28)
    plt.imshow(img, cmap="gray")
    plt.title(f"True Label: {true_classes[index]} | Predicted: {predicted_classes[index]}")
    plt.show()
 
# Plotando a primeira imagem de teste
plot_prediction(0)
 
# Plotando outra amostra
plot_prediction(25)
					
				
			
		



Saída:
Exibe a imagem com títulos indicando tanto o rótulo verdadeiro quanto a previsão do modelo.

Precisão do Modelo
O modelo alcançou uma precisão de 93% no conjunto de validação, demonstrando sua capacidade de generalizar bem em dados não vistos. Para um desempenho aprimorado, ajustes adicionais e arquiteturas mais complexas podem ser explorados.

Visualizando a Estrutura da Rede Neural 
Compreender a arquitetura de uma rede neural pode ajudar a entender como os dados fluem e ocorrem as transformações. Abaixo está uma representação visual da rede neural construída:





		
		
			
			
Java
			
			import matplotlib.pyplot as plt

def draw_neural_net(ax, left, right, bottom, top, layer_sizes):
    '''
    Desenha um diagrama de rede neural.
    
    :param ax: Objeto Matplotlib Axes
    :param left: Limite esquerdo
    :param right: Limite direito
    :param bottom: Limite inferior
    :param top: Limite superior
    :param layer_sizes: Lista contendo o número de neurônios em cada camada
    '''
    n_layers = len(layer_sizes)
    v_spacing = (top - bottom)/float(max(layer_sizes))
    h_spacing = (right - left)/float(n_layers - 1)
    
    # Desenha neurônios
    for n, layer_size in enumerate(layer_sizes):
        layer_top = v_spacing*(layer_size - 1)/2. + (top + bottom)/2.
        for m in range(layer_size):
            circle = plt.Circle((n*h_spacing + left, layer_top - m*v_spacing), v_spacing/4.,
                                color='w', ec='k', zorder=4)
            ax.add_artist(circle)
    
    # Desenha conexões
    for n, (layer_size_a, layer_size_b) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])):
        layer_top_a = v_spacing*(layer_size_a - 1)/2. + (top + bottom)/2.
        layer_top_b = v_spacing*(layer_size_b - 1)/2. + (top + bottom)/2.
        for m in range(layer_size_a):
            for o in range(layer_size_b):
                line = plt.Line2D([n*h_spacing + left, (n + 1)*h_spacing + left],
                                  [layer_top_a - m*v_spacing, layer_top_b - o*v_spacing], c='k')
                ax.add_artist(line)

# Desenhando a rede neural
fig = plt.figure(figsize=(12, 12))
ax = fig.gca()
ax.axis('off')
draw_neural_net(ax, .1, .9, .1, .9, [784, 100, 144, 10])
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
				
						import matplotlib.pyplot as plt
 
def draw_neural_net(ax, left, right, bottom, top, layer_sizes):
    '''
    Desenha um diagrama de rede neural.
    
    :param ax: Objeto Matplotlib Axes
    :param left: Limite esquerdo
    :param right: Limite direito
    :param bottom: Limite inferior
    :param top: Limite superior
    :param layer_sizes: Lista contendo o número de neurônios em cada camada
    '''
    n_layers = len(layer_sizes)
    v_spacing = (top - bottom)/float(max(layer_sizes))
    h_spacing = (right - left)/float(n_layers - 1)
    
    # Desenha neurônios
    for n, layer_size in enumerate(layer_sizes):
        layer_top = v_spacing*(layer_size - 1)/2. + (top + bottom)/2.
        for m in range(layer_size):
            circle = plt.Circle((n*h_spacing + left, layer_top - m*v_spacing), v_spacing/4.,
                                color='w', ec='k', zorder=4)
            ax.add_artist(circle)
    
    # Desenha conexões
    for n, (layer_size_a, layer_size_b) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])):
        layer_top_a = v_spacing*(layer_size_a - 1)/2. + (top + bottom)/2.
        layer_top_b = v_spacing*(layer_size_b - 1)/2. + (top + bottom)/2.
        for m in range(layer_size_a):
            for o in range(layer_size_b):
                line = plt.Line2D([n*h_spacing + left, (n + 1)*h_spacing + left],
                                  [layer_top_a - m*v_spacing, layer_top_b - o*v_spacing], c='k')
                ax.add_artist(line)
 
# Desenhando a rede neural
fig = plt.figure(figsize=(12, 12))
ax = fig.gca()
ax.axis('off')
draw_neural_net(ax, .1, .9, .1, .9, [784, 100, 144, 10])
plt.show()
					
				
			
		



Saída:


Este diagrama ilustra o fluxo desde os neurônios de entrada (784) através das camadas ocultas até os neurônios de saída (10).

Otimização do Treinamento: Utilizando GPUs 
Treinar redes neurais, especialmente as profundas, pode ser computacionalmente intensivo e demorado. Aproveitar as Unidades de Processamento Gráfico (GPUs) pode acelerar significativamente o processo de treinamento. Veja como você pode utilizar GPUs com Keras:

    Garantir Compatibilidade com GPU:
        
            Instale o NVIDIA CUDA Toolkit e cuDNN.
            Verifique se sua GPU é compatível com TensorFlow (a base para Keras).
        
    
    Instalar TensorFlow Compatível com GPU:
        



		
		
			
			
Java
			
			pip install tensorflow-gpu
			
				
					
				
					1
				
						pip install tensorflow-gpu
					
				
			
		


    
    Configurar TensorFlow para Usar GPU:
        O TensorFlow detecta e utiliza GPUs automaticamente. No entanto, você pode especificar explicitamente as configurações da GPU, se necessário.
        



		
		
			
			
Java
			
			import tensorflow as tf

gpus = tf.config.list_physical_devices('GPU')
if gpus:
    try:
        # Restringe o TensorFlow a usar apenas a primeira GPU
        tf.config.set_visible_devices(gpus[0], 'GPU')
        tf.config.experimental.set_memory_growth(gpus[0], True)
    except RuntimeError as e:
        print(e)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						import tensorflow as tf
 
gpus = tf.config.list_physical_devices('GPU')
if gpus:
    try:
        # Restringe o TensorFlow a usar apenas a primeira GPU
        tf.config.set_visible_devices(gpus[0], 'GPU')
        tf.config.experimental.set_memory_growth(gpus[0], True)
    except RuntimeError as e:
        print(e)
					
				
			
		


    


Benefícios de Usar GPUs:

    Processamento Paralelo: GPUs podem lidar com múltiplos cálculos simultaneamente, ideal para operações matriciais em redes neurais.
    Treinamento Mais Rápido: Modelos treinam significativamente mais rápido, permitindo mais experimentações e iterações rápidas.


Nota: Otimizar o uso da GPU pode exigir configurações adicionais com base em configurações específicas do sistema.

Conclusão 
Construir uma rede neural simples para classificação de dígitos usando Keras e o conjunto de dados MNIST é uma excelente introdução ao mundo do aprendizado de máquina e do aprendizado profundo. Ao seguir este guia, você aprendeu como:

    Compreender e pré-processar o conjunto de dados MNIST.
    Construir um modelo de rede neural com Keras.
    Treinar e avaliar o desempenho do modelo.
    Visualizar a arquitetura da rede.
    Otimizar o treinamento utilizando GPUs.


Embora o modelo discutido alcance uma precisão respeitável, há muito espaço para melhoria. Explorar arquiteturas mais complexas, experimentar diferentes funções de ativação ou implementar técnicas de regularização pode levar a um desempenho aprimorado. À medida que você continua sua jornada no aprendizado de máquina, construir sobre esses fundamentos lhe dará o poder de enfrentar projetos mais intrincados e impactantes.

Feliz Codificação!