Keras e TensorFlow in R

introduzione

È sempre stato un argomento discutibile scegliere tra R e Python. Il mondo del machine learning è stato diviso per la preferenza di una lingua rispetto all'altra. Ma con l'esplosione del Deep Learning, equilibrio spostato su Python, dato che aveva un enorme elenco di librerie e framework di deep learning che mancavano a R (Fino ad ora).

Personalmente, sono passato a Python da r semplicemente perché volevo immergermi nello spazio di deep learning, ma con un R, era quasi impossibile. Ma non più!

Con il lancio di Keras a R, questa lotta torna al centro. Python stava lentamente diventando il linguaggio de facto per i modelli di deep learning. Ma con il rilascio della libreria Keras in R con tensorflow (Compatibilità CPU e GPU) nel backend d'ora in poi, È probabile che R lotterà di nuovo contro Python per il podio anche nello spazio Deep Learning.

Prossimo, vedremo come installare Keras con Tensorflow in R e costruire il nostro primo modello di rete neurale sul classico dataset MNIST in RStudio.

Sommario

Installazione di Keras con tensorflow sul backend.
Diversi tipi di modelli che possono essere costruiti in R usando Keras
Classificazione delle cifre scritte a mano MNIST utilizzando un MLP in R
Confronto dell'output MNIST con codice identico in Python
Note finali

1. Installazione di Keras con tensorflow sul backend.

I passaggi per installare Keras in RStudio sono molto semplici. Segui i passaggi seguenti e sarebbe bello se creassi il tuo primo modello di rete neurale in R.

install.packages("devtools")

devtools::install_github("rstudio/keras")

Il passaggio precedente caricherà la libreria keras dal repository GitHub. Ora è il momento di caricare keras in R e installare tensorflow.

library(keras)

Per impostazione predefinita, RStudio carica la versione CPU di tensorflow. Usa il seguente comando per scaricare la versione CPU di tensorflow.

install_tensorflow()

Per installare la versione di tensorflow supportata dalla GPU per utente singolo / sistema desktop, usa il seguente comando.

install_tensorflow(gpu=TRUE)

Per installazione multiutente, guarda questo guida d'installazione.

Ora che abbiamo keras e tensorflow installati all'interno di RStudio, iniziamo e costruiamo la nostra prima rete neurale in R per risolvere il set di dati MNIST.

2. Diversi tipi di modelli che possono essere costruiti in R usando keras

Di seguito è riportato l'elenco dei modelli che possono essere costruiti in R utilizzando Keras.

Perceptron multistrato
Reti neurali complesse
Reti neurali ricorrenti
Modelli Skip-Gram
Utilizzare modelli precedentemente addestrati come VGG16, RESNET, eccetera.
Ottimizza i modelli precedentemente addestrati.

Iniziamo con la creazione di un modello MLP molto semplice utilizzando solo un livello nascosto per cercare di classificare le cifre scritte a mano.

3. Classificazione delle cifre scritte a mano MNIST tramite MLP in 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)

Il codice sopra aveva una precisione di addestramento di 99,14 e una precisione di convalida di 96,89. Il codice è stato eseguito sul mio processore i5 e ha preso in giro 13.5 secondi per una singola epoca, mentre, su una GPU TITANx, la precisione di convalida era 98.44 con un tempo medio di 2 secondi.

4. MLP usando hard – R contro Python

Per fare un confronto, inoltre ho implementato il problema MNIST sopra in python. Non dovrebbero esserci differenze poiché keras in R crea un'istanza conda ed esegue keras su di essa. Ma ancora, puoi trovare il codice Python identico qui sotto.

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

Il modello precedente ha raggiunto una precisione di convalida di 98,42 sulla stessa GPU. Quindi, come inizialmente supponevamo, i risultati sono uguali.

5. Note finali

Se questo fosse il tuo primo modello di Deep Learning in R, Spero ti sia piaciuto. Con un codice molto semplice, era in grado di classificare le cifre scritte a mano con una precisione del 98%. Questa dovrebbe essere una motivazione sufficiente per iniziare l'apprendimento profondo..

Se hai già lavorato sulla libreria di deep learning di Keras in Python, Scoprirai che la sintassi e la struttura della libreria keras in R sono molto simili a Python. In realtà, Il pacchetto keras in R crea un ambiente conda e installa tutto ciò che è essenziale per eseguire keras in quell'ambiente. Ma ora sono più entusiasta di vedere gli scienziati dei dati creare modelli di deep learning nella vita reale in R. Come si dice, la concorrenza non dovrebbe mai fermarsi. Vorrei anche sentire i tuoi pensieri su questo nuovo sviluppo per R. Sentiti libero di commentare.