Redes Neurais | Redes Neurais com Keras e TensorFlow 2.0
Redes neurais na prática de forma simples e rápida.
Nesse texto vamos ver como criar e treinar um modelo de rede neural utilizando a API Keras, do módulo TensorFlow 2.0, desenvolvido pela Google. Os códigos usados estão em Python, principal linguagem para trabalhar com TensorFlow e as bibliotecas necessárias foram baixadas usando Anaconda.
Como esse post trata o tema de redes neurais é recomendado que se tenha um conhecimento básico sobre elas. Caso não se tenha nenhum, ou caso queira revisar o tema, leia a série anterior de Modelos de Predição que trata do assunto:
Por que Keras?
A maior vantagem de se implementar Keras ao invés de escrever todas as funções na mão, como foi feito anteriormente no Turing Talks #22, é pela diminuição na complexidade, reduzindo para poucas linhas de código o que levaria dezenas de linhas. Também é possível obter um grande ganho em velocidade para rodar o código, com o fato da API ter sido criada para ser mais rápida possível, sem ganhar complexidade para criar modelos simples.
Para usar essas ferramentas é necessário primeiro carregá-la no seu ambiente de programação, utilizando o código a seguir, lembrando que estamos usando a versão 2.0 do TensorFlow para esse tutorial:
Agora que estamos com tudo que precisamos carregado vamos copiar o modelo usado para classificar a base de dados de números manuscritos MNIST presente no Turing Talks #22, montando ela usando Sequential.
Sequential
Sequential
é como o Keras organiza seu modelo, com cada uma das camadas adicionada colocada em sequência (daí seu nome), sendo que a primeira camada recebe os dados de entrada do sistema e manda sua saída para a próxima camada, e a saída da última camada sendo a saída do modelo. Essas camadas são chamadas layers
, podendo ser vários tipos diferentes, tendo como exemplo algumas das mais usadas:
Flatten
pega uma matriz de tamanho arbitrário e transforma em um vetor;Reshape
pega uma matriz, ou vetor, e reorganiza seus valores para caber em uma matriz de tamanho dado pelo usuário, no caso 2 por 3;Dense
é uma camada de neurônios, comunits
definindo a quantidade de neurônios, no caso 10, com os pesos dos neurônios (kernel_initializer
) iniciados com valores aleatórios, com os pesos dos vieses (bias_initializer
) também iniciados aleatoriamente e aplicando uma função de ativação sigmoidal nos valores de saída;Conv2D
aplica uma camada de convolução, com 5 filtros de tamanho 4 por 4. Muito usado em CNNs;MaxPooling2D
reduz o tamanho de uma matriz, pegando o valor máximo de cada seção reduzida, como foi explicado no Turing Talks #23. Também muito usado em CNNs;
Vale a pena lembrar que esse são apenas uma pequena parcela dos layers
disponíveis pelo Keras, e mesmo nos exemplos escolhidos é possível modificar muitos mais hiperparâmetros presentes dentro das camadas. A documentação do Keras é sempre recomendada para caso se queira aprofundar mais no assunto.
Para se criar um modelo é necessário primeiro criar uma instância de Sequential
e adicionar camadas a ele com o comando add()
. Seguindo o mesmo modelo criado no Turing Talks #22, com apenas um hidden layer de 800 neurônios e um output layer de 10 neurônios, um para cada caractere, obtemos o modelo:
- O comando
compile()
configura o modelo, preparando ele para o treinamento; optimizer
é o que o programa usa para atualizar os pesos da rede, sendo o SGD o mais simples, que calcula o gradiente do erro em relação aos pesos, multiplica pela taxa de aprendizado e subtrai nos erros;loss
é a função de erro que o programa tenta minimizar;- O comando
fit()
treina a rede neural; - Os dados de treino são separados em partes de mesmo tamanho e cada parte é usada para atualizar os pesos, depois é usada a próxima parte para atualizar novamente os dados até que todos os dados sejam varridos. Esse processo é repetido a quantidade de vezes dada por
epochs
e o tamanho desses pedaços é dado porbatch_size
, no caso igual a quantidade de dados para os pesos serem atualizados uma vez por época (epoch).
Com o treinamento desse modelo obtivemos uma rede com acurácia de 90,8% na predição de números manuscritos.
Pronto! Todo o processo de criar uma rede neural e treiná-la pode ser reduzido em apenas algumas linhas de código usando Keras.
TensorBoard
Uma ótima ferramenta disponível com o TensorFlow é o TensorBoard, que disponibiliza a visualização da performance de um modelo treinado, a comparação desse modelo com outros já treinados, a evolução dos pesos, e muito mais. Para conseguir utilizar essa ferramenta é necessário adicionar algumas linhas de código antes de dar o comando fit()
e adicionar um parâmetro callbacks
novo à ele:
- A primeira linha de código,
log_dir
, define o lugar em que o programa deve salvar as atualizações do modelo treinado, no caso, dentro delogs/fit/<data e hora>
; - A segunda linha de código, com
tensorboard_callback
, cria a função que salva as atualizações do modelo; - A terceira linha de código é apenas o comando fit() usado anteriormente, só que com
callbacks=[tensorboard_callback]
adicionado a ele associando a função criada anteriormente ao treinamento.
Agora é necessário abrir o terminal de comando na pasta em que o programa está e rodar o seguinte comando:
tensorboard --logdir logs/fit
O terminal não deve retornar nenhum erro e devolver que o TensorBoard está disponível no localhost:6006, sendo apenas necessário copiar e colar o link no browser para acessar a ferramenta, se deparando com algo desse tipo:
Implementando uma CNN
Até agora lidamos com camadas de neurônios, que têm como entrada um vetor, uma sequencia de N valores, e tem como saída um outro vetor de tamanho diferente. Agora vamos lidar com uma camada de convolução, que tem como entrada uma série de matrizes NxM e como saída uma outra série de matrizes de tamanho diferente, explicado com detalhe no Turing Talks #23, leitura altamente recomendada para compreender os conceitos que serão abordados a seguir.
A principal diferença de se tratar com Redes Neurais Convolucionais (Convolutional Neural Networks, em inglês) é o fato de se estar trabalhando com modelos que têm como entrada matrizes ao invés de vetores (note que no exemplo anterior seria possível tratar os dados para serem bidimensionais sem alterar o treinamento). O formato usual desses modelos é ter como as primeiras camadas de convolução e de pooling, depois os dados são achatados num vetor e tratados por camadas de neurônios.
Utilizando a base de dados CIFAR10, composta por imagens de 32 por 32 pixels de 10 classes diferentes (avião, carro, pássaro, gato, cervo, cachorro, sapo, cavalo, barco e caminhão), é possível montar o seguinte modelo como exemplo:
- No caso, a entrada do modelo são 3 matrizes de tamanho 32x32, sendo que cada uma das 3 representa uma das 3 cores no padrão RGB, a formatação dessa entrada pode ser vista em
input_shape=(32, 32, 3)
; - Todas as camadas de convolução tem como função de ativação a ReLU, que faz com que, caso o valor seja negativo seja substituído por 0, caso contrário ele fica inalterado, podendo ser exemplificada pela função
ReLU(x) = max(x, 0)
; - A primeira camada de
Conv2D
possui 32 dois filtros, logo, tendo como saída 32 matrizes. A mesma lógica pode ser aplicada para as outras camadas de convolução; - A camada de
MaxPooling2D
reduz pela metade as dimensões das matrizes que ele recebe; - A camada
Flatten
recebe 64 matrizes e transforma elas em um único vetor; - A última camada de neurônios
Dense
possui como função de ativação a Softmax, que primeiro pega o valor exponencial das saídas e divide eles pela soma das exponenciais das saídas, de forma a fazer todos os valores sejam positivos e que a soma de todos seja igual a 1, obtendo um vetor da probabilidade da imagem ser cada uma das 10 classes.
Foi possível conseguir uma acurácia de 96.1% seguindo apenas um modelo padrão de Rede Neural Convolucional.
Agora é com você
Agora que você sabe os básicos dessa ferramenta incrível é extremamente recomendável que você pegue o código completo aqui e brinque com ele o quanto quiser para ver como isso afeta a velocidade de treino e acurácia do modelo. Adicione mais camadas, mude os hiperparâmetros das camadas e de treinamento, mude função de ativação da saída da camada, mude o otimizador de treinamento, entre na documentação e pegue uma coisa que nem foi explicada nesse texto, o céu é o limite. Só lembre que a ultima camada deve ter uma saída de 10 números tanto para a base MNIST como para a base CIFAR10.
Também vale ressaltar que a utilização da plataforma Anaconda para lidar com o TensorFlow e Keras é muito recomendada, tendo que rodar o comando conda install -c conda-forge keras
no terminal do Anaconda para baixar todos os itens utilizados nesse tutorial, também é necessário avisar que para lidar com o python e TensorFlow baixados no anaconda deve ser usado o terminal do Anaconda.
Curtiu o tutorial? Esperamos que você possa usar o que foi ensinado aqui na sua vida, aplicando seu conhecimento de inteligência artificial. Não esqueça de conferir nossos outros posts no Facebook, LinkedIn e Instagram para ver tudo sobre o mundo de IA e mais coisas que podem ser feitas com os conhecimentos fornecidos nesse texto.
Até mais!