qadence 1.7.0__py3-none-any.whl → 1.7.1__py3-none-any.whl

qadence/ml_tools/constructors.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 import numpy as np
+from sympy import Basic
 
+from qadence.backend import BackendConfiguration
 from qadence.blocks import chain, kron
 from qadence.blocks.abstract import AbstractBlock
 from qadence.blocks.composite import ChainBlock, KronBlock
@@ -18,11 +20,16 @@ from qadence.constructors import (
 )
 from qadence.constructors.ansatze import hea_digital, hea_sDAQC
 from qadence.constructors.hamiltonians import ObservableConfig, TDetuning
-from qadence.operations import CNOT, RX, RY, H, I, N, Z
+from qadence.measurements import Measurements
+from qadence.noise import Noise
+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,
+    BackendName,
+    DiffMode,
+    InputDiffMode,
     Interaction,
     MultivariateStrategy,
     ObservableTransform,
@@ -721,54 +728,69 @@ def create_observable(
 
 def build_qnn_from_configs(
     register: int | Register,
-    fm_config: FeatureMapConfig,
-    ansatz_config: AnsatzConfig,
     observable_config: ObservableConfig | list[ObservableConfig],
+    fm_config: FeatureMapConfig = FeatureMapConfig(),
+    ansatz_config: AnsatzConfig = AnsatzConfig(),
+    backend: BackendName = BackendName.PYQTORCH,
+    diff_mode: DiffMode = DiffMode.AD,
+    measurement: Measurements | None = None,
+    noise: Noise | None = None,
+    configuration: BackendConfiguration | dict | None = None,
+    input_diff_mode: InputDiffMode | str = InputDiffMode.AD,
 ) -> QNN:
     """
     Build a QNN model.
 
     Args:
         register (int | Register): Number of qubits or a register object.
+        observable_config (ObservableConfig | list[ObservableConfig]): Observable configuration(s).
         fm_config (FeatureMapConfig): Feature map configuration.
         ansatz_config (AnsatzConfig): Ansatz configuration.
-        observable_config (ObservableConfig): Observable configuration.
+        backend (BackendName): The chosen quantum backend.
+        diff_mode (DiffMode): The differentiation engine to use. Choices are
+            'gpsr' or 'ad'.
+        measurement (Measurements): Optional measurement protocol. If None,
+            use exact expectation value with a statevector simulator.
+        noise (Noise): A noise model to use.
+        configuration (BackendConfiguration | dict): Optional backend configuration.
+        input_diff_mode (InputDiffMode): The differentiation mode for the input tensor.
 
     Returns:
         QNN: A QNN model.
     """
-    fm_blocks = create_fm_blocks(register=register, config=fm_config)
-    full_fm = _interleave_ansatz_in_fm(
-        register=register,
-        fm_blocks=fm_blocks,
-        ansatz_config=ansatz_config,
-    )
+    blocks: list[AbstractBlock] = []
+    inputs: list[Basic | str] | None = None
 
-    ansatz = create_ansatz(register=register, config=ansatz_config)
+    if fm_config.num_features > 0:
+        fm_blocks = create_fm_blocks(register=register, config=fm_config)
+        full_fm = _interleave_ansatz_in_fm(
+            register=register,
+            fm_blocks=fm_blocks,
+            ansatz_config=ansatz_config,
+        )
+        inputs = fm_config.inputs
+        blocks.append(full_fm)
 
-    # Add a block before the Featuer Map to move from 0 state to an
-    # equal superposition of all states. This needs to be here only for rydberg
-    # feature map and only as long as the feature map is not updated to include
-    # a driving term in the Hamiltonian.
+    blocks.append(create_ansatz(register=register, config=ansatz_config))
 
-    if ansatz_config.ansatz_strategy == "rydberg":
-        num_qubits = register if isinstance(register, int) else register.n_qubits
-        mixing_block = kron(*[H(i) for i in range(num_qubits)])
-        full_fm = chain(mixing_block, full_fm)
+    circ = QuantumCircuit(register, *blocks)
 
-    circ = QuantumCircuit(
-        register,
-        full_fm,
-        ansatz,
+    observable: AbstractBlock | list[AbstractBlock] = (
+        [observable_from_config(register=register, config=cfg) for cfg in observable_config]
+        if isinstance(observable_config, list)
+        else observable_from_config(register=register, config=observable_config)
     )
 
-    if isinstance(observable_config, list):
-        observable = [
-            observable_from_config(register=register, config=cfg) for cfg in observable_config
-        ]
-    else:
-        observable = observable_from_config(register=register, config=observable_config)  # type: ignore[assignment]
-
-    ufa = QNN(circ, observable, inputs=fm_config.inputs)
+    ufa = QNN(
+        circ,
+        observable,
+        inputs=inputs,
+        backend=backend,
+        diff_mode=diff_mode,
+        measurement=measurement,
+        noise=noise,
+        configuration=configuration,
+        input_diff_mode=input_diff_mode,
+    )
 
     return ufa

qadence/ml_tools/models.py

@@ -14,6 +14,7 @@ from qadence.blocks.abstract import AbstractBlock
 from qadence.circuit import QuantumCircuit
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
+from qadence.ml_tools.config import AnsatzConfig, FeatureMapConfig
 from qadence.model import QuantumModel
 from qadence.noise import Noise
 from qadence.register import Register
@@ -61,7 +62,7 @@ def derivative(ufa: torch.nn.Module, x: Tensor, derivative_indices: tuple[int, .
     obs_config = ObservableConfig(detuning=Z)
 
     f = QNN.from_configs(
-        register=3, fm_config=fm_config, ansatz_config=ansatz_config, obs_config=obs_config
+        register=3, obs_config=obs_config, fm_config=fm_config, ansatz_config=ansatz_config,
     )
     inputs = torch.rand(5,3,requires_grad=True)
 
@@ -211,21 +212,41 @@ class QNN(QuantumModel):
     def from_configs(
         cls,
         register: int | Register,
-        fm_config: Any,
-        ansatz_config: Any,
         obs_config: Any,
+        fm_config: Any = FeatureMapConfig(),
+        ansatz_config: Any = AnsatzConfig(),
+        backend: BackendName = BackendName.PYQTORCH,
+        diff_mode: DiffMode = DiffMode.AD,
+        measurement: Measurements | None = None,
+        noise: Noise | None = None,
+        configuration: BackendConfiguration | dict | None = None,
+        input_diff_mode: InputDiffMode | str = InputDiffMode.AD,
     ) -> QNN:
         """Create a QNN from a set of configurations.
 
         Args:
-            register: The number of qubits or a register object.
-            fm_config: The configuration for the feature map.
-            ansatz_config: The configuration for the ansatz.
-            obs_config: The configuration for the observable.
+            register (int | Register): The number of qubits or a register object.
+            obs_config (list[ObservableConfig] | ObservableConfig): The configuration(s)
+                for the observable(s).
+            fm_config (FeatureMapConfig): The configuration for the feature map.
+                Defaults to no feature encoding block.
+            ansatz_config (AnsatzConfig): The configuration for the ansatz.
+                Defaults to a single layer of hardware efficient ansatz.
+            backend (BackendName): The chosen quantum backend.
+            diff_mode (DiffMode): The differentiation engine to use. Choices are
+                'gpsr' or 'ad'.
+            measurement (Measurements): Optional measurement protocol. If None,
+                use exact expectation value with a statevector simulator.
+            noise (Noise): A noise model to use.
+            configuration (BackendConfiguration | dict): Optional backend configuration.
+            input_diff_mode (InputDiffMode): The differentiation mode for the input tensor.
 
         Returns:
             A QNN object.
 
+        Raises:
+            ValueError: If the observable configuration is not provided.
+
         Example:
         ```python exec="on" source="material-block" result="json"
         import torch
@@ -234,10 +255,17 @@ class QNN(QuantumModel):
         from qadence.constructors import ObservableConfig
         from qadence.operations import Z
         from qadence.types import (
-            AnsatzType, BasisSet, ReuploadScaling, ObservableTransform, Strategy
+            AnsatzType, BackendName, BasisSet, ObservableTransform, ReuploadScaling, Strategy
         )
 
         register = 4
+        obs_config = ObservableConfig(
+            detuning=Z,
+            scale=5.0,
+            shift=0.0,
+            transformation_type=ObservableTransform.SCALE,
+            trainable_transform=None,
+        )
         fm_config = FeatureMapConfig(
             num_features=2,
             inputs=["x", "y"],
@@ -253,15 +281,10 @@ class QNN(QuantumModel):
             ansatz_type=AnsatzType.HEA,
             ansatz_strategy=Strategy.DIGITAL,
         )
-        obs_config = ObservableConfig(
-            detuning=Z,
-            scale=5.0,
-            shift=0.0,
-            transformation_type=ObservableTransform.SCALE,
-            trainable_transform=None,
-        )
 
-        qnn = QNN.from_configs(register, fm_config, ansatz_config, obs_config)
+        qnn = QNN.from_configs(
+            register, obs_config, fm_config, ansatz_config, backend=BackendName.PYQTORCH
+        )
 
         x = torch.rand(2, 2)
         y = qnn(x)
@@ -270,7 +293,18 @@ class QNN(QuantumModel):
         """
         from .constructors import build_qnn_from_configs
 
-        return build_qnn_from_configs(register, fm_config, ansatz_config, obs_config)
+        return build_qnn_from_configs(
+            register=register,
+            observable_config=obs_config,
+            fm_config=fm_config,
+            ansatz_config=ansatz_config,
+            backend=backend,
+            diff_mode=diff_mode,
+            measurement=measurement,
+            noise=noise,
+            configuration=configuration,
+            input_diff_mode=input_diff_mode,
+        )
 
     def forward(
         self,

qadence/ml_tools/printing.py

@@ -11,8 +11,11 @@ def print_metrics(loss: float | None, metrics: dict, iteration: int) -> None:
     print(msg)
 
 
-def write_tensorboard(writer: SummaryWriter, loss: float, metrics: dict, iteration: int) -> None:
-    writer.add_scalar("loss", loss, iteration)
+def write_tensorboard(
+    writer: SummaryWriter, loss: float = None, metrics: dict = {}, iteration: int = 0
+) -> None:
+    if loss is not None:
+        writer.add_scalar("loss", loss, iteration)
     for key, arg in metrics.items():
         writer.add_scalar(key, arg, iteration)
 

qadence/ml_tools/saveload.py

@@ -14,7 +14,7 @@ from torch.optim import Optimizer
 logger = getLogger(__name__)
 
 
-def get_latest_checkpoint_name(folder: Path, type: str) -> Path:
+def get_latest_checkpoint_name(folder: Path, type: str, device: str | torch.device = "cpu") -> Path:
     file = Path("")
     files = [f for f in os.listdir(folder) if f.endswith(".pt") and type in f]
     if len(files) == 0:
@@ -22,12 +22,18 @@ def get_latest_checkpoint_name(folder: Path, type: str) -> Path:
     if len(files) == 1:
         file = Path(files[0])
     else:
-        pattern = re.compile(".*_(\d+).pt$")
+        device = str(device).split(":")[0]
+        pattern = re.compile(f".*_(\d+)_device_{device}.pt$")
+        legacy_pattern = re.compile(".*_(\d+).pt$")
         max_index = -1
         for f in files:
+            legacy_match = legacy_pattern.search(f)
             match = pattern.search(f)
-            if match:
-                index_str = match.group(1).replace("_", "")
+            if match or legacy_match:
+                if legacy_match:
+                    logger.warn(f"Found checkpoint(s) in legacy format: {f}.")
+                    match = legacy_match
+                index_str = match.group(1).replace("_", "")  # type: ignore [union-attr]
                 index = int(index_str)
                 if index > max_index:
                     max_index = index
@@ -41,19 +47,23 @@ def load_checkpoint(
     optimizer: Optimizer | NGOptimizer,
     model_ckpt_name: str | Path = "",
     opt_ckpt_name: str | Path = "",
+    device: str | torch.device = "cpu",
 ) -> tuple[Module, Optimizer | NGOptimizer, int]:
     if isinstance(folder, str):
         folder = Path(folder)
     if not folder.exists():
         folder.mkdir(parents=True)
         return model, optimizer, 0
-    model, iter = load_model(folder, model, model_ckpt_name)
-    optimizer = load_optimizer(folder, optimizer, opt_ckpt_name)
+    model, iter = load_model(folder, model, model_ckpt_name, device)
+    optimizer = load_optimizer(folder, optimizer, opt_ckpt_name, device)
     return model, optimizer, iter
 
 
 def write_checkpoint(
-    folder: Path, model: Module, optimizer: Optimizer | NGOptimizer, iteration: int | str
+    folder: Path,
+    model: Module,
+    optimizer: Optimizer | NGOptimizer,
+    iteration: int | str,
 ) -> None:
     from qadence import QuantumModel
 
@@ -63,8 +73,12 @@ def write_checkpoint(
     try:
         # We extract the device from the pyqtorch native circuit
         device = str(model.device).split(":")[0]  # in case of using several CUDA devices
-    except Exception:
-        pass
+    except Exception as e:
+        msg = (
+            f"Unable to identify in which device the QuantumModel is stored due to {e}."
+            "Setting device to None"
+        )
+        logger.warning(msg)
 
     iteration_substring = f"{iteration:03n}" if isinstance(iteration, int) else iteration
     model_checkpoint_name: str = (
@@ -102,13 +116,18 @@ def write_checkpoint(
 
 
 def load_model(
-    folder: Path, model: Module, model_ckpt_name: str | Path = "", *args: Any, **kwargs: Any
+    folder: Path,
+    model: Module,
+    model_ckpt_name: str | Path = "",
+    device: str | torch.device = "cpu",
+    *args: Any,
+    **kwargs: Any,
 ) -> tuple[Module, int]:
     from qadence import QNN, QuantumModel
 
     iteration = 0
     if model_ckpt_name == "":
-        model_ckpt_name = get_latest_checkpoint_name(folder, "model")
+        model_ckpt_name = get_latest_checkpoint_name(folder, "model", device)
 
     try:
         iteration, model_dict = torch.load(folder / model_ckpt_name, *args, **kwargs)
@@ -116,6 +135,10 @@ def load_model(
             model._from_dict(model_dict, as_torch=True)
         elif isinstance(model, Module):
             model.load_state_dict(model_dict, strict=True)
+        # Load model to a specific gpu device if specified
+        pattern = re.compile("cuda:\d+$")
+        if pattern.search(str(device)):
+            model.to(device)
 
     except Exception as e:
         msg = f"Unable to load state dict due to {e}.\
@@ -128,9 +151,10 @@ def load_optimizer(
     folder: Path,
     optimizer: Optimizer | NGOptimizer,
     opt_ckpt_name: str | Path = "",
+    device: str | torch.device = "cpu",
 ) -> Optimizer | NGOptimizer:
     if opt_ckpt_name == "":
-        opt_ckpt_name = get_latest_checkpoint_name(folder, "opt")
+        opt_ckpt_name = get_latest_checkpoint_name(folder, "opt", device)
     if os.path.isfile(folder / opt_ckpt_name):
         if isinstance(optimizer, Optimizer):
             (_, OptType, optimizer_state) = torch.load(folder / opt_ckpt_name)

qadence/ml_tools/train_grad.py

@@ -110,8 +110,11 @@ def train(
     """
     # load available checkpoint
     init_iter = 0
+    log_device = "cpu" if device is None else device
     if config.folder:
-        model, optimizer, init_iter = load_checkpoint(config.folder, model, optimizer)
+        model, optimizer, init_iter = load_checkpoint(
+            config.folder, model, optimizer, device=log_device
+        )
         logger.debug(f"Loaded model and optimizer from {config.folder}")
 
     # Move model to device before optimizer is loaded
@@ -150,12 +153,32 @@ def train(
         data_dtype = float64 if dtype == complex128 else float32
 
     best_val_loss = math.inf
+
     with progress:
         dl_iter = iter(dataloader) if dataloader is not None else None
-        if perform_val:
-            dl_iter_val = iter(val_dataloader) if val_dataloader is not None else None
+
+        # Initial validation evaluation
+        try:
+            if perform_val:
+                dl_iter_val = iter(val_dataloader) if val_dataloader is not None else None
+                xs = next(dl_iter_val)
+                xs_to_device = data_to_device(xs, device=device, dtype=data_dtype)
+                best_val_loss, metrics = loss_fn(model, xs_to_device)
+
+                metrics["val_loss"] = best_val_loss
+                write_tensorboard(writer, None, metrics, init_iter)
+
+            if config.folder:
+                if config.checkpoint_best_only:
+                    write_checkpoint(config.folder, model, optimizer, iteration="best")
+                else:
+                    write_checkpoint(config.folder, model, optimizer, init_iter)
+
+        except KeyboardInterrupt:
+            logger.info("Terminating training gracefully after the current iteration.")
 
         # outer epoch loop
+        init_iter += 1
         for iteration in progress.track(range(init_iter, init_iter + config.max_iter)):
             try:
                 # in case there is not data needed by the model
@@ -189,10 +212,13 @@ def train(
                     )
 
                 if iteration % config.print_every == 0 and config.verbose:
-                    print_metrics(loss, metrics, iteration)
+                    # Note that the loss returned by optimize_step
+                    # is the value before doing the training step
+                    # which is printed accordingly by the previous iteration number
+                    print_metrics(loss, metrics, iteration - 1)
 
                 if iteration % config.write_every == 0:
-                    write_tensorboard(writer, loss, metrics, iteration)
+                    write_tensorboard(writer, loss, metrics, iteration - 1)
 
                 if perform_val:
                     if iteration % config.val_every == 0:
@@ -204,7 +230,7 @@ def train(
                             if config.folder and config.checkpoint_best_only:
                                 write_checkpoint(config.folder, model, optimizer, iteration="best")
                             metrics["val_loss"] = val_loss
-                            write_tensorboard(writer, math.nan, metrics, iteration)
+                            write_tensorboard(writer, None, metrics, iteration)
 
                 if config.folder:
                     if iteration % config.checkpoint_every == 0 and not config.checkpoint_best_only:
@@ -214,7 +240,19 @@ def train(
                 logger.info("Terminating training gracefully after the current iteration.")
                 break
 
-    # Final writing and checkpointing
+        # Handling printing the last training loss
+        # as optimize_step does not give the loss value at the last iteration
+        try:
+            xs = next(dl_iter) if dataloader is not None else None  # type: ignore[arg-type]
+            xs_to_device = data_to_device(xs, device=device, dtype=data_dtype)
+            loss, metrics = loss_fn(model, xs_to_device)
+            if iteration % config.print_every == 0 and config.verbose:
+                print_metrics(loss, metrics, iteration)
+
+        except KeyboardInterrupt:
+            logger.info("Terminating training gracefully after the current iteration.")
+
+    # Final printing, writing and checkpointing
     if config.folder and not config.checkpoint_best_only:
         write_checkpoint(config.folder, model, optimizer, iteration)
     write_tensorboard(writer, loss, metrics, iteration)