Keras und TensorFlow in R

Einführung

Es war schon immer ein umstrittenes Thema, zwischen R und Python zu wählen. Die Welt des maschinellen Lernens wurde über die Bevorzugung einer Sprache gegenüber der anderen gespalten. Aber mit der Explosion von Deep Learning, Balance auf Python verschoben, da es eine riesige Liste von Deep-Learning-Bibliotheken und -Frameworks gab, die R fehlte (Bis jetzt).

Persönlich, Ich bin von r zu Python gewechselt, weil ich in den Deep-Learning-Raum eintauchen wollte, aber mit einem R, es war fast unmöglich. Aber nicht mehr!

Mit der Einführung von Keras in R, dieser Kampf kehrt ins Zentrum zurück. Python wurde langsam zur De-facto-Sprache für Deep-Learning-Modelle. Aber mit der Veröffentlichung der Keras-Bibliothek in R mit tensorflow (CPU- und GPU-Kompatibilität) ab sofort im Backend, R wird wahrscheinlich sogar im Deep Learning-Bereich wieder mit Python um das Podium kämpfen.

Dann, Wir werden sehen, wie man Keras mit Tensorflow in R installiert und unser erstes neuronales Netzwerkmodell auf dem klassischen MNIST-Datensatz in RStudio erstellt.

Inhaltsverzeichnis

Keras-Installation mit Tensorflow im Backend.
Verschiedene Typen von Modellen, die mit Keras . in R erstellt werden können
MNIST Handschriftliche Ziffernklassifizierung mit einem MLP in R
Vergleich der MNIST-Ausgabe mit identischem Code in Python
Abschließende Anmerkungen

1. Keras-Installation mit Tensorflow im Backend.

Die Schritte zur Installation von Keras in RStudio sind sehr einfach. Befolgen Sie einfach die folgenden Schritte und es wäre schön, wenn Sie Ihr erstes neuronales Netzwerkmodell in R . erstellen würden.

install.packages("devtools")

devtools::install_github("rstudio/keras")

Der obige Schritt lädt die Keras-Bibliothek aus dem GitHub-Repository. Jetzt ist es an der Zeit, Keras in R zu laden und tensorflow zu installieren.

library(keras)

Standardmäßig, RStudio lädt die CPU-Version von tensorflow. Verwenden Sie den folgenden Befehl, um die CPU-Version von tensorflow herunterzuladen.

install_tensorflow()

So installieren Sie die von der Einzelbenutzer-GPU unterstützte Version von tensorflow / Desktop-System, Verwenden Sie den folgenden Befehl.

install_tensorflow(gpu=TRUE)

Für Mehrbenutzerinstallation, Sieh dir das an Installationsanleitung.

Jetzt haben wir Keras und Tensorflow in RStudio installiert, Lass uns loslegen und unser erstes neuronales Netzwerk in R aufbauen, um den MNIST-Datensatz zu lösen.

2. Verschiedene Arten von Modellen, die mit keras . in R gebaut werden können

Unten ist die Liste der Modelle, die mit Keras . in R gebaut werden können.

Mehrschichtige Perzeptronen
Komplizierte neuronale Netze
Rekurrente neuronale Netze
Modelos Skip-Gram
Verwenden Sie zuvor trainierte Modelle wie VGG16, RESNET, etc.
Tunen Sie zuvor trainierte Modelle.

Beginnen wir damit, ein sehr einfaches MLP-Modell zu erstellen, das nur eine versteckte Schicht verwendet, um zu versuchen, die handgeschriebenen Ziffern zu kategorisieren.

3. MNIST Handschriftliche Ziffernklassifizierung über 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)

Der obige Code hatte eine Trainingspräzision von 99,14 und eine Validierungsgenauigkeit von 96,89. Der Code lief auf meinem i5-Prozessor und dauerte herum 13.5 Sekunden für eine einzelne Epoche, während, auf einer TITANx-GPU, die Validierungsgenauigkeit war 98.44 mit einer durchschnittlichen Zeit von 2 Sekunden.

4. MLP mit hartem – R vs Python

Zum Vergleich, außerdem habe ich das obige MNIST-Problem in Python implementiert. Es sollte keinen Unterschied geben, da keras in R eine Conda-Instanz erstellt und keras darauf ausführt. Aber dennoch, Sie können den identischen Python-Code unten finden.

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

Das Vorgängermodell erreichte eine Validierungsgenauigkeit von 98,42 auf der gleichen GPU. Dann, wie wir anfangs angenommen haben, die ergebnisse sind gleich.

5. Abschließende Anmerkungen

Wenn dies Ihr erstes Deep-Learning-Modell in R war, Ich hoffe, dass es Ihnen gefallen hat. Mit einem ganz einfachen Code, konnte handgeschriebene Ziffern mit einer Genauigkeit von kategorisieren 98%. Dies sollte Motivation genug sein, um mit Deep Learning zu beginnen..

Wenn Sie bereits an der keras Deep-Learning-Bibliothek in Python gearbeitet haben, Sie werden feststellen, dass die Syntax und Struktur der Keras-Bibliothek in R Python sehr ähnlich ist. In Wirklichkeit, keras-Paket in R erstellt eine Conda-Umgebung und installiert alles, was für die Ausführung von keras in dieser Umgebung erforderlich ist. Aber jetzt freue ich mich noch mehr, zu sehen, wie Data Scientists reale Deep-Learning-Modelle in R . entwickeln. Wie sagt man, Der Wettbewerb sollte nie aufhören. Ich würde auch gerne Ihre Meinung zu dieser neuen Entwicklung für R . hören. Fühlen Sie sich frei zu kommentieren.