qadence 1.5.2__py3-none-any.whl → 1.6.1__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
@@ -191,28 +195,6 @@ class Backend(BackendInterface):
         if n_shots < 1:
             raise ValueError("You can only call sample with n_shots>0.")
 
-        def _sample(
-            _probs: ArrayLike, n_shots: int, endianness: Endianness, n_qubits: int
-        ) -> Counter:
-            _logits = jax.vmap(lambda _p: jnp.log(_p / (1 - _p)))(_probs)
-
-            def _smple(accumulator: ArrayLike, i: int) -> tuple[ArrayLike, None]:
-                accumulator = accumulator.at[i].set(
-                    jax.random.categorical(jax.random.PRNGKey(i), _logits)
-                )
-                return accumulator, None
-
-            samples = jax.lax.scan(
-                _smple, jnp.empty_like(jnp.arange(n_shots)), jnp.arange(n_shots)
-            )[0]
-            return Counter(
-                {
-                    int_to_basis(k=k, n_qubits=n_qubits, endianness=endianness): count.item()
-                    for k, count in enumerate(jnp.bincount(samples))
-                    if count > 0
-                }
-            )
-
         wf = self.run(
             circuit=circuit,
             param_values=param_values,
@@ -221,16 +203,26 @@ class Backend(BackendInterface):
             unhorqify_state=False,
         )
         probs = jnp.abs(jnp.float_power(wf, 2.0)).ravel()
-        samples = [
-            _sample(
-                _probs=probs,
-                n_shots=n_shots,
-                endianness=endianness,
-                n_qubits=circuit.abstract.n_qubits,
-            ),
-        ]
+        key = jax.random.PRNGKey(0)
+        # JAX handles pseudo random number generation by tracking an explicit state via a random key
+        # For more details, see https://jax.readthedocs.io/en/latest/random-numbers.html
+        samples = jax.vmap(
+            lambda subkey: jax.random.choice(
+                key=subkey, a=jnp.arange(0, 2**circuit.abstract.n_qubits), p=probs
+            )
+        )(jax.random.split(key, n_shots))
 
-        return samples
+        return [
+            Counter(
+                {
+                    int_to_basis(
+                        k=k, n_qubits=circuit.abstract.n_qubits, endianness=endianness
+                    ): count.item()
+                    for k, count in enumerate(jnp.bincount(samples))
+                    if count > 0
+                }
+            )
+        ]
 
     def assign_parameters(self, circuit: ConvertedCircuit, param_values: ParamDictType) -> Any:
         raise NotImplementedError

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,52 @@ 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_sim = run_noisy_sim(noise_prob)
+                if not param_values:
+                    noisy_sim = noisy_sim[0]
+                noisy_batched_dms.append(noisy_sim)
+            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 +330,48 @@ 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.squeeze(), param_values, qubit_support=support, noise=noise
+                            )
+                            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/convert_ops.py

@@ -5,6 +5,7 @@ from typing import Sequence
 import torch
 from torch.nn import Module
 
+from qadence import Noise
 from qadence.blocks import (
     AbstractBlock,
 )
@@ -26,17 +27,29 @@ class PulserObservable(Module):
     def __init__(self, block: AbstractBlock, n_qubits: int | None):
         super().__init__()
         self.block = block
-        self.n_qubits = n_qubits
+        self.n_qubits = n_qubits if n_qubits else max(block.qubit_support) + 1
+
+        if not self.block.is_parametric:
+            block_mat = block_to_tensor(
+                self.block, {}, qubit_support=tuple(i for i in range(self.n_qubits))
+            ).squeeze(0)
+            self.register_buffer("block_mat", block_mat)
 
     def forward(
         self,
         state: torch.Tensor,
-        values: dict[str, torch.Tensor] | list = {},
+        values: dict[str, torch.Tensor] = dict(),
         qubit_support: tuple | None = None,
+        noise: Noise | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> torch.Tensor:
-        # FIXME: cache this, it is very inefficient for non-parametric observables
-        block_mat = block_to_tensor(
-            self.block, values, qubit_support=qubit_support, endianness=endianness  # type: ignore [arg-type]  # noqa
-        ).squeeze(0)
-        return torch.sum(torch.matmul(state, block_mat) * state.conj(), dim=1)
+        if not self.block.is_parametric:
+            block_mat = self.block_mat
+        else:
+            block_mat = block_to_tensor(
+                self.block, values, qubit_support=qubit_support, endianness=endianness  # type: ignore [arg-type]  # noqa
+            ).squeeze(0)
+        if noise is None:  # Compute expectations for state vector.
+            return torch.sum(torch.matmul(state, block_mat) * state.conj(), dim=1)
+        else:  # Compute expectations for density matrices.
+            return torch.trace(torch.matmul(block_mat, state))

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]: