⚛️ quantum physics

Qutrit-Based Neural Quantum Kernels for Classification Tasks

This paper extends neural quantum kernels to qutrit-based systems, demonstrating through systematic benchmarking that leveraging the increased degrees of freedom in $\mathrm{SU}(3)$ unitaries significantly improves classification performance over qubit baselines while highlighting the critical impact of parameterization choices on optimization and scalability.

Original authors: Camila Cristiano-Romero, Pablo Rodriguez-Grasa, Mikel Sanz

Published 2026-07-28

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Camila Cristiano-Romero, Pablo Rodriguez-Grasa, Mikel Sanz

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a computer to recognize patterns, like telling the difference between a picture of a sneaker and a sandal. In the world of machine learning, we often use "neural networks," which are like digital brains made of layers of connections. To make these brains smarter, we sometimes give them a special "lens" to look at the data first. This lens is called a "kernel." It transforms the messy, complicated data into a new, cleaner shape where the differences between categories (like shoes vs. sandals) become much easier to spot.

Now, most of these digital brains are built using tiny switches called "qubits," which can be in two states: on or off, like a light switch. But scientists have been wondering: what if we used "qudits" instead? Think of a qudit not as a simple light switch, but as a dimmer switch with many settings, or a dial that can point to three, four, or even more positions at once. This paper explores what happens when we swap the simple two-state switches for these richer, multi-state dials, specifically using a three-state version called a "qutrit." The big question is: does giving our digital brain these extra settings help it learn better, or does it just make things more complicated?

The Experiment: Upgrading the Digital Brain

In this study, the researchers took a specific type of machine learning model called a "Neural Quantum Kernel" (NQK) and upgraded it from using simple qubits to using qutrits. You can think of the NQK as a two-step process. First, they train a small quantum neural network to learn how to best "translate" raw data (like pixel values from an image) into a quantum state. Once this translation is learned, they freeze the settings and use it as a fixed lens to look at new data. This is much more efficient than trying to retrain the whole lens every time.

The team tested this new qutrit-based system on a famous dataset of clothing images called Fashion-MNIST. They asked the computer to perform two tasks: a simple binary task (distinguishing between sandals and sneakers) and a harder three-class task (telling the difference between sandals, sneakers, and ankle boots).

What They Found

The results were quite promising. In almost every scenario they tested, the qutrit-based models performed better than the standard qubit-based models. It seems that having those extra "dial settings" allowed the computer to capture more subtle details in the data.

The researchers also played with two different ways of building these models:

The "Copy-Paste" Method (1-to-n): They trained a single qutrit to do the best job, then copied that same trained behavior across a group of qutrits, linking them together with a fixed connection.
The "Team Effort" Method (n-to-n): They trained a whole group of qutrits together from the start, letting them learn how to work as a team.

Surprisingly, both methods worked very well and achieved similar high scores. The "Team Effort" method had a slight edge in some cases, but the "Copy-Paste" method was almost just as good, suggesting that you don't always need a massive, complex training process to get great results.

The Secret Sauce: How You Turn the Dials

One of the most interesting discoveries was about how the qutrits were programmed. Just like a dimmer switch can be wired in different ways, the mathematical "dials" (called SU(3) parameterizations) used to control the qutrits mattered a lot. The researchers tried three different ways to set these dials:

Geometric: A direct, symmetrical approach.
Euler-angles: A step-by-step rotation method.
Givens-rotations: A method that focuses on swapping specific pairs of states.

They found that the Geometric approach was the clear winner. It consistently gave the best results and improved the most as they added more data features. The other two methods worked, but they didn't perform as well or improve as smoothly. This suggests that the way you choose to "wire" your quantum dials is just as important as the dials themselves.

Scaling Up and Saturation

The team also checked if making the system bigger (adding more qutrits) or feeding it more information (adding more features) always helped. The answer was: "It depends."

Adding Qutrits: Generally, adding more qutrits improved the accuracy, but only up to a point. Around 4 qutrits, the performance seemed to hit a ceiling, getting only tiny improvements after that.
Adding Features: Similarly, feeding the model more data features helped, but again, there was a limit. After a certain number of features (around 5 or 6 for some datasets), adding more didn't make the model smarter; it just stopped getting better.

The Bottom Line

In these ideal, noise-free computer simulations, the qutrit-based Neural Quantum Kernels proved to be a powerful upgrade over the traditional qubit versions. They handled complex, multi-category tasks naturally and outperformed their simpler cousins. However, the paper also warns that this isn't a magic bullet. The benefits depend heavily on the specific dataset, the number of qutrits used, and, crucially, the specific mathematical method chosen to program the qutrits.

While these results are exciting, they are currently based on perfect simulations. The researchers note that real-world quantum computers are noisy and imperfect, so the next step is to see if these qutrit advantages hold up when the lights flicker and the signals get messy. For now, though, the study suggests that moving from two-state switches to three-state dials is a promising path for making quantum machine learning smarter and more versatile.

Technical Summary: Qutrit-Based Neural Quantum Kernels for Classification Tasks

Problem Statement
Quantum Machine Learning (QML) has largely focused on qubit-based architectures (two-level systems). While parameterized quantum circuits (PQCs) and data re-uploading models have shown promise, they face challenges regarding trainability (e.g., barren plateaus) and expressivity. Furthermore, standard qubit embeddings are structurally limited by the $SU(2)$ algebra, which offers only three independent parameters per subsystem, restricting the number of features that can be encoded locally. Additionally, qubit-based models often require complex readout strategies for multiclass classification. The paper addresses the need to extend Neural Quantum Kernels (NQKs) to qudits ( $d$ -level systems), specifically qutrits ( $d=3$ ), to leverage richer local degrees of freedom, enable natural multiclass interfaces, and potentially improve feature encoding efficiency.

Methodology
The authors extend the Neural Quantum Kernel framework to qutrits. NQKs operate in two stages: (1) pretraining a Quantum Neural Network (QNN) via supervised learning to find an optimal task-adapted embedding, and (2) freezing these parameters to define a quantum kernel, which is then used with a classical Support Vector Machine (SVM).

Key methodological components include:

Architecture: The study utilizes a data re-uploading architecture where classical features are encoded repeatedly and interleaved with trainable variational blocks.
Scalable Pretraining: To mitigate optimization difficulties, the authors employ a "progressive growth" strategy. Models are trained starting from a single qutrit, and the learned parameters are used to warm-start larger systems (2, 3, 4 qutrits) by initializing new parameters (including entangling gates) to zero.
Kernel Constructions: Two approaches are compared:
- $n$ -to- $n$ : An $n$ -qutrit QNN is trained directly, and its full embedding is reused.
- 1-to- $n$ : A single-qutrit QNN is trained, and its learned unitary is replicated across an $n$ -qutrit register, interleaved with fixed entangling operations.
Qutrit Specifics:
- Parameterizations: The study investigates three distinct parameterizations for single-qutrit $SU(3)$ unitaries: Geometric (Lie-algebra exponential), Euler-angles decomposition, and Givens-rotations form.
- Entangling Primitives: The 1-to- $n$ construction uses fixed SUM (generalized CNOT) gates, while the $n$ -to- $n$ construction uses trainable controlled-unitary gates arranged in a nearest-neighbor pattern.
- Feature Budget: The number of encoded features ( $p$ ) is mapped to the parameters of the $SU(3)$ generators. For $d=3$ , up to 8 features can be encoded per subsystem.
Tasks and Datasets: The models are evaluated on binary and three-class classification tasks using four benchmark datasets: Fashion-MNIST, HAR (Human Activity Recognition), MAGIC Gamma Telescope, and Covertype.

Key Contributions

Extension to Qudits: The paper generalizes the NQK framework from qubits to qutrits, introducing new design choices regarding local dimension, $SU(3)$ parameterization, and feature budget allocation.
Systematic Design Analysis: It provides a comprehensive ablation study on how specific architectural choices (system size $n$ , feature budget $p$ , kernel construction type, and $SU(3)$ parameterization) impact performance.
Parameterization Impact: The work demonstrates that the choice of $SU(3)$ parameterization is critical. The Geometric (Lie-algebra exponential) parameterization consistently outperforms Euler-angles and Givens-rotations in terms of optimization dynamics (gradient norms, training loss) and final accuracy.
Performance Validation: The study empirically shows that qutrit-based NQKs generally outperform their corresponding QNN baselines (measurement-based variational classifiers) across various system sizes and feature budgets.

Results

NQK vs. QNN: Across nearly all settings on the Fashion-MNIST dataset, qutrit NQKs (both 1-to- $n$ and $n$ -to- $n$ ) achieved higher test accuracy than the corresponding QNN baselines. This supports the hypothesis that learning a task-adapted embedding and freezing it for kernel construction yields a stronger classifier than the variational model alone.
Scaling Trends:
- System Size ( $n$ ): Increasing the number of qutrits generally improved performance, though gains tended to saturate (e.g., around $n=4$ for Fashion-MNIST).
- Feature Budget ( $p$ ): Increasing the number of encoded features generally improved accuracy, but the relationship was dataset-dependent. For some datasets (e.g., Covertype), performance was non-monotonic, peaking at intermediate feature counts.
- Parameterization: The Geometric parameterization consistently yielded the best results. The Euler-angles and Givens-rotations parameterizations showed lower performance and different scaling behaviors, highlighting that the structural role of parameters (e.g., phases vs. rotations) affects learning.
Comparison to Classical Baselines: When compared to a classical RBF-SVM using identical preprocessing, the qutrit NQKs remained competitive. While the classical SVM often achieved slightly higher mean accuracy (within statistical uncertainty), the quantum models approached this performance, with the 4-to-4 NQK slightly exceeding the classical baseline in the Covertype three-class task.
1-to- $n$ vs. $n$ -to- $n$ : At moderate system sizes ( $n=4$ ), both constructions achieved comparable accuracy, suggesting that the simpler 1-to- $n$ strategy (replicating a single-qutrit map) can be competitive with the more flexible $n$ -to- $n$ approach.

Significance and Claims
The paper claims that extending NQKs to qudits is not merely a generalization but a promising avenue for exploiting complex data structures in QML. The primary significance lies in demonstrating that:

Richer Embeddings: The increased local degrees of freedom in $SU(3)$ allow for richer feature embeddings and more efficient parameter usage compared to $SU(2)$.
Multiclass Suitability: Qutrits provide a natural interface for multiclass classification via the computational basis, avoiding the need for complex encoding schemes required by qubits.
Design Sensitivity: The performance of qudit-based models is highly sensitive to design choices, particularly the parameterization of unitaries. The study emphasizes that a "design-driven" approach is necessary, where the selection of building blocks (parameterization, entangling strategy) is as crucial as scaling resources.
Practical Viability: Despite being tested under ideal (noiseless) simulations, the results suggest that qudit NQKs can compete with strong classical kernel methods, provided that architectural choices are optimized.

The authors remain modest regarding their claims, noting that results are limited to ideal simulations and small system sizes due to computational costs. They acknowledge that the benefits of scaling are dataset-dependent and that the interaction between feature encoding and parameterization requires further systematic characterization. Future work is suggested to explore noise robustness and higher-dimensional qudits ( $d > 3$ ).

Technical Summary: Qutrit-Based Neural Quantum Kernels for Classification Tasks

More like this