Fixed tests

qadence/backends/pyqtorch/backend.py

@@ -96,7 +96,6 @@ def run(
         unpyqify_state: bool = True,
     ) -> Tensor:
         n_qubits = circuit.abstract.n_qubits
-        orig_param_values = param_values.pop("orig_param_values", {})
         if state is None:
             # If no state is passed, we infer the batch_size through the length
             # of the individual parameter value tensors.
@@ -105,8 +104,6 @@ def run(
             validate_state(state, n_qubits)
             # pyqtorch expects input shape [2] * n_qubits + [batch_size]
             state = pyqify(state, n_qubits) if pyqify_state else state
-        if len(orig_param_values) != 0:
-            param_values.update({"orig_param_values": orig_param_values})
         state = circuit.native.run(state=state, values=param_values)
         state = unpyqify(state) if unpyqify_state else state
         state = invert_endianness(state) if endianness != self.native_endianness else state
@@ -168,12 +165,9 @@ def _looped_expectation(
                 "Looping expectation does not make sense with batched initial state. "
                 "Define your initial state with `batch_size=1`"
             )
-        orig_param_values = param_values.pop("orig_param_values", {})
         list_expvals = []
         observables = observable if isinstance(observable, list) else [observable]
         for vals in to_list_of_dicts(param_values):
-            if len(orig_param_values) != 0:
-                vals.update({"orig_param_values": orig_param_values})
             wf = self.run(circuit, vals, state, endianness, pyqify_state=True, unpyqify_state=False)
             exs = torch.cat([obs.native(wf, vals) for obs in observables], 0)
             list_expvals.append(exs)
@@ -220,14 +214,11 @@ def sample(
         endianness: Endianness = Endianness.BIG,
         pyqify_state: bool = True,
     ) -> list[Counter]:
-        orig_param_values = param_values.pop("orig_param_values", {})
         if state is None:
             state = circuit.native.init_state(batch_size=infer_batchsize(param_values))
         elif state is not None and pyqify_state:
             n_qubits = circuit.abstract.n_qubits
             state = pyqify(state, n_qubits) if pyqify_state else state
-        if len(orig_param_values) != 0:
-            param_values.update({"orig_param_values": orig_param_values})
         samples: list[Counter] = circuit.native.sample(
             state=state, values=param_values, n_shots=n_shots
         )

qadence/backends/pyqtorch/convert_ops.py

@@ -363,7 +363,6 @@ def Ht(t: Tensor | float) -> Tensor:
                 sesolve(Ht, unpyqify(state).T[:, 0:1], tsave, self.config.ode_solver).states[-1].T
             )
         else:
-            values.pop("orig_param_values", {})
             result = apply_operator(
                 state,
                 self.unitary(values),

qadence/backends/utils.py

@@ -98,10 +98,11 @@ def to_list_of_dicts(param_values: ParamDictType) -> list[ParamDictType]:
     if not param_values:
         return [param_values]
 
-    max_batch_size = max(p.size()[0] for p in param_values.values())
+    max_batch_size = max(p.size()[0] for p in param_values.values() if isinstance(p, Tensor))
     batched_values = {
         k: (v if v.size()[0] == max_batch_size else v.repeat(max_batch_size, 1))
         for k, v in param_values.items()
+        if isinstance(v, Tensor)
     }
 
     return [{k: v[i] for k, v in batched_values.items()} for i in range(max_batch_size)]