Keras e TensorFlow em R

Introdução

Sempre foi um tópico discutível selecionar entre R e Python. O mundo do aprendizado de máquina foi dividido pela preferência de um idioma sobre o outro. Mas com a explosão do Deep Learning, equilíbrio alterado para Python, visto que ele tinha uma lista enorme de bibliotecas e estruturas de aprendizagem profunda que faltava em R (até o momento).

Pessoalmente, mudei de r para python simplesmente porque queria mergulhar no espaço de aprendizagem profunda, mas com um R, era quase impossivel. Mas não mais!

Com o lançamento do Keras in R, esta luta retorna ao centro. Python estava lentamente se tornando a linguagem de fato para modelos de aprendizagem profunda. Mas com o lançamento da biblioteca Keras em R com tensorflow (Compatibilidade de CPU e GPU) no backend de agora em diante, R provavelmente lutará contra Python novamente pelo pódio, mesmo no espaço de Deep Learning.

A seguir, veremos como instalar Keras com Tensorflow em R e construir nosso primeiro modelo de rede neural no conjunto de dados MNIST clássico em RStudio.

Tabela de conteúdo

Instalação do Keras com tensorflow no backend.
Diferentes tipos de modelos que podem ser construídos em R usando Keras
Classificação MNIST de dígitos manuscritos usando um MLP em R
Comparação da saída MNIST com código idêntico em Python
Notas finais

1. Instalação do Keras com tensorflow no backend.

As etapas para instalar o Keras no RStudio são muito simples. Basta seguir os passos abaixo e seria bom se você criasse seu primeiro modelo de rede neural em R.

install.packages("devtools")

devtools::install_github("rstudio/keras")

A etapa acima carregará a biblioteca keras do repositório GitHub. Agora é a hora de carregar o keras no R e instalar o tensorflow.

library(keras)

Por padrão, RStudio carrega a versão da CPU do tensorflow. Use o seguinte comando para baixar a versão CPU do tensorflow.

install_tensorflow()

Para instalar a versão do tensorflow compatível com GPU de usuário único / sistema desktop, use o seguinte comando.

install_tensorflow(gpu=TRUE)

Para instalação multiusuário, consulte este Guia de instalação.

Agora que temos keras e tensorflow instalados dentro do RStudio, vamos começar e construir nossa primeira rede neural em R para resolver o conjunto de dados MNIST.

2. Diferentes tipos de modelos que podem ser construídos em R usando keras

Abaixo está a lista de modelos que podem ser construídos em R usando Keras.

Perceptrons Multicamadas
Redes neurais intrincadas
Redes neurais recorrentes
Modelos Skip-Gram
Use modelos previamente treinados como VGG16, RESNET, etc.
Ajuste modelos previamente treinados.

Vamos começar construindo um modelo MLP muito simples usando apenas uma camada oculta para tentar categorizar os dígitos escritos à mão.

3. Classificação MNIST de dígitos manuscritos via MLP em R

#loading keras library
library(keras)

#loading the keras inbuilt mnist dataset
data<-dataset_mnist()

#separating train and test file
train_x<-data$train$x
train_y<-data$train$y
test_x<-data$test$x
test_y<-data$test$y

rm(data)

# converting a 2D array into a 1D array for feeding into the MLP and normalising the matrix
train_x <- array(train_x, dim = c(dim(train_x)[1], prod(dim(train_x)[-1]))) / 255
test_x <- array(test_x, dim = c(dim(test_x)[1], prod(dim(test_x)[-1]))) / 255

#converting the target variable to once hot encoded vectors using keras inbuilt function
train_y<-to_categorical(train_y,10)
test_y<-to_categorical(test_y,10)

#defining a keras sequential model
model <- keras_model_sequential()

#defining the model with 1 input layer[784 neurons], 1 hidden layer[784 neurons] with dropout rate 0.4 and 1 output layer[10 neurons]
#i.e number of digits from 0 to 9

model %>%
layer_dense(units = 784, input_shape = 784) %>%
layer_dropout(rate=0.4)%>%
layer_activation(activation = 'relu') %>%
layer_dense(units = 10) %>%
layer_activation(activation = 'softmax')

#compiling the defined model with metric = accuracy and optimiser as adam.
model %>% compile(
loss="categorical_crossentropy",
optimizer="adam",
metrics = c('accuracy')
)

#fitting the model on the training dataset
model %>% fit(train_x, train_y, epochs = 100, batch_size = 128)

#Evaluating model on the cross validation dataset
loss_and_metrics <- model %>% evaluate(test_x, test_y, batch_size = 128)

O código acima tinha uma precisão de treinamento de 99,14 e uma precisão de validação de 96,89. O código foi executado no meu processador i5 e demorou 13.5 segundos para uma única época, enquanto que, em uma GPU TITANx, a precisão de validação foi 98.44 com um tempo médio de 2 segundos.

4. MLP usando difícil – R vs Python

Para efeito de comparação, além disso, implementei o problema MNIST acima em python. Não deve haver diferença uma vez que keras em R cria uma instância conda e executa keras nela. Mas mesmo assim, você pode encontrar o código python idêntico abaixo.

#importing the required libraries for the MLP model
import keras
from keras.models import Sequential
import numpy as np

#loading the MNIST dataset from keras
from keras.datasets import mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()

#reshaping the x_train, y_train, x_test and y_test to conform to MLP input and output dimensions
x_train=np.reshape(x_train,(x_train.shape[0],-1))/255
x_test=np.reshape(x_test,(x_test.shape[0],-1))/255

import pandas as pd
y_train=pd.get_dummies(y_train)
y_test=pd.get_dummies(y_test)

#performing one-hot encoding on target variables for train and test
y_train=np.array(y_train)
y_test=np.array(y_test)

#defining model with one input layer[784 neurons], 1 hidden layer[784 neurons] with dropout rate 0.4 and 1 output layer [10 #neurons]
model=Sequential()

from keras.layers import Dense

model.add(Dense(784, input_dim=784, activation='relu'))
keras.layers.core.Dropout(rate=0.4)
model.add(Dense(10,input_dim=784,activation='softmax'))

# compiling model using adam optimiser and accuracy as metric
model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=['accuracy'])
# fitting model and performing validation

model.fit(x_train,y_train,epochs=50,batch_size=128,validation_data=(x_test,y_test))

O modelo anterior alcançou uma precisão de validação de 98,42 na mesma GPU. Então, como inicialmente assumimos, os resultados são iguais.

5. Notas finais

Se este foi seu primeiro modelo de Deep Learning em R, Espero que tenha gostado. Com um código muito simples, foi capaz de categorizar dígitos manuscritos com uma precisão de 98%. Isso deve ser motivação suficiente para iniciar o aprendizado profundo..

Se você já trabalhou na biblioteca de aprendizado profundo keras em Python, Você verá que a sintaxe e a estrutura da biblioteca keras em R é muito semelhante a Python. Na realidade, O pacote keras em R cria um ambiente conda e instala tudo o que é essencial para executar keras nesse ambiente. Mas agora estou mais animado para ver os cientistas de dados construindo modelos de aprendizagem profunda da vida real em R. Como se diz, competição nunca deve parar. Eu também gostaria de ouvir sua opinião sobre este novo desenvolvimento para R. Sinta-se à vontade para comentar.