eqc-models 0.9.8__py3-none-any.whl

eqc_models-0.9.8.data/platlib/eqc_models/allocation/portbase.py

@@ -0,0 +1,128 @@
+# (C) Quantum Computing Inc., 2024.
+# Import libs
+import os
+import sys
+import time
+import datetime
+import json
+import warnings
+from functools import wraps
+import numpy as np
+import pandas as pd
+
+from ..base import ConstraintsMixIn
+from eqc_models import QuadraticModel
+
+
+class PortBase(ConstraintsMixIn, QuadraticModel):
+    def __init__(
+        self,
+        stocks: list,
+        stock_data_dir: str,
+        adj_date: str,
+        lookback_days: int = 60,
+    ):
+        self.stocks = stocks
+        self.data_dir = stock_data_dir
+        self.adj_date = adj_date
+        self.lookback_days = lookback_days
+
+        self._H = self.build()
+
+    def get_stock_returns(self, min_date, max_date):
+        stocks = self.stocks
+        min_date = pd.to_datetime(min_date)
+        max_date = pd.to_datetime(max_date)
+
+        return_df = None
+        for stock in stocks:
+            stock_df = pd.read_csv(
+                os.path.join(self.data_dir, "%s.csv" % stock)
+            )
+            stock_df["Date"] = stock_df["Date"].astype("datetime64[ns]")
+            stock_df = (
+                stock_df.fillna(method="ffill")
+                .fillna(method="bfill")
+                .fillna(0)
+            )
+            stock_df[stock] = stock_df[stock].pct_change()
+            stock_df = stock_df.dropna()
+
+            stock_df = stock_df[
+                (stock_df["Date"] >= min_date)
+                & (stock_df["Date"] <= max_date)
+            ]
+
+            if return_df is None:
+                return_df = stock_df
+            else:
+                return_df = return_df.merge(
+                    stock_df,
+                    how="outer",
+                    on="Date",
+                )
+
+        return_df = (
+            return_df.fillna(method="ffill")
+            .fillna(method="bfill")
+            .fillna(0)
+        )
+
+        return return_df
+
+    def get_hamiltonian(
+        self,
+        return_df,
+        min_date,
+        max_date,
+    ):
+        pass
+
+    def build(self):
+        # Get dates
+        adj_date = pd.to_datetime(self.adj_date)
+        min_date = adj_date - datetime.timedelta(days=self.lookback_days)
+        max_date = adj_date - datetime.timedelta(days=1)
+
+        # Get return dataframe
+        return_df = self.get_stock_returns(min_date, max_date)
+        return_df = return_df.sort_values("Date")
+        return_df = return_df.fillna(method="ffill").fillna(0)
+
+        # Get and set hamiltonian
+        J, C, sum_constraint = self.get_hamiltonian(
+            return_df,
+            min_date,
+            max_date,
+        )
+        self._C = C
+        self._J = J
+        self._sum_constraint = sum_constraint
+        
+        # Set domain
+        num_variables = C.shape[0]
+        self.upper_bound = sum_constraint * np.ones((num_variables,))
+
+        return C, J
+
+    def get_dynamic_range(self):
+        C = self._C
+        J = self._J
+
+        if C is None:
+            return
+
+        if J is None:
+            return
+
+        absc = np.abs(C)
+        absj = np.abs(J)
+        minc = np.min(absc[absc > 0])
+        maxc = np.max(absc)
+        minj = np.min(absj[absj > 0])
+        maxj = np.max(absj)
+
+        minval = min(minc, minj)
+        maxval = max(maxc, maxj)
+
+        return 10 * np.log10(maxval / minval)

eqc_models-0.9.8.data/platlib/eqc_models/allocation/portmomentum.py

@@ -0,0 +1,137 @@
+# (C) Quantum Computing Inc., 2024.
+# Import libs
+import os
+import sys
+import time
+import datetime
+import json
+import warnings
+from functools import wraps
+import numpy as np
+import pandas as pd
+
+from .portbase import PortBase
+
+
+class PortMomentum(PortBase):
+    def __init__(
+        self,
+        stocks: list,
+        stock_data_dir: str,
+        adj_date: str,
+        lookback_days: int = 60,
+        window_days: int = 30,
+        window_overlap_days: int = 15,
+        weight_upper_limit: float = 0.08,
+        r_base: float = 0.05 / 365,
+        alpha: float = 5.0,
+        beta: float = 1.0,
+        xi: float = 1.0,
+    ):
+        self.stocks = stocks
+        self.data_dir = stock_data_dir
+        self.adj_date = adj_date
+        self.lookback_days = lookback_days
+
+        self.window_days = window_days
+        self.window_overlap_days = window_overlap_days
+        self.weight_upper_limit = weight_upper_limit
+        self.r_base = r_base
+        self.alpha = alpha
+        self.beta = beta
+        self.xi = xi
+
+        self._H = self.build()
+
+    def get_hamiltonian(
+        self,
+        return_df,
+        min_date,
+        max_date,
+    ):
+        stocks = self.stocks
+        xi = self.xi
+        window_days = self.window_days
+        window_overlap_days = self.window_overlap_days
+        weight_upper_limit = self.weight_upper_limit
+
+        # Set some params
+        K = len(stocks)
+
+        # Calculate Q and p_vec
+        Q = np.zeros(shape=(K, K), dtype=np.float32)
+        p_vec = np.zeros(shape=(K), dtype=np.float32)
+
+        m = 0
+        min_date = pd.to_datetime(min_date)
+        max_date = pd.to_datetime(max_date)
+        tmp_date = min_date
+        while tmp_date <= max_date:
+            tmp_min_date = tmp_date
+            tmp_max_date = tmp_date + datetime.timedelta(days=window_days)
+            tmp_df = return_df[
+                (return_df["Date"] >= tmp_min_date)
+                & (return_df["Date"] <= tmp_max_date)
+            ]
+
+            r_list = []
+            for i in range(K):
+                r_list.append(np.array(tmp_df[stocks[i]]))
+
+            Q_tmp = np.cov(r_list)
+            for i in range(K):
+                p_vec[i] += -self.r_base * np.mean(r_list[i])
+                for j in range(K):
+                    Q[i][j] += Q_tmp[i][j]
+
+            tmp_date += datetime.timedelta(
+                days=window_days - window_overlap_days,
+            )
+            m += 1
+
+        fct = m
+        if fct > 0:
+            fct = 1.0 / fct
+
+        p_vec = fct * p_vec
+        Q = fct * Q
+
+        # Calculate the Hamiltonian
+        J_no_limit = xi * Q
+        C_no_limit = p_vec
+
+        # make sure J is symmetric up to machine precision
+        J_no_limit = 0.5 * (J_no_limit + J_no_limit.transpose())
+
+        if weight_upper_limit is None:
+            return J_no_limit, C_no_limit, 100.0
+
+        W_max = 100.0 * weight_upper_limit
+
+        J = np.zeros(shape=(2 * K, 2 * K), dtype=np.float32)
+        C = np.zeros(shape=(2 * K), dtype=np.float32)
+
+        for i in range(K):
+            for j in range(K):
+                J[i][j] = J_no_limit[i][j] + self.alpha
+
+            J[i][i] += self.beta
+            J[i][i + K] += self.beta
+            J[i + K][i] += self.beta
+            J[i + K][i + K] += self.beta
+            C[i] = (
+                C_no_limit[i] - 200.0 * self.alpha - 2 * self.beta * W_max
+            )
+            C[i + K] = -2 * self.beta * W_max
+
+        C = C.reshape((C.shape[0], 1))
+
+        # Check hamiltonian dims
+        stocks = self.stocks
+        K = len(stocks)
+
+        assert J.shape[0] == K or J.shape[0] == 2 * K
+        assert J.shape[1] == K or J.shape[0] == 2 * K
+        assert C.shape[0] == K or C.shape[0] == 2 * K
+
+        return J, C, K * W_max

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

@@ -0,0 +1,5 @@
+# (C) Quantum Computing Inc., 2024.
+
+from .qap import QAPModel
+
+__all__ = ["QAPModel"]

eqc_models-0.9.8.data/platlib/eqc_models/assignment/qap.py

@@ -0,0 +1,82 @@
+# (C) Quantum Computing Inc., 2024.
+import numpy as np
+from eqc_models.base import ConstrainedQuadraticModel
+
+class QAPModel(ConstrainedQuadraticModel):
+    """ 
+    Parameters
+    ----------
+
+    A : np.array
+        matrix of distances or costs between locations
+    B : np.array
+        matrix of flows between facilities
+    C : np.array
+        matrix pf fixed costs of assigning facilities to locations
+
+
+    Formulates a quadratic programming model from three inputs. The inputs are composed of:
+    a matrix which describes the unit cost of moving a single asset between locations. This
+    matrix can describe asynchronous costs that differ by direction of flow; a matrix which
+    describes the quantity of flow between facilities. This matrix describes the quantity 
+    in the direction of flow; a matrix which desribes the fixed cost of assigning a facility
+    to a location.
+
+    Using these flows and costs, an optimization problem is formulated to determine a
+    solution which minimizes the total cost for positioning facilities at locations. The 
+    facilities do not have to be buildings or campuses and the locations do not have to be
+    geographical locations. See Beckmann and and Koopmans (1957) for the original reference.
+
+    >>> A = np.array([[0, 5, 8, 0, 1],
+    ...               [0, 0, 0, 10, 15],
+    ...               [0, 0, 0, 13, 18],
+    ...               [0, 0, 0, 0, 0.],
+    ...               [0, 0, 0, 1, 0.]])
+    >>> B = np.array([[0, 8.54, 6.4, 10, 8.94],
+    ...               [8.54, 0, 4.47, 5.39, 6.49],
+    ...               [6.4, 4.47, 0, 3.61, 3.0],
+    ...               [10, 5.39, 3.61, 0, 2.0],
+    ...               [8.94, 6.49, 3.0, 2.0, 0.]])
+    >>> C = np.array([[2, 3, 6, 3, 7],
+    ...               [3, 9, 2, 5, 9],
+    ...               [2, 6, 4, 1, 2],
+    ...               [7, 5, 8, 5, 7],
+    ...               [1, 9, 2, 9, 2.]])
+    >>> model = QAPModel(A, B, C)
+    >>> model.penalty_multiplier = 105.625
+    >>> Q = model.qubo.Q
+    >>> np.sum(Q)
+    24318.03
+
+    """
+
+    def __init__(self, A : np.ndarray, B : np.ndarray, C: np.ndarray):
+        
+        self.A = A
+        self.B = B
+        self.C = C
+        # N is the number of facilities (same as locations)
+        # n is the number of variables (N ** 2)
+        self.N = N = A.shape[0]
+        self.upper_bound = np.ones((N**2,), dtype=np.int64)
+
+        # objective 
+        A = self.A
+        B = self.B
+        C = self.C
+        n = self.N ** 2
+        
+        objective = np.kron(A, B) + np.diag(C.reshape((n, )))
+        objective += objective.T
+        objective /= 2.
+        self.quad_objective = objective
+        self.linear_objective = np.zeros((n,))
+        # G
+        m = 2 * self.N
+        G = np.zeros((m, n), dtype=np.float32)
+        for i in range(self.N):
+            G[i, i::self.N] = 1
+            G[self.N + i, i*self.N:(i+1)*self.N] = 1
+        h = np.ones((m,))
+        self.lhs = G
+        self.rhs = h

eqc_models-0.9.8.data/platlib/eqc_models/assignment/setpartition.py

@@ -0,0 +1,170 @@
+from typing import List, Tuple, Dict, Union
+import numpy as np
+from eqc_models.base import ConstraintsMixIn, PolynomialModel
+
+class SetPartitionModel(ConstraintsMixIn, PolynomialModel):
+    """
+    This class represents a set partitioning model for optimization problems that require selecting subsets
+    to partition a universal set while minimizing an objective function defined by weights. Given a collection
+    of subsets, a weight is assigned to each subset, and the goal is to determine an optimal selection of subsets
+    to fully cover the universal set with minimized total weight.
+
+    Parameters
+    ----------
+
+    subsets : List of sets
+        List of sets (subsets) defining the collection to partition.
+        Each element in this list represents a subset containing elements from the universal set.
+
+    weights : List of floats
+        List of weights corresponding to each subset. The length of this list should be equal to
+        the number of subsets, with each weight indicating the cost or weight associated with selecting
+        a particular subset.
+
+    Attributes
+    ----------
+
+    H : tuple of np.ndarray
+        Tuple containing the linear (h) and quadratic (J) coefficients for the Hamiltonian representation
+        of the quadratic problem formulation.
+
+    penalty_multiplier : float
+        Value for weighting the penalties formed from the equality constraints.
+
+    polynomial : Polynomial
+        Polynomial operator representation for the model, constructed from the penalty terms
+        to encode the set partition constraints.
+
+    linear_objective : np.ndarray
+        Array representing the linear objective function coefficients based on the weights of subsets.
+
+    quad_objective : np.ndarray
+        Quadratic objective function matrix initialized as zeros (no quadratic terms for objective).
+
+    constraints : tuple of np.ndarray
+        Matrix `A` and vector `b` representing constraints for the set partition problem:
+        - `A`: Binary matrix indicating subset membership of elements in the universal set.
+        - `b`: Vector of ones, enforcing full coverage of the universal set by the selected subsets.
+
+    universal_set : set
+        Set containing all unique elements present across the input subsets, representing the elements
+        that must be fully covered in the partition solution.
+
+    Example
+    --------
+
+    Given a list of subsets representing a set partition problem, each with an associated weight:
+
+    >>> import numpy as np
+    >>> np.random.seed(21)
+    >>> subsets = [{"A", "B", "C"}, {"D", "E", "F"}, {"A", "F"}, {"B", "E"}, {"C", "D"}, {"A"},
+                   {"B"}, {"C", "D", "E"}, {"B", "C"}]
+    >>> weights = [100 * np.random.random() for _ in subsets]
+
+    We can construct and use the `SetPartitionModel` as follows:
+
+    >>> model = SetPartitionModel(subsets=subsets, weights=weights)
+    >>> solution = np.random.randint(0, 2, len(subsets))  # Random binary solution vector
+    >>> print("Objective Value:", model.evaluateObjective(solution))  # Evaluate solution cost
+
+    This approach builds the constraints matrix and penalties automatically, enabling efficient
+    optimization using solvers like `Dirac3CloudSolver`.
+    """
+    def __init__(self, subsets: List[set], weights: List[float]) -> None:
+        # Combine subsets to form the universal set
+        self.universal_set = set()
+        for subset in subsets:
+            self.universal_set = self.universal_set.union(subset)
+
+        # Create the constraint matrix A and vector b
+        A = []
+        for x in self.universal_set:
+            row = [1 if x in subset else 0 for subset in subsets]
+            A.append(row)
+        A = np.array(A)
+        b = np.ones((A.shape[0],))
+
+        # Define penalty terms
+        J = A.T @ A
+        h = -2 * b.T @ A
+        n = h.shape[0]
+        h = h.reshape((n, 1))
+        offset = b.T @ b
+
+        # Assign the constraints to the mixin's properties
+        self.constraints = (A, b)
+
+        # Initialize PolynomialModel with J and h, properly formatted as indices and coefficients
+        indices, coefficients = self._construct_polynomial_terms(h, J)
+        super().__init__(coefficients, indices)
+
+        # Define the linear objective function based on subset weights
+        self.linear_objective = np.array(weights).reshape((n, 1))
+        self.quad_objective = np.zeros_like(J)
+
+    def _construct_polynomial_terms(self, h: np.ndarray, J: np.ndarray) -> Tuple[List[List[int]], List[np.ndarray]]:
+        """
+        Constructs the polynomial terms (indices and coefficients) needed for the quadratic
+        Hamiltonian representation of the problem.
+
+        Parameters
+        ----------
+        h : np.ndarray
+            Linear term of the penalty function as a 1D array.
+
+        J : np.ndarray
+            Quadratic term of the penalty function as a 2D array.
+
+        Returns
+        -------
+        Tuple[List[List[int]], List[float]]
+            A tuple where:
+            - The first element is a list of index lists, representing terms in polynomial format.
+            - The second element is a list of float coefficients corresponding to each term.
+        """
+        indices = []
+        coefficients = []
+
+        # Linear terms
+        for i in range(h.shape[0]):
+            if h[i, 0] != 0:
+                indices.append([0, i + 1])  # 1-based index
+                coefficients.append(h[i, 0])
+
+        # Quadratic terms
+        for i in range(J.shape[0]):
+            for j in range(i, J.shape[1]):
+                if J[i, j] != 0:
+                    indices.append([i + 1, j + 1])  # 1-based indices
+                    coefficients.append(J[i, j])
+
+        return indices, coefficients
+
+    @property
+    def H(self) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Hamiltonian representation as a polynomial, returning the coefficients and indices.
+
+        Returns
+        -------
+        Tuple[np.ndarray, np.ndarray]
+            Tuple where the first element is an array of coefficients, and the second element
+            is an array of indices, each representing polynomial terms for the Hamiltonian.
+        """
+        return self.coefficients, self.indices
+
+    def evaluateObjective(self, solution: np.ndarray) -> float:
+        """
+        Evaluate the objective function by calculating the weighted sum of selected subsets.
+
+        Parameters
+        ----------
+        solution : np.ndarray
+            Binary array where each element indicates if a subset is selected (1) or not (0).
+
+        Returns
+        -------
+        float
+            The value of the objective function, representing the total weight of selected subsets.
+        """
+        return float(np.squeeze(solution).T @ np.squeeze(self.linear_objective))

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

@@ -0,0 +1,72 @@
+# (C) Quantum Computing Inc., 2024.
+"""
+This subpackage contains the building blocks for formulating and solving models
+with EQC devices. Many well known models in the space of quantum computing use
+quadratic operators. Two generally accepted formats for quadratic models are
+Ising Hamiltonian and QUBO operators. Ising models are not explicitly supported
+because of the simple equivalence to QUBO models. Converters from Ising to QUBO
+are readily available and may be added as a utility function in the future, but
+for now are left out of the package. Other quadratic models, such as integer
+or floating point models are supported using the domain and upper bound of the
+model variables and the solver choice. 
+
+Polynomial models are used to support higher order interactions between 
+variables. These models are defined over non-negative variables with the 
+highest power interaction being the only restriction on variable interactions.
+This is also known as all-to-all connectivity.
+
+Subpackages
+-----------
+
+constraints 
+    This module defines support for linear equality and inequality constraints.
+    It can be paired with the penalty multiplier algorithm to choose multiplier
+    values which satisfy the enforcement of constraints as penalties. The mixin
+    pattern is used to allow more complex classes to be built from these bases.
+
+    - ConstraintMixIn
+    - ConstraintModel
+    - InequalitiesMixIn
+    - InequalityConstraintModel
+
+quadratic
+    This module defines the methods required to convert a linear vector and 
+    quadratic matrix into the required operator, either QUBO or Polynomial, for
+    solving with EQC. The support for constraints is also incorporated.
+
+    - ConstrainedQuadraticModel
+    - QuadraticModel
+
+polynomial
+    This module defines the classes and methods for conversion from arrays of
+    coefficients and indices to operators for solving with EQC. The support for
+    constriants is also incorporated.
+
+    - PolynomialModel
+    - ConstrainedPolynomialModel
+
+base
+    This module defines abstract base classes for models and solvers.
+
+    - EqcModel
+    - ModelSolver
+
+operators
+    This module defines the operator types to use for passing problems to EQC
+    devices.
+
+    - Polynomial
+    - QUBO
+
+"""
+from .constraints import (ConstraintModel, ConstraintsMixIn, InequalitiesMixin, 
+                          InequalityConstraintModel)
+from .quadratic import (ConstrainedQuadraticModel, QuadraticModel)
+from .polynomial import (PolynomialModel, ConstrainedPolynomialModel)
+from .base import (ModelSolver, EqcModel)
+from .operators import (QUBO, Polynomial)
+
+__all__ = ["ConstraintsMixIn", "ConstraintModel", "ConstrainedQuadraticModel", 
+           "QuadraticModel", "PolynomialModel", "ConstrainedPolynomialModel",
+           "InequalitiesMixin", "InequalityConstraintModel",
+           "EqcModel", "ModelSolver", "QUBO", "Polynomial"]