qhyper 0.dev1__py3-none-any.whl

QHyper/problems/workflow_scheduling.py

@@ -0,0 +1,220 @@
+import math
+from collections import defaultdict
+from dataclasses import dataclass
+
+import networkx as nx
+import numpy as np
+import pandas as pd
+import sympy
+from wfcommons import Instance
+from wfcommons.utils import read_json
+
+from networkx.classes.reportviews import NodeView
+
+from sympy.core.expr import Expr
+from typing import cast
+
+from QHyper.hyperparameter_gen.parser import Expression
+from .base import Problem
+
+
+@dataclass
+class TargetMachine:
+    name: str
+    memory: int
+    cpu: dict[str, float]
+    price: float
+    memory_cost_multiplier: float
+
+
+class Workflow:
+    def __init__(
+            self, tasks_file: str, machines_file: str, deadline: float
+    ) -> None:
+        self.wf_instance = Instance(tasks_file)
+        self.tasks = self._get_tasks()
+        self.machines = self._get_machines(machines_file)
+        self.deadline = deadline
+        self._set_paths()
+        self.time_matrix, self.cost_matrix = self._calc_dataframes()
+        self.task_names = self.time_matrix.index
+        self.machine_names = self.time_matrix.columns
+
+    def _get_tasks(self) -> NodeView:
+        return self.wf_instance.workflow.nodes(data=True)
+
+    def _get_machines(self, machines_file: str) -> dict[str, TargetMachine]:
+        target_machines = read_json(machines_file)
+        return {
+            machine['name']: TargetMachine(**machine)
+            for machine in target_machines["machines"]
+        }
+
+    def _set_paths(self) -> None:
+        all_paths = []
+        for root in self.wf_instance.roots():
+            for leaf in self.wf_instance.leaves():
+                paths = nx.all_simple_paths(
+                    self.wf_instance.workflow, root, leaf)
+                all_paths.extend(paths)
+
+        self.paths = all_paths
+
+    def _calc_dataframes(self) -> tuple[pd.DataFrame, pd.DataFrame]:
+        costs, runtimes = {}, {}
+        for machine_name, machine_details in self.machines.items():
+            machine_cost, machine_runtime = [], []
+            for task_name, task in self.tasks:
+                old_machine = task["task"].machine
+                number_of_operations = (
+                    task["task"].runtime
+                    * old_machine.cpu_speed
+                    * old_machine.cpu_cores
+                    * 10 ** 6
+                )
+                # todo can this overflow?
+                real_runtime = number_of_operations / (
+                        machine_details.cpu["speed"]
+                        * machine_details.cpu["count"] * 10 ** 6)
+                machine_runtime.append(real_runtime)
+                machine_cost.append(real_runtime * machine_details.price)
+            costs[machine_name] = machine_cost
+            runtimes[machine_name] = machine_runtime
+
+        time_df = pd.DataFrame(
+            data=runtimes, index=self.wf_instance.workflow.nodes)
+        cost_df = pd.DataFrame(
+            data=costs, index=self.wf_instance.workflow.nodes)
+
+        return time_df, cost_df
+
+
+def calc_slack_coefficients(constant: int) -> list[int]:
+    num_slack = int(np.floor(np.log2(constant)))
+    slack_coefficients = [2 ** j for j in range(num_slack)]
+    if constant - 2 ** num_slack >= 0:
+        slack_coefficients.append(constant - 2 ** num_slack + 1)
+    return slack_coefficients
+
+
+class WorkflowSchedulingProblem(Problem):
+    def __init__(self, workflow: Workflow):
+        self.workflow: Workflow = workflow
+        self.slack_coefficients = self._get_slacks()
+        self.variables: tuple[sympy.Symbol] = sympy.symbols(' '.join(
+            [f'x{i}' for i in range(
+                len(self.workflow.tasks) * len(self.workflow.machines))]
+        ) + ' ' + ' '.join(
+            [f's{i}' for i in range(len(self.slack_coefficients))]))
+
+        self._set_objective_function()
+        self._set_constraints()
+
+    def _get_slacks(self) -> list[int]:
+        min_path_runtime, _ = self.get_deadlines()
+        deadline_diff = int(self.workflow.deadline - min_path_runtime)
+        return calc_slack_coefficients(deadline_diff)
+
+    def _set_objective_function(self) -> None:
+        expression: Expr = cast(Expr, 0)
+        for task_id, task_name in enumerate(self.workflow.time_matrix.index):
+            for machine_id, machine_name in enumerate(
+                    self.workflow.time_matrix.columns):
+                cost = self.workflow.cost_matrix[machine_name][task_name]
+                expression += cost * self.variables[
+                    machine_id
+                    + task_id * len(self.workflow.time_matrix.columns)
+                ]
+
+        self.objective_function: Expression = Expression(expression)
+
+    def _set_constraints(self) -> None:
+        self.constraints: list[Expression] = []
+
+        # machine assignment constraint
+        for task_id in range(len(self.workflow.time_matrix.index)):
+            expression: Expr = cast(Expr, 0)
+            for machine_id in range(len(self.workflow.time_matrix.columns)):
+                expression += self.variables[
+                    machine_id
+                    + task_id * len(self.workflow.time_matrix.columns)
+                ]
+            expression -= 1
+
+            self.constraints.append(Expression(expression))
+
+        # deadline constraint
+
+        min_deadline, _ = self.get_deadlines()
+        # deadline_for_slacks = int(self.workflow.deadline - min_deadline)
+
+        for path in self.workflow.paths:
+            expression = cast(Expr, -self.workflow.deadline)
+            for task_id, task_name in enumerate(
+                    self.workflow.time_matrix.index):
+                for machine_id, machine_name in enumerate(
+                        self.workflow.time_matrix.columns):
+                    if task_name in path:
+                        time = self.workflow.time_matrix[
+                            machine_name][task_name]
+                        expression += time * self.variables[
+                            machine_id
+                            + task_id * len(self.workflow.time_matrix.columns)
+                        ]
+
+            first_slack_index = (
+                len(self.workflow.time_matrix.index)
+                * len(self.workflow.time_matrix.columns)
+            )
+            for i, coefficient in enumerate(self.slack_coefficients):
+                expression += (
+                    coefficient * self.variables[first_slack_index + i])
+
+            self.constraints.append(Expression(expression))
+
+    def check_solution_correctness(self) -> None:
+        raise NotImplementedError  # todo check if slack values are correct
+
+    def decode_solution(self, solution: dict) -> dict:
+        decoded_solution = {}
+        for variable, value in solution.items():
+            _, id = variable[0], int(variable[1:])  # todo add validation
+            if value == 1.0:
+                machine_id = id % len(self.workflow.machines)
+                task_id = id // len(self.workflow.machines)
+                decoded_solution[self.workflow.time_matrix.index[task_id]] = (
+                    self.workflow.time_matrix.columns[machine_id])
+
+        return decoded_solution
+
+    def get_deadlines(self) -> tuple[float, float]:  # todo test this function
+        """Calculates the minimum and maximum path runtime
+           for the whole workflow."""
+
+        flat_runtimes = [
+            (runtime, name)
+            for n, machine_runtimes in self.workflow.time_matrix.items()
+            for runtime, name in zip(
+                machine_runtimes, self.workflow.task_names)
+        ]
+
+        max_path_runtime = 0.0
+        min_path_runtime = 0.0
+
+        for path in self.workflow.paths:
+            max_runtime: defaultdict[str, float] = defaultdict(lambda: 0.0)
+            min_runtime: defaultdict[str, float] = defaultdict(
+                lambda: math.inf)
+
+            for runtime, name in flat_runtimes:
+                if name not in path:
+                    continue
+                max_runtime[name] = max(max_runtime[name], runtime)
+                min_runtime[name] = min(min_runtime[name], runtime)
+            max_path_runtime = max(max_path_runtime, sum(max_runtime.values()))
+            min_path_runtime = max(min_path_runtime, sum(min_runtime.values()))
+
+        return min_path_runtime, max_path_runtime
+
+    def get_score(self, result: str, penalty: float = 0) -> float:
+        return 0

QHyper/solvers/__init__.py

@@ -0,0 +1,14 @@
+from typing import Type
+
+from .base import Solver
+
+from .vqa.base import VQA
+from .gurobi.gurobi import Gurobi
+from .cqm.cqm import CQM
+
+
+SOLVERS: dict[str, Type[Solver]] = {
+    'vqa': VQA,
+    'gurobi': Gurobi,
+    'cqm': CQM,
+}

QHyper/solvers/base.py

@@ -0,0 +1,86 @@
+from abc import abstractmethod
+
+from typing import Any, Optional
+
+from QHyper.problems.base import Problem
+from QHyper.optimizers import OPTIMIZERS_BY_NAME
+from QHyper.optimizers.base import Optimizer
+
+
+class Solver:
+    """
+    Abstract base class for solvers.
+
+    Attributes
+    ----------
+    problem : Problem
+        The problem to be solved.
+    hyper_optimizer: Optimizer, optional
+        Hyperparameter optmizer.
+    """
+
+    problem: Problem
+    hyper_optimizer: Optimizer = None
+
+    def __init__(self, problem: Problem, **kwargs: Any) -> None:
+        pass
+
+    @staticmethod
+    def from_config(problem: Problem, config: dict[str, Any]) -> 'Solver':
+        """
+        Alternative way of creating solver.
+        Expect dict with two keys:
+        - type - type of solver
+        - args - arguments which will be passed to Solver instance
+
+        Parameters
+        ----------
+        problem : Problem
+            The problem to be solved
+        config : dict[str. Any]
+            Configuration in form of dict
+
+        Returns
+        -------
+        Solver
+            Initialized Solver object
+        """
+        from QHyper.solvers import SOLVERS
+
+        try:
+            solver_type = config['solver'].pop('type').lower()
+            solver_args = config['solver'].pop('args')
+        except KeyError:
+            raise Exception("Configuration for Solver was not provided")
+
+        solver = SOLVERS[solver_type](problem, **solver_args)
+
+        if 'hyper_optimizer' in config:
+            try:
+                optimizer_type = config['hyper_optimizer'].pop('type')
+            except KeyError:
+                raise Exception("Type for hyper optimizer was not provided")
+
+            solver.hyper_optimizer = OPTIMIZERS_BY_NAME[optimizer_type](
+                **config['hyper_optimizer']
+            )
+        return solver
+
+    @abstractmethod
+    def solve(
+            self,
+            params_inits: dict[str, Any]
+    ) -> Any:
+        """
+        Parameters
+        ----------
+        params_inits : dict[str, Any], optional
+            Initial parameters for the optimization. Default is None.
+
+        Returns
+        -------
+        Any
+            The result of the solver.
+        """
+
+        ...

QHyper/solvers/converter.py

@@ -0,0 +1,128 @@
+from typing import Any, cast
+
+import dimod
+from dimod import ConstrainedQuadraticModel, DiscreteQuadraticModel
+from QHyper.hyperparameter_gen.parser import Expression
+from QHyper.problems.base import Problem
+from QHyper.util import QUBO, VARIABLES
+
+
+def dict_to_list(my_dict: QUBO) -> list[tuple[Any, ...]]:
+    return [tuple([*key, val]) for key, val in my_dict.items()]
+
+
+class Converter:
+    @staticmethod
+    def create_qubo(problem: Problem, weights: list[float]) -> QUBO:
+        results: dict[VARIABLES, float] = {}
+
+        if len(weights) != len(problem.constraints) + 1:
+            raise Exception(
+                f"Expected {len(problem.constraints)+1} weights, "
+                f"got {len(weights)}"
+            )
+
+        objective_function = Expression(
+            {
+                key: weights[0] * val
+                for key, val in problem.objective_function.as_dict().items()
+            }
+        )
+        for key, value in objective_function.as_dict().items():
+            if key in results:
+                results[key] += value
+            else:
+                results[key] = value
+
+        constraint_weights = weights[1:]
+
+        for weight, element in zip(constraint_weights, problem.constraints):
+            constraint = Expression(element.polynomial**2 * weight)
+            for key, value in constraint.as_dict().items():
+                if key in results:
+                    results[key] += value
+                else:
+                    results[key] = value
+
+        return results
+
+    @staticmethod
+    def create_weight_free_qubo(problem: Problem) -> QUBO:
+        results: dict[VARIABLES, float] = {}
+
+        objective_function = Expression(problem.objective_function.polynomial)
+        for key, value in objective_function.as_dict().items():
+            if key in results:
+                results[key] += value
+            else:
+                results[key] = value
+        
+
+        return results
+
+    @staticmethod
+    def to_cqm(problem: Problem) -> ConstrainedQuadraticModel:
+        binary_polynomial = dimod.BinaryPolynomial(
+            problem.objective_function.as_dict(), dimod.BINARY
+        )
+        cqm = dimod.make_quadratic_cqm(binary_polynomial)
+
+        # todo this cqm can probably be initialized in some other way
+        for var in problem.variables:
+            if str(var) not in cqm.variables:
+                cqm.add_variable(dimod.BINARY, str(var))
+
+        for i, constraint in enumerate(problem.constraints):
+            cqm.add_constraint(
+                dict_to_list(constraint.as_dict()), "==", label=i
+            )
+
+        return cqm
+
+    @staticmethod
+    def to_qubo(problem: Problem) -> tuple[QUBO, float]:
+        cqm = Converter.to_cqm(problem)
+        bqm, _ = dimod.cqm_to_bqm(cqm, lagrange_multiplier=10)
+        return cast(tuple[QUBO, float], bqm.to_qubo())  # (qubo, offset)
+
+    @staticmethod
+    def to_dqm(problem: Problem) -> DiscreteQuadraticModel:
+        dqm = dimod.DiscreteQuadraticModel()
+
+        BIN_OFFSET = 1 if problem.cases == 1 else 0
+
+        def binary_to_discrete(v: str) -> str:
+            id = int(v[1:])
+            discrete_id = id // problem.cases
+            return f"x{discrete_id}"
+
+        variables_discrete = [
+            binary_to_discrete(str(v))
+            for v in problem.variables[:: problem.cases]
+        ]
+        for var in variables_discrete:
+            if var not in dqm.variables:
+                dqm.add_variable(problem.cases + BIN_OFFSET, var)
+
+        for vars, bias in problem.objective_function.as_dict().items():
+            s_i, *s_j = vars
+            x_i = binary_to_discrete(s_i)
+            xi_idx: int = cast(int, dqm.variables.index(x_i))
+            if s_j:
+                x_j = binary_to_discrete(*s_j)
+                xj_idx: int = cast(int, dqm.variables.index(x_j))
+                dqm.set_quadratic(
+                    dqm.variables[xi_idx],
+                    dqm.variables[xj_idx],
+                    {
+                        (case, case): bias
+                        for case in range(problem.cases + BIN_OFFSET)
+                    },
+                )
+            else:
+                dqm.set_linear(
+                    dqm.variables[xi_idx],
+                    [bias for _ in range(problem.cases + BIN_OFFSET)],
+                )
+
+        return dqm

QHyper/solvers/cqm/__init__.py

@@ -0,0 +1 @@
+from .cqm import CQM

QHyper/solvers/cqm/cqm.py

@@ -0,0 +1,66 @@
+import os
+from dimod import ConstrainedQuadraticModel
+from dwave.system import LeapHybridCQMSampler
+
+from typing import Any, Optional
+
+from QHyper.solvers.converter import Converter
+from QHyper.problems.base import Problem
+from QHyper.solvers.base import Solver
+from QHyper.optimizers.base import Optimizer
+
+
+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] = {}) -> Any:
+        """
+        Solve the problem using the CQM approach.
+
+        Parameters
+        ----------
+        params_inits : dict[str, Any], optional
+            Initial parameters for the optimization. Default is None.
+        hyper_optimizer : Optimizer, optional
+            Hyperparameter optimizer. Default is None.
+
+        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)
+        correct_solutions = [
+            s for s in solutions
+            if len(cqm.violations(s, skip_satisfied=True)) == 0
+        ]
+
+        return correct_solutions[0]

QHyper/solvers/dqm/__init__.py

@@ -0,0 +1 @@
+from .dqm import DQM

QHyper/solvers/dqm/dqm.py

@@ -0,0 +1,23 @@
+import os
+from typing import Any
+
+from dwave.system import LeapHybridDQMSampler
+from QHyper.problems.base import Problem
+from QHyper.solvers.base import Solver
+from QHyper.solvers.converter import Converter
+
+DWAVE_API_TOKEN = os.environ.get("DWAVE_API_TOKEN")
+
+
+class DQM(Solver):
+    def __init__(self, problem: Problem, time: float) -> None:
+        self.problem: Problem = problem
+        self.time: float = time
+
+    def solve(self, params_inits: dict[str, Any] = {}) -> Any:
+        converter = Converter()
+        dqm = converter.to_dqm(self.problem)
+        sampler = LeapHybridDQMSampler(token=DWAVE_API_TOKEN)
+        sampleset = sampler.sample_dqm(dqm, self.time)
+
+        return sampleset

QHyper/solvers/gurobi/__init__.py

@@ -0,0 +1 @@
+from .gurobi import Gurobi

QHyper/solvers/gurobi/gurobi.py

@@ -0,0 +1,77 @@
+from typing import Any
+
+import gurobipy as gp
+from QHyper.problems.base import Problem
+from QHyper.solvers.base import Solver
+from QHyper.solvers.converter import QUBO
+
+
+def calc(vars: dict[str, Any], poly_dict: QUBO) -> Any:
+    cost_function: float = 0
+    for key, value in poly_dict.items():
+        tmp = 1
+        for k in key:
+            tmp *= vars[k]
+        cost_function += tmp * value
+    return cost_function
+
+
+class Gurobi(Solver):  # todo works only for quadratic expressions
+    def __init__(self, problem: Problem) -> None:
+        self.problem: Problem = problem
+
+    def solve(self, params_inits: dict[str, Any]) -> Any:
+        name = params_inits.get("name", "name")
+        gpm = gp.Model(name)
+        if "MIPGap" in params_inits:
+            gpm.Params.MIPGap = params_inits["MIPGap"]
+
+        vars = {
+            str(var_name): gpm.addVar(vtype=gp.GRB.BINARY, name=str(var_name))
+            for var_name in self.problem.variables
+        }
+        # gpm.update()
+
+        objective_function = calc(
+            vars, self.problem.objective_function.as_dict()
+        )
+        gpm.setObjective(objective_function, gp.GRB.MINIMIZE)
+
+        for i, constraint in enumerate(self.problem.constraints):
+            tmp_constraint = calc(vars, constraint.as_dict())
+            gpm.addConstr(tmp_constraint == 0, f"constr_{i}")
+            gpm.update()
+
+        # eq_constraints = self.problem.constraints["=="]
+        # for i, constraint in enumerate(eq_constraints):
+        #     tmp_constraint = calc(vars, constraint.as_dict())
+        #     gpm.addConstr(tmp_constraint == 0, f"eq_constr_{i}")
+        #
+        # ltq_constraints = self.problem.constraints["<="]
+        # for i, constraint in enumerate(ltq_constraints):
+        #     tmp_constraint = calc(vars, constraint.as_dict())
+        #     gpm.addConstr(tmp_constraint <= 0, f"leq_constr_{i}")
+        #
+        # gtq_constraints = self.problem.constraints["<="]
+        # for i, constraint in enumerate(gtq_constraints):
+        #     tmp_constraint = calc(vars, constraint.as_dict())
+        #     gpm.addConstr(tmp_constraint >= 0, f"gtq_constr_{i}")
+
+        gpm.optimize()
+
+        # print(dir(gpm))
+        # print("status ", gpm.Status)
+        # print("is optimal? ", GRB.OPTIMAL)
+        #
+        # allvars = gpm.getVars()
+        # for v in allvars[-1:]:
+        #     print(v.VarName)
+        #     print(v.X)
+        #     print(dir(v))
+
+        allvars = gpm.getVars()
+        solution = {}
+        for v in allvars:
+            solution[v.VarName] = v.X
+
+        return solution

QHyper/solvers/vqa/__init__.py

@@ -0,0 +1,25 @@
+from typing import Type
+
+# === PQC ===
+
+from .pqc.base import PQC
+from .pqc.h_qaoa import HQAOA
+from .pqc.qaoa import QAOA
+from .pqc.wf_qaoa import WFQAOA
+
+PQC_BY_NAME: dict[str, Type[PQC]] = {
+    'hqaoa': HQAOA,
+    'qaoa': QAOA,
+    'wfqaoa': WFQAOA
+}
+
+# # === Evaluation functions ===
+
+# from .eval_funcs.base import EvalFunc
+# from .eval_funcs.expval import ExpVal
+# from .eval_funcs.wfeval import WFEval
+
+# EVAL_FUNCS_BY_NAME: dict[str, Type[EvalFunc]] = {
+#     'expval': ExpVal,
+#     'wfeval': WFEval,
+# }