eqc-models 0.9.8__py3-none-any.whl

eqc_models-0.9.8.data/platlib/eqc_models/graph/hypergraph.py

@@ -0,0 +1,307 @@
+import numpy as np
+import pandas as pd
+from typing import List, Tuple, Dict, Union
+from collections import defaultdict
+from eqc_models.base import ConstraintsMixIn, PolynomialModel
+from eqc_models.base.operators import Polynomial
+
+
+class HypergraphModel(ConstraintsMixIn, PolynomialModel):
+    """
+    HypergraphModel represents a flexible model for constructing and preparing hypergraph-based
+    polynomial optimization problems for use with solvers serviced through eqc-models.
+
+    Parameters
+    ----------
+    data : List of Lists, Dictionary, Nested Dictionary, np.ndarray, pd.DataFrame, or nx.Graph
+        The hypergraph data representing terms and relationships among nodes. Supported formats:
+
+        - List of lists: Each sublist represents a hyperedge with nodes as elements.
+        - Dictionary of tuples: Each key is a unique term identifier, with values as tuples of nodes.
+        - Nested dictionary: Supports detailed attribute descriptions per node in each term.
+        - 2D np.ndarray: Each row represents a relationship with two elements, where the first
+          is the hyperedge and the second is the node.
+        - pd.DataFrame: Assumes the first two columns are edges and nodes by default, with an optional
+          'weight' column specifying weights for incidences.
+
+    lhs : np.ndarray, optional
+        Left-hand side matrix for linear constraints in penalty terms.
+    rhs : np.ndarray, optional
+        Right-hand side vector for linear constraints in penalty terms.
+    alpha : float, optional
+        Multiplier for penalties associated with linear constraints, default is 1.0.
+
+    Attributes
+    ----------
+    H : tuple of arrays
+        Polynomial coefficients and indices for the Hamiltonian representation of the problem.
+
+    penalty_multiplier : float
+        Weighting for penalties formed from linear constraints, which scales the penalty terms.
+
+    polynomial : eqc_models.base.operators.Polynomial
+        Polynomial operator representation for the problem terms.
+
+    qubo : eqc_models.base.operators.QUBO
+        QUBO operator representation if quadratic constraints are required.
+
+    dynamic_range : float
+        Dynamic range of the polynomial coefficients, measured in decibels.
+
+    This class provides a model for representing hypergraph-based optimization problems with various
+    polynomial terms based on input types. The hypergraph data can include hyperedges of arbitrary order,
+    penalties for linear constraints, and flexible terms to allow encoding multibody interactions.
+
+    Example
+    -------
+    An example of creating a hypergraph model from a list of lists input representing hyperedges:
+
+    >>> data = [['A', 'B', 'C'], ['A', 'D'], ['C', 'D', 'E']]
+    >>> lhs = np.array([[1, -1, 0], [0, 1, -1]])
+    >>> rhs = np.array([0, 0])
+    >>> model = HypergraphModel(data, lhs=lhs, rhs=rhs, alpha=2.0)
+    >>> model.penalty_multiplier
+    2.0
+    >>> coefficients, indices = model.H
+    >>> coefficients
+    array([1., 1., 1.])
+    >>> indices
+    array([[1, 2, 3],
+           [0, 1, 4],
+           [3, 4, 5]])
+
+    This model can then be used with solvers serviced through eqc-models for optimizing polynomial-based
+    objectives with hypergraph structure.
+    """
+    def __init__(self, data: Union[List[List], Dict[int, Tuple], Dict[int, Dict[str, Dict[str, Union[str, int]]]],
+                 np.ndarray, pd.DataFrame], lhs: np.ndarray = None, rhs: np.ndarray = None,
+                 alpha: float = 1.0):
+        # Process data to extract `coefficients` and `indices` for polynomial terms
+        coefficients, indices = self.process_data(data)
+
+        # Initialize PolynomialModel with processed coefficients and indices
+        super().__init__(coefficients, indices)
+
+        # Initialize constraints if provided
+        if lhs is not None and rhs is not None:
+            self.constraints = (lhs, rhs)
+        self.penalty_multiplier = alpha
+
+    def process_data(self, data: Union[List[List], Dict[int, Tuple], Dict[int, Dict[str, Dict[str, Union[str, int]]]],
+                     np.ndarray, pd.DataFrame]) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Processes the input data to extract polynomial coefficients and indices for
+        the hypergraph representation.
+
+        Parameters
+        ----------
+        data : Union[List of Lists, Dict, Dict of Dicts, np.ndarray, pd.DataFrame]
+            Input hypergraph data in various supported formats, representing terms
+            and relationships among nodes.
+
+        Returns
+        -------
+        Tuple of numpy arrays
+            Tuple containing two numpy arrays, one for coefficients and one for indices
+            representing polynomial terms.
+        """
+        if isinstance(data, list):
+            return self._process_list_data(data)
+        elif isinstance(data, dict):
+            return self._process_dict_data(data)
+        elif isinstance(data, np.ndarray) and data.shape[1] == 2:
+            return self._process_ndarray_data(data)
+        elif isinstance(data, pd.DataFrame) and data.shape[1] >= 2:
+            return self._process_dataframe_data(data)
+        else:
+            raise ValueError("Unsupported data type for hypergraph model")
+
+    def _process_list_data(self, data: List[List]) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Converts a list of lists to formatted coefficients and indices.
+
+        Parameters
+        ----------
+        data : List of Lists
+            Each sublist represents a hyperedge with nodes as elements.
+
+        Returns
+        -------
+        Tuple of numpy arrays
+            Coefficients as a 1D array and indices as a 2D array formatted with
+            polynomial terms for each hyperedge.
+        """
+        # Create a unique index for each element across all sublists
+        unique_elements = sorted(set(element for sublist in data for element in sublist))
+        element_to_index = {element: idx + 1 for idx, element in enumerate(unique_elements)}  # 1-based indexing
+
+        indices = []
+        order = max([len(sublist) for sublist in data])
+        for sublist in data:
+            # Convert each element in the sublist to its unique index and sort
+            term_indices = sorted(element_to_index[element] for element in sublist)
+            indices.append(([0] * (order - len(sublist))) + term_indices)  # Prepend 0 to each index list per format
+
+        indices = sorted(indices)
+        coefficients = np.ones(len(data))  # Default coefficient of 1.0 for each sublist term
+        return coefficients, np.array(indices)
+
+    def _process_dict_data(self, data: Dict[int, Tuple[str, ...]]) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Converts a dictionary with tuple values to formatted coefficients and indices.
+
+        Parameters
+        ----------
+        data : Dictionary of tuples
+            Dictionary where each key represents a unique term identifier and values
+            are tuples of nodes forming the term.
+
+        Returns
+        -------
+        Tuple of numpy arrays
+            Coefficients as a 1D array and indices as a 2D array formatted with
+            polynomial terms for each term in the dictionary.
+        """
+        # Create a unique index for each element across all tuples
+        unique_elements = sorted(set(element for elements in data.values() for element in elements))
+        element_to_index = {element: idx + 1 for idx, element in enumerate(unique_elements)}  # 1-based indexing
+
+        indices = []
+        order = max([len(sublist) for sublist in data.values()])
+        for elements in data.values():
+            # Convert each element in the tuple to its unique index and sort
+            term_indices = sorted(element_to_index[element] for element in elements)
+            indices.append(([0] * (order - len(elements))) + term_indices)  # Prepend 0 to each index list per format
+
+        indices = sorted(indices)
+        coefficients = np.ones(len(data))  # Default coefficient of 1.0 for each term
+        return coefficients, np.array(indices)
+
+    def _process_ndarray_data(self, data: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Converts a numpy array to formatted coefficients and indices, assuming
+        shape (N, 2), where each row represents a [Group, Node] pair.
+
+        Parameters
+        ----------
+        data : np.ndarray
+            2D array where each row represents a hyperedge and node relationship.
+
+        Returns
+        -------
+        Tuple of numpy arrays
+            Coefficients as a 1D array with default values, and indices as a 2D array
+            formatted for each group of nodes within each unique hyperedge.
+        """
+        # Group nodes by hyperedge label (first element in each row)
+        grouped_nodes = defaultdict(list)
+        for group_label, node_label in data:
+            grouped_nodes[group_label].append(node_label)
+
+        # Create a unique index for each node label across all hyperedges
+        unique_nodes = sorted(set(node for nodes in grouped_nodes.values() for node in nodes))
+        node_to_index = {node: idx + 1 for idx, node in enumerate(unique_nodes)}  # 1-based indexing
+
+        indices = []
+        order = max([len(sublist) for sublist in grouped_nodes.values()])
+        for nodes in grouped_nodes.values():
+            # Convert each node in the hyperedge to its unique index and sort
+            term_indices = sorted(node_to_index[node] for node in nodes)
+            indices.append(([0] * (order - len(nodes))) + term_indices)  # Prepend 0 to each index list per format
+
+        indices = sorted(indices)
+        coefficients = np.ones(len(indices))  # Default coefficient of 1.0 for each hyperedge term
+        return coefficients, np.array(indices)
+
+    def _process_dataframe_data(self, data: pd.DataFrame) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Converts a DataFrame with edge, node, and optional weight columns to formatted
+        coefficients and indices.
+
+        Parameters
+        ----------
+        data : pd.DataFrame
+            DataFrame where the first two columns represent edges and nodes, and an
+            optional 'weight' column specifies weights for each incidence.
+
+        Returns
+        -------
+        Tuple of numpy arrays
+            Coefficients based on the 'weight' column if present, and indices as a 2D
+            array for each hyperedge.
+        """
+        # Use the first two columns as edge and node labels
+        edge_column = data.columns[0]
+        node_column = data.columns[1]
+
+        # Check for a 'weight' column; default weights to 1.0 if not present
+        if 'weight' in data.columns:
+            weights = data['weight'].fillna(1.0).values
+        else:
+            weights = np.ones(len(data))
+
+        # Group nodes by hyperedge (first column)
+        grouped_nodes = data.groupby(edge_column)[node_column].apply(list).to_dict()
+        grouped_weights = data.groupby(edge_column)['weight'].apply(lambda x: x.iloc[0] if 'weight' in data.columns else 1.0).tolist()
+
+        # Map each node label to a unique, 1-based index
+        unique_nodes = sorted(set(node for nodes in grouped_nodes.values() for node in nodes))
+        node_to_index = {node: idx + 1 for idx, node in enumerate(unique_nodes)}  # 1-based indexing
+
+        indices = []
+        order = max([len(sublist) for sublist in grouped_nodes.values()])
+        for nodes in grouped_nodes.values():
+            # Convert each node in the hyperedge to its unique index and sort
+            term_indices = sorted(node_to_index[node] for node in nodes)
+            indices.append(([0] * (order - len(nodes))) + term_indices)  # Prepend 0 to each index list per format
+
+        # Sort indices and grouped_weights
+        grouped_weights = [x for _, x in sorted(zip(indices, grouped_weights))]
+        indices = sorted(indices)
+
+        coefficients = np.array(grouped_weights)  # Use the grouped weights as coefficients
+        return coefficients, np.array(indices)
+
+    @property
+    def H(self) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Retrieves the Hamiltonian representation as polynomial coefficients and indices.
+
+        Returns
+        -------
+        Tuple of numpy arrays
+            Coefficients and indices for polynomial terms in the Hamiltonian.
+        """
+        return self.coefficients, self.indices
+
+    def evaluateObjective(self, solution: np.ndarray) -> float:
+        """
+        Evaluate polynomial at solution
+
+        :solution: 1-d numpy array with the same length as the number of variables
+
+        returns a floating point value
+
+        """
+
+        value = 0
+        coefficients, indices = self.H
+        for index, coefficient in zip(indices, coefficients):
+            term = coefficient
+            for i in index:
+                if i > 0:
+                    term *= solution[i - 1]
+            value += term
+        return value
+
+    @property
+    def polynomial(self) -> Polynomial:
+        """
+        Retrieves the polynomial operator representation of the hypergraph model.
+
+        Returns
+        -------
+        Polynomial
+            Polynomial operator representing terms in the hypergraph model.
+        """
+        return Polynomial(list(self.H[0]), list(self.H[1]))

eqc_models-0.9.8.data/platlib/eqc_models/graph/maxcut.py

@@ -0,0 +1,155 @@
+# (C) Quantum Computing Inc., 2024.
+import networkx as nx
+import numpy as np
+from .base import TwoPartitionModel
+
+
+class MaxCutModel(TwoPartitionModel):
+
+    def decode(self, solution: np.ndarray) -> np.ndarray:
+        """ Override the default decoding to use a the max cut metric to determine a solution """
+
+        Gprime, solution = determine_solution(self.G, solution)
+        cut_size = len(self.G.edges) - len(Gprime.edges)
+        return solution
+    
+    @property
+    def J(self) -> np.ndarray:
+        return self.quad_objective
+
+    @property
+    def C(self) -> np.ndarray:
+        return self.linear_objective
+    
+    @property
+    def H(self):
+        return self.linear_objective, self.quad_objective
+    
+    def partition(self, solution):
+        """ Return a dictionary with the partition number of each node """
+        
+        partition_num = {}
+        for i, u in enumerate(self.node_map):
+            if solution[i] == 0:
+                partition_num[u] = 1
+            else:
+                partition_num[u] = 2
+        return partition_num
+    
+    def getCutSize(self, partition):
+        cut_size = 0
+        for u, v in self.G.edges:
+            if partition[u]!=partition[v]:
+                cut_size += 1
+        return cut_size
+
+    def costFunction(self):
+        """ 
+        Parameters
+        -------------
+        
+        None
+        
+        Returns
+        --------------
+        
+        :C: linear operator (vector array of coefficients) for cost function
+        :J: quadratic operator (N by N matrix array of coefficients ) for cost function
+        
+        """
+        G = self.G
+        self.node_map = list(G.nodes)
+        variables = self.variables
+        n = len(variables)
+        self.upper_bound = np.ones((n,))
+        
+        J = np.zeros((n, n), dtype=np.float32)
+        h = np.zeros((n, 1), dtype=np.float32)
+        for u, v in G.edges:
+            J[u, v] += 1
+            J[v, u] += 1
+            h[u, 0] -= 1
+            h[v, 0] -= 1
+        return h, J
+
+
+def get_graph(n, d):
+    """ Produce a repeatable graph with parameters n and d """
+
+    seed = n * d
+    return nx.random_graphs.random_regular_graph(d, n, seed)
+
+
+def get_partition_graph(G, solution):
+    """
+    Build the partitioned graph, counting cut size 
+
+    :parameters: G : nx.DiGraph, solution : np.ndarray
+    :returns: nx.DiGraph, int
+    
+    """
+
+    cut_size = 0
+    Gprime = nx.DiGraph()
+    Gprime.add_nodes_from(G.nodes)
+    for i, j in G.edges:
+        if solution[i] != solution[j]:
+            cut_size += 1
+        else:
+            Gprime.add_edge(i, j)
+    return Gprime, cut_size
+
+
+def determine_solution(G, solution):
+    """
+    Use a simple bisection method to determine the binary solution. Uses
+    the cut size as the metric.
+
+    Returns the partitioned graph and solution.
+
+    :parameters: G : nx.DiGraph, solution : np.ndarray
+    :returns: nx.DiGraph, np.ndarray
+
+    """
+    solution = np.array(solution)
+    test_vals = np.copy(solution)
+    test_vals.sort()
+    lower = 0
+    upper = solution.shape[0] - 1
+    best_cut_size = 0
+    best_graph = G
+    best_solution = None
+    while upper > lower:
+        middle = (upper + lower) // 2
+        threshold = test_vals[middle]
+        test_solution = (solution>=threshold).astype(np.int32)
+        Gprime, cut_size = get_partition_graph(G, test_solution)
+        if cut_size > best_cut_size:
+            best_cut_size = cut_size
+            lower = middle
+            best_solution = test_solution
+            best_graph = Gprime
+        else:
+            upper = middle
+    return best_graph, best_solution
+
+def get_maxcut_H(G, t):
+    """ 
+    Return a Hamiltonian representing the Maximum Cut Problem. Scale the problem using `t`.
+    Automatically adds a slack qudit.
+    
+    """
+    n = len(G.nodes)
+    J = np.zeros(shape=(n+1, n+1), dtype=np.float32)
+    h = np.zeros(shape=(n+1,1), dtype=np.float32)
+    for u, v in G.edges:
+        J[u, v] += 1
+        J[v, u] += 1
+        J[u, u] = 1
+        J[v, v] = 1
+        h[u] -= 1
+        h[v] -= 1
+    J *= 1/t**2
+    h *= 1/t
+    H = np.hstack([h, J])
+    return H

eqc_models-0.9.8.data/platlib/eqc_models/graph/maxkcut.py

@@ -0,0 +1,184 @@
+# (C) Quantum Computing Inc., 2024.
+import numpy as np
+import networkx as nx
+from .base import NodeModel
+
+
+class MaxKCutModel(NodeModel):
+
+    def __init__(self, G : nx.Graph, k : int):
+        super(MaxKCutModel, self).__init__(G)
+        self.k = k
+        self.lhs = None
+        self.rhs = None
+        self._objective = None
+        self._J = None
+        self._C = None
+
+    def decode(self, solution: np.ndarray) -> np.ndarray:
+        """ Override the default decoding to use a the max cut metric to determine a solution """
+
+        # only one partition per node can be selected
+        # rather than the same cutoff per node, use the max value per partition
+        decoded_solution = np.zeros_like(solution, dtype=np.int32)
+        k = self.k
+        for i, u in enumerate(self.variables):
+            idx = slice(k*i, k*(i+1))
+            spins = solution[idx]
+            mx = np.max(spins)
+            for j in range(k):
+                if spins[j] == mx:
+                    decoded_solution[k*i+j] = 1
+                    break
+        return decoded_solution
+    
+    def partition(self, solution):
+        """ Return a dictionary with the partition number of each node """
+        k = self.k
+        n = len(self.variables)
+        partition_num = {}
+        for i, u in enumerate(self.variables):
+            for j in range(k):
+                if solution[i*k+j] == 1:
+                    partition_num[u] = j+1
+        return partition_num
+    
+    def getCutSize(self, partition):
+        cut_size = 0
+        for u, v in self.G.edges:
+            if partition[u]!=partition[v]:
+                cut_size += 1
+        return cut_size
+
+    def _build_objective(self):
+        
+        node_map = self.variables
+        G = self.G
+        m = len(G.nodes)
+        n = self.k * m
+        # construct the quadratic portion of the objective
+        # the linear portion is 0
+        objective = np.zeros((n, n), dtype=np.float32)
+        # increment the joint variable terms indicating the nodes are in different sets
+        pairs = [(i, j) for i in range(self.k) for j in range(self.k) if i!=j]
+        for u, v in G.edges:
+            i = node_map.index(u)
+            j = node_map.index(v)
+            ibase = i * self.k
+            jbase = j * self.k
+            for incr1, incr2 in pairs:
+                idx1 = ibase + incr1
+                idx2 = jbase + incr2
+                objective[idx1, idx2] += -1
+        self._objective = (np.zeros((n, 1)), objective)
+
+    def _build_constraints(self):
+
+        node_map = self.variables
+        G = self.G
+        m = len(G.nodes)
+        n = self.k * m
+
+        # build the constraints
+        A = np.zeros((m, n))
+        b = np.ones((m,))
+        for u in G.nodes:
+            i = node_map.index(u)
+            ibase = i * self.k
+            A[i, ibase:ibase+self.k] = 1
+        self.lhs = A
+        self.rhs = b
+
+    def build(self, multiplier=None):
+        """ Create the constraints and objective and Hamiltonian """
+
+        # there are k * m variables in this problem where m is the number of nodes in the graph
+        node_map = self.variables
+        G = self.G
+        m = len(G.nodes)
+        n = self.k * m
+        self.upper_bound = np.ones((n,))
+        
+        self._build_objective()
+        if multiplier is None:
+            multiplier = np.max(np.abs(self._objective[1]))
+        self._build_constraints()
+
+        self._C, self._J = self.buildH(multiplier)
+        self.sum_constraint = m
+
+    def buildH(self, multiplier):
+        """ Combine the objective and penalties using the multiplier """
+
+        objC, objJ = self.objective
+        lhs, rhs = self.constraints
+        Pq = lhs.T@lhs
+        Pl = -2 * rhs.T@lhs
+        offset = rhs.T@rhs
+        n = self.n
+        J = np.zeros((n, n), np.float32)
+        C = np.zeros([n, 1], np.float32)
+        C += objC
+        J[:,:] += objJ
+        C += multiplier * Pl.reshape((n, 1))
+        J[:,:] += multiplier * Pq
+        return C, J
+
+    @property
+    def constraints(self):
+        """ Return LHS, RHS in numpy matrix format """
+        if self.rhs is None:
+            self.build()
+        return self.lhs, self.rhs
+
+    @property
+    def objective(self):
+        """ Return the quadratic objective as NxN+1 matrix """
+
+        if self._objective is None:
+            self.build()
+        return self._objective
+
+    @property
+    def H(self):
+        """ Return the Hamiltonian as parts C, J """
+
+        if self._C is None:
+            self.build()
+        return self._C, self._J
+    
+class WeightedMaxKCutModel(MaxKCutModel):
+
+    def __init__(self, G: nx.Graph, k: int, weight_label : str = "weight"):
+        super().__init__(G, k)
+
+        self.weight_label = weight_label
+    
+    def _build_objective(self):
+        
+        node_map = self.variables
+        G = self.G
+        m = len(G.nodes)
+        n = self.k * m
+        # construct the quadratic portion of the objective
+        # the linear portion is 0
+        objective = np.zeros((n, n), dtype=np.float32)
+        # increment the joint variable terms indicating the nodes are in different sets
+        pairs = [(i, j) for i in range(self.k) for j in range(self.k) if i!=j]
+        for u, v in G.edges:
+            i = node_map.index(u)
+            j = node_map.index(v)
+            ibase = i * self.k
+            jbase = j * self.k
+            for incr1, incr2 in pairs:
+                idx1 = ibase + incr1
+                idx2 = jbase + incr2
+                objective[idx1, idx2] += G[u][v][self.weight_label]
+        self._objective = (np.zeros((n, 1)), objective)
+
+    def getCutSize(self, partition):
+        cut_size = 0
+        for u, v in self.G.edges:
+            if partition[u]!=partition[v]:
+                cut_size += self.G[u][v][self.weight_label]
+        return cut_size

eqc_models-0.9.8.data/platlib/eqc_models/ml/__init__.py

@@ -0,0 +1,15 @@
+# (C) Quantum Computing Inc., 2024.
+from .classifierqboost import QBoostClassifier
+from .classifierqsvm import QSVMClassifier
+from .decomposition import PCA
+from .forecast import ReservoirForecastModel
+
+__all__ = [
+    "QBoostClassifier",
+    "QSVMClassifier",
+    "PCA",
+    "ReservoirForecastModel",
+    "LinearRegression",
+    "GraphClustering",
+    "Clustering",
+]