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:

Turing Talks #19 | Modelos de Predição — Redes Neurais

Turing Talks #21 | Modelos de Predição — Redes Neurais (Parte 2)

Turing Talks #22 | Modelos de Predição — Redes Neurais (Parte 3)

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, com units 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 por batch_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 de logs/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:

Acurácia do modelo e erro ao longo do treinamento

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.

Turing Talks #23 | Modelos de Predição — Redes Neurais Convolucionais

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.

Base de dados CIFAR10

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!