From 8831782ed80a0e21adfc4cf6b3149286625c9317 Mon Sep 17 00:00:00 2001 From: KilianPoirier Date: Wed, 13 Sep 2023 09:45:58 +0000 Subject: [PATCH 01/28] Updated links in .rst format --- .../openqaoa_azure/openqaoa_azure_install.rst | 2 +- .../openqaoa_braket_install.rst | 4 +- docs/source/openqaoa_metapackage_install.rst | 57 ++++++++++--------- .../openqaoa_pyquil_install.rst | 4 +- .../openqaoa_qiskit_install.rst | 4 +- 5 files changed, 37 insertions(+), 34 deletions(-) diff --git a/docs/source/openqaoa_azure/openqaoa_azure_install.rst b/docs/source/openqaoa_azure/openqaoa_azure_install.rst index d5af9b0fc..3e7c6b63c 100644 --- a/docs/source/openqaoa_azure/openqaoa_azure_install.rst +++ b/docs/source/openqaoa_azure/openqaoa_azure_install.rst @@ -14,6 +14,6 @@ You can install the latest version of openqaoa-azure directly from PyPi. We reco Installation instructions for Developers ---------------------------------------- -OpenQAOA-Azure does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available [here]() +OpenQAOA-Azure does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available :ref:`here ` Should you face any issue during the installation, please drop us an email at openqaoa@entropicalabs.com or open an issue! \ No newline at end of file diff --git a/docs/source/openqaoa_braket/openqaoa_braket_install.rst b/docs/source/openqaoa_braket/openqaoa_braket_install.rst index 42f1a24b3..e940bb179 100644 --- a/docs/source/openqaoa_braket/openqaoa_braket_install.rst +++ b/docs/source/openqaoa_braket/openqaoa_braket_install.rst @@ -3,7 +3,7 @@ OpenQAOA Braket Installation Install via PyPI ---------------- -You can install the latest version of openqaoa-braket directly from PyPi. We recommend creating a virtual environment with `python>=3.8` first and then simply pip install openqaoa-braket with the following command. +You can install the latest version of openqaoa-braket directly from PyPi. We recommend creating a virtual environment with ``python>=3.8`` first and then simply pip install openqaoa-braket with the following command. **NOTE:** Installing ``openqaoa-braket`` installs ``openqaoa-core`` by default @@ -14,6 +14,6 @@ You can install the latest version of openqaoa-braket directly from PyPi. We rec Installation instructions for Developers ---------------------------------------- -OpenQAOA-Braket does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available [here]() +OpenQAOA-Braket does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available :ref:`here ` Should you face any issue during the installation, please drop us an email at openqaoa@entropicalabs.com or open an issue! \ No newline at end of file diff --git a/docs/source/openqaoa_metapackage_install.rst b/docs/source/openqaoa_metapackage_install.rst index 80d95cfe0..0d3d564ef 100644 --- a/docs/source/openqaoa_metapackage_install.rst +++ b/docs/source/openqaoa_metapackage_install.rst @@ -1,49 +1,52 @@ OpenQAOA Metapackage Installation ================================= - +.. _openqaoa: The following instructions install OpenQAOA along with all optional plugins -OpenQAOA is divided into separately installable plugins based on the requirements of the user. The core elements of the package are placed in `openqaoa-core` which comes pre-installed with each flavour of OpenQAOA. +OpenQAOA is divided into separately installable plugins based on the requirements of the user. The core elements of the package are placed in ``openqaoa-core`` which comes pre-installed with each flavour of OpenQAOA. + +Currently, OpenQAOA supports the following backends and each can be installed exclusively with the exception of ``openqaoa-azure`` which installs ``openqaoa-qiskit`` as an additional requirement because Azure backends support circuit submissions via `qiskit`. -Currently, OpenQAOA supports the following backends and each can be installed exclusively with the exception of `openqaoa-azure` which installs `openqaoa-qiskit` as an additional requirement because Azure backends support circuit submissions via `qiskit`. -- `openqaoa-braket` for AWS Braket -- `openqaoa-azure` for Microsoft Azure Quantum -- `openqaoa-pyquil` for Rigetti Pyquil -- `openqaoa-qiskit` for IBM Qiskit +- ``openqaoa-braket`` for AWS Braket +- ``openqaoa-azure`` for Microsoft Azure Quantum +- ``openqaoa-pyquil`` for Rigetti Pyquil +- ``openqaoa-qiskit`` for IBM Qiskit The OpenQAOA metapackage allows you to install all OpenQAOA plug-ins together. Install via PyPI ---------------- You can install the latest version of OpenQAOA directly from PyPI. First, create a virtual environment with python3.8, 3.9, 3.10 and then pip install openqaoa with the following command -``` -pip install openqaoa -``` +.. code-block:: bash + pip install openqaoa Install via git clone --------------------- Alternatively, you can install OpenQAOA manually from the GitHub repository by following the instructions below. -**NOTE:** We recommend creating a python virtual environment for this project using a python environment manager, for instance Anaconda. Instructions can be found [here](https://conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html#creating-an-environment-with-commands). Make sure to use **python 3.8** (or newer) for the environment. +**NOTE:** We recommend creating a python virtual environment for this project using a python environment manager, for instance Anaconda. Instructions can be found `here `_. Make sure to use **python 3.8** (or newer) for the environment. + 1. Clone the git repository: -``` -git clone https://github.com/entropicalabs/openqaoa.git -``` -2. After cloning the repository `cd openqaoa` and pip install the package with instructions from the Makefile as follows -``` -make local-install -``` + +.. code-block:: bash + git clone https://github.com/entropicalabs/openqaoa.git + +2. After cloning the repository ``cd openqaoa`` and pip install the package with instructions from the Makefile as follows + +.. code-block:: bash + make local-install Installation instructions for Developers ---------------------------------------- -Users can install OpenQAOA in the developer mode via the Makefile. For a clean editable install of the package run the following command from the `openqaoa` folder. -``` -make dev-install -``` -The package can be installed as an editable with extra requirements defined in the `setup.py`. If you would like to install the extra requirements to be able run the tests module or generate the docs, you can run the following - -``` -make dev-install-x, with x = {tests, docs, all} -``` +Users can install OpenQAOA in the developer mode via the Makefile. For a clean editable install of the package run the following command from the ``openqaoa`` folder. + +.. code-block:: bash + make dev-install + +The package can be installed as an editable with extra requirements defined in the ``setup.py``. If you would like to install the extra requirements to be able run the tests module or generate the docs, you can run the following + +.. code-block:: bash + make dev-install-x +with x = {tests, docs, all} Should you face any issue during the installation, please drop us an email at openqaoa@entropicalabs.com or open an issue! \ No newline at end of file diff --git a/docs/source/openqaoa_pyquil/openqaoa_pyquil_install.rst b/docs/source/openqaoa_pyquil/openqaoa_pyquil_install.rst index 484f67ece..a7b8f3c12 100644 --- a/docs/source/openqaoa_pyquil/openqaoa_pyquil_install.rst +++ b/docs/source/openqaoa_pyquil/openqaoa_pyquil_install.rst @@ -4,7 +4,7 @@ OpenQAOA Pyquil Installation Install via PyPI ---------------- -You can install the latest version of openqaoa-pyquil directly from PyPi. We recommend creating a virtual environment with `python>=3.8` first and then simply pip install openqaoa-pyquil with the following command. +You can install the latest version of openqaoa-pyquil directly from PyPi. We recommend creating a virtual environment with ``python>=3.8`` first and then simply pip install openqaoa-pyquil with the following command. **NOTE:** Installing ``openqaoa-pyquil`` installs ``openqaoa-core`` by default @@ -15,6 +15,6 @@ You can install the latest version of openqaoa-pyquil directly from PyPi. We rec Installation instructions for Developers ---------------------------------------- -OpenQAOA-Qiskit does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available [here]() +OpenQAOA-Qiskit does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available :ref:`here ` Should you face any issue during the installation, please drop us an email at openqaoa@entropicalabs.com or open an issue! diff --git a/docs/source/openqaoa_qiskit/openqaoa_qiskit_install.rst b/docs/source/openqaoa_qiskit/openqaoa_qiskit_install.rst index cebb0328b..af822b7c8 100644 --- a/docs/source/openqaoa_qiskit/openqaoa_qiskit_install.rst +++ b/docs/source/openqaoa_qiskit/openqaoa_qiskit_install.rst @@ -4,7 +4,7 @@ OpenQAOA Qiskit Installation Install via PyPI ---------------- -You can install the latest version of openqaoa-qiskit directly from PyPi. We recommend creating a virtual environment with `python>=3.8` first and then simply pip install openqaoa-qiskit with the following command. +You can install the latest version of openqaoa-qiskit directly from PyPi. We recommend creating a virtual environment with ``python>=3.8`` first and then simply pip install openqaoa-qiskit with the following command. **NOTE:** Installing ``openqaoa-qiskit`` installs ``openqaoa-core`` by default @@ -15,6 +15,6 @@ You can install the latest version of openqaoa-qiskit directly from PyPi. We rec Installation instructions for Developers ---------------------------------------- -OpenQAOA-Qiskit does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available [here]() +OpenQAOA-Qiskit does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available :ref:`here ` Should you face any issue during the installation, please drop us an email at openqaoa@entropicalabs.com or open an issue! \ No newline at end of file From b83b572ae20d10d776088865c5c2ff7436ae0f11 Mon Sep 17 00:00:00 2001 From: KilianPoirier Date: Wed, 13 Sep 2023 09:46:56 +0000 Subject: [PATCH 02/28] Updqted links in .rst format --- docs/source/openqaoa_core/openqaoa_core_install.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/openqaoa_core/openqaoa_core_install.rst b/docs/source/openqaoa_core/openqaoa_core_install.rst index 352b37ad9..dd98ba1ac 100644 --- a/docs/source/openqaoa_core/openqaoa_core_install.rst +++ b/docs/source/openqaoa_core/openqaoa_core_install.rst @@ -16,6 +16,6 @@ You can install the latest version of openqaoa-core directly from PyPi. We recom Installation instructions for Developers ---------------------------------------- -OpenQAOA-Core does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available [here]() +OpenQAOA-Core does not yet support developer install as a standalone package. If you wish to work in developer mode, please install the entire library. Instructions are available :ref:`here ` Should you face any issue during the installation, please drop us an email at openqaoa@entropicalabs.com or open an issue! \ No newline at end of file From 233efd9a19d303e5976bd66a74270af609fdb093 Mon Sep 17 00:00:00 2001 From: KilianPoirier Date: Wed, 13 Sep 2023 09:49:23 +0000 Subject: [PATCH 03/28] Updated documentation changelog (ref directly from CHANGELOG.md) + requirements --- docs/source/changelog.md | 2 ++ docs/source/changelog.rst | 7 ------- docs/source/conf.py | 1 + src/openqaoa-core/requirements_docs.txt | 3 ++- 4 files changed, 5 insertions(+), 8 deletions(-) create mode 100644 docs/source/changelog.md delete mode 100644 docs/source/changelog.rst diff --git a/docs/source/changelog.md b/docs/source/changelog.md new file mode 100644 index 000000000..edbd12b10 --- /dev/null +++ b/docs/source/changelog.md @@ -0,0 +1,2 @@ +```{include} ../../CHANGELOG.md +``` \ No newline at end of file diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst deleted file mode 100644 index 7ac20a342..000000000 --- a/docs/source/changelog.rst +++ /dev/null @@ -1,7 +0,0 @@ -Changelog -========= - -`v0.0.1-beta `__ (July 11, 2022) ------------------------------------------------------------------------------------------------------ - -- Initial beta release \ No newline at end of file diff --git a/docs/source/conf.py b/docs/source/conf.py index 9bc69cb66..fd1cd9c35 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -56,6 +56,7 @@ "IPython.sphinxext.ipython_console_highlighting", "nbsphinx", "sphinx.ext.intersphinx", + "myst_parser", ] autodoc_mock_imports = [ diff --git a/src/openqaoa-core/requirements_docs.txt b/src/openqaoa-core/requirements_docs.txt index 53ae73e39..fd7c6ca0f 100644 --- a/src/openqaoa-core/requirements_docs.txt +++ b/src/openqaoa-core/requirements_docs.txt @@ -3,4 +3,5 @@ sphinx-autodoc-typehints>=1.18.1 sphinx-rtd-theme>=1.0.0 nbsphinx>=0.8.9 ipython>=8.10.0 -nbconvert>=6.5.1 \ No newline at end of file +nbconvert>=6.5.1 +myst_parser>=2.0.0 \ No newline at end of file From 47b776779eddbcfa1e52e5ae518aeb91f88799c2 Mon Sep 17 00:00:00 2001 From: V Vijendran Date: Sun, 15 Oct 2023 19:11:11 +1100 Subject: [PATCH 04/28] Created and Partially Implemented a BPSP Problem Class --- src/openqaoa-core/openqaoa/problems/bpsp.py | 185 ++++++++++++++++++++ 1 file changed, 185 insertions(+) create mode 100644 src/openqaoa-core/openqaoa/problems/bpsp.py diff --git a/src/openqaoa-core/openqaoa/problems/bpsp.py b/src/openqaoa-core/openqaoa/problems/bpsp.py new file mode 100644 index 000000000..01ff6f28c --- /dev/null +++ b/src/openqaoa-core/openqaoa/problems/bpsp.py @@ -0,0 +1,185 @@ +import numpy as np +import networkx as nx +import matplotlib.pyplot as plt +from typing import Union +from docplex.mp.model import Model + +from .problem import Problem +from .converters import FromDocplex2IsingModel +from .qubo import QUBO + + +class BPSP(Problem): + + + __name__ = "Binary_Paint_Shop_Problem" + + def __init__(self, car_sequence): + + self.car_sequence = car_sequence + self._car_sequence = None + self.car_positions = self.get_pos() + self.bpsp_graph = self.construct_bpsp_graph() + + @property + def car_sequence(self): + return self._car_sequence + + @car_sequence.setter + def car_sequence(self, sequence): + # Check if each car ID appears exactly twice + unique_ids, counts = np.unique(sequence, return_counts=True) + if not all(count == 2 for count in counts): + raise ValueError("Each car ID must appear exactly twice in the sequence.") + + # Check if range of car IDs is continuous + if len(unique_ids) != (max(unique_ids) + 1): + raise ValueError("The range of car IDs must be continuous.") + + # If all checks pass, assign the sequence to the private attribute + self._car_sequence = sequence + + + @staticmethod + def random_instance(**kwargs): + """ + Generates a random instance of the BPSP problem, based on the specified number of cars. + + The function creates a list with two occurrences of each car ID, then applies the Fisher-Yates shuffle + to randomize the order of the cars. The shuffled sequence of cars is then used to create a BPSP instance. + + Parameters + ---------- + **kwargs: + num_cars: int + The number of distinct cars to be considered in the sequence. Each car will appear twice in the + final sequence. + + Returns + ------- + BPSP + A random instance of the BPSP problem, based on the shuffled sequence of cars. + """ + + # Extract the number of cars from the provided keyword arguments. + num_cars = kwargs.get("num_cars") + + # Generate a list with two occurrences of each car ID, i.e., [0, 1, ..., n, 0, 1, ..., n]. + car_sequence = np.array(list(range(num_cars)) + list(range(num_cars))) + + # Apply the Fisher-Yates shuffle to the car_sequence. + # Start from the end of the list and swap the current element with a randomly chosen earlier element. + for i in range(len(car_sequence)-1, 0, -1): + # Select a random index between 0 and i (inclusive). + j = np.random.randint(0, i+1) + # Swap the elements at indices i and j. + car_sequence[i], car_sequence[j] = car_sequence[j], car_sequence[i] + + # Return a BPSP instance using the shuffled car_sequence. + return BPSP(car_sequence) + + + def get_pos(self): + """ + Retrieve the positions of each car ID in the car sequence. + + This method tracks the occurrences of each car ID in the car sequence. + Since each car ID is expected to appear twice in the sequence, the method + returns a dictionary where keys are car IDs and values are tuples with the + positions of the two occurrences. + + Returns + ------- + dict + A dictionary where keys are car IDs and values are tuples with the positions + of the two occurrences. For example, for a sequence [0, 1, 0, 1], the + output would be {0: (0, 2), 1: (1, 3)}. + """ + + # Initialize an empty dictionary to store car positions. + car_pos = {} + + # Enumerate through each car ID in the sequence to track its positions. + for idx, car in enumerate(self.car_sequence): + # If the car ID is already in the dictionary, append the new position. + if car in car_pos: + car_pos[car].append(idx) + # If this is the first occurrence of the car ID, initialize a list with the position. + else: + car_pos[car] = [idx] + + # Convert the lists of positions to tuples for a consistent output format. + for car, positions in car_pos.items(): + car_pos[car] = tuple(positions) + + return car_pos + + + def construct_bpsp_graph(self): + """ + Construct a graph to represent the Binary Paint Shop Problem (BPSP) using the Ising model. + + This function takes a car sequence from the instance and translates it to an Ising graph. + In the graph, nodes represent cars, and edges represent the interaction between two consecutive + cars in the sequence. The weight on each edge indicates the interaction strength and sign. + + Returns + ------- + ising_graph : nx.Graph + A graph representing the Ising model for the BPSP based on the car sequence of the instance. + + Notes + ----- + The interaction strength is determined based on how many times the cars appeared + in the sequence before the current pair. + """ + + # Number of distinct cars in the sequence. + num_cars = int(len(self.car_sequence) / 2) + + # A list to count occurrences of each car as the sequence is processed. + car_occurrences = [0] * num_cars + + # Dictionary to hold edges and their weights. + graph = {} + + # Helper function to add or update an edge in the graph. + def add_edge(u, v, weight): + # Sort the vertices to maintain a consistent edge representation. + edge = (u, v) if u < v else (v, u) + # Add the weight or update the existing weight of the edge. + graph[edge] = graph.get(edge, 0) + weight + + # Process each pair of cars in the sequence. + for i in range(len(self.car_sequence) - 1): + # Get the current car pair. + car1, car2 = self.car_sequence[i], self.car_sequence[i+1] + + # Get the occurrences of the cars in the sequence so far. + occ_car1, occ_car2 = car_occurrences[car1], car_occurrences[car2] + + # Calculate the interaction weight based on car occurrences. + weight = (-1)**(occ_car1 + occ_car2 + 1) + + # Add or update the graph with the edge and its weight. + add_edge(car1, car2, weight) + + # Update the occurrence count for the first car of the current pair. + car_occurrences[car1] += 1 + + # Construct the final Ising graph with non-zero weights. + ising_graph = nx.Graph() + + # Add edges without self-loops to the graph. + for (u, v), weight in graph.items(): + if u != v: + ising_graph.add_edge(u, v, weight=weight) + + # Ensure all car nodes are in the graph, even if they don't have any edges. + ising_graph.add_nodes_from(range(num_cars)) + + return ising_graph + + + + From 5d88ca9bdb880e6fea7711c10cd4ee8546f4f532 Mon Sep 17 00:00:00 2001 From: V Vijendran Date: Sun, 15 Oct 2023 19:24:03 +1100 Subject: [PATCH 05/28] Added CPLEX Model for BPSP --- src/openqaoa-core/openqaoa/problems/bpsp.py | 54 +++++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/src/openqaoa-core/openqaoa/problems/bpsp.py b/src/openqaoa-core/openqaoa/problems/bpsp.py index 01ff6f28c..6ea34a1d2 100644 --- a/src/openqaoa-core/openqaoa/problems/bpsp.py +++ b/src/openqaoa-core/openqaoa/problems/bpsp.py @@ -179,6 +179,60 @@ def add_edge(u, v, weight): ising_graph.add_nodes_from(range(num_cars)) return ising_graph + + @property + def docplex_bpsp_model(self): + """ + Construct a CPLEX model for the Binary Paint Shop Problem (BPSP). + + This method encodes the BPSP into a linear optimization problem. + The BPSP seeks to determine a painting sequence for cars such that adjacent cars + in the sequence don't receive the same color if they are the same car type. + The sequence length is twice the number of cars as each car passes the painting station twice. + + The decision variables represent the paint color (binary: 0 or 1) for each car at each position in the sequence. + The objective function aims to minimize the absolute difference between adjacent paint values in the sequence. + + Attributes + ---------- + car_sequence : list + A list representing the sequence of cars as they pass the paint shop. + Each car is represented by its identifier (e.g., integer), and appears twice in the sequence. + + car_positions : dict + A dictionary mapping each car to its two positions in the car_sequence. + For example, if car 'a' appears in positions 2 and 5 in car_sequence, then + car_positions['a'] = [2, 5]. + + Returns + ------- + Model + A CPLEX model instance representing the BPSP, ready to be solved. + """ + + mdl = Model("BPSP_Problem") + sequence = self.car_sequence + car_pos = self.car_positions + + # Dictionary for storing the paint value for car 'x' at position 'j'. + w_vars = {f"{w}_{i}": mdl.binary_var(name=f"w_{w}_{i}") for i, w in enumerate(sequence)} + + # This loop adds the constraint that a particular car cannot have the same paint + # at both occurrences in the paint sequence. If the first occurrence is 0, the other has to + # be 1 and vice-versa. + for car, positions in car_pos.items(): + w_key1, w_key2 = f"{car}_{positions[0]}", f"{car}_{positions[1]}" + mdl.add_constraint(w_vars[w_key1] + w_vars[w_key2] == 1) + + # Encode the objective function: sum_i^2n-1 |paint[i] - paint[i+1]|. Since docplex accepts abs operator, + # you can directly utilize it for the objective. This makes the model simpler than in Gurobi. + w_keys = list(w_vars.keys()) + objective_function = mdl.sum(mdl.abs(w_vars[w_keys[i]] - w_vars[w_keys[i + 1]]) for i in range(len(w_keys) - 1)) + + # Set the objective to minimize. + mdl.minimize(objective_function) + + return mdl From c36e8b2f29d2f9279973e8c9351fd90682f80684 Mon Sep 17 00:00:00 2001 From: V Vijendran Date: Sun, 15 Oct 2023 19:33:28 +1100 Subject: [PATCH 06/28] Added QUBO Encoding of BPSP --- src/openqaoa-core/openqaoa/problems/bpsp.py | 27 +++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/src/openqaoa-core/openqaoa/problems/bpsp.py b/src/openqaoa-core/openqaoa/problems/bpsp.py index 6ea34a1d2..529b2d76d 100644 --- a/src/openqaoa-core/openqaoa/problems/bpsp.py +++ b/src/openqaoa-core/openqaoa/problems/bpsp.py @@ -235,5 +235,32 @@ def docplex_bpsp_model(self): return mdl + @property + def qubo(self): + """ + Returns the QUBO encoding of the Binary Paint Shop Problem. + + This function provides a QUBO representation of the BPSP, where the objective is to minimize the + total weight of violations. The violations here refer to two adjacent cars in the sequence receiving + the same color. + + Returns + ------- + QUBO + The QUBO encoding of the BPSP. This is a representation that describes + the quadratic objective function over binary variables. + """ + + # Iterate over edges (with weight) and store accordingly + terms = [] + weights = [] + + # Here, we use self.bpsp_graph to gather terms and weights. + for u, v, edge_weight in self.bpsp_graph.edges(data="weight"): + terms.append([u, v]) + + weights.append(edge_weight) + + return QUBO(self.bpsp_graph.number_of_nodes(), terms, weights) From 620db83bc83871895c741b38971d84792eacf530 Mon Sep 17 00:00:00 2001 From: V Vijendran Date: Mon, 16 Oct 2023 11:54:12 +1100 Subject: [PATCH 07/28] Added Classical Solution Function --- src/openqaoa-core/openqaoa/problems/bpsp.py | 25 ++++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) diff --git a/src/openqaoa-core/openqaoa/problems/bpsp.py b/src/openqaoa-core/openqaoa/problems/bpsp.py index 529b2d76d..0b3455dcc 100644 --- a/src/openqaoa-core/openqaoa/problems/bpsp.py +++ b/src/openqaoa-core/openqaoa/problems/bpsp.py @@ -5,7 +5,6 @@ from docplex.mp.model import Model from .problem import Problem -from .converters import FromDocplex2IsingModel from .qubo import QUBO @@ -264,3 +263,27 @@ def qubo(self): return QUBO(self.bpsp_graph.number_of_nodes(), terms, weights) + def classical_solution(self, string: bool = False): + """ + Solves the SK problem and returns the CPLEX solution. + + Returns + ------- + solution : dict + A dictionary containing the solution found with spin values. + """ + model = self.docplex_model + model.solve() + status = model.solve_details.status + if status != "integer optimal solution": + print(status) + if string: + return "".join( + str(round(model.solution.get_value(var))) + for var in model.iter_binary_vars() + ) + else: + return { + var.name: model.solution.get_value(var) + for var in model.iter_binary_vars() + } \ No newline at end of file From e9a682577614be936655275b974fea26836d6e45 Mon Sep 17 00:00:00 2001 From: V Vijendran Date: Mon, 16 Oct 2023 12:03:07 +1100 Subject: [PATCH 08/28] Modified Init File in Problems --- src/openqaoa-core/openqaoa/problems/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/openqaoa-core/openqaoa/problems/__init__.py b/src/openqaoa-core/openqaoa/problems/__init__.py index adaafb6ef..eabe523e7 100644 --- a/src/openqaoa-core/openqaoa/problems/__init__.py +++ b/src/openqaoa-core/openqaoa/problems/__init__.py @@ -9,6 +9,7 @@ from .binpacking import BinPacking from .vehiclerouting import VRP from .sherrington_kirkpatrick import SK +from .bpsp import BPSP from .kcolor import KColor from .converters import FromDocplex2IsingModel from .qubo import QUBO From 8f81308fa0ea8fa0fe9eba565e36cb2a9b718dd6 Mon Sep 17 00:00:00 2001 From: V Vijendran Date: Mon, 16 Oct 2023 18:53:28 +1100 Subject: [PATCH 09/28] Fixed Some Bugs --- src/openqaoa-core/openqaoa/problems/bpsp.py | 17 +++-------------- 1 file changed, 3 insertions(+), 14 deletions(-) diff --git a/src/openqaoa-core/openqaoa/problems/bpsp.py b/src/openqaoa-core/openqaoa/problems/bpsp.py index 0b3455dcc..c39f5500e 100644 --- a/src/openqaoa-core/openqaoa/problems/bpsp.py +++ b/src/openqaoa-core/openqaoa/problems/bpsp.py @@ -16,7 +16,6 @@ class BPSP(Problem): def __init__(self, car_sequence): self.car_sequence = car_sequence - self._car_sequence = None self.car_positions = self.get_pos() self.bpsp_graph = self.construct_bpsp_graph() @@ -65,7 +64,6 @@ def random_instance(**kwargs): # Generate a list with two occurrences of each car ID, i.e., [0, 1, ..., n, 0, 1, ..., n]. car_sequence = np.array(list(range(num_cars)) + list(range(num_cars))) - # Apply the Fisher-Yates shuffle to the car_sequence. # Start from the end of the list and swap the current element with a randomly chosen earlier element. for i in range(len(car_sequence)-1, 0, -1): @@ -263,7 +261,7 @@ def qubo(self): return QUBO(self.bpsp_graph.number_of_nodes(), terms, weights) - def classical_solution(self, string: bool = False): + def classical_solution(self): """ Solves the SK problem and returns the CPLEX solution. @@ -272,18 +270,9 @@ def classical_solution(self, string: bool = False): solution : dict A dictionary containing the solution found with spin values. """ - model = self.docplex_model + model = self.docplex_bpsp_model model.solve() status = model.solve_details.status if status != "integer optimal solution": print(status) - if string: - return "".join( - str(round(model.solution.get_value(var))) - for var in model.iter_binary_vars() - ) - else: - return { - var.name: model.solution.get_value(var) - for var in model.iter_binary_vars() - } \ No newline at end of file + return [int(model.solution.get_value(var)) for var in model.iter_binary_vars()] \ No newline at end of file From 4e6598a219c83936c01d63afa97a5b69dfaec055 Mon Sep 17 00:00:00 2001 From: V Vijendran Date: Mon, 16 Oct 2023 20:17:13 +1100 Subject: [PATCH 10/28] Finished bpsp.py --- src/openqaoa-core/openqaoa/problems/bpsp.py | 334 +++++++++++++++++++- 1 file changed, 319 insertions(+), 15 deletions(-) diff --git a/src/openqaoa-core/openqaoa/problems/bpsp.py b/src/openqaoa-core/openqaoa/problems/bpsp.py index c39f5500e..dcb0299e6 100644 --- a/src/openqaoa-core/openqaoa/problems/bpsp.py +++ b/src/openqaoa-core/openqaoa/problems/bpsp.py @@ -1,30 +1,137 @@ +""" +bpsp.py + +This module provides an implementation for the Binary Paint Shop Problem (BPSP), a combinatorial optimization problem arising from automotive paint shops. +Given a fixed sequence of cars, each requiring two distinct colors, the objective is to determine the order of painting such that color changes between +adjacent cars are minimized. The problem is NP-hard, and approximating it is also challenging. The module offers various solution strategies, including +greedy and quantum approximate optimization approaches. + +This implementation is based on the following works: + - "Beating classical heuristics for the binary paint shop problem with the + quantum approximate optimization algorithm" + (https://journals.aps.org/pra/abstract/10.1103/PhysRevA.104.012403) + - "Some heuristics for the binary paint shop problem and their expected number + of colour changes" + (https://www.sciencedirect.com/science/article/pii/S1570866710000559) + - Upcoming/unpublished work by V Vijendran et al. + +Author: V Vijendran (Vijey) +GitHub: https://github.com/vijeycreative +Email: v.vijendran@anu.edu.au +""" + + import numpy as np import networkx as nx import matplotlib.pyplot as plt -from typing import Union from docplex.mp.model import Model +from collections import defaultdict from .problem import Problem from .qubo import QUBO class BPSP(Problem): + """ + Binary Paint Shop Problem (BPSP) + + This class is dedicated to solving the Binary Paint Shop Problem (BPSP), a combinatorial + optimization challenge drawn from an automotive paint shop context. In this problem, there + exists a specific sequence of cars, with each car making two appearances in the sequence. + The primary objective is to find the best coloring sequence such that consecutive cars in the + sequence necessitate the fewest color switches. + When initializing, the solver accepts a list of car numbers indicative of a valid BPSP instance + and subsequently establishes a Binary Paint Shop Problem instance based on this. + + To elaborate on the problem: + + Imagine we have 'n' distinct cars, labeled as c_1, c_2, ..., c_n. These cars are presented + in a sequence of length '2n', such that each car c_i makes two appearances. This sequence + is represented as w_1, w_2, ..., w_2n, with every w_i being one of the cars from the set. + + The challenge further presents two paint colors, represented as 1 and 2. For every car + in the sequence, a decision must be made on which color to paint it first, resulting in a + color assignment sequence like f_1, f_2, ..., f_2n. It's crucial to ensure that if two + occurrences in the sequence pertain to the same car, their color designations differ. + + The main goal is to choose a sequence of colors such that we minimize the instances where + consecutive cars require different paint colors. This is quantified by computing the difference + between color assignments for consecutive cars and aggregating this difference for the entire sequence. + """ __name__ = "Binary_Paint_Shop_Problem" def __init__(self, car_sequence): + """ + Initialize the Binary Paint Shop Problem (BPSP) instance. + + Parameters: + - car_sequence : list[int] + A list of integers representing car numbers, denoting the sequence + in which cars appear in the BPSP. Each car number appears exactly + twice, symbolizing the two distinct color coatings each car requires. + + Attributes Set: + - self.car_sequence : list[int] + Stores the sequence of car numbers. + + - self.car_positions : dict[int, tuple] + Maps each car number to a tuple of its two positions in the car_sequence. + Determined by the `car_pos` property. + + - self.bpsp_graph : networkx.Graph + Represents the BPSP as a graph where nodes are car positions and edges + indicate adjacent car positions in the sequence. Constructed by the + `construct_bpsp_graph` method. + + Returns: + None + """ self.car_sequence = car_sequence - self.car_positions = self.get_pos() - self.bpsp_graph = self.construct_bpsp_graph() + self.car_positions = self.car_pos + self.bpsp_graph = self.construct_bpsp_graph + @property def car_sequence(self): + """ + Getter for the 'car_sequence' property. + + This method retrieves the current value of the `_car_sequence` attribute, which represents + the sequence of cars to be painted. Each car is identified by a unique integer ID, + and each ID must appear exactly twice in the sequence, indicating the two times the car + is painted. + + Returns: + ------- + list[int] + The current sequence of car IDs. Each ID appears exactly twice in the sequence. + """ return self._car_sequence @car_sequence.setter def car_sequence(self, sequence): + """ + Setter for the 'car_sequence' property. + + This method validates and sets a new value for the `_car_sequence` attribute. + The validation ensures: + 1. Each car ID appears exactly twice in the sequence. + 2. The range of car IDs is continuous (e.g., for IDs 0, 1, 2, both 0 and 2 cannot appear without 1). + + Parameters: + ---------- + sequence : list[int] + A new sequence of car IDs to be assigned to `_car_sequence`. + + Raises: + ------ + ValueError: + If any of the validation checks fail, a ValueError is raised with an appropriate error message. + + """ # Check if each car ID appears exactly twice unique_ids, counts = np.unique(sequence, return_counts=True) if not all(count == 2 for count in counts): @@ -36,7 +143,6 @@ def car_sequence(self, sequence): # If all checks pass, assign the sequence to the private attribute self._car_sequence = sequence - @staticmethod def random_instance(**kwargs): @@ -75,8 +181,8 @@ def random_instance(**kwargs): # Return a BPSP instance using the shuffled car_sequence. return BPSP(car_sequence) - - def get_pos(self): + @property + def car_pos(self): """ Retrieve the positions of each car ID in the car sequence. @@ -111,8 +217,8 @@ def get_pos(self): return car_pos - - def construct_bpsp_graph(self): + @property + def bpsp_graph(self): """ Construct a graph to represent the Binary Paint Shop Problem (BPSP) using the Ising model. @@ -231,7 +337,6 @@ def docplex_bpsp_model(self): return mdl - @property def qubo(self): """ @@ -260,19 +365,218 @@ def qubo(self): return QUBO(self.bpsp_graph.number_of_nodes(), terms, weights) - - def classical_solution(self): + def cplex_solution(self): """ - Solves the SK problem and returns the CPLEX solution. + Solves the BPSP using the CPLEX solver and returns the solution and its objective value. + + The Binary Paintshop Problem (BPSP) solution represents a sequence of paint choices + where a value of 0 represents blue paint and a value of 1 represents red paint. Returns ------- - solution : dict - A dictionary containing the solution found with spin values. + tuple + A tuple where the first element is a list containing the paint choices + (0 for blue, 1 for red) and the second element is the objective value. """ + + # Retrieve the model for BPSP model = self.docplex_bpsp_model + + # Solve the BPSP using CPLEX model.solve() + + # Check the status of the solution status = model.solve_details.status if status != "integer optimal solution": print(status) - return [int(model.solution.get_value(var)) for var in model.iter_binary_vars()] \ No newline at end of file + + # Extract the solution values representing paint choices + solution = [int(model.solution.get_value(var)) for var in model.iter_binary_vars()] + + # Get the objective value of the solution + objective_value = model.objective_value + + # Return the paint choices and their corresponding objective value + return solution, objective_value + + def qaoa_solution(self, bitstring): + """ + Transforms a sequence of initial car colors to a paint sequence and computes the number of paint swaps. + + Given a bitstring sequence of car colors ('0' or '1'), this function transforms it into + a paint sequence. Each car's colors are determined by two consecutive positions in + the sequence. The function also computes the number of times the paint changes (swaps) + between consecutive positions in the paint sequence. + + Parameters + ---------- + colors : str + A string of car colors where each character is either '0' or '1'. + + Returns + ------- + tuple + A tuple where the first element is a list representing the paint sequence + (0 for blue, 1 for red) and the second element is the number of paint swaps. + """ + + # Convert the input string colors to a list of integers + colors = [int(color) for color in bitstring] + + # Initialize the paint sequence with zeros + paint_sequence = [0 for _ in range(2 * len(colors))] + + # Fill the paint sequence based on the input colors and car positions + for car, color in enumerate(colors): + pos1, pos2 = self.car_positions[car] + + paint_sequence[pos1] = color + paint_sequence[pos2] = 1 - color # The opposite color + + # Compute the number of paint swaps in the sequence + color_swaps = sum(abs(paint_sequence[i] - paint_sequence[i + 1]) for i in range(len(paint_sequence) - 1)) + + return paint_sequence, color_swaps + + def red_first_solution(self): + """ + The `red_first_solution` method applies a heuristic to generate a paint sequence for cars. + Specifically, it colors the first occurrence of each car as Red (1) and the second + occurrence as Blue (0). On average, this heuristic may not be as efficient as the greedy + algorithm. + + Attributes: + ---------- + self.car_sequence : list[int] + A list containing the sequence of cars that need to be painted. + + Returns: + ------- + tuple + A tuple containing two elements: + 1. A list representing the paint sequence with '1' indicating Red and '0' indicating Blue. + 2. An integer representing the total number of paint swaps in the sequence. + """ + + # Dictionary to keep track of whether a car has been painted or not + cars_painted = defaultdict(bool) + + # Create the paint sequence + paint_sequence = [] + for car in self.car_sequence: + if not cars_painted[car]: + paint_sequence.append(1) + cars_painted[car] = True + else: + paint_sequence.append(0) + + # Compute the number of color swaps in the sequence + color_swaps = sum(abs(paint_sequence[i] - paint_sequence[i + 1]) for i in range(len(self.car_sequence) - 1)) + + return paint_sequence, color_swaps + + def greedy_solution(self): + """ + The `greedy_solution` method determines a feasible paint sequence for cars using a + greedy approach. It processes the car sequence from left to right, coloring the + first occurrence of each car based on its predecessor and the second occurrence + with the opposite color. + + Attributes: + ---------- + self.car_sequence : list[int] + A list containing the sequence of cars that need to be painted. + self.car_positions : dict[int, tuple] + A dictionary mapping each car to a tuple containing the + first and second position of the car's occurrence in `car_sequence`. + + Returns: + ------- + tuple + A tuple containing two elements: + 1. A list representing the paint sequence with '1' indicating Red and '0' indicating Blue. + 2. An integer representing the total number of paint swaps in the sequence. + """ + + # Dictionary to keep track of whether a car has been painted or not + cars_painted = defaultdict(bool) + + # List to store the paint sequence + paint_sequence = [] + + # Variable to keep track of the last used color + last_color = 0 + + # Create the paint sequence + for car in self.car_sequence: + if not cars_painted[car]: + if paint_sequence: # if paint_sequence is not empty + last_color = paint_sequence[-1] + paint_sequence.append(last_color) + cars_painted[car] = True + else: + paint_sequence.append(1 - paint_sequence[self.car_positions[car][0]]) + + # Compute the number of color swaps in the sequence + color_swaps = sum(abs(paint_sequence[i] - paint_sequence[i + 1]) for i in range(len(self.car_sequence) - 1)) + + return paint_sequence, color_swaps + + def plot_colored_cars(self, paint_sequence, ax=None): + """ + Plot a bar chart showing the colors assigned to cars based on the given paint_sequence. + + Parameters: + ---------- + self.car_sequence : list[int] + List containing the order of cars to be painted. + + paint_sequence : list[int] + List containing 0 or 1 for each car in `self.car_sequence`. A 0 indicates the car + is painted Blue, while a 1 indicates it's painted Red. + + ax : matplotlib.axes.Axes, optional + Axes object to plot on. If not provided, a new figure is created. + + Returns: + ------- + None + + Note: + ----- + This function uses a blue-red color mapping and plots bars without any gaps to visually + represent the paint sequence of cars. The plot's size is dynamically adjusted based on + the number of cars. + """ + + # Define color mapping for 0s and 1s in the paint_sequence to 'blue' and 'red' respectively + color_map = {0: '#f25c54', 1: '#48cae4'} # shades of blue and red + plot_colors = [color_map[color] for color in paint_sequence] + + # Dynamically determine the width of the figure based on the number of cars in self.car_sequence + fig_width = len(self.car_sequence) * 0.8 # This provides each bar approximately 0.8 inch width + + # If no ax (subplot) is provided, create a new figure with the determined width + if ax is None: + fig, ax = plt.subplots(figsize=(fig_width, 2)) + + # Plot bars for each car, colored based on the paint_sequence + ax.bar(self.car_sequence, [1]*len(self.car_sequence), color=plot_colors, width=1, align='center') + ax.set_title("BPSP Solution") + ax.set_xlim(min(self.car_sequence)-0.5, max(self.car_sequence)+0.5) # Set x limits to tightly fit bars + ax.set_ylim(0, 1) # Set y limits from 0 to 1 as the bars have a fixed height of 1 + ax.yaxis.set_visible(False) # Hide the y-axis as it's not relevant + + # Set x-ticks to indicate car numbers and label them as "Car 1", "Car 2", etc. + ax.set_xticks(self.car_sequence) + ax.set_xticklabels([f"Car {car}" for car in self.car_sequence]) + + # Hide the top, right, and left spines for cleaner visuals + ax.spines['top'].set_visible(False) + ax.spines['right'].set_visible(False) + ax.spines['left'].set_visible(False) + + # If no ax is provided, show the plot directly + if ax is None: + plt.tight_layout() + plt.show() \ No newline at end of file From 3d2b0967788b35997c9dbd63a638bd470da59505 Mon Sep 17 00:00:00 2001 From: V Vijendran Date: Mon, 16 Oct 2023 20:29:09 +1100 Subject: [PATCH 11/28] Fixed Some Bug --- src/openqaoa-core/openqaoa/problems/bpsp.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/openqaoa-core/openqaoa/problems/bpsp.py b/src/openqaoa-core/openqaoa/problems/bpsp.py index dcb0299e6..fd9bdf669 100644 --- a/src/openqaoa-core/openqaoa/problems/bpsp.py +++ b/src/openqaoa-core/openqaoa/problems/bpsp.py @@ -83,7 +83,7 @@ def __init__(self, car_sequence): - self.bpsp_graph : networkx.Graph Represents the BPSP as a graph where nodes are car positions and edges indicate adjacent car positions in the sequence. Constructed by the - `construct_bpsp_graph` method. + `bpsp_graph` method. Returns: None @@ -91,7 +91,7 @@ def __init__(self, car_sequence): self.car_sequence = car_sequence self.car_positions = self.car_pos - self.bpsp_graph = self.construct_bpsp_graph + self.bpsp_graph = self.graph @property @@ -218,7 +218,7 @@ def car_pos(self): return car_pos @property - def bpsp_graph(self): + def graph(self): """ Construct a graph to represent the Binary Paint Shop Problem (BPSP) using the Ising model. @@ -438,7 +438,7 @@ def qaoa_solution(self, bitstring): return paint_sequence, color_swaps - def red_first_solution(self): + def redfirst_solution(self): """ The `red_first_solution` method applies a heuristic to generate a paint sequence for cars. Specifically, it colors the first occurrence of each car as Red (1) and the second @@ -522,7 +522,7 @@ def greedy_solution(self): return paint_sequence, color_swaps - def plot_colored_cars(self, paint_sequence, ax=None): + def plot_paint_sequence(self, paint_sequence, ax=None): """ Plot a bar chart showing the colors assigned to cars based on the given paint_sequence. From 2ee0c58aedaf23b4c60159f97f6a93ff3e3f68b5 Mon Sep 17 00:00:00 2001 From: V Vijendran Date: Mon, 16 Oct 2023 20:32:45 +1100 Subject: [PATCH 12/28] Fixed Plotting Function to Work with Numpy Arrays --- src/openqaoa-core/openqaoa/problems/bpsp.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/openqaoa-core/openqaoa/problems/bpsp.py b/src/openqaoa-core/openqaoa/problems/bpsp.py index fd9bdf669..c7e8ff2a2 100644 --- a/src/openqaoa-core/openqaoa/problems/bpsp.py +++ b/src/openqaoa-core/openqaoa/problems/bpsp.py @@ -528,12 +528,12 @@ def plot_paint_sequence(self, paint_sequence, ax=None): Parameters: ---------- - self.car_sequence : list[int] - List containing the order of cars to be painted. + self.car_sequence : numpy.ndarray[int] + Numpy array containing the order of cars to be painted. - paint_sequence : list[int] - List containing 0 or 1 for each car in `self.car_sequence`. A 0 indicates the car - is painted Blue, while a 1 indicates it's painted Red. + paint_sequence : list[int] or numpy.ndarray[int] + List or numpy array containing 0 or 1 for each car in `self.car_sequence`. + A 0 indicates the car is painted Blue, while a 1 indicates it's painted Red. ax : matplotlib.axes.Axes, optional Axes object to plot on. If not provided, a new figure is created. @@ -554,22 +554,22 @@ def plot_paint_sequence(self, paint_sequence, ax=None): plot_colors = [color_map[color] for color in paint_sequence] # Dynamically determine the width of the figure based on the number of cars in self.car_sequence - fig_width = len(self.car_sequence) * 0.8 # This provides each bar approximately 0.8 inch width + fig_width = self.car_sequence.size * 0.8 # This provides each bar approximately 0.8 inch width # If no ax (subplot) is provided, create a new figure with the determined width if ax is None: fig, ax = plt.subplots(figsize=(fig_width, 2)) # Plot bars for each car, colored based on the paint_sequence - ax.bar(self.car_sequence, [1]*len(self.car_sequence), color=plot_colors, width=1, align='center') + ax.bar(self.car_sequence, np.ones_like(self.car_sequence), color=plot_colors, width=1, align='center') ax.set_title("BPSP Solution") - ax.set_xlim(min(self.car_sequence)-0.5, max(self.car_sequence)+0.5) # Set x limits to tightly fit bars + ax.set_xlim(np.min(self.car_sequence)-0.5, np.max(self.car_sequence)+0.5) # Set x limits to tightly fit bars ax.set_ylim(0, 1) # Set y limits from 0 to 1 as the bars have a fixed height of 1 ax.yaxis.set_visible(False) # Hide the y-axis as it's not relevant # Set x-ticks to indicate car numbers and label them as "Car 1", "Car 2", etc. ax.set_xticks(self.car_sequence) - ax.set_xticklabels([f"Car {car}" for car in self.car_sequence]) + ax.set_xticklabels([f"Car {int(car)}" for car in self.car_sequence]) # Hide the top, right, and left spines for cleaner visuals ax.spines['top'].set_visible(False) From c40eb0052fdfb28bd49d5cd73c9026f9155bf131 Mon Sep 17 00:00:00 2001 From: KilianPoirier Date: Mon, 16 Oct 2023 09:33:20 +0000 Subject: [PATCH 13/28] Updated documentation generation --- docs/requirements.txt | 2 ++ docs/source/changelog.md | 4 +++- docs/source/conf.py | 4 ++++ docs/source/openqaoa_metapackage_install.rst | 20 ++++++++++++++++---- 4 files changed, 25 insertions(+), 5 deletions(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index e161750e8..f0dc39b3c 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -12,3 +12,5 @@ amazon-braket-sdk==1.23.0 autograd>=1.4 semantic_version>=2.10 autoray>=0.3.1 +myst_parser>=2.0.0 +# myst_nb diff --git a/docs/source/changelog.md b/docs/source/changelog.md index edbd12b10..28b04b845 100644 --- a/docs/source/changelog.md +++ b/docs/source/changelog.md @@ -1,2 +1,4 @@ +# CHANGELOG + ```{include} ../../CHANGELOG.md -``` \ No newline at end of file +``` \ No newline at end of file diff --git a/docs/source/conf.py b/docs/source/conf.py index fd1cd9c35..892317a6e 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -57,6 +57,7 @@ "nbsphinx", "sphinx.ext.intersphinx", "myst_parser", + # "myst_nb", ] autodoc_mock_imports = [ @@ -125,3 +126,6 @@ # def setup(app): # app.connect(skip) + +# pygments_style = 'sphinx' +# suppress_warnings = ["myst_header"] \ No newline at end of file diff --git a/docs/source/openqaoa_metapackage_install.rst b/docs/source/openqaoa_metapackage_install.rst index 0d3d564ef..c9e797acc 100644 --- a/docs/source/openqaoa_metapackage_install.rst +++ b/docs/source/openqaoa_metapackage_install.rst @@ -1,6 +1,7 @@ OpenQAOA Metapackage Installation ================================= .. _openqaoa: + The following instructions install OpenQAOA along with all optional plugins OpenQAOA is divided into separately installable plugins based on the requirements of the user. The core elements of the package are placed in ``openqaoa-core`` which comes pre-installed with each flavour of OpenQAOA. @@ -18,7 +19,9 @@ Install via PyPI ---------------- You can install the latest version of OpenQAOA directly from PyPI. First, create a virtual environment with python3.8, 3.9, 3.10 and then pip install openqaoa with the following command .. code-block:: bash - pip install openqaoa + +pip install openqaoa + Install via git clone --------------------- @@ -29,24 +32,33 @@ Alternatively, you can install OpenQAOA manually from the GitHub repository by f 1. Clone the git repository: .. code-block:: bash + git clone https://github.com/entropicalabs/openqaoa.git + 2. After cloning the repository ``cd openqaoa`` and pip install the package with instructions from the Makefile as follows .. code-block:: bash + make local-install + Installation instructions for Developers ---------------------------------------- Users can install OpenQAOA in the developer mode via the Makefile. For a clean editable install of the package run the following command from the ``openqaoa`` folder. -.. code-block:: bash +.. code-block:: bash + make dev-install - + + The package can be installed as an editable with extra requirements defined in the ``setup.py``. If you would like to install the extra requirements to be able run the tests module or generate the docs, you can run the following .. code-block:: bash + make dev-install-x + + with x = {tests, docs, all} -Should you face any issue during the installation, please drop us an email at openqaoa@entropicalabs.com or open an issue! \ No newline at end of file +Should you face any issue during the installation, please drop us an email at openqaoa@entropicalabs.com or open an issue! From fd61c873b26431568f4402a9fe228bc12ebe2dae Mon Sep 17 00:00:00 2001 From: V Vijendran Date: Mon, 16 Oct 2023 21:00:01 +1100 Subject: [PATCH 14/28] Fixed Plot Paint Sequence --- src/openqaoa-core/openqaoa/problems/bpsp.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/openqaoa-core/openqaoa/problems/bpsp.py b/src/openqaoa-core/openqaoa/problems/bpsp.py index c7e8ff2a2..908abda72 100644 --- a/src/openqaoa-core/openqaoa/problems/bpsp.py +++ b/src/openqaoa-core/openqaoa/problems/bpsp.py @@ -561,14 +561,13 @@ def plot_paint_sequence(self, paint_sequence, ax=None): fig, ax = plt.subplots(figsize=(fig_width, 2)) # Plot bars for each car, colored based on the paint_sequence - ax.bar(self.car_sequence, np.ones_like(self.car_sequence), color=plot_colors, width=1, align='center') - ax.set_title("BPSP Solution") - ax.set_xlim(np.min(self.car_sequence)-0.5, np.max(self.car_sequence)+0.5) # Set x limits to tightly fit bars + ax.bar(range(len(self.car_sequence)), np.ones_like(self.car_sequence), color=plot_colors, width=1, align='center') + ax.set_xlim(-0.5, len(self.car_sequence) - 0.5) # Set x limits to tightly fit bars ax.set_ylim(0, 1) # Set y limits from 0 to 1 as the bars have a fixed height of 1 ax.yaxis.set_visible(False) # Hide the y-axis as it's not relevant - # Set x-ticks to indicate car numbers and label them as "Car 1", "Car 2", etc. - ax.set_xticks(self.car_sequence) + # Set x-ticks to indicate car numbers and label them as "Car 3", "Car 2", "Car 2", etc. + ax.set_xticks(range(len(self.car_sequence))) ax.set_xticklabels([f"Car {int(car)}" for car in self.car_sequence]) # Hide the top, right, and left spines for cleaner visuals From 557ca66c35d8acfead85063f1279b1c32f85b585 Mon Sep 17 00:00:00 2001 From: V Vijendran Date: Tue, 17 Oct 2023 11:25:58 +1100 Subject: [PATCH 15/28] Modified BPSP to Pass test_qubo.py Tests --- src/openqaoa-core/openqaoa/problems/bpsp.py | 56 +++++++++++++++---- .../openqaoa/problems/helper_functions.py | 2 + src/openqaoa-core/tests/test_qubo.py | 3 + 3 files changed, 51 insertions(+), 10 deletions(-) diff --git a/src/openqaoa-core/openqaoa/problems/bpsp.py b/src/openqaoa-core/openqaoa/problems/bpsp.py index 908abda72..a550fb448 100644 --- a/src/openqaoa-core/openqaoa/problems/bpsp.py +++ b/src/openqaoa-core/openqaoa/problems/bpsp.py @@ -60,7 +60,7 @@ class BPSP(Problem): between color assignments for consecutive cars and aggregating this difference for the entire sequence. """ - __name__ = "Binary_Paint_Shop_Problem" + __name__ = "binary_paint_shop_problem" def __init__(self, car_sequence): """ @@ -93,6 +93,28 @@ def __init__(self, car_sequence): self.car_positions = self.car_pos self.bpsp_graph = self.graph + @property + def problem_instance(self): + instance = super().problem_instance # Get the original problem_instance + return self.convert_ndarrays(instance) + + @staticmethod + def convert_ndarrays(obj): + """ + Recursively convert numpy objects in the given object to their Python counterparts. + Converts numpy.ndarrays to Python lists and numpy.int64 to Python int. + """ + if isinstance(obj, np.ndarray): + return obj.tolist() + elif isinstance(obj, np.int64): + return int(obj) + elif isinstance(obj, dict): + return {k: BPSP.convert_ndarrays(v) for k, v in obj.items()} + elif isinstance(obj, list): + return [BPSP.convert_ndarrays(item) for item in obj] + else: + return obj + @property def car_sequence(self): @@ -158,6 +180,8 @@ def random_instance(**kwargs): num_cars: int The number of distinct cars to be considered in the sequence. Each car will appear twice in the final sequence. + seed: int, optional + The seed for the random number generator. If provided, the output will be deterministic based on this seed. Returns ------- @@ -165,11 +189,19 @@ def random_instance(**kwargs): A random instance of the BPSP problem, based on the shuffled sequence of cars. """ - # Extract the number of cars from the provided keyword arguments. + # Extract the number of cars and the seed from the provided keyword arguments. num_cars = kwargs.get("num_cars") + seed = kwargs.get("seed", None) # Default value is None if not provided. + + # Assert that the number of cars is greater than 0. + assert num_cars > 0, "The number of cars must be greater than 0." # Generate a list with two occurrences of each car ID, i.e., [0, 1, ..., n, 0, 1, ..., n]. car_sequence = np.array(list(range(num_cars)) + list(range(num_cars))) + + # Set the seed for numpy's random module. + np.random.seed(seed) + # Apply the Fisher-Yates shuffle to the car_sequence. # Start from the end of the list and swap the current element with a randomly chosen earlier element. for i in range(len(car_sequence)-1, 0, -1): @@ -177,7 +209,7 @@ def random_instance(**kwargs): j = np.random.randint(0, i+1) # Swap the elements at indices i and j. car_sequence[i], car_sequence[j] = car_sequence[j], car_sequence[i] - + # Return a BPSP instance using the shuffled car_sequence. return BPSP(car_sequence) @@ -204,18 +236,22 @@ def car_pos(self): # Enumerate through each car ID in the sequence to track its positions. for idx, car in enumerate(self.car_sequence): + # Convert the car to int type (assuming it's of type np.int64 or similar) + car_key = int(car) + # If the car ID is already in the dictionary, append the new position. - if car in car_pos: - car_pos[car].append(idx) + if car_key in car_pos: + car_pos[car_key].append(idx) # If this is the first occurrence of the car ID, initialize a list with the position. else: - car_pos[car] = [idx] + car_pos[car_key] = [idx] # Convert the lists of positions to tuples for a consistent output format. - for car, positions in car_pos.items(): - car_pos[car] = tuple(positions) + for car_key, positions in car_pos.items(): + car_pos[car_key] = tuple(positions) return car_pos + @property def graph(self): @@ -363,7 +399,7 @@ def qubo(self): weights.append(edge_weight) - return QUBO(self.bpsp_graph.number_of_nodes(), terms, weights) + return QUBO(self.bpsp_graph.number_of_nodes(), terms, weights, self.problem_instance,) def cplex_solution(self): """ @@ -550,7 +586,7 @@ def plot_paint_sequence(self, paint_sequence, ax=None): """ # Define color mapping for 0s and 1s in the paint_sequence to 'blue' and 'red' respectively - color_map = {0: '#f25c54', 1: '#48cae4'} # shades of blue and red + color_map = {0: '#48cae4', 1: '#f25c54'} # shades of blue and red plot_colors = [color_map[color] for color in paint_sequence] # Dynamically determine the width of the figure based on the number of cars in self.car_sequence diff --git a/src/openqaoa-core/openqaoa/problems/helper_functions.py b/src/openqaoa-core/openqaoa/problems/helper_functions.py index 0d7b1d1ea..a077f1c0b 100644 --- a/src/openqaoa-core/openqaoa/problems/helper_functions.py +++ b/src/openqaoa-core/openqaoa/problems/helper_functions.py @@ -14,6 +14,7 @@ from .binpacking import BinPacking from .portfoliooptimization import PortfolioOptimization from .sherrington_kirkpatrick import SK +from .bpsp import BPSP from .qubo import QUBO @@ -52,6 +53,7 @@ def create_problem_from_dict(problem_instance: dict) -> Problem: "k_color": KColor, "portfolio_optimization": PortfolioOptimization, "sherrington_kirkpatrick": SK, + "binary_paint_shop_problem": BPSP, } # check if the problem type is in the mapper diff --git a/src/openqaoa-core/tests/test_qubo.py b/src/openqaoa-core/tests/test_qubo.py index 4b024e876..e68926c28 100644 --- a/src/openqaoa-core/tests/test_qubo.py +++ b/src/openqaoa-core/tests/test_qubo.py @@ -17,6 +17,7 @@ BinPacking, SK, KColor, + BPSP ) from openqaoa.utilities import convert2serialize from openqaoa.problems.helper_functions import create_problem_from_dict @@ -71,6 +72,7 @@ def __generate_random_problems(self): "k_color": KColor.random_instance( n_nodes=int(rng.integers(3, 8)), k=int(rng.integers(2, 5)), seed=seed ), + "binary_paint_shop_problem": BPSP.random_instance(num_cars = 10, seed = seed), } qubo_random_instances = { k: v.qubo for k, v in problems_random_instances.items() @@ -157,6 +159,7 @@ def test_problem_instance(self): ], "sherrington_kirkpatrick": ["problem_type", "G"], "k_color": ["problem_type", "G", "k", "penalty"], + "binary_paint_shop_problem": ["problem_type", 'car_sequence', 'car_positions', 'bpsp_graph'], "generic_qubo": ["problem_type"], } From 4296f816adbe7e96bff56fd4f76dbbd5bb9fc97d Mon Sep 17 00:00:00 2001 From: V Vijendran Date: Sat, 21 Oct 2023 17:56:44 +1100 Subject: [PATCH 16/28] Fixed Bug with CPLEX Solver --- src/openqaoa-core/openqaoa/problems/bpsp.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/openqaoa-core/openqaoa/problems/bpsp.py b/src/openqaoa-core/openqaoa/problems/bpsp.py index a550fb448..4d526ec52 100644 --- a/src/openqaoa-core/openqaoa/problems/bpsp.py +++ b/src/openqaoa-core/openqaoa/problems/bpsp.py @@ -427,11 +427,10 @@ def cplex_solution(self): print(status) # Extract the solution values representing paint choices - solution = [int(model.solution.get_value(var)) for var in model.iter_binary_vars()] + solution = [int(np.round(model.solution.get_value(var))) for var in model.iter_binary_vars()] # Get the objective value of the solution objective_value = model.objective_value - # Return the paint choices and their corresponding objective value return solution, objective_value From 066187584d5c49d9132b07ae6cee4e14f96735c3 Mon Sep 17 00:00:00 2001 From: V Vijendran Date: Sat, 21 Oct 2023 18:09:00 +1100 Subject: [PATCH 17/28] Fixed Another Bug in CPLEX Objective Value --- src/openqaoa-core/openqaoa/problems/bpsp.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/openqaoa-core/openqaoa/problems/bpsp.py b/src/openqaoa-core/openqaoa/problems/bpsp.py index 4d526ec52..81287bcfe 100644 --- a/src/openqaoa-core/openqaoa/problems/bpsp.py +++ b/src/openqaoa-core/openqaoa/problems/bpsp.py @@ -285,7 +285,7 @@ def graph(self): # Helper function to add or update an edge in the graph. def add_edge(u, v, weight): # Sort the vertices to maintain a consistent edge representation. - edge = (u, v) if u < v else (v, u) + edge = (u, v) #if u < v else (v, u) # Add the weight or update the existing weight of the edge. graph[edge] = graph.get(edge, 0) + weight @@ -430,7 +430,8 @@ def cplex_solution(self): solution = [int(np.round(model.solution.get_value(var))) for var in model.iter_binary_vars()] # Get the objective value of the solution - objective_value = model.objective_value + diff_sum = lambda lst: sum(abs(lst[i] - lst[i+1]) for i in range(len(lst)-1)) + objective_value = diff_sum(solution) # Return the paint choices and their corresponding objective value return solution, objective_value From 4235fb1a891307a7278cfc84b277af410b935cb2 Mon Sep 17 00:00:00 2001 From: V Vijendran Date: Sat, 21 Oct 2023 18:33:04 +1100 Subject: [PATCH 18/28] Started writing Unit Tests for BPSP --- src/openqaoa-core/tests/test_bpsp.py | 114 +++++++++++++++++++++++++++ 1 file changed, 114 insertions(+) create mode 100644 src/openqaoa-core/tests/test_bpsp.py diff --git a/src/openqaoa-core/tests/test_bpsp.py b/src/openqaoa-core/tests/test_bpsp.py new file mode 100644 index 000000000..5de3d210d --- /dev/null +++ b/src/openqaoa-core/tests/test_bpsp.py @@ -0,0 +1,114 @@ +import unittest +import networkx as nx +import numpy as np +from openqaoa.problems import BPSP + + +def terms_list_equality(terms_list1, terms_list2): + """ + Check the terms equality between two terms list + where the order of edges do not matter. + """ + if len(terms_list1) != len(terms_list2): + bool = False + else: + for term1, term2 in zip(terms_list1, terms_list2): + bool = True if (term1 == term2 or term1 == term2[::-1]) else False + + return bool + + +def terms_list_isclose(terms_list1, terms_list2): + """ + Check if the distance between two terms list + where the order of edges do not matter. + """ + if len(terms_list1) != len(terms_list2): + bool = False + else: + for term1, term2 in zip(terms_list1, terms_list2): + bool = ( + True + if np.isclose(term1, term2) or np.isclose(term1, term2[::-1]) + else False + ) + + return bool + + +class TestBPSP(unittest.TestCase): + + def test_bpsp_terms_weights_constant(self): + """Test that BPSP creates a correct QUBO from the provided graph""" + + n_nodes = 5 + rng = np.random.default_rng(1234) + G = nx.Graph() + G.add_weighted_edges_from( + [ + [i, j, round(2 * rng.random() - 1)] + for i in range(n_nodes) + for j in range(i + 1, n_nodes) + ] + ) + gr_edges = [[0, 1], [0, 3], [1, 3], [1, 4], [2, 4], [0], [1], [2], [3], [4]] + gr_weights = [-1.0, -1.0, 1.0, 1.0, -1.0, 0.0, 0.0, 0.0, 0.0, 0.0] # You might want to adjust these expected values + + bpsp_prob_qubo = BPSP(G).qubo + self.assertTrue(terms_list_equality(gr_edges, bpsp_prob_qubo.terms)) + self.assertEqual(gr_weights, bpsp_prob_qubo.weights) + self.assertEqual(0.0, bpsp_prob_qubo.constant) + + def setUp(self): + # This method is run before each test. It's used to set up testing data. + self.bp = BPSP(np.array([0, 1, 0, 1])) + + def test_car_sequence_raises(self): + # Test if ValueErrors are raised as expected + with self.assertRaises(ValueError): + self.bp.car_sequence = np.array([0, 1, 0]) + with self.assertRaises(ValueError): + self.bp.car_sequence = np.array([0, 0, 1, 2, 2, 3, 3, 3]) + + def test_random_instance(self): + # Test random instance generation + instance = BPSP.random_instance(num_cars=2) + self.assertTrue(all(np.array([0, 1, 0, 1]) == instance.car_sequence) or + all(np.array([1, 0, 1, 0]) == instance.car_sequence)) + + def test_car_pos(self): + self.assertEqual(self.bp.car_positions, {0: (0, 2), 1: (1, 3)}) + + def test_graph(self): + # Add a basic test for graph generation (more rigorous tests would require inspecting the graph) + self.assertEqual(len(self.bp.bpsp_graph.nodes), 2) + + def test_docplex_bpsp_model(self): + # Test for the docplex model (basic check) + self.assertIsNotNone(self.bp.docplex_bpsp_model) + + def test_cplex_solution(self): + # Assuming cplex is installed and functional + solution, objective_value = self.bp.cplex_solution() + self.assertEqual(len(solution), 4) + self.assertIn(objective_value, [1, 3]) # Depending on the BPSP instance solution + + def test_qaoa_solution(self): + sequence, color_swaps = self.bp.qaoa_solution("1010") + self.assertEqual(sequence, [1, 0, 0, 1]) + self.assertEqual(color_swaps, 3) + + def test_redfirst_solution(self): + sequence, color_swaps = self.bp.redfirst_solution() + self.assertEqual(sequence, [1, 1, 0, 0]) + self.assertEqual(color_swaps, 2) + + def test_greedy_solution(self): + sequence, color_swaps = self.bp.greedy_solution() + self.assertEqual(sequence, [0, 0, 1, 1]) + self.assertEqual(color_swaps, 2) + +# ... other tests ... + +if __name__ == "__main__": + unittest.main() From 8ba87913fd507ffe7297aa13584e6d4fcb2df8dc Mon Sep 17 00:00:00 2001 From: V Vijendran Date: Sun, 22 Oct 2023 14:00:42 +1100 Subject: [PATCH 19/28] Fixed Bugs in BPSP Test --- src/openqaoa-core/tests/test_bpsp.py | 102 +++++++++++++++------------ 1 file changed, 57 insertions(+), 45 deletions(-) diff --git a/src/openqaoa-core/tests/test_bpsp.py b/src/openqaoa-core/tests/test_bpsp.py index 5de3d210d..5dfd327c5 100644 --- a/src/openqaoa-core/tests/test_bpsp.py +++ b/src/openqaoa-core/tests/test_bpsp.py @@ -1,6 +1,6 @@ import unittest -import networkx as nx import numpy as np +import networkx as nx from openqaoa.problems import BPSP @@ -18,97 +18,109 @@ def terms_list_equality(terms_list1, terms_list2): return bool -def terms_list_isclose(terms_list1, terms_list2): - """ - Check if the distance between two terms list - where the order of edges do not matter. +class TestBPSP(unittest.TestCase): """ - if len(terms_list1) != len(terms_list2): - bool = False - else: - for term1, term2 in zip(terms_list1, terms_list2): - bool = ( - True - if np.isclose(term1, term2) or np.isclose(term1, term2[::-1]) - else False - ) + Test suite for the BPSP problem. - return bool + This test suite checks the functionality of methods related to the BPSP problem, + including QUBO creation, car sequencing, solution methods, and more. + """ + def setUp(self): + """ + Set up testing data before each test. -class TestBPSP(unittest.TestCase): + This method initializes a BPSP instance with a specific car sequence. + """ + self.bp = BPSP(np.array([0, 1, 0, 1])) def test_bpsp_terms_weights_constant(self): - """Test that BPSP creates a correct QUBO from the provided graph""" + """ + Test the correct QUBO formation from a provided graph. - n_nodes = 5 - rng = np.random.default_rng(1234) + This method validates that BPSP creates the expected QUBO by comparing + its terms and weights with predefined expected values. + """ + car_sequence = [3, 1, 0, 0, 2, 2, 4, 4, 3, 1] G = nx.Graph() - G.add_weighted_edges_from( - [ - [i, j, round(2 * rng.random() - 1)] - for i in range(n_nodes) - for j in range(i + 1, n_nodes) - ] - ) - gr_edges = [[0, 1], [0, 3], [1, 3], [1, 4], [2, 4], [0], [1], [2], [3], [4]] - gr_weights = [-1.0, -1.0, 1.0, 1.0, -1.0, 0.0, 0.0, 0.0, 0.0, 0.0] # You might want to adjust these expected values - - bpsp_prob_qubo = BPSP(G).qubo + G.add_weighted_edges_from([[3, 1, -2], [3, 4, -1], [1, 0, -1], [0, 2, 1], [2, 4, 1]]) + + gr_edges = [[3, 1], [3, 4], [1, 0], [0, 2], [2, 4]] + gr_weights = [-2, -1, -1, 1, 1] + + bpsp_prob_qubo = BPSP(car_sequence).qubo self.assertTrue(terms_list_equality(gr_edges, bpsp_prob_qubo.terms)) self.assertEqual(gr_weights, bpsp_prob_qubo.weights) self.assertEqual(0.0, bpsp_prob_qubo.constant) - def setUp(self): - # This method is run before each test. It's used to set up testing data. - self.bp = BPSP(np.array([0, 1, 0, 1])) - def test_car_sequence_raises(self): - # Test if ValueErrors are raised as expected + """ + Test if ValueErrors are raised for invalid car sequences. + + Certain car sequences are expected to be invalid based on their content. + This method checks if setting such sequences raises a ValueError. + """ with self.assertRaises(ValueError): self.bp.car_sequence = np.array([0, 1, 0]) with self.assertRaises(ValueError): self.bp.car_sequence = np.array([0, 0, 1, 2, 2, 3, 3, 3]) def test_random_instance(self): - # Test random instance generation + """ + Test the generation of a random BPSP instance. + + Validates that the generated random BPSP instance has one of the + expected car sequences. + """ instance = BPSP.random_instance(num_cars=2) self.assertTrue(all(np.array([0, 1, 0, 1]) == instance.car_sequence) or + all(np.array([1, 1, 0, 0]) == instance.car_sequence) or + all(np.array([0, 0, 1, 1]) == instance.car_sequence) or all(np.array([1, 0, 1, 0]) == instance.car_sequence)) def test_car_pos(self): + """Test the retrieval of car positions.""" self.assertEqual(self.bp.car_positions, {0: (0, 2), 1: (1, 3)}) def test_graph(self): - # Add a basic test for graph generation (more rigorous tests would require inspecting the graph) + """Test the generation of a graph representation of the BPSP instance.""" self.assertEqual(len(self.bp.bpsp_graph.nodes), 2) def test_docplex_bpsp_model(self): - # Test for the docplex model (basic check) + """Test if the docplex model representation of BPSP is generated.""" self.assertIsNotNone(self.bp.docplex_bpsp_model) def test_cplex_solution(self): - # Assuming cplex is installed and functional + """ + Test the solution of the BPSP problem using CPLEX. + + This test assumes that CPLEX is installed and functional. It checks + the length of the solution and the objective value. + """ solution, objective_value = self.bp.cplex_solution() self.assertEqual(len(solution), 4) - self.assertIn(objective_value, [1, 3]) # Depending on the BPSP instance solution + self.assertIn(objective_value, [1, 3]) def test_qaoa_solution(self): - sequence, color_swaps = self.bp.qaoa_solution("1010") + """Test the solution of the BPSP problem using QAOA.""" + sequence, color_swaps = self.bp.qaoa_solution('10') self.assertEqual(sequence, [1, 0, 0, 1]) - self.assertEqual(color_swaps, 3) + self.assertEqual(color_swaps, 2) def test_redfirst_solution(self): + """Test the solution of the BPSP problem using the Red-First method.""" sequence, color_swaps = self.bp.redfirst_solution() self.assertEqual(sequence, [1, 1, 0, 0]) - self.assertEqual(color_swaps, 2) + self.assertEqual(color_swaps, 1) def test_greedy_solution(self): + """Test the solution of the BPSP problem using the Greedy method.""" sequence, color_swaps = self.bp.greedy_solution() self.assertEqual(sequence, [0, 0, 1, 1]) - self.assertEqual(color_swaps, 2) + self.assertEqual(color_swaps, 1) + + -# ... other tests ... if __name__ == "__main__": unittest.main() From 5d2507f04f0b38463a4e27ec8b97e38c3c76c50e Mon Sep 17 00:00:00 2001 From: KilianPoirier Date: Mon, 23 Oct 2023 07:27:06 +0000 Subject: [PATCH 20/28] Removeed print statement --- src/openqaoa-core/openqaoa/problems/tsp.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/openqaoa-core/openqaoa/problems/tsp.py b/src/openqaoa-core/openqaoa/problems/tsp.py index dabdd4e0b..349355900 100644 --- a/src/openqaoa-core/openqaoa/problems/tsp.py +++ b/src/openqaoa-core/openqaoa/problems/tsp.py @@ -179,7 +179,6 @@ def validate_graph(G): """ # Set edge weights to be the distances between corresponding cities for u, v, weight in G.edges(data="weight"): - print(weight) if not isinstance(weight, float) and not isinstance(weight, int): raise TypeError("The edge weights must be of type float or int") From 4a2ec6a0aa1ba12ded71f4ef48a2f7890ed7d4b7 Mon Sep 17 00:00:00 2001 From: V Vijendran Date: Wed, 25 Oct 2023 19:34:06 +1100 Subject: [PATCH 21/28] Made Changes Suggested by Kilian on bpsp.py, test_bpsp.py, and test_qubo.py --- src/openqaoa-core/openqaoa/problems/bpsp.py | 24 ++++---- src/openqaoa-core/tests/test_bpsp.py | 62 ++++++++++----------- src/openqaoa-core/tests/test_qubo.py | 6 +- 3 files changed, 47 insertions(+), 45 deletions(-) diff --git a/src/openqaoa-core/openqaoa/problems/bpsp.py b/src/openqaoa-core/openqaoa/problems/bpsp.py index 81287bcfe..644a086fe 100644 --- a/src/openqaoa-core/openqaoa/problems/bpsp.py +++ b/src/openqaoa-core/openqaoa/problems/bpsp.py @@ -13,7 +13,7 @@ - "Some heuristics for the binary paint shop problem and their expected number of colour changes" (https://www.sciencedirect.com/science/article/pii/S1570866710000559) - - Upcoming/unpublished work by V Vijendran et al. + - Upcoming/unpublished work by V Vijendran et al from A*STAR and CQC2T. Author: V Vijendran (Vijey) GitHub: https://github.com/vijeycreative @@ -86,7 +86,8 @@ def __init__(self, car_sequence): `bpsp_graph` method. Returns: - None + ------- + The initialized BPSP object. """ self.car_sequence = car_sequence @@ -199,19 +200,20 @@ def random_instance(**kwargs): # Generate a list with two occurrences of each car ID, i.e., [0, 1, ..., n, 0, 1, ..., n]. car_sequence = np.array(list(range(num_cars)) + list(range(num_cars))) - # Set the seed for numpy's random module. - np.random.seed(seed) + # Create a new instance of the default random number generator. + rng = np.random.default_rng(seed) # Apply the Fisher-Yates shuffle to the car_sequence. # Start from the end of the list and swap the current element with a randomly chosen earlier element. - for i in range(len(car_sequence)-1, 0, -1): - # Select a random index between 0 and i (inclusive). - j = np.random.randint(0, i+1) + for i in range(len(car_sequence) - 1, 0, -1): + # Select a random index between 0 and i (inclusive) using the rng instance. + j = rng.integers(0, i + 1) # Swap the elements at indices i and j. car_sequence[i], car_sequence[j] = car_sequence[j], car_sequence[i] # Return a BPSP instance using the shuffled car_sequence. return BPSP(car_sequence) + @property def car_pos(self): @@ -401,7 +403,7 @@ def qubo(self): return QUBO(self.bpsp_graph.number_of_nodes(), terms, weights, self.problem_instance,) - def cplex_solution(self): + def solve_cplex(self): """ Solves the BPSP using the CPLEX solver and returns the solution and its objective value. @@ -435,7 +437,7 @@ def cplex_solution(self): # Return the paint choices and their corresponding objective value return solution, objective_value - def qaoa_solution(self, bitstring): + def paintseq_from_bits(self, bitstring): """ Transforms a sequence of initial car colors to a paint sequence and computes the number of paint swaps. @@ -474,7 +476,7 @@ def qaoa_solution(self, bitstring): return paint_sequence, color_swaps - def redfirst_solution(self): + def solve_redfirst(self): """ The `red_first_solution` method applies a heuristic to generate a paint sequence for cars. Specifically, it colors the first occurrence of each car as Red (1) and the second @@ -511,7 +513,7 @@ def redfirst_solution(self): return paint_sequence, color_swaps - def greedy_solution(self): + def solve_greedy(self): """ The `greedy_solution` method determines a feasible paint sequence for cars using a greedy approach. It processes the car sequence from left to right, coloring the diff --git a/src/openqaoa-core/tests/test_bpsp.py b/src/openqaoa-core/tests/test_bpsp.py index 5dfd327c5..0f4f1c5e2 100644 --- a/src/openqaoa-core/tests/test_bpsp.py +++ b/src/openqaoa-core/tests/test_bpsp.py @@ -26,14 +26,6 @@ class TestBPSP(unittest.TestCase): including QUBO creation, car sequencing, solution methods, and more. """ - def setUp(self): - """ - Set up testing data before each test. - - This method initializes a BPSP instance with a specific car sequence. - """ - self.bp = BPSP(np.array([0, 1, 0, 1])) - def test_bpsp_terms_weights_constant(self): """ Test the correct QUBO formation from a provided graph. @@ -53,69 +45,77 @@ def test_bpsp_terms_weights_constant(self): self.assertEqual(gr_weights, bpsp_prob_qubo.weights) self.assertEqual(0.0, bpsp_prob_qubo.constant) - def test_car_sequence_raises(self): + def test_bpsp_car_sequence_raises(self): """ Test if ValueErrors are raised for invalid car sequences. Certain car sequences are expected to be invalid based on their content. This method checks if setting such sequences raises a ValueError. """ + bpsp = BPSP(np.array([0, 1, 0, 1])) with self.assertRaises(ValueError): - self.bp.car_sequence = np.array([0, 1, 0]) + bpsp.car_sequence = np.array([0, 1, 0]) with self.assertRaises(ValueError): - self.bp.car_sequence = np.array([0, 0, 1, 2, 2, 3, 3, 3]) + bpsp.car_sequence = np.array([0, 0, 1, 2, 2, 3, 3, 3]) - def test_random_instance(self): + def test_bpsp_random_instance(self): """ Test the generation of a random BPSP instance. Validates that the generated random BPSP instance has one of the expected car sequences. """ - instance = BPSP.random_instance(num_cars=2) - self.assertTrue(all(np.array([0, 1, 0, 1]) == instance.car_sequence) or - all(np.array([1, 1, 0, 0]) == instance.car_sequence) or - all(np.array([0, 0, 1, 1]) == instance.car_sequence) or - all(np.array([1, 0, 1, 0]) == instance.car_sequence)) + bpsp = BPSP.random_instance(num_cars=2, seed=1234) + self.assertTrue(all(np.array([0, 1, 0, 1]) == bpsp.car_sequence) or + all(np.array([1, 1, 0, 0]) == bpsp.car_sequence) or + all(np.array([0, 0, 1, 1]) == bpsp.car_sequence) or + all(np.array([1, 0, 1, 0]) == bpsp.car_sequence)) - def test_car_pos(self): + def test_bpsp_car_pos(self): """Test the retrieval of car positions.""" - self.assertEqual(self.bp.car_positions, {0: (0, 2), 1: (1, 3)}) + bpsp = BPSP(np.array([0, 1, 0, 1])) + self.assertEqual(bpsp.car_positions, {0: (0, 2), 1: (1, 3)}) - def test_graph(self): + def test_bpsp_graph(self): """Test the generation of a graph representation of the BPSP instance.""" - self.assertEqual(len(self.bp.bpsp_graph.nodes), 2) + bpsp = BPSP.random_instance(num_cars=2, seed=1234) + self.assertEqual(len(bpsp.bpsp_graph.nodes), 2) - def test_docplex_bpsp_model(self): + def test_bpsp_docplex_bpsp_model(self): """Test if the docplex model representation of BPSP is generated.""" - self.assertIsNotNone(self.bp.docplex_bpsp_model) + bpsp = BPSP.random_instance(num_cars=2, seed=1234) + self.assertIsNotNone(bpsp.docplex_bpsp_model) - def test_cplex_solution(self): + def test_bpsp_cplex_solution(self): """ Test the solution of the BPSP problem using CPLEX. This test assumes that CPLEX is installed and functional. It checks the length of the solution and the objective value. """ - solution, objective_value = self.bp.cplex_solution() + bpsp = BPSP(np.array([0, 1, 0, 1])) + solution, objective_value = bpsp.solve_cplex() self.assertEqual(len(solution), 4) self.assertIn(objective_value, [1, 3]) - def test_qaoa_solution(self): + def test_bpsp_qaoa_solution(self): """Test the solution of the BPSP problem using QAOA.""" - sequence, color_swaps = self.bp.qaoa_solution('10') + bpsp = BPSP(np.array([0, 1, 0, 1])) + sequence, color_swaps = bpsp.paintseq_from_bits('10') self.assertEqual(sequence, [1, 0, 0, 1]) self.assertEqual(color_swaps, 2) - def test_redfirst_solution(self): + def test_bpsp_redfirst_solution(self): """Test the solution of the BPSP problem using the Red-First method.""" - sequence, color_swaps = self.bp.redfirst_solution() + bpsp = BPSP(np.array([0, 1, 0, 1])) + sequence, color_swaps = bpsp.solve_redfirst() self.assertEqual(sequence, [1, 1, 0, 0]) self.assertEqual(color_swaps, 1) - def test_greedy_solution(self): + def test_bpsp_greedy_solution(self): """Test the solution of the BPSP problem using the Greedy method.""" - sequence, color_swaps = self.bp.greedy_solution() + bpsp = BPSP(np.array([0, 1, 0, 1])) + sequence, color_swaps = bpsp.solve_greedy() self.assertEqual(sequence, [0, 0, 1, 1]) self.assertEqual(color_swaps, 1) diff --git a/src/openqaoa-core/tests/test_qubo.py b/src/openqaoa-core/tests/test_qubo.py index e68926c28..b1c14c598 100644 --- a/src/openqaoa-core/tests/test_qubo.py +++ b/src/openqaoa-core/tests/test_qubo.py @@ -17,7 +17,7 @@ BinPacking, SK, KColor, - BPSP + BPSP, ) from openqaoa.utilities import convert2serialize from openqaoa.problems.helper_functions import create_problem_from_dict @@ -72,7 +72,7 @@ def __generate_random_problems(self): "k_color": KColor.random_instance( n_nodes=int(rng.integers(3, 8)), k=int(rng.integers(2, 5)), seed=seed ), - "binary_paint_shop_problem": BPSP.random_instance(num_cars = 10, seed = seed), + "binary_paint_shop_problem": BPSP.random_instance(num_cars=10, seed=seed), } qubo_random_instances = { k: v.qubo for k, v in problems_random_instances.items() @@ -159,7 +159,7 @@ def test_problem_instance(self): ], "sherrington_kirkpatrick": ["problem_type", "G"], "k_color": ["problem_type", "G", "k", "penalty"], - "binary_paint_shop_problem": ["problem_type", 'car_sequence', 'car_positions', 'bpsp_graph'], + "binary_paint_shop_problem": ["problem_type", "car_sequence", "car_positions", "bpsp_graph"], "generic_qubo": ["problem_type"], } From a3184c7d097f477e1782de3d7f1ede663601c967 Mon Sep 17 00:00:00 2001 From: V Vijendran Date: Thu, 26 Oct 2023 16:04:28 +1100 Subject: [PATCH 22/28] Improved Testing in bpsp_test.py --- src/openqaoa-core/tests/test_bpsp.py | 133 ++++++++++++++++++++++----- 1 file changed, 110 insertions(+), 23 deletions(-) diff --git a/src/openqaoa-core/tests/test_bpsp.py b/src/openqaoa-core/tests/test_bpsp.py index 0f4f1c5e2..a8b083462 100644 --- a/src/openqaoa-core/tests/test_bpsp.py +++ b/src/openqaoa-core/tests/test_bpsp.py @@ -1,7 +1,9 @@ import unittest import numpy as np import networkx as nx +from docplex.mp.model import Model from openqaoa.problems import BPSP +from docplex.mp.constants import ObjectiveSense def terms_list_equality(terms_list1, terms_list2): @@ -17,6 +19,45 @@ def terms_list_equality(terms_list1, terms_list2): return bool +def fisher_yates_shuffle(arr, rng): + """ + Perform an in-place shuffle of a list using the Fisher-Yates shuffle algorithm. + + This algorithm runs in O(n) time and ensures that every permutation of the array is equally likely. + The shuffle is performed in-place, meaning that the input array `arr` is modified directly. + + Parameters: + ----------- + arr : list + A list of elements to be shuffled. This list will be modified in place. + rng : numpy.random.Generator + A random number generator instance from NumPy for generating random numbers. + This allows for reproducibility and control over the random number generation. + + Returns: + -------- + list + The shuffled list. Note that the input list is shuffled in place, and the same list is returned. + + Example: + -------- + >>> from numpy.random import default_rng + >>> rng = default_rng(seed=42) + >>> arr = [1, 2, 3, 4, 5] + >>> fisher_yates_shuffle(arr, rng) + [3, 4, 1, 5, 2] # Output can vary based on the RNG seed and state. + """ + + # Iterate over the array from the last element down to the second element + for i in range(len(arr) - 1, 0, -1): + # Generate a random index to swap with the current element + j = rng.integers(0, i + 1) + + # Swap the current element with the randomly chosen element + arr[i], arr[j] = arr[j], arr[i] + + # Return the shuffled array + return arr class TestBPSP(unittest.TestCase): """ @@ -26,7 +67,7 @@ class TestBPSP(unittest.TestCase): including QUBO creation, car sequencing, solution methods, and more. """ - def test_bpsp_terms_weights_constant(self): + def test_bpsp_qubo(self): """ Test the correct QUBO formation from a provided graph. @@ -45,7 +86,7 @@ def test_bpsp_terms_weights_constant(self): self.assertEqual(gr_weights, bpsp_prob_qubo.weights) self.assertEqual(0.0, bpsp_prob_qubo.constant) - def test_bpsp_car_sequence_raises(self): + def test_bpsp_car_sequence(self): """ Test if ValueErrors are raised for invalid car sequences. @@ -60,16 +101,35 @@ def test_bpsp_car_sequence_raises(self): def test_bpsp_random_instance(self): """ - Test the generation of a random BPSP instance. + Test the random instance generation of the Binary Paint Shop Problem (BPSP). + + This test verifies whether the `random_instance` method of the BPSP class + correctly creates a randomized car sequence based on a given number of cars and seed. + The car sequence should be a list containing two occurrences of each car ID, + randomly shuffled using the Fisher-Yates shuffle algorithm. - Validates that the generated random BPSP instance has one of the - expected car sequences. + The function asserts that the sequence generated by the BPSP class's method + is identical to the sequence produced by an explicitly defined Fisher-Yates shuffle process, + ensuring both consistency and correctness in the shuffling method based on a fixed seed. """ - bpsp = BPSP.random_instance(num_cars=2, seed=1234) - self.assertTrue(all(np.array([0, 1, 0, 1]) == bpsp.car_sequence) or - all(np.array([1, 1, 0, 0]) == bpsp.car_sequence) or - all(np.array([0, 0, 1, 1]) == bpsp.car_sequence) or - all(np.array([1, 0, 1, 0]) == bpsp.car_sequence)) + + # Seed and number of cars for generating the instance + seed = 1234 + num_cars = 10 + + # Lambda function to create and shuffle car sequence using Fisher-Yates algorithm + # The lambda function first duplicates each car ID using np.tile, then applies the shuffle. + create_car_seq = lambda num_cars, seed: fisher_yates_shuffle( + np.tile(np.arange(num_cars), 2), np.random.default_rng(seed)) + + # Generating a random BPSP instance using the class method + bpsp = BPSP.random_instance(num_cars=num_cars, seed=seed) + + # Asserting if the generated car sequence in BPSP instance is identical + # to the sequence produced by our lambda function. + # This confirms the random instance generation works as expected. + self.assertTrue(all(bpsp.car_sequence == create_car_seq(num_cars, seed)), + "The generated car sequence does not match the expected shuffled sequence.") def test_bpsp_car_pos(self): """Test the retrieval of car positions.""" @@ -78,15 +138,45 @@ def test_bpsp_car_pos(self): def test_bpsp_graph(self): """Test the generation of a graph representation of the BPSP instance.""" - bpsp = BPSP.random_instance(num_cars=2, seed=1234) - self.assertEqual(len(bpsp.bpsp_graph.nodes), 2) + car_sequence = [3, 1, 0, 0, 2, 2, 4, 4, 3, 1] + G = nx.Graph() + G.add_weighted_edges_from([[3, 1, -2], [3, 4, -1], [1, 0, -1], [0, 2, 1], [2, 4, 1]]) + + bpsp_graph = BPSP(car_sequence).graph + + assert nx.is_isomorphic(G, bpsp_graph), "The created graph and BPSP graph are not identical," def test_bpsp_docplex_bpsp_model(self): """Test if the docplex model representation of BPSP is generated.""" bpsp = BPSP.random_instance(num_cars=2, seed=1234) - self.assertIsNotNone(bpsp.docplex_bpsp_model) - - def test_bpsp_cplex_solution(self): + + # Obtain the model + mdl = bpsp.docplex_bpsp_model # Access as attribute due to @property decorator + + # Verify that the function returns a valid model instance + self.assertIsInstance(mdl, Model, "Model is not an instance of DOcplex Model") + + # Manually retrieve binary variables based on their expected names + sequence = bpsp.car_sequence + expected_var_names = [f"w_{w}_{i}" for i, w in enumerate(sequence)] + binary_vars = [mdl.get_var_by_name(name) for name in expected_var_names] + + # Check that all variables are present and are binary + self.assertEqual(len(binary_vars), 4, "Unexpected number of binary variables") + for var in binary_vars: + self.assertTrue(var is not None, f"Variable {var} not found in model") + self.assertTrue(var.is_binary(), f"Variable {var} is not binary") + + # Check number of constraints + self.assertEqual(mdl.number_of_constraints, 11, "Unexpected number of constraints") + + # Check if objective function exists + self.assertIsNotNone(mdl.objective_expr, "Objective function is missing") + + # Check if the objective is to minimize + self.assertEqual(mdl.objective_sense, ObjectiveSense.Minimize, "Objective should be of type 'minimize'") + + def test_bpsp_solve_cplex(self): """ Test the solution of the BPSP problem using CPLEX. @@ -95,32 +185,29 @@ def test_bpsp_cplex_solution(self): """ bpsp = BPSP(np.array([0, 1, 0, 1])) solution, objective_value = bpsp.solve_cplex() - self.assertEqual(len(solution), 4) - self.assertIn(objective_value, [1, 3]) + self.assertEqual(solution, [1, 1, 0, 0]) + self.assertEqual(objective_value, 1) - def test_bpsp_qaoa_solution(self): + def test_bpsp_paintseq_from_bits(self): """Test the solution of the BPSP problem using QAOA.""" bpsp = BPSP(np.array([0, 1, 0, 1])) sequence, color_swaps = bpsp.paintseq_from_bits('10') self.assertEqual(sequence, [1, 0, 0, 1]) self.assertEqual(color_swaps, 2) - def test_bpsp_redfirst_solution(self): + def test_bpsp_solve_redfirst(self): """Test the solution of the BPSP problem using the Red-First method.""" bpsp = BPSP(np.array([0, 1, 0, 1])) sequence, color_swaps = bpsp.solve_redfirst() self.assertEqual(sequence, [1, 1, 0, 0]) self.assertEqual(color_swaps, 1) - def test_bpsp_greedy_solution(self): + def test_bpsp_solve_greedy(self): """Test the solution of the BPSP problem using the Greedy method.""" bpsp = BPSP(np.array([0, 1, 0, 1])) sequence, color_swaps = bpsp.solve_greedy() self.assertEqual(sequence, [0, 0, 1, 1]) self.assertEqual(color_swaps, 1) - - - if __name__ == "__main__": unittest.main() From 5a46df5c4ec61ca666913ec9a9ed1fbc661cce0e Mon Sep 17 00:00:00 2001 From: KilianPoirier Date: Thu, 26 Oct 2023 08:09:07 +0000 Subject: [PATCH 23/28] Update bin packing tutorial --- .../community_tutorials/04_binpacking.ipynb | 511 ++++++++---------- 1 file changed, 212 insertions(+), 299 deletions(-) diff --git a/examples/community_tutorials/04_binpacking.ipynb b/examples/community_tutorials/04_binpacking.ipynb index 66e2bc8ca..764f46cfc 100644 --- a/examples/community_tutorials/04_binpacking.ipynb +++ b/examples/community_tutorials/04_binpacking.ipynb @@ -1,5 +1,13 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "91900971", + "metadata": {}, + "source": [ + "This notebook was written by Alejandro Montañez-Barrera [@alejomonbar](https://github.com/alejomonbar)." + ] + }, { "cell_type": "markdown", "id": "71151440", @@ -15,21 +23,33 @@ "\n", "### Problem statement\n", "\n", - "minimize $$K = \\sum_{j=1}^m y_j$$\n", + "$$\\begin{equation}\n", + "\\min \\sum_{j=0}^{m-1} y_j\\tag{1},\n", + "\\end{equation}$$\n", + "\n", + "subject to the following constraints. Each bin's weight capacity should not be exceeded\n", "\n", - "subject to:\n", + "$$\\begin{equation}\n", + "\\sum_{i=0}^{n-1} w_i x_{ij} \\le B y_j \\quad \\forall j=0,...,m-1\\tag{2},\n", + "\\end{equation}$$\n", "\n", - "$$\\sum_{i=1}^n s(i) x_{ij} \\le B y_j \\qquad \\forall \\ j=1,...,m$$\n", - "$$\\sum_{j=1}^m x_{ij} = 1 \\qquad \\forall \\ i = 1, ..., n$$\n", - "$$x_{ij}\\in \\{0,1\\} \\qquad \\forall \\ i=1,..,n \\qquad j=1,..,m$$\n", - "$$y_{j}\\in \\{0,1\\} \\qquad \\forall \\ j=1,..,m $$\n", + "and each item can only be assigned to one bin\n", "\n", - "- n is the number of items\n", - "- m is the number of bins\n", - "- $s(i)$ is the i-th item weight\n", - "- B is the maximum weight of the bin\n", - "- $x_{ij}$ is the variable that represent if the item i is in the bin j.\n", - "- $y_j$ is the variable that represent if bin j is used" + "$$\\begin{equation}\n", + "\\sum_{j=0}^{m-1} x_{ij} = 1 \\quad \\forall i = 0, ..., n-1.\\tag{3}\n", + "\\end{equation}$$\n", + "\n", + "Binary variables indicating item-bin assignments and bin utilization\n", + "\n", + "$$\\begin{equation}\n", + "x_{ij} \\in {0,1} \\quad \\forall i=0,..,n-1 \\quad \\forall j=0,..,m-1,\\tag{4}\n", + "\\end{equation}$$\n", + "\n", + "$$\\begin{equation}\n", + "y_j \\in {0,1} \\quad \\forall j=0,..,m-1\\tag{5}\n", + "\\end{equation}$$\n", + "\n", + "In the above equations, $n$ represents the number of items (nodes), $m$ represents the number of bins, $w_{i}$ is the weight of the $i$-th item, $B$ denotes the maximum weight capacity of each bin, and $x_{ij}$ and $y_j$ are binary variables representing the presence of item $i$ in bin $j$ and the utilization of bin $j$, respectively. The objective function in Eq.(1) aims to minimize the number of bins used, while Eq.(2) enforces the constraint on bin weight capacity. Eq.(3) ensures that each item is assigned to only one bin, and Eqs.(4) and (5) define the binary nature of variables $x_{ij}$ and $y_j$." ] }, { @@ -39,424 +59,317 @@ "metadata": {}, "outputs": [], "source": [ - "%matplotlib notebook\n", - "\n", - "# Import external libraries to present an manipulate the data\n", + "# Import external libraries\n", + "from openqaoa.problems import BinPacking\n", + "from openqaoa.problems import FromDocplex2IsingModel\n", + "from openqaoa import QAOA, QUBO\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", - "\n", - "# Import docplex model to generate the problem to optimize\n", - "from docplex.mp.model import Model\n", - "\n", - "# Import the libraries needed to employ the QAOA quantum algorithm using OpenQAOA\n", - "from openqaoa import QAOA\n", "\n", - "# method to covnert a docplex model to a qubo problem\n", - "from openqaoa.problems.converters import FromDocplex2IsingModel\n", - "from openqaoa.backends import create_device\n", + "font_size = 16\n", + "plt.rcParams['font.size'] = font_size\n", "\n", - "# method to find the corrects states for the QAOA boject \n", - "from openqaoa.utilities import ground_state_hamiltonian" + "%matplotlib inline" ] }, { "cell_type": "markdown", - "id": "92daf6ae", + "id": "904f4713", "metadata": {}, "source": [ - "## Generate the data\n", + "## Setting the problem\n", "\n", - "It generates the data necessary to create the BinPacking problem, i.e. to consider number of items, macimum number of bins, max weight of a bin, and the weight of each item." + "It generates the data necessary to create the BinPacking problem, i.e. to consider number of items, maximum number of bins, max weight of a bin, and the weight of each item." ] }, { "cell_type": "code", "execution_count": 2, - "id": "904f4713", + "id": "d7276ddf", "metadata": {}, "outputs": [], "source": [ - "# For the case of reproducibility this seed is configured\n", - "np.random.seed(1)\n", - "\n", - "# Number of items\n", - "num_items = 2 \n", - "\n", - "# Limit the maximum number of bins\n", - "num_bins = num_items\n", - "\n", - "# Limit the max weight of a bin\n", - "max_weight = 7 \n", - "\n", - "# Randomly picking the item weight\n", - "weights = np.random.randint(1, max_weight, num_items)" + "np.random.seed(1234)\n", + "#setting the problem\n", + "n_items = 3 # number of items\n", + "n_bins = 2 # maximum number of bins the solution will be explored on \n", + "min_weight = 1 # minimum weight of the items\n", + "max_weight = 3 # maximum weight of the items\n", + "weight_capacity = 5 # weight capacity of the bins\n", + "weights = np.random.randint(min_weight, max_weight, n_items) # random instance of the problem" ] }, { "cell_type": "markdown", - "id": "06fb9665", + "id": "1afa067b", "metadata": {}, "source": [ - "## Obtain the Quadratic problem from DOCPLEX\n", - "\n", - "Once it is obtained the values for the binpacking problem, the next step is to translate it into a docplex model. Considering the above data the docplex model to solve it is given by " + "## Classical solution and visualizaiton using CPLEX\n", + "This solution is based on the python based library of `CPLEX`, [docplex](https://pypi.org/project/docplex/)." ] }, { "cell_type": "code", "execution_count": 3, - "id": "6a5aab82", + "id": "f15612c4", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "// This file has been generated by DOcplex\n", - "// model name is: BinPacking\n", - "// var contrainer section\n", - "dvar bool y[2];\n", - "dvar bool x[2][2];\n", - "\n", - "minimize\n", - " y_0 + y_1;\n", - " \n", - "subject to {\n", - " x_0_0 + x_0_1 == 1;\n", - " x_1_0 + x_1_1 == 1;\n", - " 6 x_0_0 + 4 x_1_0 <= 7 y_0;\n", - " 6 x_0_1 + 4 x_1_1 <= 7 y_1;\n", - "\n", - "}\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "# Construct model using docplex starting with the name of the Model object\n", - "mdl = Model(\"BinPacking\")\n", - "\n", - "# List of binary variables that represent the bins\n", - "y = mdl.binary_var_list(num_bins, name=\"y\")\n", - "\n", - "# List of binary variables that represent the items on the specific bin\n", - "x = mdl.binary_var_matrix(num_items, num_bins, \"x\") \n", - "\n", - "# Design the objective function\n", - "objective = mdl.sum(y)\n", - "\n", - "# This problem is minize the objective function\n", - "mdl.minimize(objective)\n", - "\n", - "# Indicate the equality constraints\n", - "for i in range(num_items):\n", - " # First set of constraints: the items must be in any bin\n", - " mdl.add_constraint(mdl.sum(x[i, j] for j in range(num_bins)) == 1)\n", - "\n", - "# Indicate the inequality constraints\n", - "for j in range(num_bins):\n", - " # Second set of constraints: weight constraints\n", - " mdl.add_constraint(mdl.sum(weights[i] * x[i, j] for i in range(num_items)) <= max_weight * y[j])\n", - "\n", - "# Print a summary of the Docplex model\n", - "mdl.prettyprint()" + "bpp = BinPacking(weights, weight_capacity, n_bins=n_bins, simplifications=False) #setting the problem using a openqaoa class\n", + "sol_cplex = bpp.classical_solution(string=True) # getting the optimal solution using DocPLEX \n", + "fig, ax = plt.subplots()\n", + "bpp.plot_solution(sol_cplex, ax)# Plotting the optimal solution" ] }, { "cell_type": "markdown", - "id": "fc3a73be", + "id": "46c864ea", "metadata": {}, "source": [ - "## Solving the problem using QAOA\n", + "## Solving using QAOA\n", "\n", + "We define a convenience function to solve the problem using QAOA, the steps abstracted here are:\n", "\n", - "The class `FromDocplex2IsingModel` from OpenQAOA converts the docplex representation of the problem to its QUBO representation in Ising encoding (-1, 1). From there, it is only required setting the QAOA model and solve the QUBO." + "* Setting the problem up and normalizing the weights\n", + "* Defining the QAOA properties, including parameter initialization, classical optimizer, etc...\n", + "* Compilation of the QAOA object\n", + "* Optimization" ] }, { "cell_type": "code", "execution_count": 4, - "id": "ffcc1361", + "id": "2551ac28", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "// This file has been generated by DOcplex\n", - "// model name is: Copy of Copy of BinPacking\n", - "// var contrainer section\n", - "dvar bool y[2];\n", - "dvar bool x[2][2];\n", - "dvar bool slack_C2[3];\n", - "dvar bool slack_C3[3];\n", - "\n", - "// single vars section\n", - "dvar bool y_0;\n", - "dvar bool y_1;\n", - "dvar bool x_0_0;\n", - "dvar bool x_0_1;\n", - "dvar bool x_1_0;\n", - "dvar bool x_1_1;\n", - "dvar bool slack_C2_0;\n", - "dvar bool slack_C2_1;\n", - "dvar bool slack_C2_2;\n", - "dvar bool slack_C3_0;\n", - "dvar bool slack_C3_1;\n", - "dvar bool slack_C3_2;\n", - "\n", - "minimize\n", - " y_0 + y_1 - 6 x_0_0 - 6 x_0_1 - 6 x_1_0 - 6 x_1_1 [ 147 y_0^2 - 252 y_0*x_0_0\n", - " - 168 y_0*x_1_0 - 42 y_0*slack_C2_0 - 84 y_0*slack_C2_1 - 168 y_0*slack_C2_2\n", - " + 147 y_1^2 - 252 y_1*x_0_1 - 168 y_1*x_1_1 - 42 y_1*slack_C3_0\n", - " - 84 y_1*slack_C3_1 - 168 y_1*slack_C3_2 + 111 x_0_0^2 + 6 x_0_0*x_0_1\n", - " + 144 x_0_0*x_1_0 + 36 x_0_0*slack_C2_0 + 72 x_0_0*slack_C2_1\n", - " + 144 x_0_0*slack_C2_2 + 111 x_0_1^2 + 144 x_0_1*x_1_1 + 36 x_0_1*slack_C3_0\n", - " + 72 x_0_1*slack_C3_1 + 144 x_0_1*slack_C3_2 + 51 x_1_0^2 + 6 x_1_0*x_1_1\n", - " + 24 x_1_0*slack_C2_0 + 48 x_1_0*slack_C2_1 + 96 x_1_0*slack_C2_2\n", - " + 51 x_1_1^2 + 24 x_1_1*slack_C3_0 + 48 x_1_1*slack_C3_1\n", - " + 96 x_1_1*slack_C3_2 + 3 slack_C2_0^2 + 12 slack_C2_0*slack_C2_1\n", - " + 24 slack_C2_0*slack_C2_2 + 12 slack_C2_1^2 + 48 slack_C2_1*slack_C2_2\n", - " + 48 slack_C2_2^2 + 3 slack_C3_0^2 + 12 slack_C3_0*slack_C3_1\n", - " + 24 slack_C3_0*slack_C3_2 + 12 slack_C3_1^2 + 48 slack_C3_1*slack_C3_2\n", - " + 48 slack_C3_2^2 ] + 6;\n", - " \n", - "subject to {\n", - "\n", - "}\n" - ] - } - ], + "outputs": [], "source": [ - "# Converting the Docplex model of binpacking into its qubo representation\n", - "qubo_bin = FromDocplex2IsingModel(mdl) \n", - "\n", - "# Ising encoding of the QUBO problem for binpacking problem\n", - "ising_encoding_bin = qubo_bin.ising_model \n", - "\n", - "# Docplex encoding of the QUBO problem for binpacking problem\n", - "mdl_qubo_docplex_bin = qubo_bin.qubo_docplex\n", - "mdl_qubo_docplex_bin.prettyprint()" + "def qaoa_result(qubo, p=5, maxiter=100):\n", + " \"\"\"\n", + " qubo (openqaoa.QUBO): Ising Hamiltonian of the problem\n", + " p (int): Number of layers of the QAOA circuit\n", + " maxiter (int): Maximum number of iterations\n", + " \"\"\"\n", + " max_weight = np.max(qubo.weights)\n", + " qubo_weights = [w/max_weight for w in qubo.weights]\n", + " qubo_normal = QUBO(qubo.n, qubo.terms, qubo_weights) # Normalizing the QUBO weights, (it can help sometimes to improve the results)\n", + "\n", + " qaoa = QAOA()\n", + " qaoa.set_circuit_properties(p=p, init_type=\"ramp\", linear_ramp_time=0.1) # initialization betas and gammas with a ramp technique\n", + " qaoa.set_classical_optimizer(maxiter=maxiter) \n", + " qaoa.compile(qubo_normal)\n", + " qaoa.optimize()\n", + " return qaoa" ] }, { "cell_type": "markdown", - "id": "246cbebf", + "id": "debfb6b3", "metadata": {}, "source": [ - "Using the pyquil backend and 1024 shots with a p value equals to 3, with betas and gammas of $0.01 * \\pi$ " + "### 1 - Solve using slack variable encoding" ] }, { "cell_type": "code", "execution_count": 5, - "id": "efd1a6b0", + "id": "2c8c796d", "metadata": {}, "outputs": [], "source": [ - "# Indicate the device, this case is a local simulator\n", - "device = create_device(\"local\", 'pyquil.statevector_simulator')\n", - "\n", - "# Initilize the QAOA object\n", - "qaoa_bin = QAOA(device)\n", - "\n", - "# Set the parameters to work the QAOA algorithm\n", - "qaoa_bin.set_backend_properties(n_shots=1024, seed_simulator=1)\n", - "rep = 3\n", - "qaoa_bin.set_circuit_properties(p=rep, init_type=\"custom\", variational_params_dict={\"betas\":rep*[0.01*np.pi],\"gammas\":rep*[0.01*np.pi]})\n", - "qaoa_bin.compile(ising_encoding_bin)\n", - "\n", - "# Run the QAOA algorithm\n", - "qaoa_bin.optimize()" + "penalty = [10, 10] # [Equality, Inequality] constraints\n", + "bpp_slack = BinPacking(weights, weight_capacity, n_bins=n_bins, penalty=penalty, simplifications=False, method=\"slack\")\n", + "qubo = bpp_slack.qubo # Ising Hamiltonian of the BPP using the slack variables encoding \n", + "results_slack = qaoa_result(qubo, p=5, maxiter=100)" ] }, { "cell_type": "markdown", - "id": "c8621ecf", + "id": "52bfe520", "metadata": {}, "source": [ - "show the best 5 states for this binpacking problem" + "We can now analyze the solution generated by the QAOA optimization and visualize the result and cost" ] }, { "cell_type": "code", "execution_count": 6, - "id": "fc3ec364", + "id": "5a2b720f", "metadata": {}, "outputs": [ { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
solutions_bitstringsbitstrings_energiesprobabilities
01110011001102.06.772599e-07
11101101101002.06.772599e-07
21000101100004.02.518399e-06
30101000001004.01.779673e-05
41010001000004.01.779673e-05
\n", - "
" - ], - "text/plain": [ - " solutions_bitstrings bitstrings_energies probabilities\n", - "0 111001100110 2.0 6.772599e-07\n", - "1 110110110100 2.0 6.772599e-07\n", - "2 100010110000 4.0 2.518399e-06\n", - "3 010100000100 4.0 1.779673e-05\n", - "4 101000100000 4.0 1.779673e-05" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "The probability of finding the optimal solution using the slack approach is: 0.2%\n" + ] } ], "source": [ - "qaoa_bin_dict = qaoa_bin.result.lowest_cost_bitstrings(5)\n", - "pd.DataFrame(qaoa_bin_dict)" - ] - }, - { - "cell_type": "markdown", - "id": "f6a5f3cc", - "metadata": {}, - "source": [ - "Chek the correct answer using the ground_state_hamiltonian and the 2 correct answer are in the best 5 best states." + "nstates = 10\n", + "results = results_slack.result.lowest_cost_bitstrings(nstates)\n", + "idx_opt = 0\n", + "p = 0\n", + "for n in range(nstates): # There are multiple optimal solutions, \n", + " # Let's check which states share the same enegry with the ground state\n", + " if results[\"bitstrings_energies\"][n] == results[\"bitstrings_energies\"][idx_opt]:\n", + " p += results[\"probabilities\"][n]\n", + "print(f\"The probability of finding the optimal solution using the slack approach is: {round(100*p,1)}%\")" ] }, { "cell_type": "code", "execution_count": 7, - "id": "a0bbc68b", + "id": "052f14d4", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "states kept: 10\n" + ] + }, { "data": { + "image/png": "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", "text/plain": [ - "(2.0, ['110110110100', '111001100110'])" + "
" ] }, - "execution_count": 7, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "# Check the exactly solution\n", - "sol = ground_state_hamiltonian(qaoa_bin.cost_hamil)\n", - "sol" + "fig, ax = plt.subplots(1,3, figsize=(30,5))\n", + "bpp_slack.plot_solution(results[\"solutions_bitstrings\"][0], ax=ax[0])\n", + "results_slack.result.plot_cost(ax=ax[1])\n", + "results_slack.result.plot_probabilities(n_states_to_keep=nstates, ax=ax[2])\n", + "t = ax[0].set_title(\"Optimal solution\")" ] }, { "cell_type": "markdown", - "id": "70ed22ec", + "id": "da6c04f3", "metadata": {}, "source": [ - "### 2.2 Solution using DOCPLEX\n", - "\n", - "The QUBO problem can be solved classically using DOCPLEX. This is a good comparision between QAOA against classical optimizers.\n", + "### 2 - Solve using unbalanced penalization\n", "\n", - "**Note: For the next cell you will need to install cplex with the command** `pip install cplex>=22.1.0.0` " + "For the penalty terms, we can use the tuned parameters presented in the original [unbalanced penalization paper](https://arxiv.org/abs/2211.13914)" ] }, { "cell_type": "code", "execution_count": 8, - "id": "ec103334", + "id": "90a4f75c", + "metadata": {}, + "outputs": [], + "source": [ + "penalty = [10, 2, 1] # [Equality, Inequality] constraints got from the unbalanced penalization paper\n", + "bpp_unbalanced = BinPacking(weights, weight_capacity, n_bins=n_bins, penalty=penalty, simplifications=False, method=\"unbalanced\")\n", + "qubo = bpp_unbalanced.qubo # Ising Hamiltonian of the BPP using the slack variables encoding \n", + "results_unbalanced = qaoa_result(qubo, p=5, maxiter=100)" + ] + }, + { + "cell_type": "markdown", + "id": "0aca51e4", + "metadata": {}, + "source": [ + "Once again let's analywe the results of the QAOA optimization:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0401841a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "objective: 2.000\n", - " y_0=1\n", - " y_1=1\n", - " x_0_0=0\n", - " x_0_1=1\n", - " x_1_0=1\n", - " x_1_1=0\n", - " slack_C2_0=1\n", - " slack_C2_1=1\n", - " slack_C2_2=0\n", - " slack_C3_0=1\n", - " slack_C3_1=0\n", - " slack_C3_2=0\n" + "The probability of finding the optimal solution using unbalanced penalization is: 12.0%\n" ] } ], "source": [ - "# docplex QUBO model\n", - "mdl_qubo_bin = qubo_bin.qubo_docplex \n", - "\n", - "# Obtain the docplex solution\n", - "sol_bin_docplex = mdl_qubo_bin.solve()\n", - "sol_bin = {i.name: int(sol_bin_docplex.get_value(i)) for i in mdl_qubo_bin.iter_binary_vars()}\n", - "mdl_qubo_bin.print_solution(print_zeros=True)" + "nstates = 20\n", + "results = results_unbalanced.result.lowest_cost_bitstrings(nstates)\n", + "indx_opt = results[\"solutions_bitstrings\"].index(sol_cplex)\n", + "p = 0\n", + "for n in range(nstates): # There are multiple optimal solutions, \n", + " # Let's check which states share the same enegry with the ground state\n", + " if results[\"bitstrings_energies\"][n] == results[\"bitstrings_energies\"][0]:\n", + " p += results[\"probabilities\"][n]\n", + "print(f\"The probability of finding the optimal solution using unbalanced penalization is: {round(100*p,1)}%\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "661b6312", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "states kept: 20\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1,3, figsize=(30,5))\n", + "bpp_unbalanced.plot_solution(results[\"solutions_bitstrings\"][0], ax=ax[0])\n", + "results_unbalanced.result.plot_cost(ax=ax[1])\n", + "results_unbalanced.result.plot_probabilities(n_states_to_keep=nstates, ax=ax[2])\n", + "title=ax[0].set_title(\"Optimal solution\")" ] }, { "cell_type": "markdown", - "id": "0535b083", + "id": "ee9c120e", "metadata": {}, "source": [ - "The solution is `110110110100`, being one state as in the quantum algorithm" + "# Conclusion \n", + "\n", + "In this notebook, we tested the BPP using `openqaoa` for a three items problem with QAOA $p=5$. The results are presented for the unbalanced penalization and slack encodings. The unbalanced penalization reduces the number of qubit needed to represent the problems and therefore improves considerably the probability of obtaining the optimal solution compared to the slack variables approach." ] + }, + { + "cell_type": "markdown", + "id": "8b3c4264", + "metadata": {}, + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "docplex", + "display_name": "oq_latest", "language": "python", - "name": "docplex" + "name": "oq_latest" }, "language_info": { "codemirror_mode": { @@ -468,7 +381,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.10.0" } }, "nbformat": 4, From 00269e634852eefdaac3943978fb8ecc31679c89 Mon Sep 17 00:00:00 2001 From: KilianPoirier Date: Wed, 22 Nov 2023 11:19:33 +0000 Subject: [PATCH 24/28] Removed pyquil from global package --- Makefile | 10 +++++----- setup.py | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/Makefile b/Makefile index e144f4486..72305c260 100644 --- a/Makefile +++ b/Makefile @@ -5,7 +5,7 @@ local-install: pip install ./src/openqaoa-core pip install ./src/openqaoa-qiskit - pip install ./src/openqaoa-pyquil +# pip install ./src/openqaoa-pyquil pip install ./src/openqaoa-braket pip install ./src/openqaoa-azure pip install . @@ -14,7 +14,7 @@ local-install: dev-install: pip install -e ./src/openqaoa-core pip install -e ./src/openqaoa-qiskit - pip install -e ./src/openqaoa-pyquil +# pip install -e ./src/openqaoa-pyquil pip install -e ./src/openqaoa-braket pip install -e ./src/openqaoa-azure pip install -e . @@ -23,7 +23,7 @@ dev-install: dev-install-tests: pip install -e ./src/openqaoa-core[tests] pip install -e ./src/openqaoa-qiskit - pip install -e ./src/openqaoa-pyquil +# pip install -e ./src/openqaoa-pyquil pip install -e ./src/openqaoa-braket pip install -e ./src/openqaoa-azure pip install -e . @@ -32,7 +32,7 @@ dev-install-tests: dev-install-docs: pip install -e ./src/openqaoa-core[docs] pip install -e ./src/openqaoa-qiskit - pip install -e ./src/openqaoa-pyquil +# pip install -e ./src/openqaoa-pyquil pip install -e ./src/openqaoa-braket pip install -e ./src/openqaoa-azure pip install -e . @@ -41,7 +41,7 @@ dev-install-docs: dev-install-all: pip install -e ./src/openqaoa-core[all] pip install -e ./src/openqaoa-qiskit - pip install -e ./src/openqaoa-pyquil +# pip install -e ./src/openqaoa-pyquil pip install -e ./src/openqaoa-braket pip install -e ./src/openqaoa-azure pip install -e . diff --git a/setup.py b/setup.py index fba7e87db..fd9bc2f68 100644 --- a/setup.py +++ b/setup.py @@ -13,7 +13,7 @@ requirements = [ f"{each_folder_name}=={version}" for each_folder_name in os.listdir("src") - if "openqaoa-" in each_folder_name + if ("openqaoa-" in each_folder_name and "openqaoa-pyquil" not in each_folder_name) ] setup( From b0b84c55a0d5c452929f38d26c13b00592c31407 Mon Sep 17 00:00:00 2001 From: KilianPoirier Date: Thu, 23 Nov 2023 09:07:59 +0000 Subject: [PATCH 25/28] Remove pyquil tests from the pipeline TEMPORARILY --- .github/workflows/test_dev.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test_dev.yml b/.github/workflows/test_dev.yml index f2c7b3d84..da339fd64 100644 --- a/.github/workflows/test_dev.yml +++ b/.github/workflows/test_dev.yml @@ -63,7 +63,7 @@ jobs: run: | source env/bin/activate ipython kernel install --name "env" --user - pytest tests/ src/*/tests -m 'not (qpu or sim)' --cov -n auto + pytest tests/ src/openqaoa-core/tests src/openqaoa-azure/tests src/openqaoa-braket/tests src/openqaoa-qiskit/tests -m 'not (qpu or sim)' --cov -n auto - name: Upload coverage reports to Codecov with GitHub Action uses: codecov/codecov-action@v3 with: From 710f97d07a78b96447beb0162d455e6989fbc2dc Mon Sep 17 00:00:00 2001 From: KilianPoirier Date: Thu, 23 Nov 2023 09:22:05 +0000 Subject: [PATCH 26/28] Remove pyquil from main test pipeline TEMPORARILY --- .github/workflows/test_main_linux.yml | 2 +- .github/workflows/test_main_macos.yml | 2 +- .github/workflows/test_main_windows.yml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/test_main_linux.yml b/.github/workflows/test_main_linux.yml index 65b39c541..158947692 100644 --- a/.github/workflows/test_main_linux.yml +++ b/.github/workflows/test_main_linux.yml @@ -67,7 +67,7 @@ jobs: run: | source env/bin/activate ipython kernel install --name "env" --user - pytest tests/ src/*/tests -m 'not (qpu or sim)' --cov --cov-report=xml:coverage.xml + pytest tests/ src/openqaoa-core/tests src/openqaoa-azure/tests src/openqaoa-braket/tests src/openqaoa-qiskit/tests -m 'not (qpu or sim)' --cov --cov-report=xml:coverage.xml - name: Upload coverage reports to Codecov with GitHub Action uses: codecov/codecov-action@v3 diff --git a/.github/workflows/test_main_macos.yml b/.github/workflows/test_main_macos.yml index f1a3fc0fd..c60dd7d9b 100644 --- a/.github/workflows/test_main_macos.yml +++ b/.github/workflows/test_main_macos.yml @@ -56,4 +56,4 @@ jobs: run: | source env/bin/activate ipython kernel install --user --name "env" - pytest tests/ src/*/tests -m 'not (qpu or api or docker_aws or braket_api or sim)' + pytest tests/ src/openqaoa-core/tests src/openqaoa-azure/tests src/openqaoa-braket/tests src/openqaoa-qiskit/tests -m 'not (qpu or api or docker_aws or braket_api or sim)' diff --git a/.github/workflows/test_main_windows.yml b/.github/workflows/test_main_windows.yml index 3fcd9d93e..061e1929e 100644 --- a/.github/workflows/test_main_windows.yml +++ b/.github/workflows/test_main_windows.yml @@ -63,5 +63,5 @@ jobs: run: | .\env\Scripts\Activate.ps1 ipython kernel install --name "env" --user - pytest \tests -m 'not (qpu or api or docker_aws or braket_api or sim)' + pytest tests/ src/openqaoa-core/tests src/openqaoa-azure/tests src/openqaoa-braket/tests src/openqaoa-qiskit/tests -m 'not (qpu or api or docker_aws or braket_api or sim)' Get-ChildItem -Directory | ForEach-Object { pytest $_.FullName -m 'not (qpu or api or docker_aws or braket_api or sim)'} From 311761028e2989cd7f497a4b74bbf59ba9a157b8 Mon Sep 17 00:00:00 2001 From: KilianPoirier Date: Thu, 23 Nov 2023 09:46:56 +0000 Subject: [PATCH 27/28] Removed more pyquil related tests TEMPORARILY + changed back of one notebook --- examples/community_tutorials/02_docplex_example.ipynb | 4 ++-- tests/test_imports.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/examples/community_tutorials/02_docplex_example.ipynb b/examples/community_tutorials/02_docplex_example.ipynb index 6264780cd..955abcf8c 100644 --- a/examples/community_tutorials/02_docplex_example.ipynb +++ b/examples/community_tutorials/02_docplex_example.ipynb @@ -1082,8 +1082,8 @@ } ], "source": [ - "#Specific local device usign qiskit backend\n", - "device = create_device(\"local\", 'pyquil.statevector_simulator')\n", + "#Specific local device usign local vectorized backend\n", + "device = create_device(\"local\", 'vectorized')\n", "\n", "#Is possible check the devices using qaoa.local_simulators, qaoa.cloud_provider\n", "qaoa = QAOA(device)\n", diff --git a/tests/test_imports.py b/tests/test_imports.py index 1928d0430..2fdaf5de0 100644 --- a/tests/test_imports.py +++ b/tests/test_imports.py @@ -17,7 +17,7 @@ def test_all_module_import(self): """ folder_names = [ - each_file for each_file in os.listdir("src") if "openqaoa-" in each_file + each_file for each_file in os.listdir("src") if ("openqaoa-" in each_file and not "openqaoa-pyquil") ] packages_import = [] From 3c765476c95c5dc81f7df8de4f7ae06c26564cc0 Mon Sep 17 00:00:00 2001 From: KilianPoirier Date: Mon, 27 Nov 2023 08:02:36 +0000 Subject: [PATCH 28/28] Remove duplicate requirement myst_parser --- docs/requirements.txt | 2 -- 1 file changed, 2 deletions(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index f0dc39b3c..e161750e8 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -12,5 +12,3 @@ amazon-braket-sdk==1.23.0 autograd>=1.4 semantic_version>=2.10 autoray>=0.3.1 -myst_parser>=2.0.0 -# myst_nb