Stochastic Discount Factor

02 Jan 2026 - Tags: Generative AI in Asset Management

Understanding the Stochastic Discount Factor (in Plain English)

Understanding the Stochastic Discount Factor (in Plain English)

At the heart of modern finance is one simple question:

What is an asset worth today, given that it pays something in the future?

A powerful way economists answer this is with a surprisingly compact formula:

[ p = E(m x) ]

Don’t worry about the symbols yet. Let’s unpack what this really means.

---

The Big Idea: Pricing = Discounted Expected Payoff

Imagine an asset that will pay you money next year. Its price today depends on two things:

1. How much it might pay
2. How much you value that future money compared to money today

In a world with no uncertainty, pricing is simple:

[ p = \frac{1}{R_f} x ]

Here:

• ( R_f ) is the risk-free interest rate.
• ( 1/R_f ) is the discount factor.
• Future money is worth less than money today because you could invest today’s money and earn interest.

That’s standard present value logic.

---

But Real Life Has Risk

Most investments are uncertain. Stocks, startups, crypto, even bonuses — we don’t know their exact payoff.

Traditionally, finance handled this by giving each risky asset its own “risk-adjusted” discount rate:

[ p_i = \frac{1}{R_i} E(x_i) ]

Each asset gets a different discount rate depending on its risk.

But this approach gets messy.

---

Enter the Stochastic Discount Factor (SDF)

Modern asset pricing introduces something deeper:

[ p = E(m x) ]

Here:

• ( x ) = the future payoff
• ( m ) = the stochastic discount factor (SDF)
• ( E ) = expectation (average over possible outcomes)

The word stochastic just means random.

So instead of using a different discount rate for each asset, we use one single random discount factor for all assets.

That’s powerful.

---

What Is the Stochastic Discount Factor?

The SDF is defined as:

[ m_{t+1} = \beta \frac{u’(c_{t+1})}{u’(c_t)} ]

Translated into plain English:

• ( u’(c) ) = marginal utility of consumption (how valuable one extra unit of consumption feels)
• ( \beta ) = time preference (how patient you are)

So:

The stochastic discount factor measures how much investors value consumption tomorrow relative to today.

It’s also called:

• Marginal rate of substitution
• Pricing kernel
• State price density
• Change of measure

All different names for the same core idea.

---

The Deep Insight

Here’s the big breakthrough:

Instead of adjusting each asset’s discount rate separately, we can:

• Use one universal discount factor
• Put it inside the expectation
• Let risk adjustments come from how each asset’s payoff correlates with m

Why does this work?

Because risk isn’t about volatility alone. It’s about:

Does the asset pay off when I really need it?

If an asset pays off in bad times (when consumption is low and marginal utility is high), it’s valuable. Investors are willing to pay more for it.

If an asset pays off in good times (when everyone is already rich and happy), it’s less valuable.

The key driver is correlation with marginal utility, not just variance.

---

Why This Framework Matters

The equation:

[ p = E(m x) ]

is almost an accounting identity. It doesn’t specify a model by itself.

The real modeling happens when we ask:

What determines the stochastic discount factor?

Different asset pricing models (CAPM, consumption models, habit models, etc.) are really just different ways of modeling m.

That separation is elegant:

• The pricing formula stays the same.
• Only the model for the SDF changes.

This makes asset pricing theory clean, modular, and powerful.

---

Intuition in One Sentence

The stochastic discount factor says:

An asset is valuable if it pays off when consumption is scarce and investors care the most.

That’s the core idea.

Everything else is math around that truth.

---

Here’s a simple Python implementation of the core pricing equation:

[ p = E(m x) ]

We’ll simulate:

• Future consumption ( c_{t+1} )
• Future asset payoff ( x_{t+1} )
• Compute the stochastic discount factor [ m_{t+1} = \beta \frac{u’(c_{t+1})}{u’(c_t)} ]
• Then estimate the price as the average of ( m \times x )

---

Step 1: Assumptions

We’ll assume:

• CRRA utility [ u’(c) = c^{-\gamma} ]
• ( \beta ) = time preference
• ( \gamma ) = risk aversion
• Monte Carlo simulation

---

Simple Python Example

import numpy as np

# --- Parameters ---
beta = 0.96        # time discount factor
gamma = 2.0        # risk aversion
c_t = 1.0          # current consumption
n_sim = 100000     # number of simulations

# --- Simulate future consumption (lognormal) ---
mu = 0.02
sigma = 0.1
c_t1 = np.random.lognormal(mean=mu, sigma=sigma, size=n_sim)

# --- Define marginal utility (CRRA) ---
def marginal_utility(c, gamma):
    return c ** (-gamma)

# --- Compute stochastic discount factor ---
m_t1 = beta * (marginal_utility(c_t1, gamma) /
               marginal_utility(c_t, gamma))

# --- Simulate asset payoff correlated with consumption ---
# Example: risky asset that pays more in good times
x_t1 = 1.0 + 0.5 * (c_t1 - np.mean(c_t1))

# --- Pricing equation: p = E[mx] ---
price = np.mean(m_t1 * x_t1)

print("Estimated Asset Price:", price)

---

What This Code Is Doing

1. Simulates future consumption.
2. Computes marginal utility today and tomorrow.
3. Constructs the stochastic discount factor.
4. Simulates an asset payoff correlated with consumption.

5. Prices the asset using:

   price = np.mean(m_t1 * x_t1)
   

That line is literally:

[ p = E(m x) ]

---

Key Insight

If you change:

• gamma (risk aversion)
• correlation between x_t1 and c_t1
• volatility of consumption

You’ll see the asset price change.

That’s because risk adjustments come from covariance between m and x, not from manually changing discount rates.

---

Let’s talk about how Generative AI can enhance the stochastic discount factor (SDF) framework.

---

Reframing the Core Idea

The pricing equation:

[ p = E(m x) ]

says:

• Asset prices depend on payoffs ( x )
• And a stochastic discount factor ( m )
• Risk corrections come from covariance between m and x

So the entire modeling problem becomes:

How do we model the stochastic discount factor ( m )?

Traditional models:

• CAPM → linear in market return
• Consumption models → function of consumption growth
• Habit models → nonlinear in consumption

All are just different parameterizations of m.

---

Where Generative AI Comes In

Generative AI (especially deep generative models) can help in three powerful ways:

---

Learning the SDF Directly from Data

Instead of assuming:

[ m = \beta \frac{u’(c_{t+1})}{u’(c_t)} ]

We can learn ( m ) from data.

Approach:

Train a neural network:

[ m_\theta = f_\theta(\text{macro variables, market states}) ]

Subject to:

[ E(m_\theta x) = p ]

This becomes a moment-matching problem.

Why Generative AI helps:

• Transformers can encode time-series states
• Diffusion models can generate state-contingent pricing kernels
• Variational models can learn latent macro risk factors

This is already happening in:

• Deep SDF models (Gu, Kelly, Xiu 2020)
• GAN-based asset pricing models

Instead of hand-crafting economic theory, we let the model generate the pricing kernel.

---

Generating State-Contingent Scenarios

Remember:

[ p = E(m x) ]

Expectation requires integrating over future states of the world.

Generative models (diffusion, GANs, autoregressive models) can:

• Generate realistic macroeconomic scenarios
• Simulate joint distributions of consumption + asset returns
• Produce rare tail events better than Gaussian assumptions

This improves:

• Risk estimation
• Tail pricing
• Stress testing
• Scenario-based portfolio construction

In short:

Better generative modeling → better expectation operator.

---

Nonlinear Risk Pricing

Traditional asset pricing assumes linear structure:

[ E(R_i) = \beta_i \lambda ]

But real-world risk is nonlinear, state-dependent, and regime-switching.

LLMs + deep generative models can:

• Capture nonlinear state transitions
• Detect regime changes
• Model latent economic narratives
• Integrate textual macro signals (Fed statements, earnings calls)

Example:

Combine:

• Structured macro data
• Market data
• News embeddings (SBERT / LLM embeddings)

Then learn:

[ m = f(\text{numerical factors}, \text{text embeddings}) ]

Now your SDF reacts to:

• Policy tone
• Geopolitical sentiment
• Earnings narratives

That’s something classical models cannot do.

---

Learning Latent Economic States

The SDF is fundamentally about:

When does money matter most?

Generative AI can learn latent economic states like:

• Crisis regime
• Liquidity crunch
• Inflation fear regime
• Growth optimism regime

Instead of manually defining states, VAEs or diffusion models can infer them.

Then:

[ m = g(\text{latent state}) ]

This connects deeply to macro-finance research.

---

Multi-Agent + Economic Simulation

Multi-agent AI systems:

We could simulate:

• Households optimizing consumption
• Firms making investment decisions
• Central banks adjusting policy

Train agents using reinforcement learning. Let equilibrium SDF emerge from the simulation.

Now you’re not just estimating m. You’re generating it from economic microfoundations.

That’s frontier research.

---

The Deeper Insight

Traditional finance says:

Theory → Define m → Test it

Generative AI flips it:

Data → Learn m → Interpret it

This is a massive shift.

The SDF framework is perfect for AI because:

• It reduces pricing to a single object
• It separates pricing identity from modeling
• It allows flexible nonlinear estimation

---

Practical Architecture (AI + SDF)

Example pipeline you could build:

1. Input:

   • Macro time series
   • Cross-sectional asset returns
   • News embeddings
   • Policy sentiment scores

2. Model:

   • Transformer encoder for time series
   • Dense layers for cross-sectional conditioning
   • Generative latent state model

3. Output:

   • Stochastic discount factor ( m_t )

4. Training objective: Minimize pricing errors: [ \sum_i (p_i - E(m x_i))^2 ]

That’s an end-to-end AI pricing engine.

---

The Big Takeaway

The equation:

[ p = E(m x) ]

is simple.

The future of finance is about:

Using AI to model m flexibly, realistically, and data-driven.

Generative AI doesn’t replace asset pricing theory. It enhances the modeling of the stochastic discount factor.

And that’s where the real edge is.

---

Below is a Hugging Face + PyTorch implementation of a Deep Stochastic Discount Factor (Deep SDF) model that:

• Uses a Transformer to encode macro time-series states
• Learns a neural stochastic discount factor ( m_t )
• Prices assets using [ p = E(m x) ]
• Trains by minimizing pricing errors

This is a simplified research-style prototype — clean but powerful.

---

Architecture Overview

We build:

[ m_\theta = f_\theta(\text{macro state}_t) ]

Then price assets via:

[ \hat{p}i = E(m\theta x_i) ]

Training objective:

[ \text{Loss} = \sum_i (p_i - \hat{p}_i)^2 ]

---

Step 1: Install

pip install torch transformers datasets

---

Step 2: Deep SDF Model (Transformer-Based)

import torch
import torch.nn as nn
import torch.optim as optim
from transformers import TimeSeriesTransformerConfig, TimeSeriesTransformerModel

# --------------------------
# CONFIG
# --------------------------
device = "cuda" if torch.cuda.is_available() else "cpu"

batch_size = 32
sequence_length = 12      # e.g. 12 months of macro history
num_macro_features = 10
num_assets = 20

# --------------------------
# HUGGING FACE TIME SERIES TRANSFORMER
# --------------------------
config = TimeSeriesTransformerConfig(
    prediction_length=1,
    context_length=sequence_length,
    input_size=num_macro_features,
    d_model=64,
    n_head=4,
    num_encoder_layers=2,
)

transformer = TimeSeriesTransformerModel(config).to(device)

# --------------------------
# SDF HEAD
# --------------------------
class DeepSDF(nn.Module):
    def __init__(self, transformer):
        super().__init__()
        self.transformer = transformer
        self.sdf_head = nn.Sequential(
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Linear(32, 1)
        )

    def forward(self, macro_series):
        # Transformer output
        outputs = self.transformer(
            past_values=macro_series
        )

        hidden_state = outputs.last_hidden_state[:, -1, :]
        m = self.sdf_head(hidden_state)
        return m.squeeze(-1)

model = DeepSDF(transformer).to(device)

---

Step 3: Simulated Training Data

# Simulated macro time series
macro_data = torch.randn(batch_size, sequence_length, num_macro_features).to(device)

# Simulated asset payoffs x
asset_payoffs = torch.randn(batch_size, num_assets).to(device)

# Observed market prices (simulated)
true_prices = torch.randn(num_assets).to(device)

---

Step 4: Pricing Equation Implementation

[ p = E(m x) ]

def pricing_loss(model, macro_data, asset_payoffs, true_prices):
    m = model(macro_data)                    # (batch,)
    
    # Expand m to multiply with each asset payoff
    m_expanded = m.unsqueeze(1)              # (batch, 1)
    
    # Monte Carlo expectation
    predicted_prices = torch.mean(m_expanded * asset_payoffs, dim=0)
    
    loss = torch.mean((predicted_prices - true_prices)**2)
    return loss

---

Step 5: Training Loop

optimizer = optim.Adam(model.parameters(), lr=1e-3)

for epoch in range(200):
    optimizer.zero_grad()
    
    loss = pricing_loss(model, macro_data, asset_payoffs, true_prices)
    
    loss.backward()
    optimizer.step()
    
    if epoch % 20 == 0:
        print(f"Epoch {epoch} | Loss: {loss.item():.6f}")

---

What This Model Is Doing

1. Transformer learns macro state representation.
2. Neural network maps state → stochastic discount factor ( m_t ).

3. Asset prices are computed using:

   predicted_prices = torch.mean(m * x)
   

4. Model adjusts ( m ) to minimize pricing errors.

This is AI learning the pricing kernel directly from data.

---

Enhancement 2: Add Textual Macro Signals (LLM Embeddings)

We now add:

• Fed statements
• Earnings call transcripts
• News embeddings

Example using Hugging Face BERT:

from transformers import AutoTokenizer, AutoModel

tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
bert = AutoModel.from_pretrained("bert-base-uncased").to(device)

text = ["Inflation expectations remain elevated."]
inputs = tokenizer(text, return_tensors="pt").to(device)

with torch.no_grad():
    outputs = bert(**inputs)
    
text_embedding = outputs.last_hidden_state[:, 0, :]

Then concatenate:

combined_state = torch.cat([macro_hidden_state, text_embedding], dim=1)

Now your SDF depends on:

• Quantitative macro data
• Narrative / policy tone

That’s frontier macro-finance.

---

Research-Level Interpretation

Traditional:

[ m = \beta \frac{u’(c_{t+1})}{u’(c_t)} ]

Deep AI version:

[ m_\theta = f_\theta(\text{macro}, \text{latent states}, \text{text}) ]

Same pricing identity:

[ p = E(m_\theta x) ]

Different modeling power.

---

Why This Is Powerful

• Handles nonlinear risk
• Learns regime shifts
• Incorporates unstructured data
• Scales across thousands of assets
• No need to specify utility function

This is essentially a Generative AI pricing engine.