Michael Brenndoerfer | Data & AI, Private Equity, Technology

Michael Brenndoerfer

Emergence vs Metrics › Visualizing Smooth Capability with Discontinuous Metrics

Michael BrenndoerferNovember 8, 20253 min read

Language AI HandbookAll chapters

Part 30 of 67Emergent Capabilities

Chapter 217Emergence vs Metrics › Visualizing Smooth Capability with Discontinuous Metrics

Reading section 4 of 13 · Visualizing Smooth Capability with Discontinuous Metrics · 3 minSection 4 of 13 · 3 min

Section 4 of 13 · 3 min read

Emergence vs Metrics › Visualizing Smooth Capability with Discontinuous MetricsOne section · Sections in this chapter4 / 13 ↓

Sections in this chapter13

Reading tools Definitions & inline links

Choose your expertise level to adjust how many terms are explained. Beginners see more tooltips, experts see fewer to maintain reading flow. Hover over underlined terms for instant definitions.

Article links

Make inline references clickable

Let's create a simulation that demonstrates how smooth underlying improvements can appear as emergent transitions when measured with accuracy. This visualization will make the abstract mathematics concrete by showing exactly how the same underlying capability trajectory produces different apparent patterns depending on our choice of metric.

In[7]:

Code

import numpy as np


# Simulate a model capability that improves smoothly with scale
def smooth_capability(
    log_compute: np.ndarray,
    start: float = 0.7,
    end: float = 0.98,
    midpoint: float = 22,
) -> np.ndarray:
    """
    Simulate smooth per-token capability improvement.
    Uses a sigmoid to model gradual saturation.
    """
    # Linear improvement in logit space (common for neural networks)
    slope = 0.5
    logits = slope * (log_compute - midpoint)
    capability = start + (end - start) / (1 + np.exp(-logits))
    return capability


def accuracy_from_capability(
    capability: np.ndarray, sequence_length: int
) -> np.ndarray:
    """Convert per-token capability to sequence accuracy."""
    return capability**sequence_length


# Generate data across model scales
log_compute = np.linspace(18, 26, 100)  # ~10^18 to 10^26 FLOPs
per_token_cap = smooth_capability(log_compute)

# Calculate accuracy for different sequence lengths
acc_short = accuracy_from_capability(per_token_cap, 5)
acc_medium = accuracy_from_capability(per_token_cap, 20)
acc_long = accuracy_from_capability(per_token_cap, 50)

Out[8]:

Visualization

Line plot showing smooth sigmoid improvement in per-token accuracy as training compute increases. — Smooth sigmoid improvement in per-token probability as training compute increases from 10^18 to 10^26 FLOPs. The underlying capability develops gradually without abrupt transitions.

Line plot showing increasingly sharp S-curve transitions in sequence accuracy for longer sequences. — Sequence accuracy curves for different output lengths, showing increasingly sharp S-curve transitions. Tasks requiring longer outputs (50 tokens) exhibit dramatic emergence around 10^24 FLOPs, while shorter sequences (5 tokens) show more gradual improvement.

The left panel shows smooth, gradual improvement in the model's underlying capability. The right panel shows how this same improvement appears when measured by accuracy on sequences of different lengths. The 50-token task appears to "emerge" suddenly around $10^{24}$ FLOPs, while the 5-token task shows more gradual improvement. Yet the underlying capability change is identical. This visualization shows the core argument: emergence can be an optical illusion created by our measurement choices, not a basic property of how capabilities develop.