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

Creating the Loss Functions Module

Let's start by organizing our loss functions into dedicated functions within our neuralnets package structure. We'll create MSE loss functions that are cleanly organized and easily importable. The key insight here is separating the mathematical operations from the training logic, creating a clean interface that makes our code more testable and allows us to easily add other loss functions in the future. neuralnets/losses/mse.R: Rmse_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)) } To make these functions available throughout our package, we create an initialization file that sources our loss functions: neuralnets/losses/init.R: Rsource("neuralnets/losses/mse.R")source("neuralnets/losses/mse.R")

Creating the Optimizers Module

Similarly, let's organize our optimization algorithm into its own R6 class. We'll implement our SGD optimizer as a class that encapsulates both the learning rate parameter and the update logic, following the same R6 patterns we established in our previous lesson. The key benefit of this modular approach is that we encapsulate the optimization logic in a reusable class with a clean interface. The update method applies the sgd update rule to any layer that has trainable parameters, making our optimizer robust and flexible. neuralnets/optimizers/sgd.R: Rlibrary(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 } } ) ) We also need to create an initialization file for our optimizers: neuralnets/optimizers/init.R: Rsource("neuralnets/optimizers/sgd.R")

Package Initialization System

To tie all our modular components together, we create a main initialization file that loads all our modules. This creates a clean API similar to Python's__init__.py imports, making our components easily accessible throughout the package. neuralnets/init.R : 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

Building a Complete Training Pipeline

Now comes the exciting part — putting all our modular components together into a complete training pipeline! This demonstrates the power of our modular design: clean imports, specific component usage, and a readable training setup that clearly separates concerns. Our training pipeline combines the MLP class from our previous lesson with our newly modularized loss functions and optimizers. Notice how each component has a specific responsibility: the network handles forward and backward propagation, the loss functions compute objectives and gradients, and the optimizer updates weights. We're using a learning rate of 0.5, which is quite high compared to typical values (like 0.01 or 0.001) — this aggressive learning rate works for the simple xor problem but would likely cause instability on more complex datasets. neuralnets/main.R: 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)) }

Understanding Our Modular Architecture

Our neural network library now follows a clean modular architecture: 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 This structure provides clear separation of concerns, making our code more maintainable and allowing us to easily extend functionality. Each module has a specific purpose, and the initialization system ensures all components are properly loaded and available when needed.

Analyzing the Training Results

Conclusion and Next Steps

Excellent work! We've successfully completed the next major step in building our neural network library by modularizing our training components . We've organized our loss functions and optimizers into dedicated modules with a clean directory structure, creating a separation of concerns that makes our code more maintainable, testable, and extensible. The successful training on the xor problem validates that our modular components work together seamlessly, setting us up perfectly for the next phase of development. Looking ahead, we have two exciting milestones remaining in our library-building journey: In our next lesson, we'll create a high-level Model orchestrator class that will provide an even cleaner interface for defining, training, and evaluating neural networks. After that, we'll put our completed library to the test on the california housing dataset, demonstrating its capabilities on real-world regression problems. But first, it's time to get hands-on! The upcoming practice section will give you the opportunity to extend and experiment with the modular components we've built, reinforcing your understanding through practical application.

Previous Lesson

Next Lesson: Model Orchestration in R

Join the 1M+ learners on CodeSignal

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

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

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