⚛️ quantum physics

Hardware-Aware Design and Layout Selection in Quantum Reservoir Computing for Insurance Claims Forecasting

This paper demonstrates that small, hardware-aware six-qubit quantum reservoir computing models can achieve competitive accuracy in forecasting motor-insurance claims, comparable to classical baselines, while effectively mitigating performance degradation when transferred from ideal simulations to noisy IBM quantum hardware through optimized layout selection.

Original author: Renáta Rusnáková, Eugen Šlapak, Gaurav K. Pandey, Juraj Gazda

Published 2026-11-04

📖 5 min read🧠 Deep dive

CC BY 4.0

Original author: Renáta Rusnáková, Eugen Šlapak, Gaurav K. Pandey, Juraj Gazda

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 author. For technical accuracy, refer to the original paper. Read full disclaimer

In the world of modern computing, there is a growing desire to use machines that operate on the strange rules of quantum physics to solve problems that are too difficult for today's supercomputers. These new machines, often called quantum processors, are still in their early stages. They are small, fragile, and prone to errors because their components lose their special quantum properties very quickly. To make these machines useful before they are perfect, scientists are developing a technique called quantum reservoir computing. Instead of trying to teach the quantum machine every single step of a solution, which is difficult and error-prone, researchers set up a fixed, complex system that naturally processes information as it flows through. They then simply train a standard computer to read the results coming out of this quantum system. This approach is attractive because it avoids the need for deep, complicated training that often fails on noisy hardware, shifting the challenge instead to finding the right physical setup to run the experiment.

A team of researchers set out to test whether this method could actually work for a very practical, real-world problem: predicting how many insurance claims a car insurance company would receive the next day. This is a critical task for insurers, who must prepare for daily fluctuations in costs. The researchers used a small quantum processor with six qubits, the basic units of quantum information, to act as their forecasting engine. They fed the machine data about the number of active car policies, the day of the week, whether it was a holiday, and the number of claims from the previous day. The goal was to see if a tiny, noisy quantum system could predict the future number of claims as accurately as the best traditional computer models, and more importantly, if the predictions made on a real, imperfect machine would match the predictions made in a perfect computer simulation.

The team began by designing five different versions of their quantum system, each with a slightly different internal structure to see which one remembered past information best. They tested these designs in a perfect, noise-free simulation first. In this ideal environment, the quantum models performed competitively, producing errors that were statistically comparable to several classical recurrent and reservoir baselines, though the standard ridge regression model remained the most accurate overall. The quantum systems were able to track the daily ups and downs of claim counts just as well as many established methods, proving that even a small quantum system could handle this type of complex, time-based data.

However, the true test came when the researchers moved from the perfect simulation to a real quantum processor located at a research facility. This machine, while advanced, is not perfect; its components have slight errors, and the connections between them are not uniform. The researchers discovered that simply running the same code on the real machine did not guarantee the same results. The way the quantum bits were physically placed on the chip mattered immensely. They compared three different ways of arranging the data on the processor: a method chosen by standard software, a random arrangement, and a custom, "hardware-aware" design they created.

The results of this physical test were revealing. The custom, hardware-aware design consistently outperformed the standard software approach. When the researchers used their careful, tailored layout, the difference between the simulation and the real machine was small and manageable. The predictions remained stable, with the real machine deviating from the ideal by an average of less than eight claims per day at its worst. In contrast, the standard software layout sometimes failed dramatically, with errors jumping to nearly twelve claims per day, and the random arrangements were so unstable that they occasionally produced errors of over thirty claims, rendering the forecast useless. The study showed that the errors introduced by the real machine were mostly a simple shift in the overall number, rather than a chaotic mess, meaning the system was still tracking the daily changes correctly even if the total count was slightly off.

The researchers also found a limitation that affected all the models, not just the quantum ones. As the insurance company grew and the number of active policies increased significantly during the test period, the models struggled to predict the higher total number of claims. This was because the models had been trained on data from a smaller portfolio and had to guess what would happen at a much larger scale. While the traditional statistical model handled this growth slightly better, the quantum models still kept pace with the daily fluctuations, proving they could compete with classical methods even when the data moved outside the range they had seen before.

Ultimately, this work demonstrates that quantum computing is ready to tackle specific, real-world forecasting tasks, provided the hardware is treated with care. The study showed that a small quantum system can be just as accurate as a classical computer for predicting insurance claims, but only if the researchers carefully select the physical layout of the machine to minimize errors. It is not enough to simply run a quantum algorithm; one must understand the specific quirks of the hardware it runs on. By mapping the problem to the physical reality of the processor, the team ensured that their forecasts survived the journey from theory to practice, offering a clear path forward for using these fragile, powerful machines to solve everyday business problems.

Technical Summary: Hardware-Aware Quantum Reservoir Forecasting of Insurance Claims

Problem Statement
The paper addresses the challenge of applying Quantum Reservoir Computing (QRC) to real-world, noisy intermediate-scale quantum (NISQ) hardware for time-series forecasting. Specifically, it targets the forecasting of next-day motor-insurance property-damage claim counts. The study investigates two primary questions: (1) Can small, fixed-dynamics QRC models compete with classical statistical and machine learning models on this task? and (2) Can these models be systematically designed and mapped to physical qubits such that their predictions survive the transfer from ideal simulation to noisy quantum processors without retraining the readout layer?

The authors note that while QRC avoids the barren-plateau problem and gradient-based optimization of quantum parameters, it shifts the difficulty to the "QPU transfer" problem: ensuring that a readout trained on ideal simulated features remains accurate when applied to features measured on hardware subject to decoherence, gate errors, and readout noise.

Methodology
The research follows a three-stage workflow (Fig. 1) applied to a dataset of 4.5 years of daily insurance claims, portfolio exposure (active policies), and calendar data.

Problem Formulation and Data:
- Task: One-day-ahead forecasting of property-damage claim counts ( $C_{t+1}$ ).
- Features: Four inputs ( $F_4$ ): current claim count ( $C_t$ ), active policies ( $P_t$ ), target weekday ( $D_{t+1}$ ), and public holiday indicator ( $H_{t+1}$ ).
- Split: Chronological split into training (2022–2024), validation (2025), and held-out test (2026) sets. The test period features a significant increase in portfolio size (from ~90k to ~222k policies), creating an extrapolation challenge.
Quantum Reservoir Design (Simulation):
- Architecture: A six-qubit gate-based reservoir. Qubits $q_0$ – $q_3$ serve as an injection register (encoding inputs via $R_Y$ rotations), and $q_4$ – $q_5$ serve as a memory register.
- Dynamics: The system evolves under a Trotterized transverse-field Ising Hamiltonian with an additional local $Y$ field on the memory qubits.
- Input Encoding: Continuous variables are standardized and clipped or scaled (softsign transformation) to rotation angles. Categorical variables are mapped cyclically or as binary phases.
- Readout: A classical ridge regression model trained on ideal simulation features. The readout is frozen before test evaluation and applied to all subsequent data (ideal, noisy simulation, and hardware).
- Candidate Selection: Five logical graphs ( $H_0$ $H_{0}$ – $H_4$ $H_{4}$ ) compatible with the heavy-hex topology of IBM processors were evaluated. Candidates were selected based on four rules:
  - R1: Forecast accuracy (lowest CV RMSE).
  - R2: Delayed-input memory capacity.
  - R3: Measurement robustness (ensuring observables vary more than shot noise).
  - R4: Circuit efficiency (minimizing CZ count and depth).
- Result: Five frozen candidates ( $C_1$ – $C_5$ ) were retained, representing trade-offs between accuracy, memory, robustness, and cost.
Hardware Execution and Layout Selection:
- Platform: IBM Kingston (156 qubits).
- Layout Policies: The study compares three physical qubit mapping strategies for the five candidates:
  - Hardware-Aware (HA): Selects layouts based on a calibration-aware workload proxy (gate and readout errors) and a "transfer distortion" metric ( $d$ ) estimated via short probes on training data.
  - Random-Native: Selects a random native embedding without routing.
  - Qiskit: Uses the default Qiskit transpiler (optimization level 1).
- Evaluation: 63 total evaluations were performed across 21 paired rounds (each round evaluating the same candidate under all three layout policies). The frozen readout was applied to features extracted from the QPU. No readout retraining or error mitigation (e.g., Estimator primitives) was used during the final test runs to isolate the effect of layout selection.

Key Contributions

Reproducible Hardware-Aware QRC Workflow: The authors provide a complete pipeline from logical design to hardware deployment, including selection rules, calibrated-noise screening, and frozen configurations.
Competitive Forecasting Performance: Ideal QRC candidates achieved Root-Mean-Square Errors (RMSE) of 5.66–6.12 claims/day. While Ridge regression performed best (5.36), the QRC models were statistically comparable to classical recurrent networks (ESN, GRU, RNN) and XGBoost, with no significant difference from Ridge for four of the five candidates under a 95% block bootstrap.
Layout Policy Comparison: The Hardware-Aware (HA) layout selection consistently outperformed the default Qiskit layout. HA achieved lower RMSE in all 21 paired rounds and limited maximum transfer distortion to 7.59 claims/day, compared to 11.84 claims/day for Qiskit. Random-native layouts showed high variability and severe transfer failures (distortions up to 35.3 claims/day) due to degraded couplers.
Pre-Deployment Diagnosis: The study demonstrated that a short QPU probe using only training inputs could detect systematic forecast shifts (level shifts) before test runs, allowing for the identification of layouts that preserve the ideal prediction pattern.

Results

Forecasting Accuracy: On the held-out test set, Ridge regression remained the top performer. The QRC models exhibited a systematic underprediction bias (negative bias of -1.5 to -3.1 claims/day), particularly in the second half of the test period where portfolio exposure exceeded training ranges. This suggests the QRC struggled with extrapolation beyond the training distribution, whereas Ridge's linear nature handled the exposure growth better.
Transfer Distortion: The HA layout selection significantly reduced the distortion between ideal and hardware predictions. The distortion was primarily characterized as a systematic shift in the forecast level rather than a loss of day-to-day variation (high $\rho_{lvl}$ values).
Hardware vs. Simulation: While the QRC models were competitive in ideal simulation, the transfer to hardware introduced errors. However, the HA strategy successfully mitigated severe failures seen in random layouts, proving that careful physical mapping is critical for reliable QRC deployment.

Significance and Claims
The paper claims that small QRC models can reach competitive accuracy on real-world insurance forecasting tasks, provided the logical architecture and physical qubit layout are carefully selected. It highlights that hardware-aware layout selection is a critical factor in ensuring the reliable transfer of forecasts from simulation to NISQ hardware.

The authors modestly conclude that while QRC does not yet surpass the best classical baselines (Ridge) on this specific extrapolation-heavy task, it performs comparably to complex recurrent and reservoir baselines. The primary value demonstrated is the feasibility of a "frozen forecaster" approach where the quantum dynamics are fixed, and the classical readout is trained once, with performance preserved through intelligent hardware mapping rather than retraining. The work establishes a benchmark for QRC on real hardware for time-series forecasting, distinguishing between forecasting accuracy and the fidelity of simulation-to-hardware transfer.

Technical Summary: Hardware-Aware Quantum Reservoir Forecasting of Insurance Claims

More like this