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

qadence/ml_tools/tensors.py

@@ -39,3 +39,12 @@ def promote_to(x: Tensor, dtype: Any) -> float | np.ndarray | Tensor:
         return x
     else:
         raise ValueError(f"Don't know how to convert Tensor to {dtype}")
+
+
+def detach_loss_metrics(
+    loss_metrics: tuple[torch.Tensor, dict[str, Any]],
+) -> tuple[torch.Tensor, dict[str, Any]]:
+    """Detach the tensors contained in the loss and metrics history."""
+    loss, metrics = loss_metrics
+    detached_metrics = {k: v.detach() if isinstance(v, Tensor) else v for k, v in metrics.items()}
+    return loss.detach(), detached_metrics

qadence/ml_tools/trainer.py

@@ -15,6 +15,7 @@ from qadence.ml_tools.data import DictDataLoader, OptimizeResult, data_to_device
 from qadence.ml_tools.information import InformationContent
 from qadence.ml_tools.optimize_step import optimize_step, update_ng_parameters
 from qadence.ml_tools.stages import TrainingStage
+from qadence.ml_tools.tensors import detach_loss_metrics
 
 from .train_utils.base_trainer import BaseTrainer
 from .train_utils.accelerator import Accelerator
@@ -654,6 +655,8 @@ class Trainer(BaseTrainer):
         All metrics are prefixed with the proper state of the training process
          - "train_" or "val_" or "test_"
         A "{state}_loss" is added to metrics.
+        In order to save memory, all tensors are detached so that gradients
+        are not tracked.
 
         Args:
             loss_metrics (tuple[torch.Tensor, dict[str, Any]]): Original loss and metrics.
@@ -666,8 +669,8 @@ class Trainer(BaseTrainer):
                 loss, metrics = loss_metrics
                 updated_metrics = {f"{phase}_{key}": value for key, value in metrics.items()}
                 updated_metrics[f"{phase}_loss"] = loss
-                return loss, updated_metrics
-        return loss_metrics
+                loss_metrics = (loss, updated_metrics)
+        return detach_loss_metrics(loss_metrics)
 
     def _aggregate_result(
         self, result: tuple[torch.Tensor, dict[str, Any]]

qadence/states.py

@@ -41,6 +41,10 @@ __all__ = [
     "DensityMatrix",
     "density_mat",
     "overlap",
+    "partial_trace",
+    "von_neumann_entropy",
+    "purity",
+    "fidelity",
 ]
 
 ATOL_64 = 1e-14  # 64 bit precision
@@ -589,3 +593,128 @@ def equivalent_state(
     fidelity = overlap(s0, s1)
     expected = torch.ones_like(fidelity)
     return torch.allclose(fidelity, expected, rtol=rtol, atol=atol)  # type: ignore[no-any-return]
+
+
+# DensityMatrix utility functions
+
+
+def partial_trace(rho: DensityMatrix, keep_indices: list[int]) -> DensityMatrix:
+    """
+    Compute the partial trace of a density matrix for a system of several qubits with batch size.
+
+    This function also permutes qubits according to the order specified in keep_indices.
+
+    Args:
+        rho (DensityMatrix) : Density matrix of shape [batch_size, 2**n_qubits, 2**n_qubits].
+        keep_indices (list[int]): Index of the qubit subsystems to keep.
+
+    Returns:
+        DensityMatrix: Reduced density matrix after the partial trace,
+        of shape [batch_size, 2**n_keep, 2**n_keep].
+    """
+    from pyqtorch.utils import dm_partial_trace
+
+    return dm_partial_trace(rho.permute((1, 2, 0)), keep_indices).permute((2, 0, 1))
+
+
+def von_neumann_entropy(rho: DensityMatrix, eps: float = 1e-12) -> torch.Tensor:
+    """Calculate the von Neumann entropy of a quantum density matrix.
+
+    The von Neumann entropy is defined as S(ρ) = -Tr(ρ log₂ ρ) = -∑ᵢ λᵢ log₂ λᵢ,
+    where λᵢ are the eigenvalues of ρ.
+
+    Args:
+        rho: Density matrix of shape [batch_size, dim, dim]
+        eps: Small value to avoid log(0) for zero eigenvalues
+
+    Returns:
+        Von Neumann entropy for each density matrix in the batch, shape [batch_size]
+    """
+
+    # Compute eigenvalues for each density matrix in the batch
+    # For a Hermitian density matrix, eigenvalues should be real and non-negative
+    eigenvalues = torch.linalg.eigvalsh(rho)
+
+    # Normalize eigenvalues to ensure they sum to 1 (trace preservation)
+    # This step might be redundant but helps with numerical stability
+    eigenvalues = eigenvalues / torch.sum(eigenvalues, dim=1, keepdim=True)
+
+    # Filter out very small eigenvalues to avoid numerical issues
+    valid_eigenvalues = eigenvalues.clone()
+    valid_eigenvalues[valid_eigenvalues < eps] = eps
+
+    # Compute the entropy: -∑ᵢ λᵢ log₂ λᵢ
+    # Using natural logarithm and converting to base 2
+    log_base_conversion = torch.log(torch.tensor(2.0, device=rho.device))
+    entropy = -torch.sum(
+        valid_eigenvalues * torch.log(valid_eigenvalues) / log_base_conversion, dim=1
+    )
+
+    return entropy
+
+
+def purity(rho: DensityMatrix, order: int = 2) -> Tensor:
+    """Compute the n-th purity of a density matrix.
+
+    Args:
+        rho (DensityMatrix): Density matrix.
+        order (int, optional): Exponent n.
+
+    Returns:
+        Tensor: Tr[rho ** n]
+    """
+    # Compute eigenvalues
+    eigenvalues = torch.linalg.eigvalsh(rho)
+
+    # Compute the sum of eigenvalues raised to power n
+    return torch.sum(eigenvalues**order, dim=1)
+
+
+def fidelity(rho: DensityMatrix, sigma: DensityMatrix) -> Tensor:
+    """Calculate the fidelity between two quantum states represented by density matrices.
+
+    The fidelity is defined as F(ρ,σ) = Tr[√(√ρ σ √ρ)], or equivalently,
+    F(ρ,σ) = ||√ρ·√σ||₁ where ||·||₁ is the trace norm.
+
+    Args:
+        rho: First density matrix of shape [batch_size, dim, dim]
+        sigma: Second density matrix of shape [batch_size, dim, dim]
+
+    Returns:
+        Fidelity between each pair of density matrices in the batch, shape [batch_size]
+    """
+
+    # Compute square root of rho
+    rho_eigvals, rho_eigvecs = torch.linalg.eigh(rho)
+
+    # Ensure non-negative eigenvalues
+    rho_eigvals = torch.clamp(rho_eigvals, min=0)
+
+    # Compute square root using eigendecomposition
+    sqrt_eigvals = torch.sqrt(rho_eigvals)
+
+    # Compute √ρ for each batch element
+    sqrt_rho = torch.zeros_like(rho)
+    for i in range(rho.shape[0]):
+        sqrt_rho[i] = torch.mm(
+            rho_eigvecs[i],
+            torch.mm(
+                torch.diag(sqrt_eigvals[i]).to(dtype=rho_eigvecs.dtype), rho_eigvecs[i].t().conj()
+            ),
+        )
+
+    # Compute √ρ σ √ρ for each batch element
+    inner_product = torch.zeros_like(rho)
+    for i in range(rho.shape[0]):
+        inner_product[i] = torch.mm(sqrt_rho[i], torch.mm(sigma[i], sqrt_rho[i]))
+
+    # Compute eigenvalues of inner product
+    inner_eigvals = torch.linalg.eigvalsh(inner_product)
+
+    # Ensure non-negative eigenvalues
+    inner_eigvals = torch.clamp(inner_eigvals, min=0)
+
+    # Compute the fidelity as the sum of the square roots of eigenvalues
+    fidelity_values = torch.sum(torch.sqrt(inner_eigvals), dim=1)
+
+    return fidelity_values

{qadence-1.11.3.dist-info → qadence-1.11.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qadence
-Version: 1.11.3
+Version: 1.11.5
 Summary: Pasqal interface for circuit-based quantum computing SDKs
 Author-email: Aleksander Wennersteen <aleksander.wennersteen@pasqal.com>, Gert-Jan Both <gert-jan.both@pasqal.com>, Niklas Heim <niklas.heim@pasqal.com>, Mario Dagrada <mario.dagrada@pasqal.com>, Vincent Elfving <vincent.elfving@pasqal.com>, Dominik Seitz <dominik.seitz@pasqal.com>, Roland Guichard <roland.guichard@pasqal.com>, "Joao P. Moutinho" <joao.moutinho@pasqal.com>, Vytautas Abramavicius <vytautas.abramavicius@pasqal.com>, Gergana Velikova <gergana.velikova@pasqal.com>, Eduardo Maschio <eduardo.maschio@pasqal.com>, Smit Chaudhary <smit.chaudhary@pasqal.com>, Ignacio Fernández Graña <ignacio.fernandez-grana@pasqal.com>, Charles Moussa <charles.moussa@pasqal.com>, Giorgio Tosti Balducci <giorgio.tosti-balducci@pasqal.com>, Daniele Cucurachi <daniele.cucurachi@pasqal.com>, Pim Venderbosch <pim.venderbosch@pasqal.com>, Manu Lahariya <manu.lahariya@pasqal.com>, Sungwoo Ahn <sungwoo.ahn@pasqal.com>
 License: PASQAL OPEN-SOURCE SOFTWARE LICENSE (MIT-derived)
@@ -24,7 +24,7 @@ Requires-Dist: nevergrad
 Requires-Dist: numpy
 Requires-Dist: openfermion
 Requires-Dist: pasqal-cloud
-Requires-Dist: pyqtorch==1.7.6
+Requires-Dist: pyqtorch==1.7.7
 Requires-Dist: pyyaml
 Requires-Dist: rich
 Requires-Dist: scipy
@@ -44,7 +44,7 @@ Requires-Dist: nvidia-pyindex; extra == 'dlprof'
 Provides-Extra: horqrux
 Requires-Dist: einops; extra == 'horqrux'
 Requires-Dist: flax; extra == 'horqrux'
-Requires-Dist: horqrux==0.8.1; extra == 'horqrux'
+Requires-Dist: horqrux==0.9.0; extra == 'horqrux'
 Requires-Dist: jax; extra == 'horqrux'
 Requires-Dist: jaxopt; extra == 'horqrux'
 Requires-Dist: optax; extra == 'horqrux'
@@ -225,5 +225,15 @@ doi = {10.1109/MS.2025.3536607}
 }
 ```
 
+If you use the approximate Generalized parameter shift rule for your publication, we kindly ask you to cite:
+```latex
+@misc{2505.18090,
+Author = {Vytautas Abramavicius and Evan Philip and Kaonan Micadei and Charles Moussa and Mario Dagrada and Vincent E. Elfving and Panagiotis Barkoutsos and Roland Guichard},
+Title = {Evaluation of derivatives using approximate generalized parameter shift rule},
+Year = {2025},
+Eprint = {arXiv:2505.18090},
+}
+```
+
 ## License
 Qadence is a free and open source software package, released under the PASQAL OPEN-SOURCE SOFTWARE LICENSE (MIT-derived).

{qadence-1.11.3.dist-info → qadence-1.11.5.dist-info}/RECORD

@@ -18,7 +18,7 @@ qadence/qubit_support.py,sha256=Nkn1Q01RVViTcggSIom7EFKdWpAuM4TMGwBZ5feCUxA,2120
 qadence/register.py,sha256=MlI1-L1P_e7ugjelhH-1YdxrfPsgmLmX5m-dueawuWQ,13172
 qadence/serial_expr_grammar.peg,sha256=z5ytL7do9kO8o4h-V5GrsDuLdso0KsRcMuIYURFfmAY,328
 qadence/serialization.py,sha256=IB0OgYhtV3F9AmMMMbGcfgNil9vBzs92j5G3yj4KPhg,15616
-qadence/states.py,sha256=Aj28aNHGWkZrFw_mKpHrxCA1bDXlkFhw18D70tg0RF0,15953
+qadence/states.py,sha256=GosmwMN0oK9N3hNnSgfb8qDsOGVEHZqOSNERvGgscpw,20408
 qadence/types.py,sha256=HtOKf6xi-kTtncqctRWK0Wpxut7KEXHdqoQVqfx0vxo,11927
 qadence/utils.py,sha256=fChJDz7OelWNGLPjoBBcmleWGluWhR36Mf0LnqCx8FA,12376
 qadence/analog/__init__.py,sha256=BCyS9R4KUjzUXN0Ax3b0eMo8ZAuSkGoJQVtZ4_pvAFs,279
@@ -111,8 +111,8 @@ qadence/ml_tools/optimize_step.py,sha256=21m2Wxmxkj_kMHQnKygOWqFdcO-wi5CnMnIZTGE
 qadence/ml_tools/parameters.py,sha256=gew2Kq_5-RgRpaTvs8eauVhgo0sTqqDQEV6WHFEiLGM,1301
 qadence/ml_tools/qcnn_model.py,sha256=2ua_SuaXC9nJKtBnMCKkU3b_gMwRijIeBPj16YsfN2I,5369
 qadence/ml_tools/stages.py,sha256=qW2phMIvQBLM3tn2UoGN-ePiBnZoNq5k844eHVnnn8Y,1407
-qadence/ml_tools/tensors.py,sha256=xZ9ZRzOqEaMgLUGWQf1najDmL6iLuN1ojCGVFs1Tm94,1337
-qadence/ml_tools/trainer.py,sha256=rAm4hpXpPSt1pCWUtMenVBsRXiodwBpUpmWWMP1duDs,34914
+qadence/ml_tools/tensors.py,sha256=l1j33DRFj4i06Fq5DhwHUEQjbmAfEwDjzpMu-FQub1E,1708
+qadence/ml_tools/trainer.py,sha256=wUOTCu2FjzONFphRE0Bp0qNwcBdmcxzEQDPhJXGE254,35103
 qadence/ml_tools/utils.py,sha256=PW8FyoV0mG_DtN1U8njTDV5qxZ0EK4mnFwMAsLBArfk,1410
 qadence/ml_tools/callbacks/__init__.py,sha256=pTdfjulDGNKca--9BgrdmMyvJSah_0spp929Th6RzC8,913
 qadence/ml_tools/callbacks/callback.py,sha256=JVY1BtPItCx11oAa1-3wICZyDfDLFdc5pmjTbfASHqA,29929
@@ -146,7 +146,7 @@ qadence/transpile/flatten.py,sha256=k4HAfVzvDV40HyfaukiEHyJtAtvFRIcyDbAWiCL8tf0,
 qadence/transpile/invert.py,sha256=IeyidgBwECCKB0i7Ym0KkLyfcx42LyT2mbqkfbK1H8M,4843
 qadence/transpile/noise.py,sha256=LDcDJtQGkgUPkL2t69gg6AScTb-p3J3SxCDZbYOu1L8,1668
 qadence/transpile/transpile.py,sha256=xnzkHA6Qdb-Y5Fv9Latrolrpw44N6_OKc7_QGt70f0I,2713
-qadence-1.11.3.dist-info/METADATA,sha256=KnEzhBVUnxeEgo778rmcj9l5R_otThJo6lUH6sKyuMI,10752
-qadence-1.11.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-qadence-1.11.3.dist-info/licenses/LICENSE,sha256=IfA3wQpmMOjCnDZ0P8Od2Bxb39rND9s5zfGHp1vMTbQ,2359
-qadence-1.11.3.dist-info/RECORD,,
+qadence-1.11.5.dist-info/METADATA,sha256=fWleO5GRnMifx1ETu9KB86VBJgLfHksX66aD-R9DOQ0,11202
+qadence-1.11.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+qadence-1.11.5.dist-info/licenses/LICENSE,sha256=IfA3wQpmMOjCnDZ0P8Od2Bxb39rND9s5zfGHp1vMTbQ,2359
+qadence-1.11.5.dist-info/RECORD,,