QSBench/QSBench-Amplitude-v1.0.0-demo

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

QSBench Amplitude Damping Demo v1.0.0

Quantum Machine Learning dataset for noise robustness and error prediction. Includes paired ideal and noisy expectation values under amplitude damping noise models.

Keywords: quantum dataset, noisy quantum circuits, amplitude damping, relaxation noise, QML benchmark, expectation value prediction.

5000 high-quality synthetic quantum circuits with amplitude damping — demo subset of the QSBench Noise Pack.

Designed for researchers and engineers working on noise-aware quantum ML, energy relaxation analysis ($T_1$ effects), and error mitigation.

Why this dataset?

Real quantum hardware suffers from energy relaxation. Amplitude damping is the standard model for describing the transition from an excited state to the ground state. This dataset allows you to:

• Compare ideal vs noisy outputs under relaxation effects
• Train models that predict or correct decay-related errors
• Benchmark robustness of ML models on 8-qubit circuits
• Study error distributions in deeper quantum circuits (depth=6)

Use Cases

• Noise robustness benchmarking
• Error mitigation research (specifically for $T_1$ relaxation)
• Predicting noisy expectation values
• Learning error correction models
• Feature engineering for noisy quantum states

Dataset Overview

• Samples: 5000
• Qubits: 8
• Depth: 6
• Circuit Families: Mixed (HEA, RealAmplitudes, QFT, Efficient SU(2), Random)
• Entanglement: Full
• Noise: Amplitude Damping ($p = 0.012$)
• 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
• Circuit adjacency matrix
• Gate statistics (CX, H, RX, RY, RZ, etc.)
• Structural metrics: Gate entropy + Meyer-Wallach entanglement
• Ideal expectation values
• Noisy expectation values (after amplitude damping)
• Explicit error targets: error_<label> = ideal - noisy
• Circuit metadata and generation parameters (depth=6, n=8)
• Deterministic split label

Key Learning Signals

For every observable, the dataset provides: ideal_expval_*, noisy_expval_*, error_*, sign_ideal_*, sign_noisy_*. This supports both high-precision regression and classification tasks for noise modeling.

QSBench-Amplitude: Asymmetric Noise Prediction

You don't need a PhD in Quantum Physics to use this dataset. This dataset represents a specific type of hardware degradation (Amplitude Damping), similar to battery drain or signal loss over time.

The ML Mission: Complex Tabular Regression

Unlike simple symmetric noise, Amplitude Damping affects the system in a biased way. Your mission is to build a predictive model that understands how specific topological structures (e.g., dense adjacency graphs) exacerbate this specific type of signal loss.

Dataset Anatomy (Features & Targets)

Group	Column Name	What is it for ML?
Features (X)	adjacency	The graph structure. Dense graphs decay differently than sparse ones.
Features (X)	qasm_transpiled	The hardware-specific compiled code (NLP feature).
Features (X)	single_qubit_gates, two_qubit_gates	The operation counts.
Target (y)	error_Z_global, error_X_global	Continuous regression targets representing the signal loss.
Physics	meyer_wallach	A measure of entanglement. Does highly entangled data decay faster?

Quick Start Idea

Compare feature importances. Does depth matter more than the number of two_qubit_gates when predicting Amplitude Damping errors?

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 amplitude damping demo dataset
dataset = load_dataset("QSBench/QSBench-Amplitude-v1.0.0-demo", split="train")

# Inspect the first sample with noise data
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[["ideal_expval_Z_global", "noisy_expval_Z_global", "error_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-Amplitude-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)

• Transpilation Hardware Pack (200k samples)

Part of the QSBench Family

This is a small public demo version. Full-scale datasets (20k–150k+ samples), specialized noisy versions, and custom hardware 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