qoro-divi 0.2.0b1__py3-none-any.whl

divi/qprog/_vqe.py

@@ -0,0 +1,275 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from enum import Enum
+
+import numpy as np
+import pennylane as qml
+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]
+
+
+class VQE(QuantumProgram):
+    def __init__(
+        self,
+        symbols,
+        bond_length: float,
+        coordinate_structure: list[tuple[float, float, float]],
+        charge: float = 0,
+        n_layers: int = 1,
+        ansatz=VQEAnsatz.HARTREE_FOCK,
+        optimizer=Optimizer.MONTE_CARLO,
+        max_iterations=10,
+        **kwargs,
+    ) -> None:
+        """
+        Initialize the VQE problem.
+
+        Args:
+            symbols (list): The symbols of the atoms in the molecule
+            bond_length (float): The bond length to consider
+            coordinate_structure (list): The coordinate structure of the molecule, represented in unit lengths
+            charge (float): the charge of the molecule. Defaults to 0.
+            ansatz (VQEAnsatz): 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.symbols = symbols
+        self.coordinate_structure = coordinate_structure
+        self.bond_length = bond_length
+        self.charge = charge
+        if len(self.coordinate_structure) != len(self.symbols):
+            raise ValueError(
+                "The number of symbols must match the number of coordinates"
+            )
+
+        self.n_layers = n_layers
+        self.results = {}
+        self.ansatz = ansatz
+        self.optimizer = optimizer
+        self.max_iterations = max_iterations
+        self.current_iteration = 0
+
+        self.cost_hamiltonian = self._generate_hamiltonian_operations()
+
+        super().__init__(**kwargs)
+
+        self._meta_circuits = self._create_meta_circuits_dict()
+
+    def _generate_hamiltonian_operations(self) -> qml.operation.Operator:
+        """
+        Generate the Hamiltonian operators for the given bond length.
+
+        Returns:
+            The Hamiltonian corresponding to the VQE problem.
+        """
+
+        coordinates = [
+            (
+                coord_0 * self.bond_length,
+                coord_1 * self.bond_length,
+                coord_2 * self.bond_length,
+            )
+            for (coord_0, coord_1, coord_2) in self.coordinate_structure
+        ]
+
+        coordinates = np.array(coordinates)
+        molecule = qml.qchem.Molecule(self.symbols, coordinates, charge=self.charge)
+        hamiltonian, qubits = qml.qchem.molecular_hamiltonian(molecule)
+
+        self.n_qubits = qubits
+        self.n_electrons = molecule.n_electrons
+
+        self.n_params = self.ansatz.n_params(
+            self.n_qubits, n_electrons=self.n_electrons
+        )
+
+        constant_terms_idx = list(
+            filter(
+                lambda x: all(
+                    isinstance(term, qml.I) for term in hamiltonian[x].terms()[1]
+                ),
+                range(len(hamiltonian)),
+            )
+        )
+
+        self.loss_constant = sum(
+            map(lambda x: hamiltonian[x].scalar.item(), constant_terms_idx)
+        )
+
+        for idx in constant_terms_idx:
+            hamiltonian -= hamiltonian[idx]
+
+        return hamiltonian.simplify()
+
+    def _create_meta_circuits_dict(self) -> dict[str, MetaCircuit]:
+        weights_syms = sp.symarray("w", (self.n_layers, self.n_params))
+
+        def _prepare_circuit(ansatz, hamiltonian, params):
+            """
+            Prepare the circuit for the VQE problem.
+            Args:
+                ansatz (Ansatze): The ansatz to use
+                hamiltonian (qml.Hamiltonian): The Hamiltonian to use
+                params (list): The parameters to use for the ansatz
+            """
+            self._set_ansatz(ansatz, params)
+
+            # Even though in principle we want to sample from a state,
+            # we are applying an `expval` operation here to make it compatible
+            # with the pennylane transforms down the line, which complain about
+            # the `sample` operation.
+            return qml.expval(hamiltonian)
+
+        return {
+            "cost_circuit": self._meta_circuit_factory(
+                qml.tape.make_qscript(_prepare_circuit)(
+                    self.ansatz, 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.
+
+        In this method, we generate bulk circuits based on the selected parameters.
+        We generate circuits for each bond length and each ansatz and optimization choice.
+
+        The structure of the circuits is as follows:
+        - For each bond length:
+            - For each ansatz:
+                - Generate the circuit
+        """
+
+        for p, params_group in enumerate(self._curr_params):
+            circuit = self._meta_circuits[
+                "cost_circuit"
+            ].initialize_circuit_from_params(params_group, tag_prefix=f"{p}")
+
+            self.circuits.append(circuit)
+
+    def _run_optimization_circuits(self, store_data, data_file):
+        if self.cost_hamiltonian is None or len(self.cost_hamiltonian) == 0:
+            raise RuntimeError(
+                "Hamiltonian operators must be generated before running the VQE"
+            )
+
+        return super()._run_optimization_circuits(store_data, data_file)

divi/qprog/_vqe_sweep.py

@@ -0,0 +1,144 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from functools import partial
+from itertools import product
+from typing import Literal
+
+import matplotlib.pyplot as plt
+
+from divi.qprog import VQE, ProgramBatch, VQEAnsatz
+
+from .optimizers import Optimizer
+
+
+class VQEHyperparameterSweep(ProgramBatch):
+    """Allows user to carry out a grid search across different values
+    for the ansatz and the bond length used in a VQE program.
+    """
+
+    def __init__(
+        self,
+        bond_lengths: list[float],
+        ansatze: list[VQEAnsatz],
+        symbols: list[str],
+        coordinate_structure: list[tuple[float, float, float]],
+        charge: float = 0,
+        optimizer: Optimizer = Optimizer.MONTE_CARLO,
+        max_iterations: int = 10,
+        **kwargs,
+    ):
+        """Initiates the class.
+
+        Args:
+            bond_lengths (list): The bond lengths to consider.
+            ansatze (list): The ansatze to use for the VQE problem.
+            symbols (list): The symbols of the atoms in the molecule.
+            coordinate_structure (list): The coordinate structure of the molecule.
+            optimizer (Optimizers): The optimizer to use.
+            max_iterations (int): Maximum number of iteration optimizers.
+        """
+        super().__init__(backend=kwargs.pop("backend"))
+
+        self.ansatze = ansatze
+        self.bond_lengths = [round(bnd, 9) for bnd in bond_lengths]
+        self.max_iterations = max_iterations
+
+        self._constructor = partial(
+            VQE,
+            symbols=symbols,
+            coordinate_structure=coordinate_structure,
+            charge=charge,
+            optimizer=optimizer,
+            max_iterations=self.max_iterations,
+            backend=self.backend,
+            **kwargs,
+        )
+
+    def create_programs(self):
+        if len(self.programs) > 0:
+            raise RuntimeError(
+                "Some programs already exist. "
+                "Clear the program dictionary before creating new ones by using batch.reset()."
+            )
+
+        super().create_programs()
+
+        for ansatz, bond_length in product(self.ansatze, self.bond_lengths):
+            _job_id = (ansatz, bond_length)
+            self.programs[_job_id] = self._constructor(
+                job_id=_job_id,
+                bond_length=bond_length,
+                ansatz=ansatz,
+                losses=self._manager.list(),
+                final_params=self._manager.list(),
+                progress_queue=self._queue,
+            )
+
+    def aggregate_results(self):
+        if len(self.programs) == 0:
+            raise RuntimeError("No programs to aggregate. Run create_programs() first.")
+
+        if self._executor is not None:
+            self.wait_for_all()
+
+        if any(len(program.losses) == 0 for program in self.programs.values()):
+            raise RuntimeError(
+                "Some/All programs have empty losses. Did you call run()?"
+            )
+
+        all_energies = {key: prog.losses[-1] for key, prog in self.programs.items()}
+
+        smallest_key = min(all_energies, key=lambda k: min(all_energies[k].values()))
+        smallest_value = min(all_energies[smallest_key].values())
+
+        return smallest_key, smallest_value
+
+    def visualize_results(self, graph_type: Literal["line", "scatter"] = "line"):
+        """
+        Visualize the results of the VQE problem.
+        """
+        if graph_type not in ["line", "scatter"]:
+            raise ValueError(
+                f"Invalid graph type: {graph_type}. Choose between 'line' and 'scatter'."
+            )
+
+        if self._executor is not None:
+            self.wait_for_all()
+
+        data = []
+        colors = ["blue", "g", "r", "c", "m", "y", "k"]
+
+        ansatz_list = list(VQEAnsatz)
+
+        if graph_type == "scatter":
+            for ansatz, bond_length in self.programs.keys():
+                min_energies = []
+
+                curr_energies = self.programs[(ansatz, bond_length)].losses[-1]
+                min_energies.append(
+                    (
+                        bond_length,
+                        min(curr_energies.values()),
+                        colors[ansatz_list.index(ansatz)],
+                    )
+                )
+                data.extend(min_energies)
+
+            x, y, z = zip(*data)
+            plt.scatter(x, y, color=z, label=ansatz)
+
+        elif graph_type == "line":
+            for ansatz in self.ansatze:
+                energies = []
+                for bond_length in self.bond_lengths:
+                    energies.append(
+                        min(self.programs[(ansatz, bond_length)].losses[-1].values())
+                    )
+                plt.plot(self.bond_lengths, energies, label=ansatz)
+
+        plt.xlabel("Bond length")
+        plt.ylabel("Energy level")
+        plt.legend()
+        plt.show()

divi/qprog/batch.py

@@ -0,0 +1,235 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import traceback
+from abc import ABC, abstractmethod
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from multiprocessing import Event, Manager
+from multiprocessing.synchronize import Event as EventClass
+from queue import Empty, Queue
+from threading import Lock, Thread
+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.qprog.quantum_program import QuantumProgram
+
+
+def queue_listener(
+    queue: Queue,
+    progress_bar: Progress,
+    pb_task_map: dict[QuantumProgram, TaskID],
+    done_event: EventClass,
+    is_jupyter: bool,
+    lock: Lock,
+):
+    while not done_event.is_set():
+        try:
+            msg = queue.get(timeout=0.1)
+        except Empty:
+            continue
+        except Exception as e:
+            progress_bar.console.log(f"[queue_listener] Unexpected exception: {e}")
+            continue
+
+        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,
+        )
+
+
+class ProgramBatch(ABC):
+    """This abstract class provides the basic scaffolding for higher-order
+    computations that require more than one quantum program to achieve its goal.
+
+    Each implementation of this class has to have an implementation of two functions:
+        1. `create_programs`: This function generates the independent programs that
+            are needed to achieve the objective of the job. The creation of those
+            programs can utilize the instance variables of the class to initialize
+            their parameters. The programs should be stored in a key-value store
+            where the keys represent the identifier of the program, whether random
+            or identificatory.
+
+        2. `aggregate_results`: This function aggregates the results of the programs
+            after they are done executing. This function should be aware of the different
+            formats the programs might have (counts dictionary, expectation value, etc) and
+            handle such cases accordingly.
+    """
+
+    def __init__(self, backend: CircuitRunner):
+        super().__init__()
+
+        self.backend = backend
+        self._executor = None
+        self.programs = {}
+
+        self._total_circuit_count = 0
+        self._total_run_time = 0.0
+
+        self._is_local = isinstance(backend, ParallelSimulator)
+        self._is_jupyter = Console().is_jupyter
+
+        # Disable logging since we already have the bars to track progress
+        disable_logging()
+
+    @property
+    def total_circuit_count(self):
+        return self._total_circuit_count
+
+    @property
+    def total_run_time(self):
+        return self._total_run_time
+
+    @abstractmethod
+    def create_programs(self):
+        self._manager = Manager()
+        self._queue = self._manager.Queue()
+
+        if hasattr(self, "max_iterations"):
+            self._done_event = Event()
+
+    def reset(self):
+        self.programs.clear()
+
+        # Stop any active executor
+        if self._executor is not None:
+            self._executor.shutdown(wait=False)
+            self._executor = None
+            self.futures = None
+
+        # Signal and wait for listener thread to stop
+        if hasattr(self, "_done_event") and self._done_event is not None:
+            self._done_event.set()
+            self._done_event = None
+
+        if getattr(self, "_listener_thread", None) is not None:
+            self._listener_thread.join(timeout=1)
+            if self._listener_thread.is_alive():
+                warn(
+                    "Listener thread did not terminate within timeout and may still be running."
+                )
+            else:
+                self._listener_thread = None
+            self._queue.close()
+            self._queue.join_thread()
+            self._queue = None
+
+        # Stop the progress bar if it's still active
+        if getattr(self, "_progress_bar", None) is not None:
+            try:
+                self._progress_bar.stop()
+                self._progress_bar = None
+            except Exception:
+                pass  # Already stopped or not running
+
+            self._pb_task_map.clear()
+
+    def add_program_to_executor(self, program):
+        self.futures.append(self._executor.submit(program.run))
+
+        if self._progress_bar is not None:
+            with self._pb_lock:
+                self._pb_task_map[program.job_id] = self._progress_bar.add_task(
+                    "",
+                    job_name=f"Job {program.job_id}",
+                    total=self.max_iterations,
+                    completed=0,
+                    poll_attempt=0,
+                    message="",
+                    final_status="",
+                    mode=("simulation" if self._is_local else "network"),
+                )
+
+    def run(self):
+        if self._executor is not None:
+            raise RuntimeError("A batch is already being run.")
+
+        if len(self.programs) == 0:
+            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,
+            )
+            if hasattr(self, "max_iterations")
+            else None
+        )
+
+        self._executor = ProcessPoolExecutor()
+        self.futures = []
+        self._pb_task_map = {}
+        self._pb_lock = Lock()
+
+        if self._progress_bar is not None:
+            self._progress_bar.start()
+            self._listener_thread = Thread(
+                target=queue_listener,
+                args=(
+                    self._queue,
+                    self._progress_bar,
+                    self._pb_task_map,
+                    self._done_event,
+                    self._is_jupyter,
+                    self._pb_lock,
+                ),
+                daemon=True,
+            )
+            self._listener_thread.start()
+
+        for program in self.programs.values():
+            self.add_program_to_executor(program)
+
+    def check_all_done(self):
+        return all(future.done() for future in self.futures)
+
+    def wait_for_all(self):
+        if self._executor is None:
+            return
+
+        exceptions = []
+        try:
+            # Ensure all futures are completed and handle exceptions.
+            for future in as_completed(self.futures):
+                try:
+                    future.result()  # Raises an exception if the task failed.
+                except Exception as e:
+                    exceptions.append(e)
+
+        finally:
+            self._executor.shutdown(wait=True, cancel_futures=False)
+            self._executor = None
+
+            if self._progress_bar is not None:
+                self._done_event.set()
+                self._listener_thread.join()
+
+        if exceptions:
+            for i, exc in enumerate(exceptions, 1):
+                print(f"Task {i} failed with exception:")
+                traceback.print_exception(type(exc), exc, exc.__traceback__)
+            raise RuntimeError("One or more tasks failed. Check logs for details.")
+
+        if self._progress_bar is not None:
+            self._progress_bar.stop()
+
+        self._total_circuit_count += sum(future.result()[0] for future in self.futures)
+        self._total_run_time += sum(future.result()[1] for future in self.futures)
+        self.futures = []
+
+    @abstractmethod
+    def aggregate_results(self):
+        raise NotImplementedError