SAUDAÇÕES!

Seja bem vindo à página do professor Pedro Albuquerque. Para saber mais sobre meu currículo, disciplinas ministradas e interesses de pesquisa, navegue no menu disponível no topo da página.

sexta-feira, 15 de janeiro de 2016

Deep Learning usando R.


Deep learning é um novo paradigma no campo de Aprendizado de Máquinas no qual há evidências de superar as Máquinas de Suporte Vetorial em problemas de classificação como sugerido por Bengio e LeCun (2007).

Apesar do sucesso de métodos de aprendizado de máquina por meio de kernel como os SVMs, recentes trabalhos em Aprendizado de Máquinas tem destacado que arquiteturas profundas, tais como redes de múltiplas camadas neurais e redes de crenças profundas parecem se ajustar melhor a dados complexos do que modelos de estruturas mais rasas de como SVMs (Bengio e LeCun, 2007).

Arquiteturas profundas parecem aprender melhor mapeamentos complexos, transformando suas entradas através de múltiplas camadas de processamento não-linear (Hinton et al., 2006).

Basicamente a ideia por trás do Deep learning é o uso de muitas (e profundas) camadas em um modelo de Redes Neurais. Considere $\mathbf{x}$ um vetor associado a uma determinada observação, onde cada elemento desse vetor é composto por variáveis (atributos ou características) que representam esse vetor, como por exemplo: idade, renda, altura, etc..

A ideia do Deep learning em Redes Neurais é aplicar sucessivas e múltiplas camadas de de funções não lineares (funções de ativação) na construção de uma rede neuronal.

Especificamente, a primeira camada é construída fazendo-se $\mathbf{h}_{1}=\sigma(\mathbf{W}_{1}\mathbf{x}-\mathbf{b}_{1})$ onde $\mathbf{W}_{1}$ é uma matriz de pesos a ser estimada (por exemplo, através do aumento da acurácia na previsão) e $\mathbf{b}_{1}$ um termo de viés (ou intercepto) também a ser estimado. A função de ativação pode ser algo como: $$\sigma(z)=\frac{1}{1+\exp{-z}}$$.

O vetor $\mathbf{h}_{1}$ é então mapeado para outro vetor $\mathbf{h}_{2}=\sigma(\mathbf{W}_{2}\mathbf{h}_{1}-\mathbf{b}_{2})$, o vetor $\mathbf{h}_{2}$ é também mapeado para outro vetor $\mathbf{h}_{3}=\sigma(\mathbf{W}_{3}\mathbf{h}_{2}-\mathbf{b}_{3})$ e assim sucessivamente até que se crie uma estrutura profunda o "suficiente":


Na última camada teríamos o resultado escalar para a observação mapeada. Por se tratar de um procedimento computacionalmente complexo, é necessário que a implementação considere ou processamento em paralelo ou o uso de GPUs.

No R há alguns pacotes que implementam o Deep learning são eles: deepnet, h2o, neuralnet e darch.

Nesse post utilizaremos o mesmo conjunto de dados apresentado em Credit Score usando o R. Vamos importar os dados para o R:

#Limpa o Workspace
rm(list=ls())

#Importa os dados German.csv 
dados.df<-read.csv("https://dl.dropboxusercontent.com/u/36068691/Blog/german.csv")

#Apresenta as variáveis do DataFrame
names(dados.df)

#Apresenta a estrutura do DataFrame
str(dados.df)
O pacote que utilizaremos para estimar o Risco de Crédito será o pacote h2o:
#Chama o pacote
library(h2o)

#Inicia uma conexão
localH2O <- h2o.init()

#Converte o objeto data.frame para o formato h2o
#Mantêm somente as variáveis de interesse
dados.h2o <- as.h2o(localH2O, dados.df[,c("DURATION","AMOUNT","AGE","RESPONSE")])
O próximo passo é construir a rede para a previsão da variável dependente (RESPONSE):
model <- 
  h2o.deeplearning(x = 1:3,  #Número das colunas com as variáveis preditoras
                   y = 4,    #Número da coluna com a variável dependente
                   training_frame = dados.h2o, #Dados no formato H2O
                   activation = "TanhWithDropout", #Função de ativação
                   hidden = c(50,50,50)) #Três camadas com 50 nós
Após ajustar o modelo, averiguamos a acurácia obtida:
#Converte para data.frame
yhat <- as.data.frame(h2o_yhat)
#Cria as categorias de zero e 1
yhat[yhat<0.8]<-0
yhat[yhat>=0.8]<-1
#Compara com o valor observado
dados.df$RESPONSE_hat<-unlist(yhat)
table(dados.df$RESPONSE_hat,dados.df$RESPONSE)
Nesse modelo a matriz de confusão foi:
O último passo é fechar a conexão criada com o h2o:
#Fecha a conexão com o h2o:
h2o.shutdown(conn = localH2O, prompt = FALSE)
Para saber mais sobre Deep learning viste http://deeplearning.net/