README.md

---
license: apache-2.0
task_categories:
- tabular-regression
tags:
- hyperparameter-optimization
- automl
- bioinformatics
- multi-omics
- autoencoder
- benchmark
size_categories:
- 100K<n<1M
---

# BBOmix: Raw HPO Data

BBOmix is a large-scale tabular benchmark for hyperparameter optimization (HPO) of
unsupervised autoencoder (AE) representation learning on real-world biological
multi-omics data. This dataset contains the **raw, per-run evaluation records**
underlying the benchmark: 105,000 individual training runs spanning 5 AE
architectures, 7 dataset-modality tasks, 1,000 sampled hyperparameter
configurations per architecture, and 3 random seeds.

This collection is the unprocessed source data. It was used to build the
serialized tabular blackboxes used in the  [BBOmix paper](https://arxiv.org/abs/2606.05139). If you want to run HPO
optimizers against the benchmark directly, use [Syne Tune](https://github.com/syne-tune/syne-tune). Use this raw data if you want to
build your own surrogate/analysis pipeline.

**Total size:** ~1 GB (uncompressed JSON)
**Total files:** 105,000 JSON files (one per training run)

The files are now stored as 4 separate ZIP archives based on their architecture: `vanillix.zip`, `varix.zip`, `disentanglix.zip`, and `ontix.zip`.

## Downloading and using the data

The raw JSON files are packaged into four zip archives based on their architecture, hosted on Hugging Face at `autoencodix/BBOmix`:
- `vanillix.zip`
- `varix.zip`
- `disentanglix.zip`
- `ontix.zip`

You can download them using the `huggingface_hub` Python library. For example, to download and extract the `varix` data:

```python
from huggingface_hub import hf_hub_download
import zipfile

# Download the zip file
file_path = hf_hub_download(repo_id="autoencodix/BBOmix", filename="varix.zip", repo_type="dataset")

# Extract to your desired directory
with zipfile.ZipFile(file_path, 'r') as zip_ref:
    zip_ref.extractall("bbomix_raw/")
```

Alternatively, you can use the Hugging Face CLI:

```bash
huggingface-cli download autoencodix/BBOmix varix.zip --repo-type dataset
unzip varix.zip -d raw_hpo_data/
```

Once extracted, you will have access to the individual JSON files, which can be loaded and parsed using standard tools (e.g., Python's `json` or `pandas` libraries).

## What's in the benchmark

- **5 AE architectures:** Vanillix (standard AE), Varix (β-VAE), Disentanglix
  (β-TCVAE-style disentangled VAE), and two Ontix variants (ontology-constrained VAE, evaluated
  with two ontology variants: `chromosome` and `reactome`)
- **2 source datasets:** TCGA (The Cancer Genome Atlas, bulk multi-omics,
  pan-cancer) and SCHC (Single-Cell Human Cortex, single-cell multi-omics)
- **7 dataset-modality tasks:** three TCGA modalities (RNA, EPIGENETIC, DNA) and their
  combinations, plus two SCHC modalities (RNA, EPIGENETIC) and their combination —
  each task always includes the relevant clinical/annotation labels (`CLIN`)
  used for downstream evaluation
- **1,000 hyperparameter configurations** sampled uniformly at random per
  architecture
- **3 random seeds** per configuration to account for stochastic training
  variation
- **300 training epochs** per run, with reconstruction loss logged at every
  epoch to support multi-fidelity / early-stopping HPO methods

Each configuration was trained on real biological data and evaluated both by
its unsupervised reconstruction loss and by downstream supervised task
performance (logistic regression AUC-ROC on frozen embeddings), enabling
analysis of how well reconstruction loss serves as a cheap proxy for
downstream utility — see the paper for details.

## Directory / file naming

Each JSON file corresponds to a single training run. Files are named/grouped
by architecture, dataset, modality combination, seed, and hyperparameter
configuration index, following the `RUN_ID` field inside the file itself, e.g.:

```
disentanglix_schc_1_METH_CLIN_hp0.json
```

reads as: architecture = `disentanglix`, dataset = `schc`, seed = `1`,
modalities = `METH` + `CLIN`, hyperparameter configuration index = `hp0`.

For Ontix runs, the ontology variant (`chromosome` or `reactome`) is also
encoded in the filename/RUN_ID, since the two ontologies define distinct
decoder structures and are treated as separate architecture variants.

## JSON schema

Every file has the same top-level schema:

| Field | Type | Description |
|---|---|---|
| `RUN_ID` | string | Unique identifier for this run (see naming convention above). |
| `ARCHITECTURE` | string | One of `vanillix`, `varix`, `disentanglix`, `ontix`. |
| `SEED` | int | Random seed used for this run (`0`, `1`, or `2`). |
| `DATASET` | string | Source dataset: `tcga` or `schc`. |
| `MODALITIES` | list[string] | Data modalities used as input, e.g. `["METH", "CLIN"]`. `CLIN` denotes the clinical/annotation labels used for downstream evaluation, not a training input modality. |
| `ONTOLOGY` | string or null | For Ontix runs: `"chromosome"` or `"reactome"`. `null` for all other architectures. |
| `HYPERPARAMETERS` | dict | The sampled hyperparameter configuration for this run. Keys vary by architecture — see [Hyperparameter search spaces](#hyperparameter-search-spaces) below. |
| `AVG_ML_TASK_PERFORMANCE` | float | Downstream performance (AUC-ROC), averaged across all downstream tasks defined for this dataset/modality combination. This is the paper's primary "downstream utility" metric. |
| `PER_TASK_PERFORMANCE` | dict | Downstream AUC-ROC broken down per individual clinical/annotation task (e.g. `sex`, `age_group`, cancer subtype, survival status — task names depend on `DATASET`; see Appendix A of the paper for the full list per dataset). |
| `VALID_RECON_LOSS` | float | Final validation-set reconstruction loss (or ELBO/total loss for VAE-style architectures) at the last logged epoch. |
| `loss_per_epoch` | dict[str, float] | Per-epoch training/validation loss curve, keyed by epoch index (`"0"` through `"299"`) as strings. Enables multi-fidelity and early-stopping HPO methods (e.g. ASHA, BOHB, Hyperband) to query intermediate fidelities without retraining. |
| `RUNTIME_SECONDS` | float | Wall-clock training time for this run in seconds. |

### Hyperparameter search spaces

The keys present in `HYPERPARAMETERS` depend on `ARCHITECTURE`:

- **Shared across all architectures:** `k_filter` (input filter/feature size),
  `n_layers` (number of encoder layers), `enc_factor` (encoding factor),
  `learning_rate`, `batch_size`, `drop_p` (dropout probability), `weight_decay`,
  `epochs`, `checkpoint_interval`, `loss_reduction`
- **Vanillix:** shared parameters only, plus `latent_dim`
- **Varix / Ontix:** adds `beta` (KL-divergence weight)
- **Disentanglix:** adds `beta_mi` (mutual information weight), `beta_tc`
  (total-correlation weight), `beta_dimKL` (per-dimension KL weight)
- **Ontix:** `latent_dim` is architecture-defined by the chosen ontology rather
  than sampled (see `ONTOLOGY` field)

See Table 1 in the paper for the exact sampling distributions (uniform vs.
log-uniform vs. categorical) for every hyperparameter.

## Example record

```json
{
  "RUN_ID": "disentanglix_schc_1_METH_CLIN_hp0",
  "ARCHITECTURE": "disentanglix",
  "SEED": 1,
  "DATASET": "schc",
  "MODALITIES": ["METH", "CLIN"],
  "ONTOLOGY": null,
  "HYPERPARAMETERS": {
    "epochs": 300,
    "checkpoint_interval": 300,
    "loss_reduction": "sum",
    "k_filter": 4096,
    "n_layers": 2,
    "enc_factor": 1,
    "learning_rate": 0.009251283695699343,
    "weight_decay": 9.54041826560807e-05,
    "batch_size": 64,
    "drop_p": 0.6628240927476112,
    "beta_mi": 0.0509093966079994,
    "beta_tc": 288.99999718361437,
    "beta_dimKL": 0.00022271800642020435,
    "latent_dim": 16
  },
  "AVG_ML_TASK_PERFORMANCE": 0.6147933697669551,
  "PER_TASK_PERFORMANCE": {
    "author_cell_type": 0.7042096421209849,
    "age_group": 0.5984282088126611,
    "sex": 0.5417422583672192
  },
  "VALID_RECON_LOSS": 92.06772205753184,
  "loss_per_epoch": {
    "0": 139.4601534783552,
    "1": 132.60988325103102,
    "...": "...",
    "299": 92.06772205753184
  },
  "RUNTIME_SECONDS": 1571.6251
}
```

## Intended use

This raw data is intended for:

- Building custom tabular/surrogate HPO benchmarks beyond the provided Syne
  Tune blackboxes (e.g., different aggregation of seeds, custom multi-fidelity
  schedules, alternative surrogates for off-grid queries)
- Studying the relationship between reconstruction loss and downstream
  biological utility across architectures and modalities
- Hyperparameter importance analysis (e.g., permutation importance, fANOVA)
  using the full configuration-to-performance mapping
- Meta-learning / transfer-learning research across tasks, architectures, and
  modalities, using the full per-run records rather than aggregated summaries

This dataset does **not** contain raw omics measurements (e.g. sequencing
reads, methylation beta values, mutation calls) — only the evaluation results
of models trained on that data. The underlying TCGA and SCHC data are public
and de-identified; see the paper for their original sources.

## Citation

If you use this dataset, please cite the BBOmix paper:

```
@misc{thalebombien2026bbomixtabularbenchmarkhyperparameter,
      title={BBOmix: A Tabular Benchmark for Hyperparameter Optimization of Unsupervised Biological Representation Learning}, 
      author={Luca Thale-Bombien and Jan Ewald and Ralf König and Aaron Klein},
      year={2026},
      eprint={2606.05139},
      archivePrefix={arXiv},
      primaryClass={cs.LG},
      url={https://arxiv.org/abs/2606.05139}, 
}
```

## License

Released under the Apache 2.0 license.