Common Symptoms of Instability

Recognizing the early signs of training instability is fundamental for preventing wasted compute cycles and ensuring the successful development of large language models. While robust monitoring is discussed in the next section, understanding the common symptoms allows you to quickly identify when a training run is deviating from a healthy trajectory. These symptoms often manifest in the primary metrics you track during training, particularly the loss function and gradient statistics.

NaN Loss

Perhaps the most definitive sign of catastrophic failure is the appearance of NaN (Not a Number) values in your loss calculation.

$$\text{Loss} = \text{NaN}$$

A NaN loss typically halts the training process immediately, as subsequent gradient calculations and weight updates become mathematically undefined. This usually signifies a severe numerical issue, such as:

1. Numerical Overflow: Operations resulting in numbers larger than the maximum representable value for the current floating-point format (e.g., FP16, BF16, or even FP32 under extreme conditions). This can happen during matrix multiplications or within activation functions.
2. Numerical Underflow: Operations resulting in numbers smaller (closer to zero) than the minimum representable positive value. While less likely to directly cause NaNs, underflow in intermediate steps can sometimes lead to problematic scenarios like division by zero.
3. Invalid Operations: Mathematical operations like taking the logarithm of zero or a negative number (log(0)), calculating the square root of a negative number, or dividing by zero. These can occur due to specific data points or unstable intermediate activation values.

Detecting NaNs early in the training loop is important. You can add checks directly after the loss computation.

# Inside the training loop (PyTorch example)
outputs = model(inputs)
loss = loss_function(outputs, targets)

# Check for NaN or infinity in the loss
if not torch.isfinite(loss):
    print(f"Unstable loss detected: {loss.item()}. Stopping training.")
    # Add logic here to save state, log details, and terminate
    break

# Proceed with backward pass only if loss is valid
loss.backward()
# ... optimizer step, etc.

Loss Spikes

Less immediately fatal than NaN loss, but still a serious warning sign, are sudden, sharp increases in the loss value, often referred to as "loss spikes." The loss might recover partially or fully in subsequent steps, or the spike might precede complete divergence.

A typical loss curve showing a sudden spike around iteration 500 before partially recovering.

Loss spikes can be triggered by several factors:

1. Problematic Data Batch: A single batch containing corrupted data, outliers, or examples that are significantly different from the rest of the dataset can cause the model to produce highly incorrect predictions, leading to a large loss value for that step.
2. Learning Rate: An overly aggressive learning rate can cause the optimizer to overshoot optima, leading to temporary instability.
3. Gradient Issues: Even without becoming NaN, gradients might momentarily explode, causing large, destabilizing weight updates. This is particularly relevant when using adaptive optimizers like Adam.

While a single, isolated spike might not derail training entirely, frequent spikes indicate underlying instability that needs addressing.

Diverging Loss

Unlike a temporary spike, diverging loss refers to a consistent upward trend in the loss value over multiple iterations or epochs. This indicates that the model's performance is continuously degrading, and the optimization process is moving away from, rather than towards, a good solution.

Comparison of a healthy, converging loss curve and a diverging loss curve indicating training failure.

Divergence often points to more fundamental issues:

1. Learning Rate Too High: The most common cause. The optimizer consistently overshoots minima.
2. Gradient Problems: Persistent issues with gradient calculation or scaling.
3. Initialization: Poor weight initialization might place the model in a region of the loss landscape where gradients consistently point "uphill."
4. Architectural Flaws: Incorrect implementation of model components or normalization layers.
5. Data Issues: Systematic problems within the training dataset.

Oscillating Loss or Metrics

Another symptom is when the loss value, or other evaluation metrics like perplexity or accuracy on a validation set, fluctuates significantly without showing a clear trend of improvement. The values might bounce up and down between steps or epochs, never settling into a stable decrease (for loss) or increase (for accuracy).

This oscillation often suggests:

1. High Learning Rate: The learning rate might be too high, causing the optimizer to repeatedly jump across a valley in the loss landscape instead of settling at the bottom.
2. Batch-to-Batch Variation: High variance in the composition or difficulty of data batches can cause performance metrics to fluctuate.
3. Inadequate Regularization: Lack of proper regularization might allow the model to fit noise in individual batches, leading to unstable performance.

Underlying Gradient Issues: Explosion and Vanishing

While not always directly visible as primary symptoms like NaN loss or spikes, extreme gradient magnitudes are often the root cause.

• Gradient Explosion: Occurs when the magnitude of the gradients ($||\nabla L||$) becomes excessively large. This leads to large weight updates that can destabilize the network, often manifesting as NaNs or loss spikes. Monitoring the gradient norm is essential for detecting this.
• Gradient Vanishing: Occurs when gradients become extremely small, approaching zero. This slows down or halts learning, particularly in deeper layers, as weight updates become negligible. While it primarily causes stagnation rather than sudden instability, severe vanishing in certain parts of a network could potentially contribute to numerical issues indirectly.

Recognizing these common symptoms is the important first step. The following sections will provide guidance on how to monitor training metrics effectively to catch these signs early and diagnose the underlying causes of instability.