Pulse-Driven Spin Paradigm for Noise-Aware Quantum Classification

Abstract

Quantum machine learning (QML) integrates quantum computing with classical machine learning. Within this domain, QML-CQ classification tasks, where classical data is processed by quantum circuits, have attracted particular interest for their potential to exploit high-dimensional feature maps, entanglement-enabled correlations, and non-classical priors. Yet, practical realizations remain constrained by the Noisy Intermediate-Scale Quantum (NISQ) era, where limited qubit counts, gate errors, and coherence losses necessitate frugal, noise-aware strategies. The Data Re-Uploading (DRU) algorithm has emerged as a strong NISQ-compatible candidate, offering universal classification capabilities with minimal qubit requirements. While DRU has been experimentally demonstrated on ion-trap, photonic, and superconducting platforms, no implementations exist for spin-based quantum processing units (QPU-SBs), despite their scalability potential via CMOS-compatible fabrication and recent demonstrations of multi-qubit processors. Here, we present a pulse-level, noise-aware DRU framework for spin-based QPUs, designed to bridge the gap between gate-level models and realistic spin-qubit execution. Our approach includes (i) compiling DRU circuits into hardware-proximate, time-domain controls derived from the Loss–DiVincenzo Hamiltonian, (ii) explicitly incorporating coherent and incoherent noise sources through pulse perturbations and Lindblad channels, (iii) enabling systematic noise-sensitivity studies across one-, two-, and four-spin configurations via continuous-time simulation, and (iv) developing a noise-aware training pipeline that benchmarks gate-level baselines against spin-level dynamics using information-theoretic loss functions. Numerical experiments show that our simulations reproduce gate-level dynamics with fidelities near unity while providing a richer error characterization under realistic noise. Moreover, divergence-based losses significantly enhance classification accuracy and robustness compared to fidelity-based metrics. Together, these results establish the proposed framework as a practical route for advancing DRU on spin-based platforms and motivate future work on error-attentive training and spin–quantum-dot noise modeling.

1. Introduction

Quantum computing (QC) leverages the principles of quantum mechanics, such as superposition and entanglement, to solve computational problems more efficiently and with reduced energy consumption [1]. Building on this foundation, quantum machine learning (QML) seeks to integrate QC with classical machine learning (ML) to tackle problems that may be intractable for classical methods alone [2]. Overall, QML has found applications across diverse domains, including cancer detection [3], economic forecasting and high-energy physics [4], quantum computing fault detection [5], quantum chemistry [6], and materials science [7]. Two complementary strands now shape QML: quantum circuits as trainable ML models and quantum acceleration for ML subroutines. The former employs a parameterized quantum circuit (PQC)—also called a variational quantum circuit or quantum neural network—to fit data by optimizing gate parameters exactly as one would train a classical model. This circuit-as-model view underpins quantum circuit learning and variational classifiers, with theory and practice showing expressive non-linear function approximation and successful small-scale experiments [8]. Further, the second QML line treats ML as the beneficiary of quantum algorithmic speedups in core primitives—kernels, linear algebra, and search/sampling—thereby enhancing otherwise classical pipelines. A central example is quantum feature maps and kernels, where a quantum device estimates inner products in large Hilbert spaces to power kernel methods, e.g., support vector machines (SVMs), and yield tasks with plausible or provable separations [9].

QML tasks are commonly categorized as CC, CQ, QC, and QQ depending on whether both the algorithm and data are classical (C) or quantum (Q) [10]. Within this taxonomy, QML-CQ classification tasks stand out, as they involve classical input data processed through quantum models. Namely, parameterized or variational quantum circuits act as expressive learners, exploiting entanglement to capture high-order correlations that are otherwise costly to model. Compact amplitude- and state-based encodings enable efficient representation of structured data, while quantum preprocessing routines such as quantum principal component analysis (qPCA) enhance dimensionality reduction and feature extraction. Prominent examples include quantum kernels and quantum support vector machines (QSVMs), which leverage quantum devices to estimate large Hilbert-space inner products [11]. Furthermore, probabilistic quantum generative models introduce non-classical priors that enrich hypothesis spaces, and query/sampling advantages grounded in amplitude estimation or Grover-type subroutines offer algorithmic speedups. Together, these elements provide both representational and computational pathways that are difficult to emulate with classical resources, establishing QML-CQ as a fertile ground for demonstrating tangible quantum advantages in supervised learning [12].

While QML algorithmic advances are promising, current quantum processing units (QPUs) remain firmly in the Noisy Intermediate-Scale Quantum (NISQ) era. In this regime, limited qubit counts, short coherence times, and significant gate and readout errors sharply constrain both circuit depth and the scalability of quantum models [13]. As a result, QML approaches designed for near-term deployment must be explicitly engineered for noise resilience and quantum-resource efficiency, carefully minimizing the number of qubits, gate operations, and measurement shots. Such frugality is not merely a hardware necessity but also a methodological imperative, ensuring that algorithmic performance in ML tasks can be meaningfully assessed under realistic noise models rather than idealized assumptions [14].

In this context, the QML Data Re-Uploading (DRU) algorithm emerges as a particularly well-suited candidate for the NISQ era [15]. By repeatedly re-encoding classical features into the same quantum register, DRU achieves expressive data representations while keeping qubit requirements and circuit depth remarkably low. This economy of quantum resources makes it highly compatible with current hardware limitations. Beyond its practical appeal, DRU enjoys rigorous theoretical guarantees: it has been formally established that even with almost a single qubit, the method can serve as a universal classifier, with its formulation naturally extending to multi-qubit architectures for enhanced representational power [16]. Conceptually, DRU resembles a single-layer neural network, yet it sidesteps fundamental quantum restrictions such as the no-cloning theorem, leveraging quantum interference and re-uploaded rotations to build expressive decision boundaries unattainable by purely classical linear models [17].

Experimental realizations of DRU have been successfully reported across diverse QPU platforms—most prominently on ion-trap processors [18], bosonic and photonic circuits [19], and superconducting quantum simulators [20]—underscoring both the adaptability of the algorithm and the strong experimental interest in probing its performance under noisy conditions [21]. Also, spin-based qubits remain an active research frontier with extensive progress on electronic-spin platforms, particularly nitrogen-vacancy (NV) center implementations [22]. Still, no experimental realization of DRU has been reported on spin-based QPUs, marking a significant gap in experimental validation and motivating targeted efforts to extend DRU to spin-based frameworks [16]. Indeed, spin-qubit quantum processing units (QPU-SBs) have emerged as one of the most promising platforms for scalable quantum information processing. Unlike atomic-spin realizations such as NMR, which face intrinsic scalability constraints [23], or NV centers in diamond, where reproducibility is limited by the stochastic placement of lattice defects, QPU-SB architectures leverage compatibility with standard CMOS/MOS fabrication processes [24]. This industrial alignment enables the direct transfer of decades of semiconductor expertise into the quantum domain, providing a credible pathway toward large-scale integration and manufacturable processors [25]. In particular, the quantum dot spin qubit [26], realized by controlling the spin of a confined electron with external magnetic fields, supports high-fidelity single- and two-qubit gate operations [27], with initialization and readout fidelities exceeding 99% [28] and coherence times approaching ∼120 μs [29]. Moreover, recent demonstrations of a six-qubit programmable processor further underscore the viability of this platform [30].

Despite the advantages of the DRU method and the QPU-SB technology, their practical realization demands an architecture-aware, pulse-level workflow. Such a workflow must (i) translate high-level algorithmic gates into hardware-native pulse schedules with optimized control waveforms [31], (ii) explicitly incorporate noise models that capture both quantum noise (QN) arising from decoherence and depolarization, as well as coherent control noise (CN) stemming from instrumental instabilities and pulse-shape fluctuations [10], and (iii) establish noise-aware training and benchmarking protocols to ensure that DRU-based learning remains robust under the realistic dynamics of spin-based devices [32].

Recent gate-to-pulse efforts have shown that DRU can be instantiated across multiple physical platforms, with successful implementations relying critically on platform-specific pulse calibration, detailed noise characterization, and fine-grained control tuning [20]. Notwithstanding impressive full-stack demonstrations reaching down to microwave/RF control of NV centers [33], most existing gate-to-pulse toolchains remain technology or architecture-specific, and thus do not seamlessly extend to QPU-SB built on quantum-dot architectures [26]. Attempts to bridge the gate- and pulse-level gap using spin-oriented frameworks, such as QuTiP-based modules or other pulse programming toolkits [34,35], highlight practical shortcomings, including rigid parameterizations, limited scalability to multi-qubit regimes, and embedded interaction models that restrict flexibility. These constraints hinder the direct realization of DRU-tailored pulse programming for electronic quantum-dot spin processors, underscoring the need for more adaptable and noise-aware spin-specific techniques.

In turn, available simulation infrastructures further accentuate this gap. Gate-level platforms such as PyQuil, Qiskit, Cirq, ProjectQ, and PennyLane incorporate noise through Kraus operators, stochastic Pauli channels, or simplified $T_1/T_2$ relaxation models [36]. While useful for benchmarking logical circuits, these discrete-time abstractions cannot faithfully reproduce continuous-time decoherence processes or distortions induced by time-dependent control waveforms. Pulse-level environments, by contrast, enable the explicit modeling of coherent noise sources and full time-domain dynamics [34,37]. However, such frameworks are largely optimized for superconducting architectures and often lack the flexible spin-Hamiltonian parametrization and efficient parameter-sweep capabilities needed to realistically capture spin-based device behavior [38]. Publicly accessible spin-based QPUs remain scarce. QuTech has released limited access to its Spin-2 and upgraded Spin-2+ demonstrators through the Quantum Inspire platform [39], providing one of the few cloud interfaces to spin-qubit hardware. By contrast, broader semiconductor initiatives such as the QLSI and QLSI2 projects target large-scale silicon-spin processors, with demonstrators envisioned at the tens-to-hundreds of qubits level. However, these efforts remain primarily in the development stage and do not yet offer wide public accessibility, see https://qt.eu/projects/computing/qlsi (accessed on 1 July 2025). Consequently, quantitative noise investigations for quantum-dot spin models must currently rely on simulation toolchains and gate-to-pulse adaptations specifically tailored to spin Hamiltonians. Performance assessments of DRU under noise reflect these methodological constraints: existing evaluations—whether gate-level analyses [40] or hardware/simulator-based demonstrations [41]—remain confined to one or two qubits, preferentially model superconducting architectures, and often emphasize narrow classification benchmarks [42]. These restrictions, compounded by the absence of controlled studies of coherent noise in QPU-SB, underscore the pressing need for the electronic-spin and pulse-level DRU.

In this paper, we introduce an end-to-end framework that bridges the gap between gate-level DRU models and QPU-SB execution by integrating pulse-level compilation, explicit noise modeling, and noise-aware training. The proposed approach is organized around the following key contributions:

–

Pulse-level compilation of DRU circuits: We translate gate-level DRU operations into hardware-proximate, time-domain controls consistent with the Loss–DiVincenzo (LD) Hamiltonian [26], employing the flexible parametrization of exchange interactions and external fields to enable pulse shaping, amplitude/phase modulation, and alignment with experimentally constrained spin-qubit controls.

–

Explicit modeling of device imperfections: CN is incorporated through stochastic and systematic perturbations on control amplitudes, while incoherent QN is captured using Lindblad-type dissipation channels [43], permitting continuous-time simulation that better reflect realistic device dynamics.

–

Spin-specific simulation environment: The framework supports systematic parameter sweeps over control variables and Hamiltonian parameters, enabling quantitative studies of noise sensitivity across one-, two-, and four-spin configurations. Our simulations demonstrate fidelities near unity with gate-level dynamics while providing richer insight into error propagation at the pulse level.

–

Noise-aware training and benchmarking: We implement a training pipeline that benchmarks gate-level baselines [44] against spin-QPU pulse-level simulations under varying noise regimes. Information-theoretic loss functions, including von Neumann and Rényi divergences, are shown to enhance classification robustness compared to standard fidelity-based objectives. Classifier evaluation with AUC [42] confirms improved performance in noisy environments.

Attained results reveal that (i) pulse-level simulations faithfully reproduce gate-level dynamics with high fidelity, (ii) divergence-based loss functions substantially improve classifier accuracy and robustness under noise, and (iii) the proposed framework establishes, to our knowledge, the first pulse-level, noise-aware spin-based QML classifier, paving the way for error-attentive training strategies and more realistic modeling of spin–quantum-dot noise processes.

The remainder of this article is organized as follows. Section 2 presents the related work. Then, Section 3 details the main materials and methods. Section 4 and Section 5 present the experiments and results. Finally, Section 6 depicts the concluding remarks and future work.

2. Related Work

2.1. Gate-to-Pulse Level Approaches in DRU Compilation

Compiling quantum algorithms into pulse-level implementations has become a crucial step toward realistic QML, particularly in the context of noise-aware execution. The DRU algorithm has been experimentally realized on diverse hardware platforms, including bosonic systems [45], superconducting devices [20], ion traps [18], qudit systems [41], and NV centers in diamond [33]. These studies consistently highlight the importance of platform-specific pulse calibration, noise characterization, and fine-grained control optimization in determining classification fidelity and robustness. The NV-center experiment in [33] is particularly notable for compiling DRU into microwave and RF pulse sequences, achieving a full-stack realization of QML down to hardware-level control at room temperature. Yet, most of these implementations are technology specific and do not directly extend to spin-based quantum-dot platforms governed by the LD Hamiltonian [26]. Attempts to generalize compilation frameworks have been reported. For instance, QuTiP-based modules [34] provide customizable Hamiltonian modeling but remain constrained by rigid parameterizations and reliance on the rotating wave approximation (RWA). Similarly, pulse programming toolkits such as [35] offer structures closer to the LD model but remain limited to single-qubit setups and embed interaction terms that restrict flexibility. Remarkably, while prior work has demonstrated the feasibility of DRU compilation at the pulse level, no existing study has implemented DRU within a spin-based QPU governed by the LD Hamiltonian, nor has any explored its robustness under coherent control noise.

2.2. Simulation Frameworks for Noisy Pulse-Level Compilation

Simulation frameworks represent a central tool for assessing the performance of QML algorithms under noise. These efforts can be broadly divided into static (gate-level) and dynamic (pulse-level) approaches. At the gate level, simulators incorporate QN and sometimes CN using probabilistic channel models. Examples include PyQuil [46], Qiskit [47], Cirq [47], ProjectQ [48], and PennyLane [36]. These platforms simulate noise via Kraus operators, stochastic Pauli channels, or simplified $T_1/T_2$ relaxation models. While effective for algorithmic prototyping, their discrete-time abstractions cannot capture continuous decoherence processes or time-dependent distortions induced by pulse control. Dynamic (pulse-level) frameworks provide a closer match to hardware by modeling time-domain evolution under explicit control fields. OpenPulse [49] enables pulse compilation with customizable Hamiltonians, while [37] integrates Lindblad operators for simulating Markovian noise. QuTiP-based approaches [34] extend this by perturbing control amplitudes for CN and modeling QN via Lindblad terms associated with $T_1/T_2$.

Despite these advances, key limitations persist. Gate-level simulators lack the ability to model continuous-time dynamics, preventing insight into weakly coupled environments. Pulse-level frameworks, although more expressive, are largely optimized for superconducting architectures, offering limited adaptability to spin Hamiltonians and lacking efficient parameter-sweep capabilities. Among the reviewed works, only [34] employs spin Hamiltonians, but its default model diverges from the LD Hamiltonian, precluding its direct application to quantum-dot spin qubits.

2.3. Performance Studies of DRU Under Noisy Conditions

Evaluating the robustness of the DRU algorithm under noise has been the subject of several investigations spanning three contexts:

–

Gate-level simulations. Works such as [40,50] analyze how Kraus-modeled noise channels (amplitude damping, depolarization, and bit-flip) and circuit depth influence DRU cost functions and classification accuracy.

–

Pulse-level and hardware demonstrations. Studies like [41,51] benchmark DRU performance under noisy superconducting backends, focusing on depth-dependent accuracy and dataset size but remain tied to superconducting simulators (e.g., IBM devices).

–

Noisy dataset evaluations. Other approaches introduce noise directly into the data used for training and testing, focusing on classifier robustness to data corruption rather than quantum or control noise channels [52,53].

Across these contexts, several limitations consistently emerge. Most studies remain confined to restricted system sizes, typically exploring only one or two qubits or, in some cases, single qudits. Performance evaluation is often reduced to narrow accuracy-based metrics, overlooking more informative measures such as F1-score or AUC that better capture classifier behavior under imbalance and noise [42]. In addition, error models are generally static, relying on fixed Kraus channels that fail to account for time-dependent dynamics or the impact of coherent control noise. A strong platform bias is also evident, as the majority of evaluations focus on superconducting hardware, leaving the influence of coherent noise in spin-based QPUs largely unexplored. Finally, some studies employ non-comparable information units, such as qudits rather than qubits, which complicates benchmarking across different architectures.

Of note, no performance study has addressed DRU under coherent noise within spin-based QPUs governed by the LD Hamiltonian, underscoring a critical research gap. This gap frames the central motivation for our pulse-level, noise-aware DRU framework for spin-based architectures.

3. Materials and Methods

3.1. Data Re-Uploading for Quantum Classification

Data Re-Uploading (DRU) is a quantum embedding and classification strategy in which each classical feature vector ${\overrightarrow{x}}_n\in {\mathbb{R}}^P$, corresponding to the n-th sample in a dataset of size N, is repeatedly encoded into the parameters of a parameterized quantum circuit (PQC) [16]. The central idea is to alternate layers of trainable unitaries with multiple re-introductions of the same classical data, thereby enriching the expressive capacity of the quantum model while maintaining a compact circuit depth [15]. Formally, each DRU layer applies a single-qubit unitary whose rotation angles depend jointly on trainable parameters and on the components of the classical data vector. Specifically, the i-th layer in the DRU scheme is defined as

$$L\left(i\right)=\widehat{U}\left({\overrightarrow{\varphi }}_i\right)=\widehat{U}\left({\overrightarrow{\theta }}_i+{\overrightarrow{w}}_i\odot {\overrightarrow{x}}_n\right),$$

(1)

where $\widehat{U}\left({\overrightarrow{\varphi }}_i\right)$ denotes a single-qubit unitary parameterized by the vector of rotation angles ${\overrightarrow{\varphi }}_i$, typically expressed through a Euler decomposition such as $R_x\left({\varphi }_i^1\right)R_y\left({\varphi }_i^2\right)R_z\left({\varphi }_i^3\right)$. The vector ${\overrightarrow{\theta }}_i\in {\mathbb{R}}^3$ contains trainable parameters that define baseline rotations for the i-th layer, while ${\overrightarrow{w}}_i\in {\mathbb{R}}^{3\times P}$ is a trainable weight structure that modulates the influence of the classical input. Moreover, ⊙ represents the Hadamard (element-wise) product, ensuring that each feature component is scaled before being re-uploaded.

Thus, the effective angles ${\overrightarrow{\varphi }}_i={\overrightarrow{\theta }}_i+{\overrightarrow{w}}_i\odot \overrightarrow{x}\in {\mathbb{R}}^3$ combine learnable parameters with reintroduced classical information. Of note, this construction allows the PQC to repeatedly embed classical data across layers, overcoming the representational limitations of shallow circuits and enabling universal function approximation with single-qubit architectures when combined with suitable measurement schemes. When the input dimension satisfies $P>3$, the feature vector ${\overrightarrow{x}}_n$ is partitioned into k subvectors ${\left\{{\overrightarrow{x}}_n^{\left(j\right)}\right\}}_{j=1}^k$ with ${\overrightarrow{x}}_n^{\left(j\right)}\in {\mathbb{R}}^3$. A single DRU layer is then realized as a product of sub-encodings [54]:

$$L\left(i\right)=\prod _{j=1}^k\widehat{U}\left({\overrightarrow{\theta }}_i^{\left(j\right)}+{\overrightarrow{w}}_i^{\left(j\right)}\odot {\overrightarrow{x}}_n^{\left(j\right)}\right),$$

(2)

allowing high-dimensional features to be efficiently re-uploaded through multiple three-angle encodings per layer.

By stacking $N_L$ layers, the full single-qubit DRU circuit is obtained, parameterized by the trainable weights $\{\overrightarrow{\theta },\overrightarrow{w}\}$:

$$\mathcal{U}(\overrightarrow{w},\overrightarrow{\theta },{\overrightarrow{x}}_n)=\prod _{i=1}^{N_L}\widehat{U}\left({\overrightarrow{\varphi }}_i\right).$$

(3)

The resulting quantum state is then

$$|{\psi }_n\rangle =|\psi (\overrightarrow{\theta },\overrightarrow{w},{\overrightarrow{x}}_n)\rangle =\mathcal{U}(\overrightarrow{w},\overrightarrow{\theta },{\overrightarrow{x}}_n)|0\rangle .$$

(4)

This repeated re-uploading of ${\overrightarrow{x}}_n$ across layers induces non-linear dependence on the input, thereby enhancing the expressive power of the model for classification tasks [55].

3.2. Fundamentals of the Quantum Processing Unit-Spin-Based (QPU-SB)

The spin-based quantum processing unit (QPU-SB) provides a natural physical platform for pulse-level compilation, where external control fields directly modulate the Hamiltonian dynamics of electronic spins. We begin with the single-spin model under the rotating-wave approximation (RWA), which captures the essential features of coherent control [56]. Consider a single electronic spin subjected to a magnetic field of the form

$$\overrightarrow{\mathbf{B}}\left(t\right)=({\mathcal{B}}_x\left(t\right),0,-B_z)=(B_{x}cos\left({\omega }_{x}t\right),0,-B_z).$$

(5)

The spin energy eigenstates are defined as

$$|\uparrow \rangle \equiv |0\rangle =\left[\begin{array}{c}1\\ 0\end{array}\right],|\downarrow \rangle \equiv |1\rangle =\left[\begin{array}{c}0\\ 1\end{array}\right].$$

(6)

In the rotating frame at frequency ${\omega }_x$, the detuning is defined as ${\Delta }_{\omega }={\omega }_z-{\omega }_x$, where ${\omega }_z=-\gamma B_z$ as the Larmor frequency, and the Rabi frequency ${\Omega }_x=\gamma B_x$. Under the RWA, the Hamiltonian yields [57]

$${\widehat{H}}_{\mathrm{RWA}}=-{\displaystyle \frac{\hslash }{2}}{\Delta }_{\omega }{\sigma }_z+{\displaystyle \frac{\hslash }{2}}{\Omega }_x{\sigma }_x,$$

(7)

which makes explicit that a resonant drive (${\Delta }_{\omega }=0$) generates coherent rotations about the x-axis with rotation angle $\theta =\int {\Omega }_x\left(t\right)dt$, where ${\Omega }_x\left(t\right)$ specifies the time-dependent pulse envelope. The latter can be extended to a register of $N_q$ electronic spins by adding both static and time-dependent contributions. The resulting Hamiltonian is written as [58]

$$\begin{array}{cc}\hfill \widehat{H}\left(t\right)& =\underset{{\widehat{H}}_0}{\underbrace{{\displaystyle \frac{\hslash }{2}}\sum _{i=1}^{N_q}{\omega }_z^{\left(i\right)}{\sigma }_z^{\left(i\right)}}}-\underset{{\widehat{H}}_{\det }\left(t\right)}{\underbrace{{\displaystyle \frac{\hslash }{2}}\sum _{i=1}^{N_q}{\omega }_x^{\left(i\right)}\left(t\right){\sigma }_z^{\left(i\right)}}}+\underset{{\widehat{H}}_{\mathrm{drive}}\left(t\right)}{\underbrace{{\displaystyle \frac{\hslash }{2}}\sum _{i=1}^{N_q}{\Omega }_x^{\left(i\right)}\left(t\right){\sigma }_x^{\left(i\right)}}}.\hfill \end{array}$$

(8)

Here, ${\omega }_x^{\left(i\right)}\left(t\right)$ denotes the frequency of the x-component of a square pulse applied to the i-th spin, remaining constant during the pulse, while ${\Omega }_x^{\left(i\right)}\left(t\right)$ represents a transverse drive. Both controls can be compactly expressed using analytic forms such as rectangular windows ${\mathrm{rect}}_{{\Delta }_t}(t-t_0)$. In explicit tensor-product notation, the Pauli operator acting on qubit i is expressed as

$${\sigma }_{\alpha }^{\left(i\right)}=I\otimes \cdots \otimes I\otimes \underset{\mathrm{position}i}{\underbrace{{\sigma }_{\alpha }}}\otimes I\otimes \cdots \otimes I,\alpha \in \{x,y,z\}.$$

(9)

In simulation environments such as QuTiP [59], the static part ${\widehat{H}}_0$ is typically specified once, while the time-dependent coefficients for ${\widehat{H}}_{\det }$ and ${\widehat{H}}_{\mathrm{drive}}$ are provided as callables encoding the chosen pulse envelopes.

Beyond single-qubit dynamics, entangling interactions are realized through the isotropic Heisenberg exchange coupling [60]. Then, for a pair of spins $(1,2)$ with tunable exchange strength $J\left(t\right)$, the Hamiltonian takes the form

$${\widehat{H}}_{\mathrm{ex}}\left(t\right)={\displaystyle \frac{J\left(t\right)}{4}}\left({\sigma }_x^{\left(1\right)}{\sigma }_x^{\left(2\right)}+{\sigma }_y^{\left(1\right)}{\sigma }_y^{\left(2\right)}+{\sigma }_z^{\left(1\right)}{\sigma }_z^{\left(2\right)}\right).$$

(10)

If the pulse area is defined as $\Phi ={\displaystyle \frac{1}{\hslash }}\int J\left(t\right)dt$, the corresponding two-qubit propagator can be written as

$$U_{\mathrm{ex}}=exp\left(-\mathrm{j}{\displaystyle \frac{\Phi }{4}}\left({\sigma }_x\otimes {\sigma }_x+{\sigma }_y\otimes {\sigma }_y+{\sigma }_z\otimes {\sigma }_z\right)\right).$$

(11)

Special cases include $\Phi =\pi$, which up to single-qubit phases implements a SWAP gate, and $\Phi =\pi /2$, which yields a $\sqrt{\mathrm{SWAP}}$, a universal entangling operation when combined with local rotations [61,62].

Together, these Hamiltonians describe the fundamental building blocks of spin-based quantum processors. They not only capture the essential physics of single- and two-qubit operations but also provide the foundation for noise-aware pulse-level compilation, where realistic pulse shapes and control imperfections can be systematically integrated into quantum algorithm design.

3.3. Quantum and Coherence Noise Modeling

In modeling realistic spin-based quantum processors, two principal noise mechanisms must be considered: fluctuations in the control amplitudes, commonly referred to as coherent noise (CN), and dissipative processes that arise from coupling to the environment, collectively captured under quantum noise (QN). We first formalize the treatment of amplitude noise in the driven single-spin Hamiltonian and then extend the discussion to open-system dynamics through Lindblad master equations and their corresponding collapse operators [63].

In this work, amplitude fluctuations in the transverse driving field are introduced through an additive stochastic process. For the i-th qubit, the noisy control field can be written as

$${\mathcal{B}}_x^{\mathrm{CN}\left(i\right)}\left(t\right)=B_x^{\left(i\right)}+{\eta }^{\left(i\right)}\left(t\right),{\eta }^{\left(i\right)}\left(t\right)\sim \mathcal{N}(0,{\sigma }_{cn}^2),$$

(12)

where ${\eta }^{\left(i\right)}\left(t\right)$ denotes a Gaussian random variable with zero mean and variance ${\sigma }_{cn}^2$. In practical simulations, however, the transverse field is represented by a rectangular pulse. This motivates the use of a scaled-noise formulation in which the stochastic term perturbs the ideal rectangular envelope, yielding

$${\mathcal{B}}_x^{\mathrm{ScN}}\left(t\right)=B_x\left({\mathrm{rect}}_{{\Delta }_t}(t-t_0)+{\eta }_{\mathrm{ScN}}\left(t\right)\right),{\eta }_{\mathrm{ScN}}\left(t\right)\sim \mathcal{N}\left(0,{\sigma }_{\mathrm{ScN}}^2\right).$$

(13)

Here, the relative variance ${\sigma }_{\mathrm{ScN}}^2={({\sigma }_{cn}/B_x)}^2$ emerges naturally from the scaling property of Gaussian variables [64]: if $\eta \sim \mathcal{N}(0,{\sigma }^2)$, then for any constant c, the rescaled variable $c\eta$ follows $\mathcal{N}(0,c^2{\sigma }^2)$. This connection makes explicit the relation between absolute noise variance and its normalized counterpart when expressed with respect to the drive amplitude. The inclusion of scaled amplitude noise leads to a decomposition of the driven Hamiltonian into deterministic and stochastic parts. For a transverse drive on qubit i,

$$\begin{array}{cc}\hfill {\widehat{H}}_{\mathrm{drive}}^{\mathrm{CN}\left(i\right)}\left(t\right)& ={\displaystyle \frac{\hslash }{2}}{\Omega }_x^{\mathrm{CN}\left(i\right)}\left(t\right){\sigma }_x^i\hfill \\ \hfill & ={\displaystyle \frac{\hslash \gamma }{2}}{\mathcal{B}}_x^{\mathrm{ScN}}\left(t\right){\sigma }_x^i\hfill \\ \hfill & ={\displaystyle \frac{\hslash \gamma }{2}}{B}_x\left({\mathrm{rect}}_{{\Delta }_t}(t-t_0)+{\eta }_{\mathrm{ScN}}\left(t\right)\right){\sigma }_x^i\hfill \\ \hfill & =\underset{{\widehat{H}}_{\mathrm{drive}}\left(t\right)(\mathrm{deterministic}\mathrm{drive})}{\underbrace{{\displaystyle \frac{\hslash \gamma }{2}}{B}_x{\mathrm{rect}}_{{\Delta }_t}(t-t_0){\sigma }_x^i}}+\underset{{\widehat{H}}_{\mathrm{drive}}^{\mathrm{noise}}\left(t\right)(\mathrm{stochastic}\mathrm{term})}{\underbrace{{\displaystyle \frac{\hslash \gamma }{2}}{B}_x{\eta }_{\mathrm{ScN}}\left(t\right){\sigma }_x^i}}.\hfill \end{array}$$

(14)

This decomposition highlights the role of the control pulse as the intended coherent operation, while simultaneously isolating the stochastic perturbation introduced by amplitude noise. Such a formulation is advantageous because it enables both the analytical evaluation of error rates and efficient sampling-based numerical simulations.

In addition to coherent fluctuations, spin qubits are subject to incoherent noise processes originating from their interaction with the surrounding environment. These processes are modeled using the Gorini–Kossakowski–Sudarshan–Lindblad (GKSL) master equation in the Schrödinger picture, given by [65]

$$\dot{\rho }\left(t\right)=-{\displaystyle \frac{\mathrm{i}}{\hslash }}[\widehat{H}\left(t\right),\rho \left(t\right)]+\sum _k\left({\widehat{L}}_k\rho \left(t\right){\widehat{L}}_k^{†}-\frac{1}{2}\{{\widehat{L}}_k^{†}{\widehat{L}}_k,\rho \left(t\right)\}\right),$$

(15)

where $\rho \left(t\right)$ denotes the system’s density matrix and the set $\left\{{\widehat{L}}_k\right\}$ contains collapse or jump operators associated with specific decoherence channels.

For longitudinal relaxation, which describes the irreversible decay of an excited state with characteristic time $T_1$, the corresponding jump operator is [66]

$${\widehat{L}}_1=\sqrt{{\displaystyle \frac{1}{T_1}}}{\sigma }_{-},$$

(16)

where ${\sigma }_{-}=|\uparrow \rangle \langle \downarrow |$. Pure dephasing, in contrast, captures the loss of phase coherence without population transfer. It is represented by a Hermitian operator proportional to ${\sigma }_z$ [67]:

$${\widehat{L}}_{\varphi }=\sqrt{{\displaystyle \frac{1}{2T_{\varphi }}}}{\sigma }_z.$$

(17)

The relation between relaxation and dephasing processes is usually expressed in terms of the transverse coherence time $T_2$:

$${\displaystyle \frac{1}{T_2}}={\displaystyle \frac{1}{2T_1}}+{\displaystyle \frac{1}{T_{\varphi }}}.$$

(18)

In experiments, the inhomogeneous dephasing time $T_2^{*}$ is often reported, which accounts for ensemble broadening effects. A commonly used approximation is [68]

$${\displaystyle \frac{1}{T_2^{*}}}={\displaystyle \frac{1}{T_2}}-{\displaystyle \frac{1}{2T_1}},$$

(19)

although the precise relation depends on the noise spectrum and should be applied cautiously. An alternative dephasing ansatz sometimes adopted in simulations replaces ${\sigma }_z$ with the population-projection operator ${\sigma }_{+}{\sigma }_{-}$, yielding [69]

$${\widehat{L}}_2^{\left(\mathrm{alt}\right)}=\sqrt{{\displaystyle \frac{1}{2T_2^{*}}}}{\sigma }_{+}{\sigma }_{-}.$$

(20)

Since ${\sigma }_{+}{\sigma }_{-}=(\mathbb{I}-{\sigma }_z)/2$ and ${\sigma }_{+}={\sigma }_{-}^{†}$, both choices are equivalent in their physical action, although the ${\sigma }_z$-based form is algebraically simpler and more widely employed.

When extending these noise models to registers of multiple qubits, the collapse operators must be embedded into the full Hilbert space so that dissipation acts selectively on specific qubits. For a register of size $N_q$ with a designated target qubit $q_{\mathrm{obj}}$, the single-qubit operators are mapped into the global system by tensoring with identity operators on all non-target sites:

$$A_{L_1}^{\left(j\right)}=\left\{\begin{array}{cc}\sqrt{{\displaystyle \frac{1}{T_1}}}{\sigma }_{-},\hfill & j=q_{\mathrm{obj}},\hfill \\ \mathbb{I},\hfill & j\ne q_{\mathrm{obj}},\hfill \end{array}\right.A_{L_{\varphi }}^{\left(j\right)}=\left\{\begin{array}{cc}\sqrt{{\displaystyle \frac{1}{2T_{\varphi }}}}{\sigma }_z,\hfill & j=q_{\mathrm{obj}},\hfill \\ \mathbb{I},\hfill & j\ne q_{\mathrm{obj}}.\hfill \end{array}\right.$$

(21)

The resulting full-system collapse operators are then

$${\widehat{L}}_1^{\left(\mathrm{full}\right)}=\underset{i=1}{\overset{N_q}{⨂}}{A}_{L_1}^{\left(i\right)},{\widehat{L}}_{\varphi }^{\left(\mathrm{full}\right)}=\underset{i=1}{\overset{N_q}{⨂}}{A}_{L_{\varphi }}^{\left(i\right)}.$$

(22)

In numerical implementations with QuTiP [70], these operators are passed as entries of the collapse-operator list supplied to the master-equation solver so that the solver automatically includes both relaxation and dephasing channels in accordance with the Lindblad equation. Through this combined treatment of coherent amplitude fluctuations and Lindblad-type incoherent processes, our simulation framework is equipped to capture the dominant noise sources present in spin-based quantum processors. This dual-layer noise modeling provides the foundation for systematically evaluating the robustness of pulse-driven DRU classifiers under realistic device conditions.

3.4. Spin-Based Data Re-Uploading Framework

The proposed spin-based DRU framework builds upon the circuit architectures introduced in [16] as shown in Figure 1. The baseline configurations include one-, two-, and four-qubit circuits—denoted as DRU1Q, DRU2Q, and DRU4Q—and their entangled extensions, DRU2QE and DRU4QE. Each model is trained at the gate level (GL), where intermediate quantum states are represented by red dashed lines and expressed as $|{\mathsf{\psi }}_{\mu }^i\rangle$, with i indexing the circuit layer and $\mu$ denoting the embedded data point ${\mathit{x}}_{\mu }$.

Each DRU ansatz is composed of three fundamental building blocks: the single-qubit DRU layer $L\left(i\right)$, the two-qubit controlled-Z gate ($C{Z}_{q_i,q_j}$), and the four-qubit controlled-Z constructed via SWAP networks ($CZ{4}_{q_i,q_j}$). Here, $q_i$ and $q_j$ denote the control and target qubits, respectively. The pulse-level compilation of these models on the spin-based quantum processing unit (QPU-SB) follows the single-spin Hamiltonian in Equation (7) and the exchange-coupling model in Equation (10), assuming a linear array of electron spins with nearest-neighbor coupling.

3.4.1. Single Layer Model

Each DRU layer is parameterized as a unitary operator whose rotation angles depend linearly on trainable parameters and classical inputs [16] as defined in Equation (1). This formulation separates trainable variables ${\overrightarrow{\theta }}_i$ from the input-dependent modulation ${\overrightarrow{w}}_i\odot {\overrightarrow{x}}_{\mu }$, enabling efficient gradient-based optimization. The single-qubit operation is expressed through a three-angle Euler decomposition:

$$\widehat{U}\left(\overrightarrow{\varphi }\right)=R_z\left({\varphi }_2\right)R_y\left({\varphi }_1\right)R_z\left({\varphi }_3\right),$$

(23)

where $R_{\alpha }\left(\theta \right)=exp(-i\frac{\theta }{2}{\sigma }_{\alpha })$. Since the QPU-SB supports control only along the x and z axes, $R_y$ rotations are synthesized using the standard conjugation identity [71]:

$$R_y\left({\varphi }_1\right)=R_x\left(\frac{\pi }{2}\right)R_z\left({\varphi }_1\right)R_x\left(-\frac{\pi }{2}\right).$$

(24)

Thus, all layer unitaries can be expressed in terms of native $R_x$ and $R_z$ rotations, fully compatible with pulse-level synthesis via transverse-field and detuning controls. The rotation angle for an $R_x$ gate is determined by the pulse area ($\theta =\gamma B_x\tau$), where $\tau$ denotes the pulse duration, while $R_z$ rotations correspond to detuning-induced or virtual-frame operations. These mappings translate the DRU parameters ${\overrightarrow{\varphi }}_i$ into physically realizable control envelopes within the Hamiltonian models of Equations (7) and (10).

3.4.2. Two-Qubit CZ Gate

The controlled-Z primitive (CZ-2), shown in Figure 2, is implemented through two $\sqrt{\mathrm{SWAP}}$ operations interleaved with single-qubit $R_z$ phase gates:

$$U_{CZ}=\left(R_z(-\frac{\pi }{2})\otimes R_z\left(\frac{\pi }{2}\right)\right)\sqrt{\mathrm{SWAP}}(I\otimes R_z(-\pi ))\sqrt{\mathrm{SWAP}}=iCZ.$$

(25)

This decomposition reproduces the canonical CZ operation (up to a global phase) and naturally maps to exchange-pulse sequences and local phase adjustments in the QPU-SB.

3.4.3. Four-Qubit CZ4 Gate

The non-adjacent controlled-Z operation (CZ4), illustrated in Figure 3, is realized using SWAP networks that bring distant qubits into adjacency. The construction employs Hadamard gates to toggle between CZ and CNOT forms, with SWAP layers restoring the original qubit ordering. The Hadamard gate is decomposed as

$${\widehat{U}}_H=R_z(\pi /2)R_x(\pi /2)R_z(\pi /2)=e^{i\pi }H.$$

(26)

3.4.4. CNOT Decomposition and Hardware Mapping

Figure 4 shows the decomposition of an adjacent CNOT gate into native spin-QPU primitives. The entangling operation is achieved through $\sqrt{\mathrm{SWAP}}$ gates, while local rotations are implemented using the $R_x$–$R_z$ synthesis rules established above. This mapping provides a consistent bridge between gate-level and pulse-level abstractions, forming the foundation for benchmarking DRU compilation on spin-based architectures.

4. Experimental Set-Up

We evaluate our proposed Spin-based Quantum Classifier (SQC) framework through comprehensive simulations conducted at both the pulse and gate levels. This dual-level evaluation enables a direct comparison between abstract circuit-based performance and the underlying continuous-time spin dynamics governed by the Loss–DiVincenzo Hamiltonian. To demonstrate the classification capabilities of the SQC under realistic noise and control constraints, we employ a benchmark dataset widely used in quantum and classical machine learning studies, allowing the systematic assessment of accuracy, robustness, and noise sensitivity across different spin configurations.

4.1. Tested Dataset

For empirical validation, we employ the Iris dataset, a canonical benchmark in both classical and quantum machine learning studies [64]. The dataset consists of 150 labeled samples evenly distributed across three species: setosa, versicolor, and virginica. Each sample is characterized by four continuous features—sepal length, sepal width, petal length, and petal width—normalized within the range $[0,1]$ for quantum encoding. The Iris dataset provides an ideal testbed for evaluating quantum classifiers due to its mixed separability properties: while setosa is linearly separable from the remaining species, versicolor and virginica exhibit substantial overlap, introducing a non-linear decision boundary that challenges low-dimensional quantum representations. Despite its simplicity, this dataset enables the controlled analysis of embedding expressivity, decision boundary complexity, and noise robustness within constrained spin-based architectures [72].

Although the dataset employed is the Iris dataset, which originally consists of four features and three classes embedded, in this work we adopt the notation $\mathrm{IRIS}(n,m)$, where n denotes the dimensionality of features ${\mathbb{R}}^n$ (with Principal Component Analysis, PCA, applied when $n<3$ to reduce dimensionality) and m specifies the number of selected classes from the dataset, namely, Iris-Setosa, Iris-Versicolour, and Iris-Virginica.

4.2. Training Details and Baselines

Gate-level training was carried out using the PennyLane Python library with the Adam optimizer configured as ${\beta }_1=0.9$ and ${\beta }_2=0.99$ [73]. For each circuit, the labeled quantum states are defined as $\left\{|{\psi }_c\rangle |c\in \{1,2,\dots ,N_c\}\right\}$, where $N_c$ denotes the number of classes. These states were prepared as pure states under the maximum orthogonality labeling criterion proposed in [16]. Representative labeling configurations are shown in Figure 5.

Representative quantum states $|{\mathsf{\psi }}_c\rangle$ are defined for each tested qubit–class configuration as follows:

–

For a single qubit and two classes, we use $|{\mathsf{\psi }}_1\rangle =|0\rangle$ and $|{\mathsf{\psi }}_2\rangle =|1\rangle$.

–

When extending to three classes, the states are defined as $|{\mathsf{\psi }}_1\rangle =|0\rangle$, $|{\mathsf{\psi }}_2\rangle =(\sqrt{3}/2)|0\rangle +(1/2)|1\rangle$, and  $|{\mathsf{\psi }}_3\rangle =(\sqrt{3}/2)|0\rangle -(1/2)|1\rangle$.

–

For four classes, we adopt $|{\mathsf{\psi }}_1\rangle =|0\rangle$, $|{\mathsf{\psi }}_2\rangle =(1/\sqrt{3})|0\rangle +\sqrt{2/3}|1\rangle$, $|{\mathsf{\psi }}_3\rangle =(1/\sqrt{3})|0\rangle +e^{i2\pi /3}\sqrt{2/3}|1\rangle$, and  $|{\mathsf{\psi }}_4\rangle =(1/\sqrt{3})|0\rangle +e^{-i2\pi /3}\sqrt{2/3}|1\rangle$.

–

For two-qubit circuits, the states corresponding to two classes are $|{\mathsf{\psi }}_1\rangle =|00\rangle$ and $|{\mathsf{\psi }}_2\rangle =|11\rangle$,

–

While for three classes we use $|{\mathsf{\psi }}_1\rangle =|00\rangle$, $|{\mathsf{\psi }}_2\rangle =|01\rangle$, and $|{\mathsf{\psi }}_3\rangle =|10\rangle$.

–

Finally, for four-qubit encodings, we select $|{\mathsf{\psi }}_1\rangle =|0000\rangle$ and $|{\mathsf{\psi }}_2\rangle =|0001\rangle$ for two classes, and extend to $|{\mathsf{\psi }}_3\rangle =|0010\rangle$ for three-class configurations.

Further, quantum fidelity provides a fundamental measure of similarity between quantum states and serves a dual purpose in this study: (i) as an evaluation metric to quantify the accuracy of pulse-to-gate compilation, and (ii) as a supervised cost function for classification. For two quantum states $\mathsf{\rho }$ and $\mathsf{\sigma }$ represented by density matrices, fidelity is defined as [74]

$$F(\mathsf{\rho },\mathsf{\sigma })={\left(Tr\sqrt{\sqrt{\mathsf{\rho }}\mathsf{\sigma }\sqrt{\mathsf{\rho }}}\right)}^2,$$

(27)

with $F(\mathsf{\rho },\mathsf{\sigma })\in [0,1]$, where $F=1$ denotes identical states and $F=0$ indicates orthogonality. Within spin-based QPU simulations, fidelity is computed between an ideal layer state ${\mathsf{\rho }}_{\mu }^i=|{\psi }_{\mu }^i\rangle \langle {\psi }_{\mu }^i|$ and its compiled counterpart ${\mathsf{\sigma }}_{\mu }^i=|{\tilde{\psi }}_{\mu }^i\rangle \langle {\tilde{\psi }}_{\mu }^i|$, thereby capturing deviations arising from QN and CN. Also, the average fidelity over all samples after the final layer, ${\mathsf{\rho }}_{\mu }^{N_L}$ and ${\mathsf{\sigma }}_{\mu }^{N_L}$, quantifies the accuracy of the compiled dynamics.

For classification, fidelity acts as a quantum scoring function that maps the predicted quantum state ${\mathsf{\sigma }}_{\mathrm{predict}}\left({\mathit{x}}_{\mu }\right)$ to the most similar label state ${\mathsf{\rho }}_c^{\mathrm{label}}=|{\psi }_c\rangle \langle {\psi }_c|$, given by

$$c_{\mathrm{predict}}^{*}=arg\underset{c^{*}}{max}\left\{F({\mathsf{\sigma }}_{\mathrm{predict}},{\mathsf{\rho }}_c^{\mathrm{label}})|{\mathsf{\rho }}_c^{\mathrm{label}}\in {\left\{|{\psi }_c\rangle \langle {\psi }_c|\right\}}_{c=1}^{N_c}\right\}.$$

(28)

This procedure yields a classical label $c_{\mathrm{predict}}^{*}$ for each predicted quantum state, which is subsequently evaluated using the classical Area Under the ROC Curve (AUC) measure [44]

$$\mathrm{AUC}={\int }_0^1\mathrm{TPR}d\left(\mathrm{FPR}\right),$$

(29)

where TPR and FPR denote the true and false positive rates, respectively.

In addition, the DRU algorithm’s performance is benchmarked under non-ideal conditions, analyzing how circuit configuration (number of qubits $N_q$), depth ($N_L$), and cost function choice affect classification outcomes across varying levels of coherent noise (${\sigma }_{cn}$) and quantum decoherence ($T_2$). All evaluations are performed under a one-vs-rest AUC scheme to identify optimal training strategies for noise-aware DRU models on spin-based quantum processors [75]. A 5-fold cross-validation scheme is fixed for classification training and testing. Each model was trained for 10 epochs with a batch size of 32. To assess robustness, the coherent control noise amplitude ${\sigma }_{cn}$ was varied within $0.0010\le {\sigma }_{cn}\le 0.05$ [T], while decoherence times $T_2$ ranged from $0.001\mu \le T_2\le 10\mu$ [s] [76].

For each circuit architecture, depths of $N_L\in \{2,5,10\}$ were tested. The training objective minimized one of four loss functions, each quantifying the dissimilarity between the true and predicted quantum states density matrices ${\mathsf{\rho }}_{\mathrm{true}}={\mathsf{\rho }}_c^{\mathrm{label}}$ and ${\mathsf{\sigma }}_{\mathrm{pred}}\left({\mathit{x}}_{\mathrm{train}}\right)$, respectively. Specifically [77,78]: (i) the Trace Distance $T({\mathsf{\rho }}_{\mathrm{true}},{\mathsf{\sigma }}_{\mathrm{pred}})$ measures the distinguishability between two quantum states; (ii) the Quantum Relative Entropy $S({\mathsf{\rho }}_{\mathrm{true}}\parallel {\mathsf{\sigma }}_{\mathrm{pred}})$ quantifies their information divergence (i.e., von Neumann divergence); (iii) the Rényi Divergence $D_{\alpha }({\mathsf{\rho }}_{\mathrm{true}}\parallel {\mathsf{\sigma }}_{\mathrm{pred}})$ generalizes entropy-based distances for tunable $\alpha$, commonly fixed as $0.5$ or 2; and (iv) the Fidelity Complement Loss ${\chi }_f^2({\mathsf{\rho }}_{\mathrm{true}},{\mathsf{\sigma }}_{\mathrm{pred}})$ penalizes dissimilarity in terms of state fidelity. Their analytical forms are given as follows:

$$\begin{array}{cc}\hfill T({\mathsf{\rho }}_{\mathrm{true}},{\mathsf{\sigma }}_{\mathrm{pred}})& =\frac{1}{2}Tr\left[\sqrt{{({\mathsf{\rho }}_{\mathrm{true}}-{\mathsf{\sigma }}_{\mathrm{pred}})}^{†}({\mathsf{\rho }}_{\mathrm{true}}-{\mathsf{\sigma }}_{\mathrm{pred}})}\right],\hfill \end{array}$$

(30)

$$\begin{array}{cc}\hfill S({\mathsf{\rho }}_{\mathrm{true}}\parallel {\mathsf{\sigma }}_{\mathrm{pred}})& =Tr\left[{\mathsf{\rho }}_{\mathrm{true}}\left(log{\mathsf{\rho }}_{\mathrm{true}}-log{\mathsf{\sigma }}_{\mathrm{pred}}\right)\right],\hfill \end{array}$$

(31)

$$\begin{array}{cc}\hfill D_{\alpha }({\mathsf{\rho }}_{\mathrm{true}}\parallel {\mathsf{\sigma }}_{\mathrm{pred}})& ={\displaystyle \frac{1}{\alpha -1}}log\left({\displaystyle \frac{Tr\left[{\left({\mathsf{\sigma }}_{\mathrm{pred}}^{\frac{1-\alpha }{2\alpha }}{\mathsf{\rho }}_{\mathrm{true}}{\mathsf{\sigma }}_{\mathrm{pred}}^{\frac{1-\alpha }{2\alpha }}\right)}^{\alpha }\right]}{Tr\left({\mathsf{\rho }}_{\mathrm{true}}\right)}}\right),\hfill \end{array}$$

(32)

$$\begin{array}{cc}\hfill {\chi }_f^2({\mathsf{\rho }}_{\mathrm{true}},{\mathsf{\sigma }}_{\mathrm{pred}})& =1-{\left(Tr\sqrt{\sqrt{{\mathsf{\rho }}_{\mathrm{true}}}{\mathsf{\sigma }}_{\mathrm{pred}}\sqrt{{\mathsf{\rho }}_{\mathrm{true}}}}\right)}^2.\hfill \end{array}$$

(33)

After training, the optimized parameters were deployed to the QPU for pulse-level simulation under noisy conditions. Each test input produced a corresponding quantum state, from which the predicted class label was inferred via fidelity-based comparison. The classification performance was then quantified using the AUC metric, providing a robust measure of separability under realistic noise. The complete end-to-end workflow is illustrated in Figure 6.

5. Results and Discussion

5.1. Pulse and Fidelity Compilation

This subsection presents the simulation outcomes for the implementation and compilation of DRU circuits on the spin-based QPU under ideal (noise-free) conditions. We first analyze the impact of detuning, caused by variations in the resonance frequency, using a single-qubit DRU circuit with $N_L=3$ (see Figure 7). Consistent with experimental observations in spin-based quantum hardware [79], we evaluate the frequency response of an $R_x\left({\alpha }_x\left(t\right)\right)$ rotation. The transition probability peaks when the driving frequency matches the qubit resonance, i.e., ${\omega }_x={\omega }_z=1760$ MHz. This probability is computed by projecting the time-evolved state $|{\psi }_t\rangle$ onto the measurement basis $\{|\uparrow \rangle ,|\downarrow \rangle \}$ and evaluating ${\left|\langle \uparrow |{\psi }_t\rangle \right|}^2$ or ${\left|\langle \downarrow |{\psi }_t\rangle \right|}^2$. The resulting Rabi-like oscillations show reduced amplitudes under off-resonance conditions, a behavior also observed in the DRU1Q circuit, where detuning significantly modifies the population transfer between basis states.

Next, we validate the time evolution of $CNOT$ gates for two- and four-qubit systems. These operations, combined with Hadamard gates, enable the construction of the $CZ$ gates required in DRU architectures (see Figure 8). In the two-qubit case, with $q_0$ as the control and $q_1$ as the target, the simulation reproduces the expected transition from $|\downarrow \downarrow \rangle$ to $|\downarrow \uparrow \rangle$. Similarly, in the four-qubit configuration, where $q_0$ controls $q_3$, the state of $q_3$ flips from $|\downarrow \rangle$ to $|\uparrow \rangle$, consistent with theoretical predictions [80].

Figure 9 further demonstrates the tomography of the Bell state $|{\Phi }^{+}\rangle$, confirming the simulator’s ability to reproduce entangled states [28]. The close agreement between the simulated and ideal density matrices validates the capability of our spin-based QPU framework to generate and preserve non-classical correlations with high fidelity.

Also, we assess the compilation accuracy of the DRU algorithm through fidelity evaluations between trained gate-level models and their corresponding spin-based pulse implementations.

Table 1. Average training fidelities for one-qubit DRU circuits with increasing layer depth $N_L$. All models exhibit near-unity fidelity under ideal (noise-free) conditions.

State	${\mathit{N}}_{\mathit{L}}=3$		${\mathit{N}}_{\mathit{L}}=5$		${\mathit{N}}_{\mathit{L}}=10$
	${\overline{\mathit{F}}}_{\mathit{c}}^{\mathit{train}}$	${\mathsf{\sigma }}_{{\mathit{F}}_{\mathit{c}}}$	${\overline{\mathit{F}}}_{\mathit{c}}^{\mathit{train}}$	${\mathsf{\sigma }}_{{\mathit{F}}_{\mathit{c}}}$	${\overline{\mathit{F}}}_{\mathit{c}}^{\mathit{train}}$	${\mathsf{\sigma }}_{{\mathit{F}}_{\mathit{c}}}$
$|{\psi }_0\rangle$	1.0000	$4.0\times {10}^{-9}$	1.0000	$4.0\times {10}^{-9}$	1.0000	$4.1\times {10}^{-9}$
$|{\psi }_1\rangle$	1.0000	$7.3\times {10}^{-9}$	1.0000	$4.1\times {10}^{-9}$	1.0000	$4.6\times {10}^{-9}$
$|{\psi }_2\rangle$	1.0000	$2.2\times {10}^{-9}$	1.0000	$4.2\times {10}^{-9}$	1.0000	$4.7\times {10}^{-9}$
Mean ± SD	1.0000	$(4.5\times {10}^{-9})$	1.0000	$(4.1\times {10}^{-9})$	1.0000	$(4.5\times {10}^{-9})$

reports the average fidelities ${\overline{F}}_c^{train}$ and standard deviations for the DRU1Q circuit trained on the Iris dataset using $N_L=3,5,10$. All results exhibit fidelities near unity, confirming an accurate mapping of the DRU layers into the spin-based QPU under ideal conditions.

Of note, the optimized parameters define the control amplitudes that generate the pulse sequences for QPU execution. Each input ${\overrightarrow{x}}_{\mu }$ corresponds to a distinct pulse configuration. Next, Figure 10 shows an example pulse schedule for a DRU2QE circuit, where transverse ($B_x$), longitudinal ($B_z$), and exchange ($J_{ij}$) pulses orchestrate spin rotations and entangling interactions. Virtual I gates (red) synchronize layer durations when ${\tau }_a\ne {\tau }_b$. Although these idle intervals are not yet modeled with real Z fields, their inclusion in future implementations would improve physical realism. The simulation employs an exchange interaction strength of $J=1.52\times {10}^{11}$ Hz, resulting in $\sqrt{\mathrm{SWAP}}$ and SWAP gate durations of 15 ps and 30 ps, respectively—significantly shorter than single-qubit rotation pulses. Consequently, subsystem states ${\mathbb{H}}_j$ remain effectively stable during entangling operations.

Overall, these findings demonstrate that the proposed DRU-based architectures can be reliably compiled into the spin-based QPU simulation, achieving near-unity fidelities and physically interpretable pulse-level control across all tested configurations.

5.2. Noise Modeling Results

Next, a comprehensive experiment is conducted to evaluate the effect of CN and QN on the fidelity of quantum states produced by trained DRU circuits. Five DRU ansatzes (see Figure 1) are tested using the Iris dataset. For CN, we introduce random fluctuations in the transverse field amplitude across a logarithmic range of $0.001\le {\sigma }_{cn}\le 0.05$ [T]. For QN, we simulate dephasing processes over the interval $0.001\mu \le T_2\le 10\mu$ [s]. Afterward, fidelity is computed between the simulated QPU output states and the noise-free baseline states for all test samples.

As shown in Figure 11, fidelity consistently decreases with increasing ${\sigma }_{cn}$, reflecting stronger field amplitude perturbations under CN, and with decreasing $T_2$, due to faster decoherence under QN—trends that align with theoretical expectations [81]. These results demonstrate that our spin-based QPU simulation successfully captures both noise mechanisms and their impact on quantum state degradation. Importantly, the inclusion of CN and QN within our simulation framework highlights its capability to model realistic spin-based quantum processors. Since near-term quantum devices operate in the NISQ regime, the ability to incorporate both error sources is essential for evaluating algorithmic robustness and reliability.

5.3. Quantum Classification Results

As an illustrative example, Figure 12 shows the underlying structure of the Iris dataset through a 2D Principal Component Analysis (PCA) projection and its corresponding Bloch sphere representations obtained from the one-qubit DRU circuit. The visualization highlights how the data evolves from randomly initialized embeddings to optimized quantum feature representations after training. This transformation demonstrates how the trained spin-based DRU parameters reshape the input manifold, enhancing inter-class separability and geometric clustering in the Bloch space. So, the circuit effectively encodes non-linear decision boundaries in a physically interpretable quantum state space.

Figure 13 presents the benchmarking results for our spin-based DRU quantum classifier. Specifically, the plots correspond to the one-qubit DRU ansatz across different layer configurations ($N_L=3,5,10$), where the AUC is reported. Each cell represents the average AUC from a 5-fold cross-validation across multiple loss functions. The best performance is achieved for $N_L=5$, which exhibits greater robustness against both CN and QN. This finding is consistent with theoretical expectations, as lower ${\sigma }_{cn}$ values and longer $T_2$ coherence times preserve state fidelity and enhance classification performance.

To assess the statistical significance of these findings, the Friedman test [82] was applied across all ansatzes and layer configurations.

Table 2. Average ranking (Friedman test) of loss criteria across DRU ansatzes on a spin-based QPU. For each configuration, the best and second-best criteria are shown with mean ranks (in parentheses), along with the Friedman statistic and p-value.

Configuration	Best (Rank)	Second (Rank)	Friedman	p-Value
$N_q=1,N_L=3,\mathrm{Ent}=\mathit{False}$	VN (1.91)	Rényi $\alpha =0.5$ (2.31)	112.7	$0.00\times {10}^0$
$N_q=1,N_L=5,\mathrm{Ent}=\mathit{False}$	VN (2.23)	Rényi $\alpha =0.5$ (2.91)	38.54	$8.65\times {10}^{-8}$
$N_q=1,N_L=10,\mathrm{Ent}=\mathit{False}$	Rényi $\alpha =0.5$ (2.36)	Fidelity (2.68)	106.8	$3.53\times {10}^{-22}$
$N_q=2,N_L=3,\mathrm{Ent}=\mathit{False}$	Rényi $\alpha =0.5$ (2.28)	VN (2.34)	77.47	$5.98\times {10}^{-16}$
$N_q=2,N_L=5,\mathrm{Ent}=\mathit{False}$	VN (2.28)	Rényi $\alpha =0.5$ (2.58)	70.83	$1.51\times {10}^{-14}$
$N_q=2,N_L=10,\mathrm{Ent}=\mathit{False}$	VN (2.11)	Fidelity (2.76)	58.36	$6.41\times {10}^{-12}$
$N_q=2,N_L=3,\mathrm{Ent}=\mathit{True}$	VN (2.18)	Rényi $\alpha =0.5$ (2.61)	83.03	$3.97\times {10}^{-17}$
$N_q=2,N_L=5,\mathrm{Ent}=\mathit{True}$	VN (2.18)	Rényi $\alpha =0.5$ (2.64)	87.47	$4.55\times {10}^{-18}$
$N_q=2,N_L=10,\mathrm{Ent}=\mathit{True}$	VN (2.22)	Rényi $\alpha =0.5$ (2.67)	90.13	$1.24\times {10}^{-18}$
$N_q=4,N_L=3,\mathrm{Ent}=\mathit{False}$	Rényi $\alpha =0.5$ (2.02)	VN (2.37)	86.77	$6.40\times {10}^{-18}$
$N_q=4,N_L=5,\mathrm{Ent}=\mathit{False}$	VN (2.25)	Rényi $\alpha =0.5$ (2.41)	74.05	$3.16\times {10}^{-15}$
$N_q=4,N_L=10,\mathrm{Ent}=\mathit{False}$	VN (2.32)	Trace (2.57)	21.29	$2.77\times {10}^{-4}$
$N_q=4,N_L=3,\mathrm{Ent}=\mathit{True}$	VN (1.95)	Fidelity (2.82)	144.8	$2.61\times {10}^{-30}$
$N_q=4,N_L=5,\mathrm{Ent}=\mathit{True}$	Rényi $\alpha =0.5$ (2.30)	VN (2.58)	86.92	$5.95\times {10}^{-18}$
$N_q=4,N_L=10,\mathrm{Ent}=\mathit{True}$	VN (2.39)	Trace (2.84)	7.41	$1.16\times {10}^{-1}$

Notes: VN: von Neumann divergence; Rényi α: Rényi divergence of order α; Fidelity: fidelity-based loss; Trace: trace distance. Lower mean rank indicates better performance. Bold entries highlight the best criterion per configuration.

summarizes the average ranking for each loss function. The test confirms significant differences among the evaluated losses ($p<0.05$ in all cases except for DRU4QE with $N_L=10$), indicating that the observed performance rankings are statistically reliable. Overall, the VN divergence and Rényi divergence with $\alpha =0.5$ consistently achieved the best results across most configurations, suggesting that these entropy-based criteria are particularly well-suited for training gate-level DRU models under realistic spin-based QPU conditions.

Importantly, this study adopts the AUC metric instead of accuracy. The latter can be misleading in imbalanced datasets, where a model biased toward the majority class may yield artificially high accuracy—a phenomenon known as the accuracy paradox. In the context of quantum classification, this issue is exacerbated by the system’s intrinsic relaxation dynamics. Although the depolarization time $T_1$ is longer than the coherence time $T_2$, it still introduces bias, as the quantum state tends to relax toward the ground state $|0\rangle$. This can inflate accuracy scores and obscure the model’s actual discriminative power. The AUC measure, by contrast, provides a more balanced and noise-resilient assessment of classifier performance.

6. Conclusions

We introduced a pulse-driven quantum machine learning paradigm that bridges algorithmic modeling and physical realization on spin-based quantum processing units (QPU-SB). Built upon the Data Re-Uploading (DRU) algorithm, the framework translates gate-level operations into time-domain pulse controls governed by the Loss–DiVincenzo Hamiltonian. By explicitly incorporating both coherent and quantum noise sources—modeled through stochastic control perturbations and Lindblad dynamics, our proposal establishes a comprehensive route to simulate and train quantum classifiers under realistic device conditions. Remarkably, our framework extends beyond abstract gate-based learning, providing a physically interpretable and experimentally aligned methodology to explore the interplay between quantum information encoding, spin-qubit control, and noise resilience in the NISQ regime.

The experimental results demonstrate that the proposed pulse-level DRU compilation preserves the functional integrity of gate-level quantum circuits, achieving near-unity fidelities across all tested spin configurations. Also, continuous-time simulations reveal that our approach accurately captures both oscillations and exchange-coupling dynamics, validating its consistency with spin-qubit control physics. In fact, when noise is introduced, the model exhibits predictable fidelity degradation with increasing amplitude fluctuations and reduced coherence times, confirming the realism of the noise-aware simulation. Moreover, classification benchmarks on the Iris dataset show that the trained spin-based DRU models effectively capture decision boundaries, improving class separability through physically interpretable embeddings. Also, divergence-based loss functions—particularly the von Neumann and Rényi divergences—yielded superior robustness and AUC performance compared to fidelity-based criteria, reinforcing their suitability for quantum classification under noisy environments.

Future work includes the experimental deployment of the proposed framework on real spin-qubit hardware, leveraging programmable exchange interactions and CMOS-compatible control lines to validate the pulse-level simulation and its correspondence with physical spin dynamics. Extending the model to multi-qubit DRU architectures and hybrid quantum–classical optimization routines will enhance scalability and expressivity [41]. Further, advanced noise characterization—particularly for non-Markovian environments and correlated dephasing—will allow the design of adaptive, error-attentive training protocols [83]. Moreover, integrating pulse-level learning with quantum control theory may enable self-calibrating classifiers capable of compensating for device imperfections in situ [84]. Lastly, we will also integrate a realistic measurement model by simulating quantum state tomography to reconstruct the final output states of the QPU-SB. This approach will allow for the analysis of statistical errors arising from finite-shot measurements, effectively introducing shot noise into the evaluation of expectation values. Such an extension will offer a more accurate assessment of the algorithm’s performance under experimental conditions [85,86].