qadence 1.11.0__py3-none-any.whl → 1.11.2__py3-none-any.whl

qadence/engines/torch/differentiable_backend.py

@@ -8,7 +8,7 @@ from qadence.engines.differentiable_backend import (
     DifferentiableBackend as DifferentiableBackendInterface,
 )
 from qadence.engines.torch.differentiable_expectation import DifferentiableExpectation
-from qadence.extensions import get_gpsr_fns
+from qadence.backends.parameter_shift_rules import general_psr
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.noise import NoiseHandler
@@ -75,11 +75,8 @@ class DifferentiableBackend(DifferentiableBackendInterface):
             expectation = differentiable_expectation.ad
         elif self.diff_mode == DiffMode.ADJOINT:
             expectation = differentiable_expectation.adjoint
-        else:
-            try:
-                fns = get_gpsr_fns()
-                psr_fn = fns[self.diff_mode]
-            except KeyError:
-                raise ValueError(f"{self.diff_mode} differentiation mode is not supported")
-            expectation = partial(differentiable_expectation.psr, psr_fn=psr_fn, **self.psr_args)
+        elif self.diff_mode == DiffMode.GPSR:
+            expectation = partial(
+                differentiable_expectation.psr, psr_fn=general_psr, **self.psr_args
+            )
         return expectation()

qadence/extensions.py

@@ -108,14 +108,6 @@ def _supported_gates(backend_name: str) -> list[TAbstractBlock]:
     return [getattr(operations, gate) for gate in _supported_gates]
 
 
-def _gpsr_fns() -> dict:
-    """Fallback function for native Qadence GPSR functions if extensions is not present."""
-    # avoid circular import
-    from qadence.backends.gpsr import general_psr
-
-    return {DiffMode.GPSR: general_psr}
-
-
 def _validate_diff_mode(backend: Backend, diff_mode: DiffMode) -> None:
     """Fallback function for native Qadence diff_mode if extensions is not present."""
     if not backend.supports_ad and diff_mode == DiffMode.AD:
@@ -152,11 +144,9 @@ try:
     available_backends = getattr(module, "available_backends")
     available_engines = getattr(module, "available_engines")
     supported_gates = getattr(module, "supported_gates")
-    get_gpsr_fns = getattr(module, "gpsr_fns")
     set_backend_config = getattr(module, "set_backend_config")
 except ModuleNotFoundError:
     available_backends = _available_backends
     available_engines = _available_engines
     supported_gates = _supported_gates
-    get_gpsr_fns = _gpsr_fns
     set_backend_config = _set_backend_config

qadence/ml_tools/callbacks/callbackmanager.py

@@ -115,8 +115,10 @@ class CallbacksManager:
             self.add_callback("PlotMetrics", "train_end")
         # only save the last checkpoint if not checkpoint_best_only
         if not self.config.checkpoint_best_only:
-            self.add_callback("SaveCheckpoint", "train_end")
-        self.add_callback("WriteMetrics", "train_end")
+            if self.config.checkpoint_every != 0:
+                self.add_callback("SaveCheckpoint", "train_end")
+        if self.config.write_every != 0:
+            self.add_callback("WriteMetrics", "train_end")
 
     def add_callback(
         self, callback: str | Callback, on: str | TrainingStage, called_every: int = 1

qadence/ml_tools/constructors.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Callable
+from typing import Any, Callable
 import numpy as np
 from sympy import Basic
 
@@ -8,7 +8,8 @@ from qadence.backend import BackendConfiguration
 from qadence.blocks import chain, kron
 from qadence.blocks.abstract import AbstractBlock
 from qadence.blocks.composite import ChainBlock, KronBlock
-from qadence.blocks.utils import add, tag
+from qadence.blocks.utils import tag, add
+from qadence.parameters import Parameter
 from qadence.circuit import QuantumCircuit
 from qadence.constructors import (
     analog_feature_map,
@@ -24,7 +25,7 @@ from qadence.constructors.hea import hea_digital, hea_sDAQC
 from qadence.constructors.iia import iia
 from qadence.measurements import Measurements
 from qadence.noise import NoiseHandler
-from qadence.operations import CNOT, RX, RY, I, N, Z
+from qadence.operations import CNOT, RX, RY, RZ, I
 from qadence.register import Register
 from qadence.types import (
     AnsatzType,
@@ -733,7 +734,12 @@ def create_observable(
         interaction=config.interaction,
         detuning=config.detuning,
     )
-    return add(shifting_term, detuning_hamiltonian)
+    obs: AbstractBlock = add(shifting_term, detuning_hamiltonian)
+
+    if isinstance(config.tag, str):
+        tag(obs, config.tag)
+
+    return obs
 
 
 def build_qnn_from_configs(
@@ -809,3 +815,262 @@ def build_qnn_from_configs(
     )
 
     return ufa
+
+
+def _create_feature_map_qcnn(
+    n_qubits: int,
+    n_inputs: int,
+    fm_type: str = "Fourier",
+    op: Any = RX,
+) -> Any:
+    """
+    Creates a feature map (FM) by dividing qubits among inputs and applying.
+
+    the specified feature map type.
+
+    Args:
+        n_qubits (int): Total number of qubits.
+        n_inputs (int): Number of inputs.
+        fm_type (str): Type of feature map to use (e.g., "Fourier").
+        op (Any): Quantum operation to use in the feature map (e.g., RX).
+
+    Returns:
+        Any: The combined feature map as a kronecker product
+        of individual feature maps.
+    """
+    fm_temp = []
+    qubits_per_input = n_qubits // n_inputs  # Base number of qubits per input
+    exceeding_qubits = n_qubits % n_inputs  # Number of exceeding qubits
+    start = 0  # Track current qubit index
+
+    for i in range(n_inputs):
+        # Assign base qubits + 1 extra if input has exceeding qubits
+        num_qubits = qubits_per_input + 1 if i < exceeding_qubits else qubits_per_input
+        end = start + num_qubits
+
+        # Create FM for this input
+        fm_temp.append(
+            feature_map(
+                n_qubits=num_qubits,
+                param=f"\u03C6_{i}",  # Use phi_i as the parameter
+                op=op,
+                fm_type=fm_type,
+                support=tuple(range(start, end)),
+            )
+        )
+        start = end  # Update starting index for next FM
+
+    # Combine all feature maps using kronecker product
+    return kron(*fm_temp)
+
+
+def _get_block_params(
+    params: dict,
+    layer: int,
+    rep: int,
+    pos: int,
+    is_corr: bool = False,
+) -> Any:
+    """
+    Retrieves the parameter for a given operation.
+
+    Args:
+        params (dict): Dictionary to store and retrieve parameters.
+        layer (int): The index of the current layer.
+        rep (int): The index of the current repetition in the layer.
+        pos (int): Position of the qubit in the layer.
+        is_corr (bool): If True, uses correlated parameters for corresponding gates in W^opt_ij.
+
+    Returns:
+        Parameter: the retrieved parameter.
+    """
+    if is_corr:
+        # Cycle pos from 0 to 8
+        key = f"θ_{layer}_{pos % 9}"
+    else:
+        key = f"θ_{layer}_{rep}_{pos}"
+
+    if key not in params:
+        params[key] = Parameter(key)
+    return params[key]
+
+
+def _create_single_W(
+    params: dict,
+    operations: list[Any],
+    entangler: Any,
+    layer: int,
+    rep: int,
+    max_reps: int,
+    control: int,
+    target: int,
+    spacing: int,
+    n_qubits: int,
+    is_corr: bool = False,
+) -> ChainBlock:
+    """Creates a single convolutional cell W_ij."""
+    pad = [
+        I(q)
+        for q in range(control - spacing, control + spacing + 1)
+        if q != control and q != target and 0 <= q < n_qubits
+    ]
+    gates = []
+
+    # Track per-layer repetition index for proper parameter continuity
+    key_param_counter = f"param_index_{layer}_{rep}"
+    if key_param_counter not in params:
+        params[key_param_counter] = 0  # Initialize if first time
+
+    param_index = params[key_param_counter]  # Load index
+    single_params = {}  # Store params for single RZ/RY gates
+
+    # Apply the first sequence of operations
+    for _, op in enumerate(operations):
+        param_control = _get_block_params(params, layer, rep, param_index, is_corr)
+        param_index += 1
+        param_target = _get_block_params(params, layer, rep, param_index, is_corr)
+        param_index += 1
+        gates.append(
+            kron(
+                *pad,
+                op(control, param_control),
+                op(target, param_target),
+            )
+        )
+    # entangling gate
+    gates.append(entangler(target, control))
+
+    # Apply RZ, RY and entangling gates for intermediate step
+    single_params["control_rz"] = _get_block_params(params, layer, rep, param_index, is_corr)
+    param_index += 1
+    single_params["target_ry"] = _get_block_params(params, layer, rep, param_index, is_corr)
+    param_index += 1
+    gates.append(
+        kron(
+            *pad,
+            RZ(control, single_params["control_rz"]),
+            RY(target, single_params["target_ry"]),
+        )
+    )
+    # entangling gate
+    gates.append(entangler(control, target))
+
+    intermediate_ry = _get_block_params(params, layer, rep, param_index, is_corr)
+    param_index += 1
+    gates.append(
+        kron(
+            *pad,
+            I(control),
+            RY(target, intermediate_ry),
+        )
+    )
+    # entangling gate
+    gates.append(entangler(target, control))
+
+    # Apply the first sequence of operations
+    for _, op in enumerate(operations):
+        param_control = _get_block_params(params, layer, rep, param_index, is_corr)
+        param_index += 1
+        param_target = _get_block_params(params, layer, rep, param_index, is_corr)
+        param_index += 1
+        gates.append(
+            kron(
+                *pad,
+                op(control, param_control),
+                op(target, param_target),
+            )
+        )
+    # Add final entangling gate (control -> target)
+    if rep == int(max_reps - 1):
+        gates.append(entangler(control, target))
+
+    # Update params dict with the last used index
+    params[key_param_counter] = param_index
+
+    return chain(*gates)
+
+
+def _create_conv_layer(
+    layer_index: int,
+    max_reps: int,
+    current_indices: list[int],
+    params: dict,
+    operations: list[Any],
+    entangler: Any,
+    n_qubits: int,
+    is_corr: bool,
+) -> tuple[AbstractBlock, list[int]]:
+    """
+    Function to create a single convolutional layer.
+
+    Args:
+        layer_index (int): The index of the current layer.
+        reps (int): Number of repetitions for this layer.
+        current_indices (List[int]): Indices of qubits for the current layer.
+        params (dict): Dictionary to store and retrieve parameters.
+        operations (List[Any]): List of quantum operations to apply in the gates.
+        entangler (Any): Entangling operation, such as CZ.
+        n_qubits (int): Total number of qubits.
+
+    Returns:
+        Tuple[AbstractBlock, List[int]]: A tuple containing the quantum block
+        for the layer and the target indices for the next layer.
+    """
+    current_layer = []
+    next_indices = []
+    spacing = layer_index
+
+    if layer_index in [0, 1]:  # Special behavior for first two layers
+        layer_reps = []
+        for rep in range(max_reps):
+            rep_kron = []
+            # Define qubit pairs based on odd/even repetition
+            if rep % 2 == 0:  # Even d: regular behavior
+                pairs = zip(current_indices[::2], current_indices[1::2])
+            else:  # Odd d: shift downward, leaving qubits 0 and 7 free
+                pairs = zip(current_indices[1:-1:2], current_indices[2:-1:2])
+
+            # Build the gate sequence for each pair
+            for control, target in pairs:
+                W_pairs = _create_single_W(
+                    params,
+                    operations,
+                    entangler,
+                    layer_index,
+                    rep,
+                    max_reps,
+                    control,
+                    target,
+                    spacing,
+                    n_qubits,
+                    is_corr,
+                )
+                tag(W_pairs, f"W{control,target}")
+                rep_kron.append(W_pairs)
+
+            layer_reps.append(kron(*rep_kron))
+
+        # Combine all repetitions using `chain`
+        current_layer.append(chain(*layer_reps))
+
+    else:  # Original behavior for other layers
+        for rep in range(max_reps):
+            for control, target in zip(current_indices[::2], current_indices[1::2]):
+                W_pairs = _create_single_W(
+                    params,
+                    operations,
+                    entangler,
+                    layer_index,
+                    rep,
+                    max_reps,
+                    control,
+                    target,
+                    spacing,
+                    n_qubits,
+                    is_corr,
+                )
+                current_layer.append(W_pairs)
+
+    # Update `next_indices` with the **targets** of the current layer
+    next_indices = current_indices[1::2]
+    return chain(*current_layer), next_indices

qadence/ml_tools/models.py

@@ -360,13 +360,8 @@ class QNN(QuantumModel):
             )
             observable_str = ""
             if self._observable:
-                observable_str = (
-                    "observable_config = [\n"
-                    + "\n".join(
-                        (block_to_mathematical_expression(obs.original) for obs in self._observable)
-                    )
-                    + "\n]"
-                )
+                observable_str = f"observable_config = {self.observables_to_expression()}"
+
             return f"{type(self).__name__}(\n{configs_str}\n{observable_str}\n)"
 
         return super().__str__()

qadence/ml_tools/qcnn_model.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+from qadence.blocks import chain
+from qadence.parameters import Parameter
+from qadence.blocks.utils import add, tag
+from qadence.operations import Z, RX, CZ
+from qadence.circuit import QuantumCircuit
+from qadence.types import BackendName, DiffMode
+from qadence.blocks.abstract import AbstractBlock
+
+from .models import QNN
+from qadence.ml_tools.constructors import _create_conv_layer, _create_feature_map_qcnn
+
+
+class QCNN(QNN):
+    def __init__(
+        self,
+        n_inputs: int,
+        n_qubits: int,
+        depth: list[int],
+        operations: list[Any],
+        entangler: Any = CZ,
+        random_meas: bool = True,
+        fm_basis: str = "Fourier",
+        fm_gate: Any = RX,
+        is_corr: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Creates a QCNN model.
+
+        Args:
+            n_inputs (int): Number of input features.
+            n_qubits (int): Total number of qubits.
+            depth (list[int]): List defining the depth (repetitions) of each layer.
+            operations (list[Any]): List of quantum operations to apply
+                in the gates (e.g., [RX, RZ]).
+            entangler (Any): Entangling operation, such as CZ.
+            random_meas (bool): If True, applies random weighted measurements.
+            fm_basis (str): feature map basis.
+            fm_gate (Any): gate employed in the fm, such as.
+            **kwargs (Any): Additional keyword arguments for the parent QNN class.
+        """
+        self.n_inputs = n_inputs
+        self.n_qubits = n_qubits
+        self.depth = depth
+        self.operations = operations
+        self.entangler = entangler
+        self.random_meas = random_meas
+        self.fm_basis = fm_basis
+        self.fm_gate = fm_gate
+        self.is_corr = is_corr
+
+        circuit = self.qcnn_circuit(
+            self.n_inputs,
+            self.n_qubits,
+            self.depth,
+            self.operations,
+            self.entangler,
+            self.fm_basis,
+            self.fm_gate,
+            self.is_corr,
+        )
+
+        obs = self.qcnn_deferred_obs(self.n_qubits, self.random_meas)
+
+        super().__init__(
+            circuit=circuit,
+            observable=obs,
+            backend=BackendName.PYQTORCH,
+            diff_mode=DiffMode.AD,
+            inputs=[f"\u03C6_{i}" for i in range(self.n_inputs)],
+            **kwargs,
+        )
+
+    def qcnn_circuit(
+        self,
+        n_inputs: int,
+        n_qubits: int,
+        depth: list[int],
+        operations: list[Any],
+        entangler: AbstractBlock,
+        fm_basis: str,
+        fm_gate: AbstractBlock,
+        is_corr: bool,
+    ) -> QuantumCircuit:
+        """Defines the QCNN circuit."""
+        # Validate qubit count
+        if n_qubits < 4:
+            raise ValueError(
+                f"Invalid number of qubits: {n_qubits}. " "At least 4 qubits are required."
+            )
+        if n_qubits % 2 != 0:
+            raise ValueError(
+                f"Invalid number of qubits: {n_qubits}. " "The number of qubits must be even."
+            )
+
+        # Validate that all values in `depth` are odd
+        even_depths = [d for d in depth if d % 2 == 0]
+        if even_depths:
+            raise ValueError(
+                f"Invalid depth values: '{even_depths[0]}'. " "All the conv layer 'r's must be odd."
+            )
+
+        # Feature map (FM)
+        fm = _create_feature_map_qcnn(n_qubits, n_inputs, fm_basis, fm_gate)
+        tag(fm, "FM")
+
+        # Conv and Pool layer definition
+        conv_layers = []
+        params: dict[str, Parameter] = {}
+
+        # Define layer all the 2-qubit patterns based on depth
+        layer_patterns = [(2**layer_index, depth[layer_index]) for layer_index in range(len(depth))]
+
+        # Initialize all qubits for the current layer
+        current_indices = list(range(n_qubits))
+
+        # Build the circuit layer by layer using the helper
+        for layer_index, (_, reps) in enumerate(layer_patterns):
+            if reps == 0:
+                raise ValueError(f"Invalid layer {layer_index}: zero repetitions (reps = {reps}).")
+            if len(current_indices) < 2:
+                raise RuntimeError(
+                    f"Layer {layer_index} requires at least 2 qubits, "
+                    f"but found {len(current_indices)}."
+                )
+
+            layer_block, next_indices = _create_conv_layer(
+                layer_index, reps, current_indices, params, operations, entangler, n_qubits, is_corr
+            )
+            tag(layer_block, f"C+P layer {layer_index}")
+            conv_layers.append(layer_block)
+
+            # Update `current_indices` for the next layer
+            current_indices = next_indices
+
+        # Combine all layers for the final ansatz
+        ansatz = chain(*conv_layers)
+
+        return QuantumCircuit(n_qubits, fm, ansatz)
+
+    def qcnn_deferred_obs(
+        self, n_qubits: int, random_meas: bool
+    ) -> AbstractBlock | list[AbstractBlock]:
+        """
+        Defines the measurements to be performedthe traced out.
+
+        and remaining qubits.
+        """
+        if random_meas:
+            w1 = [Parameter(f"w{i}") for i in range(n_qubits)]
+            obs = add(Z(i) * w for i, w in zip(range(n_qubits), w1))
+        else:
+            obs = add(Z(i) for i in range(n_qubits))
+
+        return obs

qadence/ml_tools/trainer.py

@@ -530,15 +530,7 @@ class Trainer(BaseTrainer):
             self.ng_params = ng_params
             loss_metrics = loss, metrics
 
-        # --------------------- FIX: Post-Optimization Loss --------------------- #
-        # Because the loss/metrics are returned before the optimization. To sync
-        # model state and current loss/metrics we calculate them again after optimization.
-        # This is not strictly necessary.
-        # TODO: Should be removed if loss can be logged at an unoptimized model state
-        with torch.no_grad():
-            post_update_loss_metrics = self.loss_fn(self.model, batch)
-
-        return self._modify_batch_end_loss_metrics(post_update_loss_metrics)
+        return self._modify_batch_end_loss_metrics(loss_metrics)
 
     @BaseTrainer.callback("val_epoch")
     def run_validation(self, dataloader: DataLoader) -> list[tuple[torch.Tensor, dict[str, Any]]]:

qadence/model.py

@@ -27,6 +27,7 @@ from qadence.mitigations import Mitigations
 from qadence.noise import NoiseHandler
 from qadence.parameters import Parameter
 from qadence.types import DiffMode, Endianness
+from qadence.utils import block_to_mathematical_expression
 
 logger = getLogger(__name__)
 
@@ -153,6 +154,11 @@ class QuantumModel(nn.Module):
         """Variational parameters."""
         return OrderedDict({k: v.data for k, v in self._params.items() if v.requires_grad})
 
+    @property
+    def params(self) -> OrderedDict:
+        """All parameters."""
+        return OrderedDict({k: v.data for k, v in self._params.items()})
+
     @property
     def vals_vparams(self) -> Tensor:
         """Dictionary with parameters which are actually updated during optimization."""
@@ -175,6 +181,19 @@ class QuantumModel(nn.Module):
         """The number of variational parameters."""
         return len(self.vals_vparams)
 
+    @property
+    def show_config(self) -> str:
+        """Attain current quantum model configurations."""
+        if isinstance(self.backend, DifferentiableBackend):
+            current_config = self.backend.backend.config
+        return BackendConfiguration.available_options(current_config)
+
+    def change_config(self, new_config: dict) -> None:
+        """Change configuration with the input."""
+        if isinstance(self.backend, DifferentiableBackend):
+            current_config = self.backend.backend.config
+        BackendConfiguration.change_config(current_config, new_config)
+
     def circuit(self, circuit: QuantumCircuit) -> ConvertedCircuit:
         """Get backend-converted circuit.
 
@@ -519,7 +538,7 @@ class QuantumModel(nn.Module):
             file_path = file_path / get_latest_checkpoint_name(file_path, "model")
 
         try:
-            qm_pt = torch.load(file_path, map_location=map_location)
+            qm_pt = torch.load(file_path, map_location=map_location, weights_only=False)
         except Exception as e:
             logger.error(f"Unable to load QuantumModel due to {e}")
         return cls._from_dict(qm_pt, as_torch)
@@ -568,6 +587,28 @@ class QuantumModel(nn.Module):
             logger.warning(f"Unable to move {self} to {args}, {kwargs} due to {e}.")
         return self
 
+    def observables_to_expression(self) -> dict[str, str] | str:
+        """
+            Convert the observable to a dictionary representation of Pauli terms.
+
+        If no observable is set, returns an empty dictionary. Each observable is
+        represented by its tag (if available) as the key and its mathematical expression
+        as the value.
+
+        Returns:
+            dict[str, str]: A dictionary where the keys are observable tags (or "Obs." if not provided)
+                            and the values are the corresponding mathematical expressions.
+        """
+        if self._observable is None:
+            return "No observable set."
+        else:
+            return {
+                obs.original.tag if obs.original.tag else "Obs.": block_to_mathematical_expression(
+                    obs.original
+                )
+                for obs in self._observable
+            }
+
     @property
     def device(self) -> torch.device:
         """Get device.

qadence/parameters.py

@@ -225,6 +225,8 @@ def sympy_to_numeric(expr: Basic) -> TNumber:
     if expr.as_real_imag()[1] != 0:
         return complex(expr)
     else:
+        if expr.is_Integer:
+            return int(expr)
         return float(expr)
 
 

qadence/register.py

@@ -329,8 +329,12 @@ class Register:
         return Register(g, spacing=None, device_specs=self.device_specs)
 
     def _to_dict(self) -> dict:
+        try:
+            graph_data = nx.node_link_data(self.graph, edges="links")
+        except TypeError:  # For Python 3.9 support
+            graph_data = nx.node_link_data(self.graph)
         return {
-            "graph": nx.node_link_data(self.graph),
+            "graph": graph_data,
             "device_specs": self.device_specs._to_dict(),
         }
 

qadence/serialization.py

@@ -226,7 +226,7 @@ def save_json(d: dict, file_path: str | Path) -> None:
 
 
 def load_pt(file_path: str | Path, map_location: str) -> Any:
-    return torch.load(file_path, map_location=map_location)
+    return torch.load(file_path, map_location=map_location, weights_only=False)
 
 
 def load_json(file_path: str | Path, map_location: str) -> Any: