qadence 1.11.1__py3-none-any.whl → 1.11.3__py3-none-any.whl

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,6 @@ def create_observable(
         interaction=config.interaction,
         detuning=config.detuning,
     )
-
     obs: AbstractBlock = add(shifting_term, detuning_hamiltonian)
 
     if isinstance(config.tag, str):
@@ -801,6 +801,7 @@ def build_qnn_from_configs(
         if isinstance(observable_config, list)
         else create_observable(register=register, config=observable_config)
     )
+
     ufa = QNN(
         circ,
         observable,
@@ -814,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/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/model.py

@@ -27,7 +27,12 @@ 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
+from qadence.utils import (
+    block_to_mathematical_expression,
+    check_param_dict_values,
+    merge_separate_params,
+)
+from qadence.transpile import set_as_variational, set_as_fixed
 
 logger = getLogger(__name__)
 
@@ -142,18 +147,31 @@ class QuantumModel(nn.Module):
         self._measurement = measurement
         self._noise = noise
         self._mitigation = mitigation
-        self._params = nn.ParameterDict(
-            {
-                str(key): nn.Parameter(val, requires_grad=val.requires_grad)
-                for key, val in conv.params.items()
-            }
-        )
+        if check_param_dict_values(conv.params):
+            self._params = nn.ParameterDict(
+                {
+                    str(key): nn.Parameter(val, requires_grad=val.requires_grad)  # type: ignore[union-attr]
+                    for key, val in conv.params.items()
+                }
+            )
+        else:
+            self._params = nn.ParameterDict(
+                {
+                    str(key): nn.Parameter(val, requires_grad=val.requires_grad)  # type: ignore[union-attr]
+                    for key, val in merge_separate_params(conv.params).items()
+                }
+            )
 
     @property
     def vparams(self) -> OrderedDict:
         """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."""
@@ -176,6 +194,93 @@ 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 set_as_variational(self, params: list[str] = list()) -> None:
+        """Set as variational the list of names in `params`.
+
+        Args:
+            params (list[str], optional): List of parameters to fix. Defaults to list().
+        """
+        circuit: QuantumCircuit = self._circuit.original
+        if self._observable is not None:
+            if isinstance(self._observable, list):
+                for obs in self._observable:
+                    set_as_variational(obs.original, params)
+                observable = [obs.original for obs in self._observable]
+            else:
+                set_as_variational(self._observable.original, params)
+                observable = [self._observable.original]
+        else:
+            observable = self._observable  # type: ignore[assignment]
+        set_as_variational(circuit.block, params)
+        conv = self.backend.convert(circuit, observable)
+        self.embedding_fn = conv.embedding_fn
+        self._circuit = conv.circuit
+        self._observable = conv.observable
+        if check_param_dict_values(conv.params):
+            self._params = nn.ParameterDict(
+                {
+                    str(key): nn.Parameter(val, requires_grad=val.requires_grad)  # type: ignore[union-attr]
+                    for key, val in conv.params.items()
+                }
+            )
+        else:
+            self._params = nn.ParameterDict(
+                {
+                    str(key): nn.Parameter(val, requires_grad=val.requires_grad)  # type: ignore[union-attr]
+                    for key, val in merge_separate_params(conv.params).items()
+                }
+            )
+
+    def set_as_fixed(self, params: list[str] = list()) -> None:
+        """Set as fixed the list of names in `params`.
+
+        Args:
+            params (list[str], optional): List of parameters to fix. Defaults to list().
+        """
+        circuit: QuantumCircuit = self._circuit.original
+        if self._observable is not None:
+            if isinstance(self._observable, list):
+                for obs in self._observable:
+                    set_as_fixed(obs.original, params)
+                observable = [obs.original for obs in self._observable]
+            else:
+                set_as_fixed(self._observable.original, params)
+                observable = [self._observable.original]
+        else:
+            observable = self._observable  # type: ignore[assignment]
+        set_as_fixed(circuit.block, params)
+        conv = self.backend.convert(circuit, observable)
+        self.embedding_fn = conv.embedding_fn
+        self._circuit = conv.circuit
+        self._observable = conv.observable
+        if check_param_dict_values(conv.params):
+            self._params = nn.ParameterDict(
+                {
+                    str(key): nn.Parameter(val, requires_grad=val.requires_grad)  # type: ignore[union-attr]
+                    for key, val in conv.params.items()
+                }
+            )
+        else:
+            self._params = nn.ParameterDict(
+                {
+                    str(key): nn.Parameter(val, requires_grad=val.requires_grad)  # type: ignore[union-attr]
+                    for key, val in merge_separate_params(conv.params).items()
+                }
+            )
+
     def circuit(self, circuit: QuantumCircuit) -> ConvertedCircuit:
         """Get backend-converted circuit.
 
@@ -520,7 +625,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)

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

qadence/transpile/__init__.py

@@ -5,7 +5,8 @@ from .block import (
     chain_single_qubit_ops,
     repeat,
     scale_primitive_blocks_only,
-    set_trainable,
+    set_as_variational,
+    set_as_fixed,
     validate,
 )
 from .circuit import fill_identities
@@ -15,4 +16,4 @@ from .invert import invert_endianness, reassign
 from .noise import set_noise
 from .transpile import blockfn_to_circfn, transpile
 
-__all__ = ["set_trainable", "invert_endianness", "set_noise"]
+__all__ = ["set_as_variational", "set_as_fixed", "invert_endianness", "set_noise"]