Emergent Capabilities in Large Language Models

# Data inspired by Wei et al. (2022) "Emergent Abilities of Large Language Models"
EMERGENT_CAPABILITIES = [
    {
        "capability": "3-digit arithmetic",
        "emergence_scale": "8B params",
        "prior_accuracy": "~0%",
        "post_accuracy": "~60%",
        "description": "Correctly computing 3-digit × 3-digit multiplication",
    },
    {
        "capability": "Chain-of-thought (zero-shot)",
        "emergence_scale": "100B+ params",
        "prior_accuracy": "~0%",
        "post_accuracy": "~60%+",
        "description": "Generating accurate step-by-step reasoning without examples",
    },
    {
        "capability": "In-context few-shot learning",
        "emergence_scale": "13B params",
        "prior_accuracy": "random",
        "post_accuracy": "above baseline",
        "description": "Learning new classification tasks from examples in the prompt",
    },
    {
        "capability": "Truthfulness calibration",
        "emergence_scale": "30B+ params",
        "prior_accuracy": "overconfident",
        "post_accuracy": "better calibrated",
        "description": "Expressing 'I don't know' appropriately for uncertain facts",
    },
    {
        "capability": "BIG-Bench reasoning tasks",
        "emergence_scale": "Varies per task",
        "prior_accuracy": "below random",
        "post_accuracy": "human-competitive",
        "description": "Many abstract reasoning tasks with near-zero accuracy until scale",
    },
]

for cap in EMERGENT_CAPABILITIES:
    print(f"{cap['capability']:45} Emerges at: {cap['emergence_scale']}")

import numpy as np
import matplotlib.pyplot as plt

def simulate_compositional_task(n_subskills: int, model_scale: float) -> float:
    """
    Simulate task accuracy when all N sub-skills must work.
    Each sub-skill accuracy increases smoothly with scale.
    Emergence occurs when all sub-skills cross a threshold simultaneously.
    """
    # Each sub-skill has a slightly different scale threshold
    skill_thresholds = np.random.uniform(0.5, 2.0, n_subskills) * model_scale

    # Individual skill accuracy (logistic curve vs scale)
    skill_accuracies = 1 / (1 + np.exp(-2 * (model_scale - skill_thresholds)))

    # Task requires ALL skills to work (multiplicative)
    task_accuracy = np.prod(skill_accuracies)

    return task_accuracy

# Task accuracy jumps sharply even though each skill improves smoothly
scales = np.linspace(0, 3, 100)
task_accuracies_1 = [simulate_compositional_task(2, s) for s in scales]
task_accuracies_5 = [simulate_compositional_task(5, s) for s in scales]

# With more sub-skills: sharper emergence, later threshold

from openai import OpenAI

client = OpenAI()

# Zero-shot: no examples
zero_shot_prompt = """Classify the drug interaction severity as major/moderate/minor:
warfarin + clarithromycin → """

# Few-shot: 3 examples in context
few_shot_prompt = """Classify the drug interaction severity as major/moderate/minor:

warfarin + aspirin → major
metformin + ibuprofen → minor
simvastatin + clarithromycin → major

warfarin + clarithromycin → """

def compare_icl(prompt: str) -> str:
    return client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=10,
        temperature=0,
    ).choices[0].message.content.strip()

print("Zero-shot:", compare_icl(zero_shot_prompt))
print("Few-shot:", compare_icl(few_shot_prompt))
# GPT-3 (175B): few-shot substantially better than zero-shot
# GPT-4: both already good, gap narrows (stronger prior from pretraining)

# Grokking experiment: modular arithmetic
# Models suddenly learn perfect generalization after huge amounts of training
# despite the loss already being low (memorization plateau → then generalization)

def create_modular_arithmetic_dataset(mod: int = 97) -> list:
    """(a + b) mod p task that demonstrates grokking in transformers."""
    data = []
    for a in range(mod):
        for b in range(mod):
            result = (a + b) % mod
            data.append({"input": f"{a} + {b} = ?", "output": str(result)})
    return data

# Train a small transformer on this:
# Steps 0-1000: train loss falls, val loss stays high (memorization)
# Steps 1000-5000: train loss low, val loss still high (pure memorization)
# Steps 5000+: val loss suddenly falls (grokking — model finds the algorithm)
# Mechanism: L2 regularization eventually forces the model to the efficient solution

def emergence_prediction_framework(capability: str, model_family: str) -> dict:
    """
    Heuristic framework for predicting emergence (not a precise tool).
    Based on the task decomposition hypothesis.
    """

    # Factors that predict earlier emergence:
    early_signals = [
        "Task can be decomposed into sub-skills already in smaller models",
        "Similar tasks have been observed to emerge at smaller scale",
        "Weak but above-chance performance is observed in current models",
        "The capability requires information already in pretraining data",
    ]

    # Factors that predict later or no emergence:
    late_signals = [
        "Task requires integrating many independent knowledge areas simultaneously",
        "Performance requires extremely precise internal representations",
        "Task type was absent from pretraining data",
        "Success requires multi-step physical world reasoning",
    ]

    return {
        "capability": capability,
        "prediction_confidence": "low",  # We're bad at this
        "framework": "task_decomposition",
        "early_emergence_indicators": early_signals,
        "late_emergence_indicators": late_signals,
        "honest_assessment": "Emergence prediction remains unreliable. Empirical scaling experiments with smaller models are the most reliable signal.",
    }

# The honest answer: we don't have a reliable theoretical framework.
# Current practice: run scaling experiments and extrapolate loss curves.

EVAL_CATEGORIES_TO_MONITOR = [
    "reasoning_multi_step",
    "instruction_following_complex",
    "refusal_boundary_cases",
    "factual_accuracy_specialized",
    "format_compliance",
]

def regression_check_on_upgrade(old_model: str, new_model: str, eval_suite: list) -> dict:
    """
    When upgrading from one model to a more capable one,
    check for both improvements AND regressions.
    Emergent capabilities in the new model may break old assumptions.
    """
    results = {"improvements": [], "regressions": [], "unchanged": []}

    for eval_case in eval_suite:
        old_result = run_evaluation(old_model, eval_case)
        new_result = run_evaluation(new_model, eval_case)

        if new_result["score"] > old_result["score"] + 0.05:
            results["improvements"].append(eval_case["id"])
        elif new_result["score"] < old_result["score"] - 0.05:
            results["regressions"].append(eval_case["id"])
        else:
            results["unchanged"].append(eval_case["id"])

    return results