emu-sv 1.0.1__py3-none-any.whl → 2.0.1__py3-none-any.whl

emu_sv/sv_backend.py

@@ -1,101 +1,125 @@
-from emu_base.base_classes.backend import Backend, BackendConfig
-from emu_base.base_classes.results import Results
-from emu_sv.sv_config import SVConfig
-from pulser import Sequence
-from emu_base.pulser_adapter import PulserData
-from emu_sv.time_evolution import do_time_step
-from emu_sv import StateVector
 import torch
-from time import time
 from resource import RUSAGE_SELF, getrusage
-from emu_base import DEVICE_COUNT
-from copy import deepcopy
+import time
+import typing
+
+from pulser.backend import EmulatorBackend, Results, Observable, State, EmulationConfig
+
+from emu_base import PulserData
+
+from emu_sv.state_vector import StateVector
+from emu_sv.sv_config import SVConfig
+from emu_sv.time_evolution import do_time_step
+
 
 _TIME_CONVERSION_COEFF = 0.001  # Omega and delta are given in rad/ms, dt in ns
 
 
-class SVBackend(Backend):
+class SVBackend(EmulatorBackend):
     """
     A backend for emulating Pulser sequences using state vectors and sparse matrices.
     """
 
-    def run(self, sequence: Sequence, sv_config: BackendConfig) -> Results:
+    default_config = SVConfig()
+
+    def run(self) -> Results:
         """
         Emulates the given sequence.
 
-        Args:
-            sequence: a Pulser sequence to simulate
-            sv_config: the backends config. Should be of type SVConfig
-
         Returns:
             the simulation results
         """
-        assert isinstance(sv_config, SVConfig)
-
-        self.validate_sequence(sequence)
-
-        results = Results()
+        assert isinstance(self._config, SVConfig)
 
-        data = PulserData(sequence=sequence, config=sv_config, dt=sv_config.dt)
-        omega, delta, phi = data.omega, data.delta, data.phi
-
-        target_times = data.target_times
+        pulser_data = PulserData(
+            sequence=self._sequence, config=self._config, dt=self._config.dt
+        )
+        self.target_times = pulser_data.target_times
+        self.time = time.time()
+        omega, delta, phi = pulser_data.omega, pulser_data.delta, pulser_data.phi
 
         nsteps = omega.shape[0]
         nqubits = omega.shape[1]
-        device = "cuda" if sv_config.gpu and DEVICE_COUNT > 0 else "cpu"
 
-        if sv_config.initial_state is not None:
-            state = deepcopy(sv_config.initial_state)
-            state.vector = state.vector.to(device)
+        self.results = Results(atom_order=(), total_duration=self.target_times[-1])
+        self.statistics = Statistics(
+            evaluation_times=[t / self.target_times[-1] for t in self.target_times],
+            data=[],
+            timestep_count=nsteps,
+        )
+
+        if self._config.initial_state is not None:
+            state = self._config.initial_state
+            state = StateVector(state.vector.clone(), gpu=state.vector.is_cuda)
         else:
-            state = StateVector.make(nqubits, gpu=sv_config.gpu)
+            state = StateVector.make(nqubits, gpu=self._config.gpu)
 
         for step in range(nsteps):
-            start = time()
-            dt = target_times[step + 1] - target_times[step]
+            dt = self.target_times[step + 1] - self.target_times[step]
 
             state.vector, H = do_time_step(
                 dt * _TIME_CONVERSION_COEFF,
                 omega[step],
                 delta[step],
                 phi[step],
-                data.full_interaction_matrix,
+                pulser_data.full_interaction_matrix,
                 state.vector,
-                sv_config.krylov_tolerance,
+                self._config.krylov_tolerance,
             )
 
-            for callback in sv_config.callbacks:
+            # callbacks in observables and self.statistics in H
+            # have "# type: ignore[arg-type]" because H has it's own type
+            # meaning H is not inherited from Operator class.
+            # We decided that ignore[arg-type] is better compared to
+            # having many unused NotImplemented methods
+            for callback in self._config.observables:
                 callback(
-                    sv_config,
-                    target_times[step + 1],
+                    self._config,
+                    self.target_times[step + 1] / self.target_times[-1],
                     state,
                     H,  # type: ignore[arg-type]
-                    results,
+                    self.results,
                 )
 
-            end = time()
-            self.log_step_statistics(
-                results,
-                step=step,
-                duration=end - start,
-                timestep_count=nsteps,
-                state=state,
-                sv_config=sv_config,
+            self.statistics.data.append(time.time() - self.time)
+            self.statistics(
+                self._config,
+                self.target_times[step + 1] / self.target_times[-1],
+                state,
+                H,  # type: ignore[arg-type]
+                self.results,
             )
+            self.time = time.time()
 
-        return results
+        return self.results
 
-    @staticmethod
-    def log_step_statistics(
-        results: Results,
-        *,
-        step: int,
-        duration: float,
+
+class Statistics(Observable):
+    def __init__(
+        self,
+        evaluation_times: typing.Sequence[float] | None,
+        data: list[float],
         timestep_count: int,
-        state: StateVector,
-        sv_config: SVConfig,
-    ) -> None:
+    ):
+        super().__init__(evaluation_times=evaluation_times)
+        self.data = data
+        self.timestep_count = timestep_count
+
+    @property
+    def _base_tag(self) -> str:
+        return "statistics"
+
+    def apply(
+        self,
+        *,
+        config: EmulationConfig,
+        state: State,
+        **kwargs: typing.Any,
+    ) -> dict:
+        """Calculates the observable to store in the Results."""
+        assert isinstance(state, StateVector)
+        assert isinstance(config, SVConfig)
+        duration = self.data[-1]
         if state.vector.is_cuda:
             max_mem_per_device = (
                 torch.cuda.max_memory_allocated(device) * 1e-6
@@ -105,22 +129,13 @@ class SVBackend(Backend):
         else:
             max_mem = getrusage(RUSAGE_SELF).ru_maxrss * 1e-3
 
-        sv_config.logger.info(
-            f"step = {step + 1}/{timestep_count}, "
+        config.logger.info(
+            f"step = {len(self.data)}/{self.timestep_count}, "
             + f"RSS = {max_mem:.3f} MB, "
             + f"Δt = {duration:.3f} s"
         )
 
-        if results.statistics is None:
-            assert step == 0
-            results.statistics = {"steps": []}
-
-        assert "steps" in results.statistics
-        assert len(results.statistics["steps"]) == step
-
-        results.statistics["steps"].append(
-            {
-                "RSS": max_mem,
-                "duration": duration,
-            }
-        )
+        return {
+            "RSS": max_mem,
+            "duration": duration,
+        }

emu_sv/sv_config.py

@@ -1,35 +1,34 @@
-from emu_base.base_classes import (
-    CorrelationMatrix,
-    QubitDensity,
-    EnergyVariance,
-    SecondMomentOfEnergy,
-)
-
 import copy
-
-
-from emu_base import BackendConfig
-from emu_sv import StateVector
-from typing import Any
+import logging
+import pathlib
+import sys
+from types import MethodType
+from typing import Any, ClassVar
 
 from emu_sv.custom_callback_implementations import (
-    qubit_density_sv_impl,
-    energy_variance_sv_impl,
-    second_moment_sv_impl,
     correlation_matrix_sv_impl,
+    energy_second_moment_sv_impl,
+    energy_variance_sv_impl,
+    qubit_occupation_sv_impl,
 )
 
-from types import MethodType
+from pulser.backend import (
+    CorrelationMatrix,
+    EmulationConfig,
+    EnergySecondMoment,
+    EnergyVariance,
+    Occupation,
+    BitStrings,
+)
 
 
-class SVConfig(BackendConfig):
+class SVConfig(EmulationConfig):
     """
     The configuration of the emu-sv SVBackend. The kwargs passed to this class
     are passed on to the base class.
     See the API for that class for a list of available options.
 
     Args:
-        initial_state: the initial state to use in the simulation
         dt: the timestep size that the solver uses. Note that observables are
             only calculated if the evaluation_times are divisible by dt.
         max_krylov_dim:
@@ -48,43 +47,101 @@ class SVConfig(BackendConfig):
         >>>     with_modulation=True) #the last arg is taken from the base class
     """
 
+    # Whether to warn if unexpected kwargs are received
+    _enforce_expected_kwargs: ClassVar[bool] = True
+
     def __init__(
         self,
         *,
-        initial_state: StateVector | None = None,
         dt: int = 10,
         max_krylov_dim: int = 100,
         krylov_tolerance: float = 1e-10,
         gpu: bool = True,
+        interaction_cutoff: float = 0.0,
+        log_level: int = logging.INFO,
+        log_file: pathlib.Path | None = None,
         **kwargs: Any,
     ):
-        super().__init__(**kwargs)
+        kwargs.setdefault("observables", [BitStrings(evaluation_times=[1.0])])
+        super().__init__(
+            dt=dt,
+            max_krylov_dim=max_krylov_dim,
+            gpu=gpu,
+            krylov_tolerance=krylov_tolerance,
+            interaction_cutoff=interaction_cutoff,
+            log_level=log_level,
+            log_file=log_file,
+            **kwargs,
+        )
+
+        self.monkeypatch_observables()
 
-        self.initial_state = initial_state
-        self.dt = dt
-        self.max_krylov_dim = max_krylov_dim
-        self.gpu = gpu
-        self.krylov_tolerance = krylov_tolerance
+        self.logger = logging.getLogger("global_logger")
+        if log_file is None:
+            logging.basicConfig(
+                level=log_level, format="%(message)s", stream=sys.stdout, force=True
+            )  # default to stream = sys.stderr
+        else:
+            logging.basicConfig(
+                level=log_level,
+                format="%(message)s",
+                filename=str(log_file),
+                filemode="w",
+                force=True,
+            )
+        if (self.noise_model.runs != 1 and self.noise_model.runs is not None) or (
+            self.noise_model.samples_per_run != 1
+            and self.noise_model.samples_per_run is not None
+        ):
+            self.logger.warning(
+                "Warning: The runs and samples_per_run "
+                "values of the NoiseModel are ignored!"
+            )
 
-        for num, obs in enumerate(self.callbacks):  # monkey patch
+    def _expected_kwargs(self) -> set[str]:
+        return super()._expected_kwargs() | {
+            "dt",
+            "max_krylov_dim",
+            "krylov_tolerance",
+            "gpu",
+            "interaction_cutoff",
+            "log_level",
+            "log_file",
+        }
+
+    def monkeypatch_observables(self) -> None:
+        obs_list = []
+        for _, obs in enumerate(self.observables):  # monkey patch
             obs_copy = copy.deepcopy(obs)
-            if isinstance(obs, QubitDensity):
+            if isinstance(obs, Occupation):
                 obs_copy.apply = MethodType(  # type: ignore[method-assign]
-                    qubit_density_sv_impl, obs
+                    qubit_occupation_sv_impl, obs_copy
                 )
-                self.callbacks[num] = obs_copy
             elif isinstance(obs, EnergyVariance):
                 obs_copy.apply = MethodType(  # type: ignore[method-assign]
-                    energy_variance_sv_impl, obs
+                    energy_variance_sv_impl, obs_copy
                 )
-                self.callbacks[num] = obs_copy
-            elif isinstance(obs, SecondMomentOfEnergy):
+            elif isinstance(obs, EnergySecondMoment):
                 obs_copy.apply = MethodType(  # type: ignore[method-assign]
-                    second_moment_sv_impl, obs
+                    energy_second_moment_sv_impl, obs_copy
                 )
-                self.callbacks[num] = obs_copy
             elif isinstance(obs, CorrelationMatrix):
                 obs_copy.apply = MethodType(  # type: ignore[method-assign]
-                    correlation_matrix_sv_impl, obs
+                    correlation_matrix_sv_impl, obs_copy
                 )
-                self.callbacks[num] = obs_copy
+            obs_list.append(obs_copy)
+        self.observables = tuple(obs_list)
+
+    def init_logging(self) -> None:
+        if self.log_file is None:
+            logging.basicConfig(
+                level=self.log_level, format="%(message)s", stream=sys.stdout, force=True
+            )  # default to stream = sys.stderr
+        else:
+            logging.basicConfig(
+                level=self.log_level,
+                format="%(message)s",
+                filename=str(self.log_file),
+                filemode="w",
+                force=True,
+            )

emu_sv/utils.py

@@ -0,0 +1,8 @@
+def index_to_bitstring(nqubits: int, index: int) -> str:
+    """
+    Convert an integer index into its corresponding bitstring representation.
+    """
+
+    msg = f"index {index} can not exceed Hilbert space size d**{nqubits}"
+    assert index < 2**nqubits, msg
+    return format(index, f"0{nqubits}b")

{emu_sv-1.0.1.dist-info → emu_sv-2.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emu-sv
-Version: 1.0.1
+Version: 2.0.1
 Summary: Pasqal State Vector based pulse emulator built on PyTorch
 Project-URL: Documentation, https://pasqal-io.github.io/emulators/
 Project-URL: Repository, https://github.com/pasqal-io/emulators
@@ -25,7 +25,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
-Requires-Dist: emu-base==1.2.7
+Requires-Dist: emu-base==2.0.1
 Description-Content-Type: text/markdown
 
 <div align="center">

emu_sv-2.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+emu_sv/__init__.py,sha256=VYP3ZjQxPQINv-VC6URdtivwJDCAaBx1Ld5iCEdTNzw,701
+emu_sv/custom_callback_implementations.py,sha256=zvsSiDIc56gwybKq87VFZyKsniTDye6-oFd2-R0shpg,3447
+emu_sv/dense_operator.py,sha256=NfgzVpnNitc5ZSM4RlfpAc5Ls2wFPNsTxdeFdhJSg1o,6909
+emu_sv/density_matrix_state.py,sha256=6UBLUXaJaUdzOhflrKolcnH8737JszX7sry1WmbyakI,6993
+emu_sv/hamiltonian.py,sha256=zZq-_yUVhhafHxKkTZN0hivzzWFwC9JkTEk4MV1fBag,6168
+emu_sv/state_vector.py,sha256=iX_33hGzn5ZsmG-LWE_Tjhu-Tvy4_lBOjHieT0C-VbA,9335
+emu_sv/sv_backend.py,sha256=LE8tfoo-5-o6O39ixUMZAGo-xM8m9Xwcl_HmM1pSYtw,4433
+emu_sv/sv_config.py,sha256=QRy0VbCugmY6TQZ48nD6RxPJbpu0wzN7-E1Sud7YxLQ,5106
+emu_sv/time_evolution.py,sha256=48C0DL_SOu7Jdjk2QKBNPsevOpQlgsPYUHE7cScY-ZM,796
+emu_sv/utils.py,sha256=-axfQ2tqw0C7I9yw-28g7lytyk373DNBjDALh4kLBrM,302
+emu_sv-2.0.1.dist-info/METADATA,sha256=FSrCZuRIQ25LNbffZ2cz73nxbX-n1JbG9xgblJecYjc,3513
+emu_sv-2.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emu_sv-2.0.1.dist-info/RECORD,,

emu_sv-1.0.1.dist-info/RECORD

@@ -1,11 +0,0 @@
-emu_sv/__init__.py,sha256=rcIsdgWgk5n75z0fSQtQsVgrFs_5jtA52WwGsTxDgAs,845
-emu_sv/custom_callback_implementations.py,sha256=H7fy0trUtY00wid6VeRJ2inUazFbkMlgavTfm8QtGq8,2754
-emu_sv/dense_operator.py,sha256=69rv1J5jsHSRoPsgZqKJZnttCgMLIk4tDCBsOaOBVR8,7034
-emu_sv/hamiltonian.py,sha256=Rg_tLGTgaL4Y8xWtO1P2axRQNrdKfHRnHwnv_BfZTEI,6091
-emu_sv/state_vector.py,sha256=s26ktVkuBID9IU6ySMup8ci7M5Tn6HHCT4jcyZGxV_w,8036
-emu_sv/sv_backend.py,sha256=lIi_aTyfW-pzrfxwJHSoF5klwJnWtLv3awwU4DSL4m4,3770
-emu_sv/sv_config.py,sha256=NUAxqYG0NTWbarVreFr1Tb-8FzB0LVQ0fYnb2QSCzxo,3161
-emu_sv/time_evolution.py,sha256=48C0DL_SOu7Jdjk2QKBNPsevOpQlgsPYUHE7cScY-ZM,796
-emu_sv-1.0.1.dist-info/METADATA,sha256=hNCpmCxzB_i_ciIRzqebQ9seyPhp8F0DiuceBYG4T7k,3513
-emu_sv-1.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-emu_sv-1.0.1.dist-info/RECORD,,