qhyper 0.2.0__tar.gz → 0.2.1__tar.gz

{qhyper-0.2.0/qhyper.egg-info → qhyper-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qhyper
-Version: 0.2.0
+Version: 0.2.1
 Summary: Quantum and classical problem solvers
 Author: ACK Cyfronet AGH
 Author-email: tomasz.lamza@cyfronet.pl

qhyper-0.2.1/QHyper/solvers/classical/gurobi.py

@@ -0,0 +1,87 @@
+# This work was supported by the EuroHPC PL infrastructure funded at the
+# Smart Growth Operational Programme (2014-2020), Measure 4.2
+# under the grant agreement no. POIR.04.02.00-00-D014/20-00
+
+
+from typing import Any, Optional
+
+import gurobipy as gp
+from QHyper.problems.base import Problem
+from QHyper.solvers.base import Solver
+from QHyper.polynomial import Polynomial
+from QHyper.constraint import Operator
+
+
+def polynomial_to_gurobi(gurobi_vars: dict[str, Any], poly: Polynomial) -> Any:
+    cost_function_1: float = 0
+    for vars, coeff in poly.terms.items():
+        tmp = 1
+        for v in vars:
+            tmp *= gurobi_vars[v]
+        cost_function_1 += tmp * coeff
+    return cost_function_1
+
+
+class Gurobi(Solver):  # todo works only for quadratic expressions
+    """
+    Gurobi solver class.
+
+    Attributes
+    ----------
+    problem : Problem
+        The problem to be solved.
+    model_name : str, optional
+        The name of the gurobi model.
+    mip_gap : float | None, optional
+        The MIP gap.
+    """
+
+    problem: Problem
+    model_name: str
+    mip_gap: float | None
+
+    def __init__(self, problem: Problem, model_name: str = "",
+                 mip_gap: float | None = None) -> None:
+        self.problem = problem
+        self.model_name = model_name
+        self.mip_gap = mip_gap
+
+    def solve(self, params_inits: Optional[dict[str, Any]] = None) -> Any:
+        gpm = gp.Model(self.model_name)
+        if self.mip_gap:
+            gpm.Params.MIPGap = self.mip_gap
+
+        vars = {
+            str(var_name): gpm.addVar(vtype=gp.GRB.BINARY, name=str(var_name))
+            for var_name in self.problem.objective_function.get_variables().union(
+                [con.get_variables() for con in self.problem.constraints]
+            )
+        }
+
+        objective_function = polynomial_to_gurobi(
+            vars, self.problem.objective_function
+        )
+        gpm.setObjective(objective_function, gp.GRB.MINIMIZE)
+
+        for i, constraint in enumerate(self.problem.constraints):
+            lhs = polynomial_to_gurobi(vars, constraint.lhs)
+            rhs = polynomial_to_gurobi(vars, constraint.rhs)
+            if constraint.operator == Operator.EQ:
+                gpm.addConstr(lhs == rhs, f"constr_{i}")
+            elif constraint.operator == Operator.LE:
+                gpm.addConstr(lhs <= rhs, f"constr_{i}")
+            elif constraint.operator == Operator.GE:
+                gpm.addConstr(lhs >= rhs, f"constr_{i}")
+
+            gpm.update()
+        gpm.optimize()
+
+        # print("Status ", gpm.Status)
+        # print("Is optimal? ", GRB.OPTIMAL)
+
+        allvars = gpm.getVars()
+        solution = {}
+        for v in allvars:
+            solution[v.VarName] = v.X
+
+        return solution

qhyper-0.2.1/QHyper/solvers/quantum_annealing/advantage.py

@@ -0,0 +1,192 @@
+from typing import Any
+import numpy as np
+import numpy.typing as npt
+from dataclasses import dataclass
+from collections import defaultdict
+
+from QHyper.problems.base import Problem
+from QHyper.solvers.base import Solver, SolverResult, SolverConfigException
+from QHyper.converter import Converter
+from QHyper.constraint import Polynomial
+from QHyper.util import weighted_avg_evaluation
+from QHyper.optimizers import (
+    OPTIMIZERS, Optimizer, OptimizationResult)
+
+from dwave.system import DWaveSampler, EmbeddingComposite
+from dimod import BinaryQuadraticModel
+from dimod.sampleset import SampleSet
+
+
+@dataclass
+class OptimizerFunction:
+    embedding_compose: DWaveSampler
+    problem: Problem
+    num_reads: int
+    chain_strength: float | None
+
+    def __call__(self, args: npt.NDArray) -> OptimizationResult:
+        sampleset = self.run_advantage(args)
+
+        result = np.recarray(
+            (len(sampleset),),
+            dtype=([(v, int) for v in sampleset.variables]
+                   + [('probability', float)]
+                   + [('energy', float)])
+        )
+
+        num_of_shots = sampleset.record.num_occurrences.sum()
+        for i, solution in enumerate(sampleset.data()):
+            for var in sampleset.variables:
+                result[var][i] = solution.sample[var]
+
+            result['probability'][i] = (
+                solution.num_occurrences / num_of_shots)
+            result['energy'][i] = solution.energy
+
+        result_energy = weighted_avg_evaluation(
+            result, self.problem.get_score, penalty=0
+        )
+
+        return OptimizationResult(result_energy, args)
+
+    def run_advantage(self, args: npt.NDArray) -> SampleSet:
+        qubo = Converter.create_qubo(self.problem, args)
+        qubo_terms, offset = convert_qubo_keys(qubo)
+        bqm = BinaryQuadraticModel.from_qubo(qubo_terms, offset=offset)
+        sampleset = self.embedding_compose.sample(
+            bqm, num_reads=self.num_reads, chain_strength=self.chain_strength
+        )
+
+        return sampleset
+
+
+class Advantage(Solver):
+    """
+    Class for solving a problem using Advantage
+
+    Attributes
+    ----------
+    problem : Problem
+        The problem to be solved.
+    version: str, default 'Advantage_system5.4'
+        The version of the D-Wave Advantage system.
+    region : str, default 'eu-central-1'
+        The region in which D-Wave Advantage is available.
+    num_reads: int, default 1
+        The number of times the solver is run.
+    chain_strength: float or None, default None
+        The coupling strength between qubits.
+    hyper_optimizer: Optimizer or None, default None
+        The optimizer for hyperparameters.
+    params_inits: dict[str, Any] | None, default None
+        The initial parameter settings.
+    """
+
+    def __init__(self, problem: Problem,
+                 version: str = "Advantage_system5.4",
+                 region: str = "eu-central-1",
+                 num_reads: int = 1,
+                 chain_strength: float | None = None,
+                 hyper_optimizer: Optimizer | None = None,
+                 params_inits: dict[str, Any] | None = None) -> None:
+        self.problem = problem
+        self.version = version
+        self.region = region
+        self.num_reads = num_reads
+        self.chain_strength = chain_strength
+        self.hyper_optimizer = hyper_optimizer
+        self.params_inits = params_inits
+
+    @classmethod
+    def from_config(cls, problem: Problem, config: dict[str, Any]) -> 'Advantage':
+        if not (hyper_optimizer_config := config.pop('hyper_optimizer', None)):
+            hyper_optimizer = None
+        elif not (hyper_optimizer_type := hyper_optimizer_config.pop('type', None)):
+            raise SolverConfigException(
+                "Optimizer type was not provided")
+        elif not (hyper_optimizer_class := OPTIMIZERS.get(
+                hyper_optimizer_type, None)):
+            raise SolverConfigException(
+                f"There is no {hyper_optimizer_type} optimizer type")
+        else:
+            hyper_optimizer = hyper_optimizer_class(**hyper_optimizer_config)
+
+        version = config.pop('version', "Advantage_system5.4")
+        region = config.pop('region', "eu-central-1")
+        num_reads = config.pop('num_reads', 1)
+        chain_strength = config.pop('chain_strength', None)
+
+        params_inits = config.pop('params_inits', None)
+
+        return cls(problem, version, region, num_reads, chain_strength, hyper_optimizer, params_inits)
+
+
+    def solve(self, params_inits: dict[str, Any] = {}) -> Any:
+        if not params_inits:
+            params_inits = self.params_inits
+        sampler = DWaveSampler(solver=self.version, region=self.region)
+        embedding_compose = EmbeddingComposite(sampler)
+
+        opt_result = None
+        wrapper = OptimizerFunction(
+            embedding_compose, self.problem, self.num_reads, self.chain_strength
+        )
+
+        if self.hyper_optimizer:
+            args = (
+                np.array(params_inits["weights"]).flatten() if params_inits["weights"]
+                else None
+            )
+
+            result = self.hyper_optimizer.minimize(wrapper, args)
+            opt_result = result.params
+
+        qubo_arguments = opt_result if self.hyper_optimizer else params_inits.get("weights", [])
+        solutions = wrapper.run_advantage(qubo_arguments)
+
+        result = np.recarray(
+            (len(solutions),),
+            dtype=([(v, int) for v in solutions.variables]
+                   + [('probability', float)]
+                   + [('energy', float)])
+        )
+
+        num_of_shots = solutions.record.num_occurrences.sum()
+        for i, solution in enumerate(solutions.data()):
+            for var in solutions.variables:
+                result[var][i] = solution.sample[var]
+
+            result['probability'][i] = (
+                solution.num_occurrences / num_of_shots)
+            result['energy'][i] = solution.energy
+
+        return SolverResult(
+            result,
+            {"weights": qubo_arguments},
+            []
+        )
+
+    def prepare_solver_result(self, result: defaultdict, arguments: npt.NDArray) -> SolverResult:
+        sorted_keys = sorted(result.keys(), key=lambda x: int(''.join(filter(str.isdigit, x))))
+        values = ''.join(str(result[key]) for key in sorted_keys)
+        probabilities = {values: 100.0}
+        parameters = {values: arguments}
+
+        return SolverResult(probabilities, parameters)
+
+def convert_qubo_keys(qubo: Polynomial) -> tuple[dict[tuple, float], float]:
+    new_qubo = defaultdict(float)
+    offset = 0.0
+
+    qubo, offset = qubo.separate_const()
+    for k, v in qubo.terms.items():
+        if len(k) == 1:
+            new_key = (k[0], k[0])
+        elif len(k) > 2:
+            raise ValueError("Only supports quadratic model")
+        else:
+            new_key = k
+
+        new_qubo[new_key] += v
+
+    return (new_qubo, offset)

qhyper-0.2.1/QHyper/solvers/quantum_annealing/cqm.py

@@ -0,0 +1,81 @@
+# This work was supported by the EuroHPC PL infrastructure funded at the
+# Smart Growth Operational Programme (2014-2020), Measure 4.2
+# under the grant agreement no. POIR.04.02.00-00-D014/20-00
+
+
+import os
+import numpy as np
+from dwave.system import LeapHybridCQMSampler
+
+from typing import Any
+
+from QHyper.converter import Converter
+from QHyper.problems import Problem
+from QHyper.solvers import Solver, SolverResult
+
+
+DWAVE_API_TOKEN = os.environ.get('DWAVE_API_TOKEN')
+
+
+class CQM(Solver):
+    """
+    Class for solving a problem using the
+    Constrained Quadratic Model (CQM) approach.
+
+    Attributes
+    ----------
+    problem : Problem
+        The problem to be solved.
+    time : float
+        The maximum time allowed for the CQM solver.
+    """
+
+    def __init__(self, problem: Problem, time: float) -> None:
+        """
+        Parameters
+        ----------
+        problem : Problem
+            The problem to be solved.
+        time : float
+            The maximum time allowed for the CQM solver.
+        """
+        self.problem: Problem = problem
+        self.time: float = time
+
+    def solve(self, params_inits: dict[str, Any] = {}) -> SolverResult:
+        """
+        Solve the problem using the CQM approach.
+
+        Returns
+        -------
+        Any
+            The solution to the problem.
+        """
+        converter = Converter()
+        cqm = converter.to_cqm(self.problem)
+        sampler = LeapHybridCQMSampler(token=DWAVE_API_TOKEN)
+        solutions = sampler.sample_cqm(cqm, self.time).aggregate()
+
+        recarray = np.recarray(
+            (len(solutions),),
+            dtype=([(v, int) for v in solutions.variables]
+                   + [('probability', float)]
+                   + [('energy', float)]
+                   + [('is_feasible', bool)])
+        )
+
+        num_of_shots = solutions.record.num_occurrences.sum()
+        for i, solution in enumerate(solutions.data()):
+            for var in solutions.variables:
+                recarray[var][i] = solution.sample[var]
+
+            recarray['probability'][i] = (
+                solution.num_occurrences / num_of_shots)
+            recarray['energy'][i] = solution.energy
+            recarray['is_feasible'][i] = solution.is_feasible
+
+        return SolverResult(
+            recarray,
+            {},
+            []
+        )

qhyper-0.2.1/QHyper/solvers/quantum_annealing/dqm.py

@@ -0,0 +1,64 @@
+# This work was supported by the EuroHPC PL infrastructure funded at the
+# Smart Growth Operational Programme (2014-2020), Measure 4.2
+# under the grant agreement no. POIR.04.02.00-00-D014/20-00
+
+
+import os
+import numpy as np
+from typing import Any
+
+from dwave.system import LeapHybridDQMSampler
+from QHyper.problems import Problem
+from QHyper.solvers import Solver, SolverResult
+from QHyper.converter import Converter
+
+
+DWAVE_API_TOKEN = os.environ.get('DWAVE_API_TOKEN')
+
+
+class DQM(Solver):
+    """
+    DQM solver class.
+
+    Attributes
+    ----------
+    problem : Problem
+        The problem to be solved.
+    time : float
+        Maximum run time in seconds
+    cases: int, default 1
+        Number of variable cases (values)
+        1 is denoting binary variable.
+    """
+
+    def __init__(self, problem: Problem, time: float, cases: int = 1) -> None:
+        self.problem: Problem = problem
+        self.time: float = time
+        self.cases: int = cases
+
+    def solve(self, params_inits: dict[str, Any] = {}) -> SolverResult:
+        dqm = Converter.to_dqm(self.problem, self.cases)
+        sampler = LeapHybridDQMSampler(token=DWAVE_API_TOKEN)
+        solutions = sampler.sample_dqm(dqm, self.time)
+
+        recarray = np.recarray(
+            (len(solutions),),
+            dtype=([(v, int) for v in solutions.variables]
+                   + [('probability', float)]
+                   + [('energy', float)])
+        )
+
+        num_of_shots = solutions.record.num_occurrences.sum()
+        for i, solution in enumerate(solutions.data()):
+            for var in solutions.variables:
+                recarray[var][i] = solution.sample[var]
+
+            recarray['probability'][i] = (
+                solution.num_occurrences / num_of_shots)
+            recarray['energy'][i] = solution.energy
+
+        return SolverResult(
+            recarray,
+            {},
+            []
+        )

{qhyper-0.2.0 → qhyper-0.2.1/qhyper.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qhyper
-Version: 0.2.0
+Version: 0.2.1
 Summary: Quantum and classical problem solvers
 Author: ACK Cyfronet AGH
 Author-email: tomasz.lamza@cyfronet.pl

{qhyper-0.2.0 → qhyper-0.2.1}/qhyper.egg-info/SOURCES.txt

@@ -26,6 +26,13 @@ QHyper/problems/tsp.py
 QHyper/problems/workflow_scheduling.py
 QHyper/solvers/__init__.py
 QHyper/solvers/base.py
+QHyper/solvers/classical/__init__.py
+QHyper/solvers/classical/gurobi.py
+QHyper/solvers/gurobi/__init__.py
+QHyper/solvers/quantum_annealing/__init__.py
+QHyper/solvers/quantum_annealing/advantage.py
+QHyper/solvers/quantum_annealing/cqm.py
+QHyper/solvers/quantum_annealing/dqm.py
 QHyper/solvers/vqa/__init__.py
 QHyper/solvers/vqa/base.py
 QHyper/solvers/vqa/eval_funcs/__init__.py