qhyper 0.dev1__tar.gz

qhyper-0.dev1/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/PKG-INFO

@@ -0,0 +1,18 @@
+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
+
+A package that allows to build and solve quantum and classical problems using predefined solvers and problems.

qhyper-0.dev1/QHyper/optimizers/__init__.py

@@ -0,0 +1,17 @@
+from typing import Type
+
+from .base import Optimizer
+
+from .cem import CEM
+from .qml_gradient_descent import QmlGradientDescent
+from .random import Random
+from .scipy_minimizer import ScipyOptimizer
+from .basinhopping import Basinhopping
+
+OPTIMIZERS_BY_NAME: dict[str, Type[Optimizer]] = {
+    'scipy': ScipyOptimizer,
+    'random': Random,
+    'qml': QmlGradientDescent,
+    'cem': CEM,
+    'basinhopping': Basinhopping
+}

qhyper-0.dev1/QHyper/optimizers/base.py

@@ -0,0 +1,39 @@
+from abc import abstractmethod
+import numpy as np
+
+import numpy.typing as npt
+from typing import Callable
+
+
+class Optimizer:
+    """
+    Abstract base class for optimizers.
+    """
+
+    @abstractmethod
+    def minimize(
+        self,
+        func: Callable[[npt.NDArray[np.float64]], float],
+        init: npt.NDArray[np.float64]
+    ) -> tuple[float, npt.NDArray[np.float64]]:
+        """
+        Abstract method that minimizes the given function using the implemented optimization algorithm.
+
+        Parameters
+        ----------
+        func : callable
+            The objective function to be minimized.
+        init : numpy.ndarray
+            The initial point for the optimization algorithm.
+
+        Returns
+        -------
+        tuple
+            A tuple containing the minimum function value and the corresponding optimal point.
+
+        Raises
+        ------
+        NotImplementedError
+            If the `minimize` method is not implemented by the derived class.
+        """
+        ...

qhyper-0.dev1/QHyper/optimizers/basinhopping.py

@@ -0,0 +1,79 @@
+from scipy.optimize import basinhopping
+import numpy as np
+import numpy.typing as npt
+from typing import Callable, Any
+
+from .base import Optimizer
+
+
+class Basinhopping(Optimizer):
+    """
+    Class for the Basin-hopping algorithm for global optimization.
+
+    Parameters
+    ----------
+    bounds : list[tuple[float, float]]
+        A list of tuples specifying the lower and upper bounds for each dimension of the search space.
+    niter : int
+        The number of basin-hopping iterations to perform.
+    maxfun : int, optional
+        Maximum number of function evaluations.
+        Default is 200.
+    config : dict, optional
+        Additional configuration options for the basinhopping function.
+        Default is an empty dictionary.
+
+    Attributes
+    ----------
+    niter : int
+        The number of basin-hopping iterations to perform.
+    maxfun : int
+        Maximum number of function evaluations.
+    bounds : numpy.ndarray
+        An array of shape (n, 2) specifying the lower and upper bounds for each dimension of the search space.
+    config : dict
+        Additional configuration options for the basinhopping function.
+    """
+    def __init__(
+            self,
+            bounds: list[tuple[float, float]],
+            niter: int,
+            maxfun: int = 200,
+            config: dict[str, Any] = {}
+    ) -> None:
+        self.niter = niter
+        self.maxfun = maxfun
+        self.bounds = np.array(bounds)
+        self.config = config
+
+    def minimize(
+        self,
+        func: Callable[[npt.NDArray[np.float64]], float],
+        init: npt.NDArray[np.float64]
+    ) -> tuple[float, npt.NDArray[np.float64]]:
+        """
+        Minimize the given function using the Basin-hopping algorithm.
+
+        Parameters
+        ----------
+        func : callable
+            The objective function to be minimized.
+            The function should take a single argument, which is a NumPy array of type np.float64,
+            and return a float value.
+        init : numpy.ndarray
+            The initial point for the optimization algorithm.
+            The array should have dtype np.float64.
+
+        Returns
+        -------
+        tuple
+            A tuple containing the minimum function value and the corresponding optimal point.
+        """
+        result = basinhopping(
+            func, init.flatten(), niter=self.niter,
+            minimizer_kwargs={
+                'options': {'maxfun': self.maxfun},
+                'bounds': self.bounds
+            }, **self.config)
+
+        return result.fun, np.array(result.x).reshape(init.shape)

qhyper-0.dev1/QHyper/optimizers/cem.py

@@ -0,0 +1,128 @@
+import multiprocessing as mp
+from dataclasses import dataclass, field
+
+from typing import Callable
+import numpy.typing as npt
+
+import numpy as np
+import tqdm
+
+from .base import Optimizer
+
+
+@dataclass
+class CEM(Optimizer):
+    bounds: npt.NDArray[np.float64]
+    epochs: int = 10
+    samples_per_epoch: int = 100
+    elite_frac: float = 0.1
+    processes: int = mp.cpu_count()
+    print_on_epochs: list[int] = field(default_factory=list)
+    disable_tqdm: bool = False
+    n_elite: int = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.n_elite: int = max(
+            int(self.samples_per_epoch * self.elite_frac), 1)
+        self.bounds = np.array(self.bounds)
+
+    """Implementation of the Cross Entropy Method for hyperparameter tuning
+
+    Attributes
+    ----------
+    epochs : int
+        number of epochs (default 10)
+    samples_per_epoch : int
+        number of samples in each epoch (default 100)
+    elite_frac : float
+        indicate the percent of how many top samples will be used to calculate
+        the mean and cov for the next epoch (default 0.1)
+    processes : int
+        number of processors that will be used (default cpu count)
+    n_elite : int
+        calulated by multiplying samples_per_epoch by elite_frac
+    print_on_epochs: list[int]
+        list indicating after which epochs print best results
+    disable_tqdm: bool
+        if set to True, tdqm will be disabled
+    """
+
+    def _get_points(
+            self,
+            mean: npt.NDArray[np.float64],
+            cov: npt.NDArray[np.float64]
+    ) -> list[npt.NDArray[np.float64]]:
+        hyperparams: list[npt.NDArray[np.float64]] = []
+        while len(hyperparams) < self.samples_per_epoch:
+            point = np.random.multivariate_normal(mean, cov)
+            if (
+                (self.bounds[:, 0] <= point).all()
+                and (point < self.bounds[:, 1]).all()
+            ):
+                hyperparams.append(point)
+
+        return hyperparams
+
+    def minimize(
+        self,
+        func: Callable[[npt.NDArray[np.float64]], float],
+        init: npt.NDArray[np.float64]
+    ) -> tuple[float, npt.NDArray[np.float64]]:
+        """Returns hyperparameters which lead to the lowest values
+            returned by optimizer
+
+        Parameters
+        ----------
+        func_creator : Callable[[ArgsType], Callable[[ArgsType], float]]
+            function which receives hyperparameters, and returns
+            a function which will be optimized using an optimizer
+        optimizer : Optimizer
+            object of the Optimizer class
+        init : ArgsType
+            initial args for optimizer
+        hyperparams_init : ArgsType
+            initial hyperparameters
+        evaluation_func : Callable[[ArgsType], Callable[[ArgsType], float]]
+            function, which receives hyperparameters, and returns
+            function which receives params and return evaluation
+        bounds : list[float]
+            bounds for hyperparameters (default None)
+
+        Returns
+        -------
+        ArgsType
+            hyperparameters which lead to the lowest values
+            returned by the optimizer
+        """
+        # wrapper = Wrapper(func_creator, optimizer, evaluation_func, init)
+        _init = np.array(init)
+        mean = _init
+        cov = np.identity(len(_init))
+        best_hyperparams = _init
+        best_score = func(_init)
+
+        for _ in range(1, self.epochs+1):
+            hyperparams = self._get_points(mean, cov)
+
+            with mp.Pool(processes=self.processes) as p:
+                results = list(tqdm.tqdm(
+                    p.imap(func, hyperparams),
+                    total=len(hyperparams),
+                    disable=self.disable_tqdm
+                ))
+
+            elite_idxs = np.array(results).argsort()[:self.n_elite]
+
+            elite_weights = [hyperparams[i].flatten() for i in elite_idxs]
+
+            best_hyperparams = elite_weights[0].reshape(_init.shape)
+
+            reward = func(best_hyperparams)
+            if reward < best_score:
+                best_hyperparams = best_hyperparams
+                best_score = reward
+
+            mean = np.mean(elite_weights, axis=0)
+            cov = np.cov(np.stack((elite_weights), axis=1), bias=True)
+
+        return func(best_hyperparams), best_hyperparams

qhyper-0.dev1/QHyper/optimizers/qml_gradient_descent.py

@@ -0,0 +1,72 @@
+from typing import Callable
+import numpy.typing as npt
+
+import pennylane as qml
+from pennylane import numpy as np
+
+from .base import Optimizer
+
+
+class QmlGradientDescent(Optimizer):
+    """Gradient Descent Optimizer
+
+    Using GradientDescentOptimizer from library PennyLane.
+
+    Attributes
+    ----------
+    optimizer : qml.GradientDescentOptimizer
+        object of class GradientDescentOptimizer or inheriting from this class
+    optimization_steps : int
+        number of optimization steps
+    """
+
+    def __init__(
+        self,
+        optimizer: qml.GradientDescentOptimizer = None,
+        optimization_steps: int = 200
+    ) -> None:
+        """
+        Parameters
+        ----------
+        optimizer : qml.GradientDescentOptimizer
+            object of class GradientDescentOptimizer
+            or inheriting from this class
+        optimization_steps : int
+            number of optimization steps
+        """
+
+        self.optimizer = optimizer if optimizer else qml.AdamOptimizer(
+            stepsize=0.005
+        ) 
+        self.optimization_steps = optimization_steps
+
+    def minimize(
+        self,
+        func: Callable[[npt.NDArray[np.float64]], float],
+        init: npt.NDArray[np.float64]
+    ) -> tuple[float, npt.NDArray[np.float64]]:
+        """Returns params which lead to the lowest value of
+            the provided function and cost history
+
+        Parameters
+        ----------
+        func : Callable[[ArgsType], float]
+            function which will be minimized
+        init : ArgsType
+            initial args for optimizer
+
+        Returns
+        -------
+        tuple[ArgsType, Any]
+            Returns tuple which contains params taht lead to the lowest value
+            of the provided function and cost history
+        """
+
+        cost_history = []
+        params = np.array(init, requires_grad=True)
+        if "reset" in dir(self.optimizer):
+            self.optimizer.reset()
+        for _ in range(self.optimization_steps):
+            params, cost = self.optimizer.step_and_cost(func, params)
+            cost_history.append(cost)
+        return cost, params

qhyper-0.dev1/QHyper/optimizers/random.py

@@ -0,0 +1,90 @@
+from dataclasses import dataclass
+import multiprocessing as mp
+from typing import Callable
+import numpy.typing as npt
+
+import numpy as np
+import tqdm
+
+from .base import Optimizer
+
+
+@dataclass
+class Random(Optimizer):
+    number_of_samples: int
+    processes: int
+    disable_tqdm: bool
+    bounds: npt.NDArray[np.float64]
+
+    def __init__(
+        self,
+        bounds: list[tuple[float, float]],
+        number_of_samples: int = 100,
+        processes: int = 1,
+        disable_tqdm: bool = False,
+    ) -> None:
+        """
+        Parameters
+        ----------
+        number_of_samples : int
+            number of random samples (default 100)
+        processes : int
+            number of processors that will be used (default cpu count)
+        disable_tqdm: bool
+            if set to True, tdqm will be disabled (default False)
+        """
+
+        self.number_of_samples: int = number_of_samples
+        self.processes: int = processes
+        self.disable_tqdm: bool = disable_tqdm
+        self.bounds = np.array(bounds)
+
+    def minimize(
+        self,
+        func: Callable[[npt.NDArray[np.float64]], float],
+        init: npt.NDArray[np.float64]
+    ) -> tuple[float, npt.NDArray[np.float64]]:
+        """Returns hyperparameters which lead to the lowest values
+            returned by the optimizer
+
+        Parameters
+        ----------
+        func_creator : Callable[[ArgsType], Callable[[ArgsType], float]]
+            function which receives hyperparameters and returns
+            a function which will be optimized using the optimizer
+        optimizer : Optimizer
+            object of the Optimizer class
+        init : ArgsType
+            initial args for the optimizer
+        hyperparams_init : ArgsType
+            initial hyperparameters
+        evaluation_func : Callable[[ArgsType], Callable[[ArgsType], float]]
+            function, which receives hyperparameters, and returns
+            function which receives params and return evaluation
+        bounds : list[float]
+            bounds for hyperparameters (default None)
+
+        Returns
+        -------
+        ArgsType
+            Returns hyperparameters which lead to the lowest values
+            returned by the optimizer
+        """
+        hyperparams_init = np.array(init)
+        hyperparams = (
+            (self.bounds[:, 1] - self.bounds[:, 0])
+            * np.random.rand(self.number_of_samples, *hyperparams_init.shape)
+            + self.bounds[:, 0])
+
+        # results = [func(hyperparam) for hyperparam in hyperparams]
+        with mp.Pool(processes=self.processes) as p:
+            results = list(tqdm.tqdm(
+                p.imap(func, hyperparams),
+                total=self.number_of_samples,
+                disable=self.disable_tqdm
+            ))
+
+        min_idx = np.argmin(results)
+        return results[min_idx], hyperparams[min_idx]
+        # return HyperOptimizerResults.from_solver_results(
+        #     results[min_idx], hyperparams[min_idx])

qhyper-0.dev1/QHyper/optimizers/scipy_minimizer.py

@@ -0,0 +1,65 @@
+import numpy.typing as npt
+from typing import Optional, Callable
+
+import scipy
+import numpy as np
+
+from .base import Optimizer
+
+
+class ScipyOptimizer(Optimizer):
+    """
+    Class for the SciPy minimizer.
+
+    Attributes
+    ----------
+    maxfun : int
+        Maximum number of function evaluations.
+    bounds : list[tuple[float, float]] or None
+        A list of tuples specifying the lower and upper bounds for each dimension of the search space,
+        or None if no bounds are provided.
+    """
+    def __init__(
+            self,
+            maxfun: int,
+            bounds: Optional[list[tuple[float, float]]] = None
+    ) -> None:
+        self.maxfun = maxfun
+        self.bounds = bounds
+
+    def minimize(
+        self,
+        func: Callable[[npt.NDArray[np.float64]], float],
+        init: npt.NDArray[np.float64]
+    ) -> tuple[float, npt.NDArray[np.float64]]:
+        """
+        Minimize the given function using the SciPy minimize.
+
+        Parameters
+        ----------
+        func : callable
+            The objective function to be minimized.
+            The function should take a single argument, which is a NumPy array of type np.float64,
+            and return a float value.
+        init : numpy.ndarray
+            The initial point for the optimization algorithm.
+            The array should have dtype np.float64.
+
+        Returns
+        -------
+        tuple
+            A tuple containing the minimum function value and the corresponding optimal point.
+        """
+        def wrapper(params: npt.NDArray[np.float64]) -> float:
+            return func(np.array(params).reshape(np.array(init).shape))
+
+        result = scipy.optimize.minimize(
+            wrapper,
+            np.array(init).flatten(),
+            bounds=(
+                self.bounds if self.bounds is not None
+                else [(0, 2*np.pi)]*len(np.array(init).flatten())
+            ),
+            options={'maxfun': self.maxfun}
+        )
+        return result.fun, result.x.reshape(np.array(init).shape)

qhyper-0.dev1/QHyper/problems/base.py

@@ -0,0 +1,62 @@
+from abc import ABC
+
+import sympy
+
+from QHyper.hyperparameter_gen.parser import Expression
+
+
+class Problem(ABC):
+    """Interface for different combinatorial optimization problems
+
+    Objective function and constrians are the main components
+    and should be written in the SymPy syntax.
+    Depending on the selcted solver, these parts can be used
+    separately or, e.g., as a Quadratic Unconstrained
+    Binary Optimization (QUBO) formularion.
+
+    If the QUBO is provided, it should be passed to the
+    objective_function and the constraints should be empty.
+
+    Attributes
+    ----------
+    objective_function: Expression
+        objective function in SymPy syntax
+    constraints : list[Expression]
+        list of constraints in SymPy syntax
+    variables : list[Any]
+        list of variables in the problem
+    name: str
+        helps to differentiate various problems (default "")
+    cases: int
+        number of variable cases (values)
+        (default 1 - denoting binary variable)
+    """
+
+    objective_function: Expression
+    constraints: list[Expression]
+    variables: tuple[sympy.Symbol]
+    name: str = ""
+    cases: int = 1
+
+    def get_score(self, result: str, penalty: float = 0) -> float:
+        """Returns score of the outcome provided as a binary string
+
+        Necessary to evaluate results.
+
+        Parameters
+        ----------
+        result : str
+            outcome as a string of zeros and ones
+
+        Returns
+        -------
+        float
+            Returns float indicating the score, if function should be
+            maximized the returned value should be returned with negative sign
+        """
+        raise Exception("Unimplemented")
+
+    def __repr__(self) -> str:
+        if self.name == "":
+            return super().__repr__()
+        return f"{self.__class__.__name__}_{self.name}"