This is an automated email from the ASF dual-hosted git repository.
400Ping pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/mahout.git
The following commit(s) were added to refs/heads/main by this push:
new de484ad8d [Website] Update QuMat release blogs and community roster
(#1420)
de484ad8d is described below
commit de484ad8d1d1a5c231b2c6977e2308a1bfa42a3b
Author: Jie-Kai Chang <[email protected]>
AuthorDate: Sun Jun 28 20:00:48 2026 +0800
[Website] Update QuMat release blogs and community roster (#1420)
Signed-off-by: 400Ping <[email protected]>
---
docs/blog/2026-02-02-Qumat-0.5.0-Release.md | 6 +-
docs/blog/2026-06-01-Qumat-0.6.0-Release/index.md | 186 ++++++++++++++++------
docs/blog/authors.yml | 2 +-
docs/community/who-we-are.md | 1 +
4 files changed, 138 insertions(+), 57 deletions(-)
diff --git a/docs/blog/2026-02-02-Qumat-0.5.0-Release.md
b/docs/blog/2026-02-02-Qumat-0.5.0-Release.md
index 9a8c2f1e8..722217de1 100644
--- a/docs/blog/2026-02-02-Qumat-0.5.0-Release.md
+++ b/docs/blog/2026-02-02-Qumat-0.5.0-Release.md
@@ -9,7 +9,7 @@ We are excited to announce **QuMat v0.5.0**, the next release
of Mahout's quantu
The main theme of this release is moving QuMat from a circuit abstraction into
a more complete quantum ML development platform. The release introduces the
first public proof-of-concept of **QDP (Quantum Data Plane)**, adds
GPU-accelerated data-to-state encoding, improves QuMat's backend behavior, and
tightens the development workflow around testing, packaging, and documentation.
-Special thanks to everyone who contributed to this release, including PMC
members Jie-Kai Chang, Guan-Ming Chiu, Andrew Musselman, Shannon Quinn (PMC
Chair), and Trevor Grant; Committers Krishna Dave, Hsien-Cheng Huang, and
Kuan-Hao Huang; and contributors Nary Yeh (Union.ai), Cheyu Wu (Synology), Vic
Wen, ChenChen Lai, and the broader Apache Mahout community.
+Special thanks to everyone who contributed to this release. We would like to
thank PMC members Jie-Kai Chang, Guan-Ming Chiu, Andrew Musselman, Shannon
Quinn (PMC Chair), and Trevor Grant. We also thank Committers Hsien-Cheng
Huang, Kuan-Hao Huang and Krishna Dave, along with contributors Nai-Jui Yeh
(Union.ai), Che-Yu Wu (Synology), Vic Wen, ChenChen Lai, and the broader Apache
Mahout community.
<!-- truncate -->
@@ -17,7 +17,7 @@ Special thanks to everyone who contributed to this release,
including PMC member
QuMat v0.5.0 introduces several important changes:
-- **QDP makes its first release appearance.** `qumat v0.5.0` can now install
the QDP extension through the `qumat[qdp]` extra; the native extension itself
is distributed as `qumat-qdp 0.1.0`.
+- **QDP makes its first release appearance.** `qumat 0.5.0` can now install
the QDP extension through the `qumat[qdp]` extra; the native extension itself
is distributed as `qumat-qdp 0.1.0`.
- **GPU state encoding is now part of the QuMat workflow.** QDP prepares
quantum states using Rust and CUDA kernels rather than Python-side
preprocessing loops.
- **Encoded states can move into PyTorch without a host copy.** QDP exposes
DLPack-compatible tensors, making it possible to hand CUDA-backed state vectors
directly to PyTorch.
- **QuMat's circuit APIs are more complete and better validated.** The release
expands gate coverage, improves parameter handling, and fixes backend-specific
behavior across Qiskit, Cirq, and Amazon Braket.
@@ -47,7 +47,7 @@ The high-level architecture is:
[GPU VRAM] CUDA kernels: direct state construction
|
v DLPack
-[Downstream: PyTorch / Qiskit Aer / PennyLane]
+[Downstream: PyTorch / Qiskit / PennyLane]
```
In v0.5.0, QDP supports four encoding families:
diff --git a/docs/blog/2026-06-01-Qumat-0.6.0-Release/index.md
b/docs/blog/2026-06-01-Qumat-0.6.0-Release/index.md
index ed289b418..db4a72a68 100644
--- a/docs/blog/2026-06-01-Qumat-0.6.0-Release/index.md
+++ b/docs/blog/2026-06-01-Qumat-0.6.0-Release/index.md
@@ -1,107 +1,187 @@
---
-title: Introducing Apache Mahout qumat 0.6.0
-date: 2026-06-01
+title: Introducing QuMat v0.6.0
+date: 2026-06-28
tags: [release, qumat, qdp]
-authors: [ryankert, mahout-team]
+authors: [jiekaichang, ryankert, mahout-team]
---
-We're excited to announce the release of **Apache Mahout qumat 0.6.0**,
rolling up 111 pull requests from contributors across the community since
0.5.0. This release brings AMD GPU support to first-class status, closes
encoder parity gaps between CUDA and ROCm, adds new benchmarks for real-world
datasets, and overhauls the documentation site.
+We are excited to announce **QuMat v0.6.0**, the next release of Mahout's
quantum machine learning stack.
-Thank you to everyone who contributed to this release: Ryan Huang, Vic Wen,
Jie-Kai Chang, Guan-Ming (Wesley) Chiu, Tim Hsiung, Kuan-Hao Huang, ChenChen
Lai, Suyash Parmar, Yehfela, Shivam Mittal, Alisha, Hsien-Cheng Huang, Eddie
Tsai, Andrew Musselman, Xin Hao, wdskuki, Trevor Grant, Karanjot Gaidu,
Howardisme, and Han-Wen Tsao.
+The main theme of this release is moving QDP from an NVIDIA-focused proof of
concept into a broader GPU data plane for quantum ML. QuMat v0.6.0 brings AMD
ROCm support to first-class status, closes encoder parity gaps between CUDA and
ROCm, adds realistic benchmark workloads, and refreshes the documentation site
for users and contributors.
+
+Special thanks to everyone who contributed to this release. We would like to
thank PMC members Jie-Kai Chang, Guan-Ming Chiu, Andrew Musselman, Shannon
Quinn (PMC Chair) and Trevor Grant. We also thank Committers Hsien-Cheng Huang,
and Kuan-Hao Huang, along with contributors Tim Hsiung (Microsoft), Vic Wen
(Microsoft), Eddie Tsai (Phind), ChenChen Lai and the broader Apache Mahout
community.
<!-- truncate -->
-## Key Highlights
+## What's New in QuMat v0.6.0
+
+QuMat v0.6.0 rolls up 111 pull requests since v0.5.0 and introduces several
important changes:
+
+- **AMD ROCm support is now first-class.** QDP can run native AMD GPU encoding
paths through hand-written Triton kernels, making ROCm selectable from the same
benchmark workflows as CUDA.
+- **CUDA and ROCm encoder coverage is now aligned.** Phase, IQP, and IQP-Z
encodings now ship on both backends, joining the existing amplitude, angle, and
basis paths.
+- **QDP adds faster zero-copy and GPU-pointer paths.** Float32 batch encoding,
DLPack handoff, async prefetching, and IQP GPU-pointer encoding reduce
host-device round trips in hot loops.
+- **Benchmarks now exercise realistic workloads.** The release adds SVHN IQP
training, SVHN quantum kernel SVM, data-to-state latency, and amplitude
DataLoader throughput benchmarks.
+- **The documentation and contributor workflow are cleaner.** The docs site
now has page frontmatter, self-hosted KaTeX, troubleshooting content, type
hints, review guidelines, and a simpler contributor entry point.
-- **QDP encoding parity and new encodings** — Phase, IQP, and IQP-Z encodings
on both CUDA and AMD ROCm; float32 zero-copy batch paths and GPU-pointer
encoding for the IQP family.
-- **AMD GPU support** — New Mahout-AMD framework with hand-written Triton
kernels running natively on ROCm; AMD is now selectable from all QDP encoding
and throughput benchmarks.
-- **New benchmarks** — SVHN Quantum Kernel SVM, MNIST amplitude encoding, and
IQP latency/throughput benchmarks with PennyLane baselines.
-- **Documentation overhaul** — Frontmatter across all pages, self-hosted
KaTeX, a new troubleshooting guide, and CONTRIBUTING merged into the README for
easier onboarding.
+Let's look at the major pieces in more detail.
-Let's explore these in more detail.
+## QDP Encoding Parity Across GPUs
-## QDP Encoding Parity and New Encodings
+QuMat v0.5.0 introduced QDP as the first public proof of concept for direct
state preparation. The goal was to avoid simulating state-preparation circuits
just to load classical data into a quantum simulator. Instead, QDP constructs
the equivalent state vector directly in GPU memory and exposes it to downstream
tools through tensor-friendly interfaces.
-Prior to 0.6.0, the CUDA and AMD ROCm backends had different encoder coverage
— some encoding paths only existed on one backend, which made benchmarking
apples-to-apples comparisons difficult and limited ROCm's usability in practice.
+QuMat v0.6.0 continues that direction by making the encoding layer more
complete and more portable. Before this release, CUDA and AMD ROCm did not have
the same encoder coverage, which made direct comparisons difficult and limited
ROCm's usefulness in practice.
-In 0.6.0, Phase, IQP, and IQP-Z encodings now ship on both NVIDIA CUDA and AMD
ROCm backends, closing the parity gap with the existing angle and amplitude
paths.
+In v0.6.0, QDP supports the same core encoder set across CUDA and ROCm:
+
+- **Amplitude encoding** for normalized state-vector preparation.
+- **Angle encoding** for one-value-per-qubit rotation inputs.
+- **Basis encoding** for computational basis states.
+- **Phase encoding** for phase-feature preparation.
+- **IQP encoding** for entangled feature maps used in quantum ML workflows.
+- **IQP-Z encoding** for Z-basis IQP-style feature maps.
On the performance side, this release adds:
-- **Float32 zero-copy batch paths** for angle and basis encoders — both
single-sample and batched, in both `qdp-core` (Rust) and the Python bindings —
eliminating host-device copies in hot loops.
-- **GPU-pointer encoding** for the IQP family — pass a CUDA tensor directly
via DLPack and skip the host round-trip entirely.
-- **IQP kernel fusion and grid-stride optimizations** — persistent kernels and
fused encode passes reduce kernel launch overhead.
-- **Async prefetching and native f32 dispatch pipelines** — overlaps I/O with
compute for throughput-bound workloads.
+
+- **Float32 zero-copy batch paths** for angle and basis encoders, including
both single-sample and batched paths in `qdp-core` and the Python bindings.
+- **GPU-pointer encoding** for the IQP family, allowing CUDA tensors to pass
through DLPack without a host round trip.
+- **IQP kernel fusion and grid-stride optimizations** to reduce kernel launch
overhead and improve occupancy.
+- **Async prefetching and native f32 dispatch pipelines** to overlap I/O and
compute for throughput-bound workloads.
*Figure: Data-to-state latency scaling (ms/vector, log scale) for amplitude,
angle, and basis encoding. QDP (orange) achieves orders-of-magnitude lower
latency than both CPU and GPU backends.*
-Install the QDP extra to try these:
+## AMD ROCm Support
+
+AMD support is the largest platform change in QuMat v0.6.0. QDP now includes a
**Triton AMD engine** (`TritonAmdEngine`) with hand-written Triton kernels that
run natively on ROCm. This is Mahout's implementation path, not a wrapper
around PennyLane.
+
+The AMD path covers amplitude, angle, basis, phase, IQP, and IQP-Z encodings.
It is also selectable from the QDP encoding and throughput benchmarks with:
```bash
-pip install "qumat[qdp]==0.6.0" # Linux x86_64 + NVIDIA CUDA
+--qdp-backend amd
```
-## AMD GPU Support
+PennyLane-AMDGPU (`lightning.amdgpu`) is included in benchmark comparisons as
a baseline, but QDP's AMD support does not depend on it.
-0.6.0 makes AMD ROCm a first-class backend via **hand-written Triton kernels**
(`TritonAmdEngine`) that run natively on ROCm without going through PennyLane.
The Triton path covers amplitude, angle, basis, phase, IQP, and IQP-Z encodings
— the same set now available on CUDA — and is selectable from the QDP encoding
and throughput benchmarks via `--qdp-backend amd`.
+This release also adds `Dockerfile.qdp-amd`, making it easier to create a
reproducible ROCm test environment even when the developer machine is not an
AMD GPU host.
-PennyLane-AMDGPU (`lightning.amdgpu`) appears in the throughput benchmark as a
comparison baseline, not as Mahout's implementation path.
+For CUDA users, kernel build targets are now configurable. Instead of
hard-coding a fixed compute capability list, build-time configuration can
target the GPU architectures users actually need, which improves forward
compatibility for newer NVIDIA hardware.
-Docker images for the AMD environment are also included
(`Dockerfile.qdp-amd`), making it easy to spin up a reproducible AMD test
environment without a physical ROCm machine.
+## Acknowledgments
-CUDA kernel build targets are now **configurable** for forward compatibility —
specify the target compute capabilities at build time rather than hard-coding
them, so the wheel stays valid on architectures released after the build.
+The AMD GPU backend in QuMat v0.6.0 was made possible in large part through
collaboration with AMD. A special thank-you goes to **AMD Taiwan** and **Mr.
Jeffrey Huang** for their crucial support in providing our team with
high-performance computing resources.
-## New Benchmarks
+Access to AMD MI300X hardware was instrumental for contributors working on
ROCm support, AMD benchmark coverage, and the broader QDP backend architecture.
Their support helped the Apache Mahout community fully explore and enrich the
quantum computing capabilities now available in this release.
-0.6.0 adds three new benchmarks that cover more realistic workloads than the
synthetic microbenchmarks from earlier releases:
+## Benchmarks for Real QML Workloads
-**SVHN IQP variational classifier** — trains a variational IQP classifier on
the Street View House Numbers dataset (digit 1 vs 7, 200 samples, 200
iterations) on two RTX 3090 Ti GPUs. QDP offloads the IQP encoding step to the
GPU in a single one-shot pass before training begins, keeping the training
backend independent of encoding cost. QDP GPU consistently outperforms
PennyLane GPU at every qubit count — **41 vs 33 samples/s at 4 qubits** and
**20 vs 15 samples/s at 10 qubits** (~1.35×).
+QuMat v0.6.0 adds benchmarks that go beyond synthetic encoder microbenchmarks.
The goal is to measure where QDP matters in full or near-full quantum ML
workflows: loading data, preparing quantum states, and feeding training or
kernel pipelines.
-
+### SVHN IQP Variational Classifier
-**SVHN Quantum Kernel SVM** — runs a precomputed squared inner-product quantum
kernel SVM on SVHN amplitude-encoded features (12 qubits), measuring end-to-end
pipeline time from raw pixels to SVM prediction. This is the first benchmark
that exercises the full pipeline (feature encoding → kernel matrix → SVM
fit/predict) rather than just the encoding step.
+The SVHN IQP benchmark trains a variational IQP classifier on the Street View
House Numbers dataset, using digit 1 versus digit 7 with 200 samples and 200
iterations on two RTX 3090 Ti GPUs.
-**Data-to-State latency** — isolates the full pipeline from CPU RAM to
GPU-ready quantum state at 16 qubits (65,536-dimensional vectors). Mahout (QDP)
delivers **0.160 ms/vector** — **4.5× faster than PennyLane** (0.716 ms), **56×
faster than Qiskit Statevec** (9.030 ms), and **477× faster than Qiskit
Initialize** (76.243 ms). PennyLane and Mahout both target GPU; Qiskit runs on
CPU with Qiskit Init adding full circuit decomposition and transpilation
overhead on top.
+QDP offloads the IQP encoding step to the GPU in a one-shot pass before
training begins. That keeps the training backend independent from encoding cost
and makes the data-preparation bottleneck visible.
-
+In this benchmark, QDP GPU outperforms PennyLane GPU at each tested qubit
count:
-**DataLoader amplitude throughput** — streams 12,800 amplitude-encoded vectors
in batches of 64 at 16 qubits. Mahout (QDP) delivers **6,101 vectors/s** —
**3.8× faster than PennyLane** (1,604 vectors/s).
+- **4 qubits:** 41 samples/s with QDP GPU versus 33 samples/s with PennyLane
GPU.
+- **10 qubits:** 20 samples/s with QDP GPU versus 15 samples/s with PennyLane
GPU.
-
+
+
+### SVHN Quantum Kernel SVM
-All benchmarks support AMD backend selection via `--qdp-backend amd`, so you
can do a direct CUDA-vs-ROCm comparison on the same workload.
+The SVHN Quantum Kernel SVM benchmark runs a precomputed squared inner-product
quantum kernel SVM on SVHN amplitude-encoded features at 12 qubits. It measures
the end-to-end path from raw pixels to SVM prediction:
-## Documentation Overhaul
+```text
+feature encoding -> kernel matrix -> SVM fit/predict
+```
-The docs site received a significant refresh:
+This is important because it exercises the whole pipeline rather than just the
encoding step.
-- **Frontmatter added to every `docs/**/*.md` page** — fixes SEO metadata that
was missing from most pages.
-- **Self-hosted KaTeX** — math rendering now works offline and no longer
depends on the CDN, fixing the "KaTeX not found" error reported by several
contributors.
-- **Troubleshooting guide** — a new guide covers the most common install and
runtime issues, especially around GPU detection and CUDA/ROCm version
mismatches.
-- **CONTRIBUTING merged into the README** — reduces the number of places a new
contributor needs to read to get started.
-- **Type hints added to qumat** — initial pass adding Python type annotations,
laying the groundwork for better IDE support and static analysis.
-- **PR policy and review guidelines** — documents the merge criteria and
review expectations in one place.
+### Data-to-State Latency
-## Other Improvements
+The data-to-state benchmark isolates the path from CPU RAM to a GPU-ready
quantum state at 16 qubits, using 65,536-dimensional vectors.
+
+Mahout QDP reaches **0.160 ms/vector** in this benchmark:
+
+- **4.5x faster than PennyLane** at 0.716 ms/vector.
+- **56x faster than Qiskit Statevector** at 9.030 ms/vector.
+- **477x faster than Qiskit Initialize** at 76.243 ms/vector.
+
+PennyLane and Mahout both target GPU in this comparison. The Qiskit baselines
run on CPU, with Qiskit Initialize also paying circuit decomposition and
transpilation overhead.
+
+
+
+### DataLoader Amplitude Throughput
+
+The DataLoader benchmark streams 12,800 amplitude-encoded vectors in batches
of 64 at 16 qubits.
+
+Mahout QDP reaches **6,101 vectors/s**, compared with **1,604 vectors/s** for
PennyLane. That is a **3.8x throughput improvement** for this data-loading
workload.
-- **Cloud storage support** — the QDP data loader now supports S3 and GCS
remote URLs in addition to local paths, enabling benchmarks and pipelines that
read directly from object storage.
-- **Encoding and Dtype enums** — `Encoding` and `Dtype` are now proper Python
enums rather than bare strings, with static dispatch in the encoder.
-- **Pure-PyTorch reference implementations** — added alongside the CUDA
kernels for correctness comparison and CPU fallback.
-- **Ruff rules expanded** — `E` and most `ANN` rules are now enforced;
document type-checking CI added.
-- **pytest-xdist** — parallel test execution cuts CI wall-clock time on
multi-core machines.
+
+
+All QDP benchmarks can select the AMD backend with `--qdp-backend amd`,
enabling direct CUDA-vs-ROCm comparisons on the same workload.
+
+## Installing QuMat with QDP
-## Getting Started
+The base QuMat package can be installed as usual:
```bash
-# Core package
pip install qumat==0.6.0
+```
+
+To install QuMat with QDP support:
-# With GPU-accelerated QDP extension (Linux x86_64 + NVIDIA CUDA)
+```bash
pip install "qumat[qdp]==0.6.0"
```
-- PyPI: https://pypi.org/project/qumat/0.6.0/
+This installs `qumat 0.6.0` and resolves the QDP native extension package,
`qumat-qdp 0.2.0`. As in v0.5.0, these are intentionally different package
versions: QuMat is the top-level Mahout quantum ML package, while `qumat-qdp`
is the separately published native extension behind the `qdp` extra.
+
+The accelerated QDP path requires a compatible GPU runtime. The CUDA path
targets Linux x86_64 with NVIDIA CUDA. The AMD path targets ROCm through the
Triton AMD engine and is intended for ROCm-capable Linux environments.
+
+## Documentation and Developer Workflow
+
+This release also improves the project around the code. The docs site and
contributor workflow received a broad cleanup:
+
+- **Frontmatter on documentation pages** so Docusaurus can generate cleaner
metadata.
+- **Self-hosted KaTeX** so math rendering works offline and no longer depends
on a CDN.
+- **A troubleshooting guide** for common install, GPU detection, CUDA, and
ROCm issues.
+- **CONTRIBUTING content merged into the README** so new contributors have
fewer entry points to check.
+- **Python type hints in QuMat** as a first step toward better IDE support and
static analysis.
+- **PR policy and review guidelines** documenting merge criteria and review
expectations.
+- **Expanded Ruff rules and type-checking CI** to keep new code more
consistent.
+- **pytest-xdist support** to reduce CI wall-clock time on multi-core runners.
+
+## Other Improvements
+
+QuMat v0.6.0 also includes several smaller but useful improvements:
+
+- **Cloud storage support** for QDP data loading from S3 and GCS remote URLs
in addition to local paths.
+- **Encoding and dtype enums** so Python callers can use structured values
instead of bare strings.
+- **Pure-PyTorch reference implementations** for correctness comparison and
CPU fallback.
+- **Configurable CUDA kernel targets** for better hardware compatibility.
+- **More benchmark controls** for comparing QDP, PennyLane, Qiskit, CUDA, and
ROCm paths.
+
+## What's Next
+
+QuMat v0.6.0 makes QDP a broader GPU data plane rather than a single-vendor
acceleration path. The next steps are to harden the CUDA and ROCm
implementations, expand benchmark coverage, improve packaging for GPU-specific
environments, and continue building end-to-end QML examples that show how QDP
fits into real training and kernel workflows.
+
+The QDP roadmap after this release focuses on:
+
+- More backend validation across NVIDIA and AMD GPU families.
+- Broader benchmark coverage for realistic quantum ML datasets.
+- Better documentation for choosing CUDA, ROCm, and CPU fallback paths.
+- Continued improvements to zero-copy tensor handoff and batched data loading.
+- More complete examples that connect QuMat circuits, QDP encoding, and
downstream training code.
+
+## Links
+
+- Apache downloads: https://downloads.apache.org/mahout/0.6/
+- QuMat PyPI: https://pypi.org/project/qumat/0.6.0/
+- QDP PyPI: https://pypi.org/project/qumat-qdp/0.2.0/
- Release tag: https://github.com/apache/mahout/releases/tag/mahout-qumat-0.6.0
- Docs: https://mahout.apache.org/
diff --git a/docs/blog/authors.yml b/docs/blog/authors.yml
index 199b91ca3..ab99030b0 100644
--- a/docs/blog/authors.yml
+++ b/docs/blog/authors.yml
@@ -12,7 +12,7 @@ jiekaichang:
image_url: /img/jiekaichang.png
ryankert:
- name: Ryan Huang
+ name: Hsien-Cheng Huang
title: Apache Mahout Committer
url: https://github.com/ryankert01
image_url: /img/authors/ryankert.png
diff --git a/docs/community/who-we-are.md b/docs/community/who-we-are.md
index a401523ac..b4675e620 100644
--- a/docs/community/who-we-are.md
+++ b/docs/community/who-we-are.md
@@ -33,6 +33,7 @@ Jacob Alexander Mannix | jmannix@... | Yes |
Jeff Eastman | jeastman@... | No | (Emeritus PMC)
Jie-Kai (Jay) Chang | jiekaichang@... | Yes | @400Ping
Krishna Dave | krishnadave829@...| No | @krishnadave
+Kuan-Hao Huang | r@... | No | @rich7420
Nikolay Sakharnykh | nsakharnykh@... | No |
Paritosh Ranjan | pranjan@... | Yes | @paritoshranjan
Pat Ferrel | pat@... | Yes | (Emeritus PMC) @occam
