Keras y TensorFlow en R

Introducción

Siempre ha sido un tema debatible seleccionar entre R y Python. El mundo del aprendizaje automático se ha dividido sobre la preferencia de un idioma sobre el otro. Pero con la explosión del Deep Learning, el equilibrio se desplazó hacia Python, dado que tenía una enorme lista de bibliotecas y marcos de Deep Learning de los que R carecía (hasta el momento).

Personalmente, cambié a Python desde R simplemente debido a que quería sumergirme en el espacio de Deep Learning, pero con una R, era casi imposible. ¡Pero ya no más!

Con el lanzamiento de Keras en R, esta lucha vuelve al centro. Python se estaba convirtiendo lentamente en el lenguaje de facto para los modelos de aprendizaje profundo. Pero con el lanzamiento de la biblioteca Keras en R con tensorflow (compatibilidad de CPU y GPU) en el backend de ahora en más, es probable que R vuelva a luchar contra Python por el podio inclusive en el espacio de Deep Learning.

A continuación, veremos cómo instalar Keras con Tensorflow en R y construir nuestro primer modelo de red neuronal en el conjunto de datos MNIST clásico en RStudio.

Tabla de contenido

Instalación de Keras con tensorflow en el backend.
Diferentes tipos de modelos que se pueden construir en R usando Keras
Clasificación de dígitos manuscritos de MNIST usando un MLP en R
Comparación del resultado de MNIST con código idéntico en Python
Notas finales

1. Instalación de Keras con tensorflow en el backend.

Los pasos para instalar Keras en RStudio son muy sencillos. Simplemente siga los pasos a continuación y sería bueno que creara su primer modelo de red neuronal en R.

install.packages("devtools")

devtools::install_github("rstudio/keras")

El paso anterior cargará la biblioteca de keras desde el repositorio de GitHub. Ahora es el momento de cargar keras en R e instalar tensorflow.

library(keras)

De forma predeterminada, RStudio carga la versión de CPU de tensorflow. Utilice el siguiente comando para descargar la versión de CPU de tensorflow.

install_tensorflow()

Para instalar la versión de tensorflow con soporte de GPU para un solo usuario / sistema de escritorio, use el siguiente comando.

install_tensorflow(gpu=TRUE)

Para la instalación multiusuario, consulte este guía de instalación.

Ahora que tenemos keras y tensorflow instalados dentro de RStudio, comencemos y construyamos nuestra primera red neuronal en R para solucionar el conjunto de datos MNIST.

2. Diferentes tipos de modelos que se pueden construir en R usando keras

A continuación se muestra la lista de modelos que se pueden construir en R usando Keras.

Perceptrones multicapa
Redes neuronales intrincadas
Redes neuronales recurrentes
Modelos Skip-Gram
Utilice modelos previamente entrenados como VGG16, RESNET, etc.
Afina los modelos previamente entrenados.

Comencemos con la construcción de un modelo MLP muy simple usando solo una capa oculta para intentar categorizar los dígitos escritos a mano.

3. Clasificación de dígitos manuscritos del MNIST a través de un MLP en 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)

El código anterior tenía una precisión de entrenamiento de 99,14 y una precisión de validación de 96,89. El código se ejecutó en mi procesador i5 y tomó alrededor de 13.5 segundos para una sola época, mientras que, en una GPU TITANx, la precisión de validación fue 98.44 con una época promedio de 2 segundos.

4. MLP usando keras – R vs Python

En aras de la comparación, además implementé el problema MNIST anterior en Python. No debería haber ninguna diferencia dado que keras en R crea una instancia de conda y ejecuta keras en ella. Pero aún así, puede hallar el código de Python idéntico a continuación.

#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))

El modelo anterior logró una precisión de validación de 98,42 en la misma GPU. Entonces, como supusimos inicialmente, los resultados son los mismos.

5. Notas finales

Si este fue su primer modelo de Deep Learning en R, espero que lo haya disfrutado. Con un código muy simple, pudo categorizar dígitos escritos a mano con una precisión del 98%. Esto debería ser una motivación suficiente para comenzar con el aprendizaje profundo.

Si ya ha trabajado en la biblioteca de aprendizaje profundo de keras en Python, encontrará que la sintaxis y la estructura de la biblioteca de keras en R son muy similares a las de Python. En realidad, el paquete keras en R crea un entorno conda e instala todo lo esencial para ejecutar keras en ese entorno. Pero ahora estoy más emocionado de ver a los científicos de datos construir modelos de aprendizaje profundo de la vida real en R. Como se dice, la competencia nunca debería detenerse. Además me agradaría escuchar sus opiniones sobre este nuevo desarrollo para R. No dude en comentar.