qadence 1.5.2__py3-none-any.whl → 1.6.0__py3-none-any.whl

qadence/__init__.py

@@ -1,10 +1,43 @@
 from __future__ import annotations
 
+import logging
+import logging.config
+import os
 from importlib import import_module
+from pathlib import Path
 
+import yaml
 from torch import cdouble, set_default_dtype
 from torch import float64 as torchfloat64
 
+DEFAULT_FLOAT_DTYPE = torchfloat64
+DEFAULT_COMPLEX_DTYPE = cdouble
+set_default_dtype(DEFAULT_FLOAT_DTYPE)
+
+logging_levels = {
+    "DEBUG": logging.DEBUG,
+    "INFO": logging.INFO,
+    "WARNING": logging.WARNING,
+    "ERROR": logging.ERROR,
+    "CRITICAL": logging.CRITICAL,
+}
+LOG_CONFIG_PATH = os.environ.get("QADENCE_LOG_CONFIG", f"{Path(__file__).parent}/log_config.yaml")
+LOG_BASE_LEVEL = os.environ.get("QADENCE_LOG_LEVEL", "").upper()
+
+with open(LOG_CONFIG_PATH, "r") as stream:
+    log_config = yaml.load(stream, Loader=yaml.FullLoader)
+logging.config.dictConfig(log_config)
+
+logger: logging.Logger = logging.getLogger(__name__)
+LOG_LEVEL = logging_levels.get(LOG_BASE_LEVEL, logging.INFO)  # type: ignore[arg-type]
+logger.setLevel(LOG_LEVEL)
+[
+    h.setLevel(LOG_LEVEL)  # type: ignore[func-returns-value]
+    for h in logger.handlers
+    if h.get_name() == "console"
+]
+logger.debug(f"Qadence logger successfully setup with log level {LOG_LEVEL}")
+
 from .analog import *
 from .backend import *
 from .backends import *
@@ -28,11 +61,6 @@ from .transpile import *
 from .types import *
 from .utils import *
 
-DEFAULT_FLOAT_DTYPE = torchfloat64
-DEFAULT_COMPLEX_DTYPE = cdouble
-set_default_dtype(DEFAULT_FLOAT_DTYPE)
-
-
 """Fetch the functions defined in the __all__ of each sub-module.
 
 Import to the qadence name space. Make sure each added submodule has the respective definition:

qadence/backend.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from collections import Counter
 from dataclasses import dataclass, fields
+from logging import getLogger
 from typing import Any, Callable, Iterator, Tuple
 
 from openfermion import QubitOperator
@@ -20,14 +21,13 @@ from qadence.blocks import (
 )
 from qadence.blocks.analog import ConstantAnalogRotation, InteractionBlock
 from qadence.circuit import QuantumCircuit
-from qadence.logger import get_logger
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.noise import Noise
 from qadence.parameters import stringify
 from qadence.types import ArrayLike, BackendName, DiffMode, Endianness, Engine, ParamDictType
 
-logger = get_logger(__file__)
+logger = getLogger(__name__)
 
 
 @dataclass

qadence/backends/adjoint.py

@@ -7,7 +7,7 @@ from pyqtorch.circuit import QuantumCircuit as PyQCircuit
 from pyqtorch.parametric import Parametric as PyQParametric
 from pyqtorch.primitive import Primitive as PyQPrimitive
 from pyqtorch.utils import inner_prod, param_dict
-from torch import Tensor, no_grad, tensor
+from torch import Tensor, no_grad, zeros
 from torch.autograd import Function
 from torch.nn import Module
 
@@ -125,7 +125,7 @@ class AdjointExpectation(Function):
                     ctx.projected_state, op.dagger(values), op.qubit_support
                 )
             elif isinstance(op, PyQCircuit):
-                grads = [g for sub_op in op.reverse() for g in _apply_adjoint(ctx, sub_op)]
+                grads = [g for sub_op in op.operations[::-1] for g in _apply_adjoint(ctx, sub_op)]
             elif isinstance(op, PyQPrimitive):
                 ctx.out_state = apply_operator(ctx.out_state, op.dagger(values), op.qubit_support)
                 if isinstance(op, PyQParametric) and values[op.param_name].requires_grad:
@@ -147,13 +147,17 @@ class AdjointExpectation(Function):
 
         grads = list(
             reversed(
-                [grad_out * g for op in ctx.circuit.reverse() for g in _apply_adjoint(ctx, op)]
+                [
+                    grad_out * g
+                    for op in ctx.circuit.operations[::-1]
+                    for g in _apply_adjoint(ctx, op)
+                ]
             )
         )
         num_grads = len(grads)
         num_params = len(ctx.saved_tensors)
         diff = num_params - num_grads
-        grads = grads + [tensor([0]) for _ in range(diff)]
+        grads = grads + [zeros(1, device=ctx.circuit.device) for _ in range(diff)]
         # Set observable grads to 0
         ctx.save_for_backward(*grads)
         return (None, None, None, None, *grads)

qadence/backends/braket/backend.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from collections import Counter
 from dataclasses import dataclass, field
+from logging import getLogger
 from typing import Any
 
 import numpy as np
@@ -15,7 +16,6 @@ from qadence.backend import ConvertedCircuit, ConvertedObservable
 from qadence.backends.utils import to_list_of_dicts
 from qadence.blocks import AbstractBlock, block_to_tensor
 from qadence.circuit import QuantumCircuit
-from qadence.logger import get_logger
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.mitigations.protocols import apply_mitigation
@@ -29,7 +29,7 @@ from qadence.utils import Endianness
 from .config import Configuration, default_passes
 from .convert_ops import convert_block
 
-logger = get_logger(__file__)
+logger = getLogger(__name__)
 
 
 def promote_parameters(parameters: dict[str, Tensor | float]) -> dict[str, float]:
@@ -56,6 +56,7 @@ class Backend(BackendInterface):
     native_endianness: Endianness = Endianness.BIG
     config: Configuration = field(default_factory=Configuration)
     engine: Engine = Engine.TORCH
+    logger.debug("Initialised")
 
     # braket specifics
     # TODO: include it in the configuration?

qadence/backends/braket/config.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
+from logging import getLogger
 from typing import Callable
 
 from qadence.backend import BackendConfiguration
-from qadence.logger import get_logger
 from qadence.transpile import digitalize, fill_identities
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 default_passes: list[Callable] = [fill_identities, digitalize]
 

qadence/backends/gpsr.py

@@ -20,7 +20,7 @@ def general_psr(spectrum: Tensor, n_eqs: int | None = None, shift_prefac: float
     sorted_unique_spectral_gaps = torch.tensor(list(sorted_unique_spectral_gaps))
 
     if n_eqs == 1:
-        return partial(single_gap_psr, spectral_gap=sorted_unique_spectral_gaps.item())
+        return single_gap_psr
     else:
         return partial(
             multi_gap_psr,

qadence/backends/horqrux/backend.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from collections import Counter
 from dataclasses import dataclass, field
+from logging import getLogger
 from typing import Any
 
 import jax
@@ -28,6 +29,8 @@ from qadence.utils import int_to_basis
 from .config import Configuration, default_passes
 from .convert_ops import HorqruxCircuit, convert_block, convert_observable
 
+logger = getLogger(__name__)
+
 
 @dataclass(frozen=True, eq=True)
 class Backend(BackendInterface):
@@ -43,6 +46,7 @@ class Backend(BackendInterface):
     native_endianness: Endianness = Endianness.BIG
     config: Configuration = field(default_factory=Configuration)
     engine: Engine = Engine.JAX
+    logger.debug("Initialised")
 
     def circuit(self, circuit: QuantumCircuit) -> ConvertedCircuit:
         passes = self.config.transpilation_passes

qadence/backends/horqrux/config.py

@@ -1,18 +1,18 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from logging import getLogger
 from typing import Callable
 
 from qadence.analog import add_background_hamiltonian
 from qadence.backend import BackendConfiguration
-from qadence.logger import get_logger
 from qadence.transpile import (
     blockfn_to_circfn,
     flatten,
     scale_primitive_blocks_only,
 )
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 def default_passes(config: Configuration) -> list[Callable]:

qadence/backends/pulser/backend.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 from collections import Counter
+from collections.abc import Iterable
 from dataclasses import dataclass, field
+from logging import getLogger
 from typing import Any
 
 import numpy as np
@@ -10,7 +12,7 @@ import torch
 from pulser import Register as PulserRegister
 from pulser import Sequence
 from pulser_simulation import SimConfig
-from pulser_simulation.simresults import SimulationResults
+from pulser_simulation.simresults import CoherentResults, SimulationResults
 from pulser_simulation.simulation import QutipEmulator
 from torch import Tensor
 
@@ -19,7 +21,6 @@ from qadence.backend import ConvertedCircuit, ConvertedObservable
 from qadence.backends.utils import to_list_of_dicts
 from qadence.blocks import AbstractBlock
 from qadence.circuit import QuantumCircuit
-from qadence.logger import get_logger
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.mitigations.protocols import apply_mitigation
@@ -37,7 +38,7 @@ from .convert_ops import convert_observable
 from .devices import IdealDevice, RealisticDevice
 from .pulses import add_addressing_pattern, add_pulses
 
-logger = get_logger(__file__)
+logger = getLogger(__name__)
 
 
 def _convert_init_state(state: Tensor) -> np.ndarray:
@@ -70,27 +71,6 @@ def make_sequence(circ: QuantumCircuit, config: Configuration) -> Sequence:
             f"Specified device of type {device_specs.type} is not supported by the pulser backend."
         )
 
-    ########
-    # FIXME: Remove the block below in V1.5.0
-    if config.spacing is not None:
-        logger.warning(
-            "Passing register spacing in the backend configuration is deprecated. "
-            "Please pass it in the register directly, as detailed in the register tutorial."
-        )
-        # Rescales the register coordinates, as was done with the previous "spacing" argument.
-        qadence_register = qadence_register.rescale_coords(scaling=config.spacing)
-    else:
-        if qadence_register.min_distance < 4.0:
-            # Throws warning for minimum distance below 4 because the typical values used
-            # for the standard pulser device parameters is ~7-8, so this likely means the user
-            # forgot to set the spacing at register creation.
-            logger.warning(
-                "Register with distance between atoms smaller than 4µm detected. "
-                "Pulser backend no longer has a default spacing of 8µm applied to the register. "
-                "Make sure you set the desired spacing as detailed in the register tutorial."
-            )
-    ########
-
     pulser_register = create_register(qadence_register)
 
     sequence = Sequence(pulser_register, device)
@@ -160,6 +140,7 @@ class Backend(BackendInterface):
     native_endianness: Endianness = Endianness.BIG
     config: Configuration = field(default_factory=Configuration)
     engine: Engine = Engine.TORCH
+    logger.debug("Initialised")
 
     def circuit(self, circ: QuantumCircuit) -> Sequence:
         passes = self.config.transpilation_passes
@@ -250,30 +231,49 @@ class Backend(BackendInterface):
         self,
         circuit: ConvertedCircuit,
         noise: Noise,
-        param_values: dict[str, Tensor] = {},
+        param_values: dict[str, Tensor] = dict(),
         state: Tensor | None = None,
         endianness: Endianness = Endianness.BIG,
-    ) -> list:
+    ) -> Tensor:
         vals = to_list_of_dicts(param_values)
         noise_probs = noise.options.get("noise_probs", None)
         if noise_probs is None:
-            KeyError(f"A range of noise probabilies should be passed. Got {noise_probs}.")
-
-        noisy_batched_dm = []
+            KeyError("A `noise probs` option should be passed to the <class QuantumModel>.")
+        if not (isinstance(noise_probs, float) or isinstance(noise_probs, Iterable)):
+            KeyError(
+                "A single or a range of noise probabilities"
+                " should be passed. Got {type(noise_probs)}."
+            )
 
-        # Pulser requires numpy types.
-        for noise_prob in noise_probs.numpy():
-            batched_dm = []
-            sim_config = {"noise": noise.protocol, noise.protocol + "_prob": noise_prob}
+        def run_noisy_sim(noise_prob: float) -> Tensor:
+            batched_dm = np.zeros(
+                (len(vals), 2**circuit.abstract.n_qubits, 2**circuit.abstract.n_qubits),
+                dtype=np.complex128,
+            )
+            sim_config = {"noise": noise.protocol, noise.protocol + "_rate": noise_prob}
             self.config.sim_config = SimConfig(**sim_config)
 
             for i, param_values_el in enumerate(vals):
                 sequence = self.assign_parameters(circuit, param_values_el)
-                sim_result = simulate_sequence(sequence, self.config, state)
-                batched_dm.append(sim_result)
-            noisy_batched_dm.append(batched_dm)
+                sim_result: CoherentResults = simulate_sequence(sequence, self.config, state)
+                final_state = sim_result.get_final_state().data.toarray()
+                batched_dm[i] = np.flip(final_state)
+            return torch.from_numpy(batched_dm)
 
-        return noisy_batched_dm
+        # Pulser requires numpy types.
+        if isinstance(noise_probs, Iterable):
+            noisy_batched_dms = []
+            for noise_prob in noise_probs:
+                noisy_batched_dms.append(run_noisy_sim(noise_prob))
+            noisy_batched_dms = torch.stack(noisy_batched_dms)
+        else:
+            noisy_batched_dms = run_noisy_sim(noise_probs)
+
+        if endianness != self.native_endianness:
+            from qadence.transpile import invert_endianness
+
+            noisy_batched_dms = invert_endianness(noisy_batched_dms)
+        return noisy_batched_dms
 
     def sample(
         self,
@@ -327,14 +327,40 @@ class Backend(BackendInterface):
     ) -> Tensor:
         observable = observable if isinstance(observable, list) else [observable]
         if mitigation is None:
-            state = self.run(circuit, param_values=param_values, state=state, endianness=endianness)
-            support = sorted(list(circuit.abstract.register.support))
-            res_list = [
-                obs.native(state, param_values, qubit_support=support) for obs in observable
-            ]
-            res = torch.transpose(torch.stack(res_list), 0, 1)
-            res = res if len(res.shape) > 0 else res.reshape(1)
-            return res.real
+            if noise is None:
+                state = self.run(
+                    circuit, param_values=param_values, state=state, endianness=endianness
+                )
+                support = sorted(list(circuit.abstract.register.support))
+                res_list = [
+                    obs.native(state, param_values, qubit_support=support) for obs in observable
+                ]
+                res = torch.transpose(torch.stack(res_list), 0, 1)
+                res = res if len(res.shape) > 0 else res.reshape(1)
+                return res.real
+            elif noise is not None:
+                dms = self.run_dm(
+                    circuit=circuit,
+                    noise=noise,
+                    param_values=param_values,
+                    state=state,
+                    endianness=endianness,
+                )
+                support = sorted(list(circuit.abstract.register.support))
+                # TODO: There should be a better check for batched density matrices.
+                if dms.size()[0] > 1:
+                    res_list = [
+                        [obs.native(dm, param_values, qubit_support=support) for dm in dms]
+                        for obs in observable
+                    ]
+                    res = torch.stack([torch.transpose(torch.stack(res), 0, 1) for res in res_list])
+                else:
+                    res_list = [
+                        obs.native(dms, param_values, qubit_support=support) for obs in observable
+                    ]
+                    res = torch.transpose(torch.stack(res_list), 0, 1)
+                res = res if len(res.shape) > 0 else res.reshape(1)
+                return res.real
         elif mitigation is not None:
             logger.warning(
                 "Mitigation protocol is deprecated. Use qadence-protocols instead.",

qadence/backends/pulser/config.py

@@ -8,7 +8,6 @@ from pasqal_cloud.device import EmulatorType
 from pulser_simulation.simconfig import SimConfig
 
 from qadence.backend import BackendConfiguration
-from qadence.types import DeviceType, Interaction
 
 DEFAULT_CLOUD_ENV = "prod"
 
@@ -25,14 +24,6 @@ class CloudConfiguration:
 
 @dataclass
 class Configuration(BackendConfiguration):
-    device_type: DeviceType = DeviceType.IDEALIZED
-    """The type of quantum Device to use in the simulations.
-
-    FIXME: This is deprecated, the device_type is now controlled in the
-    Qadence Device, as detailed in the documentation.
-    FIXME: Remove in v1.5.0
-    """
-
     sampling_rate: float = 1.0
     """Sampling rate to be used for local simulations.
 
@@ -40,14 +31,6 @@ class Configuration(BackendConfiguration):
     to avoid any interpolation in the solving procedure
     """
 
-    spacing: Optional[float] = None
-    """Spacing that multiplies the coordinates of the register.
-
-    FIXME: This is deprecated, spacing is now controlled in the Register,
-    as detailed in the register tutorial.
-    FIXME: Remove in v1.5.0
-    """
-
     method_solv: str = "adams"
     """Solver method to pass to the Qutip solver."""
 
@@ -83,17 +66,6 @@ class Configuration(BackendConfiguration):
     FIXME: To be deprecated.
     """
 
-    interaction: Interaction = Interaction.NN
-    """Type of interaction introduced in the Hamiltonian.
-
-    Currently, only
-    NN interaction is support. XY interaction is possible but not implemented
-
-    FIXME: This is deprecated, the interaction is now controlled in the
-    Qadence Device, as detailed in the documentation.
-    FIXME: Remove in v1.5.0
-    """
-
     # configuration for cloud simulations
     cloud_configuration: Optional[CloudConfiguration] = None
 

qadence/backends/pulser/pulses.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from functools import partial
+from logging import getLogger
 from typing import Union
 
 import numpy as np
@@ -20,7 +21,6 @@ from qadence.blocks.analog import (
     Interaction,
     InteractionBlock,
 )
-from qadence.logger import get_logger
 from qadence.operations import RX, RY, RZ, AnalogEntanglement
 from qadence.parameters import evaluate
 from qadence.types import PI, OpName
@@ -29,7 +29,7 @@ from .channels import GLOBAL_CHANNEL, LOCAL_CHANNEL
 from .config import Configuration
 from .waveforms import SquareWaveform
 
-logger = get_logger(__file__)
+logger = getLogger(__name__)
 
 TVar = Union[Variable, VariableItem]
 

qadence/backends/pyqtorch/backend.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from collections import Counter
 from dataclasses import dataclass, field
+from logging import getLogger
 from typing import Any
 
 import pyqtorch as pyq
@@ -18,7 +19,6 @@ from qadence.backends.utils import (
 )
 from qadence.blocks import AbstractBlock
 from qadence.circuit import QuantumCircuit
-from qadence.logger import get_logger
 from qadence.measurements import Measurements
 from qadence.mitigations.protocols import Mitigations, apply_mitigation
 from qadence.noise import Noise
@@ -36,7 +36,7 @@ from qadence.utils import infer_batchsize, int_to_basis
 from .config import Configuration, default_passes
 from .convert_ops import convert_block, convert_observable
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 @dataclass(frozen=True, eq=True)
@@ -53,6 +53,7 @@ class Backend(BackendInterface):
     native_endianness: Endianness = Endianness.BIG
     config: Configuration = field(default_factory=Configuration)
     engine: Engine = Engine.TORCH
+    logger.debug("Initialised")
 
     def circuit(self, circuit: QuantumCircuit) -> ConvertedCircuit:
         passes = self.config.transpilation_passes

qadence/backends/pyqtorch/config.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from logging import getLogger
 from typing import Callable
 
 from qadence.analog import add_background_hamiltonian
 from qadence.backend import BackendConfiguration
-from qadence.logger import get_logger
 from qadence.transpile import (
     blockfn_to_circfn,
     chain_single_qubit_ops,
@@ -14,7 +14,7 @@ from qadence.transpile import (
 )
 from qadence.types import AlgoHEvo
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 def default_passes(config: Configuration) -> list[Callable]:

qadence/blocks/block_to_tensor.py

@@ -62,7 +62,7 @@ def _fill_identities(
     full_qubit_support: tuple | list,
     diag_only: bool = False,
     endianness: Endianness = Endianness.BIG,
-    device: torch.device = torch.device("cpu"),
+    device: torch.device | None = None,
 ) -> torch.Tensor:
     """Returns a Kronecker product of a block matrix with identities.
 
@@ -265,7 +265,7 @@ def block_to_diagonal(
     qubit_support: tuple | list | None = None,
     use_full_support: bool = True,
     endianness: Endianness = Endianness.BIG,
-    device: torch.device = torch.device("cpu"),
+    device: torch.device = None,
 ) -> torch.Tensor:
     if block.is_parametric:
         raise TypeError("Sparse observables cant be parametric.")
@@ -310,7 +310,7 @@ def block_to_tensor(
     use_full_support: bool = True,
     tensor_type: TensorType = TensorType.DENSE,
     endianness: Endianness = Endianness.BIG,
-    device: torch.device = torch.device("cpu"),
+    device: torch.device = None,
 ) -> torch.Tensor:
     """
     Convert a block into a torch tensor.
@@ -369,7 +369,7 @@ def _block_to_tensor_embedded(
     qubit_support: tuple | None = None,
     use_full_support: bool = True,
     endianness: Endianness = Endianness.BIG,
-    device: torch.device = torch.device("cpu"),
+    device: torch.device = None,
 ) -> torch.Tensor:
     from qadence.blocks import MatrixBlock
     from qadence.operations import CSWAP, SWAP, HamEvo

qadence/blocks/matrix.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
 
 from functools import cached_property
+from logging import getLogger
 
 import numpy as np
 import torch
 from torch.linalg import eigvals
 
 from qadence.blocks import PrimitiveBlock
-from qadence.logger import get_logger
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 class MatrixBlock(PrimitiveBlock):

qadence/blocks/utils.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import typing
 from enum import Enum
 from itertools import chain as _flatten
+from logging import getLogger
 from typing import Generator, List, Type, TypeVar, Union, get_args
 
 from sympy import Array, Basic, Expr
@@ -29,10 +30,9 @@ from qadence.blocks.analog import (
 from qadence.blocks.analog import chain as analog_chain
 from qadence.blocks.analog import kron as analog_kron
 from qadence.exceptions import NotPauliBlockError
-from qadence.logger import get_logger
 from qadence.parameters import Parameter
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 TPrimitiveBlock = TypeVar("TPrimitiveBlock", bound=PrimitiveBlock)

qadence/circuit.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from itertools import chain as flatten
+from logging import getLogger
 from pathlib import Path
 from typing import Iterable
 
@@ -15,6 +16,8 @@ from qadence.register import Register
 # Modules to be automatically added to the qadence namespace
 __all__ = ["QuantumCircuit"]
 
+logger = getLogger(__name__)
+
 
 @dataclass(eq=False)  # Avoid unhashability errors due to mutable attributes.
 class QuantumCircuit:
@@ -167,7 +170,7 @@ class QuantumCircuit:
                 with open(path, "w") as file:
                     file.write(qc_dumped)
             except Exception as e:
-                print(f"Unable to write QuantumCircuit to disk due to {e}")
+                logger.error(f"Unable to write QuantumCircuit to disk due to {e}")
 
         return qc_dumped
 
@@ -199,6 +202,6 @@ class QuantumCircuit:
                 loaded_dict = json.load(file)
 
         except Exception as e:
-            print(f"Unable to load QuantumCircuit due to {e}")
+            logger.error(f"Unable to load QuantumCircuit due to {e}")
 
         return QuantumCircuit._from_dict(loaded_dict)