Training autoencoders, especially the more complex architectures discussed previously or those with intricate loss functions like the Evidence Lower Bound (ELBO) in VAEs, involves minimizing a potentially high-dimensional, non-convex loss function, $L$ . While basic Stochastic Gradient Descent (SGD) provides a foundation, its convergence can be slow, prone to getting stuck in suboptimal local minima or saddle points, and highly sensitive to the choice of learning rate. To effectively train deep autoencoder models and find meaningful representations, we often turn to more sophisticated optimization algorithms that adapt the learning process.

These advanced optimizers aim to navigate the loss landscape more intelligently, accelerating convergence and improving the quality of the final model. They typically achieve this by incorporating information beyond the current gradient, such as past gradients or their magnitudes.

Building on Gradient Descent: Momentum

Standard SGD updates parameters solely based on the gradient calculated for the current mini-batch. This can lead to noisy updates and oscillations, particularly in areas where the loss surface curves steeply in one direction but gently in another (common in deep networks).

Momentum addresses this by adding a fraction of the previous update vector to the current one. Think of it like a ball rolling down a hill: it accumulates momentum, smoothing out the path and speeding up movement in consistent directions while dampening oscillations across directions with rapidly changing gradients.

The update incorporates a "velocity" term, $v_t$ , which is an exponentially decaying moving average of past gradients:

$v_t = \beta v_{t-1} + (1 - \beta) \nabla_{\theta} L(\theta_t)$ $\theta_{t+1} = \theta_t - \alpha v_t$

Here, $\theta$ represents the model parameters, $\alpha$ is the learning rate, $\nabla_{\theta} L(\theta_t)$ is the gradient of the loss function $L$ with respect to parameters $\theta$ at step $t$ , and $\beta$ is the momentum coefficient (typically set around 0.9). This allows the optimizer to "remember" past gradient directions and continue moving in those directions even if the current gradient is small or noisy.

Adaptive Learning Rates: AdaGrad, RMSprop, Adam

A fixed learning rate $\alpha$ poses challenges. If it's too small, training is slow. If it's too large, the optimizer might overshoot minima or diverge. Adaptive learning rate algorithms adjust the learning rate during training, often on a per-parameter basis.

AdaGrad (Adaptive Gradient Algorithm)

AdaGrad adapts the learning rate for each parameter individually, performing smaller updates for parameters associated with frequently occurring features and larger updates for parameters associated with infrequent features. It achieves this by dividing the learning rate by the square root of the sum of all past squared gradients for that parameter.

While effective in some scenarios, AdaGrad's main drawback is that the accumulated sum of squared gradients in the denominator grows continuously during training. This causes the learning rate to shrink monotonically, sometimes becoming infinitesimally small before convergence is truly reached, effectively stopping learning prematurely.

RMSprop (Root Mean Square Propagation)

RMSprop modifies AdaGrad to resolve its monotonically decreasing learning rate issue. Instead of accumulating all past squared gradients, RMSprop uses an exponentially decaying average of squared gradients. This means recent gradient information is weighted more heavily, preventing the denominator from growing indefinitely and allowing the learning rate to adapt more dynamically.

The update involves maintaining a moving average of squared gradients, $E[g^2]_t$ :

$E[g^2]_t = \gamma E[g^2]_{t-1} + (1 - \gamma) (\nabla_{\theta} L(\theta_t))^2$ $\theta_{t+1} = \theta_t - \frac{\alpha}{\sqrt{E[g^2]_t + \epsilon}} \nabla_{\theta} L(\theta_t)$

Here, $\gamma$ is the decay rate (similar to $\beta$ in momentum, often around 0.9), and $\epsilon$ is a small constant for numerical stability (e.g., $10^{-8}$ ).

Adam (Adaptive Moment Estimation)

Adam is arguably one of the most popular and often default optimization algorithms used in deep learning today. It combines the ideas of both momentum (using the first moment estimate, like momentum) and adaptive learning rates (using the second moment estimate, like RMSprop).

Adam maintains two exponentially decaying moving averages:

The first moment (mean) of the gradients ( $m_t$ ), similar to momentum.
The second moment (uncentered variance) of the gradients ( $v_t$ ), similar to RMSprop.

$m_t = \beta_1 m_{t-1} + (1 - \beta_1) \nabla_{\theta} L(\theta_t)$ $v_t = \beta_2 v_{t-1} + (1 - \beta_2) (\nabla_{\theta} L(\theta_t))^2$

Since $m_t$ and $v_t$ are initialized as zeros, they are biased towards zero, especially during the initial steps. Adam performs bias correction to counteract this:

$\hat{m}_t = \frac{m_t}{1 - \beta_1^t}$ $\hat{v}_t = \frac{v_t}{1 - \beta_2^t}$

The final parameter update uses these bias-corrected estimates:

$\theta_{t+1} = \theta_t - \frac{\alpha}{\sqrt{\hat{v}_t} + \epsilon} \hat{m}_t$

Common default values are $\beta_1 = 0.9$ , $\beta_2 = 0.999$ , and $\epsilon = 10^{-8}$ . Adam often works well with minimal tuning across a wide range of problems, including training complex autoencoders.

AdamW

A refinement often seen in practice is AdamW. It modifies the standard Adam algorithm by decoupling the weight decay (L2 regularization) from the gradient update step. In standard Adam, weight decay becomes implicitly linked to the adaptive learning rates, which can sometimes lead to suboptimal regularization. AdamW applies the weight decay directly to the weights after the Adam update step, which often results in better generalization performance. Many deep learning libraries now offer AdamW as a distinct optimizer.

Conceptual illustration of how different optimizers might navigate a loss landscape. SGD can oscillate, Momentum smooths the path, and adaptive methods like Adam often converge faster and more reliably.

Choosing and Tuning Optimizers

For training autoencoders, Adam or AdamW are typically excellent starting points due to their robustness and generally good performance across various architectures and datasets. RMSprop can also be effective. While standard SGD with momentum can work, it often requires more careful tuning of the learning rate and momentum parameter.

Implementing these optimizers is straightforward in modern deep learning frameworks like TensorFlow and PyTorch:

# PyTorch Example
import torch.optim as optim

# model is your defined autoencoder architecture
# learning_rate is your chosen learning rate

# Using AdamW
optimizer = optim.AdamW(model.parameters(), lr=learning_rate, weight_decay=0.01)

# Using RMSprop
# optimizer = optim.RMSprop(model.parameters(), lr=learning_rate, alpha=0.9)

# Using SGD with Momentum
# optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=0.9)

# --- Training loop ---
# for data in dataloader:
#     inputs, _ = data
#     optimizer.zero_grad()
#     outputs, latent_vars = model(inputs) # Or however your model forward pass works
#     loss = calculate_loss(outputs, inputs, ...) # Calculate appropriate loss
#     loss.backward()
#     optimizer.step()
# ---------------------

# TensorFlow/Keras Example
import tensorflow as tf

# model is your defined Keras autoencoder model
# learning_rate is your chosen learning rate

# Using AdamW (available via tensorflow_addons or built-in in newer TF versions)
# from tensorflow.keras.optimizers import AdamW # Check TF version
# optimizer = AdamW(learning_rate=learning_rate, weight_decay=0.01)

# Using Adam (more common)
optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)

# Using RMSprop
# optimizer = tf.keras.optimizers.RMSprop(learning_rate=learning_rate, rho=0.9)

# Using SGD with Momentum
# optimizer = tf.keras.optimizers.SGD(learning_rate=learning_rate, momentum=0.9)

# model.compile(optimizer=optimizer, loss=your_loss_function)
# model.fit(x_train, x_train, epochs=num_epochs, batch_size=batch_size, ...)

While default hyperparameters for optimizers like Adam ( $\beta_1=0.9, \beta_2=0.999$ ) often work well, the learning rate ( $\alpha$ ) remains a critical hyperparameter that usually requires tuning. The effectiveness of an optimizer is also intertwined with other aspects of training, such as batch size, regularization strength, and importantly, the learning rate schedule, which we will discuss next. Selecting the right optimizer and tuning it appropriately are significant steps toward successfully training performant autoencoder models.