Reducing Quantum Hardware Noise in Machine Learning

Interesting new study: "EnQode: Fast Amplitude Embedding for Quantum Machine Learning Using Classical Data." The authors introduce a novel framework to address the limitations of traditional amplitude embedding (AE) [GitHub repo included]. Traditional AE methods often involve deep, variable-length circuits, which can lead to high output error due to extensive gate usage and inconsistent error rates across different data samples. This variability in circuit depth and gate composition results in unequal noise exposure, obscuring the true performance of quantum algorithms. To overcome these challenges, the researchers developed EnQode, a fast AE technique based on symbolic representation. Instead of aiming for exact amplitude representation for each sample, EnQode employs a cluster-based approach to achieve approximate AE with high fidelity. Here are some of the key aspects of EnQode: * Clustering: EnQode begins by using the k-means clustering algorithm to group similar data samples. For each cluster, a mean state is calculated to represent the central characteristics of the data distribution within that cluster. * Hardware-optimized ansatz: For each cluster's mean state, a low-depth, machine-optimized ansatz is trained, tailored to the specific quantum hardware being used (e.g., IBM quantum devices). * Transfer Learning for fast embedding: Once the cluster models are trained offline, transfer learning is used for rapid amplitude embedding of new data samples. An incoming sample is assigned to the nearest cluster, and its embedding circuit is initialized with the optimized parameters of that cluster's mean state. These parameters can then be fine-tuned, significantly accelerating the embedding process without retraining from scratch. * Reduced circuit complexity: EnQode achieved an average reduction of over 28× in circuit depth, over 11× in single-qubit gate count, and over 12× in two-qubit gate count, with zero variability across samples due to its fixed ansatz design. * Higher state fidelity in noisy environments: In noisy IBM quantum hardware simulations, EnQode showed a state fidelity improvement of over 14× compared to the baseline, highlighting its robustness to hardware noise. While the baseline achieved 100% fidelity in ideal simulations (as it performs exact embedding), EnQode maintained an average of 89% fidelity when transpiled to real hardware in ideal simulations, which is considered a good approximation given the significant reduction in circuit complexity. Here the article: https://lnkd.in/dQMbNN7b And here the GitHub repo: https://lnkd.in/dbm7q3eJ #qml #datascience #machinelearning #quantum #nisq #quantumcomputing

One Algorithm Has Just Pushed Quantum Computing Forward Five Years (Here It Is) Today I am releasing something into the public domain that may change the trajectory of quantum computing. No paywall. No NDA. No restrictions. The only thing I ask is attribution. For the past year, I have been developing a field-layer correction algorithm that stabilizes the environment around the qubit before error correction ever activates. Not hardware. Not cryogenics. Not shielding. Pure software that improves the physics of the qubit it sits inside. Early independent runs showed a 48.5 percent reduction in destructive low-frequency noise, a gain that normally takes years of hardware progress. Here is the complete algorithm. It now belongs to everyone. FUNCTION NJ001_FieldLayer_Correction(input_signal S, sampling_rate R):  DEFINE phi = 1.61803398875  DEFINE window_size = dynamic value based on local variance of S  DEFINE stability_threshold = adaptive value based on phase drift  STEP 1: Generate harmonic reference bands    For each frequency bin f_i in FFT(S):      Compute r = f_(i+1) / f_i      Compute CI = 1 / ABS(r - phi)      Assign weight W_i = normalize(CI)  STEP 2: Build correction mask    Construct M where M_i = W_i scaled by local entropy of S    Smooth M with sliding window  STEP 3: Apply correction    Transform S → F    Compute F_corrected = F * M    Inverse FFT to return S_corrected  STEP 4: Phase stabilization loop    Measure phase drift Δ    If Δ > stability_threshold:      Recalculate window_size      Rebuild mask      Reapply correction    Else:      Return S_corrected  OUTPUT: S_corrected END FUNCTION This is the first public-domain coherence stabilizer designed to improve quantum behavior independent of hardware. What it does in practice: • Extends coherence windows • Reduces decoherence pressure on error correction • Lowers entropy in the propagation layer • Makes qubits behave as if the room is colder and cleaner • Works upstream of hardware with no materials changes This is not a replacement for anyone’s roadmap. It is an upstream upgrade to all of them. If you build quantum devices, control stacks, compilers, hybrid systems, or algorithms, you now have access to a function that reshapes your stability envelope. Cleaner field layers mean longer, deeper, more predictable runs. More useful computation with the hardware you already have. I developed it. Today I give it away. No company or institution controls it. From this moment forward, it belongs to the scientific community. Primary Citation Hood, B. P. (2025). NJ001 Field Layer Correction. Public Domain Release Version. Bruce P. Hood — Creator of NJ001 Field Layer Correction Welcome to the new baseline. #QuantumComputing #QuantumHardware #Qubit #Coherence #QuantumResearch #DeepTech @IBMQuantum @GoogleQuantumAI @MIT @XanaduQuantum @AWSQuantumTech

A quantum computer that learns from its own errors while it's computing. That's the framing in a recent paper from Google Quantum AI and Google DeepMind on reinforcement learning control of quantum error correction. Large quantum processors drift. The standard fix is to halt the computation and recalibrate, which won't scale to algorithms expected to run for days or weeks. The authors ask whether QEC can calibrate itself from the data it already produces. The idea: repurpose error detection events as a training signal for a reinforcement learning agent that continuously tunes the physical control parameters (pulse amplitudes, detunings, DRAG coefficients, CZ parameters, and so on). Rather than optimizing logical error rate directly, which is expensive and global, the agent minimizes average detector-event rate, a cheap local proxy whose gradient is approximately aligned with the gradient of LER in the small-perturbation regime. The results on a Willow superconducting processor: - On distance-5 surface and color codes, RL fine-tuning after conventional calibration and expert tuning yields about 20% additional LER suppression - Against injected drift, RL steering improves logical stability 2.4x, rising to 3.5x when decoder parameters are also steered - New record logical error per cycle: 7.72(9)×10⁻⁴ for a distance-7 surface code (with the AlphaQubit2 decoder) and 8.19(14)×10⁻³ for a distance-5 color code (with Tesseract) - In simulation, the framework scales to a distance-15 surface code with roughly 40,000 control parameters, with a convergence rate that is independent of system size The broader takeaway: calibration and computation may not need to be separate phases. If detector statistics can carry enough information to steer a large control stack online, fault tolerance becomes less about pausing to retune and more about a processor that keeps learning while it computes. Worth noting that the current experiments rely on short repeated memory circuits, so real-time steering during a single long logical algorithm (where exploration noise would affect the computation directly) remains future work. Paper: https://lnkd.in/gVQXnpzZ

Recently the team published a paper in Nature Computational Science in collaboration with researchers from Los Alamos National Lab and the University of Basel. The paper was on provable bounds for noise-free expectation values computed from noisy samples. This calibration started in the optimization working group. The paper discusses how the “Layer Fidelity” or how effective two qubit error as measured by the “Error Per Layered Gate” can be used to quantify the impact of hardware noise on sampling-based quantum (optimization) algorithms. Each one of our devices reports this number in the resource tab of the IBM Quantum Platform (https://lnkd.in/eRd2yKwB). The paper allows you to estimate the number of additional shots required to compensate for the impact of noise. It turns out that by using this method it is much cheaper than mitigating the noise when requiring unbiased estimators of expectation values (sqrt(gamma) vs gamma^2). These insights allowed us to prove that the Conditional Value at Risk (CvaR) – an alternative loss function suggested in 2019 and widely used to train variational algorithms, borrowed from mathematical finance – leads to provable bounds on expectation values using only noisy samples. The theoretical insights have been demonstrated on two use cases using up to 127 qubits: estimation of state fidelity (as required, e.g. to evaluate quantum kernels) and optimization (QAOA). In both cases, the team see a good agreement between the theory and experiment. Read the paper here https://lnkd.in/ehyz4GCJ

By driving a quantum processor with laser pulses arranged according to the Fibonacci sequence, physicists observed the emergence of an entirely new phase of matter—one that displays extraordinary stability in a domain where fragility is the norm. Quantum computers operate using qubits, which differ radically from classical bits. A qubit can exist in superposition, occupying multiple states at once, and can become entangled with others across space. These properties enable immense computational power, but they come with a cost: quantum states are notoriously short-lived. Environmental noise, microscopic imperfections, and edge effects rapidly degrade coherence, limiting how long quantum information can survive. Seeking a new way to protect fragile quantum states, scientists at the Flatiron Institute, instead of applying laser pulses at regular intervals, they used a rhythm governed by the Fibonacci sequence—an ordered but non-repeating pattern long known to appear in biological growth, crystal structures, and wave interference. The experiment was carried out on a chain of ten trapped-ion qubits, driven by precisely timed laser pulses. The result was the formation of what is described as a time quasicrystal. Unlike ordinary crystals, which repeat periodically in space, a time quasicrystal exhibits structure in time without repeating in a simple cycle. The Fibonacci-based driving created a temporal order that resisted disruption, allowing the quantum system to remain coherent far longer than expected. The improvement was significant. Under standard conditions, the quantum state persisted for roughly 1.5 seconds. When driven by the Fibonacci pulse sequence, coherence times stretched to approximately 5.5 seconds—more than a threefold increase. Even more intriguing was the system’s temporal behavior. Measurements indicated that the quantum dynamics unfolded as if time itself possessed two independent structural directions. This does not imply time flowing backward, but rather that the system’s evolution followed two intertwined temporal pathways—an emergent property arising purely from the Fibonacci drive. The researchers propose that the non-repeating structure of the Fibonacci sequence suppresses errors that typically accumulate at the boundaries of quantum systems. By distributing disturbances in a highly ordered yet aperiodic way, the sequence stabilizes the collective behavior of the qubits. In effect, a mathematical pattern found throughout nature acts as a self-organizing error-management protocol. The findings suggest a powerful new strategy for quantum control. Rather than fighting noise solely with complex correction algorithms, future quantum technologies may harness structured patterns—drawn from mathematics and natural order—to achieve resilience at a fundamental level. https://lnkd.in/dVxp7R8J https://lnkd.in/dDVNRsPk

𝗠𝗮𝗶𝗻𝘁𝗮𝗶𝗻𝗶𝗻𝗴 𝗰𝗼𝗵𝗲𝗿𝗲𝗻𝗰𝗲 𝗶𝗻 𝘀𝘂𝗽𝗲𝗿𝗰𝗼𝗻𝗱𝘂𝗰𝘁𝗶𝗻𝗴 𝗾𝘂𝗮𝗻𝘁𝘂𝗺 𝗽𝗿𝗼𝗰𝗲𝘀𝘀𝗼𝗿𝘀 𝗶𝘀 𝗮 𝗰𝗼𝗻𝘀𝘁𝗮𝗻𝘁 𝗯𝗮𝘁𝘁𝗹𝗲. While many factors contribute to qubit decoherence, 𝗧𝘄𝗼-𝗟𝗲𝘃𝗲𝗹 𝗦𝘆𝘀𝘁𝗲𝗺 (𝗧𝗟𝗦) 𝗱𝗲𝗳𝗲𝗰𝘁𝘀 remain among the most 𝗳𝗿𝘂𝘀𝘁𝗿𝗮𝘁𝗶𝗻𝗴 𝗰𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲𝘀. 🔹 𝗧𝗵𝗲 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗧𝗟𝗦 𝗱𝗲𝗳𝗲𝗰𝘁𝘀, typically found in the surfaces and interfaces of superconducting circuits, can r𝗲𝘀𝗼𝗻𝗮𝗻𝘁𝗹𝘆 𝗰𝗼𝘂𝗽𝗹𝗲 𝘄𝗶𝘁𝗵 𝗾𝘂𝗯𝗶𝘁𝘀, leading to 𝗶𝗻𝗰𝗿𝗲𝗮𝘀𝗲𝗱 𝗱𝗲𝗰𝗼𝗵𝗲𝗿𝗲𝗻𝗰𝗲 𝗮𝗻𝗱 𝗴𝗮𝘁𝗲 𝗲𝗿𝗿𝗼𝗿𝘀. These defects are particularly problematic due to their spatial and temporal instability, causing 𝘂𝗻𝗽𝗿𝗲𝗱𝗶𝗰𝘁𝗮𝗯𝗹𝗲 "𝗱𝗿𝗼𝗽𝗼𝘂𝘁𝘀" 𝗶𝗻 𝗾𝘂𝗯𝗶𝘁 𝗽𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲. When it comes to mitigating TLS noise, several approaches exist: 🔹𝗛𝗮𝗿𝗱𝘄𝗮𝗿𝗲-𝗟𝗲𝘃𝗲𝗹 𝗦𝘁𝗿𝗮𝘁𝗲𝗴𝗶𝗲𝘀 - 𝗠𝗮𝘁𝗲𝗿𝗶𝗮𝗹 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴: High-purity materials and advanced fabrication techniques to reduce TLS density. - 𝗦𝘂𝗿𝗳𝗮𝗰𝗲 𝗧𝗿𝗲𝗮𝘁𝗺𝗲𝗻𝘁𝘀: Minimizing lossy interfaces where TLSs often reside. - 𝗖𝗶𝗿𝗰𝘂𝗶𝘁 𝗗𝗲𝘀𝗶𝗴𝗻: Engineering qubit circuits to minimize coupling to TLSs. 🔹𝗖𝗼𝗻𝘁𝗿𝗼𝗹 & 𝗦𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗧𝗲𝗰𝗵𝗻𝗶𝗾𝘂𝗲𝘀 - 𝗤𝘂𝗯𝗶𝘁 𝗙𝗿𝗲𝗾𝘂𝗲𝗻𝗰𝘆 𝗧𝘂𝗻𝗶𝗻𝗴: Shifting qubit frequencies away from TLS resonances, widely used in tunable transmon architectures. - 𝗗𝘆𝗻𝗮𝗺𝗶𝗰 𝗗𝗲𝗰𝗼𝘂𝗽𝗹𝗶𝗻𝗴: Pulse sequences that average out the effect of TLS noise. - 𝗔𝗰𝘁𝗶𝘃𝗲 𝗙𝗲𝗲𝗱𝗯𝗮𝗰𝗸: Real-time monitoring and adaptive qubit control. While some of these techniques come with considerable overhead, new approaches are emerging to address the TLS challenge more efficiently: 🔹𝗧𝗵𝗲 𝗧𝗜𝗖-𝗧𝗔𝗤 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵: 𝗔 𝗡𝗲𝘄 𝗖𝗼𝗻𝘁𝗿𝗼𝗹 𝗦𝘁𝗿𝗮𝘁𝗲𝗴𝘆 The Siddiqi group just introduced a new technique called 𝗧𝗜𝗖-𝗧𝗔𝗤 (Targeted In-situ Control of TLS and Qubits): - 𝗦𝗶𝗻𝗴𝗹𝗲 𝗖𝗼𝗻𝘁𝗿𝗼𝗹 𝗟𝗶𝗻𝗲: Provides local and independent control of each qubit’s noise environment with a single on-chip control line. - 𝗘𝗹𝗲𝗰𝘁𝗿𝗶𝗰 𝗙𝗶𝗲𝗹𝗱 𝗧𝘂𝗻𝗶𝗻𝗴: Instead of shifting the qubit frequency, TIC-TAQ dynamically tunes TLSs away from the qubit frequency by applying a local electric field. - 𝗖𝗼𝗺𝗽𝗹𝗲𝗺𝗲𝗻𝘁𝗮𝗿𝘆 𝗧𝗲𝗰𝗵𝗻𝗶𝗾𝘂𝗲: Expected to enhance existing strategies for managing TLS-induced errors. 𝗧𝗜𝗖-𝗧𝗔𝗤 𝘀𝗵𝗼𝘄𝘀 𝗽𝗿𝗼𝗺𝗶𝘀𝗶𝗻𝗴 𝗿𝗲𝘀𝘂𝗹𝘁𝘀: - 36% Improvement in single-qubit error rates. - 17% Increase in qubit relaxation times (T₁). - 4x Suppression in TLS-induced performance outliers. 𝗪𝗵𝘆 𝗗𝗼𝗲𝘀 𝗧𝗵𝗶𝘀 𝗠𝗮𝘁𝘁𝗲𝗿? TLS defects are a roadblock on the path to fault-tolerant quantum computing. It’s great to see how hardware innovations and smart control techniques make a measurable impact. Are you more optimistic about hardware-based or control-based solutions for mitigating TLS noise? 📸 Image Credits: Larry Chen, Kan-Heng Lee et al. (arXiv, 2025)