QSBench/QSBench-Transpilation-v1.0.0-demo

---
license: cc-by-nc-4.0
task_categories:
- tabular-regression
- feature-extraction
language:
- en
tags:
- qiskit
- quantum-circuits
- synthetic-dataset
- benchmark
- expectation-values
- quantum-computing
- qml-benchmark
- quantum dataset
- qml dataset
- quantum benchmark
- hardware-aware
- transpilation
- circuit-optimization
- topology-mapping

pretty_name: QSBench Transpilation Demo v1.0.0 – Hardware-Aware Quantum Dataset (n=10, depth=8)
size_categories:
- 1K<n<10K
---

🌐 [Website](https://qsbench.github.io) | 🤗 [Dataset](https://huggingface.co/datasets/QSBench/QSBench-Transpilation-v1.0.0-demo) | 🛠️ [GitHub](https://github.com/QSBench/QSBench-Transpilation-v1.0.0-demo) | 🚀 [Interactive Demo](https://huggingface.co/QSBench/spaces/)

# QSBench Transpilation Demo v1.0.0

**Hardware-aware Quantum Machine Learning dataset for circuit optimization and mapping analysis.** Includes 10-qubit circuits designed to study the impact of transpilation on circuit structure.

Keywords: quantum dataset, transpilation, hardware-aware, circuit optimization, QML benchmark, 10-qubit circuits.

**5000 high-quality synthetic quantum circuits** — demo subset of the QSBench Hardware Pack, featuring increased width (n=10) and depth (depth=8).

Designed for researchers and engineers working on compiler optimization, hardware-aware ML, and connectivity-constrained variational algorithms.

### Why this dataset?
Mapping abstract quantum circuits to physical hardware (transpilation) is one of the biggest bottlenecks in quantum computing. This dataset provides 10-qubit circuits that allow you to:
- Study **gate counts and circuit growth** after transpilation
- Analyze **connectivity and adjacency matrices** for larger-scale systems
- Train models to **predict transpilation overhead**
- Benchmark **feature extraction** from 10-qubit circuit topologies

### Use Cases
- Transpilation overhead prediction
- Hardware-aware feature engineering
- Gate count optimization benchmarking
- Connectivity and swap-gate analysis
- Scaling studies for Quantum Machine Learning models

### Dataset Overview
- **Samples**: 5000
- **Qubits**: 10
- **Depth**: 8
- **Circuit Families**: Mixed (HEA, RealAmplitudes, QFT, Efficient SU(2), Random)
- **Entanglement**: Full
- **Noise**: None (clean simulation for baseline hardware-aware studies)
- **Observables**: Z, X, Y in mixed mode (global + per-qubit)
- **Shots**: 1024
- **Splits**: Train / Validation / Test — deterministic hash-based

### What's Inside Each Sample
Each sample in the Parquet files contains:
- Raw and transpiled QASM representations (n=10)
- Circuit adjacency matrix for the 10-qubit topology
- Detailed gate statistics (CX, H, RX, RY, RZ, and total gate counts)
- Structural metrics: Gate entropy + Meyer-Wallach entanglement
- Ideal expectation values for Z, X, Y (global and per-qubit)
- Circuit family label and full generation metadata (depth=8)
- Deterministic split label

### QSBench-Transpilation: Quantum Hardware Routing

**You don't need a PhD in Quantum Physics to use this dataset.** If you like **NLP**, **Sequence-to-Sequence (Seq2Seq) models**, or **Graph Transformations**, this is the dataset for you. Transpilation is exactly like compiling high-level Python code down to C++ machine instructions.

### The ML Mission: Graph Translation & Optimization
We provide the raw "theoretical" algorithm (`qasm_raw`) and the physically compiled version (`qasm_transpiled`). Can you build an LLM or a Graph model that learns the transpilation rules? Can you predict how much a circuit will "grow" in depth after it is compiled for a specific hardware topology?

### Dataset Anatomy (Features)

| Group | Column Name | What is it for ML? |
| :--- | :--- | :--- |
| **Input (X)** | `qasm_raw` | The source language / original sequence. |
| **Output (y)** | `qasm_transpiled` | The target language / compiled sequence. |
| **Cost Metrics** | `depth`, `cx_count` | The "cost" of the compiled circuit. Can you predict the compiled depth from the raw code? |
| **Environment** | `n_qubits` | The constraints of the hardware device. |

### Quick Start Idea
Treat this as a text complexity problem. Calculate the character length and gate keyword counts of both `qasm_raw` and `qasm_transpiled`. Can you train a linear regression model to predict the "transpilation overhead" (the ratio between compiled depth and raw depth)?

### Load the Dataset
The dataset is stored in Parquet format inside the `data/shards/` folder. You can load it directly using the Hugging Face `datasets` library:

```python
from datasets import load_dataset

# Load the transpilation demo dataset
dataset = load_dataset("QSBench/QSBench-Transpilation-v1.0.0-demo", split="train")

# Inspect a 10-qubit circuit sample
print(dataset[0])
```

If you prefer to use `pandas`:

```python
import pandas as pd

# Load all Parquet shards from the data folder
df = pd.read_parquet("data/shards/*.parquet")
print(df[["total_gates", "gate_entropy", "ideal_expval_Z_global"]].head())
```

### Repository Structure

The dataset is stored in the `main` branch and contains only the data files to ensure the Dataset Viewer works correctly:

```text
QSBench-Transpilation-v1.0.0-demo/
├── README.md # This file
└── data/ # Parquet and CSV shards
└── shards/
└── *.parquet
└── *.csv
```

All metadata files (coverage.json, schema.json, meta.json, etc.) are located in a separate branch called meta.

👉 [browse meta branch](https://huggingface.co/datasets/QSBench/QSBench-Transpilation-v1.0.0-demo/tree/metadata)

### Related QSBench Datasets

- QSBench Lite (20k samples, n=4)

- QSBench Core (75k samples, n=8)

- Depolarizing Noise Pack (150k samples)

- Amplitude Damping Pack (150k samples)

- Full Hardware Pack (200k samples, n=10-12)

### Part of the QSBench Family

This is a small public demo version. Full-scale datasets (up to 200k+ samples), specialized noise models, and custom hardware-specific packs are available.

[Website & Full Catalog](https://qsbench.github.io/)

### Notes

This dataset is fully synthetic and generated using quantum circuit simulation. No real-world or personal data is included.

**License:** CC BY-NC 4.0 (Personal & Research Use)

**Questions or custom requests?** Visit our [website](https://qsbench.github.io) or open an issue on [GitHub](https://github.com/QSBench/QSBench-Transpilation-v1.0.0-demo), or inspect the generation pipeline in the **QSBench Generator** [repository](https://github.com/QSBench/QSBench-Generator).

### Support QSBench

You can support the project directly on this Giveth page:
**[https://giveth.io/project/qsbench](https://giveth.io/project/qsbench)**

Your donations help us generate larger datasets, cover GPU costs, and continue developing new realistic noise models.

---
*Generated with QSBench Generator v5.0.2*