From fc3a8df9eb2d766bd5689afa139491fb8eb2725c Mon Sep 17 00:00:00 2001 From: maolinml <86260930+maolinml@users.noreply.github.com> Date: Mon, 9 Sep 2024 17:57:12 -0700 Subject: [PATCH 01/14] change the way we do ahs emulation which automatically include the measurement noise --- setup.py | 3 ++- src/braket/aws/aws_device.py | 4 ++-- .../emulation/emulation_passes/ahs_passes/ahs_noisy_pass.py | 3 ++- 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/setup.py b/setup.py index 071d78aef..69b9bfe77 100644 --- a/setup.py +++ b/setup.py @@ -29,7 +29,8 @@ install_requires=[ "amazon-braket-schemas>=1.21.3", # "amazon-braket-default-simulator>=1.26.0", - "amazon-braket-default-simulator@git+https://github.com/Altanali/amazon-braket-default-simulator-python.git@optional_net_detuning", # noqa: E501 + # "amazon-braket-default-simulator@git+https://github.com/Altanali/amazon-braket-default-simulator-python.git@optional_net_detuning", # noqa: E501 + "amazon-braket-default-simulator@git+https://github.com/amazon-braket/amazon-braket-default-simulator-python.git@mao/ahs_noise", "oqpy~=0.3.5", "backoff", "boltons", diff --git a/src/braket/aws/aws_device.py b/src/braket/aws/aws_device.py index f78b6930f..6f659a5e9 100644 --- a/src/braket/aws/aws_device.py +++ b/src/braket/aws/aws_device.py @@ -931,9 +931,9 @@ def _setup_gate_device_emulator(self) -> Emulator: return self._emulator def _setup_ahs_device_emulator(self) -> Emulator: - self._emulator = Emulator(backend="braket_ahs", name=self._name) + self._emulator = Emulator(backend="braket_ahs_noisy", name=self._name) self._emulator.add_pass(ahs_criterion(self.properties)) - self._emulator.add_pass(ahs_noise_model(self.properties)) + # self._emulator.add_pass(ahs_noise_model(self.properties)) return self._emulator def validate( diff --git a/src/braket/emulation/emulation_passes/ahs_passes/ahs_noisy_pass.py b/src/braket/emulation/emulation_passes/ahs_passes/ahs_noisy_pass.py index 1ed40c363..5cabeda82 100644 --- a/src/braket/emulation/emulation_passes/ahs_passes/ahs_noisy_pass.py +++ b/src/braket/emulation/emulation_passes/ahs_passes/ahs_noisy_pass.py @@ -29,7 +29,8 @@ class AhsNoiseData: atom_detection_error_false_negative: float -AhsProgramType = TypeVar('AhsProgramType', bound = AHSProgram | AnalogHamiltonianSimulation) +# AhsProgramType = TypeVar('AhsProgramType', bound = AHSProgram | AnalogHamiltonianSimulation) # Gives error TypeError: unsupported operand type(s) for |: 'ModelMetaclass' and 'type' +AhsProgramType = TypeVar('AhsProgramType', bound = Union[AHSProgram, AnalogHamiltonianSimulation]) class AhsNoise(EmulationPass[AhsProgramType]): From 0b6ef50e5a432058b903638c9ccac2e1edbfd5e4 Mon Sep 17 00:00:00 2001 From: maolinml <86260930+maolinml@users.noreply.github.com> Date: Thu, 12 Sep 2024 17:09:32 -0700 Subject: [PATCH 02/14] add args and kwargs for emulate method --- src/braket/aws/aws_device.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/braket/aws/aws_device.py b/src/braket/aws/aws_device.py index 6f659a5e9..482c67148 100644 --- a/src/braket/aws/aws_device.py +++ b/src/braket/aws/aws_device.py @@ -979,6 +979,8 @@ def emulate( task_specification: ProgramType, shots: Optional[int] = None, inputs: Optional[dict[str, float]] = None, + *args: Any, + **kwargs: Any, ) -> QuantumTask: """Emulate a quantum task specification on this quantum device emulator. A quantum task can be a circuit. Emulation @@ -999,4 +1001,4 @@ def emulate( QuantumTask: The QuantumTask tracking task execution on this device emulator. """ task_specification = deepcopy(task_specification) - return self.emulator.run(task_specification, shots, inputs) + return self.emulator.run(task_specification, shots, inputs, *args, **kwargs) From 0567b6381acbedb823fd4d4e6b497bc2b479e672 Mon Sep 17 00:00:00 2001 From: maolinml <86260930+maolinml@users.noreply.github.com> Date: Thu, 12 Sep 2024 17:24:28 -0700 Subject: [PATCH 03/14] add back the add_noise_model --- src/braket/aws/aws_device.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/braket/aws/aws_device.py b/src/braket/aws/aws_device.py index 482c67148..49b24cba5 100644 --- a/src/braket/aws/aws_device.py +++ b/src/braket/aws/aws_device.py @@ -933,7 +933,7 @@ def _setup_gate_device_emulator(self) -> Emulator: def _setup_ahs_device_emulator(self) -> Emulator: self._emulator = Emulator(backend="braket_ahs_noisy", name=self._name) self._emulator.add_pass(ahs_criterion(self.properties)) - # self._emulator.add_pass(ahs_noise_model(self.properties)) + self._emulator.add_pass(ahs_noise_model(self.properties)) return self._emulator def validate( From 5807e7a38eb3c4f6c4a2459569ea1b4562d834da Mon Sep 17 00:00:00 2001 From: maolinml <86260930+maolinml@users.noreply.github.com> Date: Thu, 12 Sep 2024 17:27:57 -0700 Subject: [PATCH 04/14] revert the previous commit --- src/braket/aws/aws_device.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/braket/aws/aws_device.py b/src/braket/aws/aws_device.py index 49b24cba5..482c67148 100644 --- a/src/braket/aws/aws_device.py +++ b/src/braket/aws/aws_device.py @@ -933,7 +933,7 @@ def _setup_gate_device_emulator(self) -> Emulator: def _setup_ahs_device_emulator(self) -> Emulator: self._emulator = Emulator(backend="braket_ahs_noisy", name=self._name) self._emulator.add_pass(ahs_criterion(self.properties)) - self._emulator.add_pass(ahs_noise_model(self.properties)) + # self._emulator.add_pass(ahs_noise_model(self.properties)) return self._emulator def validate( From 7e7f5f33422eb7adf3396a003789cf5dc36e8834 Mon Sep 17 00:00:00 2001 From: maolinml <86260930+maolinml@users.noreply.github.com> Date: Thu, 12 Sep 2024 17:30:12 -0700 Subject: [PATCH 05/14] revert the previous commit again --- src/braket/aws/aws_device.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/braket/aws/aws_device.py b/src/braket/aws/aws_device.py index 482c67148..49b24cba5 100644 --- a/src/braket/aws/aws_device.py +++ b/src/braket/aws/aws_device.py @@ -933,7 +933,7 @@ def _setup_gate_device_emulator(self) -> Emulator: def _setup_ahs_device_emulator(self) -> Emulator: self._emulator = Emulator(backend="braket_ahs_noisy", name=self._name) self._emulator.add_pass(ahs_criterion(self.properties)) - # self._emulator.add_pass(ahs_noise_model(self.properties)) + self._emulator.add_pass(ahs_noise_model(self.properties)) return self._emulator def validate( From 782fb1ad65c5285ae240d454061d014d4432eb72 Mon Sep 17 00:00:00 2001 From: maolinml <86260930+maolinml@users.noreply.github.com> Date: Thu, 12 Sep 2024 17:52:37 -0700 Subject: [PATCH 06/14] revert the previous commit again 2 --- src/braket/aws/aws_device.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/braket/aws/aws_device.py b/src/braket/aws/aws_device.py index 49b24cba5..482c67148 100644 --- a/src/braket/aws/aws_device.py +++ b/src/braket/aws/aws_device.py @@ -933,7 +933,7 @@ def _setup_gate_device_emulator(self) -> Emulator: def _setup_ahs_device_emulator(self) -> Emulator: self._emulator = Emulator(backend="braket_ahs_noisy", name=self._name) self._emulator.add_pass(ahs_criterion(self.properties)) - self._emulator.add_pass(ahs_noise_model(self.properties)) + # self._emulator.add_pass(ahs_noise_model(self.properties)) return self._emulator def validate( From d06f21d738d5452a6b5de96836754f793bc0aaef Mon Sep 17 00:00:00 2001 From: maolinml <86260930+maolinml@users.noreply.github.com> Date: Thu, 12 Sep 2024 18:16:42 -0700 Subject: [PATCH 07/14] remove AhsNoise AhsNoiseData --- src/braket/aws/aws_emulation.py | 52 +-- .../emulation_passes/ahs_passes/__init__.py | 8 +- .../ahs_passes/ahs_noisy_pass.py | 392 +++++++++--------- 3 files changed, 226 insertions(+), 226 deletions(-) diff --git a/src/braket/aws/aws_emulation.py b/src/braket/aws/aws_emulation.py index c0a8de832..fbab866bc 100644 --- a/src/braket/aws/aws_emulation.py +++ b/src/braket/aws/aws_emulation.py @@ -9,7 +9,7 @@ from braket.device_schema.iqm import IqmDeviceCapabilities from braket.device_schema.quera import QueraDeviceCapabilities from braket.device_schema.rigetti import RigettiDeviceCapabilities -from braket.emulation.emulation_passes.ahs_passes import AhsValidator, AhsNoise, AhsNoiseData +# from braket.emulation.emulation_passes.ahs_passes import AhsValidator, AhsNoise, AhsNoiseData from braket.emulation.emulation_passes.ahs_passes.device_capabilities_constants import ( DeviceCapabilitiesConstants, ) @@ -307,30 +307,30 @@ def _(properties: QueraDeviceCapabilities) -> DeviceCapabilitiesConstants: -def ahs_noise_model(properties: DeviceCapabilities) -> AhsNoise: - return _ahs_noise_model(properties) +# def ahs_noise_model(properties: DeviceCapabilities) -> AhsNoise: +# return _ahs_noise_model(properties) -@singledispatch -def _ahs_noise_model(properties: DeviceCapabilities) -> AhsNoise: - raise NotImplementedError("An AHS noise model cannot be created from device capabilities of " - f"type {type(properties)}.") +# @singledispatch +# def _ahs_noise_model(properties: DeviceCapabilities) -> AhsNoise: +# raise NotImplementedError("An AHS noise model cannot be created from device capabilities of " +# f"type {type(properties)}.") -@_ahs_noise_model.register(QueraDeviceCapabilities) -def _(properties: QueraDeviceCapabilities): - - capabilities = properties.paradigm - performance = capabilities.performance - noise_data = AhsNoiseData( - site_position_error= float(performance.lattice.sitePositionError), - filling_error = float(performance.lattice.vacancyErrorTypical), - vacancy_error = float(performance.lattice.vacancyErrorTypical), - ground_prep_error = float(performance.rydberg.rydbergGlobal.groundPrepError), - rabi_amplitude_ramp_correction = performance.rydberg.rydbergGlobal.rabiAmplitudeRampCorrection, - rabi_frequency_error_rel = float(performance.rydberg.rydbergGlobal.rabiFrequencyGlobalErrorRel), - detuning_error = float(performance.rydberg.rydbergGlobal.detuningError), - detuning_inhomogeneity = float(performance.rydberg.rydbergGlobal.detuningInhomogeneity), - atom_detection_error_false_positive = float(performance.lattice.atomDetectionErrorFalsePositiveTypical), - atom_detection_error_false_negative = float(performance.lattice.atomDetectionErrorFalseNegativeTypical), - rabi_amplitude_max = float(capabilities.rydberg.rydbergGlobal.rabiFrequencyRange[-1]) - ) - return AhsNoise(noise_data) +# @_ahs_noise_model.register(QueraDeviceCapabilities) +# def _(properties: QueraDeviceCapabilities): + +# capabilities = properties.paradigm +# performance = capabilities.performance +# noise_data = AhsNoiseData( +# site_position_error= float(performance.lattice.sitePositionError), +# filling_error = float(performance.lattice.vacancyErrorTypical), +# vacancy_error = float(performance.lattice.vacancyErrorTypical), +# ground_prep_error = float(performance.rydberg.rydbergGlobal.groundPrepError), +# rabi_amplitude_ramp_correction = performance.rydberg.rydbergGlobal.rabiAmplitudeRampCorrection, +# rabi_frequency_error_rel = float(performance.rydberg.rydbergGlobal.rabiFrequencyGlobalErrorRel), +# detuning_error = float(performance.rydberg.rydbergGlobal.detuningError), +# detuning_inhomogeneity = float(performance.rydberg.rydbergGlobal.detuningInhomogeneity), +# atom_detection_error_false_positive = float(performance.lattice.atomDetectionErrorFalsePositiveTypical), +# atom_detection_error_false_negative = float(performance.lattice.atomDetectionErrorFalseNegativeTypical), +# rabi_amplitude_max = float(capabilities.rydberg.rydbergGlobal.rabiFrequencyRange[-1]) +# ) +# return AhsNoise(noise_data) diff --git a/src/braket/emulation/emulation_passes/ahs_passes/__init__.py b/src/braket/emulation/emulation_passes/ahs_passes/__init__.py index 1fe6a3836..e4b586055 100644 --- a/src/braket/emulation/emulation_passes/ahs_passes/__init__.py +++ b/src/braket/emulation/emulation_passes/ahs_passes/__init__.py @@ -1,5 +1,5 @@ from braket.emulation.emulation_passes.ahs_passes.ahs_validator import AhsValidator # noqa: F40 -from braket.emulation.emulation_passes.ahs_passes.ahs_noisy_pass import( #noqa: F40 - AhsNoise, - AhsNoiseData -) \ No newline at end of file +# from braket.emulation.emulation_passes.ahs_passes.ahs_noisy_pass import( #noqa: F40 +# AhsNoise, +# AhsNoiseData +# ) \ No newline at end of file diff --git a/src/braket/emulation/emulation_passes/ahs_passes/ahs_noisy_pass.py b/src/braket/emulation/emulation_passes/ahs_passes/ahs_noisy_pass.py index 5cabeda82..92a96f2cd 100644 --- a/src/braket/emulation/emulation_passes/ahs_passes/ahs_noisy_pass.py +++ b/src/braket/emulation/emulation_passes/ahs_passes/ahs_noisy_pass.py @@ -1,239 +1,239 @@ -from braket.emulation.emulation_passes import EmulationPass -from braket.ahs import AnalogHamiltonianSimulation -from braket.timings.time_series import TimeSeries -from braket.ahs.pattern import Pattern -from braket.ahs.field import Field -from braket.ahs.atom_arrangement import AtomArrangement, SiteType -from braket.ahs.driving_field import DrivingField -from braket.ahs.local_detuning import LocalDetuning -from braket.ir.ahs import Program as AHSProgram -from typing import Union, List, TypeVar, Tuple -from dataclasses import dataclass -from functools import singledispatchmethod -import scipy -import numpy as np -from decimal import Decimal +# from braket.emulation.emulation_passes import EmulationPass +# from braket.ahs import AnalogHamiltonianSimulation +# from braket.timings.time_series import TimeSeries +# from braket.ahs.pattern import Pattern +# from braket.ahs.field import Field +# from braket.ahs.atom_arrangement import AtomArrangement, SiteType +# from braket.ahs.driving_field import DrivingField +# from braket.ahs.local_detuning import LocalDetuning +# from braket.ir.ahs import Program as AHSProgram +# from typing import Union, List, TypeVar, Tuple +# from dataclasses import dataclass +# from functools import singledispatchmethod +# import scipy +# import numpy as np +# from decimal import Decimal -@dataclass -class AhsNoiseData: - site_position_error: float - filling_error: float - vacancy_error: float - ground_prep_error: float - rabi_amplitude_ramp_correction: List[float] - rabi_frequency_error_rel: float - rabi_amplitude_max: float - detuning_error: float - detuning_inhomogeneity: float - atom_detection_error_false_positive: float - atom_detection_error_false_negative: float +# @dataclass +# class AhsNoiseData: +# site_position_error: float +# filling_error: float +# vacancy_error: float +# ground_prep_error: float +# rabi_amplitude_ramp_correction: List[float] +# rabi_frequency_error_rel: float +# rabi_amplitude_max: float +# detuning_error: float +# detuning_inhomogeneity: float +# atom_detection_error_false_positive: float +# atom_detection_error_false_negative: float -# AhsProgramType = TypeVar('AhsProgramType', bound = AHSProgram | AnalogHamiltonianSimulation) # Gives error TypeError: unsupported operand type(s) for |: 'ModelMetaclass' and 'type' -AhsProgramType = TypeVar('AhsProgramType', bound = Union[AHSProgram, AnalogHamiltonianSimulation]) +# # AhsProgramType = TypeVar('AhsProgramType', bound = AHSProgram | AnalogHamiltonianSimulation) # Gives error TypeError: unsupported operand type(s) for |: 'ModelMetaclass' and 'type' +# AhsProgramType = TypeVar('AhsProgramType', bound = Union[AHSProgram, AnalogHamiltonianSimulation]) -class AhsNoise(EmulationPass[AhsProgramType]): - def __init__(self, ahs_noise_data: AhsNoiseData): - self._noise_data = ahs_noise_data +# class AhsNoise(EmulationPass[AhsProgramType]): +# def __init__(self, ahs_noise_data: AhsNoiseData): +# self._noise_data = ahs_noise_data - def run(self, program: AhsProgramType, steps: int = 100) -> AhsProgramType: - return self._apply_noise_model(program, steps) +# def run(self, program: AhsProgramType, steps: int = 100) -> AhsProgramType: +# return self._apply_noise_model(program, steps) - @singledispatchmethod - def _apply_noise_model(self, program: AhsProgramType, steps: int) -> AhsProgramType: - raise NotImplementedError +# @singledispatchmethod +# def _apply_noise_model(self, program: AhsProgramType, steps: int) -> AhsProgramType: +# raise NotImplementedError - @_apply_noise_model.register(AnalogHamiltonianSimulation) - def _(self, program: AnalogHamiltonianSimulation, steps: int) -> AnalogHamiltonianSimulation: - sites, fillings, preseq = self._apply_lattice_initialization_errors(program) - drive, local_detuning = self._apply_rydberg_noise(program, steps) - - register = AtomArrangement() - for (site, filling) in zip(sites, fillings): - if filling == 1: - register.add(site) - else: - register.add(site, site_type=SiteType.VACANT) +# @_apply_noise_model.register(AnalogHamiltonianSimulation) +# def _(self, program: AnalogHamiltonianSimulation, steps: int) -> AnalogHamiltonianSimulation: +# sites, fillings, preseq = self._apply_lattice_initialization_errors(program) +# drive, local_detuning = self._apply_rydberg_noise(program, steps) + +# register = AtomArrangement() +# for (site, filling) in zip(sites, fillings): +# if filling == 1: +# register.add(site) +# else: +# register.add(site, site_type=SiteType.VACANT) - return AnalogHamiltonianSimulation( - register=register, - hamiltonian=drive+local_detuning - ) +# return AnalogHamiltonianSimulation( +# register=register, +# hamiltonian=drive+local_detuning +# ) - @_apply_noise_model.register(AHSProgram) - def _(self, program: AHSProgram) -> AHSProgram: - raise NotImplementedError - - def _apply_lattice_initialization_errors(self, program: AnalogHamiltonianSimulation) \ - -> Tuple[List[List[float]], List[int], List[int]]: - #Default to using the typical position error for now instead of the worst case error. - sites = [[float(x), float(y)] for (x, y) in zip(program.register.coordinate_list(0), program.register.coordinate_list(1))] - filling = program.to_ir().setup.ahs_register.filling - - erroneous_sites = self._apply_site_position_error(sites) - erroneous_filling = self._apply_binomial_noise(filling, \ - self._noise_data.filling_error, self._noise_data.vacancy_error) - - pre_seq = self._apply_binomial_noise(erroneous_filling, \ - self._noise_data.atom_detection_error_false_negative, \ - self._noise_data.atom_detection_error_false_positive) +# @_apply_noise_model.register(AHSProgram) +# def _(self, program: AHSProgram) -> AHSProgram: +# raise NotImplementedError + +# def _apply_lattice_initialization_errors(self, program: AnalogHamiltonianSimulation) \ +# -> Tuple[List[List[float]], List[int], List[int]]: +# #Default to using the typical position error for now instead of the worst case error. +# sites = [[float(x), float(y)] for (x, y) in zip(program.register.coordinate_list(0), program.register.coordinate_list(1))] +# filling = program.to_ir().setup.ahs_register.filling + +# erroneous_sites = self._apply_site_position_error(sites) +# erroneous_filling = self._apply_binomial_noise(filling, \ +# self._noise_data.filling_error, self._noise_data.vacancy_error) + +# pre_seq = self._apply_binomial_noise(erroneous_filling, \ +# self._noise_data.atom_detection_error_false_negative, \ +# self._noise_data.atom_detection_error_false_positive) - erroneous_filling = self._apply_binomial_noise(erroneous_filling, \ - 0, self._noise_data.ground_prep_error) +# erroneous_filling = self._apply_binomial_noise(erroneous_filling, \ +# 0, self._noise_data.ground_prep_error) - return erroneous_sites, erroneous_filling, pre_seq +# return erroneous_sites, erroneous_filling, pre_seq - def _apply_site_position_error(self, - sites: List[List[float]]) -> List[List[float]]: - erroneous_sites = [] - for site in sites: - erroneous_sites.append( - site + self._noise_data.site_position_error * np.random.normal(size=2) - ) +# def _apply_site_position_error(self, +# sites: List[List[float]]) -> List[List[float]]: +# erroneous_sites = [] +# for site in sites: +# erroneous_sites.append( +# site + self._noise_data.site_position_error * np.random.normal(size=2) +# ) - return erroneous_sites +# return erroneous_sites - def _apply_binomial_noise(self, - arr: List[int], - binomial_probability_p01: float, - binomial_probability_p10: float) -> List[int]: - noisy_arr = [] - for val in arr: - if val == 1: - # Apply the error of switching 1 as 0 - noisy_arr.append(1 - np.random.binomial(1, binomial_probability_p10)) - else: - # Apply the error of switching 0 as 1 - noisy_arr.append(np.random.binomial(1, binomial_probability_p01)) +# def _apply_binomial_noise(self, +# arr: List[int], +# binomial_probability_p01: float, +# binomial_probability_p10: float) -> List[int]: +# noisy_arr = [] +# for val in arr: +# if val == 1: +# # Apply the error of switching 1 as 0 +# noisy_arr.append(1 - np.random.binomial(1, binomial_probability_p10)) +# else: +# # Apply the error of switching 0 as 1 +# noisy_arr.append(np.random.binomial(1, binomial_probability_p01)) - return noisy_arr +# return noisy_arr - def _apply_rydberg_noise(self, program: AnalogHamiltonianSimulation, steps: int) \ - -> Tuple[TimeSeries, LocalDetuning]: - noisy_detuning, local_detuning = self._apply_detuning_errors( - program.hamiltonian.detuning, - program.to_ir().setup.ahs_register.filling, - steps - ) +# def _apply_rydberg_noise(self, program: AnalogHamiltonianSimulation, steps: int) \ +# -> Tuple[TimeSeries, LocalDetuning]: +# noisy_detuning, local_detuning = self._apply_detuning_errors( +# program.hamiltonian.detuning, +# program.to_ir().setup.ahs_register.filling, +# steps +# ) - noisy_amplitude = self._apply_amplitude_errors( - program.hamiltonian.amplitude, - steps, - ) - noisy_drive = DrivingField(amplitude = noisy_amplitude, - detuning = noisy_detuning, - phase = program.hamiltonian.phase) +# noisy_amplitude = self._apply_amplitude_errors( +# program.hamiltonian.amplitude, +# steps, +# ) +# noisy_drive = DrivingField(amplitude = noisy_amplitude, +# detuning = noisy_detuning, +# phase = program.hamiltonian.phase) - return noisy_drive, local_detuning +# return noisy_drive, local_detuning - def _apply_detuning_errors(self, - detuning: TimeSeries, - fillings: List[int], - steps: int - ) -> Tuple[TimeSeries, LocalDetuning]: +# def _apply_detuning_errors(self, +# detuning: TimeSeries, +# fillings: List[int], +# steps: int +# ) -> Tuple[TimeSeries, LocalDetuning]: - detuning_times = np.array(detuning.time_series.times(), dtype='float64') - detuning_values = np.array(detuning.time_series.values(), dtype='float64') +# detuning_times = np.array(detuning.time_series.times(), dtype='float64') +# detuning_values = np.array(detuning.time_series.values(), dtype='float64') - noisy_detuning_times = np.linspace(0, detuning_times[-1], steps) - noisy_detuning_values = np.interp(noisy_detuning_times, detuning_times, detuning_values) +# noisy_detuning_times = np.linspace(0, detuning_times[-1], steps) +# noisy_detuning_values = np.interp(noisy_detuning_times, detuning_times, detuning_values) - # Apply the detuning error - noisy_detuning_values += \ - self._noise_data.detuning_error * np.random.normal(size=len(noisy_detuning_values)) - - noisy_detuning = TimeSeries.from_lists(noisy_detuning_times, noisy_detuning_values) - - # Apply detuning inhomogeneity - h = Pattern([np.random.rand() for _ in fillings]) - detuning_local = TimeSeries.from_lists(noisy_detuning_times, - self._noise_data.detuning_inhomogeneity * np.ones( - len(noisy_detuning_times) - ) - ) +# # Apply the detuning error +# noisy_detuning_values += \ +# self._noise_data.detuning_error * np.random.normal(size=len(noisy_detuning_values)) + +# noisy_detuning = TimeSeries.from_lists(noisy_detuning_times, noisy_detuning_values) + +# # Apply detuning inhomogeneity +# h = Pattern([np.random.rand() for _ in fillings]) +# detuning_local = TimeSeries.from_lists(noisy_detuning_times, +# self._noise_data.detuning_inhomogeneity * np.ones( +# len(noisy_detuning_times) +# ) +# ) - # Assemble the local detuning - local_detuning = LocalDetuning( - magnitude=Field( - time_series=detuning_local, - pattern=h - ) - ) - - return noisy_detuning, local_detuning +# # Assemble the local detuning +# local_detuning = LocalDetuning( +# magnitude=Field( +# time_series=detuning_local, +# pattern=h +# ) +# ) + +# return noisy_detuning, local_detuning - def _apply_amplitude_errors(self, amplitude: TimeSeries, steps: int) \ - -> TimeSeries: - amplitude_times = np.array(amplitude.time_series.times(), dtype='float64') - amplitude_values = np.array(amplitude.time_series.values(), dtype='float64') - - # Rewrite the rabi_ramp_correction as a function of slopes - rabi_ramp_correction_slopes = [self._noise_data.rabi_amplitude_max / float(corr.rampTime) - for corr in self._noise_data.rabi_amplitude_ramp_correction - ] - rabi_ramp_correction_fracs = [float(corr.rabiCorrection) - for corr in self._noise_data.rabi_amplitude_ramp_correction - ] - rabi_ramp_correction_slopes = rabi_ramp_correction_slopes[::-1] - rabi_ramp_correction_fracs = rabi_ramp_correction_fracs[::-1] - - # Helper function to find the correction factor for a given slope - get_frac = scipy.interpolate.interp1d(rabi_ramp_correction_slopes, - rabi_ramp_correction_fracs, - bounds_error=False, - fill_value="extrapolate" - ) +# def _apply_amplitude_errors(self, amplitude: TimeSeries, steps: int) \ +# -> TimeSeries: +# amplitude_times = np.array(amplitude.time_series.times(), dtype='float64') +# amplitude_values = np.array(amplitude.time_series.values(), dtype='float64') + +# # Rewrite the rabi_ramp_correction as a function of slopes +# rabi_ramp_correction_slopes = [self._noise_data.rabi_amplitude_max / float(corr.rampTime) +# for corr in self._noise_data.rabi_amplitude_ramp_correction +# ] +# rabi_ramp_correction_fracs = [float(corr.rabiCorrection) +# for corr in self._noise_data.rabi_amplitude_ramp_correction +# ] +# rabi_ramp_correction_slopes = rabi_ramp_correction_slopes[::-1] +# rabi_ramp_correction_fracs = rabi_ramp_correction_fracs[::-1] + +# # Helper function to find the correction factor for a given slope +# get_frac = scipy.interpolate.interp1d(rabi_ramp_correction_slopes, +# rabi_ramp_correction_fracs, +# bounds_error=False, +# fill_value="extrapolate" +# ) - noisy_amplitude_times = np.linspace(0, amplitude_times[-1], steps) - noisy_amplitude_values = [] +# noisy_amplitude_times = np.linspace(0, amplitude_times[-1], steps) +# noisy_amplitude_values = [] - # First apply the rabi ramp correction - for ind in range(len(amplitude_times)): - if ind == 0: - continue +# # First apply the rabi ramp correction +# for ind in range(len(amplitude_times)): +# if ind == 0: +# continue - # First determine the correction factor from the slope - t1, t2 = amplitude_times[ind-1], amplitude_times[ind] - v1, v2 = amplitude_values[ind-1], amplitude_values[ind] - slope = (v2 - v1) / (t2 - t1) - if np.abs(slope) > 0: - frac = get_frac(np.abs(slope)) * np.sign(slope) - else: - frac = 1.0 +# # First determine the correction factor from the slope +# t1, t2 = amplitude_times[ind-1], amplitude_times[ind] +# v1, v2 = amplitude_values[ind-1], amplitude_values[ind] +# slope = (v2 - v1) / (t2 - t1) +# if np.abs(slope) > 0: +# frac = get_frac(np.abs(slope)) * np.sign(slope) +# else: +# frac = 1.0 - # Next, determine the coefficients for the quadratic correction - if frac >= 1.0: - a, b, c = 0, 0, v2 - else: - # Determine the coefficients for the quadratic correction - # of the form f(t) = a*t^2 + b * t + c - # such that f(t1) = v1 and f(t2) = v2 and - # a/3*(t2^3-t1^3) + b/2*(t2^2-t1^2) + c(t2-t1) = frac * (t2-t1) * (v2-v1)/2 +# # Next, determine the coefficients for the quadratic correction +# if frac >= 1.0: +# a, b, c = 0, 0, v2 +# else: +# # Determine the coefficients for the quadratic correction +# # of the form f(t) = a*t^2 + b * t + c +# # such that f(t1) = v1 and f(t2) = v2 and +# # a/3*(t2^3-t1^3) + b/2*(t2^2-t1^2) + c(t2-t1) = frac * (t2-t1) * (v2-v1)/2 - a = 3 * (v1 + frac * v1 + v2 - frac * v2)/(t1 - t2)**2 - c = (t2 * v1 * ((2 + 3 * frac) * t1 + t2) + t1 * v2 * (t1 + (2 - 3 * frac) * t2))/(t1 - t2)**2 - b = (v2 - c - a * t2**2) / t2 +# a = 3 * (v1 + frac * v1 + v2 - frac * v2)/(t1 - t2)**2 +# c = (t2 * v1 * ((2 + 3 * frac) * t1 + t2) + t1 * v2 * (t1 + (2 - 3 * frac) * t2))/(t1 - t2)**2 +# b = (v2 - c - a * t2**2) / t2 - # Finally, put values into noisy_amplitude_values - for t in noisy_amplitude_times: - if t1 <= t and t <= t2: - noisy_amplitude_values.append(a * t**2 + b * t + c) +# # Finally, put values into noisy_amplitude_values +# for t in noisy_amplitude_times: +# if t1 <= t and t <= t2: +# noisy_amplitude_values.append(a * t**2 + b * t + c) - # Next apply amplitude error - rabi_errors = 1 + self._noise_data.rabi_frequency_error_rel * np.random.normal(size=len(noisy_amplitude_values)) - noisy_amplitude_values = np.multiply(noisy_amplitude_values, rabi_errors) - noisy_amplitude_values = [max(0, value) for value in noisy_amplitude_values] # amplitude has to be non-negative +# # Next apply amplitude error +# rabi_errors = 1 + self._noise_data.rabi_frequency_error_rel * np.random.normal(size=len(noisy_amplitude_values)) +# noisy_amplitude_values = np.multiply(noisy_amplitude_values, rabi_errors) +# noisy_amplitude_values = [max(0, value) for value in noisy_amplitude_values] # amplitude has to be non-negative - noisy_amplitude = TimeSeries.from_lists(noisy_amplitude_times, noisy_amplitude_values) +# noisy_amplitude = TimeSeries.from_lists(noisy_amplitude_times, noisy_amplitude_values) - return noisy_amplitude +# return noisy_amplitude \ No newline at end of file From aa86fbf2362bf5db8bc2b1f6a1a1694fed9187e3 Mon Sep 17 00:00:00 2001 From: maolinml <86260930+maolinml@users.noreply.github.com> Date: Thu, 12 Sep 2024 18:17:35 -0700 Subject: [PATCH 08/14] minor change --- src/braket/aws/aws_emulation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/braket/aws/aws_emulation.py b/src/braket/aws/aws_emulation.py index fbab866bc..5cb6eb787 100644 --- a/src/braket/aws/aws_emulation.py +++ b/src/braket/aws/aws_emulation.py @@ -9,7 +9,7 @@ from braket.device_schema.iqm import IqmDeviceCapabilities from braket.device_schema.quera import QueraDeviceCapabilities from braket.device_schema.rigetti import RigettiDeviceCapabilities -# from braket.emulation.emulation_passes.ahs_passes import AhsValidator, AhsNoise, AhsNoiseData +from braket.emulation.emulation_passes.ahs_passes import AhsValidator #, AhsNoise, AhsNoiseData from braket.emulation.emulation_passes.ahs_passes.device_capabilities_constants import ( DeviceCapabilitiesConstants, ) From 7a6c45cc7a4a5504db6dc9cbd33f128153d61623 Mon Sep 17 00:00:00 2001 From: maolinml <86260930+maolinml@users.noreply.github.com> Date: Thu, 12 Sep 2024 18:18:28 -0700 Subject: [PATCH 09/14] minor change --- src/braket/aws/aws_device.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/braket/aws/aws_device.py b/src/braket/aws/aws_device.py index 482c67148..d147e175c 100644 --- a/src/braket/aws/aws_device.py +++ b/src/braket/aws/aws_device.py @@ -30,7 +30,7 @@ from braket.annealing.problem import Problem from braket.aws.aws_emulation import ( ahs_criterion, - ahs_noise_model, + # ahs_noise_model, connectivity_validator, gate_connectivity_validator, gate_validator, From 21ac9a3ac74177155fab227870654b6c49c42e8b Mon Sep 17 00:00:00 2001 From: maolinml <86260930+maolinml@users.noreply.github.com> Date: Thu, 12 Sep 2024 18:50:50 -0700 Subject: [PATCH 10/14] revert the previous several commits --- src/braket/aws/aws_device.py | 4 +- src/braket/aws/aws_emulation.py | 50 +-- .../emulation_passes/ahs_passes/__init__.py | 8 +- .../ahs_passes/ahs_noisy_pass.py | 392 +++++++++--------- 4 files changed, 227 insertions(+), 227 deletions(-) diff --git a/src/braket/aws/aws_device.py b/src/braket/aws/aws_device.py index d147e175c..49b24cba5 100644 --- a/src/braket/aws/aws_device.py +++ b/src/braket/aws/aws_device.py @@ -30,7 +30,7 @@ from braket.annealing.problem import Problem from braket.aws.aws_emulation import ( ahs_criterion, - # ahs_noise_model, + ahs_noise_model, connectivity_validator, gate_connectivity_validator, gate_validator, @@ -933,7 +933,7 @@ def _setup_gate_device_emulator(self) -> Emulator: def _setup_ahs_device_emulator(self) -> Emulator: self._emulator = Emulator(backend="braket_ahs_noisy", name=self._name) self._emulator.add_pass(ahs_criterion(self.properties)) - # self._emulator.add_pass(ahs_noise_model(self.properties)) + self._emulator.add_pass(ahs_noise_model(self.properties)) return self._emulator def validate( diff --git a/src/braket/aws/aws_emulation.py b/src/braket/aws/aws_emulation.py index 5cb6eb787..9dd717a5f 100644 --- a/src/braket/aws/aws_emulation.py +++ b/src/braket/aws/aws_emulation.py @@ -307,30 +307,30 @@ def _(properties: QueraDeviceCapabilities) -> DeviceCapabilitiesConstants: -# def ahs_noise_model(properties: DeviceCapabilities) -> AhsNoise: -# return _ahs_noise_model(properties) +def ahs_noise_model(properties: DeviceCapabilities) -> AhsNoise: + return _ahs_noise_model(properties) -# @singledispatch -# def _ahs_noise_model(properties: DeviceCapabilities) -> AhsNoise: -# raise NotImplementedError("An AHS noise model cannot be created from device capabilities of " -# f"type {type(properties)}.") +@singledispatch +def _ahs_noise_model(properties: DeviceCapabilities) -> AhsNoise: + raise NotImplementedError("An AHS noise model cannot be created from device capabilities of " + f"type {type(properties)}.") -# @_ahs_noise_model.register(QueraDeviceCapabilities) -# def _(properties: QueraDeviceCapabilities): - -# capabilities = properties.paradigm -# performance = capabilities.performance -# noise_data = AhsNoiseData( -# site_position_error= float(performance.lattice.sitePositionError), -# filling_error = float(performance.lattice.vacancyErrorTypical), -# vacancy_error = float(performance.lattice.vacancyErrorTypical), -# ground_prep_error = float(performance.rydberg.rydbergGlobal.groundPrepError), -# rabi_amplitude_ramp_correction = performance.rydberg.rydbergGlobal.rabiAmplitudeRampCorrection, -# rabi_frequency_error_rel = float(performance.rydberg.rydbergGlobal.rabiFrequencyGlobalErrorRel), -# detuning_error = float(performance.rydberg.rydbergGlobal.detuningError), -# detuning_inhomogeneity = float(performance.rydberg.rydbergGlobal.detuningInhomogeneity), -# atom_detection_error_false_positive = float(performance.lattice.atomDetectionErrorFalsePositiveTypical), -# atom_detection_error_false_negative = float(performance.lattice.atomDetectionErrorFalseNegativeTypical), -# rabi_amplitude_max = float(capabilities.rydberg.rydbergGlobal.rabiFrequencyRange[-1]) -# ) -# return AhsNoise(noise_data) +@_ahs_noise_model.register(QueraDeviceCapabilities) +def _(properties: QueraDeviceCapabilities): + + capabilities = properties.paradigm + performance = capabilities.performance + noise_data = AhsNoiseData( + site_position_error= float(performance.lattice.sitePositionError), + filling_error = float(performance.lattice.vacancyErrorTypical), + vacancy_error = float(performance.lattice.vacancyErrorTypical), + ground_prep_error = float(performance.rydberg.rydbergGlobal.groundPrepError), + rabi_amplitude_ramp_correction = performance.rydberg.rydbergGlobal.rabiAmplitudeRampCorrection, + rabi_frequency_error_rel = float(performance.rydberg.rydbergGlobal.rabiFrequencyGlobalErrorRel), + detuning_error = float(performance.rydberg.rydbergGlobal.detuningError), + detuning_inhomogeneity = float(performance.rydberg.rydbergGlobal.detuningInhomogeneity), + atom_detection_error_false_positive = float(performance.lattice.atomDetectionErrorFalsePositiveTypical), + atom_detection_error_false_negative = float(performance.lattice.atomDetectionErrorFalseNegativeTypical), + rabi_amplitude_max = float(capabilities.rydberg.rydbergGlobal.rabiFrequencyRange[-1]) + ) + return AhsNoise(noise_data) diff --git a/src/braket/emulation/emulation_passes/ahs_passes/__init__.py b/src/braket/emulation/emulation_passes/ahs_passes/__init__.py index e4b586055..1fe6a3836 100644 --- a/src/braket/emulation/emulation_passes/ahs_passes/__init__.py +++ b/src/braket/emulation/emulation_passes/ahs_passes/__init__.py @@ -1,5 +1,5 @@ from braket.emulation.emulation_passes.ahs_passes.ahs_validator import AhsValidator # noqa: F40 -# from braket.emulation.emulation_passes.ahs_passes.ahs_noisy_pass import( #noqa: F40 -# AhsNoise, -# AhsNoiseData -# ) \ No newline at end of file +from braket.emulation.emulation_passes.ahs_passes.ahs_noisy_pass import( #noqa: F40 + AhsNoise, + AhsNoiseData +) \ No newline at end of file diff --git a/src/braket/emulation/emulation_passes/ahs_passes/ahs_noisy_pass.py b/src/braket/emulation/emulation_passes/ahs_passes/ahs_noisy_pass.py index 92a96f2cd..5cabeda82 100644 --- a/src/braket/emulation/emulation_passes/ahs_passes/ahs_noisy_pass.py +++ b/src/braket/emulation/emulation_passes/ahs_passes/ahs_noisy_pass.py @@ -1,239 +1,239 @@ -# from braket.emulation.emulation_passes import EmulationPass -# from braket.ahs import AnalogHamiltonianSimulation -# from braket.timings.time_series import TimeSeries -# from braket.ahs.pattern import Pattern -# from braket.ahs.field import Field -# from braket.ahs.atom_arrangement import AtomArrangement, SiteType -# from braket.ahs.driving_field import DrivingField -# from braket.ahs.local_detuning import LocalDetuning -# from braket.ir.ahs import Program as AHSProgram -# from typing import Union, List, TypeVar, Tuple -# from dataclasses import dataclass -# from functools import singledispatchmethod -# import scipy -# import numpy as np -# from decimal import Decimal +from braket.emulation.emulation_passes import EmulationPass +from braket.ahs import AnalogHamiltonianSimulation +from braket.timings.time_series import TimeSeries +from braket.ahs.pattern import Pattern +from braket.ahs.field import Field +from braket.ahs.atom_arrangement import AtomArrangement, SiteType +from braket.ahs.driving_field import DrivingField +from braket.ahs.local_detuning import LocalDetuning +from braket.ir.ahs import Program as AHSProgram +from typing import Union, List, TypeVar, Tuple +from dataclasses import dataclass +from functools import singledispatchmethod +import scipy +import numpy as np +from decimal import Decimal -# @dataclass -# class AhsNoiseData: -# site_position_error: float -# filling_error: float -# vacancy_error: float -# ground_prep_error: float -# rabi_amplitude_ramp_correction: List[float] -# rabi_frequency_error_rel: float -# rabi_amplitude_max: float -# detuning_error: float -# detuning_inhomogeneity: float -# atom_detection_error_false_positive: float -# atom_detection_error_false_negative: float +@dataclass +class AhsNoiseData: + site_position_error: float + filling_error: float + vacancy_error: float + ground_prep_error: float + rabi_amplitude_ramp_correction: List[float] + rabi_frequency_error_rel: float + rabi_amplitude_max: float + detuning_error: float + detuning_inhomogeneity: float + atom_detection_error_false_positive: float + atom_detection_error_false_negative: float -# # AhsProgramType = TypeVar('AhsProgramType', bound = AHSProgram | AnalogHamiltonianSimulation) # Gives error TypeError: unsupported operand type(s) for |: 'ModelMetaclass' and 'type' -# AhsProgramType = TypeVar('AhsProgramType', bound = Union[AHSProgram, AnalogHamiltonianSimulation]) +# AhsProgramType = TypeVar('AhsProgramType', bound = AHSProgram | AnalogHamiltonianSimulation) # Gives error TypeError: unsupported operand type(s) for |: 'ModelMetaclass' and 'type' +AhsProgramType = TypeVar('AhsProgramType', bound = Union[AHSProgram, AnalogHamiltonianSimulation]) -# class AhsNoise(EmulationPass[AhsProgramType]): -# def __init__(self, ahs_noise_data: AhsNoiseData): -# self._noise_data = ahs_noise_data +class AhsNoise(EmulationPass[AhsProgramType]): + def __init__(self, ahs_noise_data: AhsNoiseData): + self._noise_data = ahs_noise_data -# def run(self, program: AhsProgramType, steps: int = 100) -> AhsProgramType: -# return self._apply_noise_model(program, steps) + def run(self, program: AhsProgramType, steps: int = 100) -> AhsProgramType: + return self._apply_noise_model(program, steps) -# @singledispatchmethod -# def _apply_noise_model(self, program: AhsProgramType, steps: int) -> AhsProgramType: -# raise NotImplementedError + @singledispatchmethod + def _apply_noise_model(self, program: AhsProgramType, steps: int) -> AhsProgramType: + raise NotImplementedError -# @_apply_noise_model.register(AnalogHamiltonianSimulation) -# def _(self, program: AnalogHamiltonianSimulation, steps: int) -> AnalogHamiltonianSimulation: -# sites, fillings, preseq = self._apply_lattice_initialization_errors(program) -# drive, local_detuning = self._apply_rydberg_noise(program, steps) - -# register = AtomArrangement() -# for (site, filling) in zip(sites, fillings): -# if filling == 1: -# register.add(site) -# else: -# register.add(site, site_type=SiteType.VACANT) + @_apply_noise_model.register(AnalogHamiltonianSimulation) + def _(self, program: AnalogHamiltonianSimulation, steps: int) -> AnalogHamiltonianSimulation: + sites, fillings, preseq = self._apply_lattice_initialization_errors(program) + drive, local_detuning = self._apply_rydberg_noise(program, steps) + + register = AtomArrangement() + for (site, filling) in zip(sites, fillings): + if filling == 1: + register.add(site) + else: + register.add(site, site_type=SiteType.VACANT) -# return AnalogHamiltonianSimulation( -# register=register, -# hamiltonian=drive+local_detuning -# ) + return AnalogHamiltonianSimulation( + register=register, + hamiltonian=drive+local_detuning + ) -# @_apply_noise_model.register(AHSProgram) -# def _(self, program: AHSProgram) -> AHSProgram: -# raise NotImplementedError - -# def _apply_lattice_initialization_errors(self, program: AnalogHamiltonianSimulation) \ -# -> Tuple[List[List[float]], List[int], List[int]]: -# #Default to using the typical position error for now instead of the worst case error. -# sites = [[float(x), float(y)] for (x, y) in zip(program.register.coordinate_list(0), program.register.coordinate_list(1))] -# filling = program.to_ir().setup.ahs_register.filling - -# erroneous_sites = self._apply_site_position_error(sites) -# erroneous_filling = self._apply_binomial_noise(filling, \ -# self._noise_data.filling_error, self._noise_data.vacancy_error) - -# pre_seq = self._apply_binomial_noise(erroneous_filling, \ -# self._noise_data.atom_detection_error_false_negative, \ -# self._noise_data.atom_detection_error_false_positive) + @_apply_noise_model.register(AHSProgram) + def _(self, program: AHSProgram) -> AHSProgram: + raise NotImplementedError + + def _apply_lattice_initialization_errors(self, program: AnalogHamiltonianSimulation) \ + -> Tuple[List[List[float]], List[int], List[int]]: + #Default to using the typical position error for now instead of the worst case error. + sites = [[float(x), float(y)] for (x, y) in zip(program.register.coordinate_list(0), program.register.coordinate_list(1))] + filling = program.to_ir().setup.ahs_register.filling + + erroneous_sites = self._apply_site_position_error(sites) + erroneous_filling = self._apply_binomial_noise(filling, \ + self._noise_data.filling_error, self._noise_data.vacancy_error) + + pre_seq = self._apply_binomial_noise(erroneous_filling, \ + self._noise_data.atom_detection_error_false_negative, \ + self._noise_data.atom_detection_error_false_positive) -# erroneous_filling = self._apply_binomial_noise(erroneous_filling, \ -# 0, self._noise_data.ground_prep_error) + erroneous_filling = self._apply_binomial_noise(erroneous_filling, \ + 0, self._noise_data.ground_prep_error) -# return erroneous_sites, erroneous_filling, pre_seq + return erroneous_sites, erroneous_filling, pre_seq -# def _apply_site_position_error(self, -# sites: List[List[float]]) -> List[List[float]]: -# erroneous_sites = [] -# for site in sites: -# erroneous_sites.append( -# site + self._noise_data.site_position_error * np.random.normal(size=2) -# ) + def _apply_site_position_error(self, + sites: List[List[float]]) -> List[List[float]]: + erroneous_sites = [] + for site in sites: + erroneous_sites.append( + site + self._noise_data.site_position_error * np.random.normal(size=2) + ) -# return erroneous_sites + return erroneous_sites -# def _apply_binomial_noise(self, -# arr: List[int], -# binomial_probability_p01: float, -# binomial_probability_p10: float) -> List[int]: -# noisy_arr = [] -# for val in arr: -# if val == 1: -# # Apply the error of switching 1 as 0 -# noisy_arr.append(1 - np.random.binomial(1, binomial_probability_p10)) -# else: -# # Apply the error of switching 0 as 1 -# noisy_arr.append(np.random.binomial(1, binomial_probability_p01)) + def _apply_binomial_noise(self, + arr: List[int], + binomial_probability_p01: float, + binomial_probability_p10: float) -> List[int]: + noisy_arr = [] + for val in arr: + if val == 1: + # Apply the error of switching 1 as 0 + noisy_arr.append(1 - np.random.binomial(1, binomial_probability_p10)) + else: + # Apply the error of switching 0 as 1 + noisy_arr.append(np.random.binomial(1, binomial_probability_p01)) -# return noisy_arr + return noisy_arr -# def _apply_rydberg_noise(self, program: AnalogHamiltonianSimulation, steps: int) \ -# -> Tuple[TimeSeries, LocalDetuning]: -# noisy_detuning, local_detuning = self._apply_detuning_errors( -# program.hamiltonian.detuning, -# program.to_ir().setup.ahs_register.filling, -# steps -# ) + def _apply_rydberg_noise(self, program: AnalogHamiltonianSimulation, steps: int) \ + -> Tuple[TimeSeries, LocalDetuning]: + noisy_detuning, local_detuning = self._apply_detuning_errors( + program.hamiltonian.detuning, + program.to_ir().setup.ahs_register.filling, + steps + ) -# noisy_amplitude = self._apply_amplitude_errors( -# program.hamiltonian.amplitude, -# steps, -# ) -# noisy_drive = DrivingField(amplitude = noisy_amplitude, -# detuning = noisy_detuning, -# phase = program.hamiltonian.phase) + noisy_amplitude = self._apply_amplitude_errors( + program.hamiltonian.amplitude, + steps, + ) + noisy_drive = DrivingField(amplitude = noisy_amplitude, + detuning = noisy_detuning, + phase = program.hamiltonian.phase) -# return noisy_drive, local_detuning + return noisy_drive, local_detuning -# def _apply_detuning_errors(self, -# detuning: TimeSeries, -# fillings: List[int], -# steps: int -# ) -> Tuple[TimeSeries, LocalDetuning]: + def _apply_detuning_errors(self, + detuning: TimeSeries, + fillings: List[int], + steps: int + ) -> Tuple[TimeSeries, LocalDetuning]: -# detuning_times = np.array(detuning.time_series.times(), dtype='float64') -# detuning_values = np.array(detuning.time_series.values(), dtype='float64') + detuning_times = np.array(detuning.time_series.times(), dtype='float64') + detuning_values = np.array(detuning.time_series.values(), dtype='float64') -# noisy_detuning_times = np.linspace(0, detuning_times[-1], steps) -# noisy_detuning_values = np.interp(noisy_detuning_times, detuning_times, detuning_values) + noisy_detuning_times = np.linspace(0, detuning_times[-1], steps) + noisy_detuning_values = np.interp(noisy_detuning_times, detuning_times, detuning_values) -# # Apply the detuning error -# noisy_detuning_values += \ -# self._noise_data.detuning_error * np.random.normal(size=len(noisy_detuning_values)) - -# noisy_detuning = TimeSeries.from_lists(noisy_detuning_times, noisy_detuning_values) - -# # Apply detuning inhomogeneity -# h = Pattern([np.random.rand() for _ in fillings]) -# detuning_local = TimeSeries.from_lists(noisy_detuning_times, -# self._noise_data.detuning_inhomogeneity * np.ones( -# len(noisy_detuning_times) -# ) -# ) + # Apply the detuning error + noisy_detuning_values += \ + self._noise_data.detuning_error * np.random.normal(size=len(noisy_detuning_values)) + + noisy_detuning = TimeSeries.from_lists(noisy_detuning_times, noisy_detuning_values) + + # Apply detuning inhomogeneity + h = Pattern([np.random.rand() for _ in fillings]) + detuning_local = TimeSeries.from_lists(noisy_detuning_times, + self._noise_data.detuning_inhomogeneity * np.ones( + len(noisy_detuning_times) + ) + ) -# # Assemble the local detuning -# local_detuning = LocalDetuning( -# magnitude=Field( -# time_series=detuning_local, -# pattern=h -# ) -# ) - -# return noisy_detuning, local_detuning + # Assemble the local detuning + local_detuning = LocalDetuning( + magnitude=Field( + time_series=detuning_local, + pattern=h + ) + ) + + return noisy_detuning, local_detuning -# def _apply_amplitude_errors(self, amplitude: TimeSeries, steps: int) \ -# -> TimeSeries: -# amplitude_times = np.array(amplitude.time_series.times(), dtype='float64') -# amplitude_values = np.array(amplitude.time_series.values(), dtype='float64') - -# # Rewrite the rabi_ramp_correction as a function of slopes -# rabi_ramp_correction_slopes = [self._noise_data.rabi_amplitude_max / float(corr.rampTime) -# for corr in self._noise_data.rabi_amplitude_ramp_correction -# ] -# rabi_ramp_correction_fracs = [float(corr.rabiCorrection) -# for corr in self._noise_data.rabi_amplitude_ramp_correction -# ] -# rabi_ramp_correction_slopes = rabi_ramp_correction_slopes[::-1] -# rabi_ramp_correction_fracs = rabi_ramp_correction_fracs[::-1] - -# # Helper function to find the correction factor for a given slope -# get_frac = scipy.interpolate.interp1d(rabi_ramp_correction_slopes, -# rabi_ramp_correction_fracs, -# bounds_error=False, -# fill_value="extrapolate" -# ) + def _apply_amplitude_errors(self, amplitude: TimeSeries, steps: int) \ + -> TimeSeries: + amplitude_times = np.array(amplitude.time_series.times(), dtype='float64') + amplitude_values = np.array(amplitude.time_series.values(), dtype='float64') + + # Rewrite the rabi_ramp_correction as a function of slopes + rabi_ramp_correction_slopes = [self._noise_data.rabi_amplitude_max / float(corr.rampTime) + for corr in self._noise_data.rabi_amplitude_ramp_correction + ] + rabi_ramp_correction_fracs = [float(corr.rabiCorrection) + for corr in self._noise_data.rabi_amplitude_ramp_correction + ] + rabi_ramp_correction_slopes = rabi_ramp_correction_slopes[::-1] + rabi_ramp_correction_fracs = rabi_ramp_correction_fracs[::-1] + + # Helper function to find the correction factor for a given slope + get_frac = scipy.interpolate.interp1d(rabi_ramp_correction_slopes, + rabi_ramp_correction_fracs, + bounds_error=False, + fill_value="extrapolate" + ) -# noisy_amplitude_times = np.linspace(0, amplitude_times[-1], steps) -# noisy_amplitude_values = [] + noisy_amplitude_times = np.linspace(0, amplitude_times[-1], steps) + noisy_amplitude_values = [] -# # First apply the rabi ramp correction -# for ind in range(len(amplitude_times)): -# if ind == 0: -# continue + # First apply the rabi ramp correction + for ind in range(len(amplitude_times)): + if ind == 0: + continue -# # First determine the correction factor from the slope -# t1, t2 = amplitude_times[ind-1], amplitude_times[ind] -# v1, v2 = amplitude_values[ind-1], amplitude_values[ind] -# slope = (v2 - v1) / (t2 - t1) -# if np.abs(slope) > 0: -# frac = get_frac(np.abs(slope)) * np.sign(slope) -# else: -# frac = 1.0 + # First determine the correction factor from the slope + t1, t2 = amplitude_times[ind-1], amplitude_times[ind] + v1, v2 = amplitude_values[ind-1], amplitude_values[ind] + slope = (v2 - v1) / (t2 - t1) + if np.abs(slope) > 0: + frac = get_frac(np.abs(slope)) * np.sign(slope) + else: + frac = 1.0 -# # Next, determine the coefficients for the quadratic correction -# if frac >= 1.0: -# a, b, c = 0, 0, v2 -# else: -# # Determine the coefficients for the quadratic correction -# # of the form f(t) = a*t^2 + b * t + c -# # such that f(t1) = v1 and f(t2) = v2 and -# # a/3*(t2^3-t1^3) + b/2*(t2^2-t1^2) + c(t2-t1) = frac * (t2-t1) * (v2-v1)/2 + # Next, determine the coefficients for the quadratic correction + if frac >= 1.0: + a, b, c = 0, 0, v2 + else: + # Determine the coefficients for the quadratic correction + # of the form f(t) = a*t^2 + b * t + c + # such that f(t1) = v1 and f(t2) = v2 and + # a/3*(t2^3-t1^3) + b/2*(t2^2-t1^2) + c(t2-t1) = frac * (t2-t1) * (v2-v1)/2 -# a = 3 * (v1 + frac * v1 + v2 - frac * v2)/(t1 - t2)**2 -# c = (t2 * v1 * ((2 + 3 * frac) * t1 + t2) + t1 * v2 * (t1 + (2 - 3 * frac) * t2))/(t1 - t2)**2 -# b = (v2 - c - a * t2**2) / t2 + a = 3 * (v1 + frac * v1 + v2 - frac * v2)/(t1 - t2)**2 + c = (t2 * v1 * ((2 + 3 * frac) * t1 + t2) + t1 * v2 * (t1 + (2 - 3 * frac) * t2))/(t1 - t2)**2 + b = (v2 - c - a * t2**2) / t2 -# # Finally, put values into noisy_amplitude_values -# for t in noisy_amplitude_times: -# if t1 <= t and t <= t2: -# noisy_amplitude_values.append(a * t**2 + b * t + c) + # Finally, put values into noisy_amplitude_values + for t in noisy_amplitude_times: + if t1 <= t and t <= t2: + noisy_amplitude_values.append(a * t**2 + b * t + c) -# # Next apply amplitude error -# rabi_errors = 1 + self._noise_data.rabi_frequency_error_rel * np.random.normal(size=len(noisy_amplitude_values)) -# noisy_amplitude_values = np.multiply(noisy_amplitude_values, rabi_errors) -# noisy_amplitude_values = [max(0, value) for value in noisy_amplitude_values] # amplitude has to be non-negative + # Next apply amplitude error + rabi_errors = 1 + self._noise_data.rabi_frequency_error_rel * np.random.normal(size=len(noisy_amplitude_values)) + noisy_amplitude_values = np.multiply(noisy_amplitude_values, rabi_errors) + noisy_amplitude_values = [max(0, value) for value in noisy_amplitude_values] # amplitude has to be non-negative -# noisy_amplitude = TimeSeries.from_lists(noisy_amplitude_times, noisy_amplitude_values) + noisy_amplitude = TimeSeries.from_lists(noisy_amplitude_times, noisy_amplitude_values) -# return noisy_amplitude + return noisy_amplitude \ No newline at end of file From 2e46daf9c1a81de84963f982a072771de36f0ba6 Mon Sep 17 00:00:00 2001 From: maolinml <86260930+maolinml@users.noreply.github.com> Date: Thu, 12 Sep 2024 18:51:16 -0700 Subject: [PATCH 11/14] modify run_passes a bit for ahs --- src/braket/emulation/emulator.py | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-) diff --git a/src/braket/emulation/emulator.py b/src/braket/emulation/emulator.py index 51cc8e93b..19f89d98c 100644 --- a/src/braket/emulation/emulator.py +++ b/src/braket/emulation/emulator.py @@ -12,7 +12,7 @@ from braket.ir.openqasm import Program as OpenQasmProgram from braket.tasks import QuantumTask from braket.tasks.quantum_task_batch import QuantumTaskBatch - +from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation class Emulator(Device, BaseEmulator): @@ -157,13 +157,24 @@ def run_passes( ProgramType: A compiled program with a noise model applied, if one exists for this emulator and apply_noise_model is true. """ - try: - program = super().run_passes(task_specification) - if apply_noise_model and self.noise_model: - return self._noise_model.apply(program) - return program - except Exception as e: - self._raise_exception(e) + if isinstance(task_specification, AnalogHamiltonianSimulation): + try: + if apply_noise_model: + program = super().run_passes(task_specification) + return program + else: + self.validate(program) + return program + except Exception as e: + self._raise_exception(e) + else: + try: + program = super().run_passes(task_specification) + if apply_noise_model and self.noise_model: + return self._noise_model.apply(program) + return program + except Exception as e: + self._raise_exception(e) def validate(self, task_specification: ProgramType) -> None: """ From 137302255d31f1f6d66d48347d869364e552f0d2 Mon Sep 17 00:00:00 2001 From: maolinml <86260930+maolinml@users.noreply.github.com> Date: Thu, 12 Sep 2024 18:52:02 -0700 Subject: [PATCH 12/14] minor change --- src/braket/aws/aws_emulation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/braket/aws/aws_emulation.py b/src/braket/aws/aws_emulation.py index 9dd717a5f..c0a8de832 100644 --- a/src/braket/aws/aws_emulation.py +++ b/src/braket/aws/aws_emulation.py @@ -9,7 +9,7 @@ from braket.device_schema.iqm import IqmDeviceCapabilities from braket.device_schema.quera import QueraDeviceCapabilities from braket.device_schema.rigetti import RigettiDeviceCapabilities -from braket.emulation.emulation_passes.ahs_passes import AhsValidator #, AhsNoise, AhsNoiseData +from braket.emulation.emulation_passes.ahs_passes import AhsValidator, AhsNoise, AhsNoiseData from braket.emulation.emulation_passes.ahs_passes.device_capabilities_constants import ( DeviceCapabilitiesConstants, ) From bf7d8d041583869b1dd5dcaca818eadf9dd0ef88 Mon Sep 17 00:00:00 2001 From: maolinml <86260930+maolinml@users.noreply.github.com> Date: Thu, 12 Sep 2024 18:53:31 -0700 Subject: [PATCH 13/14] minor change --- src/braket/emulation/emulator.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/braket/emulation/emulator.py b/src/braket/emulation/emulator.py index 19f89d98c..f2d9f31e9 100644 --- a/src/braket/emulation/emulator.py +++ b/src/braket/emulation/emulator.py @@ -163,8 +163,8 @@ def run_passes( program = super().run_passes(task_specification) return program else: - self.validate(program) - return program + self.validate(task_specification) + return task_specification except Exception as e: self._raise_exception(e) else: From 8bb7216014b7cb7b60abdda11508c09b4d4c7db6 Mon Sep 17 00:00:00 2001 From: maolinml <86260930+maolinml@users.noreply.github.com> Date: Sat, 14 Sep 2024 12:10:25 -0700 Subject: [PATCH 14/14] change the backend for ahs to ahs tn noisy --- src/braket/aws/aws_device.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/braket/aws/aws_device.py b/src/braket/aws/aws_device.py index 49b24cba5..d759b8248 100644 --- a/src/braket/aws/aws_device.py +++ b/src/braket/aws/aws_device.py @@ -931,7 +931,7 @@ def _setup_gate_device_emulator(self) -> Emulator: return self._emulator def _setup_ahs_device_emulator(self) -> Emulator: - self._emulator = Emulator(backend="braket_ahs_noisy", name=self._name) + self._emulator = Emulator(backend="braket_ahs_tn_noisy", name=self._name) self._emulator.add_pass(ahs_criterion(self.properties)) self._emulator.add_pass(ahs_noise_model(self.properties)) return self._emulator