qhyper 0.dev1__py3-none-any.whl

QHyper/solvers/vqa/base.py

@@ -0,0 +1,108 @@
+from dataclasses import dataclass
+import numpy as np
+from typing import Optional, Any, cast
+import numpy.typing as npt
+
+from QHyper.problems.base import Problem
+
+from QHyper.optimizers import OPTIMIZERS_BY_NAME
+from QHyper.optimizers.base import Optimizer
+from .pqc.base import PQC
+
+from QHyper.solvers.base import Solver
+from QHyper.solvers.vqa import PQC_BY_NAME
+
+
+@dataclass
+class OptWrapper:
+    pqc: PQC
+    problem: Problem
+    hyper_params: npt.NDArray[np.float64]
+
+    def __call__(self, args: npt.NDArray[np.float64]) -> float:
+        return self.pqc.run_opt(self.problem, args, self.hyper_params)
+
+
+@dataclass
+class Wrapper:
+    pqc: PQC
+    problem: Problem
+    optimizer: Optional[Optimizer]
+    params_config: dict[str, Any]
+
+    def __call__(self, hargs: npt.NDArray[np.float64]) -> float:
+        opt_args = self.pqc.get_opt_args(self.params_config, hyper_args=hargs)
+        opt_wrapper = OptWrapper(self.pqc, self.problem, hargs)
+
+        if self.optimizer:
+            value, _ = self.optimizer.minimize(opt_wrapper, opt_args)
+        else:
+            value = opt_wrapper(opt_args)
+        return value
+
+
+@dataclass
+class VQA(Solver):
+    problem: Problem
+    pqc: PQC
+    optimizer: Optional[Optimizer]
+
+    def __init__(
+            self,
+            problem: Problem,
+            pqc: PQC | str = "",
+            optimizer: Optimizer | str = "",
+            hyper_optimizer: Optimizer = None,
+            config: dict[str, dict[str, Any]] = {}
+    ) -> None:
+        self.problem = problem
+        self.hyper_optimizer = hyper_optimizer
+
+        if isinstance(pqc, str):
+            if pqc == "":
+                try:
+                    pqc = config['pqc'].pop('type')
+                except KeyError:
+                    raise Exception("Configuration for PQC was not provided")
+            self.pqc = PQC_BY_NAME[cast(str, pqc)](**config.get('pqc', {}))
+        else:
+            self.pqc = pqc
+
+        if isinstance(optimizer, str):
+            if optimizer == "" and 'optimizer' not in config:
+                self.optimizer = None
+            else:
+                if optimizer == "":
+                    optimizer = config['optimizer'].pop('type')
+                self.optimizer = OPTIMIZERS_BY_NAME[cast(str, optimizer)](
+                    **config.get('optimizer', {}))
+        else:
+            self.optimizer = optimizer
+
+    def solve(self, params_inits: dict[str, Any]) -> Any:
+        hyper_args = self.pqc.get_hopt_args(params_inits)
+
+        if self.hyper_optimizer:
+            # TODO
+            wrapper = Wrapper(
+                self.pqc, self.problem, self.optimizer, params_inits)
+            _, best_hargs = self.hyper_optimizer.minimize(wrapper, hyper_args)
+        else:
+            best_hargs = hyper_args
+
+        opt_args = self.pqc.get_opt_args(params_inits, hyper_args=best_hargs)
+        opt_wrapper = OptWrapper(self.pqc, self.problem, hyper_args)
+        if self.optimizer:
+            _, best_opt_args = self.optimizer.minimize(opt_wrapper, opt_args)
+        else:
+            best_opt_args = opt_args
+
+        return self.pqc.get_params_init_format(best_opt_args, best_hargs)
+
+    def evaluate(
+            self, params_inits: dict[str, Any], print_results: bool = False
+    ) -> float:
+        hyper_args = self.pqc.get_hopt_args(params_inits)
+        opt_args = self.pqc.get_opt_args(params_inits)
+        return self.pqc.run_opt(
+            self.problem, opt_args, hyper_args, print_results)

QHyper/solvers/vqa/eval_funcs/base.py

@@ -0,0 +1,40 @@
+from abc import abstractmethod
+
+from QHyper.problems.base import Problem
+
+
+class EvalFunc:
+    """
+    Abstract base class for evaluation functions.
+
+    Methods
+    -------
+    evaluate(results, problem, const_params)
+        Evaluate the results based on the problem and constant parameters.
+    """
+
+    @abstractmethod
+    def evaluate(
+        self,
+        results: dict[str, float],
+        problem: Problem,
+        const_params: list[float]
+    ) -> float:
+        """
+        Evaluate the results based on the problem and constant parameters.
+
+        Parameters
+        ----------
+        results : dict[str, float]
+            The results to be evaluated.
+        problem : Problem
+            The problem definition.
+        const_params : list[float]
+            The constant parameters.
+
+        Returns
+        -------
+        float
+            The evaluation result.
+        """
+        ...

QHyper/solvers/vqa/eval_funcs/wfeval.py

@@ -0,0 +1,32 @@
+from .base import EvalFunc
+from QHyper.problems.base import Problem
+
+
+class WFEval(EvalFunc):
+    def __init__(self, penalty: float = 0) -> None:
+        self.penalty = penalty
+
+    def evaluate(
+            self,
+            results: dict[str, float],
+            problem: Problem,
+            const_params: list[float]
+    ) -> float:
+        score: float = 0
+
+        sorted_results = {
+            k: v for k, v in
+            sorted(
+                results.items(),
+                key=lambda item: item[1],
+                reverse=True
+            )[:40]
+        }
+
+        # print(sorted_results)
+        scaler = 1/sum([v for v in sorted_results.values()])
+        # print(scaler)
+
+        for result, prob in sorted_results.items():
+            score += scaler * prob * problem.get_score(result, self.penalty)
+        return score

QHyper/solvers/vqa/pqc/base.py

@@ -0,0 +1,133 @@
+from abc import abstractmethod
+
+import numpy as np
+import numpy.typing as npt
+from typing import Any, Optional
+
+from QHyper.problems.base import Problem
+
+
+PQCResults = tuple[dict[str, float], list[float]]
+
+
+class PQC:
+    """
+    Abstract base class for Parameterized Quantum Circuit (PQC).
+
+    Attributes
+    ----------
+    pqc_type : str
+        Type of the parameterized quantum circuit.
+    """
+
+    pqc_type: str
+
+    @abstractmethod
+    def __init__(self, **kwargs: Any) -> None: ...
+
+    @abstractmethod
+    def run_opt(
+        self,
+        problem: Problem,
+        opt_args: npt.NDArray[np.float64],
+        hyper_args: npt.NDArray[np.float64]
+    ) -> float:
+        """
+        Run optimization using the PQC.
+
+        Parameters
+        ----------
+        problem : Problem
+            The problem to be solved.
+        opt_args : npt.NDArray[np.float64]
+            Optimization arguments.
+        hyper_args : npt.NDArray[np.float64]
+            Hyperparameter optimization arguments.
+
+        Returns
+        -------
+        float
+            The result of the optimization.
+        """
+        ...
+
+    @abstractmethod
+    def get_opt_args(
+        self,
+        params_init: dict[str, Any],
+        args: Optional[npt.NDArray[np.float64]] = None,
+        hyper_args: Optional[npt.NDArray[np.float64]] = None
+    ) -> npt.NDArray[np.float64]:
+        """
+        Get optimization arguments. This method should return arguments for
+        optimizer. These arguments may come from initial parameters
+        (params_init) or might be override by args or hyper_args.
+
+        Parameters
+        ----------
+        params_init : dict[str, Any]
+            Initial parameters for the optimization.
+        args : Optional[npt.NDArray[np.float64]], optional
+            Additional arguments, by default None.
+        hyper_args : Optional[npt.NDArray[np.float64]], optional
+            Hyperparameter optimization arguments, by default None.
+
+        Returns
+        -------
+        npt.NDArray[np.float64]
+            Optimization arguments.
+        """
+        ...
+
+    @abstractmethod
+    def get_hopt_args(
+        self,
+        params_init: dict[str, Any],
+        args: Optional[npt.NDArray[np.float64]] = None,
+        hyper_args: Optional[npt.NDArray[np.float64]] = None
+    ) -> npt.NDArray[np.float64]:
+        """
+        Get hyperparameter optimization arguments.
+        This method should return arguments for hyperoptimizer.
+        These arguments may come from initial parameters
+        (params_init) or might be override by args or hyper_args.
+
+        Parameters
+        ----------
+        params_init : dict[str, Any]
+            Initial parameters for the optimization.
+        args : Optional[npt.NDArray[np.float64]], optional
+            Additional arguments, by default None.
+        hyper_args : Optional[npt.NDArray[np.float64]], optional
+            Hyperparameter optimization arguments, by default None.
+
+        Returns
+        -------
+        npt.NDArray[np.float64]
+            Hyperparameter optimization arguments.
+        """
+        ...
+
+    @abstractmethod
+    def get_params_init_format(
+        self,
+        opt_args: npt.NDArray[np.float64],
+        hyper_args: npt.NDArray[np.float64]
+    ) -> dict[str, Any]:
+        """
+        Get initial params format. Method changes opt_args and hyper_args into
+        dict in same format at provided params_init in different methods.
+
+        Parameters
+        ----------
+        opt_args : npt.NDArray[np.float64]
+            Optimization arguments.
+        hyper_args : npt.NDArray[np.float64]
+            Hyperparameter optimization arguments.
+
+        Returns
+        -------
+        dict[str, Any]
+            Initial arguments.
+        """
+        ...

QHyper/solvers/vqa/pqc/h_qaoa.py

@@ -0,0 +1,86 @@
+from dataclasses import dataclass
+import pennylane as qml
+import numpy as np
+
+import numpy.typing as npt
+from typing import Any, Callable, cast, Optional
+
+from QHyper.problems.base import Problem
+
+from QHyper.solvers.vqa.pqc.qaoa import QAOA
+from QHyper.solvers.converter import Converter
+from QHyper.solvers.vqa.eval_funcs.wfeval import WFEval
+
+
+@dataclass
+class HQAOA(QAOA):
+    layers: int = 3
+    mixer: str = "pl_x_mixer"
+    backend: str = "default.qubit"
+
+    def get_probs_func(self, problem: Problem, weights: list[float]
+                       ) -> Callable[[npt.NDArray[np.float64]], list[float]]:
+        """Returns function that takes angles and returns probabilities
+
+        Parameters
+        ----------
+        weights : list[float]
+            weights for converting Problem to QUBO
+
+        Returns
+        -------
+        Callable[[list[float]], float]
+            Returns function that takes angles and returns probabilities
+        """
+        qubo = Converter.create_qubo(problem, weights)
+        cost_operator = self._create_cost_operator(qubo)
+
+        @qml.qnode(self.dev)
+        def probability_circuit(params: npt.NDArray[np.float64]
+                                ) -> list[float]:
+            self._circuit(problem, params, cost_operator)
+            return cast(list[float],
+                        qml.probs(wires=[str(x) for x in problem.variables]))
+
+        return cast(Callable[[npt.NDArray[np.float64]], list[float]],
+                    probability_circuit)
+
+    def run_opt(
+        self,
+        problem: Problem,
+        opt_args: npt.NDArray[np.float64],
+        hyper_args: npt.NDArray[np.float64]
+    ) -> float:
+        self.dev = qml.device(
+            self.backend, wires=[str(x) for x in problem.variables])
+        # const_params = params_config['weights']
+        weights = list(opt_args[:1 + len(problem.constraints)])
+        probs = self.get_probs_func(problem, list(weights))(
+            opt_args[1 + len(problem.constraints):].reshape(2, -1))
+        results_by_probabilites = {
+            format(result, 'b').zfill(len(problem.variables)): float(prob)
+            for result, prob in enumerate(probs)
+        }
+        return WFEval().evaluate(results_by_probabilites, problem, weights)
+
+    def get_opt_args(
+        self,
+        params_init: dict[str, Any],
+        args: Optional[npt.NDArray[np.float64]] = None,
+        hyper_args: Optional[npt.NDArray[np.float64]] = None
+    ) -> npt.NDArray[np.float64]:
+        return np.concatenate((
+            hyper_args if hyper_args is not None
+            else params_init['hyper_args'],
+            np.array(args if args else params_init['angles']).flatten()
+        ))
+
+    def get_params_init_format(
+        self,
+        opt_args: npt.NDArray[np.float64],
+        hyper_args: npt.NDArray[np.float64]
+    ) -> dict[str, Any]:
+        return {
+            'angles': opt_args[len(hyper_args):],
+            'hyper_args': opt_args[:len(hyper_args)],
+        }

QHyper/solvers/vqa/pqc/mixers.py

@@ -0,0 +1,12 @@
+import pennylane as qml
+
+from typing import Iterable, Callable
+
+
+def mixer(wires: Iterable[str]) -> qml.Hamiltonian:
+    return qml.qaoa.x_mixer(wires)
+
+
+MIXERS_BY_NAME: dict[str, Callable[[Iterable[str]], qml.Hamiltonian]] = {
+    'pl_x_mixer': mixer
+}

QHyper/solvers/vqa/pqc/qaoa.py

@@ -0,0 +1,130 @@
+from dataclasses import dataclass
+import pennylane as qml
+import numpy as np
+from scipy.sparse import csr_matrix
+
+import numpy.typing as npt
+from typing import Any, Callable, cast, Optional
+
+from QHyper.problems.base import Problem
+
+from QHyper.solvers.vqa.pqc.base import PQC
+from QHyper.solvers.converter import QUBO, Converter
+
+from .mixers import MIXERS_BY_NAME
+
+
+@dataclass
+class QAOA(PQC):
+    layers: int = 3
+    backend: str = "default.qubit"
+    mixer: str = 'pl_x_mixer'
+
+    def _create_cost_operator(self, qubo: QUBO) -> qml.Hamiltonian:
+        result = qml.Identity(0)
+        for variables, coeff in qubo.items():
+            if not variables:
+                continue
+            tmp = coeff * (
+                0.5 * qml.Identity(str(variables[0]))
+                - 0.5 * qml.PauliZ(str(variables[0]))
+            )
+            if len(variables) == 2 and variables[0] != variables[1]:
+                tmp = tmp @ (
+                    0.5 * qml.Identity(str(variables[1]))
+                    - 0.5 * qml.PauliZ(str(variables[1]))
+                )
+            result += tmp
+        return result
+    
+    def _create_weight_free_hamiltonian(
+            self, problem: Problem) -> qml.Hamiltonian:
+        row = []
+        col = []
+        data = []
+
+        for i in range(2**len(problem.variables)):
+            row.append(i)
+            col.append(i)
+            data.append(problem.get_score(
+                format(i, 'b').zfill(len(problem.variables)),
+                penalty=0.1
+            ))
+        sparse_matrix = csr_matrix((data, (row, col)))
+        ham = qml.SparseHamiltonian(sparse_matrix, problem.variables)
+        return ham
+ 
+    def _hadamard_layer(self, problem: Problem) -> None:
+        for i in problem.variables:
+            qml.Hadamard(str(i))
+
+    def _create_mixing_hamiltonian(self, problem: Problem) -> qml.Hamiltonian:
+        if self.mixer not in MIXERS_BY_NAME:
+            raise Exception(f"Unknown {self.mixer} mixer")
+        return MIXERS_BY_NAME[self.mixer]([str(v) for v in problem.variables])
+
+    def _circuit(self, problem: Problem, params: npt.NDArray[np.float64],
+                 cost_operator: qml.Hamiltonian) -> None:
+
+        def qaoa_layer(gamma: list[float], beta: list[float]) -> None:
+            qml.qaoa.cost_layer(gamma, cost_operator)
+            qml.qaoa.mixer_layer(
+                beta, self._create_mixing_hamiltonian(problem))
+
+        self._hadamard_layer(problem)
+        qml.layer(qaoa_layer, self.layers, params[0], params[1])
+
+    def get_expval_circuit(self, problem: Problem, weights: list[float]
+                           ) -> Callable[[npt.NDArray[np.float64]], float]:
+        qubo = Converter.create_qubo(problem, weights)
+        cost_operator = self._create_cost_operator(qubo)
+
+        @qml.qnode(self.dev)
+        def expval_circuit(params: npt.NDArray[np.float64]) -> float:
+            self._circuit(problem, params, cost_operator)
+            return cast(float, qml.expval(
+                cost_operator
+                # self._create_weight_free_hamiltonian(problem)
+            ))
+
+        return cast(Callable[[npt.NDArray[np.float64]], float], expval_circuit)
+
+    def run_opt(
+        self,
+        problem: Problem,
+        opt_args: npt.NDArray[np.float64],
+        hyper_args: npt.NDArray[np.float64]
+    ) -> float:
+        self.dev = qml.device(
+            self.backend, wires=[str(x) for x in problem.variables])
+        return self.get_expval_circuit(problem, list(hyper_args))(
+            opt_args.reshape(2, -1))
+
+    def get_opt_args(
+        self,
+        params_init: dict[str, Any],
+        args: Optional[npt.NDArray[np.float64]] = None,
+        hyper_args: Optional[npt.NDArray[np.float64]] = None
+    ) -> npt.NDArray[np.float64]:
+        return args if args is not None else np.array(params_init['angles'])
+
+    def get_hopt_args(
+        self,
+        params_init: dict[str, Any],
+        args: Optional[npt.NDArray[np.float64]] = None,
+        hyper_args: Optional[npt.NDArray[np.float64]] = None
+    ) -> npt.NDArray[np.float64]:
+        return (
+            hyper_args if hyper_args is not None
+            else np.array(params_init['hyper_args'])
+        )
+
+    def get_params_init_format(
+        self,
+        opt_args: npt.NDArray[np.float64],
+        hyper_args: npt.NDArray[np.float64]
+    ) -> dict[str, Any]:
+        return {
+            'angles': opt_args,
+            'hyper_args': hyper_args,
+        }

QHyper/solvers/vqa/pqc/wf_qaoa.py

@@ -0,0 +1,80 @@
+from dataclasses import dataclass
+import pennylane as qml
+import numpy as np
+
+import numpy.typing as npt
+from typing import Callable, cast
+
+from QHyper.problems.base import Problem
+
+from QHyper.solvers.vqa.pqc.qaoa import QAOA
+from QHyper.solvers.converter import Converter
+from QHyper.solvers.vqa.eval_funcs.wfeval import WFEval
+
+
+@dataclass
+class WFQAOA(QAOA):
+    layers: int = 3
+    penalty: float = 0
+    mixer: str = "pl_x_mixer"
+    backend: str = "default.qubit"
+
+    def get_probs_func(self, problem: Problem, weights: list[float]
+                       ) -> Callable[[npt.NDArray[np.float64]], list[float]]:
+        """Returns function that takes angles and returns probabilities
+
+        Parameters
+        ----------
+        weights : list[float]
+            weights for converting Problem to QUBO
+
+        Returns
+        -------
+        Callable[[list[float]], float]
+            Returns function that takes angles and returns probabilities
+        """
+        qubo = Converter.create_qubo(problem, weights)
+        cost_operator = self._create_cost_operator(qubo)
+
+        @qml.qnode(self.dev)
+        def probability_circuit(params: npt.NDArray[np.float64]
+                                ) -> list[float]:
+            self._circuit(problem, params, cost_operator)
+            return cast(list[float],
+                        qml.probs(wires=[str(x) for x in problem.variables]))
+
+        return cast(Callable[[npt.NDArray[np.float64]], list[float]],
+                    probability_circuit)
+
+    def run_opt(
+        self,
+        problem: Problem,
+        opt_args: npt.NDArray[np.float64],
+        hyper_args: npt.NDArray[np.float64],
+        print_probabilities: bool = False
+    ) -> float:
+        self.dev = qml.device(
+            self.backend, wires=[str(x) for x in problem.variables])
+        probs = self.get_probs_func(problem, list(hyper_args))(
+            opt_args.reshape(2, -1))
+        
+        if isinstance(probs, qml.numpy.numpy_boxes.ArrayBox):
+            probs = probs._value
+        results_by_probabilites = {
+            format(result, 'b').zfill(len(problem.variables)): float(prob)
+            for result, prob in enumerate(probs)
+        }
+        if print_probabilities:
+            sorted_results = {
+                k: v for k, v in
+                sorted(
+                    results_by_probabilites.items(),
+                    key=lambda item: item[1],
+                    reverse=True
+                )[:8]
+            }
+            for k, v in sorted_results.items():
+                print(f'{k}, {v:.3f}, {problem.get_score(k)}')
+
+        return WFEval(self.penalty).evaluate(
+            results_by_probabilites, problem, list(hyper_args))

QHyper/util.py

@@ -0,0 +1,4 @@
+from typing import Union
+
+VARIABLES = Union[tuple[()], tuple[str], tuple[str, str], tuple[str, ...]]
+QUBO = dict[VARIABLES, float]

qhyper-0.dev1.dist-info/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Tomasz Lamża
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

qhyper-0.dev1.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.1
+Name: qhyper
+Version: 0.dev1
+Summary: Quantum and classical problem solvers
+Author: ACK Cyfronet AGH
+Author-email: tomasz.lamza@cyfronet.pl
+License: MIT
+Keywords: python,qhyper,quantum,solver,experiment
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: PennyLane
+Requires-Dist: tdqm
+Requires-Dist: sympy
+Requires-Dist: dwave-system
+Requires-Dist: gurobipy
+Requires-Dist: pandas
+Requires-Dist: wfcommons
+
+A package that allows to build and solve quantum and classical problems using predefined solvers and problems.