QSBench/QSBench-Transpilation-v1.0.0-demo

🌐 Website | 🤗 Dataset | 🛠️ GitHub | 🚀 Interactive Demo

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:

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:

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:

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

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.

Repository | Website & Full Catalog

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 or open an issue on GitHub.

---

Generated with QSBench Generator v5.0.2