QuantScenarioBench/qsb-black-scholes

QuantScenarioBench — Black-Scholes Benchmark Dataset

This dataset is a representative benchmark sample generated by QuantScenarioBench, a JAX-native framework for reproducible stochastic market scenario generation.

It contains 10,000 independent asset-price paths simulated under the Black-Scholes (Geometric Brownian Motion) model over 252 daily time steps (1 year horizon).

Need a larger or custom dataset? This file is a fixed benchmark sample. To generate datasets at any scale — more paths, different parameters, non-uniform time grids, or other market models — use the QuantScenarioBench library directly:

pip install quantscenariobench

See the GitHub project for full documentation and examples.

---

Model Description

The Black-Scholes model (Black & Scholes, 1973) describes the evolution of an asset price $S_t$ under Geometric Brownian Motion:

$$d{S}_t=\mu S_{t}dt+\sigma S_{t}d{W}_{t}dS\_t\; =\; \backslash mu\backslash ,S\_t\backslash ,dt\; +\; \backslash sigma\backslash ,S\_t\backslash ,dW\_t$$

where $W_t$ is a standard Brownian motion. The model has constant drift $\mu$ and constant volatility $\sigma$.

This is the simplest and most widely used continuous-time model for equity prices. It produces log-normal returns with no volatility clustering or skew.

Parameters used for this dataset

Parameter	Value	Description
S0	100.0	Initial asset price
mu	0.0	Drift (risk-neutral; $r = 0$)
sigma	0.2	Constant annual volatility (20%)

The risk-neutral setting (mu=0) makes ATM option prices directly comparable across models in this benchmark suite.

---

Simulation Configuration

Field	Value
Time grid	linspace(0.0, 1.0, 253) — 252 daily steps over 1 year
Number of paths	10,000
PRNG seed	42
Backend	JAX CPU (float64)
Library version	1.0.0
Dataset version	1.0.0

---

Column Schema

All QuantScenarioBench datasets share the same 12-column schema regardless of the market model used. This enables direct cross-model comparison by loading datasets with identical code.

Column	Type	Description
observation	list<float64>	Asset price path $S_{t_0}, \ldots, S_{t_T}$; one row per path
latent_state	list<float64>	Latent state path; empty list for Black-Scholes (no latent process)
seed	int64	Integer PRNG seed used to reproduce this batch
prng_key_info	string	JAX PRNGKey derivation description
model_name	string	BlackScholes
model_version	string	Model specification version
parameters	string	JSON-encoded model parameters
time_grid	string	JSON-encoded array of 253 time points
n_paths	int64	10000
library_version	string	quantscenariobench library version
dataset_version	string	Dataset version identifier (independent of library version)
generated_at	string	UTC ISO-8601 generation timestamp

---

Usage

from datasets import load_dataset
import numpy as np

ds = load_dataset("QuantScenarioBench/qsb-black-scholes", split="train")

# Each row is one simulated path
row = ds[0]
prices = np.array(row["observation"])   # shape (253,)
print(f"S0={prices[0]:.2f}  S_T={prices[-1]:.2f}")

# Stack all paths into a numpy array
all_paths = np.stack([ds[i]["observation"] for i in range(len(ds))])
print(all_paths.shape)   # (10000, 253)

Cross-model comparison

All three benchmark datasets share the same schema and time grid:

bs  = load_dataset("QuantScenarioBench/qsb-black-scholes",  split="train")
h   = load_dataset("QuantScenarioBench/qsb-heston",          split="train")
rb  = load_dataset("QuantScenarioBench/qsb-rough-bergomi",   split="train")

# Compare terminal distributions
import numpy as np
for name, ds in [("BS", bs), ("Heston", h), ("rBergomi", rb)]:
    terminals = np.array([ds[i]["observation"][-1] for i in range(len(ds))])
    print(f"{name:10s}  mean={terminals.mean():.2f}  std={terminals.std():.2f}")

Generate a custom dataset

from quantscenariobench.api import simulate
from quantscenariobench.export import export_parquet, publish_to_hub
from quantscenariobench.interface import TimeGrid
from quantscenariobench.models import BlackScholes
import jax.numpy as jnp

model    = BlackScholes(mu=0.0, sigma=0.3, S0=100.0)   # 30% vol
tg       = TimeGrid(jnp.linspace(0.0, 2.0, 505))       # 2-year horizon
scenario = simulate(model, tg, n_paths=100_000, seed=99)

export_parquet([scenario], "my_bs_dataset.parquet")
# or: publish_to_hub([scenario], "my-org/my-bs-dataset")

---

Reproducibility

Simulation paths are bit-identical across runs on the same computational backend when using the same seed, library_version, and model parameters.

Cross-backend bit-identity is not guaranteed. JAX floating-point operations may produce different bit patterns across hardware backends (CPU, GPU, TPU) even with identical inputs. The seed, prng_key_info, and library_version columns document full provenance so that any differences can be traced to backend changes rather than parameter or code drift.

---

Related Datasets

Model	Dataset
Black-Scholes (this dataset)	QuantScenarioBench/qsb-black-scholes
Heston	QuantScenarioBench/qsb-heston
Rough Bergomi	QuantScenarioBench/qsb-rough-bergomi

All three datasets use the same time grid, seed, and initial spot for direct cross-model comparison.

---

Citation

If you use this dataset or QuantScenarioBench in your research, please cite the GitHub repository.