keras: deep learning em R

Como você já sabe, machine learning é um subcampo da ciência da computação (CS). Deep learning, por sua vez, é um subcampo de machine learning composto por um conjunto de algoritmos inspirados na estrutura e no funcionamento do cérebro, normalmente chamados de redes neurais artificiais (ANN). Deep learning é uma das maiores tendências em machine learning no momento, e há muitos problemas em que ele brilha, como robótica, reconhecimento de imagens e inteligência artificial (IA).

O tutorial de hoje traz uma introdução rápida ao deep learning em R com Keras usando o pacote keras:

# Carregue o pacote keras
library(keras)

# Instale o TensorFlow
install_tensorflow()

Carregando os dados

Com a instalação concluída e o ambiente pronto, é hora de carregar seus dados! Neste ponto, você tem três opções principais: usar um dos conjuntos de dados embutidos que vêm com o pacote keras, carregar seu próprio conjunto (por exemplo, de arquivos CSV) ou criar dados de exemplo (dummy).

Qualquer que seja o seu caso, você vai ver que dá para começar rapidamente. Esta seção passa pelas três opções e explica como carregar (ou criar) os dados de que você precisa!

# Ler dados do MNIST
mnist <- dataset_mnist()

# Ler dados do CIFAR10
cifar10 <- dataset_cifar10()

# Ler dados do IMDB
imdb <- dataset_imdb()

Exploração de dados

Neste tutorial, vamos continuar com o famoso conjunto iris que você importou com read.csv().

Para quem não tem o background de biologia necessário para trabalhar com esses dados, aqui vai: todas as flores têm sépalas e pétalas. A sépala envolve as pétalas e geralmente é verde e semelhante a uma folha, enquanto as pétalas são, em geral, coloridas. No caso das flores de íris, isso é um pouco diferente, como você vê na imagem a seguir:

Você deve ter notado na seção anterior que o data frame iris não tinha nomes de colunas após a importação. Para o restante do tutorial, isso não é tão crítico: embora read.csv() retorne um data.frame, os dados que você vai passar para a função fit() precisam ser uma matriz ou array.

Alguns lembretes sobre essas duas estruturas: - Matrizes e arrays não têm nomes de colunas; - Matrizes são objetos bidimensionais de um único tipo de dado; - Arrays são objetos multidimensionais de um único tipo de dado;

Dica: veja este vídeo se quiser relembrar as estruturas de dados em R!

Já o data frame é uma lista nomeada especial em que todos os elementos têm o mesmo comprimento. É um objeto multidimensional que pode conter múltiplos tipos de dados. Você já viu isso ao checar a estrutura do iris antes. Sabendo disso e considerando que vamos precisar de um objeto bi ou multidimensional de um único tipo, já dá para se preparar para algum pré-processamento antes de construir a rede neural!

Por ora, nomes de coluna ajudam na exploração e na compreensão dos dados, então vamos adicioná-los com names(). Em seguida, já usamos a variável iris na exploração! Plote, for exemplo, como o comprimento e a largura da pétala se correlacionam com plot().

Note que usamos unclass() para converter os nomes das espécies — “setosa, versicolor” e “virginica” — em valores numéricos 1, 2 e 3.

Agora olhe mais de perto o resultado do gráfico:

O gráfico indica correlação positiva entre Petal.Length e Petal.Width para as diferentes espécies de íris. Mesmo assim, você provavelmente vai querer testar isso com a função cor(), que dá a correlação geral entre todos os atributos incluídos no conjunto:

Além disso, você pode usar o pacote corrplot em conjunto com cor() para visualizar as correlações entre os atributos; aqui, calculamos a correlação geral para todos os atributos do data frame iris. Guardamos o resultado em M e o passamos para corrplot().

Não esqueça de indicar o método (method) de visualização!

Você pode experimentar com o método de visualização no bloco DataCamp Light abaixo:

Use o console do R para explorar os dados ainda mais.

Se quiser fazer gráficos com o pacote ggvis, que traz uma gramática de gráficos interativa, veja o tutorial Machine Learning in R For Beginners da DataCamp ou faça o curso de ggvis.

Pré-processamento de dados

Antes de construir o modelo, você precisa garantir que os dados estejam limpos, normalizados (se aplicável) e divididos em treino e teste. Como o dataset vem do UCI Machine Learning Repository, dá para esperar que esteja relativamente limpo — mas vamos conferir a qualidade mesmo assim.

A princípio, quando olhou com head(), nada estranho, certo? Vamos usar summary() e str() para recapitular o que aprendemos ao checar a importação:

Agora que você tem certeza de que os dados estão bons, confira se a normalização é necessária para algum dos atributos usados neste tutorial.

x_train <- imdb$train$x
y_train <- imdb$train$y
x_test <- imdb$test$x
y_test <- imdb$test$y

Construindo o modelo

Para começar, inicialize um modelo sequencial com keras_model_sequential(). Depois, comece a modelar.

Antes, vale revisitar a pergunta original: dá para prever a espécie de uma flor de íris? Trabalhar com dados numéricos é mais fácil, e você já pré-processou e aplicou one-hot encoding ao alvo: a flor é versicolor, setosa ou virginica — representado por 1 e 0 binários.

Um tipo de rede que funciona bem nesse problema é o perceptron multicamadas. Esse tipo de rede neural costuma ser totalmente conectada. Ou seja, vamos montar uma pilha simples de camadas densas para resolver o problema. Quanto às funções de ativação, a mais comum para começar com Keras e redes neurais é a relu. Essa função retificadora é usada em uma camada oculta — em geral, uma boa prática.

Além disso, usamos a softmax na camada de saída, para garantir que os valores de saída fiquem entre 0 e 1 e possam ser interpretados como probabilidades previstas:

Veja como a camada de saída cria 3 valores de saída, um para cada classe de íris (versicolor, virginica ou setosa). Já a primeira camada, com 8 nós ocultos, tem input_shape de 4 — pois iris.training tem 4 colunas.

Você pode inspecionar seu modelo com as funções abaixo:

• summary() imprime um resumo do modelo;
• get_config() retorna uma lista com a configuração do modelo;
• get_layer() retorna a configuração da camada;
• o atributo layers recupera a lista achatada de camadas do modelo;
• para listar os tensores de entrada, use o atributo inputs; e
• para recuperar os tensores de saída, use o atributo outputs.

Compilar e ajustar (fit) o modelo

Com a arquitetura pronta, é hora de compilar e ajustar o modelo aos dados. Para compilar, configure o otimizador adam e a função de perda categorical_crossentropy. Além disso, monitore a acurácia durante o treino passando 'accuracy' no argumento metrics.

Optimizer e loss são argumentos obrigatórios na compilação.

Algoritmos populares de otimização incluem Stochastic Gradient Descent (SGD), ADAM e RMSprop. Dependendo da escolha, você ajusta parâmetros como taxa de aprendizado (learning rate) ou momentum. A escolha da função de perda depende da tarefa: por exemplo, para regressão, usa-se geralmente Mean Squared Error (MSE).

Neste exemplo, usamos categorical_crossentropy para o problema multiclasse de determinar se uma íris é versicolor, virginica ou setosa. Note que, para classificação binária, você deveria usar binary_crossentropy.

Agora ajuste o modelo aos dados; aqui, treinamos por 200 epochs (iterações sobre todas as amostras em iris.training e iris.trainLabels), em lotes (batches) de 5 amostras.

Dica: se quiser, você pode definir o argumento verbose em fit(). Com valor 1, você vê a barra de progresso.

O código acima treina o modelo por um número definido de epochs (exposições ao conjunto de treino). Uma epoch é uma passagem única por todo o treino, seguida de teste no conjunto de validação. O batch_size define quantas amostras são propagadas pela rede de cada vez. Isso também ajuda na eficiência, evitando carregar padrões demais na memória ao mesmo tempo.

Visualizar o histórico de treino

Você também pode visualizar o ajuste se armazenar o resultado do fit em uma variável. Depois, passe essa variável para plot(), como neste bloco!

Estude o gráfico com atenção.

À primeira vista, é normal parecer meio bagunçado. Talvez não esteja claro o que observar.

Algo útil: loss e acc indicam perda e acurácia no treino, enquanto val_loss e val_acc são essas mesmas métricas nos dados de validação (teste).

Ainda assim, não é trivial interpretar os dois gráficos juntos. Vamos separar em dois: um para a perda do modelo e outro para a acurácia. Felizmente, dá para usar o operador $ para acessar os dados e plotar passo a passo.

Veja como fazer abaixo:

No primeiro gráfico, você plotou a perda do modelo no treino e no teste. Agora faça o mesmo para a acurácia:

Alguns pontos para ter em mente:

• Se a acurácia do treino continua melhorando enquanto a da validação piora, provavelmente há overfitting: o modelo começa a memorizar os dados em vez de aprender.
• Se a tendência de acurácia em ambos os conjuntos ainda sobe nas últimas epochs, o modelo claramente ainda não superaprendeu o conjunto de treino.

Prever rótulos de novos dados

Com o modelo criado, compilado e ajustado, é hora de usá-lo para prever os rótulos do conjunto de teste iris.test. Como esperado, use predict(). Depois, imprima a matriz de confusão para comparar previsões e rótulos reais do iris.test com table().

O que achou dos resultados? À primeira vista, o modelo parece acertar as previsões?

Avaliando o modelo

Mesmo tendo uma ideia do desempenho ao olhar as previsões para iris.test, ainda é importante avaliar o modelo. Use evaluate(): passe os dados de teste iris.test, os rótulos iris.testLabels e defina o batch size. Guarde o resultado em score, como abaixo:

Ao imprimir score, você recebe o valor da perda e o valor da métrica (neste caso, 'accuracy').

Ajuste fino do modelo

Ajustar o modelo é algo que você vai fazer bastante, especialmente no começo, porque nem todos os problemas de classificação e regressão são tão diretos quanto o primeiro exemplo. Como vimos, há duas decisões-chave que você provavelmente vai ajustar: quantas camadas usar e quantas “unidades ocultas” em cada camada.

No início, é uma jornada de experimentação.

Além de brincar com o número de epochs ou o batch size, há outras formas de melhorar o modelo: adicionando camadas, aumentando o número de unidades ocultas e passando seus próprios parâmetros de otimização para compile(). Esta seção cobre essas três opções.

Salvando, carregando ou exportando seu modelo

Por fim, você pode salvar ou exportar seu modelo para carregá-lo depois.

• Primeiro, use save_model_hdf5() e load_model_hdf5() para salvar e carregar no seu ambiente:

save_model_hdf5(model, "my_model.h5")
model <- load_model_hdf5("my_model.h5")

• Além disso, você pode salvar e carregar os pesos com save_model_weights_hdf5() e load_model_weights_hdf5():

save_model_weights_hdf5("my_model_weights.h5")
model %>% load_model_weights_hdf5("my_model_weights.h5")

• Por fim, saiba que você pode exportar a configuração do modelo para JSON ou YAML. As funções model_to_json() e model_to_yaml() ajudam nisso. Para carregar as configurações de volta, use model_from_json() e model_from_yaml():

json_string <- model_to_json(model)
model <- model_from_json(json_string)

yaml_string <- model_to_yaml(model)
model <- model_from_yaml(yaml_string)