mahout.apache.org

Apache Mahout is an Apache Software Foundation project that builds an environment for quickly creating scalable, performant machine learning applications. Its current work centers on quantum machine learning in Python, delivered through two components: Qumat, a backend-agnostic quantum circuit library, and QDP (Quantum Data Plane), a GPU-accelerated engine that encodes classical data into quantum states. The earlier Mahout Classic codebase (Samsara and MapReduce) is in maintenance mode, so new work should target Qumat and QDP.

The two current components

Qumat: write a circuit once, run it on three backends

Qumat is a high-level Python library for quantum computing. You build a circuit from standard and parameterized gates, then execute it on Qiskit, Cirq, or Amazon Braket through one unified API, on simulators or real quantum hardware.

The practical benefit is portability: a variational circuit you prototype on a simulator can be pointed at a different backend without a rewrite, which matters when you are comparing hardware or avoiding lock-in to one SDK.

QDP: remove the data-loading bottleneck

QDP targets a specific cost in quantum machine learning: preparing classical data as quantum states. Instead of simulating a state-preparation circuit, it constructs the state vector directly in GPU memory and hands it to your training or kernel pipeline.

• Six encodings — amplitude, angle, basis, phase, IQP, and IQP-Z, with the same coverage on every GPU backend.
• NVIDIA CUDA and AMD ROCm — native CUDA kernels and hand-written Triton kernels for ROCm, selectable from the same API.
• Zero-copy interop — DLPack handoff to and from PyTorch, NumPy, and TensorFlow, plus GPU-pointer paths that skip the host round trip.
• Benchmarked on real workloads — SVHN IQP training, quantum kernel SVM, and data-to-state latency benchmarks ship with the project.

For example, if you are training an IQP-style model on image data, the encoding step is where classical-to-quantum conversion usually dominates wall-clock time; QDP's approach is aimed at that step rather than at the circuit execution itself.

Which version should you use?

• Starting new quantum ML work in Python: use Qumat, and add QDP if your pipeline is bottlenecked on encoding classical data into quantum states and you have a supported GPU (CUDA or ROCm).
• Maintaining an existing Mahout Classic deployment (Samsara/MapReduce): it remains available but is in maintenance mode; the community's active development is on Qumat and QDP, so plan migrations accordingly.

Release status and where to start

Qumat 0.6 is the current release noted on the project site. It adds first-class AMD ROCm support, six QDP encodings with parity across CUDA and ROCm, and faster zero-copy GPU paths. The site links release notes and a download path for 0.6.

To evaluate the project, the most direct route is the Qumat install (pip install qumat on Python 3.10+) followed by the shipped benchmarks, which let you measure encoding latency and kernel performance on your own hardware before committing to a design.

QDP (Quantum Data Plane) is Apache Mahout's GPU-accelerated data plane that removes the data-loading bottleneck in quantum machine learning. Instead of simulating a state-preparation circuit, it constructs the quantum state vector directly in GPU memory and hands it to your training or kernel pipeline. It is the right tool when your bottleneck is getting classical data into quantum states at scale, and you want to avoid the cost of circuit-based state preparation.

The problem it solves

Quantum machine learning pipelines need classical data (images, vectors, kernel inputs) encoded as quantum states. The conventional route is to build a state-preparation circuit and simulate it. That simulation is the bottleneck: it adds latency before any training or kernel computation begins, and it scales poorly as data volume grows.

QDP takes a different route. Rather than simulating a circuit, it constructs the state vector directly in GPU memory. The encoded state is then passed to your training or kernel pipeline, so the data-loading step no longer dominates the pipeline.

How it works

• Direct state construction: QDP builds the state vector in GPU memory instead of simulating a state-preparation circuit.
• Six encodings: amplitude, angle, basis, phase, IQP, and IQP-Z, with the same coverage on every GPU backend.
• GPU backends: native CUDA kernels for NVIDIA and hand-written Triton kernels for AMD ROCm, selectable from the same API.
• Zero-copy interop: DLPack handoff to and from PyTorch, NumPy, and TensorFlow, plus GPU-pointer paths that skip the host round trip.

The zero-copy path matters in practice: if your data already lives on the GPU in a PyTorch or TensorFlow tensor, QDP can consume it without copying back to host memory and out again.

When to use QDP

Qumat and QDP are complementary: Qumat is the high-level Python library for building and executing circuits across backends, while QDP handles the data-encoding layer beneath it. Qumat requires Python 3.10+ and installs from PyPI with pip install qumat.

Verifying it in your pipeline

The project ships benchmarks on real workloads — SVHN IQP training, quantum kernel SVM, and data-to-state latency benchmarks — so you can compare encoding latency against a circuit-simulation baseline before committing. A practical check: time your current state-preparation step, then time the same encoding through QDP on your target GPU backend; the difference is the bottleneck QDP removes.

Current status

Qumat 0.6 is the current release, adding first-class AMD ROCm support, six QDP encodings with parity across CUDA and ROCm, and faster zero-copy GPU paths. The earlier Mahout Classic codebase (Samsara and MapReduce) is in maintenance mode; the community's active work is on Qumat and QDP.

Install Qumat with pip install qumat on Python 3.10 or newer, then write a circuit once and run it on Qiskit, Cirq, or Amazon Braket by changing a config value rather than your circuit code. Version 0.6 adds first-class AMD ROCm support, six QDP encodings with parity across CUDA and ROCm, and faster zero-copy GPU paths. This guide covers the prerequisites, the install-and-run steps, what 0.6 changed, and where to find release notes and project resources.

What Apache Mahout is now

Apache Mahout builds an environment for quickly creating scalable, performant machine learning applications. Today that work centers on quantum machine learning in Python, with two components:

• Qumat — a high-level Python library for quantum computing. You build a circuit with standard and parameterized gates, then execute it on Qiskit, Cirq, or Amazon Braket through one unified API, on simulators or real quantum hardware.
• QDP (Quantum Data Plane) — a GPU-accelerated data plane that turns classical data into quantum states without simulating state-preparation circuits.

The earlier Mahout Classic codebase (Samsara and MapReduce) is in maintenance mode; the community's current work is on Qumat and QDP.

Before you start

You do not need to install a separate quantum SDK to write circuits — Qumat provides the unified API — but you do need access to whichever backend you intend to execute on.

Step 1: Install Qumat

pip install qumat

Expected result: the qumat package is available in your Python 3.10+ environment. If pip resolves an older release, pin the version explicitly to get 0.6 features.

Step 2: Build a circuit with standard and parameterized gates

Qumat supports Hadamard, Pauli, CNOT, Toffoli, SWAP, and rotation gates, with parameter binding for variational circuits. The workflow is: define gates and parameters once, then reuse the same circuit definition across backends.

Input: a gate list and, for variational circuits, parameter values. Action: construct the circuit through the Qumat API. Expected result: a backend-agnostic circuit object you can hand to any supported backend.

Step 3: Switch backends by config, not code

The core promise of Qumat is "one API, three backends." To move from Qiskit to Cirq or Amazon Braket, change a config value — your circuit code stays the same. This is the main reason to choose Qumat over writing directly against a single SDK: portability across simulators and hardware without a rewrite.

Step 4: Use QDP when data loading is the bottleneck

QDP addresses the data-loading bottleneck in quantum machine learning. Instead of simulating a state-preparation circuit, it constructs the state vector directly in GPU memory and hands it to your training or kernel pipeline.

• Six encodings: amplitude, angle, basis, phase, IQP, and IQP-Z — with the same coverage on every GPU backend.
• NVIDIA CUDA and AMD ROCm: native CUDA kernels and hand-written Triton kernels for ROCm, selectable from the same API.
• Zero-copy interop: DLPack handoff to and from PyTorch, NumPy, and TensorFlow, plus GPU-pointer paths that skip the host round trip.
• Benchmarked on real workloads: SVHN IQP training, quantum kernel SVM, and data-to-state latency benchmarks ship with the project.

Use QDP when your pipeline spends meaningful time preparing quantum states from classical data; use Qumat alone when you mainly need portable circuit construction and execution.

What's new in Qumat 0.6

• First-class AMD ROCm support.
• Six QDP encodings with parity across CUDA and ROCm.
• Faster zero-copy GPU paths.

Release notes and the download link are on the project site (mahout.apache.org), alongside the "Get Qumat 0.6" entry point.

Verify your setup

A quick check that the install and backend selection work: build a small circuit with a Hadamard and a CNOT, run it on a simulator backend, and confirm you get the expected output distribution. Then change the backend config value and rerun the same circuit — if it executes without code changes, your setup matches Qumat's intended workflow.

Common snags

• Python too old: Qumat requires 3.10+; an older interpreter will fail at install or import.
• Assuming a backend is bundled: backend access (including real hardware) is separate from the Qumat install.
• Reaching for Mahout Classic: Samsara/MapReduce material is maintenance mode; new work should target Qumat and QDP.
• GPU expectations: CUDA and ROCm paths are for QDP's data plane, not a requirement for basic Qumat circuit work.

Where to go next

The project is under the Apache Software Foundation and licensed under the Apache License. For community context, the project lists talks including "Accelerating Quantum Machine Learning: Building a GPU-Accelerated Data Plane in Apache Mahout" (Community Over Code Asia 2026), "Introducing Qumat!" (FOSDEM 2025), and "QuMat: Apache Mahout's Quantum Computing Interface" (FOSSY 2024). Start at mahout.apache.org for the Qumat and QDP pages, release notes, and download links.

Qumat and QDP solve different problems in the same quantum machine learning pipeline. Qumat is a Python library for building quantum circuits once and running them on Qiskit, Cirq, or Amazon Braket through a single API. QDP (Quantum Data Plane) is a GPU-accelerated engine that turns classical data into quantum state vectors directly in GPU memory, skipping state-preparation circuit simulation. Choose Qumat when your bottleneck is circuit portability across backends; choose QDP when your bottleneck is loading classical data into quantum form. They are designed to be used together, not as alternatives.

The core difference in one table

What Qumat does

Qumat is a high-level Python library for quantum computing. You build a circuit with standard gates (Hadamard, Pauli, CNOT, Toffoli, SWAP) and rotation gates with parameter binding for variational circuits, then execute it on Qiskit, Cirq, or Amazon Braket. The key property is portability: switching backends is a config change, not a rewrite of your circuit code. It runs on simulators or real quantum hardware.

Use Qumat when:

• You want to prototype a variational circuit and compare results across more than one backend.
• You need to move from a simulator to real hardware without changing circuit definitions.
• Your team standardizes on Python and wants a pip-installable dependency (pip install qumat, Python 3.10+).

What QDP does

QDP removes the data-loading bottleneck in quantum machine learning. Instead of simulating a state-preparation circuit to encode classical data, it constructs the state vector directly in GPU memory and hands it to your training or kernel pipeline. It supports six encodings — amplitude, angle, basis, phase, IQP, and IQP-Z — with the same coverage on every GPU backend. Native CUDA kernels and hand-written Triton kernels for ROCm are selectable from the same API, and zero-copy DLPack paths connect to PyTorch, NumPy, and TensorFlow without a host round trip.

Use QDP when:

• Your pipeline spends significant time encoding classical data (images, feature vectors) into quantum states.
• You train on NVIDIA or AMD GPUs and want the same encoding coverage on both.
• You need the encoded state to flow into PyTorch or NumPy tensors without copying through host memory.

How they fit together

A quantum ML workflow typically has two stages: prepare data as quantum states, then run circuits over them. QDP handles the first stage on GPU; Qumat handles the second across backends. For example, an IQP-encoded image dataset produced by QDP can feed a variational circuit defined and executed through Qumat. The project ships benchmarks for exactly this kind of workload, including SVHN IQP training, quantum kernel SVM, and data-to-state latency, so you can check whether the encoding stage is your actual bottleneck before adopting QDP.

Which to start with

Start with Qumat if your immediate need is circuit portability or you are evaluating multiple backends. Start with QDP if profiling shows data encoding dominates your training time, or if you already have a circuit stack and only need faster state preparation. If you are building a full pipeline from scratch, Qumat is the natural entry point because circuit code is where most workflows begin; add QDP once encoding latency becomes measurable.

Practical notes

• Qumat 0.6 added first-class AMD ROCm support, six QDP encodings with parity across CUDA and ROCm, and faster zero-copy GPU paths.
• The earlier Mahout Classic codebase (Samsara and MapReduce) is in maintenance mode; current community work is on Qumat and QDP.
• Both components are Apache-licensed and part of the Apache Software Foundation.

Qumat is Apache Mahout's high-level Python library for writing quantum circuits once and running them on Qiskit, Cirq, or Amazon Braket through a single unified API. You switch backends by changing a config value rather than rewriting circuit code, and the same circuit can target simulators or real quantum hardware. It requires Python 3.10+ and installs from PyPI with pip install qumat.

What Qumat does

Qumat sits above the backend SDKs. You build a circuit from standard and parameterized gates, then execute it on whichever backend your configuration selects. The library's current release, Qumat 0.6, adds first-class AMD ROCm support and faster zero-copy GPU paths, according to the project site.

Supported backends

The key design point: the circuit definition stays the same across all three. Only the backend configuration changes.

Supported gates

Qumat covers both fixed and parameterized gates:

• Standard gates: Hadamard, Pauli, CNOT, Toffoli, SWAP
• Rotation gates: with parameter binding for variational circuits

Parameter binding matters for variational algorithms, where gate angles are tuned during training rather than fixed at circuit construction. You define the circuit structure once and bind new parameter values per run.

How the backend switch works in practice

The workflow is:

1. Install: pip install qumat on Python 3.10 or newer.
2. Build the circuit: compose standard and parameterized gates into a circuit object.
3. Set the backend: choose Qiskit, Cirq, or Amazon Braket in configuration.
4. Execute: run on a simulator or submit to real hardware.

The expected result is the same circuit executed on your chosen backend without edits to the circuit code. The common pitfall is assuming backend parity is automatic for every feature — gate coverage and hardware availability differ by provider, so verify your specific gate set and target device before relying on a straight swap.

Where Qumat fits in Mahout today

Mahout's current focus is quantum machine learning in Python, built on two components: Qumat for circuits and QDP (Quantum Data Plane) for data encoding. QDP is a separate, GPU-accelerated engine that constructs quantum state vectors directly in GPU memory instead of simulating state-preparation circuits, with six encodings (amplitude, angle, basis, phase, IQP, IQP-Z) across NVIDIA CUDA and AMD ROCm.

The earlier Mahout Classic codebase (Samsara and MapReduce) is in maintenance mode; the community's active work is on Qumat and QDP. If you arrived at mahout.apache.org expecting the classic scalable-ML stack, note that the project has moved toward quantum ML.

When Qumat is the right choice

Choose Qumat if you want to prototype variational or gate-based circuits and compare behavior across Qiskit, Cirq, and Braket without maintaining three codebases. It is less suitable if you need deep provider-specific features that the unified API does not expose, or if you are maintaining legacy Mahout Classic workloads — those remain in maintenance mode rather than active development.