⚛️ quantum physics

Divide et impera: hybrid multinomial classifiers from quantum binary models

This paper investigates hybrid strategies for combining quantum binary models into multinomial classifiers, demonstrating that a binary decision tree approach offers a cost-effective solution with logarithmic overhead while maintaining accuracy comparable to other methods like one-vs-one and one-vs-rest.

Original authors: Simone Roncallo, Angela Rosy Morgillo, Seth Lloyd, Chiara Macchiavello, Lorenzo Maccone

Published 2026-04-10

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Simone Roncallo, Angela Rosy Morgillo, Seth Lloyd, Chiara Macchiavello, Lorenzo Maccone

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 the head of a very special, high-tech hiring committee. Your job is to look at a stack of resumes and decide which of 10 different job roles a candidate fits best.

In the world of classical computers, you might hire a team of 10 experts, where each expert is only good at spotting one specific job. Or, you might hire 45 experts, where every single pair of jobs has its own specialist to compare them. This works, but it's slow and expensive because you have to listen to everyone.

This paper is about a team of Quantum Experts (using light and lasers instead of silicon chips) who are incredibly fast at making binary decisions (Yes/No, A or B). The problem is: How do you use these super-fast "Yes/No" experts to choose between 10 different options without slowing them down?

The authors tried three different strategies to solve this puzzle. Here is the breakdown using simple analogies:

The Three Strategies

1. The "Round-Robin Tournament" (One-vs-One)

The Idea: Imagine a boxing tournament. To find the best fighter among 10 people, you have every single person fight every other person.
The Math: If you have 10 classes, you need 45 different fights (classifiers).
The Result: It's very accurate, but it's a logistical nightmare. You have to run 45 separate quantum experiments just to pick one winner. The "cost" grows very fast (quadratically) as you add more classes.

2. The "All-Star Game" (One-vs-Rest)

The Idea: Imagine you have 10 judges. Judge #1 asks, "Is this candidate a Chef?" (Yes/No). Judge #2 asks, "Is this candidate a Doctor?" (Yes/No). And so on.
The Math: You need 10 judges.
The Result: This is better than the tournament. You only run 10 experiments. However, you still have to ask everyone their question and then tally the votes. The cost grows linearly (10, 20, 30...).

3. The "Decision Tree" (The Funnel)

The Idea: This is the paper's favorite solution. Imagine a giant, magical funnel or a "Choose Your Own Adventure" book.
- Step 1: You ask one question: "Is the candidate in the 'Creative' group or the 'Technical' group?" (A binary Yes/No).
- Step 2: Based on the answer, you go down a specific path. You don't ask the other 9 questions. You only ask the next relevant question for that specific path.
- Step 3: You keep splitting the group in half until you are left with just one job title.
The Math: Instead of asking 10 or 45 questions, you only need to ask about 3 or 4 questions (because $2^3 = 8$ and $2^4 = 16$ ).
The Result: This is the winner. It is incredibly efficient. Even if you have 1,000 job roles, you only need to ask about 10 questions to find the right one.

The Big Discovery

The authors ran simulations using real-world data (like recognizing handwritten numbers, clothing items, and pictures of cats/dogs). Here is what they found:

Accuracy is the Same: Surprisingly, the "Decision Tree" method was just as accurate as the "Tournament" or "All-Star" methods. You didn't lose any quality by taking the shortcut.
Speed is Everything: The Decision Tree is the only method that keeps the Quantum Advantage.
- The Quantum computer is already super fast at the individual "Yes/No" question.
- If you use the Tournament method, you run so many questions that you cancel out the speed advantage.
- If you use the Decision Tree, you ask so few questions that the quantum speed remains exponential. It's like having a Ferrari (the quantum model) but driving it through a traffic jam (the other methods) vs. driving it on an empty highway (the Decision Tree).

The "Tree" Problem

The only catch with the Decision Tree is that it's a sequential process. You have to ask Question 1, wait for the answer, then ask Question 2. You can't ask them all at once like the other methods.

However, the authors found that even though the tree has to be built carefully, the specific shape of the tree didn't matter much. Whether you split the classes "A vs B" first or "C vs D" first, the final accuracy was roughly the same. This means you don't need a genius architect to design the tree; a random one works fine.

The Conclusion

To make a quantum computer good at sorting things into many categories (not just two), you shouldn't just throw more quantum computers at the problem. Instead, you should organize them into a Decision Tree.

This approach allows you to keep the "magic" of quantum speed (exponential speedup) while solving complex, real-world problems like identifying hundreds of different species of penguins or types of clothing, without getting bogged down in computational overhead.

In short: Don't ask everyone everything. Ask the right question, go down the right path, and let the quantum speed do the rest.

1. Problem Statement

The paper addresses a fundamental challenge in Quantum Machine Learning (QML): extending inherently binary quantum classifiers to handle multinomial (multi-class) classification tasks without compromising the potential quantum advantage.

Context: Many quantum classifiers (e.g., variational quantum classifiers, SWAP-test classifiers) are designed to output a single binary decision (0 or 1) based on a probability score.
The Bottleneck: Directly sampling from a multinomial distribution of $K$ classes typically introduces a computational overhead of at least $O(K)$ , which mimics the cost of a classical output layer with $K$ neurons. This overhead threatens to negate the exponential speedup quantum models offer regarding input size.
Goal: To construct a multinomial classifier using a collection of binary quantum models via post-processing strategies, minimizing computational overhead while preserving the quantum advantage.

2. Methodology

The authors propose a hybrid quantum-classical approach. They utilize a specific quantum optical classifier based on the Hong-Ou-Mandel (HOM) effect (as introduced in their previous work [30, 31]) and combine multiple instances of this binary model using three standard decomposition strategies:

One-vs-One (OvO):
- Trains a separate binary classifier for every pair of classes $(k, k')$ .
- Overhead: Requires $K(K-1)/2$ classifiers.
- Complexity: $O(K^2)$ at inference.
- Mechanism: Parallel evaluation with majority voting.
One-vs-Rest (OvR):
- Trains one binary classifier per class $k$ to distinguish class $k$ from all others.
- Overhead: Requires $K$ classifiers.
- Complexity: $O(K)$ at inference.
- Mechanism: Parallel evaluation; the class with the highest score is selected.
Binary Decision Tree (DT):
- Recursively splits the set of $K$ classes into binary partitions, organizing them into a hierarchical tree structure.
- Overhead: Requires traversing the tree from root to leaf.
- Complexity: $O(\log_2 K)$ at inference.
- Mechanism: Sequential evaluation. At each node, the input is routed left or right based on the binary classifier's output until a leaf (single class) is reached.

The Quantum Model:

Architecture: A shallow neural network implemented optically using photon spatial modes and HOM interference.
Equivalence: Mathematically equivalent to a classical shallow network with $M$ hidden neurons (square modulus activation) and a linear output layer (sigmoid activation).
Constraints: Weights are constrained (L2-normalized for hidden layers, L1-normalized for output) due to the physical encoding of parameters in photon states.
Speedup: Provides a superexponential speedup, classifying $N$ features with constant $O(1)$ computational and optical resources.

Experimental Setup:

Datasets: MNIST, Fashion-MNIST, and CIFAR-10.
Baselines: A classical baseline was constructed using the exact same decomposition strategies (OvO, OvR, DT) but with a more expressive architecture (deep ReLU networks, no normalization constraints) to ensure that any performance gaps were due to the post-processing strategy, not the model's expressivity.
Metrics: Average accuracy across $K$ classes.

3. Key Contributions

Hybrid Framework: Demonstrated a viable method to convert binary quantum models into multinomial classifiers without modifying the underlying quantum hardware architecture.
Overhead Analysis: Provided a rigorous comparison of computational overheads ( $O(K^2)$ , $O(K)$ , and $O(\log_2 K)$ ) for different decomposition strategies in a quantum context.
Decision Tree Optimization: Identified the Binary Decision Tree (DT) as the most cost-effective strategy, preserving the exponential speedup of the quantum model by limiting inference overhead to logarithmic complexity.
Empirical Validation: Showed that the choice of decomposition strategy has a negligible impact on accuracy, meaning the most efficient strategy (DT) can be chosen without sacrificing performance.

4. Results

The authors benchmarked the methods on 4-class and 6-class subsets of the datasets, as well as varying $K$ from 2 to 10 on CIFAR-10.

Accuracy Comparison:
- Quantum and classical models achieved comparable accuracy across all strategies (OvO, OvR, DT).
- The classical models showed a slight, consistent advantage (e.g., ~1-2% higher on MNIST), attributed to the normalization constraints on the quantum model which limit its expressivity.
- Strategy Independence: The choice of OvO, OvR, or DT did not significantly alter the final accuracy.
Scalability (Number of Classes $K$ ):
- As $K$ increased (up to 10), accuracy decreased monotonically for both quantum and classical models.
- The accuracy gap between the models and random guessing remained significant (Quantum: ~23–30% above random; Classical: ~28–35% above random).
- This suggests the bottleneck is the post-processing strategy itself, not the specific quantum architecture.
Decision Tree Robustness:
- Tests varying the tree topology and training seeds showed that neither the specific tree structure nor training variance significantly impacted accuracy, confirming that the DT approach is robust.

5. Significance and Conclusion

Preserving Quantum Advantage: The study proves that it is possible to build a multinomial quantum classifier with exponential speedup relative to input size. By using the Decision Tree approach, the overhead is reduced to $O(\log_2 K)$ , which is negligible compared to the constant $O(1)$ cost of the underlying HOM classifier.
Cost-Effectiveness: The Decision Tree is the optimal choice for hybrid quantum classifiers, offering the lowest computational overhead while maintaining accuracy levels similar to parallel methods (OvO/OvR).
Future Directions: The authors suggest that the observed accuracy degradation with increasing $K$ is due to the "agnostic" nature of the post-processing (treating classes independently). Future improvements may require joint training of the decision tree structure with the quantum models to better exploit correlations between classes, rather than treating the tree as a mere post-processing step.

In summary, the paper provides a practical roadmap for scaling quantum binary classifiers to real-world multi-class problems, identifying the Binary Decision Tree as the critical component for maintaining quantum efficiency.