Throughout this course, we've discussed various components of neural networks: layers, activation functions, loss functions, optimizers, and now, regularization techniques. When building and training these models, we distinguish between two types of settings:

Parameters: These are the values the model learns during training. Primarily, this includes the weights and biases within the network's layers. Their values are iteratively adjusted via backpropagation and gradient descent to minimize the loss function.
Hyperparameters: These are configuration settings specified before the training process begins. They are not learned from the data directly but instead define the higher-level structure of the model or control the learning process itself.

Think of parameters as the internal knowledge the model acquires, while hyperparameters are the external choices you make about how the model should be built and how it should learn.

Getting these hyperparameter choices right is significant for model performance. Just as regularization helps prevent overfitting, selecting appropriate hyperparameters influences:

Model Capacity: How complex a function can the model learn? (e.g., number of layers, number of neurons per layer).
Training Speed and Convergence: How quickly and reliably does the model learn? (e.g., learning rate, optimizer choice, batch size).
Generalization: How well does the model perform on unseen data? (e.g., regularization strength, dropout rate).

Poor hyperparameter choices can lead to models that train too slowly, get stuck in suboptimal solutions, overfit drastically, or fail to learn effectively at all.

Common Hyperparameters to Tune

Based on the concepts we've covered, here are some of the most common hyperparameters you'll encounter and need to consider tuning:

Learning Rate: Perhaps the most impactful hyperparameter. It controls the step size during gradient descent. Too high, and the training might diverge; too low, and it might take too long or get stuck in a poor local minimum. (Covered in Chapter 3)
Number of Hidden Layers: Determines the depth of the network. Deeper networks can potentially model more complex functions but are harder to train and prone to overfitting. (Covered in Chapter 2 & 5)
Number of Neurons per Hidden Layer: Controls the width of the network layers and thus the representational capacity at each stage. (Covered in Chapter 2 & 5)
Activation Functions: While often chosen based on layer type (e.g., ReLU for hidden, Sigmoid/Softmax for output), sometimes alternatives (Leaky ReLU, Tanh) might be considered hyperparameters. (Covered in Chapter 2)
Optimizer: The algorithm used for gradient descent (e.g., SGD, Adam, RMSprop). Different optimizers have different convergence properties and sensitivities to other hyperparameters like the learning rate. (Covered in Chapter 4)
Batch Size: The number of samples processed before the model's weights are updated. Affects training speed, memory usage, and the stability of the gradient estimate. (Covered in Chapter 3 & 5)
Regularization Strength: For L1/L2 regularization, this is the coefficient ( $\lambda$ ) that controls the penalty on weight magnitudes. (Covered in this Chapter)
Dropout Rate: The fraction of neurons randomly set to zero during training in a dropout layer. (Covered in this Chapter)

The Challenge of Tuning

Selecting the best combination of hyperparameters is often more art than science, requiring experimentation. The challenge lies in several factors:

Large Search Space: With multiple hyperparameters, the number of possible combinations can grow exponentially.
Interdependencies: The optimal value for one hyperparameter often depends on the values of others (e.g., the best learning rate might change if you switch optimizers or change the batch size).
Computational Cost: Training a deep learning model can be time-consuming. Evaluating many different hyperparameter combinations can require significant computational resources and time.
Data Dependence: The optimal hyperparameters can vary depending on the specific dataset and task.

Here's a conceptual look at how different learning rates might affect the training loss:

A visualization showing hypothetical training loss curves over epochs for different learning rates. A good learning rate shows steady convergence, a low rate converges slowly, and a high rate can cause the loss to fluctuate wildly or diverge.

Setting these hyperparameters often happens when defining the model architecture or configuring the optimizer. For example, in PyTorch:

import torch
import torch.nn as nn
import torch.optim as optim

# Example Hyperparameters
input_size = 784
hidden_size = 128
output_size = 10
learning_rate = 0.001
dropout_prob = 0.5 # For Dropout layer

# Define model using hyperparameters
model = nn.Sequential(
    nn.Linear(input_size, hidden_size),
    nn.ReLU(),
    nn.Dropout(dropout_prob), # Using dropout rate
    nn.Linear(hidden_size, output_size)
)

# Define optimizer using hyperparameters
optimizer = optim.Adam(model.parameters(), lr=learning_rate) # Setting learning rate

print(f"Model Architecture:\n{model}")
print(f"\nOptimizer:\n{optimizer}")

Finding good hyperparameters is an essential part of achieving high performance with deep learning models. Because manual tuning through trial and error is inefficient and often ineffective, especially with many hyperparameters, more systematic approaches are needed. The next section will introduce common strategies for automating this search process.