emu-mps 2.3.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

emu_mps/__init__.py

@@ -9,12 +9,11 @@ from pulser.backend import (
     StateResult,
     EnergySecondMoment,
 )
-from .mps_config import MPSConfig
+from .mps_config import MPSConfig, Solver
 from .mpo import MPO
 from .mps import MPS, inner
 from .mps_backend import MPSBackend
 from .observables import EntanglementEntropy
-from emu_base import aggregate
 
 
 __all__ = [
@@ -23,6 +22,7 @@ __all__ = [
     "MPS",
     "inner",
     "MPSConfig",
+    "Solver",
     "MPSBackend",
     "StateResult",
     "BitStrings",
@@ -33,8 +33,7 @@ __all__ = [
     "Energy",
     "EnergyVariance",
     "EnergySecondMoment",
-    "aggregate",
     "EntanglementEntropy",
 ]
 
-__version__ = "2.3.0"
+__version__ = "2.4.0"

emu_mps/mps.py

@@ -153,7 +153,7 @@ class MPS(State[complex, torch.Tensor]):
 
         for i in range(rl_swipe_start, desired_orthogonality_center, -1):
             q, r = torch.linalg.qr(
-                self.factors[i].view(self.factors[i].shape[0], -1).mT,
+                self.factors[i].contiguous().view(self.factors[i].shape[0], -1).mT,
             )
             self.factors[i] = q.mT.view(-1, 2, self.factors[i].shape[2])
             self.factors[i - 1] = torch.tensordot(

emu_mps/mps_backend_impl.py

@@ -10,7 +10,6 @@ import uuid
 from copy import deepcopy
 from collections import Counter
 from enum import Enum, auto
-from resource import RUSAGE_SELF, getrusage
 from types import MethodType
 from typing import Any, Optional
 
@@ -18,7 +17,7 @@ import torch
 from pulser import Sequence
 from pulser.backend import EmulationConfig, Observable, Results, State
 
-from emu_base import DEVICE_COUNT, PulserData
+from emu_base import DEVICE_COUNT, PulserData, get_max_rss
 from emu_base.math.brents_root_finding import BrentsRootFinder
 from emu_base.utils import deallocate_tensor
 
@@ -26,9 +25,9 @@ from emu_mps.hamiltonian import make_H, update_H
 from emu_mps.mpo import MPO
 from emu_mps.mps import MPS
 from emu_mps.mps_config import MPSConfig
-from emu_base.noise import pick_dark_qubits
 from emu_base.jump_lindblad_operators import compute_noise_from_lindbladians
 import emu_mps.optimatrix as optimat
+from emu_mps.solver import Solver
 from emu_mps.solver_utils import (
     evolve_pair,
     evolve_single,
@@ -69,14 +68,7 @@ class Statistics(Observable):
         """Calculates the observable to store in the Results."""
         assert isinstance(state, MPS)
         duration = self.data[-1]
-        if state.factors[0].is_cuda:
-            max_mem_per_device = (
-                torch.cuda.max_memory_allocated(device) * 1e-6
-                for device in range(torch.cuda.device_count())
-            )
-            max_mem = max(max_mem_per_device)
-        else:
-            max_mem = getrusage(RUSAGE_SELF).ru_maxrss * 1e-3
+        max_mem = get_max_rss(state.factors[0].is_cuda)
 
         config.logger.info(
             f"step = {len(self.data)}/{self.timestep_count}, "
@@ -193,10 +185,9 @@ class MPSBackendImpl:
     def init_dark_qubits(self) -> None:
         # has_state_preparation_error
         if self.config.noise_model.state_prep_error > 0.0:
+            bad_atoms = self.pulser_data.hamiltonian.bad_atoms
             self.well_prepared_qubits_filter = torch.logical_not(
-                pick_dark_qubits(
-                    self.config.noise_model.state_prep_error, self.qubit_count
-                )
+                torch.tensor(list(bool(x) for x in bad_atoms.values()))
             )
         else:
             self.well_prepared_qubits_filter = None
@@ -252,6 +243,7 @@ class MPSBackendImpl:
         initial_state.truncate()
         initial_state *= 1 / initial_state.norm()
         self.state = initial_state
+        self.state.orthogonalize(0)
 
     def init_hamiltonian(self) -> None:
         """
@@ -699,18 +691,20 @@ class DMRGBackendImpl(MPSBackendImpl):
         mps_config: MPSConfig,
         pulser_data: PulserData,
         energy_tolerance: float = 1e-5,
-        max_sweeps: int = 999,
-        residual_tolerance: float = 1e-7,
+        max_sweeps: int = 2000,
     ):
+
+        if mps_config.noise_model.noise_types != ():
+            raise NotImplementedError(
+                "DMRG solver does not currently support noise types"
+                f"you are using: {mps_config.noise_model.noise_types}"
+            )
         super().__init__(mps_config, pulser_data)
-        self.init()
-        self.state.orthogonalize(0)
         self.previous_energy: Optional[float] = None
         self.current_energy: Optional[float] = None
         self.sweep_count: int = 0
         self.energy_tolerance: float = energy_tolerance
         self.max_sweeps: int = max_sweeps
-        self.residual_tolerance: float = residual_tolerance
 
     def convergence_check(self, energy_tolerance: float) -> bool:
         if self.previous_energy is None or self.current_energy is None:
@@ -728,63 +722,72 @@ class DMRGBackendImpl(MPSBackendImpl):
             SwipeDirection.RIGHT_TO_LEFT,
         ), "Unknown Swipe direction"
 
-        if self.swipe_direction == SwipeDirection.LEFT_TO_RIGHT:
-            left_idx, right_idx = idx, idx + 1
-        elif self.swipe_direction == SwipeDirection.RIGHT_TO_LEFT:
-            left_idx, right_idx = idx - 1, idx
-
         orth_center_right = self.swipe_direction == SwipeDirection.LEFT_TO_RIGHT
         new_L, new_R, energy = minimize_energy_pair(
-            state_factors=self.state.factors[left_idx : right_idx + 1],
-            ham_factors=self.hamiltonian.factors[left_idx : right_idx + 1],
+            state_factors=self.state.factors[idx : idx + 2],
+            ham_factors=self.hamiltonian.factors[idx : idx + 2],
             baths=(self.left_baths[-1], self.right_baths[-1]),
             orth_center_right=orth_center_right,
             config=self.config,
-            residual_tolerance=self.residual_tolerance,
+            residual_tolerance=self.config.precision,
         )
-        self.state.factors[left_idx], self.state.factors[right_idx] = new_L, new_R
-        self.state.orthogonality_center = right_idx if orth_center_right else left_idx
+        self.state.factors[idx], self.state.factors[idx + 1] = new_L, new_R
+        self.state.orthogonality_center = idx + 1 if orth_center_right else idx
         self.current_energy = energy
 
         # updating baths and orthogonality center
         if self.swipe_direction == SwipeDirection.LEFT_TO_RIGHT:
+            self._left_to_right_update(idx)
+        elif self.swipe_direction == SwipeDirection.RIGHT_TO_LEFT:
+            self._right_to_left_update(idx)
+        else:
+            raise Exception("Did not expect this")
+
+        self.save_simulation()
+
+    def _left_to_right_update(self, idx: int) -> None:
+        if idx < self.qubit_count - 2:
             self.left_baths.append(
                 new_left_bath(
                     self.get_current_left_bath(),
-                    self.state.factors[left_idx],
-                    self.hamiltonian.factors[right_idx],
-                ).to(self.state.factors[right_idx].device)
+                    self.state.factors[idx],
+                    self.hamiltonian.factors[idx],
+                ).to(self.state.factors[idx + 1].device)
             )
             self.right_baths.pop()
             self.sweep_index += 1
 
-            if self.sweep_index == self.qubit_count - 1:
-                self.swipe_direction = SwipeDirection.RIGHT_TO_LEFT
+        if self.sweep_index == self.qubit_count - 2:
+            self.swipe_direction = SwipeDirection.RIGHT_TO_LEFT
 
-        elif self.swipe_direction == SwipeDirection.RIGHT_TO_LEFT:
+    def _right_to_left_update(self, idx: int) -> None:
+        if idx > 0:
             self.right_baths.append(
                 new_right_bath(
                     self.get_current_right_bath(),
-                    self.state.factors[right_idx],
-                    self.hamiltonian.factors[right_idx],
-                ).to(self.state.factors[left_idx].device)
+                    self.state.factors[idx + 1],
+                    self.hamiltonian.factors[idx + 1],
+                ).to(self.state.factors[idx].device)
             )
             self.left_baths.pop()
             self.sweep_index -= 1
 
-            if self.sweep_index == 0:
-                self.swipe_direction = SwipeDirection.LEFT_TO_RIGHT
-                self.sweep_count += 1
-                self.sweep_complete()
+        if self.sweep_index == 0:
+            self.state.orthogonalize(0)
+            self.swipe_direction = SwipeDirection.LEFT_TO_RIGHT
+            self.sweep_count += 1
+            self.sweep_complete()
 
     def sweep_complete(self) -> None:
         # This marks the end of one full sweep: checking convergence
         if self.convergence_check(self.energy_tolerance):
+            self.current_time = self.target_time
             self.timestep_complete()
         elif self.sweep_count + 1 > self.max_sweeps:
-            # not converged: restart a new sweep
+            # not converged
             raise RuntimeError(f"DMRG did not converge after {self.max_sweeps} sweeps")
         else:
+            # not converged for the current sweep. restart
             self.previous_energy = self.current_energy
 
         assert self.sweep_index == 0
@@ -798,5 +801,6 @@ def create_impl(sequence: Sequence, config: MPSConfig) -> MPSBackendImpl:
 
     if pulser_data.has_lindblad_noise:
         return NoisyMPSBackendImpl(config, pulser_data)
-
+    if config.solver == Solver.DMRG:
+        return DMRGBackendImpl(config, pulser_data)
     return MPSBackendImpl(config, pulser_data)

emu_mps/mps_config.py

@@ -4,6 +4,7 @@ from types import MethodType
 import copy
 
 from emu_base import DEVICE_COUNT
+from emu_mps.solver import Solver
 from emu_mps.custom_callback_implementations import (
     energy_mps_impl,
     energy_second_moment_mps_impl,
@@ -53,6 +54,11 @@ class MPSConfig(EmulationConfig):
         autosave_dt: minimum time interval in seconds between two autosaves.
             Saving the simulation state is only possible at specific times,
             therefore this interval is only a lower bound.
+        solver: chooses the solver algorithm to run a sequence.
+            Two options are currently available:
+            ``TDVP``, which performs ordinary time evolution,
+            and ``DMRG``, which adiabatically follows the ground state
+            of a given adiabatic pulse.
         kwargs: arguments that are passed to the base class
 
     Examples:
@@ -81,6 +87,7 @@ class MPSConfig(EmulationConfig):
         log_file: pathlib.Path | None = None,
         autosave_prefix: str = "emu_mps_save_",
         autosave_dt: int = 600,  # 10 minutes
+        solver: Solver = Solver.TDVP,
         **kwargs: Any,
     ):
         kwargs.setdefault("observables", [BitStrings(evaluation_times=[1.0])])
@@ -97,6 +104,7 @@ class MPSConfig(EmulationConfig):
             log_file=log_file,
             autosave_prefix=autosave_prefix,
             autosave_dt=autosave_dt,
+            solver=solver,
             **kwargs,
         )
         if self.optimize_qubit_ordering:
@@ -144,6 +152,7 @@ class MPSConfig(EmulationConfig):
             "log_file",
             "autosave_prefix",
             "autosave_dt",
+            "solver",
         }
 
     def monkeypatch_observables(self) -> None:

emu_mps/solver.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class Solver(str, Enum):
+    TDVP = "tdvp"
+    DMRG = "dmrg"

{emu_mps-2.3.0.dist-info → emu_mps-2.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emu-mps
-Version: 2.3.0
+Version: 2.4.0
 Summary: Pasqal MPS 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==2.3.0
+Requires-Dist: emu-base==2.4.0
 Description-Content-Type: text/markdown
 
 <div align="center">

{emu_mps-2.3.0.dist-info → emu_mps-2.4.0.dist-info}/RECORD

@@ -1,18 +1,19 @@
-emu_mps/__init__.py,sha256=vvVRxFPudsVALA-_YyqWf8rlIRhtI1WzBWakYk2vfB8,734
+emu_mps/__init__.py,sha256=ySFn8SLcpsp1ndtvv38qg_gTlO9jt_jmwZVZd21hsg0,708
 emu_mps/algebra.py,sha256=78XP9HEbV3wGNUzIulcLU5HizW4XAYmcFdkCe1T1x-k,5489
 emu_mps/custom_callback_implementations.py,sha256=SZGKVyS8U5hy07L-3SqpWlCAqGGKFTlSlWexZwSmjrM,2408
 emu_mps/hamiltonian.py,sha256=gOPxNOBmk6jRPPjevERuCP_scGv0EKYeAJ0uxooihes,15622
 emu_mps/mpo.py,sha256=aWSVuEzZM-_7ZD5Rz3-tSJWX22ARP0tMIl3gUu-_4V4,7834
-emu_mps/mps.py,sha256=n5KPuWr2qCNW4Q1OKpUGrSuhu4IbVp1v1BPLvLILbGg,19960
+emu_mps/mps.py,sha256=I7LAxoOPKr4me5ZFdL5AZMerg7go9I1fu-MAI0ZBMgU,19973
 emu_mps/mps_backend.py,sha256=bS83qFxvdoK-c12_1WaPw6O7xUc7vdWifZNHUzNP5sM,2091
-emu_mps/mps_backend_impl.py,sha256=O3vbjw3jlgyj0hOYv3nMmAP0lINqxbt96mQPgwPZN5w,30198
-emu_mps/mps_config.py,sha256=PoSKZxJMhG6zfzgEjj4tIvyiyYRQywxkRgidh8MRBsA,8222
+emu_mps/mps_backend_impl.py,sha256=JG4MlEsImc9izF-iwpgyw1t8q4M_20DxbbD4HDObSz0,30268
+emu_mps/mps_config.py,sha256=58Y9HEExeHm8p7Zm5CVwku7Y1pQmkaBV7M_hKv4PQcA,8629
 emu_mps/observables.py,sha256=7GQDH5kyaVNrwckk2f8ZJRV9Ca4jKhWWDsOCqYWsoEk,1349
+emu_mps/solver.py,sha256=M9xkHhlEouTBvoPw2UYVu6kij7CO4Z1FXw_SiGFtdgo,85
 emu_mps/solver_utils.py,sha256=VQ02_RxvPcjyXippuIY4Swpx4EdqtoJTt8Ie70GgdqU,8550
 emu_mps/utils.py,sha256=hgtaRUtBAzk76ab-S_wTVkvqfVOmaUks38zWame9GRQ,7132
 emu_mps/optimatrix/__init__.py,sha256=fBXQ7-rgDro4hcaBijCGhx3J69W96qcw5_3mWc7tND4,364
 emu_mps/optimatrix/optimiser.py,sha256=k9suYmKLKlaZ7ozFuIqvXHyCBoCtGgkX1mpen9GOdOo,6977
 emu_mps/optimatrix/permutations.py,sha256=9DDMZtrGGZ01b9F3GkzHR3paX4qNtZiPoI7Z_Kia3Lc,3727
-emu_mps-2.3.0.dist-info/METADATA,sha256=WLLpx31eshWCwR95aB_B4yoM8BRAKT81UR2mjVR3998,3587
-emu_mps-2.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-emu_mps-2.3.0.dist-info/RECORD,,
+emu_mps-2.4.0.dist-info/METADATA,sha256=6eUzR_h7HcAVtC9Sy3umvCIw-w_bICX98VD-uXjRnxM,3587
+emu_mps-2.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emu_mps-2.4.0.dist-info/RECORD,,