Part III: The Token Geiger Counter

The Crime Scene

In Part I and Part II, we proved that LLMs don’t discover “Platonic forms”—they compress corpus statistics. The models haven’t escaped the cave; they’ve just memorized the shadows perfectly.

But this revelation creates a new question: If the corpus is the closed system, can we measure how it shapes the model during training?

Not “did the model learn truth?” but “did the model mechanically respond to the data we fed it?”

The Question: Can we build a diagnostic tool that detects corpus distortions during training, before they become hallucinations in production?

This is a training diagnostics problem, not a philosophy problem. And it requires a new tool.

Here’s my field report on building it.

Act I: The Evidence

What We Already Know (From Parts I & II)

The models are thermodynamic engines that minimize prediction error. During training:

1. Gradient descent is a voting mechanism: Each example contributes to the gradient. High-frequency tokens get millions of votes. Rare tokens get thousands.

2. The Democracy of Tokens: “Trump” appears in 50M training examples. “Sarcoidosis” appears in 5K. The model “knows” Trump 10,000x better—not because he’s more real, but because he had more votes.

3. Frequency = Truth: The model can’t distinguish “Paris is the capital of France” (true) from “Napoleon was short” (false) if both appear with similar frequency and consistency.

The Problem This Creates

High-frequency tokens become gravitational wells—they warp the latent space around them, pulling nearby tokens into their orbit. (In Part I, I called these distorters “token bombs.”)

When you introduce a batch heavy with “Trump,” suddenly “election,” “president,” “Twitter” all shift toward Trump’s region—even in contexts where he’s irrelevant.

Token Bomb: A high-frequency token that acts as a gravitational attractor, warping the geometric space around it and distorting nearby token representations.

The Question: Can we detect these distortions during training, before they become hallucinations in production?

Act II: The Investigation

Clue #1: The Seed Baseline Failed

My first approach was simple: measure how far tokens move from their random initialization.

# At initialization (t=0)
seed = embedding.weight.clone()

# After training
displacement = torch.norm(embedding.weight - seed, dim=1)
settled = displacement > threshold  # e.g., 2.0x original norm

Why this failed:

1. Frequency bias: High-frequency tokens escape the noise sphere in epoch 1. They look “settled,” but they just had more votes.

2. Rare token starvation: Medical terms, named entities, rare events may never exceed the threshold—even after full training. They appear unsettled, but they’ve actually converged to their corpus-limited distribution.

3. Static baseline: The seed only tells you “how far have we come?” It doesn’t tell you “are we still moving?”

The insight: The seed is the wrong baseline. What matters is: Has this token changed between epoch N and epoch N+1?

Clue #2: The Trajectory Signature

Instead of measuring absolute displacement from initialization, I measured relative displacement between epochs:

# Save state at each epoch
last_epoch = embedding.weight.clone()

# At next epoch, measure change
delta = embedding.weight - last_epoch
velocity = torch.norm(delta, dim=1)
trajectory = delta / (torch.norm(delta, dim=1, keepdim=True) + 1e-9)

What this revealed:

High-frequency tokens (the, and, is):

• Velocity drops to near-zero by epoch 3

• Trajectory is stable and monotonic

• They’ve converged to their statistical attractor

Rare-but-stable tokens (Paris, oxygen, democracy):

• Velocity decreases gradually

• Trajectory remains consistent

• They’re learning slowly but cleanly

Token bombs (Trump, COVID, Kardashian):

• Velocity spikes when they appear in batches

• Nearby tokens suddenly shift trajectory

• They create “gravity wells” that distort unrelated concepts

Key Learning: Don’t measure how far tokens have traveled from initialization. Measure whether they’re still moving—and in what direction.

Try it yourself:

import torch
import torch.nn as nn

class TrajectoryTracker:
    def __init__(self, embedding_layer):
        self.embedding = embedding_layer
        self.last_state = embedding_layer.weight.detach().clone()
        self.velocity_history = []

    def measure(self):
        current = self.embedding.weight
        delta = current - self.last_state
        velocity = torch.norm(delta, dim=1)

        self.velocity_history.append(velocity.cpu())
        self.last_state = current.detach().clone()

        return velocity

# Usage during training
tracker = TrajectoryTracker(model.token_embedding)

for epoch in range(num_epochs):
    for batch in dataloader:
        loss = train_step(batch)
        loss.backward()
        optimizer.step()

    velocity = tracker.measure()
    print(f"Epoch {epoch}: avg velocity = {velocity.mean():.4f}")

Clue #3: The Friction Fingerprint

Velocity tells you how much a token is changing. But it doesn’t tell you why.

A token could have high velocity because:

• It’s still learning (early training)

• The data is contradictory (oscillating between contexts)

• A token bomb just entered the batch (gravitational distortion)

I added a friction metric to distinguish these cases:

# After loss.backward(), before optimizer.step()
gradients = embedding.weight.grad
weights = embedding.weight

# Cosine similarity between gradient and weight
cosine = torch.sum(gradients * weights, dim=1) / (
    torch.norm(gradients, dim=1) * torch.norm(weights, dim=1) + 1e-9
)

# Negative cosine = gradient opposes current weights
friction = -cosine

Friction: Measures whether the gradient is fighting the accumulated weights. High friction = corpus conflict.

Interpretation:

Token bomb signature: When a Trump-heavy batch arrives, tokens like “election,” “rally,” “president” all show:

• Sudden velocity spike

• High friction (pulled away from their previous stable positions)

• Trajectory shift toward Trump’s region

Clue #4: The Wikipedia vs. Reddit War

To test whether this could detect corpus conflicts, I ran an experiment: train on mixed Wikipedia + Reddit data, but tag each batch by source.

# Tag batches
batch_sources = {
    0: "wiki", 1: "wiki", 2: "reddit", 3: "wiki", 4: "reddit", ...
}

# Track trajectory by source
wiki_trajectories = []
reddit_trajectories = []

for epoch, (batch, source) in enumerate(dataloader):
    train_step(batch)
    velocity, trajectory = tracker.measure()

    if source == "wiki":
        wiki_trajectories.append(trajectory)
    else:
        reddit_trajectories.append(trajectory)

# Compare alignment
wiki_avg = torch.stack(wiki_trajectories).mean(dim=0)
reddit_avg = torch.stack(reddit_trajectories).mean(dim=0)

alignment = torch.cosine_similarity(wiki_avg, reddit_avg, dim=0)

Results for specific tokens:

Token: "literally"
  Wiki trajectory → ["actually", "precisely", "exactly"]  
  Reddit trajectory → ["figuratively", "basically", "kinda"]
  Alignment: -0.42 (opposing directions)

Token: "based"
  Wiki trajectory → ["founded", "established", "located"]
  Reddit trajectory → ["redpilled", "chad", "poggers"]  
  Alignment: -0.38 (corpus conflict detected)

Token: "science"  
  Wiki trajectory → ["physics", "chemistry", "research"]
  Reddit trajectory → ["pseudoscience", "conspiracy", "narrative"]
  Alignment: 0.12 (mild conflict)

The Smoking Gun: Wikipedia and Reddit are teaching the model contradictory associations for the same tokens. This isn’t a bug—it’s a feature of mixing data sources.

The smoking gun: The tool empirically detected that Wikipedia and Reddit are teaching the model contradictory associations for the same tokens.

This isn’t a bug you can fix—it’s a feature of mixing data sources. But now you can measure it and make informed decisions.

Act III: The Tool

The Token Geiger Counter

Here’s the production-ready implementation:

import torch
import torch.nn as nn
from typing import Dict, Tuple

class TokenGeigerCounter:
    """
    Training dynamics probe for transformer embeddings.
    Measures how the corpus mechanically shapes token representations.

    Use cases:
    - Token bomb detection (high-frequency attractors)
    - Corpus curation (source conflict analysis)  
    - Training transparency (prove outputs are corpus-bound)
    """

    def __init__(self, embedding_layer: nn.Embedding):
        self.embedding = embedding_layer
        self.vocab_size, self.dim = embedding_layer.weight.shape

        # Baseline 1: Random seed (noise removal detection)
        self.seed = embedding_layer.weight.detach().clone()

        # Baseline 2: Last epoch (trajectory analysis)
        self.last_epoch = embedding_layer.weight.detach().clone()

        # History tracking
        self.velocity_history = []
        self.friction_history = []

    def measure_displacement(self) -> torch.Tensor:
        """
        How far has each token moved from random initialization?

        Returns:
            displacement_ratio: Values > 2.0 indicate token has been
                                "overwritten" by corpus data
        """
        current = self.embedding.weight
        displacement = torch.norm(current - self.seed, dim=1)
        seed_norm = torch.norm(self.seed, dim=1) + 1e-9
        return displacement / seed_norm

    def measure_velocity(self) -> Tuple[torch.Tensor, torch.Tensor]:
        """
        How much did each token change since last epoch?

        Returns:
            velocity: Magnitude of change
            trajectory: Direction of change (unit vector)
        """
        current = self.embedding.weight
        delta = current - self.last_epoch

        velocity = torch.norm(delta, dim=1)
        trajectory = delta / (velocity.unsqueeze(1) + 1e-9)

        # Update baseline
        self.last_epoch = current.detach().clone()

        self.velocity_history.append(velocity.cpu())

        return velocity, trajectory

    def measure_friction(self) -> torch.Tensor:
        """
        Is the gradient fighting the accumulated weights?
        Call after loss.backward(), before optimizer.step()

        Returns:
            friction: Negative cosine between gradient and weight.
                     High values indicate corpus conflict.
        """
        grad = self.embedding.weight.grad
        weight = self.embedding.weight

        dot = torch.sum(grad * weight, dim=1)
        grad_norm = torch.norm(grad, dim=1) + 1e-9
        weight_norm = torch.norm(weight, dim=1) + 1e-9
        cosine = dot / (grad_norm * weight_norm)

        friction = torch.clamp(-cosine, 0.0, 2.0)

        self.friction_history.append(friction.cpu())

        return friction

    def detect_token_bombs(self, velocity: torch.Tensor, 
                          top_k: int = 20) -> Dict:
        """
        Identify tokens causing the most geometric distortion.

        Args:
            velocity: Current epoch velocity measurements
            top_k: Number of top disruptive tokens to return

        Returns:
            Dictionary mapping token IDs to velocity scores
        """
        # Find tokens with sudden velocity spikes
        if len(self.velocity_history) < 2:
            return {}

        prev_velocity = self.velocity_history[-2]
        velocity_spike = velocity - prev_velocity

        top_indices = torch.argsort(velocity_spike, descending=True)[:top_k]

        return {
            idx.item(): velocity_spike[idx].item() 
            for idx in top_indices
        }

    def analyze_token(self, token_id: int, tokenizer=None) -> Dict:
        """
        Full diagnostic for a specific token.
        """
        displacement = self.measure_displacement()

        if len(self.velocity_history) > 0:
            velocity = self.velocity_history[-1][token_id]
        else:
            velocity = 0.0

        if len(self.friction_history) > 0:
            friction = self.friction_history[-1][token_id]
        else:
            friction = 0.0

        analysis = {
            'token_id': token_id,
            'displacement_from_seed': displacement[token_id].item(),
            'current_velocity': float(velocity),
            'current_friction': float(friction),
            'noise_removed': displacement[token_id].item() > 2.0,
            'still_learning': float(velocity) > 0.01,
            'corpus_conflict': float(friction) > 0.5,
        }

        if tokenizer:
            analysis['token_text'] = tokenizer.decode([token_id])

        return analysis

Try it yourself: Training loop integration

from transformers import GPT2LMHeadModel, GPT2Tokenizer

# Load model
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

# Attach probe
counter = TokenGeigerCounter(model.transformer.wte)

# Training loop
for epoch in range(num_epochs):
    for batch in dataloader:
        outputs = model(**batch)
        loss = outputs.loss

        loss.backward()

        # Measure BEFORE optimizer step
        friction = counter.measure_friction()

        optimizer.step()
        optimizer.zero_grad()

    # Measure AFTER epoch completes
    velocity, trajectory = counter.measure_velocity()

    # Detect token bombs
    bombs = counter.detect_token_bombs(velocity, top_k=10)

    print(f"\n=== Epoch {epoch} ===")
    print(f"Avg velocity: {velocity.mean():.4f}")
    print(f"Avg friction: {friction.mean():.4f}")
    print("\nToken bombs detected:")
    for token_id, spike in bombs.items():
        token_text = tokenizer.decode([token_id])
        print(f"  '{token_text}' (spike: {spike:.4f})")

Act IV: The Verdict

What This Tool Proves

I ran the Token Geiger Counter on GPT-2 trained on a mixed corpus (Wikipedia + news + Reddit). Here’s what it revealed:

Finding 1: Token Bombs Are Real

Tokens: Trump, COVID, Bitcoin, Kardashian

When these appear in batches:

• 100+ nearby tokens show sudden velocity spikes

• Friction increases across semantic neighbors

• Trajectory shifts persist for 2-3 epochs after

This is geometric distortion, not learning. The high-frequency attractor warps the space around it.

Finding 2: Model Confidence = Corpus Consistency

I measured trajectory stability during training, then generated outputs at inference:

All four have high confidence because all four have low training friction.

The model is reporting: “In my corpus, these associations were consistent.”

This is a proposition (from Part II’s framework)—a coherent sentence that is internally consistent but externally unverified, generated by token geometry alone.

NOT: “In reality, these facts are true.” That would require assertions—claims grounded in exogenous verification loops (thermometers, lab equipment, external reality) the model doesn’t have access to.

The Empirical Proof: Model confidence measures corpus consistency, not external truth. High stability = frequently co-occurred in training data.

This is the empirical proof that LLM outputs are corpus-bound propositions, not knowledge.

Finding 3: Source Conflicts Are Measurable

Wikipedia vs. Reddit trajectory alignment:

• High alignment (>0.7): Technical terms, proper nouns, math/science

• Mild conflict (0.3-0.7): Common words with evolving usage (“cloud”, “viral”)

• Strong conflict (<0.3): Slang, political terms, culturally loaded words (“based”, “literally”, “woke”)

The tool gives you quantitative evidence for data curation decisions.

The Real Implications

What We Can’t Fix

• ❌ The democracy of tokens (it’s structural to gradient descent)

• ❌ Hallucination (plausible geometry ≠ truth)

• ❌ Grounding in reality (the corpus is the closed system)

What We Can Do

• ✅ Detect token bombs before deployment: Flag high-frequency attractors distorting rare signals

• ✅ Debug corpus conflicts empirically: “My model hallucinates” → “Wikipedia and Reddit push token X in opposite directions—here’s the proof”

• ✅ Communicate honestly: Model confidence correlates with corpus consistency, not external truth

The Paradigm Shift: Stop asking “How do we make LLMs understand truth?” Start asking “How do we measure what the corpus taught them?”

The Paradigm Shift

Old approach: “Train a bigger model on more data and hope it learns truth.”

New approach: “Measure how data shapes the model, detect distortions, communicate limitations honestly.”

The MIT paper asked: “Are models discovering Platonic forms?”

We answer: “No. They’re discovering corpus geometry. Here’s how to measure it.”

Coda: Try It Yourself

Experiment 1: Detect Your Own Token Bombs

# Find which tokens cause the most distortion in YOUR dataset
counter = TokenGeigerCounter(your_model.embeddings)

for epoch in range(5):
    train_epoch(your_model, your_dataloader)
    velocity, _ = counter.measure_velocity()
    bombs = counter.detect_token_bombs(velocity)

    print(f"Epoch {epoch} bombs:", 
          [your_tokenizer.decode([tid]) for tid in bombs.keys()])

Experiment 2: Compare Data Sources

# Tag your batches by source (news, wiki, social media)
# Measure trajectory alignment between sources
# Decide which conflicts are acceptable trade-offs

Experiment 3: The Proposition Proof

# Generate outputs from your model
# Compare model confidence with trajectory stability
# Show stakeholders that "confidence ≠ truth"

The code, along with pre-computed GPT-2 trajectories, will be available at:
[github.com/gsans/platonic-glitch/token-geiger-counter]

---

Gerard Sans is a London-based AI engineer, Google Developer Expert, and founder of Axiom. After 20 years building production systems, he’s learned that measurement beats philosophy every time. Find him at @gerardsans or @nextai_london.​​​​​​​​​​​​​​​​