Fix executing time-dependent blocks with convenience functions

qadence/backends/pyqtorch/convert_ops.py

@@ -26,7 +26,6 @@
 from torch import dtype as torch_dtype
 from torch.nn import Module
 
-from qadence import stringify
 from qadence.backends.utils import (
     finitediff,
     pyqify,
@@ -48,7 +47,7 @@
     block_to_tensor,
 )
 from qadence.blocks.primitive import ProjectorBlock
-from qadence.blocks.utils import parameters, uuid_to_expression
+from qadence.blocks.utils import parameters
 from qadence.operations import (
     U,
     multi_qubit_gateset,
@@ -316,13 +315,6 @@ def forward(
         state: Tensor,
         values: dict[str, Tensor],
     ) -> Tensor:
-        # convert values dict keys from uuids to expression strings if needed
-        uuid_dict = uuid_to_expression(self.block.generator)  # type: ignore [arg-type]
-        if list(uuid_dict.keys())[0] in values:
-            orig_param_values = values["orig_param_values"]
-            values = {stringify(v): values[k] for k, v in uuid_dict.items()}
-            values["orig_param_values"] = orig_param_values
-
         if getattr(self.block.generator, "is_time_dependent", False):  # type: ignore [union-attr]
 
             def Ht(t: Tensor | float) -> Tensor:

qadence/blocks/embedding.py

@@ -140,7 +140,6 @@ def embedding_fn(params: ParamDictType, inputs: ParamDictType) -> ParamDictType:
             gate_lvl_params: ParamDictType = {}
             for uuid, e in uuid_to_expr.items():
                 gate_lvl_params[uuid] = embedded_params[e]
-            gate_lvl_params.update({"orig_param_values": inputs})
             return gate_lvl_params
         else:
             out = {stringify(k): v for k, v in embedded_params.items()}

qadence/execution.py

@@ -71,7 +71,10 @@ def _(
     endianness: Endianness = Endianness.BIG,
     configuration: Union[BackendConfiguration, dict, None] = None,
 ) -> Tensor:
-    bknd = backend_factory(backend, configuration=configuration)
+    diff_mode = None
+    if backend == BackendName.PYQTORCH:
+        diff_mode = DiffMode.AD
+    bknd = backend_factory(backend, diff_mode=diff_mode, configuration=configuration)
     conv = bknd.convert(circuit)
     with no_grad():
         return bknd.run(
@@ -147,7 +150,10 @@ def _(
     endianness: Endianness = Endianness.BIG,
     configuration: Union[BackendConfiguration, dict, None] = None,
 ) -> list[Counter]:
-    bknd = backend_factory(backend, configuration=configuration)
+    diff_mode = None
+    if backend == BackendName.PYQTORCH:
+        diff_mode = DiffMode.AD
+    bknd = backend_factory(backend, diff_mode=diff_mode, configuration=configuration)
     conv = bknd.convert(circuit)
     return bknd.sample(
         circuit=conv.circuit,
@@ -242,7 +248,9 @@ def _(
     configuration: Union[BackendConfiguration, dict, None] = None,
 ) -> Tensor:
     observable = observable if isinstance(observable, list) else [observable]
-    bknd = backend_factory(backend, configuration=configuration, diff_mode=diff_mode)
+    if backend == BackendName.PYQTORCH:
+        diff_mode = DiffMode.AD
+    bknd = backend_factory(backend, diff_mode=diff_mode, configuration=configuration)
     conv = bknd.convert(circuit, observable)
 
     def _expectation() -> Tensor:

tests/backends/pyq/test_time_dependent_generator.py

@@ -9,13 +9,7 @@
 from metrics import MIDDLE_ACCEPTANCE
 from pyqtorch.utils import SolverType
 
-from qadence import (
-    AbstractBlock,
-    HamEvo,
-    QuantumCircuit,
-    QuantumModel,
-    Register,
-)
+from qadence import AbstractBlock, HamEvo, QuantumCircuit, QuantumModel, Register, run
 
 
 @pytest.mark.parametrize("ode_solver", [SolverType.DP5_SE, SolverType.KRYLOV_SE])
@@ -29,19 +23,26 @@ def test_time_dependent_generator(
     duration = 1.0
     n_steps = 500
 
-    # simulate with qadence HamEvo
+    # simulate with qadence HamEvo usin QuantumModel
     hamevo = HamEvo(qadence_generator, 0.0, duration=duration)
     reg = Register(2)
     circ = QuantumCircuit(reg, hamevo)
     model = QuantumModel(circ, configuration={"ode_solver": ode_solver, "n_steps_hevo": n_steps})
-    state_qadence = model.run(
+    state_qadence0 = model.run(
         values={"x": torch.tensor(feature_param_x), "y": torch.tensor(feature_param_y)}
     )
 
+    state_qadence1 = run(
+        hamevo,
+        values={"x": torch.tensor(feature_param_x), "y": torch.tensor(feature_param_y)},
+        configuration={"ode_solver": ode_solver, "n_steps_hevo": n_steps},
+    )
+
     # simulate with qutip
     t_points = np.linspace(0, duration, n_steps)
     psi_0 = qutip.basis(4, 0)
     result = qutip.sesolve(qutip_generator, psi_0, t_points)
     state_qutip = torch.tensor(result.states[-1].full().T)
 
-    assert torch.allclose(state_qadence, state_qutip, atol=MIDDLE_ACCEPTANCE)
+    assert torch.allclose(state_qadence0, state_qutip, atol=MIDDLE_ACCEPTANCE)
+    assert torch.allclose(state_qadence1, state_qutip, atol=MIDDLE_ACCEPTANCE)