Keras et TensorFlow dans R

introduction

Choisir entre R et Python a toujours été un sujet discutable. Le monde de l'apprentissage automatique a été divisé sur la préférence d'une langue par rapport à l'autre. Mais avec l'explosion du Deep Learning, équilibre déplacé vers Python, étant donné qu'il avait une énorme liste de bibliothèques et de cadres d'apprentissage en profondeur qui manquaient à R (jusqu'au moment).

Personnellement, je suis passé de r à python simplement parce que je voulais plonger dans l'espace d'apprentissage en profondeur, mais avec un R, c'était presque impossible. Mais plus maintenant!

Avec le lancement de Keras en R, ce combat revient au centre. Python devenait lentement le langage de facto pour les modèles d'apprentissage en profondeur. Mais avec la sortie de la librairie Keras en R avec tensorflow (Compatibilité CPU et GPU) dans le backend à partir de maintenant, R est susceptible de se battre à nouveau contre Python pour le podium, même dans l'espace Deep Learning.

Ensuite, nous verrons comment installer Keras avec Tensorflow dans R et construire notre premier modèle de réseau de neurones sur le jeu de données MNIST classique dans RStudio.

Table des matières

Installation de Keras avec tensorflow sur le backend.
Différents types de modèles pouvant être construits dans R à l'aide de Keras
Classification des chiffres manuscrits du MNIST à l'aide d'un MLP dans R
Comparaison de la sortie MNIST avec un code identique en Python
Remarques finales

1. Installation de Keras avec tensorflow sur le backend.

Les étapes pour installer Keras dans RStudio sont très simples. Suivez simplement les étapes ci-dessous et ce serait bien si vous créiez votre premier modèle de réseau de neurones dans R.

install.packages("devtools")

devtools::install_github("rstudio/keras")

L'étape ci-dessus chargera la bibliothèque keras à partir du référentiel GitHub. Il est maintenant temps de charger keras dans R et d'installer tensorflow.

library(keras)

Par défaut, RStudio charge la version CPU de tensorflow. Utilisez la commande suivante pour télécharger la version CPU de tensorflow.

install_tensorflow()

Pour installer la version mono-utilisateur prise en charge par GPU de tensorflow / système de bureau, utilisez la commande suivante.

install_tensorflow(gpu=TRUE)

Pour une installation multi-utilisateurs, regarde ça guide d'installation.

Maintenant que nous avons keras et tensorflow installés dans RStudio, commençons et construisons notre premier réseau de neurones en R pour résoudre l'ensemble de données MNIST.

2. Différents types de modèles pouvant être construits dans R en utilisant keras

Vous trouverez ci-dessous la liste des modèles pouvant être construits dans R à l'aide de Keras.

Perceptrons multicouches
Réseaux de neurones complexes
Réseaux de neurones récurrents
Modèles Skip-Gram
Utilisez des modèles déjà formés comme VGG16, RESNET, etc.
Optimisez les modèles déjà formés.

Commençons par créer un modèle MLP très simple en utilisant juste une couche cachée pour essayer de catégoriser les chiffres manuscrits.

3. Classification des chiffres manuscrits MNIST via MLP dans 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)

Le code ci-dessus avait une précision d'apprentissage de 99,14 et une précision de validation de 96,89. Le code a fonctionné sur mon processeur i5 et a pris environ 13.5 secondes pour une seule époque, tandis que, sur un GPU TITANx, la précision de validation était 98.44 avec un temps moyen de 2 secondes.

4. MLP utilisant dur – R contre Python

Par souci de comparaison, de plus, j'ai implémenté le problème MNIST ci-dessus en python. Il ne devrait y avoir aucune différence puisque keras dans R crée une instance conda et exécute keras dessus. Mais reste, vous pouvez trouver le code python identique ci-dessous.

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

Le modèle précédent atteignait une précision de validation de 98,42 sur le même GPU. Ensuite, comme nous l'avions supposé au départ, les résultats sont égaux.

5. Remarques finales

S'il s'agissait de votre premier modèle d'apprentissage profond dans R, J'espère que tu as aimé. Avec un code très simple, a été en mesure de catégoriser les chiffres manuscrits avec une précision de 98%. Cela devrait être une motivation suffisante pour commencer un apprentissage en profondeur..

Si vous avez déjà travaillé sur la bibliothèque d'apprentissage profond Keras en Python, Vous constaterez que la syntaxe et la structure de la bibliothèque keras dans R est très similaire à Python. En réalité, Le package keras dans R crée un environnement conda et installe tout ce qui est essentiel pour exécuter keras dans cet environnement. Mais maintenant, je suis plus enthousiaste à l'idée de voir les scientifiques des données créer des modèles d'apprentissage en profondeur réels dans R. Comment dit-on, la concurrence ne doit jamais s'arrêter. J'aimerais également entendre vos réflexions sur ce nouveau développement pour R. N'hésitez pas à commenter.