qoro-divi 0.3.2b0__py3-none-any.whl → 0.3.4__py3-none-any.whl

divi/qprog/{_vqe.py → algorithms/_vqe.py}

@@ -2,7 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from enum import Enum
 from warnings import warn
 
 import pennylane as qml
@@ -10,36 +9,8 @@ import sympy as sp
 
 from divi.circuits import MetaCircuit
 from divi.qprog import QuantumProgram
-from divi.qprog.optimizers import Optimizer
-
-
-class VQEAnsatz(Enum):
-    UCCSD = "UCCSD"
-    RY = "RY"
-    RYRZ = "RYRZ"
-    HW_EFFICIENT = "HW_EFFICIENT"
-    QAOA = "QAOA"
-    HARTREE_FOCK = "HF"
-
-    def describe(self):
-        return self.name, self.value
-
-    def n_params(self, n_qubits, **kwargs):
-        if self in (VQEAnsatz.UCCSD, VQEAnsatz.HARTREE_FOCK):
-            singles, doubles = qml.qchem.excitations(
-                kwargs.pop("n_electrons"), n_qubits
-            )
-            s_wires, d_wires = qml.qchem.excitations_to_wires(singles, doubles)
-
-            return len(s_wires) + len(d_wires)
-        elif self == VQEAnsatz.RY:
-            return n_qubits
-        elif self == VQEAnsatz.RYRZ:
-            return 2 * n_qubits
-        elif self == VQEAnsatz.HW_EFFICIENT:
-            raise NotImplementedError
-        elif self == VQEAnsatz.QAOA:
-            return qml.QAOAEmbedding.shape(n_layers=1, n_wires=n_qubits)[1]
+from divi.qprog.algorithms._ansatze import Ansatz, HartreeFockAnsatz
+from divi.qprog.optimizers import MonteCarloOptimizer, Optimizer
 
 
 class VQE(QuantumProgram):
@@ -49,8 +20,8 @@ class VQE(QuantumProgram):
         molecule: qml.qchem.Molecule | None = None,
         n_electrons: int | None = None,
         n_layers: int = 1,
-        ansatz=VQEAnsatz.HARTREE_FOCK,
-        optimizer=Optimizer.MONTE_CARLO,
+        ansatz: Ansatz | None = None,
+        optimizer: Optimizer | None = None,
         max_iterations=10,
         **kwargs,
     ) -> None:
@@ -62,19 +33,20 @@ class VQE(QuantumProgram):
             molecule (pennylane.qchem.Molecule, optional): The molecule representing the problem.
             n_electrons (int, optional): Number of electrons associated with the Hamiltonian.
                 Only needs to be provided when a Hamiltonian is given.
-            ansatz (VQEAnsatz): The ansatz to use for the VQE problem
+            ansatz (Ansatz): The ansatz to use for the VQE problem
             optimizer (Optimizers): The optimizer to use.
             max_iterations (int): Maximum number of iteration optimizers.
         """
 
         # Local Variables
+        self.ansatz = HartreeFockAnsatz() if ansatz is None else ansatz
         self.n_layers = n_layers
         self.results = {}
-        self.ansatz = ansatz
-        self.optimizer = optimizer
         self.max_iterations = max_iterations
         self.current_iteration = 0
 
+        self.optimizer = optimizer if optimizer is not None else MonteCarloOptimizer()
+
         self._process_problem_input(
             hamiltonian=hamiltonian, molecule=molecule, n_electrons=n_electrons
         )
@@ -83,6 +55,13 @@ class VQE(QuantumProgram):
 
         self._meta_circuits = self._create_meta_circuits_dict()
 
+    @property
+    def n_params(self):
+        return (
+            self.ansatz.n_params_per_layer(self.n_qubits, n_electrons=self.n_electrons)
+            * self.n_layers
+        )
+
     def _process_problem_input(self, hamiltonian, molecule, n_electrons):
         if hamiltonian is None and molecule is None:
             raise ValueError(
@@ -90,13 +69,8 @@ class VQE(QuantumProgram):
             )
 
         if hamiltonian is not None:
-            if not isinstance(n_electrons, int) or n_electrons < 0:
-                raise ValueError(
-                    f"`n_electrons` is expected to be a non-negative integer. Got {n_electrons}."
-                )
-
-            self.n_electrons = n_electrons
             self.n_qubits = len(hamiltonian.wires)
+            self.n_electrons = n_electrons
 
         if molecule is not None:
             self.molecule = molecule
@@ -111,10 +85,6 @@ class VQE(QuantumProgram):
                     UserWarning,
                 )
 
-        self.n_params = self.ansatz.n_params(
-            self.n_qubits, n_electrons=self.n_electrons
-        )
-
         self.cost_hamiltonian = self._clean_hamiltonian(hamiltonian)
 
     def _clean_hamiltonian(
@@ -137,8 +107,8 @@ class VQE(QuantumProgram):
             )
         )
 
-        self.loss_constant = sum(
-            map(lambda x: hamiltonian[x].scalar, constant_terms_idx)
+        self.loss_constant = float(
+            sum(map(lambda x: hamiltonian[x].scalar, constant_terms_idx))
         )
 
         for idx in constant_terms_idx:
@@ -147,9 +117,17 @@ class VQE(QuantumProgram):
         return hamiltonian.simplify()
 
     def _create_meta_circuits_dict(self) -> dict[str, MetaCircuit]:
-        weights_syms = sp.symarray("w", (self.n_layers, self.n_params))
+        weights_syms = sp.symarray(
+            "w",
+            (
+                self.n_layers,
+                self.ansatz.n_params_per_layer(
+                    self.n_qubits, n_electrons=self.n_electrons
+                ),
+            ),
+        )
 
-        def _prepare_circuit(ansatz, hamiltonian, params):
+        def _prepare_circuit(hamiltonian, params):
             """
             Prepare the circuit for the VQE problem.
             Args:
@@ -157,7 +135,12 @@ class VQE(QuantumProgram):
                 hamiltonian (qml.Hamiltonian): The Hamiltonian to use
                 params (list): The parameters to use for the ansatz
             """
-            self._set_ansatz(ansatz, params)
+            self.ansatz.build(
+                params,
+                n_qubits=self.n_qubits,
+                n_layers=self.n_layers,
+                n_electrons=self.n_electrons,
+            )
 
             # Even though in principle we want to sample from a state,
             # we are applying an `expval` operation here to make it compatible
@@ -168,93 +151,12 @@ class VQE(QuantumProgram):
         return {
             "cost_circuit": self._meta_circuit_factory(
                 qml.tape.make_qscript(_prepare_circuit)(
-                    self.ansatz, self.cost_hamiltonian, weights_syms
+                    self.cost_hamiltonian, weights_syms
                 ),
                 symbols=weights_syms.flatten(),
             )
         }
 
-    def _set_ansatz(self, ansatz: VQEAnsatz, params):
-        """
-        Set the ansatz for the VQE problem.
-        Args:
-            ansatz (Ansatze): The ansatz to use
-            params (list): The parameters to use for the ansatz
-            n_layers (int): The number of layers to use for the ansatz
-        """
-
-        def _add_hw_efficient_ansatz(params):
-            raise NotImplementedError
-
-        def _add_qaoa_ansatz(params):
-            # This infers layers automatically from the parameters shape
-            qml.QAOAEmbedding(
-                features=[],
-                weights=params.reshape(self.n_layers, -1),
-                wires=range(self.n_qubits),
-            )
-
-        def _add_ry_ansatz(params):
-            qml.layer(
-                qml.AngleEmbedding,
-                self.n_layers,
-                params.reshape(self.n_layers, -1),
-                wires=range(self.n_qubits),
-                rotation="Y",
-            )
-
-        def _add_ryrz_ansatz(params):
-            def _ryrz(params, wires):
-                ry_rots, rz_rots = params.reshape(2, -1)
-                qml.AngleEmbedding(ry_rots, wires=wires, rotation="Y")
-                qml.AngleEmbedding(rz_rots, wires=wires, rotation="Z")
-
-            qml.layer(
-                _ryrz,
-                self.n_layers,
-                params.reshape(self.n_layers, -1),
-                wires=range(self.n_qubits),
-            )
-
-        def _add_uccsd_ansatz(params):
-            hf_state = qml.qchem.hf_state(self.n_electrons, self.n_qubits)
-
-            singles, doubles = qml.qchem.excitations(self.n_electrons, self.n_qubits)
-            s_wires, d_wires = qml.qchem.excitations_to_wires(singles, doubles)
-
-            qml.UCCSD(
-                params.reshape(self.n_layers, -1),
-                wires=range(self.n_qubits),
-                s_wires=s_wires,
-                d_wires=d_wires,
-                init_state=hf_state,
-                n_repeats=self.n_layers,
-            )
-
-        def _add_hartree_fock_ansatz(params):
-            singles, doubles = qml.qchem.excitations(self.n_electrons, self.n_qubits)
-            hf_state = qml.qchem.hf_state(self.n_electrons, self.n_qubits)
-
-            qml.layer(
-                qml.AllSinglesDoubles,
-                self.n_layers,
-                params.reshape(self.n_layers, -1),
-                wires=range(self.n_qubits),
-                hf_state=hf_state,
-                singles=singles,
-                doubles=doubles,
-            )
-
-            # Reset the BasisState operations after the first layer
-            # for behaviour similar to UCCSD ansatz
-            for op in qml.QueuingManager.active_context().queue[1:]:
-                op._hyperparameters["hf_state"] = 0
-
-        if ansatz in VQEAnsatz:
-            locals()[f"_add_{ansatz.name.lower()}_ansatz"](params)
-        else:
-            raise ValueError(f"Invalid Ansatz Value. Got {ansatz}.")
-
     def _generate_circuits(self):
         """
         Generate the circuits for the VQE problem.

divi/qprog/batch.py

@@ -10,16 +10,15 @@ from multiprocessing import Event, Manager
 from multiprocessing.synchronize import Event as EventClass
 from queue import Empty, Queue
 from threading import Lock, Thread
+from typing import Any
 from warnings import warn
 
 from rich.console import Console
 from rich.progress import Progress, TaskID
 
-from divi._pbar import make_progress_bar
-from divi.interfaces import CircuitRunner
-from divi.parallel_simulator import ParallelSimulator
-from divi.qlogger import disable_logging
+from divi.backends import CircuitRunner, ParallelSimulator
 from divi.qprog.quantum_program import QuantumProgram
+from divi.reporting import disable_logging, make_progress_bar
 
 
 def queue_listener(
@@ -32,7 +31,7 @@ def queue_listener(
 ):
     while not done_event.is_set():
         try:
-            msg = queue.get(timeout=0.1)
+            msg: dict[str, Any] = queue.get(timeout=0.1)
         except Empty:
             continue
         except Exception as e:
@@ -42,14 +41,25 @@ def queue_listener(
         with lock:
             task_id = pb_task_map[msg["job_id"]]
 
-        progress_bar.update(
-            task_id,
-            advance=msg["progress"],
-            poll_attempt=msg.get("poll_attempt", 0),
-            message=msg.get("message", ""),
-            final_status=msg.get("final_status", ""),
-            refresh=is_jupyter,
-        )
+        # Prepare update arguments, starting with progress.
+        update_args = {"advance": msg["progress"]}
+
+        if "poll_attempt" in msg:
+            update_args["poll_attempt"] = msg.get("poll_attempt", 0)
+        if "max_retries" in msg:
+            update_args["max_retries"] = msg.get("max_retries")
+        if "service_job_id" in msg:
+            update_args["service_job_id"] = msg.get("service_job_id")
+        if "job_status" in msg:
+            update_args["job_status"] = msg.get("job_status")
+        if msg.get("message"):
+            update_args["message"] = msg.get("message")
+        if "final_status" in msg:
+            update_args["final_status"] = msg.get("final_status", "")
+
+        update_args["refresh"] = is_jupyter
+
+        progress_bar.update(task_id, **update_args)
 
 
 def _default_task_function(program: QuantumProgram):
@@ -182,10 +192,7 @@ class ProgramBatch(ABC):
             raise RuntimeError("No programs to run.")
 
         self._progress_bar = (
-            make_progress_bar(
-                max_retries=None if self._is_local else self.backend.max_retries,
-                is_jupyter=self._is_jupyter,
-            )
+            make_progress_bar(is_jupyter=self._is_jupyter)
             if hasattr(self, "max_iterations")
             else None
         )
@@ -217,8 +224,7 @@ class ProgramBatch(ABC):
         if not blocking:
             # Arm safety net
             atexit.register(self._atexit_cleanup_hook)
-
-        if blocking:
+        else:
             self.join()
 
         return self

divi/qprog/optimizers.py

@@ -2,74 +2,199 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from abc import ABC, abstractmethod
+from collections.abc import Callable
 from enum import Enum
 
 import numpy as np
+from scipy.optimize import OptimizeResult, minimize
 
+from divi.extern.scipy._cobyla import _minimize_cobyla as cobyla_fn
 
-class Optimizer(Enum):
+
+class ScipyMethod(Enum):
     NELDER_MEAD = "Nelder-Mead"
     COBYLA = "COBYLA"
-    MONTE_CARLO = "Monte Carlo"
     L_BFGS_B = "L-BFGS-B"
 
-    def describe(self):
-        return self.name, self.value
 
+class Optimizer(ABC):
     @property
+    @abstractmethod
     def n_param_sets(self):
-        if self in (Optimizer.NELDER_MEAD, Optimizer.L_BFGS_B, Optimizer.COBYLA):
-            return 1
-        elif self == Optimizer.MONTE_CARLO:
-            return 10
+        """
+        Returns the number of parameter sets the optimizer can handle per optimization run.
+        Returns:
+            int: Number of parameter sets.
+        """
+        raise NotImplementedError("This method should be implemented by subclasses.")
+
+    @abstractmethod
+    def optimize(
+        self,
+        cost_fn: Callable[[np.ndarray], float],
+        initial_params: np.ndarray,
+        callback_fn: Callable | None = None,
+        **kwargs,
+    ) -> OptimizeResult:
+        """
+        Optimize the given cost function starting from initial parameters.
+
+        Parameters:
+            cost_fn: The cost function to minimize.
+            initial_params: Initial parameters for the optimization.
+            **kwargs: Additional keyword arguments for the optimizer.
+
+        Returns:
+            Optimized parameters.
+        """
+        raise NotImplementedError("This method should be implemented by subclasses.")
+
+
+class ScipyOptimizer(Optimizer):
+    def __init__(self, method: ScipyMethod):
+        self.method = method
 
     @property
-    def n_samples(self):
-        if self == Optimizer.MONTE_CARLO:
-            return 10
+    def n_param_sets(self):
         return 1
 
-    def compute_new_parameters(self, params, iteration, **kwargs):
-        if self != Optimizer.MONTE_CARLO:
-            raise NotImplementedError
-
-        rng = kwargs.pop("rng", np.random.default_rng())
-
-        losses = kwargs.pop("losses")
-        smallest_energy_keys = sorted(losses, key=lambda k: losses[k])[: self.n_samples]
+    def optimize(
+        self,
+        cost_fn: Callable[[np.ndarray], float],
+        initial_params: np.ndarray,
+        callback_fn: Callable | None = None,
+        **kwargs,
+    ):
+        max_iterations = kwargs.pop("maxiter", None)
+
+        if max_iterations is None or self.method == ScipyMethod.COBYLA:
+            # COBYLA perceive maxiter as maxfev so we need
+            # to use the callback fn for counting instead.
+            maxiter = None
+        else:
+            # Need to add one more iteration for Nelder-Mead's simplex initialization step
+            maxiter = (
+                max_iterations + 1
+                if self.method == ScipyMethod.NELDER_MEAD
+                else max_iterations
+            )
+
+        return minimize(
+            cost_fn,
+            initial_params.squeeze(),
+            method=(
+                cobyla_fn if self.method == ScipyMethod.COBYLA else self.method.value
+            ),
+            jac=(
+                kwargs.pop("jac", None) if self.method == ScipyMethod.L_BFGS_B else None
+            ),
+            callback=callback_fn,
+            options={"maxiter": maxiter},
+        )
+
+
+class MonteCarloOptimizer(Optimizer):
+    def __init__(self, n_param_sets: int = 10, n_best_sets: int = 3):
+        super().__init__()
+
+        if n_best_sets > n_param_sets:
+            raise ValueError("n_best_sets must be less than or equal to n_param_sets.")
+
+        self._n_param_sets = n_param_sets
+        self._n_best_sets = n_best_sets
+
+        # Calculate how many times each of the best sets should be repeated
+        samples_per_best = self.n_param_sets // self.n_best_sets
+        remainder = self.n_param_sets % self.n_best_sets
+        self._repeat_counts = np.full(self.n_best_sets, samples_per_best)
+        self._repeat_counts[:remainder] += 1
 
-        new_params = []
+    @property
+    def n_param_sets(self):
+        return self._n_param_sets
 
-        for key in smallest_energy_keys:
-            new_param_set = [
-                rng.normal(
-                    params[int(key)],
-                    1 / (2 * iteration),
-                    size=params[int(key)].shape,
-                )
-                for _ in range(self.n_param_sets)
-            ]
+    @property
+    def n_best_sets(self):
+        return self._n_best_sets
+
+    def _compute_new_parameters(
+        self,
+        params: np.ndarray,
+        curr_iteration: int,
+        best_indices: np.ndarray,
+        rng: np.random.Generator,
+    ) -> np.ndarray:
+        """
+        Generates a new population of parameters based on the best-performing ones.
+        """
+
+        # 1. Select the best parameter sets from the current population
+        best_params = params[best_indices]
+
+        # 2. Prepare the means for sampling by repeating each best parameter set
+        # according to its assigned count
+        new_means = np.repeat(best_params, self._repeat_counts, axis=0)
+
+        # 3. Define the standard deviation (scale), which shrinks over iterations
+        scale = 1.0 / (2.0 * (curr_iteration + 1.0))
+
+        # 4. Generate all new parameters in a single vectorized call
+        new_params = rng.normal(loc=new_means, scale=scale)
+
+        # Apply periodic boundary conditions
+        return new_params % (2 * np.pi)
+
+    def optimize(
+        self,
+        cost_fn: Callable[[np.ndarray], float],
+        initial_params: np.ndarray,
+        callback_fn: Callable[[OptimizeResult], float | np.ndarray] | None = None,
+        **kwargs,
+    ) -> OptimizeResult:
+        """
+        Perform Monte Carlo optimization on the cost function.
+
+        Parameters:
+            cost_fn: The cost function to minimize.
+            initial_params: Initial parameters for the optimization.
+            callback_fn: Optional callback function to monitor progress.
+            **kwargs: Additional keyword arguments for the optimizer.
+        Returns:
+            Optimized parameters.
+        """
+        rng = kwargs.pop("rng", np.random.default_rng())
+        max_iterations = kwargs.pop("maxiter", 5)
 
-            for new_param in new_param_set:
-                new_param = np.clip(new_param, 0, 2 * np.pi)
+        population = np.copy(initial_params)
 
-            new_params.extend(new_param_set)
+        final_params = None
+        final_losses = None
 
-        return np.array(new_params)
+        for curr_iter in range(max_iterations):
+            # Evaluate the entire population once
+            losses = cost_fn(population)
 
-    def compute_parameter_shift_mask(self, n_params):
-        if self != Optimizer.L_BFGS_B:
-            raise NotImplementedError
+            # Find the indices of the best-performing parameter sets (only once)
+            best_indices = np.argpartition(losses, self.n_best_sets - 1)[
+                : self.n_best_sets
+            ]
 
-        mask_arr = np.arange(0, 2 * n_params, 2)
-        mask_arr[0] = 1
+            # Store the current best results
+            final_params = population[best_indices]
+            final_losses = losses[best_indices]
 
-        binary_matrix = (
-            (mask_arr[:, np.newaxis] & (1 << np.arange(n_params))) > 0
-        ).astype(np.float64)
+            if callback_fn:
+                callback_fn(OptimizeResult(x=final_params, fun=final_losses))
 
-        binary_matrix = binary_matrix.repeat(2, axis=0)
-        binary_matrix[1::2] *= -1
-        binary_matrix *= 0.5 * np.pi
+            # Generate the next generation of parameters
+            population = self._compute_new_parameters(
+                population, curr_iter, best_indices, rng
+            )
 
-        return binary_matrix
+        # Return the best results from the LAST EVALUATED population
+        return OptimizeResult(
+            x=final_params,
+            fun=final_losses,
+            nit=max_iterations,
+        )