Modular Training Components

Introduction

Welcome back to lesson 2 of "Building and Applying Your Neural Network Library"! You've made excellent progress in this course. In our previous lesson, we successfully transformed our neural network code into a well-structured modular system by organizing our core components — dense layers and activation functions . We created clean import paths and established the foundation for a professional-grade neural network library. Now we're ready to take the next crucial step: modularizing our training components . As you may recall from our previous courses, training a neural network involves two key components beyond the layers themselves: loss functions (which measure how well our network is performing) and optimizers (which update the network's weights based on the gradients we compute). Currently, these components are scattered throughout our training scripts, making them difficult to reuse and maintain. In this lesson, we'll organize these training components into dedicated modules within our neuralnets directory structure. We'll create loss functions for our Mean Squared Error (MSE) loss and an optimizer class for our Stochastic Gradient Descent (SGD) optimizer. By the end of this lesson, you'll have a complete, modular training pipeline that demonstrates the power of good software architecture in machine learning projects.

Our Test Dataset: The XOR Problem

Before we dive into modularizing our training components, let's take a moment to understand the dataset we'll be using to test our library: the xor (exclusive or) problem . This is a classic toy problem in machine learning that serves as an excellent test case for neural networks because it's non-linearly separable — meaning a single linear classifier cannot solve it, but a simple multi-layer neural network can. The xor problem consists of four data points with two binary inputs and one binary output. The output is 1 when exactly one of the inputs is 1, and 0 otherwise. This creates the pattern: [0,0] \to 0, [0,1] \to 1, [1,0] \to 1, [1,1] \to 0 . This is typically treated as a classification problem, but we can frame it as a regression task as well, which is what we'll do by using our mse loss. Despite its simplicity, if our network can learn xor, then we know our forward pass, backward pass, loss calculation, and optimization code are all functioning properly. R # XOR dataset setup X_train <- matrix(c(0,0, 0,1, 1,0, 1,1), nrow=4, ncol=2, byrow=TRUE) y_train <- matrix(c(0, 1, 1, 0), nrow=4, ncol=1) In this setup, nrow=4 specifies we have 4 training samples, ncol=2 indicates each sample has 2 input features, and byrow=TRUE ensures the data is filled row-by-row — meaning each row represents a complete sample. This structure follows the standard convention in machine learning where rows are samples (data points) and columns are features (input dimensions). While we're using xor for rapid development and testing in this lesson, later in the course we'll apply our complete neural network library to a real-world dataset — the california housing dataset — where we'll predict house prices based on various features like location, population, and median income.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

mse_loss <- function(y_true, y_pred) {
  # Calculate Mean Squared Error loss
  return(mean((y_true - y_pred)^2))
}

mse_loss_derivative <- function(y_true, y_pred) {
  # Derivative of MSE loss w.r.t. y_pred
  # Normalize by batch size (number of samples)
  return(2 * (y_pred - y_true) / nrow(y_true))
}

mse_loss <- function(y_true, y_pred) {
  # Calculate Mean Squared Error loss
  return(mean((y_true - y_pred)^2))
}

mse_loss_derivative <- function(y_true, y_pred) {
  # Derivative of MSE loss w.r.t. y_pred
  # Normalize by batch size (number of samples)
  return(2 * (y_pred - y_true) / nrow(y_true))
}

source("neuralnets/losses/mse.R")

source("neuralnets/losses/mse.R")

library(R6)

SGD <- R6Class("SGD",
  public = list(
    learning_rate = NULL,
    
    initialize = function(learning_rate = 0.01) {
      self$learning_rate <- learning_rate
    },
    
    update = function(layer) {
      # Update layer's weights and biases using its stored gradients
      # Check if the layer has trainable parameters and gradients
      if (!is.null(layer$weights) && !is.null(layer$biases) && 
          !is.null(layer$d_weights) && !is.null(layer$d_biases)) {
        
        layer$weights <- layer$weights - self$learning_rate * layer$d_weights
        layer$biases <- layer$biases - self$learning_rate * layer$d_biases
      }
    }
  )
)

source("neuralnets/optimizers/sgd.R")

source("neuralnets/layers/init.R")
source("neuralnets/activations/init.R")
source("neuralnets/losses/init.R")
source("neuralnets/optimizers/init.R")

# Make key components available at package level for easy access
# This creates a clean API similar to Python's __init__.py imports

source("neuralnets/layers/init.R")
source("neuralnets/activations/init.R")
source("neuralnets/losses/init.R")
source("neuralnets/optimizers/init.R")

# Make key components available at package level for easy access
# This creates a clean API similar to Python's __init__.py imports

source("neuralnets/init.R")
library(R6)

# MLP class
MLP <- R6Class("MLP",
  public = list(
    layers = NULL,
    
    initialize = function() {
      self$layers <- list()
    },
    
    add_layer = function(layer) {
      self$layers[[length(self$layers) + 1]] <- layer
    },
    
    forward = function(inputs) {
      current_input <- inputs
      for (layer in self$layers) {
        current_input <- layer$forward(current_input)
      }
      return(current_input)
    },
    
    backward = function(d_loss_wrt_prediction) {
      current_d_loss <- d_loss_wrt_prediction
      for (i in length(self$layers):1) {
        current_d_loss <- self$layers[[i]]$backward(current_d_loss)
      }
    }
  )
)

# Sample data: XOR problem
X_train <- matrix(c(0,0, 0,1, 1,0, 1,1), nrow=4, ncol=2, byrow=TRUE)
y_train <- matrix(c(0, 1, 1, 0), nrow=4, ncol=1)

# Build MLP using modular DenseLayer
mlp <- MLP$new()
mlp$add_layer(DenseLayer$new(n_inputs=2, n_neurons=4, activation_fn_name='relu', weight_init_scale=0.1))
mlp$add_layer(DenseLayer$new(n_inputs=4, n_neurons=1, activation_fn_name='sigmoid', weight_init_scale=0.1))

# Use modular Optimizer and Loss
# Note: learning_rate=0.5 is unusually high - typically we use much smaller
# values like 0.01 or 0.001. However, 0.5 works well for the simple XOR problem
# due to its small scale and clean separability.
optimizer <- SGD$new(learning_rate=0.5)

epochs <- 1000
cat(sprintf("Training MLP for XOR problem for %d epochs with LR=%.1f\n", epochs, optimizer$learning_rate))

for (epoch in 1:epochs) {
  # 1. Forward pass
  y_pred <- mlp$forward(X_train)
  # 2. Calculate loss
  loss <- mse_loss(y_train, y_pred)
  # 3. Calculate derivative of loss
  d_loss_wrt_pred <- mse_loss_derivative(y_train, y_pred)
  # 4. Backward pass
  mlp$backward(d_loss_wrt_pred)
  # 5. Update weights
  for (layer in mlp$layers) {
    optimizer$update(layer)
  }
  
  if (epoch %% 200 == 0 || epoch == 1) {
    cat(sprintf("Epoch %4d/%d, Loss: %.6f\n", epoch, epochs, loss))
  }
}

cat("\n--- After Training ---\n")
final_preds <- mlp$forward(X_train)
cat("Input  | True Output | Predicted Output | Rounded Prediction\n")
for (i in 1:nrow(X_train)) {
  pred_val <- final_preds[i, 1]
  rounded_pred <- round(pred_val)
  cat(sprintf("[%d %d] | %11d | %16.4f | %18.0f\n", 
      X_train[i, 1], X_train[i, 2], y_train[i, 1], pred_val, rounded_pred))
}

neuralnets/
├── init.R                 # Main package initialization
├── main.R                 # Training pipeline example
├── layers/
│   ├── init.R            # Layers module initialization
│   └── dense.R           # Dense layer implementation
├── activations/
│   ├── init.R            # Activations module initialization
│   └── functions.R       # Activation functions
├── losses/
│   ├── init.R            # Loss functions initialization
│   └── mse.R             # MSE loss implementation
└── optimizers/
    ├── init.R            # Optimizers initialization
    └── sgd.R             # SGD optimizer implementation

neuralnets/
├── init.R                 # Main package initialization
├── main.R                 # Training pipeline example
├── layers/
│   ├── init.R            # Layers module initialization
│   └── dense.R           # Dense layer implementation
├── activations/
│   ├── init.R            # Activations module initialization
│   └── functions.R       # Activation functions
├── losses/
│   ├── init.R            # Loss functions initialization
│   └── mse.R             # MSE loss implementation
└── optimizers/
    ├── init.R            # Optimizers initialization
    └── sgd.R             # SGD optimizer implementation

text

Training MLP for XOR problem for 1000 epochs with LR=0.5
Epoch    1/1000, Loss: 0.250048
Epoch  200/1000, Loss: 0.036447
Epoch  400/1000, Loss: 0.006105
Epoch  600/1000, Loss: 0.002965
Epoch  800/1000, Loss: 0.001892
Epoch 1000/1000, Loss: 0.001377

--- After Training ---
Input  | True Output | Predicted Output | Rounded Prediction
[0 0] |           0 |           0.0580 |                  0
[0 1] |           1 |           0.9745 |                  1
[1 0] |           1 |           0.9748 |                  1
[1 1] |           0 |           0.0291 |                  0

Training MLP for XOR problem for 1000 epochs with LR=0.5
Epoch    1/1000, Loss: 0.250048
Epoch  200/1000, Loss: 0.036447
Epoch  400/1000, Loss: 0.006105
Epoch  600/1000, Loss: 0.002965
Epoch  800/1000, Loss: 0.001892
Epoch 1000/1000, Loss: 0.001377

--- After Training ---
Input  | True Output | Predicted Output | Rounded Prediction
[0 0] |           0 |           0.0580 |                  0
[0 1] |           1 |           0.9745 |                  1
[1 0] |           1 |           0.9748 |                  1
[1 1] |           0 |           0.0291 |                  0

mse_loss <- function(y_true, y_pred) {
  # Calculate Mean Squared Error loss
  return(mean((y_true - y_pred)^2))
}

mse_loss_derivative <- function(y_true, y_pred) {
  # Derivative of MSE loss w.r.t. y_pred
  # Normalize by batch size (number of samples)
  return(2 * (y_pred - y_true) / nrow(y_true))
}

source("neuralnets/losses/mse.R")

library(R6)

SGD <- R6Class("SGD",
  public = list(
    learning_rate = NULL,
    
    initialize = function(learning_rate = 0.01) {
      self$learning_rate <- learning_rate
    },
    
    update = function(layer) {
      # Update layer's weights and biases using its stored gradients
      # Check if the layer has trainable parameters and gradients
      if (!is.null(layer$weights) && !is.null(layer$biases) && 
          !is.null(layer$d_weights) && !is.null(layer$d_biases)) {
        
        layer$weights <- layer$weights - self$learning_rate * layer$d_weights
        layer$biases <- layer$biases - self$learning_rate * layer$d_biases
      }
    }
  )
)

source("neuralnets/optimizers/sgd.R")

source("neuralnets/layers/init.R")
source("neuralnets/activations/init.R")
source("neuralnets/losses/init.R")
source("neuralnets/optimizers/init.R")

# Make key components available at package level for easy access
# This creates a clean API similar to Python's __init__.py imports

source("neuralnets/init.R")
library(R6)

# MLP class
MLP <- R6Class("MLP",
  public = list(
    layers = NULL,
    
    initialize = function() {
      self$layers <- list()
    },
    
    add_layer = function(layer) {
      self$layers[[length(self$layers) + 1]] <- layer
    },
    
    forward = function(inputs) {
      current_input <- inputs
      for (layer in self$layers) {
        current_input <- layer$forward(current_input)
      }
      return(current_input)
    },
    
    backward = function(d_loss_wrt_prediction) {
      current_d_loss <- d_loss_wrt_prediction
      for (i in length(self$layers):1) {
        current_d_loss <- self$layers[[i]]$backward(current_d_loss)
      }
    }
  )
)

# Sample data: XOR problem
X_train <- matrix(c(0,0, 0,1, 1,0, 1,1), nrow=4, ncol=2, byrow=TRUE)
y_train <- matrix(c(0, 1, 1, 0), nrow=4, ncol=1)

# Build MLP using modular DenseLayer
mlp <- MLP$new()
mlp$add_layer(DenseLayer$new(n_inputs=2, n_neurons=4, activation_fn_name='relu', weight_init_scale=0.1))
mlp$add_layer(DenseLayer$new(n_inputs=4, n_neurons=1, activation_fn_name='sigmoid', weight_init_scale=0.1))

# Use modular Optimizer and Loss
# Note: learning_rate=0.5 is unusually high - typically we use much smaller
# values like 0.01 or 0.001. However, 0.5 works well for the simple XOR problem
# due to its small scale and clean separability.
optimizer <- SGD$new(learning_rate=0.5)

epochs <- 1000
cat(sprintf("Training MLP for XOR problem for %d epochs with LR=%.1f\n", epochs, optimizer$learning_rate))

for (epoch in 1:epochs) {
  # 1. Forward pass
  y_pred <- mlp$forward(X_train)
  # 2. Calculate loss
  loss <- mse_loss(y_train, y_pred)
  # 3. Calculate derivative of loss
  d_loss_wrt_pred <- mse_loss_derivative(y_train, y_pred)
  # 4. Backward pass
  mlp$backward(d_loss_wrt_pred)
  # 5. Update weights
  for (layer in mlp$layers) {
    optimizer$update(layer)
  }
  
  if (epoch %% 200 == 0 || epoch == 1) {
    cat(sprintf("Epoch %4d/%d, Loss: %.6f\n", epoch, epochs, loss))
  }
}

cat("\n--- After Training ---\n")
final_preds <- mlp$forward(X_train)
cat("Input  | True Output | Predicted Output | Rounded Prediction\n")
for (i in 1:nrow(X_train)) {
  pred_val <- final_preds[i, 1]
  rounded_pred <- round(pred_val)
  cat(sprintf("[%d %d] | %11d | %16.4f | %18.0f\n", 
      X_train[i, 1], X_train[i, 2], y_train[i, 1], pred_val, rounded_pred))
}

source("neuralnets/init.R")
library(R6)

# MLP class
MLP <- R6Class("MLP",
  public = list(
    layers = NULL,
    
    initialize = function() {
      self$layers <- list()
    },
    
    add_layer = function(layer) {
      self$layers[[length(self$layers) + 1]] <- layer
    },
    
    forward = function(inputs) {
      current_input <- inputs
      for (layer in self$layers) {
        current_input <- layer$forward(current_input)
      }
      return(current_input)
    },
    
    backward = function(d_loss_wrt_prediction) {
      current_d_loss <- d_loss_wrt_prediction
      for (i in length(self$layers):1) {
        current_d_loss <- self$layers[[i]]$backward(current_d_loss)
      }
    }
  )
)

# Sample data: XOR problem
X_train <- matrix(c(0,0, 0,1, 1,0, 1,1), nrow=4, ncol=2, byrow=TRUE)
y_train <- matrix(c(0, 1, 1, 0), nrow=4, ncol=1)

# Build MLP using modular DenseLayer
mlp <- MLP$new()
mlp$add_layer(DenseLayer$new(n_inputs=2, n_neurons=4, activation_fn_name='relu', weight_init_scale=0.1))
mlp$add_layer(DenseLayer$new(n_inputs=4, n_neurons=1, activation_fn_name='sigmoid', weight_init_scale=0.1))

# Use modular Optimizer and Loss
# Note: learning_rate=0.5 is unusually high - typically we use much smaller
# values like 0.01 or 0.001. However, 0.5 works well for the simple XOR problem
# due to its small scale and clean separability.
optimizer <- SGD$new(learning_rate=0.5)

epochs <- 1000
cat(sprintf("Training MLP for XOR problem for %d epochs with LR=%.1f\n", epochs, optimizer$learning_rate))

for (epoch in 1:epochs) {
  # 1. Forward pass
  y_pred <- mlp$forward(X_train)
  # 2. Calculate loss
  loss <- mse_loss(y_train, y_pred)
  # 3. Calculate derivative of loss
  d_loss_wrt_pred <- mse_loss_derivative(y_train, y_pred)
  # 4. Backward pass
  mlp$backward(d_loss_wrt_pred)
  # 5. Update weights
  for (layer in mlp$layers) {
    optimizer$update(layer)
  }
  
  if (epoch %% 200 == 0 || epoch == 1) {
    cat(sprintf("Epoch %4d/%d, Loss: %.6f\n", epoch, epochs, loss))
  }
}

cat("\n--- After Training ---\n")
final_preds <- mlp$forward(X_train)
cat("Input  | True Output | Predicted Output | Rounded Prediction\n")
for (i in 1:nrow(X_train)) {
  pred_val <- final_preds[i, 1]
  rounded_pred <- round(pred_val)
  cat(sprintf("[%d %d] | %11d | %16.4f | %18.0f\n", 
      X_train[i, 1], X_train[i, 2], y_train[i, 1], pred_val, rounded_pred))
}

neuralnets/
├── init.R                 # Main package initialization
├── main.R                 # Training pipeline example
├── layers/
│   ├── init.R            # Layers module initialization
│   └── dense.R           # Dense layer implementation
├── activations/
│   ├── init.R            # Activations module initialization
│   └── functions.R       # Activation functions
├── losses/
│   ├── init.R            # Loss functions initialization
│   └── mse.R             # MSE loss implementation
└── optimizers/
    ├── init.R            # Optimizers initialization
    └── sgd.R             # SGD optimizer implementation

text

Training MLP for XOR problem for 1000 epochs with LR=0.5
Epoch    1/1000, Loss: 0.250048
Epoch  200/1000, Loss: 0.036447
Epoch  400/1000, Loss: 0.006105
Epoch  600/1000, Loss: 0.002965
Epoch  800/1000, Loss: 0.001892
Epoch 1000/1000, Loss: 0.001377

--- After Training ---
Input  | True Output | Predicted Output | Rounded Prediction
[0 0] |           0 |           0.0580 |                  0
[0 1] |           1 |           0.9745 |                  1
[1 0] |           1 |           0.9748 |                  1
[1 1] |           0 |           0.0291 |                  0

source("neuralnets/init.R")
library(R6)

# MLP class
MLP <- R6Class("MLP",
  public = list(
    layers = NULL,
    
    initialize = function() {
      self$layers <- list()
    },
    
    add_layer = function(layer) {
      self$layers[[length(self$layers) + 1]] <- layer
    },
    
    forward = function(inputs) {
      current_input <- inputs
      for (layer in self$layers) {
        current_input <- layer$forward(current_input)
      }
      return(current_input)
    },
    
    backward = function(d_loss_wrt_prediction) {
      current_d_loss <- d_loss_wrt_prediction
      for (i in length(self$layers):1) {
        current_d_loss <- self$layers[[i]]$backward(current_d_loss)
      }
    }
  )
)

# Sample data: XOR problem
X_train <- matrix(c(0,0, 0,1, 1,0, 1,1), nrow=4, ncol=2, byrow=TRUE)
y_train <- matrix(c(0, 1, 1, 0), nrow=4, ncol=1)

# Build MLP using modular DenseLayer
mlp <- MLP$new()
mlp$add_layer(DenseLayer$new(n_inputs=2, n_neurons=4, activation_fn_name='relu', weight_init_scale=0.1))
mlp$add_layer(DenseLayer$new(n_inputs=4, n_neurons=1, activation_fn_name='sigmoid', weight_init_scale=0.1))

# Use modular Optimizer and Loss
# Note: learning_rate=0.5 is unusually high - typically we use much smaller
# values like 0.01 or 0.001. However, 0.5 works well for the simple XOR problem
# due to its small scale and clean separability.
optimizer <- SGD$new(learning_rate=0.5)

epochs <- 1000
cat(sprintf("Training MLP for XOR problem for %d epochs with LR=%.1f\n", epochs, optimizer$learning_rate))

for (epoch in 1:epochs) {
  # 1. Forward pass
  y_pred <- mlp$forward(X_train)
  # 2. Calculate loss
  loss <- mse_loss(y_train, y_pred)
  # 3. Calculate derivative of loss
  d_loss_wrt_pred <- mse_loss_derivative(y_train, y_pred)
  # 4. Backward pass
  mlp$backward(d_loss_wrt_pred)
  # 5. Update weights
  for (layer in mlp$layers) {
    optimizer$update(layer)
  }
  
  if (epoch %% 200 == 0 || epoch == 1) {
    cat(sprintf("Epoch %4d/%d, Loss: %.6f\n", epoch, epochs, loss))
  }
}

cat("\n--- After Training ---\n")
final_preds <- mlp$forward(X_train)
cat("Input  | True Output | Predicted Output | Rounded Prediction\n")
for (i in 1:nrow(X_train)) {
  pred_val <- final_preds[i, 1]
  rounded_pred <- round(pred_val)
  cat(sprintf("[%d %d] | %11d | %16.4f | %18.0f\n", 
      X_train[i, 1], X_train[i, 2], y_train[i, 1], pred_val, rounded_pred))
}

Introduction

Our Test Dataset: The XOR Problem

Join the 1M+ learners on CodeSignal

Creating the Loss Functions Module

Creating the Optimizers Module

Package Initialization System

Building a Complete Training Pipeline

Understanding Our Modular Architecture

Analyzing the Training Results

Conclusion and Next Steps