qhyper 0.dev1__py3-none-any.whl

QHyper/problems/community_detection.py

@@ -0,0 +1,185 @@
+from dataclasses import dataclass, field
+from typing import Any, Iterable, Tuple, cast
+
+import networkx as nx
+import numpy as np
+import sympy
+from QHyper.hyperparameter_gen.parser import Expression
+from QHyper.problems.base import Problem
+from QHyper.util import VARIABLES
+from sympy.core.expr import Expr
+
+
+@dataclass
+class Network:
+    graph: nx.Graph
+    resolution: float = field(default=1)
+    modularity_matrix: np.ndarray = field(init=False)
+    weight: str | None = field(default=None)
+
+    def __post_init__(self) -> None:
+        self.modularity_matrix = self.calculate_modularity_matrix()
+
+    def calculate_modularity_matrix(self) -> np.ndarray:
+        adj_matrix: np.ndarray = nx.to_numpy_array(
+            self.graph, weight=self.weight
+        )
+        degree_matrix: np.ndarray = adj_matrix.sum(axis=1)
+        m: int = np.sum(degree_matrix)
+        return (
+            adj_matrix
+            - self.resolution * np.outer(degree_matrix, degree_matrix) / m
+        )
+
+
+class KarateClubNetwork(Network):
+    def __init__(self, resolution: float = 1):
+        super().__init__(nx.karate_club_graph(), resolution=resolution)
+
+
+class BrainNetwork(Network):
+    def __init__(
+        self,
+        input_data_dir: str,
+        input_data_name: str,
+        delimiter: str = "	",
+        resolution: int = 1,
+    ):
+        adj_matrix = np.genfromtxt(
+            f"{input_data_dir}/{input_data_name}.csv", delimiter=delimiter
+        )
+        super().__init__(
+            nx.from_numpy_matrix(adj_matrix), resolution=resolution
+        )
+
+
+class CommunityDetectionProblem(Problem):
+    """
+    Problem class instance
+    - objective function for network community detection
+
+    Attributes:
+    ----------
+    cases: int
+        number of communities into which the graph shall be divided
+        (default 2)
+    G: networkx graph
+        networkx implementation of graph
+    B: networkx modularity matrix
+        networkx implementation of modularity matrix
+
+    objective_function : Expression
+        objective function in SymPy syntax
+    constraints : list[Expression]
+        list of problem constraints in SymPy syntax, (default [])
+    variables : int
+        number of qubits in the circuit, equal to number of nodes
+        in the graph
+    """
+
+    def __init__(self, network_data: Network, communities: int = 2) -> None:
+        """
+        Parameters
+        ----------
+        network_data: Network
+            representation of a network with graph and modularity matrix
+        communities: int
+            number of communities into which the graph shall be divided
+            (default 2)
+        """
+        self.G: nx.Graph = network_data.graph
+        self.B: np.ndarray = network_data.modularity_matrix
+        if communities < 1:
+            raise Exception(
+                "Number of communities must be greater than or equal to 1"
+            )
+
+        self.cases: int = communities
+        self.variables: tuple[
+            sympy.Symbol
+        ] = self._encode_discretes_to_one_hots()
+        self._set_objective_function()
+        self._set_one_hot_constraints(communities)
+
+    def _encode_discrete_to_one_hot(
+        self, discrete_variable: sympy.Symbol, case_value: int
+    ) -> sympy.Symbol:
+        discrete_id = int(str(discrete_variable)[1:])
+        id = discrete_id * self.cases + case_value
+        return sympy.symbols(f"s{id}")
+
+    def _encode_discretes_to_one_hots(self) -> tuple[sympy.Symbol]:
+        one_hots: tuple[sympy.Symbol] = sympy.symbols(" ".join([
+            str(self._encode_discrete_to_one_hot(var, case_val))
+            for var in self._get_discrete_variable_representation()
+            for case_val in range(self.cases)
+        ]))
+        return one_hots
+
+    def iter_variables_cases(self) -> Iterable[Tuple[sympy.Symbol, ...]]:
+        """s -> (s0,s1,s2,...sn-1), (sn,sn+1,sn+2,...s2n-1), ..."""
+        return zip(*[iter(self.variables)] * self.cases)
+
+    def _get_discrete_variable_representation(
+        self,
+    ) -> tuple[sympy.Symbol] | Any:
+        return sympy.symbols(
+            " ".join([f"x{i}" for i in range(len(self.G.nodes))])
+        )
+
+    def _set_objective_function(self) -> None:
+        equation: dict[VARIABLES, float] = {}
+        for i in self.G.nodes:
+            for j in range(i + 1, len(self.G.nodes)):
+                for case_val in range(self.cases):
+                    x_i, x_j = sympy.symbols(f"x{i}"), sympy.symbols(f"x{j}")
+                    s_i = str(self._encode_discrete_to_one_hot(x_i, case_val))
+                    s_j = str(self._encode_discrete_to_one_hot(x_j, case_val))
+                    equation[(s_i, s_j)] = self.B[i, j]
+
+        equation = {key: -1 * val for key, val in equation.items()}
+
+        self.objective_function = Expression(equation)
+
+    def _set_one_hot_constraints(self, communities: int) -> None:
+        ONE_HOT_CONST = -1
+        self.constraints: list[Expression] = []
+        # In the case of 1-to-1 mapping between discrete
+        # and binary variable values no one-hot constraints
+        if communities == ONE_HOT_CONST * -1:
+            return
+
+        dummies: Iterable[Tuple[sympy.Symbol, ...]]
+        for dummies in self.iter_variables_cases():
+            expression: Expr = cast(Expr, 0)
+            dummy: sympy.Symbol
+            for dummy in dummies:
+                expression += dummy
+            expression += ONE_HOT_CONST
+            self.constraints.append(Expression(expression))
+
+    def decode_solution(self, solution: dict) -> dict:
+        ONE_HOT_VALUE = 1.0
+        decoded_solution: dict = {}
+
+        for variable, value in solution.items():
+            id = int(variable[1:])
+            if value == ONE_HOT_VALUE:
+                case_value = id % self.cases
+                variable_id = id // self.cases
+                decoded_solution[variable_id] = case_value
+
+        return self.sort_decoded_solution(decoded_solution)
+
+    def sort_encoded_solution(self, encoded_solution: dict) -> dict:
+        return {
+            str(k): encoded_solution[str(k)]
+            for k in self.variables
+            if str(k) in encoded_solution
+        }
+
+    def sort_decoded_solution(self, decoded_solution: dict) -> dict:
+        keyorder = [int(str(v)[1:]) for v in self.variables]
+        return {
+            k: decoded_solution[k] for k in keyorder if k in decoded_solution
+        }

QHyper/problems/knapsack.py

@@ -0,0 +1,176 @@
+import random
+import sympy
+from collections import namedtuple
+
+from typing import cast
+
+from .base import Problem
+from QHyper.hyperparameter_gen.parser import Expression
+
+Item = namedtuple('Item', "weight value")
+
+
+class Knapsack:
+    """Knapsack class
+
+    Attributes
+    ----------
+    max_weight: int
+        maximum weight of an item
+    max_item_value: int
+        maximum value of an item
+    items: list[Item]
+        list of items
+    """
+
+    def __init__(
+        self,
+        max_weight: int,
+        max_item_value: int = 10,
+        items_amount: int = 0,
+        items: list[tuple[int, int]] = []
+    ) -> None:
+        """
+        Parameters
+        ----------
+        max_weight: int
+            maximum weight of an item
+        max_item_value: int
+            maximum value of an item (default 10)
+        items_amount: int
+            items amount, used only for random knapsack (default 0)
+        items: list[tuple[int, int]]
+            set items in knapsack (default [])
+        """
+        self.items: list[Item] = []
+        self.max_weight: int = max_weight
+        self.max_item_value: int = max_item_value
+        if items:
+            self.set_knapsack(items)
+        else:
+            self.generate_knapsack(items_amount)
+
+    def generate_knapsack(self, items_amount: int) -> None:
+        for _ in range(items_amount):
+            self.items.append(Item(
+                random.randint(1, self.max_weight),
+                random.randint(1, self.max_item_value)
+            ))
+
+    def set_knapsack(self, items: list[tuple[int, int]]) -> None:
+        self.items = [Item(weight, value) for weight, value in items]
+
+    def __len__(self) -> int:
+        return len(self.items)
+
+
+class KnapsackProblem(Problem):
+    """Objective function and constraints for the knapsack problem
+
+    Attributes
+    ----------
+    objective_function : Expression
+        objective function in SymPy syntax wrapped in Expression class
+    constraints : list[Expression]
+        list of constraints in SymPy syntax wrapped in Expression class
+    variables : int
+        number of qubits in the circuit, equals to sum of the number
+        of items in the knapsack the max weight of a knapsack
+    knapsack: Knapsack
+        Knapsack instance
+    """
+
+    def __init__(
+        self,
+        max_weight: int,
+        max_item_value: int = 10,
+        items_amount: int = 0,
+        items: list[tuple[int, int]] = []
+    ) -> None:
+        """
+        Parameters
+        ----------
+        max_weight: int
+            maximum weight of an item
+        max_item_value: int
+            maximum value of an item (default 10)
+        items_amount: int
+            items amount, used only for random knapsack (default 0)
+        items: list[tuple[int, int]]
+            set items in knapsack (default [])
+        """
+        self.knapsack = Knapsack(
+            max_weight, max_item_value, items_amount, items)
+        # self.variables = len(self.knapsack) + self.knapsack.max_weight
+        self.variables: tuple[sympy.Symbol] = sympy.symbols(' '.join(
+            [f'x{i}' for i
+             in range(len(self.knapsack) + self.knapsack.max_weight)]
+        ))
+        self._set_objective_function()
+        self._set_constraints()
+
+    def _set_objective_function(self) -> None:
+        """
+        Create the objective functiif items on defined in SymPy syntax
+        """
+        # xs = [f"x{i}" for i in range(len(self.knapsack))]
+        equation = cast(sympy.Expr, 0)
+        for i, x in enumerate(self.variables[:len(self.knapsack)]):
+            equation += self.knapsack.items[i].value*x
+        equation *= -1
+
+        self.objective_function: Expression = Expression(equation)
+
+    def _set_constraints(self) -> None:
+        """
+        Create constraints defined in SymPy syntax
+        """
+        xs = [self.variables[i] for i in range(len(self.knapsack))]
+        ys = [self.variables[i] for i in range(
+            len(self.knapsack), len(self.knapsack) + self.knapsack.max_weight)]
+        self.constraints: list[Expression] = []
+        equation = cast(sympy.Expr, 1)
+        for y in ys:
+            equation -= y
+        # equation = equation
+        self.constraints.append(Expression(equation))
+        equation = cast(sympy.Expr, 0)
+        for i, y in enumerate(ys):
+            equation += (i + 1)*y
+        for i, x in enumerate(xs):
+            equation += -(self.knapsack.items[i].weight)*x
+        # equation = equation
+        self.constraints.append(Expression(equation))
+
+    def get_score(self, result: str, penalty: float = 0) -> float:
+        """Returns score of the provided outcome in bits
+
+        Parameters
+        ----------
+        result : str
+            outcome as a string of zeros and ones
+        penalty : float
+            penalty for incorrect results (default 0)
+
+        Returns
+        -------
+        float
+            Returns negated sum of value of picked items or 0 if knapsack
+            isn't correct
+        """
+        sum = 0
+        weight = 0
+        for i, item in enumerate(self.knapsack.items):
+            if result[i] == '1':
+                sum += item.value
+                weight += item.weight
+        if weight > self.knapsack.max_weight:
+            return penalty
+
+        for i in range(self.knapsack.max_weight):
+            if result[i + len(self.knapsack)] == '1' and i + 1 != weight:
+                return penalty
+        if weight != 0 and result[weight + len(self.knapsack) - 1] != '1':
+            return penalty
+
+        return -sum

QHyper/problems/maxcut.py

@@ -0,0 +1,37 @@
+from typing import cast
+
+import sympy
+from QHyper.hyperparameter_gen.parser import Expression
+
+from .base import Problem
+
+
+class MaxCutProblem(Problem):
+    def __init__(self, edges: list[tuple[int, int]]) -> None:
+        self.edges = edges
+        self.variables = sympy.symbols(
+            " ".join(
+                [f"x{i}" for i in range(max(v for edge in edges for v in edge))]
+            )
+        )
+
+        self._set_objective_function()
+        self.constraints = []
+
+    def _set_objective_function(self) -> None:
+        equation = cast(sympy.Expr, 0)
+
+        for e in self.edges:
+            x_i, x_j = self.variables[e[0] - 1], self.variables[e[1] - 1]
+            equation -= x_i * (1 - x_j) + x_j * (1 - x_i)
+
+        self.objective_function: Expression = Expression(equation)
+
+    def get_score(self, result: str, penalty: float = 0) -> float:
+        sum = 0
+
+        for e in self.edges:
+            x_i, x_j = int(result[e[0] - 1]), int(result[e[1] - 1])
+            sum += x_i * (1 - x_j) + x_j * (1 - x_i)
+
+        return sum

QHyper/problems/tsp.py

@@ -0,0 +1,190 @@
+import itertools
+
+import numpy as np
+import sympy
+
+from typing import cast
+
+from .base import Problem
+from ..hyperparameter_gen.parser import Expression
+
+
+class TSP:
+    """Traveling Salesman Problem
+
+    Attributes
+    ----------
+    number_of_cities : int
+        cities count
+    coords_range : tuple[int, int]
+        range of coordinates of the cities
+    cities_coords : list[tuple[float, float]]
+        coordinates of the cities
+    distance_matrix : list[list[float]]
+        matrix of distances between cities
+    normalized_distance_matrix : list[list[float]]
+        normalized to (0, 1] matrix of distances between cities
+    """
+
+    def __init__(
+        self,
+        number_of_cities: int,
+        coords_range: tuple[int, int] = (0, 10000)
+    ) -> None:
+        """
+        Parameters
+        ----------
+        number_of_cities : int
+            cities count
+        coords_range : tuple[float, float]
+            range of coordinates of the cities
+        """
+        self.number_of_cities: int = number_of_cities
+        self.coords_range: tuple[int, int] = coords_range
+        self.cities_coords: list[tuple[float, float]] = self.get_cities()
+        self.distance_matrix: list[
+            list[float]] = self.calculate_distance_matrix()
+        self.normalized_distance_matrix: list[
+            list[float]] = self.normalize_distance_matrix()
+
+    def get_cities(self) -> list[tuple[float, float]]:
+        cities_coords = np.random.randint(
+            self.coords_range[0], self.coords_range[1],
+            size=(self.number_of_cities, 2))
+        return cast(list[tuple[float, float]], cities_coords)
+
+    def calculate_distance_between_points(
+        self, point_A: tuple[float, float], point_B: tuple[float, float]
+    ) -> float:
+        return cast(
+            float,
+            np.sqrt((point_A[0] - point_B[0]) ** 2
+                    + (point_A[1] - point_B[1]) ** 2)
+        )
+
+    def calculate_distance_matrix(self) -> list[list[float]]:
+        distance_matrix = np.zeros(
+            (self.number_of_cities, self.number_of_cities))
+        for i in range(self.number_of_cities):
+            for j in range(i, self.number_of_cities):
+                distance_matrix[i][j] = self.calculate_distance_between_points(
+                    self.cities_coords[i], self.cities_coords[j])
+                distance_matrix[j][i] = distance_matrix[i][j]
+        return cast(list[list[float]], distance_matrix)
+
+    def normalize_distance_matrix(self) -> list[list[float]]:
+        return cast(
+            list[list[float]],
+            np.divide(self.distance_matrix, np.max(self.distance_matrix))
+        )
+
+
+class TSPProblem(Problem):
+    """Class defining objective function and constraints for TSP problem
+
+    Attributes
+    ----------
+    objective_function : Expression
+        objective function in SymPy syntax
+    constraints : list[Expression]
+        list of constraints in SymPy syntax
+    variables : int
+        number of qubits in the circuit, equals to number of cities
+        to the power of 2
+    tsp_instance: TSP
+        TSP problem instace
+    """
+
+    def __init__(
+            self,
+            number_of_cities: int
+    ) -> None:
+        """
+        Parameters
+        ----------
+        number_of_cities : int
+            number of cities
+        """
+
+        self.tsp_instance = TSP(number_of_cities)
+        self.variables: tuple[sympy.Symbol] = sympy.symbols(
+            ' '.join([f'x{i}' for i in range(number_of_cities ** 2)]))
+        self._set_objective_function()
+        self._set_constraints()
+
+    def _calc_bit(self, i: int, t: int) -> int:
+        return i + t * self.tsp_instance.number_of_cities
+
+    def _set_objective_function(self) -> None:
+        equation = cast(sympy.Expr, 0)
+        for i, j in itertools.permutations(
+            range(0, self.tsp_instance.number_of_cities), 2
+        ):
+            curr = 0
+            for t in range(self.tsp_instance.number_of_cities):
+                inc_t = t + 1
+                if inc_t == self.tsp_instance.number_of_cities:
+                    inc_t = 0
+                curr += (
+                    self.variables[self._calc_bit(i, t)]
+                    * self.variables[self._calc_bit(j, inc_t)]
+                )
+            equation += (
+                self.tsp_instance.normalized_distance_matrix[i][j] * curr
+            )
+        self.objective_function: Expression = Expression(equation)
+
+    def _set_constraints(self) -> None:
+        self.constraints: list[Expression] = []
+        for i in range(self.tsp_instance.number_of_cities):
+            equation = cast(sympy.Expr, 1)
+            for t in range(self.tsp_instance.number_of_cities):
+                equation -= self.variables[self._calc_bit(i, t)]
+            self.constraints.append(Expression(equation))
+
+        for t in range(self.tsp_instance.number_of_cities):
+            equation = cast(sympy.Expr, 1)
+            for i in range(self.tsp_instance.number_of_cities):
+                equation -= self.variables[self._calc_bit(i, t)]
+        self.constraints.append(Expression(equation))
+
+    def _get_distance(self, key: str) -> float:
+        results = np.array_split(list(key), self.tsp_instance.number_of_cities)
+        dist: float = 0
+        tab = []
+        for result in results:
+            tab.append(list(result).index('1'))
+
+        for i in range(len(tab)):
+            j = i - 1
+            dist += (
+                self.tsp_instance.normalized_distance_matrix[tab[i]][tab[j]]
+            )
+        return dist
+
+    def _valid(self, result: str) -> bool:
+        result_bools = np.reshape(
+            list(result),
+            (-1, self.tsp_instance.number_of_cities)
+            ).astype(np.bool8)
+        return cast(bool, (
+            result_bools.sum(0) == 1).all()
+            and (result_bools.sum(1) == 1).all()
+        )
+
+    def get_score(self, result: str, penalty: float = 0) -> float:
+        """Returns length of the route based on provided outcome in bits.
+
+        Parameters
+        ----------
+        result : str
+            route as a string of zeros and ones
+
+        Returns
+        -------
+        float
+            Returns length of the route, or 0 if route wasn't correct
+        """
+        if not self._valid(result):
+            return penalty  # Bigger value that possible distance
+        return self._get_distance(result)