README.md

---
license: cc-by-4.0
language:
- en
pretty_name: Autocallable Notes Pricing (Synthetic)
task_categories:
- tabular-regression
tags:
- finance
- quantitative-finance
- derivatives
- structured-products
- autocallable
- option-pricing
- monte-carlo
- heston
- synthetic
size_categories:
- 1M<n<10M
configs:
- config_name: default
  data_files:
  - split: train
    path: data/*/dataset.csv
---

# Autocallable Notes Pricing (Synthetic)

A fully **synthetic** dataset of autocallable structured-note scenarios paired with their
**fair value (`PV`)**, computed by Monte Carlo simulation under several stochastic models for
the underlying asset dynamics. It is designed for **derivative pricing with machine learning**:
training surrogate pricers, benchmarking tabular regressors, and studying how product terms and
market conditions map to price.

> All data is generated from first-principles simulation. It contains **no real market data, no
> proprietary quotes, and no scraped content** — every row is produced by the open-source pipeline
> at [VegaInstitute/RG-ML-Autocall-Dataset](https://github.com/VegaInstitute/RG-ML-Autocall-Dataset).

## TL;DR

- **Task:** tabular regression — predict `PV` (fair value of the note) from product terms + market state.
- **Underlying models:** Heston (stochastic volatility).
- **Pricing engine:** Monte Carlo, with a reported MC standard error (`PV_std`).
- **Scope:** single- and multi-asset baskets (1–4 assets), worst-of / min-basket payoffs, optional memory coupons.

## Supported tasks

- **Tabular regression (primary):** learn a fast surrogate that maps `(product terms, spots, correlations, implied-vol surfaces)` → `PV`.
- **Pricing acceleration / model distillation:** approximate the Monte Carlo pricer with a neural or gradient-boosted model.
- **Sensitivity & calibration studies:** analyze how `PV` responds to coupons, barriers, correlations, and the volatility surface.

## Underlying models

| Model | Dynamics | Notes |
|-------|----------|-------|
| **Heston** | Stochastic volatility | Produces a volatility smile; parameters sampled from ranges |

## Generation parameters

Defaults used by the reference pipeline (see `configs/` in the source repo):

| Parameter | Value / range |
|-----------|---------------|
| Trading days per year | 252 |
| Tenors (years) | {1, 2, 3} |
| Fixings per year | {1, 2, 4} |
| Assets per basket | 1–4 |
| Coupon | [0.01, 0.50] |
| Coupon barrier | [0.80, 1.00] |
| Autocall barrier | [1.00, 1.30] |
| Put strike | [0.70, 1.30] |
| Inter-asset correlation | [-0.80, 0.80] |
| Risk-free rate | 0.0 |
| Spot / notional | 1.0 |
| Monte Carlo paths | up to 1,000,000 |
| Basket convention | worst-of / min-basket |
| MC quality filter | scenarios kept when `PV_std` ≤ 0.01 |
| Heston: mean-reversion κ | [1.0, 10.0] |
| Heston: vol-of-vol ν | [0.01, 1.0] |
| Heston: price/var corr ρ | [-0.95, -0.10] |
| Heston: long-run var θ | [0.01, 0.20] |
| Heston: initial var V₀ | [0.0001, 0.04] |

Each model family is sampled over multiple parameter draws (`n_models`) and several product
draws per model (`n_observations`), so the total row count depends on the generation settings
you run. The published files are produced by re-running the pipeline; regenerate or extend them
with the CLI documented in the source repository.

## Data structure

The data is **wide tabular CSV**, one row per priced scenario, with **~1,531 columns** in the
full multi-asset configuration. Columns fall into the following groups.

### Identifiers & metadata

| Column | Description |
|--------|-------------|
| `value_date` | Valuation (pricing) date as a year-fraction |
| `value_date_memory` | Valuation date for the memory-coupon feature |
| `model_idx` | Index of the sampled model parameter set |
| `observation_idx` | Index of the product draw within a model |
| `frequency` | Observation/fixing frequency |
| `use_min_basket` | Whether the worst-of / min-basket convention applies |

### Product terms

| Column | Description |
|--------|-------------|
| `tenor` | Maturity in years |
| `coupon` | Coupon rate |
| `coupon_barrier` | Coupon barrier (fraction of spot) |
| `autocall_barrier` | Autocall (early-redemption) barrier |
| `is_put` | Whether a down-and-in put applies at maturity |
| `has_memory` | Whether unpaid coupons accumulate (memory effect) |
| `strike_put` | Put strike (fraction of spot) |

### Market state

| Column | Description |
|--------|-------------|
| `rate` | Risk-free rate |
| `num_assets` | Number of underlying assets (1–4) |
| `spot_asset_{1..4}` | Initial spot of each asset |
| `value_date_spot_asset_{1..4}` | Spot at valuation date for each asset |
| `corr_asset_i_j` | Pairwise correlations between assets |

### Fixing schedule & implied-volatility surfaces

| Column | Description |
|--------|-------------|
| `Date{1..12}` | Fixing/observation dates (year-fractions) |
| `Asset{a}_Date{d}_vol_{k}` | Implied volatility for asset `a`, fixing date `d`, strike index `k` (1–31) |

The `Asset{a}_Date{d}_vol_{1..31}` block encodes a **discretized implied-volatility surface**:
31 strikes per asset, per fixing date, for up to 4 assets and 12 dates.

### Target

| Column | Description |
|--------|-------------|
| **`PV`** | **Fair value of the note (regression target)** |
| `PV_std` | Monte Carlo standard error of `PV` (uncertainty of the label) |

> **Tip:** treat `PV` as the label and `PV_std` as a per-row noise estimate. Drop `model_idx` /
> `observation_idx` before training — they are bookkeeping indices, not features. Unused asset
> slots (when `num_assets < 4`) are zero-filled.

## Usage

```python
from datasets import load_dataset

ds = load_dataset("VegaInstitute/autocallable-notes-pricing", split="train")
print(ds.features)        # columns
print(ds[0]["PV"])        # target for the first scenario
```

With pandas:

```python
import pandas as pd

df = pd.read_csv("hf://datasets/VegaInstitute/autocallable-notes-pricing/data/heston/dataset.csv")
y = df["PV"]
X = df.drop(columns=["PV", "PV_std", "model_idx", "observation_idx"])
```

## Limitations & biases

- **Synthetic, not observed.** Prices and volatility surfaces come from model assumptions, not
  traded quotes; a model trained here learns *the simulated pricer*, not real-market mispricings.
- **Label noise.** `PV` carries Monte Carlo error; use `PV_std` to weight or filter rows.
- **Model coverage.** Limited to Heston with the parameter
  ranges above; out-of-range terms are out of distribution.
- **Wide and sparse.** The volatility-surface block dominates the column count; for `num_assets < 4`
  many columns are zero-filled.
- **Rate = 0.** Generated with a zero risk-free rate by default.

## Source code & reproduction

Generation pipeline, configs, and CLI:
**https://github.com/VegaInstitute/RG-ML-Autocall-Dataset**

```bash
python gen.py --model heston
```

## License

Released under **Creative Commons Attribution 4.0 International (CC-BY-4.0)**.
You may share and adapt the data, including commercially, with appropriate attribution.

## Citation

```bibtex
@misc{vegainstitute_autocall_synthetic,
  title        = {Autocallable Notes Pricing (Synthetic)},
  author       = {Vega Institute},
  year         = {2026},
  howpublished = {Hugging Face Datasets},
  url          = {https://huggingface.co/datasets/VegaInstitute/autocallable-notes-pricing},
  note         = {Synthetic Monte Carlo dataset for pricing autocallable structured notes}
}
```