Explore dynamic/real-time device calibration data integration

[ddri]

Overview

The current DeviceNoiseModel implementation uses static, hardcoded parameters researched from vendor documentation. While useful for offline analysis and relative comparisons, this approach has limitations:

1. Calibration drift: Device parameters change over time (temperature, tuning)
2. Per-qubit variation: Real devices have different T1/T2/error rates per qubit
3. Accuracy gap: Research shows 5-72% deviation between predicted and actual fidelity

This issue explores options for integrating real-time calibration data from quantum cloud providers.

Industry Approaches

Amazon Braket

from braket.aws import AwsDevice

device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3")
props = device.properties

# Per-qubit T1/T2
t1 = props.standardized.oneQubitProperties['0'].T1
t2 = props.standardized.oneQubitProperties['0'].T2

# Per-gate fidelity
cx_fidelity = props.standardized.twoQubitProperties['0-1'].twoQubitGateFidelity

Braket Local Emulator (Jan 2025): Uses actual calibration data, achieves 0.982 correlation with Ankaa-3.

IBM Qiskit

from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_aer.noise import NoiseModel

service = QiskitRuntimeService()
backend = service.backend("ibm_brisbane")

# Build noise model from live calibration
noise_model = NoiseModel.from_backend(backend)

# Or access properties directly
props = backend.properties()
t1 = props.t1(qubit=0)
gate_error = props.gate_error('cx', [0, 1])

Proposed Options

Option A: Optional Live Fetching

Add optional fetch_calibration() method that updates DeviceNoiseModel from cloud APIs:

model = qf.IONQ_ARIA
model.fetch_calibration()  # Updates T1, T2, errors from AWS Braket
fid = model.circuit_fidelity(circ)

Pros: Simple API, backwards compatible
Cons: Requires AWS credentials, network dependency

Option B: Calibration Provider Interface

Abstract calibration data source behind an interface:

class CalibrationProvider(Protocol):
    def get_t1(self, qubit: int) -> float: ...
    def get_t2(self, qubit: int) -> float: ...
    def get_gate_error(self, gate: str, qubits: tuple) -> float: ...

class BraketCalibrationProvider(CalibrationProvider):
    def __init__(self, device_arn: str): ...

class StaticCalibrationProvider(CalibrationProvider):
    """Current behavior - uses hardcoded values"""

model = DeviceNoiseModel(
    name="ionq_aria",
    calibration=BraketCalibrationProvider("arn:aws:braket:...")
)

Pros: Flexible, testable, supports multiple providers
Cons: More complex API

Option C: Per-Qubit Noise Model

Extend DeviceNoiseModel to support per-qubit parameters:

model = DeviceNoiseModel(
    name="custom",
    qubit_properties={
        0: QubitProperties(t1=35e-6, t2=20e-6, readout_error=0.02),
        1: QubitProperties(t1=40e-6, t2=25e-6, readout_error=0.03),
    },
    gate_properties={
        ('cx', 0, 1): GateProperties(error=0.008, duration=60e-9),
    }
)

Pros: More accurate modeling, matches real device heterogeneity
Cons: Significant API change, more complex usage

Related Work

• Qiskit Aer: NoiseModel.from_backend() - most mature implementation
• Amazon Braket: Local device emulator with calibration data
• Cirq: GoogleNoiseProperties for Google devices

Acceptance Criteria

• Research: Document exact API calls needed for Braket/Qiskit calibration
• Design: Choose implementation approach (A, B, or C)
• Implement: Add calibration fetching capability
• Test: Validate against real device data
• Document: Update technical docs with new capabilities

Priority

Medium - Current static implementation is functional for prototyping. Dynamic calibration is valuable for production accuracy but not blocking.

References

• Amazon Braket Device Properties
• Qiskit NoiseModel.from_backend
• EPJ Quantum Tech: Noise Model Selection
• Current implementation: quantumflow/device_noise.py