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.

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, or inspect the generation pipeline in the QSBench Generator repository.

Support QSBench

You can support the project directly on this Giveth page:
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