Early on in my deep learning journey, I confused “parameters” and “hyperparameters” more times than I’d like to admit. It’s an easy mix-up, but the distinction is fundamental to understanding how neural networks are actually built and trained. Parameters are what the model learns; hyperparameters are what you, the practitioner, decide before training even begins. Getting hyperparameters right is often the difference between a model that trains beautifully and one that never converges at all.
This article covers what hyperparameters are, how they differ from parameters, the major categories of hyperparameters you’ll encounter, and practical strategies for tuning them effectively.
Parameters vs. Hyperparameters
Parameters are internal variables that a model learns automatically from data during training — the weights and biases of a neural network. They’re updated via backpropagation and gradient descent.
Hyperparameters are configuration settings defined before training begins. They are not learned from data directly; instead, they control how the learning process itself unfolds. Examples include the learning rate, the number of layers, the batch size, and the choice of optimizer.
$$ \theta_{t+1} = \theta_t – \eta \nabla_{\theta} \mathcal{L}(\theta_t) $$
In this familiar gradient descent update rule, $\theta$ (the weights) are parameters learned during training, while $\eta$ (the learning rate) is a hyperparameter chosen beforehand.
Why Hyperparameters Matter So Much
Two identical network architectures, trained with different hyperparameters, can produce wildly different results — one might converge to a high-performing model in a few hours, while the other diverges entirely or trains so slowly it never finishes in a reasonable time frame. Hyperparameters essentially define the “rules of the game” for the optimization process, and choosing them well is often as important as the architecture itself.
Categories of Hyperparameters
1. Model Architecture Hyperparameters
These define the structure of the neural network itself:
- Number of layers (depth): More layers generally allow the model to learn more abstract, hierarchical representations, but also increase the risk of vanishing/exploding gradients and overfitting.
- Number of neurons per layer (width): Wider layers increase representational capacity but also increase computational cost and overfitting risk.
- Activation functions: ReLU, sigmoid, tanh, GELU, and others determine how nonlinearity is introduced into the network.
- Type of layers: Convolutional, recurrent, attention-based (transformer), or fully connected, depending on the data structure.
2. Training Process Hyperparameters
- Learning rate ($\eta$): Controls the step size during weight updates (see the dedicated learning rate article for full detail).
- Batch size: The number of training examples processed before a weight update. Smaller batches introduce more gradient noise (which can help escape poor minima) but produce noisier training curves; larger batches provide more stable gradient estimates but require more memory and can generalize slightly worse in some cases.
- Number of epochs: How many times the entire training dataset is passed through the network.
- Optimizer choice: SGD, SGD with momentum, Adam, RMSprop, AdamW, and others each have different convergence properties.
3. Regularization Hyperparameters
- Dropout rate ($p$): The fraction of neurons randomly deactivated during training.
- L1/L2 regularization strength ($\lambda$): Controls how strongly the loss function penalizes large weights.
- Early stopping patience: How many epochs without validation improvement to tolerate before halting training.
4. Optimizer-Specific Hyperparameters
For Adam, for example:
$$ m_t = \beta_1 m_{t-1} + (1-\beta_1)g_t, \quad v_t = \beta_2 v_{t-1} + (1-\beta_2)g_t^2 $$
Here, $\beta_1$ and $\beta_2$ (typically 0.9 and 0.999) are hyperparameters controlling the exponential decay rates of the moving averages of the gradient and squared gradient.
5. Data-Related Hyperparameters
- Data augmentation intensity: How aggressively to transform training images or text.
- Train/validation/test split ratios.
- Sequence length (for text or time series models).
Diagram: Where Hyperparameters Fit in the Training Pipeline
flowchart TD
A[Choose Hyperparameters: LR, Batch Size, Architecture, Regularization] --> B[Initialize Model Parameters/Weights]
B --> C[Train Model on Training Data]
C --> D[Evaluate on Validation Set]
D --> E{Performance Satisfactory?}
E -->|No| F[Adjust Hyperparameters]
F --> A
E -->|Yes| G[Final Evaluation on Test Set]
Hyperparameter Tuning Strategies
Manual Search
Practitioners adjust hyperparameters based on experience and intuition, observing training curves after each change. This works reasonably well for experienced practitioners but doesn’t scale to large hyperparameter spaces.
Grid Search
Grid search exhaustively evaluates all combinations of a predefined set of hyperparameter values.
learning_rates = [1e-2, 1e-3, 1e-4]
batch_sizes = [32, 64, 128]
best_score = float('-inf')
best_params = None
for lr in learning_rates:
for bs in batch_sizes:
score = train_and_evaluate(lr=lr, batch_size=bs)
if score > best_score:
best_score = score
best_params = (lr, bs)
print(f"Best hyperparameters: LR={best_params[0]}, Batch Size={best_params[1]}")
Grid search is simple but scales exponentially with the number of hyperparameters, making it impractical for high-dimensional search spaces.
Random Search
Rather than trying every combination, random search samples hyperparameter combinations randomly from specified distributions. Research by Bergstra and Bengio (2012) showed that random search often outperforms grid search for the same computational budget, since it explores each hyperparameter’s range more effectively.
Bayesian Optimization
Bayesian optimization builds a probabilistic model (often a Gaussian process) of the objective function and uses it to intelligently select the next set of hyperparameters to try, balancing exploration (trying uncertain regions) and exploitation (refining promising regions).
# Example using the Optuna library
import optuna
def objective(trial):
lr = trial.suggest_float('lr', 1e-5, 1e-1, log=True)
batch_size = trial.suggest_categorical('batch_size', [16, 32, 64, 128])
dropout = trial.suggest_float('dropout', 0.0, 0.5)
score = train_and_evaluate(lr=lr, batch_size=batch_size, dropout=dropout)
return score
study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=50)
print(f"Best hyperparameters: {study.best_params}")
Population-Based Training and Hyperband
More advanced methods like Hyperband and population-based training dynamically allocate compute resources to promising hyperparameter configurations while pruning poorly performing ones early, dramatically speeding up the search process compared to naive grid or random search.
Comparison Table: Hyperparameter Tuning Methods
| Method | Search Efficiency | Scalability | Ease of Implementation | Best For |
|---|---|---|---|---|
| Manual search | Low | Poor | Easy | Small experiments, quick iteration |
| Grid search | Low-moderate | Poor (exponential) | Easy | Few hyperparameters |
| Random search | Moderate | Good | Easy | Moderate-dimensional spaces |
| Bayesian optimization | High | Good | Moderate | Expensive-to-train models |
| Hyperband/PBT | High | Excellent | Complex | Large-scale, resource-constrained tuning |
Advantages of Systematic Hyperparameter Tuning
- Removes guesswork from the model development process.
- Often yields meaningfully better performance than default or intuition-based settings.
- Automated approaches (Bayesian optimization, Hyperband) can discover non-obvious hyperparameter interactions that manual tuning would likely miss.
Disadvantages and Limitations
- Hyperparameter search is computationally expensive, particularly for large models where a single training run can take days.
- There’s a risk of overfitting to the validation set if tuning is too aggressive or repeated too many times without proper cross-validation.
- Some hyperparameters interact in complex, non-linear ways, making independent tuning (one at a time) potentially misleading.
Real-World Use Cases
- Large-scale model pretraining (e.g., large language models) relies on carefully tuned hyperparameter schedules derived from scaling laws, since a full grid search at that scale would be prohibitively expensive.
- AutoML platforms (like Google’s Vertex AI or AWS SageMaker Autopilot) automate hyperparameter tuning as a core feature, often using Bayesian optimization or evolutionary strategies under the hood.
- Kaggle competitions frequently see top performers using tools like Optuna to fine-tune gradient boosting or deep learning hyperparameters for marginal but competition-winning performance gains.
Best Practices
- Start with well-established default hyperparameters from similar published work before doing extensive tuning from scratch.
- Prioritize tuning the learning rate and batch size first, since these tend to have the largest impact on training dynamics.
- Use random search or Bayesian optimization over grid search whenever the hyperparameter space has more than two or three dimensions.
- Always tune hyperparameters using a validation set, never the test set, and use cross-validation for small datasets to avoid unreliable single-split estimates.
- Log all hyperparameter configurations and results systematically (tools like Weights & Biases or MLflow are popular for this) to avoid redundant experiments and to build intuition over time.
Summary
Hyperparameters are the configuration choices set before training begins that govern how a neural network learns — spanning architecture (layers, width, activation functions), training process (learning rate, batch size, epochs, optimizer), regularization (dropout, weight decay), and data handling. Unlike parameters, they are not learned automatically and must be chosen or tuned through strategies ranging from manual experimentation to grid search, random search, and increasingly sophisticated Bayesian and population-based methods. Thoughtful hyperparameter tuning is often what separates a mediocre model from a state-of-the-art one.
References
- Bergstra, J., & Bengio, Y. (2012). “Random Search for Hyper-Parameter Optimization.” Journal of Machine Learning Research. https://jmlr.org/papers/v13/bergstra12a.html
- Akiba, T., et al. (2019). “Optuna: A Next-generation Hyperparameter Optimization Framework.” https://arxiv.org/abs/1907.10902
- Goodfellow, I., Bengio, Y., & Courville, A. Deep Learning. MIT Press. https://www.deeplearningbook.org/
- Li, L., et al. (2018). “Hyperband: A Novel Bandit-Based Approach to Hyperparameter Optimization.” https://arxiv.org/abs/1603.06560
