Diffusion Models for Trading Signals

TL;DR: Where Diffusion Would Help

✅ Best fit V12/V13 Company Scoring - Multi-dimensional scores, high-throughput requirements

⚠️ Maybe V7 Signals - If we just need conviction scores without reasoning

❌ Not ideal Current V7 with reasoning - Explanation and reasoning matter too much

The Breakthrough: Single-Step Diffusion

A discussion on X about single-step diffusion models revolutionizing LLM-based scoring raised an important question: Is this applicable to our SEC filing event → trading signal models?

The answer is nuanced - diffusion models aren't a replacement for everything we're doing, but they're perfect for specific use cases we're planning, especially V12/V13 company scoring.

Current V7 Signals Model Architecture

[Past events] → LLM (autoregressive) → JSON {
  "decision": "BUY",
  "conviction": 0.7,
  "reasoning": "Rare catalyst + temporal proximity...",
  "catalysts": [...],
  "exit_triggers": [...]
}

Why LLM Makes Sense for V7:

1. Reasoning is valuable - "Why BUY?" matters for:
   • Trust from portfolio managers
   • Debugging wrong signals
   • Learning what model finds important
2. Complex structured output - Multiple fields (catalysts, risks, exit triggers)
3. Current use case - Quarterly signals (not high-frequency)
   • 210K filings over 14 years = ~15K/year
   • ~40 filings/day = acceptable latency

V12/V13 Company Scoring - PERFECT For Diffusion! 🎯

# Multi-dimensional scoring at inflection points
{
  "company_score": 7.5,           # 0-10
  "risk_score": 6.8,              # 0-10
  "success_probability": 0.72,    # 0-1
  "speed_score": 5.0,             # 0-10
  "sustainability_score": 8.2,    # 0-10

  "predicted_return_6m": 18.5,    # Continuous
  "predicted_return_12m": 32.0,   # Continuous
  "max_drawdown_estimate": -15.0, # Continuous
  "sharpe_estimate": 1.8,         # Continuous
}

Why Diffusion Would Crush Here:

1. High-Throughput Scoring Needed:

• Raul's dashboard: Score all 5,000+ public companies daily
• Portfolio monitoring: Continuous re-scoring
• Real-time risk: Update scores on new events

Current LLM: 50 companies/minute = 100 minutes for full universe
Diffusion: 5,000+ companies/second = 1 second for full universe 🚀

2. Native Uncertainty:

# Sample 100 noises → get distribution
scores = diffusion_model.sample(events, n_samples=100)
company_score_mean = 7.5
company_score_std = 0.3     # ← Calibrated uncertainty!
confidence_interval = (7.2, 7.8)

This is HUGE for risk management!

3. Perfect Output Type:

• Continuous scores (0-10, 0-1)
• No need for reasoning text (dashboard shows metrics)
• Exactly what diffusion regression excels at

4. Latency Requirements:

• Dashboard refresh: Every 1-5 minutes
• Risk alerts: Sub-second
• Portfolio rebalancing: Real-time

Diffusion hits all these requirements.

Latency Comparison: The Numbers

50-100× speedup is achievable - and this would be transformative for V12/V13's vision of real-time company scoring at scale.

Specific Use Cases Where Diffusion Wins

# Get uncertainty-aware portfolio metrics
for company in portfolio:
    score_dist = diffusion.sample(events, n=100)
    worst_case = score_dist.quantile(0.05)
    best_case = score_dist.quantile(0.95)

The Hybrid Architecture: Best of Both Worlds

Event Stream
    ↓
Encoder (frozen LLM)
    ↓
    ├─→ Diffusion Head → Fast scores (real-time)
    └─→ LLM Head → Reasoning (on-demand)

Real-World Deployment:

# Fast path: Diffusion for all
scores = diffusion_model.batch_score(all_companies)

# Slow path: LLM for top signals
top_50 = scores.nlargest(50)
for company in top_50:
    detailed_analysis = llm_model.generate_reasoning(company)

Key Technical Insights

1. Consistency Trajectory Models (CTM)

The breakthrough technique from OpenAI's 2024 paper that powers Tesla's single-step diffusion:

• Train normal 50-step diffusion (teacher)
• Distill to 1-step model (student)
• Zero quality loss with 50× speedup

Code available: https://github.com/NVlabs/consistency-trajectory

2. Uncertainty is Native, Not Bolt-On

LLM approach (expensive):

# Need expensive sampling for uncertainty
scores = [llm.predict(events) for _ in range(100)]
mean = np.mean(scores)  # Costs 100× the inference

Diffusion approach (free):

# Uncertainty is free (just sample different noise)
scores = diffusion.sample(events, n_noises=100)
mean = np.mean(scores)  # Same cost as 1 inference

3. Works Best for Regression, Not Text

• Good fit: Continuous scores (company_score: 0-10)
• Bad fit: Structured text (reasoning, catalysts list)

This is why diffusion is perfect for V12/V13, not V7.

Implementation Roadmap

Phase 1: Proof of Concept (1 week)

Goal: Validate diffusion can learn event→score mapping

# Use existing V7 training data
# Convert: [events text] → LLM embedding → conviction score

# Train 1-step diffusion
git clone https://github.com/NVlabs/consistency-trajectory
python train.py --dataset v7_embeddings.npz --steps 1

Test:

• Accuracy vs LLM
• Latency improvement
• Uncertainty calibration

Phase 2: Production Prototype (2 weeks)

Architecture:

Events DB → Event Encoder → Diffusion Model → Scores
                ↓
         Cache embeddings (reuse across models)

Features:

• Batch scoring (1000s simultaneously)
• Uncertainty quantification
• Contribution heatmaps (which events matter most)

Phase 3: Hybrid System (1 month)

Deploy the full hybrid architecture with both diffusion (for speed) and LLM (for reasoning) working together.

When to Start: Decision Framework

✅ Start Prototyping If:

1. V7 validation succeeds (generates alpha)
2. V12/V13 company scoring is next priority
3. Need high-throughput scoring (>1000 companies)
4. Uncertainty quantification matters (risk dashboards)

⏸️ Wait If:

1. V7 still being validated (current status)
2. Reasoning/explainability is critical
3. Low-frequency use case (<100 predictions/day)
4. Team bandwidth limited

Bottom Line

The latency improvement (50-100×) is real and would be transformative for V12/V13's vision of real-time company scoring at scale.

Worth prototyping once V7 is validated! 🚀