A matemática por trás das redes neurais é intimidante para muitos. Mas isso não é um obstáculo para quem deseja implementar esses algoritmos, pois o Python possui várias bibliotecas e APIs que facilitam bastante a tarefa.
Uma das principais ferramentas de Python para implementações descomplicadas de redes neurais e deep learning é a biblioteca Keras.
O que é Keras?
Keras, cujo slogan é deep learning para humanos, é uma biblioteca de alto nível para construir e treinar redes neurais. A biblioteca Keras foi desenvolvida em Python para atuar como uma interface amigável para o TensorFlow. Recentemente, ela foi expandida para rodar também sobre o PyTorch e o Flax (aqui). A ideia por trás do desenvolvimento do Keras é tornar implementações de redes neurais e deep learning acessíveis a todos. Portanto, códigos escritos em Keras não têm a complexidade típica envolvida na construção de redes neurais do zero.
Para ilustrar como isso é feito, neste post utilizaremos o Keras para criar uma rede neural para classificar dígitos de 0-9 escritos à mão do conjunto de dados MNIST.
A classificação de dígitos escritos a mão não é uma tarefa fácil para algoritmos tradicionais. Mas é uma aplicação trivial para uma rede neural. Por isso, ela será usada como exemplo para nosso post.
Keras: instalação
O Keras é tradicionalmente acessado através do TensorFlow. Para instalação com pip:
pip install tensorflow
A instalação através do conda pode ser feita com o comando abaixo.
conda install -c conda-forge tensorflow
Redes neurais com Keras
A criação de uma rede neural com Keras segue as etapas tradicionais envolvidas na implementação desses algoritmos. Ou seja, é preciso fazer o pré-processamento dos dados, definir e implementar a estrutura da rede neural que será usada, treiná-la e validá-la.
Os dados
Para esse post, usaremos o conjunto de dados MNIST que o Keras já possui em sua API. O MNIST é um conjunto de dados compostos por dígitos de 0-9 escritos a mão. Cada exemplo do conjunto é a imagem de um dígito (dimensões de 28 por 28 píxeis em escala de cinzas) com sua classificação correspondente. O conjunto MNIST é tipicamente usado para tarefas de classificação com aprendizagem supervisionada. Portanto, implementaremos uma rede neural para fazer exatamente isso.
Num arquivo Python, é preciso importar o MNIST é definir as variáveis X e y de treino (train) e teste (test). Os dois conjuntos X contêm as variáveis independentes (imagens) e os conjuntos y têm as variáveis dependentes (categorias) que serão usadas para treinamento e validação da rede.
from tensorflow.keras.datasets import mnist
(X_train, y_train), (X_test, y_test) = mnist.load_data()
Antes de iniciar a implementação da rede em si, é importante visualizar alguns exemplos dos dados para entender melhor no que eles consistem. Isso pode ser feito com o matplotlib.
import matplotlib.pyplot as plt
for i in range(9):
plt.subplot(330+1+i)
plt.imshow(X_train[i], cmap=plt.get_cmap('gray'))
plt.show()
Abaixo mostramos algumas das imagens presentes nos dados.
Pré-processamento dos dados
O pré-processamento dos dados do conjunto MNIST é simples. Como as imagens têm valores de píxeis que variam de 0 a 255, é preciso fazer uma normalização dos conjuntos X_train e X_test:
X_train = X_train / 255.0
X_test = X_test / 255.0
Já as variáveis y são pré-processadas com o método to_categorical(), que as converte para categorias representadas por one hot enconding em um numpy array. Nos dados originais, essas variáveis são números de 0-9. O pré-processamento dos conjuntos y_train e y_test é feito com os comandos abaixo:
from tensorflow.keras.utils import to_categorical
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)
Redes neurais com Keras: a rede
Criar uma rede neural no Keras pode ser uma tarefa bem simples. A seleção do modelo Sequential mostrada no código abaixo é a maneira mais fácil de construir redes neurais formadas por camadas organizadas em sequências no Keras.
from tensorflow.keras.models import Sequential
model = Sequential()
Existem vários tipos de camadas disponíveis que podem ser usadas com Keras Sequential. Para este post, as camadas selecionadas para integrar nossa rede são mostradas no código abaixo. A primeira camada é do tipo Flatten. Ela é usada para converter os estímulos de entrada em um array unidimensional. O parâmetro input_shape especifica o número de atributos de entrada (recursos) do modelo.
Além da camada Flatten, nossa rede tem duas camadas ocultas do tipo Dense e uma camada Dense de saída. Camadas Dense são compostas por neurônios que se conectam com todos os neurônios da camada seguinte na sequência.
Os números de neurônios de cada camada oculta podem variar. Nossa camada de saída tem 10 neurônios, pois nossos dados possuem 10 categorias (dígitos de 0-9). As camadas ocultas e a camada de saída possuem uma função de ativação cada (activation). Selecionamos a sigmoid para as camadas ocultas e a softmax para a camada de saída. A rede completa escrita no Keras ficou assim:
from tensorflow.keras.layers import Dense, Flatten
model.add(Flatten(input_shape=(28, 28)))
model.add(Dense(128, activation='sigmoid'))
model.add(Dense(64, activation='sigmoid'))
model.add(Dense(10, activation='softmax'))
Compilação
Após construir a rede, é preciso compilá-la. Também é necessário especificar um otimizador e uma função de perda para o treinamento da rede neural. Usaremos o Adam como otimizador e a função de perda categorical_crossentropy, adequada para tarefas de classificação com múltiplas categorias.
from tensorflow.keras.losses import categorical_crossentropy
from tensorflow.keras.optimizers import Adam
model.compile(loss=categorical_crossentropy, optimizer=Adam(), metrics=['accuracy'])
Treinamento
O modelo é treinado com o método fit usando os conjuntos X_train e y_train. É preciso definir um número de épocas (epochs) para o treino. Cada época é um ciclo de treinamento da rede.
O parâmetro batch_size especifica quantos exemplos dos conjuntos de treinamento serão apresentados para a rede em cada época.
Nesta etapa do treinamento da rede também indicamos que o modelo será validado com os conjuntos de teste X_test e y_test.
model.fit(X_train, y_train, epochs=10, batch_size=32, validation_data=(X_test, y_test))
Veja abaixo os resultados obtidos para cada época do treinamento da rede implementada. Eles mostram a variação na perda e na acurácia do modelo ao longo de seu treinamento.
Epoch 1/10
1875/1875 [==============================] - 12s 6ms/step - loss: 0.4655 - accuracy: 0.8813 - val_loss: 0.2083 - val_accuracy: 0.9375
Epoch 2/10
1875/1875 [==============================] - 13s 7ms/step - loss: 0.1748 - accuracy: 0.9472 - val_loss: 0.1480 - val_accuracy: 0.9557
Epoch 3/10
1875/1875 [==============================] - 17s 9ms/step - loss: 0.1207 - accuracy: 0.9646 - val_loss: 0.1113 - val_accuracy: 0.9654
Epoch 4/10
1875/1875 [==============================] - 21s 11ms/step - loss: 0.0904 - accuracy: 0.9730 - val_loss: 0.0925 - val_accuracy: 0.9716
Epoch 5/10
1875/1875 [==============================] - 14s 8ms/step - loss: 0.0703 - accuracy: 0.9793 - val_loss: 0.0845 - val_accuracy: 0.9732
Epoch 6/10
1875/1875 [==============================] - 10s 5ms/step - loss: 0.0557 - accuracy: 0.9839 - val_loss: 0.0795 - val_accuracy: 0.9757
Epoch 7/10
1875/1875 [==============================] - 10s 5ms/step - loss: 0.0451 - accuracy: 0.9866 - val_loss: 0.0867 - val_accuracy: 0.9741
Epoch 8/10
1875/1875 [==============================] - 11s 6ms/step - loss: 0.0355 - accuracy: 0.9901 - val_loss: 0.0703 - val_accuracy: 0.9790
Epoch 9/10
1875/1875 [==============================] - 17s 9ms/step - loss: 0.0288 - accuracy: 0.9923 - val_loss: 0.0704 - val_accuracy: 0.9788
Epoch 10/10
1875/1875 [==============================] - 16s 9ms/step - loss: 0.0226 - accuracy: 0.9941 - val_loss: 0.0708 - val_accuracy: 0.9795
313/313 [==============================] - 2s 5ms/step - loss: 0.0708 - accuracy: 0.9795
Validação
Por fim, o modelo é validado. Para isso, verificamos a perda e acurácia obtidas para os conjuntos de teste X_test e y_test com a rede treinada.
loss, accuracy = model.evaluate(X_test, y_test)
print(f"Test Loss: {round(loss, 4)}, Test Accuracy: {round(accuracy, 5)}")
E esses são os resultados do modelo treinado. Sua acurácia é de aproximadamente 0.98, o que significa que ele comete apenas dois erros de classificação para cada 100 exemplos testados.
Test Loss: 0.0708, Test Accuracy: 0.9795
Customizando o modelo
Como foi possível verificar acima, implementações de redes neurais com Keras são processos simples. Para enfatizar mais esse ponto, vamos fazer algumas modificações no nosso código para customizar a rede.
Um problema comum em redes neurais é o overfitting. Ele ocorre quando as redes são treinadas de forma excessiva. Isso faz com que elas tenham desempenhos ótimos durante o treinamento, mas desempenhos piores para dados novos. Uma técnica para evitar overfitting é o uso de camadas dropout entre as camadas ocultas de uma rede neural. Camadas dropout evitam overfitting retirando uma porcentagem de neurônios de cada época do treinamento. No Keras, a modificação de uma rede para incluir camadas dropout envolve a adição de uma única linha de código para cada nova camada. Veja nosso exemplo abaixo.
from tensorflow.keras.layers import Dense, Flatten, Dropout
model.add(Flatten(input_shape=(28, 28)))
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))
Note que também modificamos as funções de ativação das camadas Dense ocultas. O resto do código é igual ao implementado acima. Executando o treinamento dessa rede, a perda e acurácia obtidas com os dados de teste são mostradas abaixo. Elas têm pequenas diferenças em relação aos resultados obtidos com a rede anterior, cujo desempenho já era ótimo. Sua implementação foi feita apenas para ilustrar como é fácil criar redes neurais com diferentes estruturas com o Keras.
Test Loss: 0.0802, Test Accuracy: 0.9772
Conclusões
Redes neurais, incluindo redes do tipo deep learning, podem ser implementadas em Python de forma fácil e descomplicada com a biblioteca Keras. Neste post, ilustramos esse processo desenvolvendo o passo a passo da implementação de uma rede neural que classifica o conjunto de dados MNIST. Vários outros problemas têm implementações com níveis equivalentes de dificuldade. Portanto, como deve ter ficado evidente, redes neurais podem ter implementações bem simples e acessíveis.
