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

qadence/ml_tools/constructors.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from typing import Callable
 import numpy as np
 from sympy import Basic
 
@@ -24,7 +25,6 @@ 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.parameters import Parameter
 from qadence.register import Register
 from qadence.types import (
     AnsatzType,
@@ -33,10 +33,10 @@ from qadence.types import (
     InputDiffMode,
     Interaction,
     MultivariateStrategy,
-    ObservableTransform,
     ReuploadScaling,
     Strategy,
     TParameter,
+    TArray,
 )
 
 from .config import AnsatzConfig, FeatureMapConfig
@@ -706,35 +706,6 @@ def _interleave_ansatz_in_fm(
     return chain(*full_fm)
 
 
-def load_observable_transformations(config: ObservableConfig) -> tuple[Parameter, Parameter]:
-    """
-    Get the observable shifting and scaling factors.
-
-    Args:
-        config (ObservableConfig): Observable configuration.
-
-    Returns:
-        tuple[Parameter, Parameter]: The observable shifting and scaling factors.
-    """
-    shift = config.shift
-    scale = config.scale
-    if config.trainable_transform is not None:
-        shift = Parameter(name=shift, trainable=config.trainable_transform)
-        scale = Parameter(name=scale, trainable=config.trainable_transform)
-    else:
-        shift = Parameter(shift)
-        scale = Parameter(scale)
-    return scale, shift
-
-
-ObservableTransformMap = {
-    ObservableTransform.RANGE: lambda detuning, scale, shift: (
-        (shift, shift - scale) if detuning is N else (0.5 * (shift - scale), 0.5 * (scale + shift))
-    ),
-    ObservableTransform.SCALE: lambda _, scale, shift: (scale, shift),
-}
-
-
 def _global_identity(register: int | Register) -> KronBlock:
     """Create a global identity block."""
     return kron(
@@ -742,7 +713,7 @@ def _global_identity(register: int | Register) -> KronBlock:
     )
 
 
-def observable_from_config(
+def create_observable(
     register: int | Register,
     config: ObservableConfig,
 ) -> AbstractBlock:
@@ -756,35 +727,11 @@ def observable_from_config(
     Returns:
         AbstractBlock: The observable block.
     """
-    scale, shift = load_observable_transformations(config)
-    return create_observable(register, config.detuning, scale, shift, config.transformation_type)
-
-
-def create_observable(
-    register: int | Register,
-    detuning: TDetuning = Z,
-    scale: TParameter | None = None,
-    shift: TParameter | None = None,
-    transformation_type: ObservableTransform = ObservableTransform.NONE,  # type: ignore[assignment]
-) -> AbstractBlock:
-    """
-    Create an observable block.
-
-    Args:
-        register (int | Register): Number of qubits or a register object.
-        detuning: The type of detuning.
-        scale: A parameter for the scale.
-        shift: A parameter for the shift.
-
-    Returns:
-        AbstractBlock: The observable block.
-    """
-    if transformation_type == ObservableTransform.RANGE:
-        scale, shift = ObservableTransformMap[transformation_type](detuning, scale, shift)  # type: ignore[index]
-    shifting_term: AbstractBlock = shift * _global_identity(register)  # type: ignore[operator]
-    detuning_hamiltonian: AbstractBlock = scale * hamiltonian_factory(  # type: ignore[operator]
+    shifting_term: AbstractBlock = config.shift * _global_identity(register)  # type: ignore[operator]
+    detuning_hamiltonian: AbstractBlock = config.scale * hamiltonian_factory(  # type: ignore[operator]
         register=register,
-        detuning=detuning,
+        interaction=config.interaction,
+        detuning=config.detuning,
     )
     return add(shifting_term, detuning_hamiltonian)
 
@@ -844,9 +791,9 @@ def build_qnn_from_configs(
     circ = QuantumCircuit(register, *blocks)
 
     observable: AbstractBlock | list[AbstractBlock] = (
-        [observable_from_config(register=register, config=cfg) for cfg in observable_config]
+        [create_observable(register=register, config=cfg) for cfg in observable_config]
         if isinstance(observable_config, list)
-        else observable_from_config(register=register, config=observable_config)
+        else create_observable(register=register, config=observable_config)
     )
 
     ufa = QNN(

qadence/ml_tools/data.py

@@ -34,6 +34,10 @@ class OptimizeResult:
     """Metrics that can be saved during training."""
     extra: dict = field(default_factory=lambda: dict())
     """Extra dict for saving anything else to be used in callbacks."""
+    rank: int = 0
+    """Rank of the process for which this result was generated."""
+    device: str | None = "cpu"
+    """Device on which this result for calculated."""
 
 
 @dataclass

qadence/ml_tools/models.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from collections import Counter
+from collections import Counter, OrderedDict
 from logging import getLogger
 from typing import Any, Callable
 
@@ -19,6 +19,7 @@ from qadence.model import QuantumModel
 from qadence.noise import NoiseHandler
 from qadence.register import Register
 from qadence.types import BackendName, DiffMode, Endianness, InputDiffMode, ParamDictType
+from qadence.utils import block_to_mathematical_expression
 
 logger = getLogger(__name__)
 
@@ -208,6 +209,8 @@ class QNN(QuantumModel):
         else:
             raise ValueError(f"Unkown forward diff mode: {self.input_diff_mode}")
 
+        self._model_configs: dict = dict()
+
     @classmethod
     def from_configs(
         cls,
@@ -255,7 +258,7 @@ class QNN(QuantumModel):
         from qadence.constructors import ObservableConfig
         from qadence.operations import Z
         from qadence.types import (
-            AnsatzType, BackendName, BasisSet, ObservableTransform, ReuploadScaling, Strategy
+            AnsatzType, BackendName, BasisSet, ReuploadScaling, Strategy
         )
 
         register = 4
@@ -263,7 +266,6 @@ class QNN(QuantumModel):
             detuning=Z,
             scale=5.0,
             shift=0.0,
-            transformation_type=ObservableTransform.SCALE,
             trainable_transform=None,
         )
         fm_config = FeatureMapConfig(
@@ -293,7 +295,7 @@ class QNN(QuantumModel):
         """
         from .constructors import build_qnn_from_configs
 
-        return build_qnn_from_configs(
+        qnn = build_qnn_from_configs(
             register=register,
             observable_config=obs_config,
             fm_config=fm_config,
@@ -305,6 +307,69 @@ class QNN(QuantumModel):
             configuration=configuration,
             input_diff_mode=input_diff_mode,
         )
+        qnn._model_configs = {
+            "register": register,
+            "observable_config": obs_config,
+            "fm_config": fm_config,
+            "ansatz_config": ansatz_config,
+        }
+        return qnn
+
+    def __str__(self) -> str | Any:
+        """Return a string representation of a QNN.
+
+        When creating a QNN from a set of configurations,
+        we print the configurations used. Otherwise, we use the default printing.
+
+        Returns:
+            str | Any: A string representation of a QNN.
+
+        Example:
+        ```python exec="on" source="material-block" result="json"
+        from qadence import QNN
+        from qadence.constructors.hamiltonians import Interaction
+        from qadence.ml_tools.config import AnsatzConfig, FeatureMapConfig
+        from qadence.ml_tools.constructors import (
+            ObservableConfig,
+        )
+        from qadence.operations import Z
+        from qadence.types import BackendName
+
+        backend = BackendName.PYQTORCH
+        fm_config = FeatureMapConfig(num_features=1)
+        ansatz_config = AnsatzConfig()
+        observable_config = ObservableConfig(detuning=Z, interaction=Interaction.ZZ, scale=2)
+
+        qnn = QNN.from_configs(
+            register=2,
+            obs_config=observable_config,
+            fm_config=fm_config,
+            ansatz_config=ansatz_config,
+            backend=backend,
+        )
+        print(qnn) # markdown-exec: hide
+        ```
+        """
+        if bool(self._model_configs):
+            configs_str = "\n".join(
+                (
+                    k + " = " + str(self._model_configs[k])
+                    for k in sorted(self._model_configs.keys())
+                    if k != "observable_config"
+                )
+            )
+            observable_str = ""
+            if self._observable:
+                observable_str = (
+                    "observable_config = [\n"
+                    + "\n".join(
+                        (block_to_mathematical_expression(obs.original) for obs in self._observable)
+                    )
+                    + "\n]"
+                )
+            return f"{type(self).__name__}(\n{configs_str}\n{observable_str}\n)"
+
+        return super().__str__()
 
     def forward(
         self,

qadence/ml_tools/optimize_step.py

@@ -40,7 +40,6 @@ def optimize_step(
     """
 
     loss, metrics = None, {}
-    xs_to_device = data_to_device(xs, device=device, dtype=dtype)
 
     def closure() -> Any:
         # NOTE: We need the nonlocal as we can't return a metric dict and
@@ -48,7 +47,7 @@ def optimize_step(
         # reason the returned loss is always the first one...
         nonlocal metrics, loss
         optimizer.zero_grad()
-        loss, metrics = loss_fn(model, xs_to_device)
+        loss, metrics = loss_fn(model, xs)
         loss.backward(retain_graph=True)
         return loss.item()
 

qadence/ml_tools/train_utils/__init__.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from .base_trainer import BaseTrainer
 from .config_manager import ConfigManager
+from .accelerator import Accelerator
+from .distribution import Distributor
 
 # Modules to be automatically added to the qadence.ml_tools.loss namespace
-__all__ = ["BaseTrainer", "ConfigManager"]
+__all__ = ["BaseTrainer", "ConfigManager", "Accelerator", "Distributor"]