qadence 1.6.3__py3-none-any.whl → 1.7.1__py3-none-any.whl

qadence/ml_tools/printing.py

@@ -11,8 +11,11 @@ def print_metrics(loss: float | None, metrics: dict, iteration: int) -> None:
     print(msg)
 
 
-def write_tensorboard(writer: SummaryWriter, loss: float, metrics: dict, iteration: int) -> None:
-    writer.add_scalar("loss", loss, iteration)
+def write_tensorboard(
+    writer: SummaryWriter, loss: float = None, metrics: dict = {}, iteration: int = 0
+) -> None:
+    if loss is not None:
+        writer.add_scalar("loss", loss, iteration)
     for key, arg in metrics.items():
         writer.add_scalar(key, arg, iteration)
 

qadence/ml_tools/saveload.py

@@ -14,7 +14,7 @@ from torch.optim import Optimizer
 logger = getLogger(__name__)
 
 
-def get_latest_checkpoint_name(folder: Path, type: str) -> Path:
+def get_latest_checkpoint_name(folder: Path, type: str, device: str | torch.device = "cpu") -> Path:
     file = Path("")
     files = [f for f in os.listdir(folder) if f.endswith(".pt") and type in f]
     if len(files) == 0:
@@ -22,12 +22,18 @@ def get_latest_checkpoint_name(folder: Path, type: str) -> Path:
     if len(files) == 1:
         file = Path(files[0])
     else:
-        pattern = re.compile(".*_(\d+).pt$")
+        device = str(device).split(":")[0]
+        pattern = re.compile(f".*_(\d+)_device_{device}.pt$")
+        legacy_pattern = re.compile(".*_(\d+).pt$")
         max_index = -1
         for f in files:
+            legacy_match = legacy_pattern.search(f)
             match = pattern.search(f)
-            if match:
-                index_str = match.group(1).replace("_", "")
+            if match or legacy_match:
+                if legacy_match:
+                    logger.warn(f"Found checkpoint(s) in legacy format: {f}.")
+                    match = legacy_match
+                index_str = match.group(1).replace("_", "")  # type: ignore [union-attr]
                 index = int(index_str)
                 if index > max_index:
                     max_index = index
@@ -41,29 +47,38 @@ def load_checkpoint(
     optimizer: Optimizer | NGOptimizer,
     model_ckpt_name: str | Path = "",
     opt_ckpt_name: str | Path = "",
+    device: str | torch.device = "cpu",
 ) -> tuple[Module, Optimizer | NGOptimizer, int]:
     if isinstance(folder, str):
         folder = Path(folder)
     if not folder.exists():
         folder.mkdir(parents=True)
         return model, optimizer, 0
-    model, iter = load_model(folder, model, model_ckpt_name)
-    optimizer = load_optimizer(folder, optimizer, opt_ckpt_name)
+    model, iter = load_model(folder, model, model_ckpt_name, device)
+    optimizer = load_optimizer(folder, optimizer, opt_ckpt_name, device)
     return model, optimizer, iter
 
 
 def write_checkpoint(
-    folder: Path, model: Module, optimizer: Optimizer | NGOptimizer, iteration: int | str
+    folder: Path,
+    model: Module,
+    optimizer: Optimizer | NGOptimizer,
+    iteration: int | str,
 ) -> None:
-    from qadence.ml_tools.models import TransformedModule
-    from qadence.models import QNN, QuantumModel
+    from qadence import QuantumModel
+
+    from .models import QNN
 
     device = None
     try:
         # We extract the device from the pyqtorch native circuit
         device = str(model.device).split(":")[0]  # in case of using several CUDA devices
-    except Exception:
-        pass
+    except Exception as e:
+        msg = (
+            f"Unable to identify in which device the QuantumModel is stored due to {e}."
+            "Setting device to None"
+        )
+        logger.warning(msg)
 
     iteration_substring = f"{iteration:03n}" if isinstance(iteration, int) else iteration
     model_checkpoint_name: str = (
@@ -81,7 +96,7 @@ def write_checkpoint(
     try:
         d = (
             model._to_dict(save_params=True)
-            if isinstance(model, (QNN, QuantumModel)) or isinstance(model, TransformedModule)
+            if isinstance(model, (QNN, QuantumModel))
             else model.state_dict()
         )
         torch.save((iteration, d), folder / model_checkpoint_name)
@@ -101,21 +116,29 @@ def write_checkpoint(
 
 
 def load_model(
-    folder: Path, model: Module, model_ckpt_name: str | Path = "", *args: Any, **kwargs: Any
+    folder: Path,
+    model: Module,
+    model_ckpt_name: str | Path = "",
+    device: str | torch.device = "cpu",
+    *args: Any,
+    **kwargs: Any,
 ) -> tuple[Module, int]:
-    from qadence.ml_tools.models import TransformedModule
-    from qadence.models import QNN, QuantumModel
+    from qadence import QNN, QuantumModel
 
     iteration = 0
     if model_ckpt_name == "":
-        model_ckpt_name = get_latest_checkpoint_name(folder, "model")
+        model_ckpt_name = get_latest_checkpoint_name(folder, "model", device)
 
     try:
         iteration, model_dict = torch.load(folder / model_ckpt_name, *args, **kwargs)
-        if isinstance(model, (QuantumModel, QNN, TransformedModule)):
+        if isinstance(model, (QuantumModel, QNN)):
             model._from_dict(model_dict, as_torch=True)
         elif isinstance(model, Module):
             model.load_state_dict(model_dict, strict=True)
+        # Load model to a specific gpu device if specified
+        pattern = re.compile("cuda:\d+$")
+        if pattern.search(str(device)):
+            model.to(device)
 
     except Exception as e:
         msg = f"Unable to load state dict due to {e}.\
@@ -128,9 +151,10 @@ def load_optimizer(
     folder: Path,
     optimizer: Optimizer | NGOptimizer,
     opt_ckpt_name: str | Path = "",
+    device: str | torch.device = "cpu",
 ) -> Optimizer | NGOptimizer:
     if opt_ckpt_name == "":
-        opt_ckpt_name = get_latest_checkpoint_name(folder, "opt")
+        opt_ckpt_name = get_latest_checkpoint_name(folder, "opt", device)
     if os.path.isfile(folder / opt_ckpt_name):
         if isinstance(optimizer, Optimizer):
             (_, OptType, optimizer_state) = torch.load(folder / opt_ckpt_name)

qadence/ml_tools/train_grad.py

@@ -52,16 +52,12 @@ def train(
         device: String defining device to train on, pass 'cuda' for GPU.
         optimize_step: Customizable optimization callback which is called at every iteration.=
             The function must have the signature `optimize_step(model,
-            optimizer, loss_fn, xs, device="cpu")` (see the example below).
-            Apart from the default we already supply three other optimization
-            functions `optimize_step_evo`, `optimize_step_grad_norm`, and
-            `optimize_step_inv_dirichlet`. Learn more about how to use this in
-            the [Advancded features](../../tutorials/advanced) tutorial of the
-            documentation.
+            optimizer, loss_fn, xs, device="cpu")`.
         write_tensorboard: Customizable tensorboard logging callback which is
             called every `config.write_every` iterations. The function must have
             the signature `write_tensorboard(writer, loss, metrics, iteration)`
             (see the example below).
+        dtype: The dtype to use for the data.
 
     Example:
     ```python exec="on" source="material-block"
@@ -70,7 +66,7 @@ def train(
     from itertools import count
     from qadence import Parameter, QuantumCircuit, Z
     from qadence import hamiltonian_factory, hea, feature_map, chain
-    from qadence.models import QNN
+    from qadence import QNN
     from qadence.ml_tools import TrainConfig, train_with_grad, to_dataloader
 
     n_qubits = 2
@@ -114,8 +110,11 @@ def train(
     """
     # load available checkpoint
     init_iter = 0
+    log_device = "cpu" if device is None else device
     if config.folder:
-        model, optimizer, init_iter = load_checkpoint(config.folder, model, optimizer)
+        model, optimizer, init_iter = load_checkpoint(
+            config.folder, model, optimizer, device=log_device
+        )
         logger.debug(f"Loaded model and optimizer from {config.folder}")
 
     # Move model to device before optimizer is loaded
@@ -154,12 +153,32 @@ def train(
         data_dtype = float64 if dtype == complex128 else float32
 
     best_val_loss = math.inf
+
     with progress:
         dl_iter = iter(dataloader) if dataloader is not None else None
-        if perform_val:
-            dl_iter_val = iter(val_dataloader) if val_dataloader is not None else None
+
+        # Initial validation evaluation
+        try:
+            if perform_val:
+                dl_iter_val = iter(val_dataloader) if val_dataloader is not None else None
+                xs = next(dl_iter_val)
+                xs_to_device = data_to_device(xs, device=device, dtype=data_dtype)
+                best_val_loss, metrics = loss_fn(model, xs_to_device)
+
+                metrics["val_loss"] = best_val_loss
+                write_tensorboard(writer, None, metrics, init_iter)
+
+            if config.folder:
+                if config.checkpoint_best_only:
+                    write_checkpoint(config.folder, model, optimizer, iteration="best")
+                else:
+                    write_checkpoint(config.folder, model, optimizer, init_iter)
+
+        except KeyboardInterrupt:
+            logger.info("Terminating training gracefully after the current iteration.")
 
         # outer epoch loop
+        init_iter += 1
         for iteration in progress.track(range(init_iter, init_iter + config.max_iter)):
             try:
                 # in case there is not data needed by the model
@@ -193,10 +212,13 @@ def train(
                     )
 
                 if iteration % config.print_every == 0 and config.verbose:
-                    print_metrics(loss, metrics, iteration)
+                    # Note that the loss returned by optimize_step
+                    # is the value before doing the training step
+                    # which is printed accordingly by the previous iteration number
+                    print_metrics(loss, metrics, iteration - 1)
 
                 if iteration % config.write_every == 0:
-                    write_tensorboard(writer, loss, metrics, iteration)
+                    write_tensorboard(writer, loss, metrics, iteration - 1)
 
                 if perform_val:
                     if iteration % config.val_every == 0:
@@ -208,7 +230,7 @@ def train(
                             if config.folder and config.checkpoint_best_only:
                                 write_checkpoint(config.folder, model, optimizer, iteration="best")
                             metrics["val_loss"] = val_loss
-                            write_tensorboard(writer, math.nan, metrics, iteration)
+                            write_tensorboard(writer, None, metrics, iteration)
 
                 if config.folder:
                     if iteration % config.checkpoint_every == 0 and not config.checkpoint_best_only:
@@ -218,7 +240,19 @@ def train(
                 logger.info("Terminating training gracefully after the current iteration.")
                 break
 
-    # Final writing and checkpointing
+        # Handling printing the last training loss
+        # as optimize_step does not give the loss value at the last iteration
+        try:
+            xs = next(dl_iter) if dataloader is not None else None  # type: ignore[arg-type]
+            xs_to_device = data_to_device(xs, device=device, dtype=data_dtype)
+            loss, metrics = loss_fn(model, xs_to_device)
+            if iteration % config.print_every == 0 and config.verbose:
+                print_metrics(loss, metrics, iteration)
+
+        except KeyboardInterrupt:
+            logger.info("Terminating training gracefully after the current iteration.")
+
+    # Final printing, writing and checkpointing
     if config.folder and not config.checkpoint_best_only:
         write_checkpoint(config.folder, model, optimizer, iteration)
     write_tensorboard(writer, loss, metrics, iteration)

qadence/ml_tools/utils.py

@@ -5,16 +5,15 @@ from typing import Any
 
 from torch import Tensor, rand
 
+from qadence import QNN, QuantumModel
 from qadence.blocks import AbstractBlock, parameters
 from qadence.circuit import QuantumCircuit
-from qadence.ml_tools.models import TransformedModule
-from qadence.models import QNN, QuantumModel
 from qadence.parameters import Parameter, stringify
 
 
 @singledispatch
 def rand_featureparameters(
-    x: QuantumCircuit | AbstractBlock | QuantumModel | QNN | TransformedModule, *args: Any
+    x: QuantumCircuit | AbstractBlock | QuantumModel | QNN, *args: Any
 ) -> dict[str, Tensor]:
     raise NotImplementedError(f"Unable to generate random featureparameters for object {type(x)}.")
 
@@ -39,8 +38,3 @@ def _(qm: QuantumModel, batch_size: int = 1) -> dict[str, Tensor]:
 @rand_featureparameters.register
 def _(qnn: QNN, batch_size: int = 1) -> dict[str, Tensor]:
     return rand_featureparameters(qnn._circuit.abstract, batch_size)
-
-
-@rand_featureparameters.register
-def _(tm: TransformedModule, batch_size: int = 1) -> dict[str, Tensor]:
-    return rand_featureparameters(tm.model, batch_size)

qadence/{models/quantum_model.py → model.py}

@@ -36,7 +36,37 @@ class QuantumModel(nn.Module):
 
     This class should be used as base class for any new quantum model supported in the qadence
     framework for information on the implementation of custom models see
-    [here](/advanced_tutorials/custom-models.md).
+    [here](../tutorials/advanced_tutorials/custom-models.md).
+
+    Example:
+    ```python exec="on" source="material-block" result="json"
+    import torch
+    from qadence import QuantumModel, QuantumCircuit, RX, RY, Z, PI, chain, kron
+    from qadence import FeatureParameter, VariationalParameter
+
+    theta = VariationalParameter("theta")
+    phi = FeatureParameter("phi")
+
+    block = chain(
+        kron(RX(0, theta), RY(1, theta)),
+        kron(RX(0, phi), RY(1, phi)),
+    )
+
+    circuit = QuantumCircuit(2, block)
+
+    observable = Z(0) + Z(1)
+
+    model = QuantumModel(circuit, observable)
+    values = {"phi": torch.tensor([PI, PI/2]), "theta": torch.tensor([PI, PI/2])}
+
+    wf = model.run(values)
+    xs = model.sample(values, n_shots=100)
+    ex = model.expectation(values)
+    print(wf)
+    print(xs)
+    print(ex)
+    ```
+    ```
     """
 
     backend: Backend | DifferentiableBackend
@@ -120,6 +150,7 @@ class QuantumModel(nn.Module):
 
     @property
     def vparams(self) -> OrderedDict:
+        """Variational parameters."""
         return OrderedDict({k: v.data for k, v in self._params.items() if v.requires_grad})
 
     @property
@@ -145,9 +176,26 @@ class QuantumModel(nn.Module):
         return len(self.vals_vparams)
 
     def circuit(self, circuit: QuantumCircuit) -> ConvertedCircuit:
+        """Get backend-converted circuit.
+
+        Args:
+            circuit: QuantumCircuit instance.
+
+        Returns:
+            Backend circuit.
+        """
         return self.backend.circuit(circuit)
 
     def observable(self, observable: AbstractBlock, n_qubits: int) -> Any:
+        """Get backend observable.
+
+        Args:
+            observable: Observable block.
+            n_qubits: Number of qubits
+
+        Returns:
+            Backend observable.
+        """
         return self.backend.observable(observable, n_qubits)
 
     def reset_vparams(self, values: Sequence) -> None:
@@ -161,6 +209,11 @@ class QuantumModel(nn.Module):
             current_vparams[k].data = torch.tensor([values[i]])
 
     def forward(self, *args: Any, **kwargs: Any) -> Tensor:
+        """Calls run method with arguments.
+
+        Returns:
+            Tensor: A torch.Tensor representing output.
+        """
         return self.run(*args, **kwargs)
 
     def run(
@@ -169,9 +222,26 @@ class QuantumModel(nn.Module):
         state: Tensor | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
+        r"""Run model.
+
+        Given an input state $| \psi_0 \rangle$,
+        a set of variational parameters $\vec{\theta}$
+        and the unitary representation of the model $U(\vec{\theta})$
+        we return $U(\vec{\theta}) | \psi_0 \rangle$.
+
+        Arguments:
+            values: Values dict which contains values for the parameters.
+            state: Optional input state to apply model on.
+            endianness: Storage convention for binary information.
+
+        Returns:
+            A torch.Tensor representing output.
+        """
         if values is None:
             values = {}
+
         params = self.embedding_fn(self._params, values)
+
         return self.backend.run(self._circuit, params, state=state, endianness=endianness)
 
     def sample(
@@ -183,6 +253,19 @@ class QuantumModel(nn.Module):
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> list[Counter]:
+        """Obtain samples from model.
+
+        Arguments:
+            values: Values dict which contains values for the parameters.
+            n_shots: Observable part of the expectation.
+            state: Optional input state to apply model on.
+            noise: A noise model to use.
+            mitigation: A mitigation protocol to use.
+            endianness: Storage convention for binary information.
+
+        Returns:
+            A list of Counter instances with the sample results.
+        """
         params = self.embedding_fn(self._params, values)
         if noise is None:
             noise = self._noise
@@ -208,7 +291,27 @@ class QuantumModel(nn.Module):
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
-        """Compute expectation using the given backend.
+        r"""Compute expectation using the given backend.
+
+
+
+        Given an input state $|\psi_0 \rangle$,
+        a set of variational parameters $\vec{\theta}$
+        and the unitary representation of the model $U(\vec{\theta})$
+        we return $\langle \psi_0 | U(\vec{\theta}) | \psi_0 \rangle$.
+
+        Arguments:
+            values: Values dict which contains values for the parameters.
+            observable: Observable part of the expectation.
+            state: Optional input state.
+            measurement: Optional measurement protocol. If None, use
+                exact expectation value with a statevector simulator.
+            noise: A noise model to use.
+            mitigation: A mitigation protocol to use.
+            endianness: Storage convention for binary information.
+
+        Raises:
+            ValueError: when no observable is set.
 
         Returns:
             A torch.Tensor of shape n_batches x n_obs
@@ -243,9 +346,22 @@ class QuantumModel(nn.Module):
         )
 
     def overlap(self) -> Tensor:
+        """Overlap of model.
+
+        Raises:
+            NotImplementedError: The overlap method is not implemented for this model.
+        """
         raise NotImplementedError("The overlap method is not implemented for this model.")
 
     def _to_dict(self, save_params: bool = False) -> dict[str, Any]:
+        """Convert QuantumModel to a dictionary for serialization.
+
+        Arguments:
+            save_params: Optionally save parameters. Defaults to False.
+
+        Returns:
+            The dictionary
+        """
         d = dict()
         try:
             if isinstance(self._observable, list):
@@ -258,10 +374,10 @@ class QuantumModel(nn.Module):
                 "observable": abs_obs,
                 "backend": self._backend_name,
                 "diff_mode": self._diff_mode,
-                "measurement": self._measurement._to_dict()
-                if self._measurement is not None
-                else {},
-                "noise": self._noise._to_dict() if self._noise is not None else {},
+                "measurement": (
+                    self._measurement._to_dict() if self._measurement is not None else dict()
+                ),
+                "noise": self._noise._to_dict() if self._noise is not None else dict(),
                 "backend_configuration": asdict(self.backend.backend.config),  # type: ignore
             }
             param_dict_conv = {}
@@ -275,6 +391,15 @@ class QuantumModel(nn.Module):
 
     @classmethod
     def _from_dict(cls, d: dict, as_torch: bool = False) -> QuantumModel:
+        """Initialize instance of QuantumModel from dictionary.
+
+        Args:
+            d: Dictionary.
+            as_torch: Load parameters as torch tensors. Defaults to False.
+
+        Returns:
+            QuantumModel instance
+        """
         from qadence.serialization import deserialize
 
         qm: QuantumModel
@@ -310,6 +435,16 @@ class QuantumModel(nn.Module):
     def save(
         self, folder: str | Path, file_name: str = "quantum_model.pt", save_params: bool = True
     ) -> None:
+        """Save model.
+
+        Arguments:
+            folder: Folder where model is saved.
+            file_name: File name for saving model. Defaults to "quantum_model.pt".
+            save_params: Save parameters if True. Defaults to True.
+
+        Raises:
+            FileNotFoundError: If folder is not a directory.
+        """
         if not os.path.isdir(folder):
             raise FileNotFoundError
         try:
@@ -321,6 +456,16 @@ class QuantumModel(nn.Module):
     def load(
         cls, file_path: str | Path, as_torch: bool = False, map_location: str | torch.device = "cpu"
     ) -> QuantumModel:
+        """Load QuantumModel.
+
+        Arguments:
+            file_path: File path to load model from.
+            as_torch: Load parameters as torch tensor. Defaults to False.
+            map_location (str | torch.device, optional): Location for loading. Defaults to "cpu".
+
+        Returns:
+            QuantumModel from file_path.
+        """
         qm_pt = {}
         if isinstance(file_path, str):
             file_path = Path(file_path)
@@ -336,11 +481,23 @@ class QuantumModel(nn.Module):
         return cls._from_dict(qm_pt, as_torch)
 
     def assign_parameters(self, values: dict[str, Tensor]) -> Any:
-        """Return the final, assigned circuit that is used in e.g. `backend.run`."""
+        """Return the final, assigned circuit that is used in e.g. `backend.run`.
+
+        Arguments:
+            values: Values dict which contains values for the parameters.
+
+        Returns:
+            Final, assigned circuit that is used in e.g. `backend.run`
+        """
         params = self.embedding_fn(self._params, values)
         return self.backend.assign_parameters(self._circuit, params)
 
     def to(self, *args: Any, **kwargs: Any) -> QuantumModel:
+        """Conversion method for device or types.
+
+        Returns:
+            QuantumModel with conversions.
+        """
         from pyqtorch import QuantumCircuit as PyQCircuit
 
         try:
@@ -354,9 +511,11 @@ class QuantumModel(nn.Module):
                             obs.native = obs.native.to(*args, **kwargs)
                 self._params = self._params.to(
                     device=self._circuit.native.device,
-                    dtype=torch.float64
-                    if self._circuit.native.dtype == torch.cdouble
-                    else torch.float32,
+                    dtype=(
+                        torch.float64
+                        if self._circuit.native.dtype == torch.cdouble
+                        else torch.float32
+                    ),
                 )
                 logger.debug(f"Moved {self} to {args}, {kwargs}.")
             else:
@@ -367,8 +526,17 @@ class QuantumModel(nn.Module):
 
     @property
     def device(self) -> torch.device:
+        """Get device.
+
+        Returns:
+            torch.device
+        """
         return (
             self._circuit.native.device
             if self.backend.backend.name == "pyqtorch"  # type: ignore[union-attr]
             else torch.device("cpu")
         )
+
+
+# Modules to be automatically added to the qadence namespace
+__all__ = ["QuantumModel"]  # type: ignore

qadence/operations/ham_evo.py

@@ -43,6 +43,7 @@ class HamEvo(TimeEvolutionBlock):
         generator: Either a AbstractBlock, torch.Tensor or numpy.ndarray.
         parameter: A scalar or vector of numeric or torch.Tensor type.
         qubit_support: The qubits on which the evolution will be performed on.
+        duration: duration of evolution in case of time-dependent generator
 
     Examples:
 
@@ -66,6 +67,7 @@ class HamEvo(TimeEvolutionBlock):
         generator: Union[TGenerator, AbstractBlock],
         parameter: TParameter,
         qubit_support: tuple[int, ...] = None,
+        duration: float | None = None,
     ):
         gen_exprs = {}
         if qubit_support is None and not isinstance(generator, AbstractBlock):
@@ -75,6 +77,10 @@ class HamEvo(TimeEvolutionBlock):
             qubit_support = generator.qubit_support
             if generator.is_parametric:
                 gen_exprs = {str(e): e for e in expressions(generator)}
+
+                if generator.is_time_dependent and duration is None:
+                    raise ValueError("For time-dependent generators, a duration must be specified.")
+
         elif isinstance(generator, torch.Tensor):
             msg = "Please provide a square generator."
             if len(generator.shape) == 2:
@@ -99,6 +105,7 @@ class HamEvo(TimeEvolutionBlock):
         ps = {"parameter": Parameter(parameter), **gen_exprs}
         self.parameters = ParamMap(**ps)
         self.generator = generator
+        self.duration = duration
 
     @classmethod
     def num_parameters(cls) -> int:
@@ -197,3 +204,6 @@ class HamEvo(TimeEvolutionBlock):
             raise NotImplementedError(
                 "The current digital decomposition can be applied only to Pauli Hamiltonians."
             )
+
+    def __matmul__(self, other: AbstractBlock) -> AbstractBlock:
+        return super().__matmul__(other)

qadence/overlap.py

@@ -13,7 +13,7 @@ from qadence.blocks.utils import chain, kron, tag
 from qadence.circuit import QuantumCircuit
 from qadence.divergences import js_divergence
 from qadence.measurements import Measurements
-from qadence.models.quantum_model import QuantumModel
+from qadence.model import QuantumModel
 from qadence.operations import SWAP, H, I, S
 from qadence.transpile import reassign
 from qadence.types import BackendName, DiffMode, OverlapMethod