Deep Learning in R Programming

Deep Learning is a part of AI that uses multi-layer neural networks to learn patterns from large and complex data. It is a subset of Machine Learning and is especially powerful for images, text, and sequential data. In R, deep learning combines strong statistical tools with modern neural network frameworks.

• Uses artificial neural networks with multiple hidden layers
• Learns automatically from structured and unstructured data
• Handles large-scale image, text, and sequence data efficiently

Why Use R for Deep Learning

R is widely used in data science and machine learning because of its strong statistical foundation and rich package ecosystem. For deep learning, it offers several advantages:

• Rich Packages: Provides libraries that simplify building deep learning models.
• Easy Prototyping: High-level syntax allows quick experimentation with less code.
• Framework Integration: Works smoothly with tools like TensorFlow and Keras.
• Strong Visualization: Excellent support for visualizing training and model performance.
• Statistical Strength: Ideal for deep data analysis and exploration before modeling.

Introduction to Deep Learning

This section covers the basic foundations of neural networks and how learning happens inside them.

• Types of Neural Networks
• Neural Networks Architecture and Learning Process
• Artificial Neural Networks and Its Applications
• Activation Functions in R

Core Neural Network Concepts

Understanding basic building blocks is essential before moving to advanced models.

• Feedforward Neural Networks (FNNs)
• Single-Layered Neural Networks
• Multi-Layered Neural Networks
• Pooling Layers

Neural Networks and Variants

Some networks are specially designed for sequential and time-based data.

• Recurrent Neural Networks
• What is GRU
• Long Short-Term Memory (LSTM)

Image Processing

Deep learning for images requires preprocessing and manipulation.

• The magick Package
• Scaling Image
• Image Arithmetic

Advanced Neural Network Architectures

These architectures are used for complex real-world problems.

• Convolutional Neural Networks (CNNs)
• Generative Adversarial Networks (GANs)

Training and Optimization Techniques

This are key techniques for training neural networks, such as stochastic gradient descent, batch size and optimizing for accuracy instead of loss.

• Epoch in Neural Network
• Gradient Descent Algorithm
• Stochastic Gradient Descent
• Bias Neurons
• Train and Test Neural Networks
• Optimizing for Accuracy Instead of Loss in Keras Model
• Batch Size
• Hyperparameter Tuning

Specialized Loss Functions & Techniques

Advanced techniques help improve prediction accuracy.

• Custom Loss Function with Keras
• Boosting
• Gradient Boosting

Packages for Deep Learning

R Programming Language has many deep learning packages in CRAN. Some of these packages are as follows :

Implementation of Neural Network in R

We will build a Neural Network using the deepnet package on the Breast Cancer dataset.

Step 1. Install and Load Required Packages

First, install and load the necessary libraries required for building and training the neural network model.

• mlbench: provides datasets including Breast Cancer
• neuralnet: used to build neural network models
• caret: helps in splitting data and evaluating models

install.packages("mlbench")
install.packages("deepnet")
install.packages("data.table")

library(data.table)
library(mlbench)
library(deepnet)

Step 2. Loading the Dataset  

Next, load the Breast Cancer dataset available in the mlbench package.

data(BreastCancer)

df <- as.data.table(BreastCancer)
df <- df[complete.cases(df)]
head(df)

Output:

Step 3. Data Cleaning and Transformation

Now we clean the dataset and convert the class labels into numeric values for training the neural network.

df$Id <- NULL

df$Class <- ifelse(df$Class == "malignant", 1, 0)
df[, -10] <- lapply(df[, -10], function(x) as.numeric(as.character(x)))

• The Id column is removed because it does not contribute to prediction.
• The Class column is converted into numeric values: 1 -> malignant, 0 -> benign
• Feature columns are converted into numeric format.

Step 4. Normalize the Dataset

Neural networks perform better when the input data is scaled between 0 and 1. We normalize the dataset using a custom function.

normalize <- function(x) {
  (x - min(x)) / (max(x) - min(x))
}

df_scaled <- as.data.frame(lapply(df, normalize))
head(df_scaled)

Output:

This step ensures that:

• All variables are on the same scale
• Model training becomes more stable and efficient.

Step 5. Split Data into Training and Testing Sets

We split the dataset into 70% training data and 30% testing data.

set.seed(123)

train_index <- createDataPartition(df_scaled$Class, p = 0.7, list = FALSE)

train_data <- df_scaled[train_index, ]
test_data  <- df_scaled[-train_index, ]

Step 6. Train the Neural Network Model

Now we train the neural network using the neuralnet() function

nn_model <- neuralnet(
  Class ~ .,
  data = train_data,
  hidden = 5,
  linear.output = FALSE
)

• Class ~ . : predicts Class using all other variables
• hidden = 5 : neural network contains 5 neurons in the hidden layer
• linear.output = FALSE : used for classification problems.

Step 7. Make Predictions and Convert to Classes

After training the neural network, we use the model to make predictions on the test dataset. The model returns probability values, which we convert into binary classes using a threshold value.

predictions <- compute(nn_model, test_data[, -10])
predicted_prob <- predictions$net.result

predicted_class <- ifelse(predicted_prob > 0.5, 1, 0)

• compute() is used to generate predictions from the trained neural network.
• predicted_prob contains probability values between 0 and 1.
• Using ifelse(), probabilities greater than 0.5 are classified as 1 (malignant) and others as 0 (benign).

Step 9. Create Confusion Matrix and Calculate Accuracy

Finally, evaluate the model performance using a confusion matrix and compute the accuracy.

cm <- table(test_data$Class, predicted_class)
print(cm)

accuracy <- sum(diag(cm)) / sum(cm)
cat("\nTest Accuracy:", accuracy * 100, "%")

Output:

We can further increase the accuracy of our model by fine-tuning as well as performing feature selection.

You can download the complete source code from here.

Related Articles

• Machine Learning with R Programming
• R Programming Tutorial