Feat vqa remote

mpqp/core/circuit.py

@@ -34,7 +34,7 @@
 from __future__ import annotations
 
 from copy import deepcopy
-from numbers import Complex
+from numbers import Complex, Number
 from typing import TYPE_CHECKING, Literal, Optional, Sequence, Type, Union, overload
 from warnings import warn
 
@@ -70,7 +70,7 @@
     from braket.circuits import Circuit as braket_Circuit
     from cirq.circuits.circuit import Circuit as cirq_Circuit
     from qat.core.wrappers.circuit import Circuit as myQLM_Circuit
-    from qiskit.circuit import QuantumCircuit
+    from qiskit.circuit import Parameter, QuantumCircuit
     from qiskit_aer import AerSimulator
     from sympy import Basic, Expr
 
@@ -171,7 +171,10 @@ def __init__(
         self._user_nb_qubits: Optional[int] = None
         self._nb_qubits: int
 
-        self.transpiled_circuit: "Optional[Union[braket_Circuit, cirq_Circuit, myQLM_Circuit, QuantumCircuit]]" = (None)
+        self.transpiled_circuit: dict[
+            AvailableDevice,
+            Union[braket_Circuit, cirq_Circuit, myQLM_Circuit, QuantumCircuit],
+        ] = {}
         """A pre-transpiled circuit to skip repeated transpilation when running 
         the circuit. Useful when working with a symbolic circuit that needs to
         be executed with different parameters."""
@@ -2152,6 +2155,15 @@ def __repr__(self) -> str:
 
         return f'QCircuit({args_repr})'
 
+    def transpiled_for_device(self, device: AvailableDevice):
+        if device not in self.transpiled_circuit:
+            self.transpiled_circuit[device] = (
+                self.to_other_device(  # pyright: ignore[reportCallIssue]
+                    device  # pyright: ignore[reportArgumentType]
+                )
+            )
+        return self.transpiled_circuit[device]
+
     def variables(self) -> set[Basic]:
         """Returns all the symbolic parameters involved in this circuit.
 
@@ -2176,3 +2188,41 @@ def variables(self) -> set[Basic]:
                     if isinstance(param, Expr):
                         params.update(param.free_symbols)
         return params
+
+    def bind_parameters(
+        self, device: AvailableDevice, values: dict[str | Parameter | Basic, Number]
+    ) -> QCircuit:
+        """Bind parameter values to the transpiled circuit."""
+        # TODO: to enhance docs
+        if device not in self.transpiled_circuit:
+            self.transpiled_for_device(device)
+        transpiled = self.transpiled_circuit[device]
+
+        param_values = {str(k): v for k, v in values.items()}
+
+        bound_circuit = deepcopy(self)
+        bound_circuit.transpiled_circuit = dict(self.transpiled_circuit)
+
+        from qiskit import QuantumCircuit
+
+        if isinstance(transpiled, QuantumCircuit):
+            qiskit_param_map = {
+                p: param_values[p.name]
+                for p in transpiled.parameters
+                if p.name in param_values
+            }
+            bound_circuit.transpiled_circuit[device] = (
+                transpiled.assign_parameters(qiskit_param_map)
+                if qiskit_param_map
+                else transpiled
+            )
+            return bound_circuit
+
+        elif isinstance(transpiled, braket_Circuit):
+            bound_circuit.transpiled_circuit[device] = transpiled.make_bound_circuit(
+                param_values
+            )
+            return bound_circuit
+
+        else:
+            raise TypeError(f"Unsupported transpiled circuit yet: {type(transpiled)}")

mpqp/core/instruction/measurement/expectation_value.py

@@ -30,6 +30,7 @@ class to define your observable, and a :class:`ExpectationMeasure` to perform
 
 if TYPE_CHECKING:
     from braket.circuits.observables import Hermitian, Sum
+    from braket.circuits import Circuit as braket_Circuit
     from cirq.circuits.circuit import Circuit as CirqCircuit
     from cirq.ops.linear_combinations import PauliSum as CirqPauliSum
     from cirq.ops.pauli_string import PauliString as CirqPauliString
@@ -39,6 +40,7 @@ class to define your observable, and a :class:`ExpectationMeasure` to perform
     from sympy import Expr
 
     from mpqp.core.instruction.gates.custom_controlled_gate import Gate
+    from mpqp.execution.devices import AvailableDevice
 
 
 class Observable:
@@ -81,8 +83,15 @@ def __init__(
         self._is_diagonal = None
         self._diag_elements: Optional[npt.NDArray[np.float64]] = None
         self.label = label
-        "See parameter description."
-        self.pre_transpiled = None
+        """See parameter description."""
+        self.pre_transpiled: dict[
+            AvailableDevice,
+            Union[
+                SparsePauliOp, QLMObservable, CirqPauliSum, CirqPauliString, Hermitian
+            ],
+        ] = {}  # TODO: do we put None, or empty dict ?
+        # TODO: docstring
+        """TODO: documentation"""
 
         if isinstance(observable, PauliString):
             self.nb_qubits = observable.nb_qubits
@@ -437,7 +446,17 @@ def __init__(
         """See parameter description."""
         self.optimize_measurement = optimize_measurement
         """See parameter description."""
-        self.pre_transpiled = None
+        # TODO: do we need both pre_transpiled and translated_pre_measures ?
+        # self.pre_transpiled = None
+        # TODO : docstring
+        """TODO"""
+        self.translated_pre_measures: dict[
+            AvailableDevice,
+            tuple[list[dict[str, npt.NDArray[np.float64]]], list[braket_Circuit]],
+        ] = {}
+        # TODO : docstring
+        """TODO"""
+
         if isinstance(observable, Observable):
             observable = [observable]
         else:
@@ -622,3 +641,44 @@ def to_dict(self):
             and not attr_name.startswith("__")
             and not callable(getattr(self, attr_name))
         }
+
+    # TODO: double check this method
+    def pre_transpile_observables(self, device: AvailableDevice):
+        from mpqp.execution.devices import AWSDevice, IBMDevice
+
+        if device in self.translated_pre_measures:
+            return
+
+        if isinstance(device, AWSDevice):
+            from mpqp.core.circuit import QCircuit
+            from mpqp.tools.pauli_grouping import (
+                find_qubitwise_rotations,
+                pauli_monomial_eigenvalues,
+            )
+
+            grouping = self.get_pauli_grouping()
+            transpiled_pre_measures = [
+                QCircuit(find_qubitwise_rotations(group)).to_other_language(
+                    Language.BRAKET
+                )
+                for group in grouping
+            ]
+            eigenvalues = [
+                {monom.name: pauli_monomial_eigenvalues(monom) for monom in group}
+                for group in grouping
+            ]
+            self.translated_pre_measures[device] = (
+                eigenvalues,
+                transpiled_pre_measures,
+            )
+
+        elif isinstance(device, IBMDevice):
+            for observable in self.observables:
+                if device not in observable.pre_transpile:
+                    observable.pre_transpile[device] = observable.to_other_language(
+                        language=Language.QISKIT
+                    )
+        else:
+            raise NotImplementedError(
+                f"Pre-transpilation for device {type(device).__name__} is not implemented."
+            )

mpqp/execution/__init__.py

@@ -3,14 +3,14 @@
     ATOSDevice,
     AvailableDevice,
     AWSDevice,
+    AZUREDevice,
     GOOGLEDevice,
     IBMDevice,
-    AZUREDevice,
 )
-from .simulated_devices import IBMSimulatedDevice
-from .job import Job, JobStatus, JobType
+from .job import ExecutionMode, Job, JobStatus, JobType
 from .result import BatchResult, Result, Sample, StateVector
 from .runner import adjust_measure, run, submit
+from .simulated_devices import IBMSimulatedDevice
 
 # This import has to be done after the loading of result to work, `pass` is a
 # trick to avoid isort to move this line above

mpqp/execution/connection/ibm_connection.py

@@ -1,5 +1,5 @@
 from getpass import getpass
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from termcolor import colored
 
@@ -9,10 +9,11 @@
 
 if TYPE_CHECKING:
     from qiskit.providers.backend import BackendV2
-    from qiskit_ibm_runtime import QiskitRuntimeService
+    from qiskit_ibm_runtime import QiskitRuntimeService, Session
 
 
 Runtime_Service = None
+_ibm_sessions: dict[str, "Session"] = {}
 
 
 def config_ibm_account(token: str):
@@ -208,3 +209,49 @@ def get_all_job_ids() -> list[str]:
     if get_env_variable("IBM_CONFIGURED") == "True":
         return [job.job_id() for job in get_QiskitRuntimeService().jobs(limit=None)]
     return []
+
+
+def get_or_create_ibm_session(
+    backend: "BackendV2", max_time: Optional[int] = None
+) -> "Session":
+    """Get an active IBM Runtime session for the given backend.
+    If a session exists and is valid, reuse it. Otherwise, create a new one.
+    """
+    from qiskit_ibm_runtime import Session
+    from qiskit_ibm_runtime.exceptions import IBMNotAuthorizedError, IBMRuntimeError
+
+    backend_name = backend.name
+    if backend_name in _ibm_sessions:
+        session = _ibm_sessions[backend_name]
+        try:
+            status = session.status()
+        except (IBMNotAuthorizedError, IBMRuntimeError):
+            status = "Closed"
+
+        if status not in ("Closed", None):
+            return session
+
+    new_session = Session(backend=backend, max_time=max_time)
+    _ibm_sessions[backend_name] = new_session
+    return new_session
+
+
+def close_ibm_session(backend: "BackendV2") -> None:
+    """Close the currently active session, if one exists."""
+
+    from qiskit_ibm_runtime.exceptions import IBMNotAuthorizedError, IBMRuntimeError
+
+    backend_name = backend.name
+    if backend_name not in _ibm_sessions:
+        return
+
+    session = _ibm_sessions[backend_name]
+    try:
+        session.close()
+    except (IBMNotAuthorizedError, IBMRuntimeError) as err:
+        raise IBMRemoteExecutionError(
+            f"Failed to close IBM session for backend '{backend_name}'. "
+            "Session was not removed; you can retry.\nTrace: " + str(err)
+        )
+    else:
+        del _ibm_sessions[backend_name]

mpqp/execution/job.py

@@ -13,9 +13,12 @@
 
 from __future__ import annotations
 
+from numbers import Number
 from typing import TYPE_CHECKING, Optional
 
 from aenum import Enum, NoAlias, auto
+from qiskit.circuit import Parameter
+from sympy import Basic
 
 from mpqp.tools.generics import MessageEnum
 
@@ -70,6 +73,19 @@ class JobType(Enum):
     retrieve the expectation value in an optimal manner."""
 
 
+class ExecutionMode(Enum):
+    """Execution mode for remote backends.
+    It controls how jobs are submitted (single job, batch and session).
+    """
+
+    JOB = "JOB"
+    BATCH = "BATCH"
+    SESSION = "SESSION"
+
+    def __str__(self):
+        return self.value
+
+
 class Job:
     """Representation of a job, an object regrouping all the information about
     the submission of a computation/measure of a quantum circuit on a
@@ -87,6 +103,7 @@ class Job:
         device: Device (simulator, quantum computer) on which we want to execute
             the job.
         measure: Object representing the measure to perform.
+        mode: Remote execution mode (JOB(single), BATCH(batch/params) and SESSION(IBM Runtime Session)).
 
     Examples:
         >>> circuit = QCircuit(3)
@@ -110,6 +127,7 @@ def __init__(
         job_type: JobType,
         circuit: QCircuit,
         device: AvailableDevice,
+        mode: ExecutionMode = ExecutionMode.JOB,
     ):
         self._status = JobStatus.INIT
 
@@ -119,12 +137,21 @@ def __init__(
         """See parameter description."""
         self.device = device
         """See parameter description."""
+        self.mode = mode
+        """See parameter description."""
         self.id: Optional[str] = None
         """Contains the id of the remote job, used to retrieve the result from 
         the remote provider.  ``None`` if the job is local. It can take a little
         while before it is set to the right value (For instance, a job
         submission can require handshake protocols to conclude before
         attributing an id to the job)."""
+        self.values: Optional[dict[str | Parameter | Basic, Number]] = None
+        """Parameter bindings for circuits containing symbolic variables.
+
+        For local execution, parameters are typically substituted directly into the
+        circuit prior to execution. For remote execution, these bindings are stored in the
+        ``Job`` so the provider can bind them on the transpiled circuit without 
+        re-transpiling the circuit each time."""
 
     @property
     def measure(self) -> Optional[Measure]:
@@ -168,7 +195,8 @@ def status(self, job_status: JobStatus):
         self._status = job_status
 
     def __repr__(self) -> str:
-        return f"{type(self).__name__}({self.job_type}, {repr(self.circuit)}, {self.device})"
+        # TODO: improve repr
+        return f"{type(self).__name__}({self.job_type}, {repr(self.circuit)}, {self.device}, mode={self.mode})"
 
     def __eq__(self, other):  # pyright: ignore[reportMissingParameterType]
         if not isinstance(other, Job):
@@ -185,6 +213,7 @@ def to_dict(self):
             "job_type": self.job_type,
             "circuit": self.circuit,
             "device": self.device,
+            "mode": self.mode,
             "measure": self.measure,
             "id": self.id,
             "status": self.status,
@@ -218,7 +247,7 @@ def load_by_local_id(job_id: int):
         Uses :func:`~mpqp.local_storage.load.get_jobs_with_id`.
 
         Args:
-            job_id: Local id of the job you need.
+           job_id: Local id of the job you need.
 
         Example:
             >>> Job.load_by_local_id(1) # doctest: +ELLIPSIS