keras: R में डीप लर्निंग

जैसा कि आप अब तक जानते हैं, मशीन लर्निंग कंप्यूटर साइंस (CS) का एक उपक्षेत्र है। डीप लर्निंग, मशीन लर्निंग का ही एक उपक्षेत्र है, जिसमें ऐसे एल्गोरिदम शामिल हैं जो मस्तिष्क की संरचना और कार्य से प्रेरित होते हैं और जिन्हें आमतौर पर आर्टिफिशियल न्यूरल नेटवर्क्स (ANN) कहा जाता है। वर्तमान में डीप लर्निंग, मशीन लर्निंग के सबसे चर्चित रुझानों में से एक है, और कई समस्याएँ हैं जहाँ डीप लर्निंग उत्कृष्ट प्रदर्शन करता है, जैसे रोबोटिक्स, इमेज रिकग्निशन और आर्टिफिशियल इंटेलिजेंस (AI)।

आज के इस ट्यूटोरियल में आप R में Keras के साथ keras पैकेज का उपयोग करते हुए डीप लर्निंग की संक्षिप्त परिचयात्मक जानकारी पाएँगे:

# Load in the keras package
library(keras)

# Install TensorFlow
install_tensorflow()

डेटा लोड करना

अब जबकि इंस्टॉलेशन प्रक्रिया स्पष्ट है और आपका वर्कस्पेस तैयार है, आप अपना डेटा लोड करना शुरू कर सकते हैं! इस बिंदु पर, डेटा के संदर्भ में आपके पास तीन बड़े विकल्प हैं: आप keras पैकेज के साथ आने वाले बिल्ट-इन डेटासेट में से किसी एक का उपयोग कर सकते हैं, आप अपने स्वयं के डेटासेट को, उदाहरण के लिए, CSV फ़ाइलों से लोड कर सकते हैं, या आप कुछ डमी डेटा बना सकते हैं।

आप किसी भी स्थिति में हों, आप देखेंगे कि आप पैकेज के साथ जल्दी शुरू कर पाएँगे। यह सेक्शन इन तीनों विकल्पों पर संक्षेप में जाएगा और बताएगा कि आप शुरुआत करने के लिए आवश्यक डेटा को कैसे लोड (या बनाए) सकते हैं!

# Read in MNIST data
mnist <- dataset_mnist()

# Read in CIFAR10 data
cifar10 <- dataset_cifar10()

# Read in IMDB data
imdb <- dataset_imdb()

# Make your dummy data
data <- matrix(rexp(1000*784), nrow = 1000, ncol = 784)

# Make dummy target values for your dummy data
labels <- matrix(round(runif(1000*10, min = 0, max = 9)), nrow = 1000, ncol = 10)

# Read in `iris` data
iris <- read.csv(url("http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"), header = FALSE) 

# Return the first part of `iris`
head(....)

# Inspect the structure
str(....)

# Obtain the dimensions
dim(....)

डेटा अन्वेषण

इस ट्यूटोरियल के लिए, आप read.csv() फ़ंक्शन से इम्पोर्ट किए गए प्रसिद्ध iris डेटासेट के साथ काम करना जारी रखेंगे।

जिनके पास इस डेटा के साथ काम करने के लिए आवश्यक जीवविज्ञान का ज्ञान नहीं है, उनके लिए कुछ पृष्ठभूमि जानकारी: सभी फूलों में सेपल और पंखुड़ी (पेटल) होती है। सेपल, पंखुड़ियों को घेरता है और आमतौर पर हरा और पत्ती जैसी संरचना का होता है, जबकि पंखुड़ियाँ सामान्यतः रंगीन पत्तियाँ होती हैं। आइरिस फूलों के मामले में, यह थोड़ा अलग है, जैसा कि आप निम्न चित्र में देख सकते हैं:

आपने पिछले सेक्शन में शायद देखा होगा कि इम्पोर्ट के बाद iris डेटा फ्रेम में कोई कॉलम नाम नहीं थे। अब, ट्यूटोरियल के शेष भाग के लिए, यह बहुत महत्वपूर्ण नहीं है: भले ही read.csv() फ़ंक्शन आपको डेटा को data.frame के रूप में लौटाता है, लेकिन fit() फ़ंक्शन को जो डेटा पास करना है, वह मैट्रिक्स या एरे होना चाहिए।

अभी-अभी उल्लेखित इन दो डेटा संरचनाओं के बारे में ध्यान रखने योग्य कुछ बातें: - मैट्रिक्स और एरे में कॉलम नाम नहीं होते; - मैट्रिक्स एकल डेटा प्रकार की दो-आयामी वस्तुएँ हैं; - एरे एकल डेटा प्रकार की बहु-आयामी वस्तुएँ हैं;

टिप: यदि आप R में डेटा संरचनाओं का रीकैप चाहते हैं, तो यह वीडियो देखें!

ध्यान दें कि डेटा फ्रेम, दूसरी ओर, एक विशेष प्रकार की नामित लिस्ट है जहाँ सभी तत्वों की लंबाई समान होती है। यह एक बहु-आयामी वस्तु है जो एकाधिक डेटा प्रकार रख सकती है। आपने यह पहले ही देखा था जब आपने पिछले सेक्शन में iris डेटा फ्रेम की संरचना की जाँच की थी। यह जानते हुए और यह ध्यान में रखते हुए कि आपको एकल डेटा प्रकार की दो या बहु-आयामी वस्तु की ओर बढ़ना है, आपको अपने न्यूरल नेटवर्क के निर्माण से पहले कुछ प्रीप्रोसेसिंग करने के लिए तैयार रहना चाहिए!

फिलहाल, कॉलम नाम अन्वेषण उद्देश्यों के लिए सहायक हो सकते हैं, और वे निश्चित रूप से आपके डेटा की समझ को आसान बनाएँगे, इसलिए आइए names() फ़ंक्शन की मदद से कुछ कॉलम नाम जोड़ते हैं। अगला, आप तुरंत अपने डेटा अन्वेषण में iris वेरिएबल का उपयोग कर सकते हैं! उदाहरण के लिए, plot() फ़ंक्शन से देखें कि पंखुड़ी की लंबाई और चौड़ाई में कैसा सहसंबंध है।

names(iris) <- c("Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width", "Species")

plot(iris$Petal.Length, 
     iris$Petal.Width, 
     pch=21, bg=c("red","green3","blue")[unclass(iris$Species)], 
     xlab="Petal Length", 
     ylab="Petal Width")

ध्यान दें कि आप unclass() फ़ंक्शन का उपयोग स्पीशीज़ के नामों—“setosa, versicolor” और “virginica”—को 1, 2, और 3 की संख्याओं में बदलने के लिए करते हैं।

अब plotting फ़ंक्शन के परिणाम पर क़रीबी नज़र डालें:

ग्राफ़, आइरिस फूलों की विभिन्न प्रजातियों के लिए Petal.Length और Petal.Width के बीच पॉज़िटिव कोरिलेशन का संकेत देता है। हालाँकि, यह वह चीज़ है जिसे आप शायद cor() फ़ंक्शन से जाँचना चाहेंगे, जो आपको डेटा सेट में शामिल सभी विशेषताओं के बीच समग्र सहसंबंध देगा:

# Overall correlation between `Petal.Length` and `Petal.Width` 
cor(................., iris$Petal.Width)

इसके अतिरिक्त, आप corrplot पैकेज का उपयोग cor() फ़ंक्शन के साथ मिलाकर अपने डेटा की विशेषताओं के बीच सहसंबंधों को प्लॉट कर सकते हैं; इस मामले में, आप iris डेटा फ्रेम की सभी विशेषताओं के लिए समग्र सहसंबंध की गणना करते हैं। आप इस गणना के परिणाम को वेरिएबल M में स्टोर करते हैं और उसे corrplot() फ़ंक्शन में पास करते हैं।

साथ ही, यह बताना न भूलें कि आप डेटा को किस विधि से प्लॉट करना चाहते हैं, इसके लिए method आर्ग्युमेंट निर्दिष्ट करें!

आप नीचे दिए गए DataCamp Light खंड में विज़ुअलाइज़ेशन विधि के साथ और प्रयोग कर सकते हैं:

# Store the overall correlation in `M`
M <- cor(iris[,1:4])

# Plot the correlation plot with `M`
corrplot(M, method="circle")

अपने डेटा का और अन्वेषण करने के लिए R कंसोल का उपयोग करें।

यदि आप इस डेटा के लिए ggvis पैकेज—जो इंटरेक्टिव ग्रामर ऑफ़ ग्राफ़िक्स है—से प्लॉट बनाना चाहते हैं, तो DataCamp का Machine Learning in R For Beginners ट्यूटोरियल देखें या DataCamp का ggvis कोर्स करें।

डेटा प्रीप्रोसेसिंग

मॉडल बनाने से पहले, आपको यह भी सुनिश्चित करना होगा कि आपका डेटा साफ़, नार्मलाइज़ (यदि लागू हो) और ट्रेनिंग व टेस्ट सेट में विभाजित हो। चूँकि डेटासेट UCI मशीन लर्निंग रिपॉज़िटरी से आता है, आप उम्मीद कर सकते हैं कि यह पहले से कुछ हद तक साफ़ होगा, लेकिन फिर भी अपने डेटा की गुणवत्ता की दोबारा जाँच कर लेते हैं।

पहली नज़र में, जब आपने head() से डेटा का निरीक्षण किया, तो कुछ असामान्य नहीं दिखा, है न? आइए summary() और str() का उपयोग करके संक्षेप में वह दोहराएँ जो आपने सीखा था जब आपने जाँचा था कि आपका डेटा इम्पोर्ट सफल हुआ या नहीं:

# Pull up a summary of `iris`
summary(....)

# Inspect the structure of `iris`
str(....)

अब जब आप आश्वस्त हैं कि डेटा पर्याप्त रूप से साफ़ है, तो आप यह जाँचना शुरू कर सकते हैं कि इस ट्यूटोरियल के लिए जिन डेटा पर आप काम कर रहे हैं, उनमें से किसी को नार्मलाइज़ करना आवश्यक है या नहीं।

# Build your own `normalize()` function
normalize <- function(x) {
  num <- x - min(x)
  denom <- max(x) - min(x)
  return (num/denom)
}

# Normalize the `iris` data
iris_norm <- as.data.frame(lapply(iris[1:4], .........))

# Return the first part of `iris` 
head(....)

iris[,5] <- ...........(iris[,5]) -1

# Turn `iris` into a matrix
iris <- as.matrix(iris)

# Set `iris` `dimnames` to `NULL`
dimnames(....) <- NULL

# Normalize the `iris` data
iris <- normalize(....[,1:4])

# Return the summary of `iris`
summary(....)

# Determine sample size
ind <- sample(2, nrow(....), replace=TRUE, prob=c(0.67, 0.33))

# Split the `iris` data
iris.training <- ....[ind==1, 1:4]
iris.test <- iris[ind==2, 1:4]

# Split the class attribute
iris.trainingtarget <- iris[...==1, 5]
iris.testtarget <- iris[ind==2, 5]

x_train <- imdb$train$x
y_train <- imdb$train$y
x_test <- imdb$test$x
y_test <- imdb$test$y

# One hot encode training target values
iris.trainLabels <- to_categorical(...................

# One hot encode test target values
iris.testLabels <- to_categorical(...............)

# Print out the iris.testLabels to double check the result
print(.............)

मॉडल का निर्माण

मॉडल बनाना शुरू करने के लिए, आपको पहले keras_model_sequential() फ़ंक्शन की मदद से एक सीक्वेंशियल मॉडल इनिशियलाइज़ करना चाहिए। फिर, आप मॉडलिंग शुरू करने के लिए तैयार हैं।

हालाँकि, शुरू करने से पहले, इस डेटासेट के बारे में अपने मूल प्रश्न पर वापस जाना अच्छा विचार है: क्या आप किसी विशेष आइरिस फूल की स्पीशीज़ का पूर्वानुमान लगा सकते हैं? संख्यात्मक डेटा के साथ काम करना आसान होता है, और आपने डेटा को प्रीप्रोसेस किया है और टार्गेट वेरिएबल के मानों को वन-हॉट एनकोड किया है: कोई फूल या तो versicolor, setosa या virginica प्रकार का होता है और यह बाइनरी 1 और 0 मानों से परिलक्षित होता है।

ऐसी समस्या पर अच्छा प्रदर्शन करने वाली नेटवर्क की एक किस्म मल्टी-लेयर पर्सेप्ट्रॉन है। इस प्रकार का न्यूरल नेटवर्क अक्सर फुली-कनेक्टेड होता है। इसका मतलब है कि आप इस समस्या को हल करने के लिए फुली-कनेक्टेड लेयर्स का एक अपेक्षाकृत सरल स्टैक बनाना चाहते हैं। जहाँ तक एक्टिवेशन फ़ंक्शंस की बात है, परिचयात्मक उद्देश्य के लिए यहाँ सबसे सामान्य में से एक का उपयोग करना बेहतर है—relu एक्टिवेशन फ़ंक्शन। यह रेक्टिफ़ायर एक्टिवेशन फ़ंक्शन hidden लेयर में उपयोग किया जाता है, जो सामान्यतः अच्छा अभ्यास है।

इसके अलावा, आप देखते हैं कि आउटपुट लेयर में softmax एक्टिवेशन फ़ंक्शन का उपयोग किया गया है। आप ऐसा इसलिए करते हैं ताकि आउटपुट मान 0 और 1 की सीमा में हों और उन्हें प्रेडिक्टेड प्रॉबेबिलिटी के रूप में उपयोग किया जा सके:

# Initialize a sequential model
model <- ......................

# Add layers to the model
model %>% 
    layer_dense(units = 8, activation = 'relu', input_shape = c(4)) %>% 
    layer_dense(units = 3, activation = 'softmax')

ध्यान दें कि आउटपुट लेयर 3 आउटपुट मान बनाती है, प्रत्येक Iris क्लास (versicolor, virginica या setosa) के लिए एक। दूसरी ओर, पहली लेयर, जिसमें 8 hidden नोड्स हैं, का input_shape 4 है। ऐसा इसलिए है क्योंकि आपके ट्रेनिंग डेटा iris.training में 4 कॉलम हैं।

आप अपने मॉडल का आगे निरीक्षण निम्नलिखित फ़ंक्शंस से कर सकते हैं:

• summary() फ़ंक्शन का उपयोग करके आप अपने मॉडल का एक सारांश प्रतिनिधित्व प्रिंट कर सकते हैं;
• get_config() एक सूची लौटाएगा जिसमें मॉडल का कॉन्फ़िगरेशन शामिल होगा;
• get_layer() लेयर कॉन्फ़िगरेशन लौटाएगा।
• layers एट्रीब्यूट का उपयोग मॉडल की लेयरों की फ्लैट लिस्ट प्राप्त करने के लिए किया जा सकता है;
• इनपुट टेन्सर्स की सूची के लिए, आप inputs एट्रीब्यूट का उपयोग कर सकते हैं; और
• अंत में, आउटपुट टेन्सर्स प्राप्त करने के लिए, आप outputs एट्रीब्यूट का उपयोग कर सकते हैं।

# Print a summary of a model
summary(model)

# Get model configuration
get_config(model)

# Get layer configuration
get_layer(model, index = 1)

# List the model's layers
model$layers

# List the input tensors
model$inputs

# List the output tensors
model$outputs

Compile and Fit the Model

Now that you have set up the architecture of your model, it’s time to compile and fit the model to the data. To compile your model, you configure the model with the adam optimizer and the categorical_crossentropy loss function. Additionally, you also monitor the accuracy during the training by passing 'accuracy' to the metrics argument.

# Compile the model
model %>% compile(
     loss = 'categorical_crossentropy',
     optimizer = 'adam',
     metrics = 'accuracy'
 )

The optimizer and the loss are two arguments that are required if you want to compile the model.

Some of the most popular optimization algorithms used are the Stochastic Gradient Descent (SGD), ADAM and RMSprop. Depending on whichever algorithm you choose, you’ll need to tune certain parameters, such as learning rate or momentum. The choice for a loss function depends on the task that you have at hand: for example, for a regression problem, you’ll usually use the Mean Squared Error (MSE).

As you see in this example, you used categorical_crossentropy loss function for the multi-class classification problem of determining whether an iris is of type versicolor, virginica or setosa. However, note that if you would have had a binary-class classification problem, you should have made use of the binary_crossentropy loss function.

Next, you can also fit the model to your data; In this case, you train the model for 200 epochs or iterations over all the samples in iris.training and iris.trainLabels, in batches of 5 samples.

# Fit the model 
model %>% fit(
     iris.training, 
     iris.trainLabels, 
     epochs = 200, 
     batch_size = 5, 
     validation_split = 0.2
 )

Tip if you want, you can also specify the verbose argument in the fit() function. By setting this argument to 1, you indicate that you want to see progress bar logging.

What you do with the code above is training the model for a specified number of epochs or exposures to the training dataset. An epoch is a single pass through the entire training set, followed by testing of the verification set. The batch size that you specify in the code above defines the number of samples that going to be propagated through the network. Also, by doing this, you optimize efficiency because you make sure that you don’t load too many input patterns into memory at the same time.

Visualize the Model Training History

Also, it’s good to know that you can also visualize the fitting if you assign the lines of code in the DataCamp Light chunk above to a variable. You can then pass the variable to the plot() function, as you see in this particular code chunk!

# Store the fitting history in `history` 
history <- model %>% fit(
     iris.training, 
     iris.trainLabels, 
     epochs = 200,
     batch_size = 5, 
     validation_split = 0.2
 )

# Plot the history
plot(history)

Make sure to study the plot in more detail.

At first sight, it’s no surprise that this all looks a tad messy. You might not entirely know what you’re looking at, right?

One good thing to know is that the loss and acc indicate the loss and accuracy of the model for the training data, while the val_loss and val_acc are the same metrics, loss and accuracy, for the test or validation data.

But, even as you know this, it’s not easy to interpret these two graphs. Let’s try to break this up into pieces that you might understand more easily! You’ll split up these two plots and make two separate ones instead: you’ll make one for the model loss and another one for the model accuracy. Luckily, you can easily make use of the $ operator to access the data and plot it step by step.

Check out the DataCamp Light box below to see how you can do this:

# Plot the model loss of the training data
plot(history$metrics$loss, main="Model Loss", xlab = "epoch", ylab="loss", col="blue", type="l")

# Plot the model loss of the test data
lines(history$metrics$val_loss, col="green")

# Add legend
legend("topright", c("train","test"), col=c("blue", "green"), lty=c(1,1))

In this first plot, you plotted the loss of the model on the training and test data. Now it’s time to also do the same, but then for the accuracy of the model:

# Plot the accuracy of the training data 
plot(history$metrics$acc, main="Model Accuracy", xlab = "epoch", ylab="accuracy", col="blue", type="l")

# Plot the accuracy of the validation data
lines(history$metrics$val_acc, col="green")

# Add Legend
legend("bottomright", c("train","test"), col=c("blue", "green"), lty=c(1,1))

Some things to keep in mind here are the following:

• If your training data accuracy keeps improving while your validation data accuracy gets worse, you are probably overfitting: your model starts to just memorize the data instead of learning from it.
• If the trend for accuracy on both datasets is still rising for the last few epochs, you can clearly see that the model has not yet over-learned the training dataset.

Predict Labels of New Data

Now that your model is created, compiled and has been fitted to the data, it’s time to actually use your model to predict the labels for your test set iris.test. As you might have expected, you can use the predict() function to do this. After, you can print out the confusion matrix to check out the predictions and the real labels of the iris.test data with the help of the table() function.

# Predict the classes for the test data
classes <- model %>% predict_classes(iris.test, batch_size = 128)

# Confusion matrix
table(iris.testtarget, classes)

What do you think of the results? At first sight, does this model that you have created make the right predictions?

Evaluating your Model

Even though you already have a slight idea of how your model performed by looking at the predicted labels for iris.test, it’s still important that you take the time to evaluate your model. Use the evaluate() function to do this: pass in the test data iris.test, the test labels iris.testLabels and define the batch size. Store the result in a variable score, like in the code example below:

# Evaluate on test data and labels
score <- model %>% evaluate(iris.test, iris.testLabels, batch_size = 128)

# Print the score
print(score)

By printing score, you’ll get back the loss value and the metric value (in this case 'accuracy') back.

Fine-tuning your Model

Fine-tuning your model is probably something that you’ll be doing a lot, especially in the beginning, because not all classification and regression problems are as straightforward as the one that you saw in the first part of this tutorial. As you read above, there are already two key decisions that you’ll probably want to adjust: how many layers you’re going to use and how many “hidden units” you will choose for each layer.

In the beginning, this will really be quite a journey.

Besides playing around with the number of epochs or the batch size, there are other ways in which you can tweak your model in the hopes that it will perform better: by adding layers, by increasing the number of hidden units and by passing your own optimization parameters to the compile() function. This section will go over these three options.

# Initialize the sequential model
model <- keras_model_sequential() 

# Add layers to model
model %>% 
    layer_dense(units = 8, activation = 'relu', input_shape = c(4)) %>% 
    layer_dense(units = 5, activation = 'relu') %>% 
    layer_dense(units = 3, activation = 'softmax')

# Compile the model
model %>% compile(
     loss = 'categorical_crossentropy',
     optimizer = 'adam',
     metrics = 'accuracy'
 )

# Fit the model to the data
model %>% fit(
     iris.training, iris.trainLabels, 
     epochs = 200, batch_size = 5, 
     validation_split = 0.2
 )

# Evaluate the model
score <- model %>% evaluate(iris.test, iris.testLabels, batch_size = 128)

# Print the score
print(score)

# Initialize a sequential model
model <- keras_model_sequential() 

# Add layers to the model
model %>% 
    layer_dense(units = 8, activation = 'relu', input_shape = c(4)) %>% 
    layer_dense(units = 5, activation = 'relu') %>% 
    layer_dense(units = 3, activation = 'softmax')

# Compile the model
model %>% compile(
     loss = 'categorical_crossentropy',
     optimizer = 'adam',
     metrics = 'accuracy'
 )

# Save the training history in history
history <- model %>% fit(
  iris.training, iris.trainLabels, 
  epochs = 200, batch_size = 5,
  validation_split = 0.2
 )

# Plot the model loss
plot(history$metrics$loss, main="Model Loss", xlab = "epoch", ylab="loss", col="blue", type="l")
lines(history$metrics$val_loss, col="green")
legend("topright", c("train","test"), col=c("blue", "green"), lty=c(1,1))

# Plot the model accuracy
plot(history$metrics$acc, main="Model Accuracy", xlab = "epoch", ylab="accuracy", col="blue", type="l")
lines(history$metrics$val_acc, col="green")
legend("bottomright", c("train","test"), col=c("blue", "green"), lty=c(1,1))

# Initialize a sequential model
model <- keras_model_sequential() 

# Add layers to the model
model %>% 
    layer_dense(units = 28, activation = 'relu', input_shape = c(4)) %>% 
    layer_dense(units = 3, activation = 'softmax')

# Compile the model
model %>% compile(
     loss = 'categorical_crossentropy',
     optimizer = 'adam',
     metrics = 'accuracy'
 )

# Fit the model to the data
model %>% fit(
     iris.training, iris.trainLabels, 
     epochs = 200, batch_size = 5, 
     validation_split = 0.2
 )

# Evaluate the model
score <- model %>% evaluate(iris.test, iris.testLabels, batch_size = 128)

# Print the score
print(score)

# Initialize the sequential model
model <- keras_model_sequential() 

# Add layers to the model
model %>% 
    layer_dense(units = 28, activation = 'relu', input_shape = c(4)) %>% 
    layer_dense(units = 3, activation = 'softmax')

# Compile the model
model %>% compile(
     loss = 'categorical_crossentropy',
     optimizer = 'adam',
     metrics = 'accuracy'
 )

# Save the training history in the history variable
history <- model %>% fit(
  iris.training, iris.trainLabels, 
  epochs = 200, batch_size = 5, 
  validation_split = 0.2
 )

# Plot the model loss
plot(history$metrics$loss, main="Model Loss", xlab = "epoch", ylab="loss", col="blue", type="l")
lines(history$metrics$val_loss, col="green")
legend("topright", c("train","test"), col=c("blue", "green"), lty=c(1,1))

# Plot the model accuracy
plot(history$metrics$acc, main="Model Accuracy", xlab = "epoch", ylab="accuracy", col="blue", type="l")
lines(history$metrics$val_acc, col="green")
legend("bottomright", c("train","test"), col=c("blue", "green"), lty=c(1,1))

# Initialize a sequential model
model <- keras_model_sequential() 

# Build up your model by adding layers to it
model %>% 
    layer_dense(units = 8, activation = 'relu', input_shape = c(4)) %>% 
    layer_dense(units = 3, activation = 'softmax')

# Define an optimizer
sgd <- optimizer_sgd(lr = 0.01)

# Use the optimizer to compile the model
model %>% compile(optimizer=sgd, 
                  loss='categorical_crossentropy', 
                  metrics='accuracy')

# Fit the model to the training data
model %>% fit(
     iris.training, iris.trainLabels, 
     epochs = 200, batch_size = 5, 
     validation_split = 0.2
 )

# Evaluate the model
score <- model %>% evaluate(iris.test, iris.testLabels, batch_size = 128)

# Print the loss and accuracy metrics
print(score)

# Define an optimizer
sgd <- optimizer_sgd(lr = 0.01)

# Compile the model
model %>% compile(optimizer=sgd, 
                  loss='categorical_crossentropy', 
                  metrics='accuracy')

# Fit the model to the training data
history <- model %>% fit(
  iris.training, iris.trainLabels, 
  epochs = 200, batch_size = 5, 
  validation_split = 0.2
 )

# Plot the model loss
plot(history$metrics$loss, main="Model Loss", xlab = "epoch", ylab="loss", col="blue", type="l")
lines(history$metrics$val_loss, col="green")
legend("topright", c("train","test"), col=c("blue", "green"), lty=c(1,1))

# Plot the model accuracy
plot(history$metrics$acc, main="Model Accuracy", xlab = "epoch", ylab="accuracy", col="blue", type="l")
lines(history$metrics$val_acc, col="green")
legend("bottomright", c("train","test"), col=c("blue", "green"), lty=c(1,1))

Saving, Loading or Exporting your Model

There is one last thing that remains in your journey with the keras package and that is saving or exporting your model so that you can load it back in at another moment.

• Firstly, you can easily make use of the save_model_hdf5() and load_model_hdf5() functions to save and load your model into your workspace:

save_model_hdf5(model, "my_model.h5")
model <- load_model_hdf5("my_model.h5")

• Additionally, you can also save and load the model weights with the save_model_weights_hdf5() and load_model_weights_hdf5() functions:

save_model_weights_hdf5("my_model_weights.h5")
model %>% load_model_weights_hdf5("my_model_weights.h5")

• Lastly, it’s good to know that you can also export your model configuration to JSON or YAML. Here, the functions model_to_json() and model_to_yaml() will help you out. To load the configurations back into your workspace, you can just use the model_from_json() and model_from yaml() functions:

json_string <- model_to_json(model)
model <- model_from_json(json_string)

yaml_string <- model_to_yaml(model)
model <- model_from_yaml(yaml_string)