Pulse-Based Quantum Machine Learning

• Pulse-based QML is a framework using time-dependent controls and pulse parametrization to directly harness hardware dynamics for enhanced quantum model performance.
• It integrates native waveform processing and hardware-aware compilation to optimize pulse sequencing, reducing schedule duration and mitigating noise effects.
• Key techniques include control-theoretic analysis, pulse-efficient transpilation, and direct state-transfer fidelity improvements, achieving competitive performance on NISQ hardware.

Pulse-based quantum machine learning (QML) denotes a family of quantum-learning approaches in which the physically implemented control layer of a quantum device enters the model more directly than in standard gate-centric formulations. In the most restrictive usage, the trainable object is the time-dependent control itself: pulse amplitudes, phases, widths, durations, or related Hamiltonian controls. In broader usage, the term also covers hardware-aware pulse-efficient compilation for variational models and waveform-native quantum models that operate on pulse data as inputs. Across these variants, the shared premise is that the gate abstraction can hide physically relevant structure—control bandwidth, schedule duration, Hamiltonian topology, calibration, and readout modality—that materially affects expressivity, trainability, and noise resilience on NISQ hardware (Alexander et al., 2020, Melo et al., 2022, Tao et al., 2024, Franz et al., 20 May 2026).

1. Scope and conceptual foundations

The pulse-based literature spans several distinct but related agendas. One strand formulates QML directly as controlled continuous-time quantum dynamics, with prediction produced by an observable measured after pulse-driven evolution. A standard form used repeatedly is

$$\ket{\dot\psi(t;x)}=-i\left[H_0(x)+\sum_{k=1}^p \theta_k(t)H_k\right]\ket{\psi(t;x)}, \qquad f(x;\Theta(t))=\langle \psi(T;x)|M|\psi(T;x)\rangle,$$

where $H_0(x)$ encodes input data and $\theta_k(t)$ are trainable controls (Tao et al., 2024, Tao et al., 2024). A second strand keeps a gate-level learning architecture but replaces part of its compiled realization by native microwave pulses or pulse-efficient schedules, so that the relevant optimization variable is no longer only a logical gate angle or circuit depth but also the schedule duration and pulse decomposition (Melo et al., 2022, Nola et al., 2024, Acedo et al., 11 Dec 2025). A third strand treats sampled pulse waveforms themselves as the learning object, as in detector pulse-shape discrimination with amplitude-encoded quantum states (Napolitano, 9 Dec 2025).

This breadth creates a recurring terminological ambiguity. In some papers, pulse-based QML means direct optimization in control space; in others, it means pulse-aware compilation; in still others, it means quantum learning on pulse data. The literature nevertheless converges on a common hardware-native viewpoint: gates are not the primitive physical operations of superconducting devices, and learning schemes that expose pulse-level structure may better exploit limited coherence time, native couplings, and measurement-stack information than idealized circuit abstractions (Alexander et al., 2020, Melo et al., 2022, Franz et al., 20 May 2026).

2. Pulse-native architectures and model classes

One of the earliest explicitly pulse-native QML constructions in this corpus is the single-qubit feed-forward block proposed for pulsed qubits. There, a classical affine preactivation is mapped directly to a pulse amplitude,

$\mathpzc{A}=\frac{2}{\pi}\left(\langle \mathbf w,\mathbf x\rangle+b\right),$

and the probability of measuring $\ket{1}$ under resonant driving obeys

$P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\mathpzc{A}\bigg).$

With a train of pulses, the rotations accumulate,

$P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\sum_{j=1}^{i}\mathpzc{A}_j\bigg) =\sin^2\!\big(\langle \mathbf w_i,\mathbf x\rangle+b_i+\varrho_i\big),$

where $\varrho_i$ collects the contribution of preceding pulses. This yields a pulse-level feed-forward block, denoted a Perthro block, in which a single qubit and a sequence of calibrated Gaussian pulses generate a vector of neuron-like outputs with a $\sin^2$ activation and a built-in cumulative offset (Hammes et al., 2023).

A second class replaces variational gates in data-reuploading models by native pulse controls. In the single-qubit block of the pulsed re-uploading model,

$$U^{\text{pulse}}_{(q)}(\nu_1,\nu_2,\Omega,\gamma) = V^{(q)}_{z}(\nu_1)\,U[(\Omega,\gamma)]\,V^{(q)}_{z}(\nu_2),$$

the trainable parameters are two virtual-$H_0(x)$0 angles, a pulse amplitude, and a pulse phase. The two-qubit layer uses a cross-resonance-inspired entangling pulse with trainable amplitude, phase, and detuning. Architecturally, the model preserves the layered logic of data re-uploading—encoding block, single-qubit variational blocks, and entangling block—but moves the variational part into pulse space on a simulated superconducting transmon processor (Acedo et al., 11 Dec 2025).

A more control-oriented variant learns a single microwave DRAG pulse that reproduces the action of a target single-qubit transformation or a short gate sequence. In that setting, pulses are parameterized by duration, signed modulus, argument, variance, correction amplitude, and phase, with the effective signed modulus bounded by

$H_0(x)$1

The objective is state-transfer fidelity across sampled input states rather than explicit process fidelity over a complete operator basis, so the learned pulse is best interpreted as sampled transformation matching rather than certified universal gate synthesis (Nola et al., 2024).

The software literature systematizes these constructions by treating pulse envelopes as composable differentiable objects. In QML-ESSENTIALS, pulse-based gates are built from time-dependent Hamiltonians

$H_0(x)$2

with carrier-modulated envelopes such as Gaussian, Rectangle, Raised Cosine, DRAG, and Hyperbolic Secant, and propagated by

$H_0(x)$3

This framework explicitly supports hybrid gate-plus-pulse models, end-to-end optimization of pulse parameters, and pulse-backed implementations of basis gates $H_0(x)$4 (Franz et al., 20 May 2026).

3. Expressivity, nonlinearity, and controllability

The control-theoretic literature places pulse-based QML on a more formal footing. A central result is that pulse-based models can be derived as the continuous-time limit of gate-based data re-uploading. For a one-qubit re-uploading block,

$H_0(x)$5

and, as $H_0(x)$6 with fixed total time $H_0(x)$7, this yields a pulse-based Schrödinger equation. In this formulation, the useful nonlinearity of pulse-based QML is attributed not to nonlinear quantum dynamics but to the encoding process—the continuous-time analogue of repeated data re-uploading—together with measurement (Tao et al., 2024).

The same work proves a universal-approximation statement under ensemble controllability. If the underlying system is ensemble controllable, the pulse-based model can approximate arbitrary nonlinear functions; an easy-to-check sufficient condition is

$H_0(x)$8

with the stronger analytic-function condition expressed through a Lie algebra containing polynomially weighted $H_0(x)$9 generators. Numerically, that framework reports increased expressivity with longer pulse duration, finer pulse discretization, and larger qubit number, and it argues that pulse-based models can be “infinitely” deep within the same physical runtime because the pulse waveform may be discretized arbitrarily finely without extending total evolution time (Tao et al., 2024).

Subsequent work qualifies this expressivity result by tying it to trainability. Using a Fliess-series expansion,

$\theta_k(t)$0

with coefficients built from iterated pulse integrals and nested Liouvillian actions, the controllability literature derives a necessary condition for expressivity: if there exists some $\theta_k(t)$1 such that $\theta_k(t)$2, then the model cannot approximate arbitrary analytic functions. This makes expressivity depend not only on the control Lie algebra but also on the initial state, the observable, and the operator sectors activated by the data Hamiltonian (Tao et al., 2024). A related dynamic-symmetry analysis reaches the same conclusion through a Dyson-series expansion and shows that trainable symmetry-restricted models require careful co-design of the dynamical Lie algebra, initial state, observable, and pulse parameterization to remain expressive (Tao et al., 7 Aug 2025).

These analyses turn controllability into the central trade-off variable. Full or ensemble controllability can imply universal approximation, but sufficiently deep controllable systems can approach approximate unitary $\theta_k(t)$3-designs and exhibit barren plateaus. Restricted models evolving on low-dimensional manifolds—such as an embedded $\theta_k(t)$4 irrep in a higher-dimensional Hilbert space—are proposed as a way to retain enough expressivity while improving gradient behavior (Tao et al., 2024). Dynamic symmetry is presented more explicitly as a route to trainability because variance scales inversely with $\theta_k(t)$5, where $\theta_k(t)$6 is the dynamical Lie algebra, so polynomially growing algebras such as $\theta_k(t)$7 or $\theta_k(t)$8 avoid the exponential concentration associated with full $\theta_k(t)$9 (Tao et al., 7 Aug 2025).

Pulse-level quantum Fourier models add a complementary perspective. In that formalism,

$\mathpzc{A}=\frac{2}{\pi}\left(\langle \mathbf w,\mathbf x\rangle+b\right),$0

and pulse parameters are shown not to change the encoded frequency set $\mathpzc{A}=\frac{2}{\pi}\left(\langle \mathbf w,\mathbf x\rangle+b\right),$1. For basis gates they act largely as reparameterizations, $\mathpzc{A}=\frac{2}{\pi}\left(\langle \mathbf w,\mathbf x\rangle+b\right),$2, but for composite logical gates independent pulse scalings can replace one logical angle by several independently tunable sub-angles. The resulting extended Jacobian can have larger rank than the gate-level Jacobian, so pulse parameters create new local tangent directions in coefficient space even when global expressibility and FCC change little. The reported conclusion is therefore not that pulse control radically enlarges the global hypothesis class, but that it changes the local optimization geometry and can provide higher-dimensional escape routes from non-global stationary points (Strobl et al., 6 May 2026).

4. Compilation layers, software infrastructure, and pulse programming

The enabling hardware interface for much of this literature is Qiskit Pulse, which exposes pulses, channels, instructions, and schedules below the circuit model. Pulses are complex envelope sample sequences $\mathpzc{A}=\frac{2}{\pi}\left(\langle \mathbf w,\mathbf x\rangle+b\right),$3 with ideal output

$\mathpzc{A}=\frac{2}{\pi}\left(\langle \mathbf w,\mathbf x\rangle+b\right),$4

The programming model includes Play, Delay, ShiftPhase, SetFrequency, and Acquire instructions, with DriveChannel, MeasureChannel, ControlChannel, and AcquireChannel corresponding to different physical signal paths. The paper also demonstrates access to readout levels 0, 1, and 2—raw, kerneled IQ, and discriminated data—which is directly relevant to pulse-native readout learning and custom discrimination (Alexander et al., 2020).

That same infrastructure underlies hardware-native calibration. Qiskit Pulse is used to calibrate un-echoed and echoed cross-resonance gates on cloud-accessible IBM hardware, characterize effective Hamiltonian coefficients from process tomography, and turn the resulting pulse schedules into high-fidelity CNOT implementations. The reported average gate fidelities are $\mathpzc{A}=\frac{2}{\pi}\left(\langle \mathbf w,\mathbf x\rangle+b\right),$5 for the un-echoed construction and $\mathpzc{A}=\frac{2}{\pi}\left(\langle \mathbf w,\mathbf x\rangle+b\right),$6 for the echoed construction, compared with a standard backend CNOT fidelity of $\mathpzc{A}=\frac{2}{\pi}\left(\langle \mathbf w,\mathbf x\rangle+b\right),$7 (Alexander et al., 2020). This established, at least for superconducting hardware with cross-resonance interactions, that user-defined pulse schedules could approach production-calibrated two-qubit performance.

A less direct but practically important development is pulse-efficient transpilation. Instead of learning pulses from scratch, this compilation strategy rewrites two-qubit logic in terms of native parameterized $\mathpzc{A}=\frac{2}{\pi}\left(\langle \mathbf w,\mathbf x\rangle+b\right),$8 interactions implemented by cross-resonance pulses, reduces schedule duration, and cancels redundant one-qubit operations. The resulting shorter schedules improve QNN classification, improve kernel estimation for MNIST, and delay the onset of noise-induced barren plateaus in a Hamiltonian Variational Ansatz; the paper explicitly frames this as pulse-aware, hardware-native compilation rather than direct pulse learning (Melo et al., 2022).

QML-ESSENTIALS extends this ecosystem by embedding pulse-level modeling inside a broader QML software stack. It supports composable ansatz blocks, pulse-backed gate libraries, differentiable pulse simulation in JAX, quantum optimal control with Adam, and Fourier-analytic diagnostics such as Fourier coefficient correlation. The framework is designed precisely to bridge abstract QML formalisms and hardware-aware pulse optimization, rather than treating pulse control as a separate calibration phase (Franz et al., 20 May 2026).

5. Empirical tasks and reported performance

The most explicit pulse-native feed-forward experiments use the Perthro block on XOR, Iris, and Airfoil Self-Noise. For XOR, a single $\mathpzc{A}=\frac{2}{\pi}\left(\langle \mathbf w,\mathbf x\rangle+b\right),$9 block—one qubit and two pulses—followed by a classical thresholding rule matched XOR ground truth in $\ket{1}$0 of 1024 hardware trials, i.e. $\ket{1}$1. For Iris, a three-block architecture $\ket{1}$2, $\ket{1}$3, $\ket{1}$4 corresponds classically to a 6-12-3 feed-forward network with sine-squared activations but uses only three qubits; the reported simulated test accuracy is $\ket{1}$5, and hardware accuracy on IBM Armonk is $\ket{1}$6. For Airfoil Self-Noise regression, the reported test MSE is $\ket{1}$7 in simulation and $\ket{1}$8 on IBM Armonk (Hammes et al., 2023).

Direct pulse learning for gate condensation is more modest in scope but quantitatively sharp. Using Qiskit Dynamics and PyTorch on an ibmq_armonk backend model, a single learned DRAG pulse reproduces a specific three-rotation target sequence with reported infidelity

$\ket{1}$9

corresponding to fidelity $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\mathpzc{A}\bigg).$0. The same study reports low infidelities for learned $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\mathpzc{A}\bigg).$1, $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\mathpzc{A}\bigg).$2, $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\mathpzc{A}\bigg).$3, $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\mathpzc{A}\bigg).$4, $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\mathpzc{A}\bigg).$5, and $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\mathpzc{A}\bigg).$6 targets after 100 epochs, and includes a narrow hardware sanity check in which a Hadamard built from a learned $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\mathpzc{A}\bigg).$7 pulse and native $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\mathpzc{A}\bigg).$8 gates produces output probabilities “nearly identical” to the native implementation (Nola et al., 2024).

Pulse-native reformulation of data re-uploading gives a more directly QML-oriented benchmark. On a noisy simulated transmon processor modeled after IBM Brisbane, and on binary MNIST $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\mathpzc{A}\bigg).$9 versus $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\sum_{j=1}^{i}\mathpzc{A}_j\bigg) =\sin^2\!\big(\langle \mathbf w_i,\mathbf x\rangle+b_i+\varrho_i\big),$0 classification after 3D PCA, the pulse-based re-uploading model reaches approximately $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\sum_{j=1}^{i}\mathpzc{A}_j\bigg) =\sin^2\!\big(\langle \mathbf w_i,\mathbf x\rangle+b_i+\varrho_i\big),$1 test accuracy across a broad range of layer counts, whereas the gate-based counterpart stays around $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\sum_{j=1}^{i}\mathpzc{A}_j\bigg) =\sin^2\!\big(\langle \mathbf w_i,\mathbf x\rangle+b_i+\varrho_i\big),$2. In a two-qubit, 20-layer setting with increasing depolarizing probability $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\sum_{j=1}^{i}\mathpzc{A}_j\bigg) =\sin^2\!\big(\langle \mathbf w_i,\mathbf x\rangle+b_i+\varrho_i\big),$3, the pulse-based model maintains about $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\sum_{j=1}^{i}\mathpzc{A}_j\bigg) =\sin^2\!\big(\langle \mathbf w_i,\mathbf x\rangle+b_i+\varrho_i\big),$4 test accuracy up to approximately $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\sum_{j=1}^{i}\mathpzc{A}_j\bigg) =\sin^2\!\big(\langle \mathbf w_i,\mathbf x\rangle+b_i+\varrho_i\big),$5, while the gate-based model degrades substantially earlier (Acedo et al., 11 Dec 2025).

Noise-aware pulse design for state preparation gives a different empirical picture: here the task is arbitrary quantum state preparation for a two-level system coupled to a bosonic bath. Pulse sequences are chosen from a discrete action set $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\sum_{j=1}^{i}\mathpzc{A}_j\bigg) =\sin^2\!\big(\langle \mathbf w_i,\mathbf x\rangle+b_i+\varrho_i\big),$6, $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\sum_{j=1}^{i}\mathpzc{A}_j\bigg) =\sin^2\!\big(\langle \mathbf w_i,\mathbf x\rangle+b_i+\varrho_i\big),$7, over a horizon $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\sum_{j=1}^{i}\mathpzc{A}_j\bigg) =\sin^2\!\big(\langle \mathbf w_i,\mathbf x\rangle+b_i+\varrho_i\big),$8 with $P(\ket{1})=\sin^2\!\bigg(\frac{\pi}{2}\sum_{j=1}^{i}\mathpzc{A}_j\bigg) =\sin^2\!\big(\langle \mathbf w_i,\mathbf x\rangle+b_i+\varrho_i\big),$9 steps. Environment-conditioned learning, in which $\varrho_i$0 are fed to the network, performs comparably to environment-specific training and allows one trained model to infer pulses across multiple noise settings. The reported comparison between DRL and SL shows DRL outperforming in low-noise settings and SL performing more stably in stronger noise; for example, in preparing $\varrho_i$1 from $\varrho_i$2, DRL attains fidelity $\varrho_i$3 versus $\varrho_i$4 for SL at $\varrho_i$5, whereas SL attains $\varrho_i$6 versus $\varrho_i$7 for DRL at $\varrho_i$8 (Wang et al., 28 Aug 2025).

A broader, waveform-native use of the term appears in germanium-detector pulse-shape discrimination. There, 1024-sample current pulses are amplitude-encoded into a 10-qubit state,

$\varrho_i$9

and processed by a 10-layer strongly entangling VQC with 300 quantum parameters plus a 2-parameter classical sigmoid readout. On an independent test set of 11,377 waveforms, the reported performance is ROC AUC $\sin^2$0, accuracy $\sin^2$1, signal efficiency $\sin^2$2, and background rejection $\sin^2$3, with only 302 trainable parameters and no denoising autoencoder. This is not pulse-native control learning in the narrow sense, but it shows that pulse morphology can itself be the native object of quantum inference (Napolitano, 9 Dec 2025).

6. Limitations, controversies, and research directions

A first recurring limitation is that pulse-based QML does not have a single, universally accepted meaning. The literature ranges from direct pulse-level parameterization of controls, to pulse-efficient transpilation, to amplitude-encoded learning on pulse waveforms. This suggests that “pulse-based” names a family resemblance rather than a single formal class of models, and comparisons across papers require care because the trainable object may be a control field, a schedule, a waveform input, or merely a hardware-aware compilation choice (Melo et al., 2022, Napolitano, 9 Dec 2025).

A second recurring issue is that pulse-level access does not automatically imply a uniquely quantum source of nonlinearity or an immediate computational advantage. The Perthro architecture derives its activation from the measured sinusoidal response of a driven qubit and its cumulative rotations, not from entanglement or exponentially large Hilbert spaces (Hammes et al., 2023). The control-theoretic literature likewise stresses that nonlinearity comes from encoding and continuous reinteraction with trainable controls, not from nonlinear quantum mechanics (Tao et al., 2024). In pulse-level quantum Fourier models, global expressibility and FCC remain largely unchanged when pulse parameters are added; the strongest effect is local optimization geometry rather than global spectral enlargement (Strobl et al., 6 May 2026).

Third, expressivity and trainability are in persistent tension. Full controllability or ensemble controllability can certify universal approximation, but the same dynamical richness can drive the model toward approximate unitary $\sin^2$4-design behavior and barren plateaus. The response in recent work is not to maximize controllability indiscriminately, but to engineer structured, partially controllable models—via low-dimensional manifolds or dynamic symmetry—that keep $\sin^2$5 moderate while preserving the operator sectors needed for the target task (Tao et al., 2024, Tao et al., 7 Aug 2025).

Fourth, many present demonstrations remain small-scale, simulation-heavy, or hardware-constrained. The DRAG pulse-learning study is single-qubit and mostly simulation-based, with no full process-fidelity certification (Nola et al., 2024). The pulse-native re-uploading study is limited to one- and two-qubit models and simulated IBM Brisbane noise (Acedo et al., 11 Dec 2025). The Perthro implementation notes pulse-programming restrictions such as short maximum pulse trains, resets, and calibration burden on current hardware (Hammes et al., 2023). In waveform-native QML, amplitude encoding compresses 1024 features to 10 qubits representationally, but exact state preparation remains the main scalability bottleneck and may require $\sin^2$6 depth in general (Napolitano, 9 Dec 2025).

A final theme is software and methodology. Qiskit Pulse established that cloud-access pulse programming, Hamiltonian characterization, and custom readout are feasible (Alexander et al., 2020). More recent software explicitly seeks to integrate pulse-level control, quantum optimal control, and Fourier-analytic QML diagnostics in one environment (Franz et al., 20 May 2026). This suggests a mature future pulse-based QML workflow in which ansatz design, pulse realization, readout modeling, and spectral analysis are treated jointly rather than sequentially. The literature does not yet provide a single dominant recipe, but it consistently points toward hardware-native co-design: choosing encoding Hamiltonians, symmetry class, initial state, observable, pulse ansatz, and compilation layer together, rather than optimizing each abstraction boundary in isolation (Tao et al., 2024, Tao et al., 7 Aug 2025, Franz et al., 20 May 2026).