QSBench/QSBench-Core-v1.0.0-demo

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

QSBench Core Demo v1.0.0

Quantum Machine Learning dataset for regression on expectation values. Includes quantum circuits, QASM, and structured features for training ML models.

Keywords: quantum dataset, QML benchmark, quantum circuits dataset, expectation value prediction.

2000 high-quality synthetic quantum circuits — clean simulation demo of the QSBench family.

Designed for researchers and engineers working on Quantum Machine Learning, variational algorithms, and hybrid quantum-classical models.

Why QSBench?

Most public quantum datasets are too small, poorly documented, or lack paired ideal/noisy data. QSBench solves this by providing reproducible, richly annotated, and ready-to-use datasets.

Use Cases

• —Training Quantum Machine Learning models
• —Benchmarking noise robustness
• —Predicting expectation values from circuit structure
• —Hybrid quantum-classical ML pipelines
• —Feature engineering from quantum circuits

Dataset Overview

• —Samples: 2000
• —Qubits: 6
• —Depth: 4
• —Circuit Families: Mixed (HEA, RealAmplitudes, QFT, Efficient SU(2), Random)
• —Entanglement: Full
• —Noise: None (clean simulation)
• —Observables: Z, X, Y in mixed mode (global + per‑qubit)
• —Shots: 512
• —Splits: Train (157) / Validation (26) / Test (17) — deterministic hash‑based

What's Inside Each Sample

Each sample in the Parquet files contains:

• —Raw and transpiled QASM representations
• —Circuit adjacency matrix
• —Detailed gate statistics (single‑qubit, two‑qubit, CX, H, RX, RY, RZ)
• —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
• —Deterministic split label (train/val/test)

QSBench-Core: Quantum Circuit Complexity

You don't need a PhD in Quantum Physics to use this dataset. If you are a Data Scientist, ML Engineer, or AI Researcher, think of a quantum circuit as a Computational Graph (DAG) or a piece of Code. This dataset provides the raw structural blueprints of thousands of quantum algorithms.

The ML Mission: Unsupervised Learning & Clustering

Since this dataset contains clean, ideal circuits (no noise), it is perfect for Unsupervised Learning. Can you cluster these circuits into distinct "complexity classes" using K-Means or HDBSCAN? Can you build a Graph Neural Network (GNN) that learns the topology of these circuits?

Dataset Anatomy (Features)

Think of these columns as your X features.

Quick Start Idea

Try to run PCA on the numeric features (depth, gate_entropy, cx_count, adj_density) to visualize the "DNA" of quantum algorithms in 2D space.

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

# Inspect the first 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.head())

Example: Train a simple model on expectation values

from sklearn.ensemble import RandomForestRegressor
import numpy as np
from datasets import load_dataset

# Load dataset
ds = load_dataset("QSBench/QSBench-Core-v1.0.0-demo")

# Use gate count as a simple feature
X_train = np.array([s["total_gates"] for s in ds["train"]]).reshape(-1, 1)
y_train = np.array([s["ideal_expval_Z_global"] for s in ds["train"]])

model = RandomForestRegressor(random_state=42)
model.fit(X_train, y_train)

# Evaluate on test set
X_test = np.array([s["total_gates"] for s in ds["test"]]).reshape(-1, 1)
y_test = np.array([s["ideal_expval_Z_global"] for s in ds["test"]])
score = model.score(X_test, y_test)
print(f"R² score: {score:.4f}")

For more advanced usage (e.g., using QASM strings, adjacency matrices), check the provided metadata files in the meta/ folder.

Repository Structure

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

QSBench-Core-v1.0.0-demo/
├── README.md # This file
└── data/ # Parquet shards (main data)
└── shards/
└── *.parquet
└── *.csv

All metadata files (coverage.json, schema.json, meta.json, data_card.md, etc.) are located in a separate branch called `metadata` to avoid interfering with the Dataset Viewer. You can browse them here:

👉 metadata branch

Related QSBench Datasets

• —Depolarizing Noise Pack (5k samples)
• —Amplitude Damping Pack (5k samples)
• —Transpilation Hardware Pack (5k samples)
• —Thermal Relaxation Pack (2k samples)
• —Realistic hardware-mimic (2k samples)
• —Readout Error (2k samples)

Part of the QSBench Family

This is a small public demo version. Full‑scale datasets (20k–150k+ samples), noisy versions (Depolarizing, Amplitude Damping), and custom datasets are available.

Repository

Website & Full Catalog

Email: QSBench@gmail.com

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

Questions or custom requests? Visit our website or open an issue on GitHub.

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