pyotc 0.2.2__py3-none-any.whl

pyotc/__init__.py

@@ -0,0 +1,5 @@
+"""Top-level package for pyotc."""
+
+__author__ = """Jay Hineman"""
+__email__ = "jay.hineman@gmail.com"
+__version__ = "0.1.0"

pyotc/examples/edge_awareness.py

@@ -0,0 +1,86 @@
+"""
+networkx graphs for edge awareness example and corresponding costs from Table 1
+
+[Alignment and Comparison of Directed Networks via Transition Couplings of Random Walks](https://arxiv.org/abs/2106.07106)
+
+Figure 4 graphs
+
+* G_1 is the regular octogon
+* G_2 is the regular octogon removing 1 edge
+* G_3 is uniform edge lengths of the octogon removing 1 edge
+"""
+
+import numpy as np
+import networkx as nx
+
+# Define graphs G1, G2, G3
+edge_awareness_1 = {
+    "nodes": [{"id": i} for i in range(1, 9)],
+    "edges": [
+        {"source": 1, "target": 2},
+        {"source": 2, "target": 3},
+        {"source": 3, "target": 4},
+        {"source": 4, "target": 5},
+        {"source": 5, "target": 6},
+        {"source": 6, "target": 7},
+        {"source": 7, "target": 8},
+        {"source": 8, "target": 1},
+    ],
+    "name": "edge awareness graph 1",
+}
+
+edge_awareness_2_3 = {
+    "nodes": [{"id": i} for i in range(1, 9)],
+    "edges": [
+        {"source": 1, "target": 2},
+        {"source": 2, "target": 3},
+        {"source": 3, "target": 4},
+        {"source": 4, "target": 5},
+        {"source": 5, "target": 6},
+        {"source": 6, "target": 7},
+        {"source": 7, "target": 8},
+    ],
+    "name": "edge awareness graph 2, 3",
+}
+
+graph_1 = nx.node_link_graph(data=edge_awareness_1, edges="edges")
+graph_2 = nx.node_link_graph(data=edge_awareness_2_3, edges="edges")
+graph_3 = nx.node_link_graph(data=edge_awareness_2_3, edges="edges")
+
+# Define the coordinates of G_1, G_2, G_3
+# All vertices are located on the unit circle in R^2
+# d1: coordinate of G_1 vertices (regular octagon)
+# d2: coordinate of G_2 vertices (regular octagon)
+# d3: coordinate of G_3 vertices (the vertices are uniformly distributed in the left semicircle)
+
+d1 = np.zeros((8, 2))
+for i in range(8):
+    d1[i, 0] = np.cos(np.pi / 8 + np.pi / 4 * i)
+    d1[i, 1] = np.sin(np.pi / 8 + np.pi / 4 * i)
+
+d2 = d1.copy()
+
+d3 = np.zeros((8, 2))
+for i in range(8):
+    d3[i, 0] = np.cos(np.pi / 2 + np.pi / 7 * i)
+    d3[i, 1] = np.sin(np.pi / 2 + np.pi / 7 * i)
+
+# Get cost matrices
+# Define a cost function equal to the squared Euclidean distance between vertex positions
+# c21: cost function between G_2 and G_1
+# c23: cost function between G_2 and G_3
+
+
+def euclidean_cost(v1, v2):
+    n1 = v1.shape[0]
+    n2 = v2.shape[0]
+    c = np.zeros((n1, n2))
+    for i in range(n1):
+        for j in range(n2):
+            c[i, j] = np.sum((v1[i, :] - v2[j, :]) ** 2)
+
+    return c
+
+
+c21 = euclidean_cost(d2, d1)
+c23 = euclidean_cost(d2, d3)

pyotc/examples/lollipops.py

@@ -0,0 +1,54 @@
+"""
+networkx graphs for lollipop examples given in
+
+[Alignment and Comparison of Directed Networks via Transition Couplings of Random Walks](https://arxiv.org/abs/2106.07106)
+
+Figure 5 graphs
+
+* lollipop_1 is the left graph
+* lollipop_2 is the right graph
+"""
+
+import networkx as nx
+
+# Define graphs
+left_lollipop_graph = {
+    "nodes": [{"id": i} for i in range(1, 13)],
+    "edges": [
+        {"source": 1, "target": 2},
+        {"source": 2, "target": 3},
+        {"source": 3, "target": 4},
+        {"source": 4, "target": 5},
+        {"source": 5, "target": 6},
+        {"source": 6, "target": 7},
+        {"source": 7, "target": 8},
+        {"source": 8, "target": 9},
+        {"source": 9, "target": 10},
+        {"source": 10, "target": 11},
+        {"source": 11, "target": 12},
+        {"source": 12, "target": 4},
+    ],
+    "name": "left lollipop graph",
+}
+
+right_lollipop_graph = {
+    "nodes": [{"id": i} for i in range(1, 13)],
+    "edges": [
+        {"source": 7, "target": 9},
+        {"source": 9, "target": 4},
+        {"source": 4, "target": 6},
+        {"source": 6, "target": 1},
+        {"source": 1, "target": 2},
+        {"source": 2, "target": 11},
+        {"source": 11, "target": 8},
+        {"source": 8, "target": 10},
+        {"source": 10, "target": 5},
+        {"source": 5, "target": 3},
+        {"source": 3, "target": 12},
+        {"source": 12, "target": 6},
+    ],
+    "name": "right lollipop graph",
+}
+
+lollipop_1 = nx.node_link_graph(data=left_lollipop_graph, edges="edges")
+lollipop_2 = nx.node_link_graph(data=right_lollipop_graph, edges="edges")

pyotc/examples/stochastic_block_model.py

@@ -0,0 +1,57 @@
+import numpy as np
+
+
+def stochastic_block_model(sizes: tuple, probs: np.ndarray) -> np.ndarray:
+    """Generate the adjacency for a stochastic block model SBM from a tuple (length n)
+    of sizes an (nxn) matrix of probabilities.
+
+    Args:
+        sizes (tuple): tuple of node sizes with length of number of blocks
+        probs (np.ndarray): nxn symmetric matrix
+
+    Raises:
+        ValueError: If probs is not a square numpy array
+        ValueError: If probs is not symmetric
+        ValueError: If sizes and probs dimensions do not match
+
+    Returns:
+        np.ndarray: adjancency matrix for SBM
+    """
+    # Check input type
+    if not isinstance(probs, np.ndarray) or probs.shape[0] != probs.shape[1]:
+        raise ValueError("'probs' must be a square numpy array.")
+    elif not np.allclose(probs, probs.T):
+        raise ValueError("'probs' must be a symmetric matrix.")
+    elif len(sizes) != probs.shape[0]:
+        raise ValueError("'sizes' and 'probs' dimensions do not match.")
+
+    n = sum(sizes)  # Total number of nodes
+    n_b = len(sizes)  # Total number of blocks
+    A = np.zeros((n, n))
+
+    # Column index of each block's start
+    cumsum = 0
+    start = [0]
+    for size in sizes:
+        cumsum += size
+        start.append(cumsum)
+
+    # Generating Adjacency Matrix (upper)
+    # Generate diagonal blocks
+    for i in range(n_b):
+        p = probs[i, i]
+        for j in range(start[i], start[i + 1]):
+            for k in range(j + 1, start[i + 1]):
+                A[j, k] = np.random.choice([0, 1], p=[1 - p, p])
+
+    # Generate Nondiagonal blocks
+    for i in range(n_b - 1):
+        for j in range(i + 1, n_b):
+            A[start[i] : start[i + 1], start[j] : start[j + 1]] = np.random.choice(
+                [0, 1], size=(sizes[i], sizes[j]), p=[1 - probs[i, j], probs[i, j]]
+            )
+
+    # Fill lower triangular matrix
+    A = A + A.T
+
+    return A

pyotc/examples/wheel.py

@@ -0,0 +1,127 @@
+"""
+networkx graphs for wheel graph examples given in Version 1 of
+
+[Alignment and Comparison of Directed Networks via Transition Couplings of Random Walks](https://arxiv.org/pdf/2106.07106v1.pdf)
+
+Figure 2 graphs
+
+* G_1 is a wheel graph of order 16
+* G_2 is a wheel graph removing 1 spoke edge
+* G_3 is a wheel graph removing 1 wheel edge
+"""
+
+import networkx as nx
+
+# Define graphs G1, G2, G3
+wheel_graph_1 = {
+    "nodes": [{"id": i} for i in range(1, 17)],
+    "edges": [
+        {"source": 1, "target": 2},
+        {"source": 1, "target": 3},
+        {"source": 1, "target": 4},
+        {"source": 1, "target": 5},
+        {"source": 1, "target": 6},
+        {"source": 1, "target": 7},
+        {"source": 1, "target": 8},
+        {"source": 1, "target": 9},
+        {"source": 1, "target": 10},
+        {"source": 1, "target": 11},
+        {"source": 1, "target": 12},
+        {"source": 1, "target": 13},
+        {"source": 1, "target": 14},
+        {"source": 1, "target": 15},
+        {"source": 1, "target": 16},
+        {"source": 2, "target": 3},
+        {"source": 3, "target": 4},
+        {"source": 4, "target": 5},
+        {"source": 5, "target": 6},
+        {"source": 6, "target": 7},
+        {"source": 7, "target": 8},
+        {"source": 8, "target": 9},
+        {"source": 9, "target": 10},
+        {"source": 10, "target": 11},
+        {"source": 11, "target": 12},
+        {"source": 12, "target": 13},
+        {"source": 13, "target": 14},
+        {"source": 14, "target": 15},
+        {"source": 15, "target": 16},
+        {"source": 16, "target": 2},
+    ],
+    "name": "wheel graph 1",
+}
+
+wheel_graph_2 = {
+    "nodes": [{"id": i} for i in range(1, 17)],
+    "edges": [
+        {"source": 1, "target": 3},
+        {"source": 1, "target": 4},
+        {"source": 1, "target": 5},
+        {"source": 1, "target": 6},
+        {"source": 1, "target": 7},
+        {"source": 1, "target": 8},
+        {"source": 1, "target": 9},
+        {"source": 1, "target": 10},
+        {"source": 1, "target": 11},
+        {"source": 1, "target": 12},
+        {"source": 1, "target": 13},
+        {"source": 1, "target": 14},
+        {"source": 1, "target": 15},
+        {"source": 1, "target": 16},
+        {"source": 2, "target": 3},
+        {"source": 3, "target": 4},
+        {"source": 4, "target": 5},
+        {"source": 5, "target": 6},
+        {"source": 6, "target": 7},
+        {"source": 7, "target": 8},
+        {"source": 8, "target": 9},
+        {"source": 9, "target": 10},
+        {"source": 10, "target": 11},
+        {"source": 11, "target": 12},
+        {"source": 12, "target": 13},
+        {"source": 13, "target": 14},
+        {"source": 14, "target": 15},
+        {"source": 15, "target": 16},
+        {"source": 16, "target": 2},
+    ],
+    "name": "wheel graph 2",
+}
+
+wheel_graph_3 = {
+    "nodes": [{"id": i} for i in range(1, 17)],
+    "edges": [
+        {"source": 1, "target": 2},
+        {"source": 1, "target": 3},
+        {"source": 1, "target": 4},
+        {"source": 1, "target": 5},
+        {"source": 1, "target": 6},
+        {"source": 1, "target": 7},
+        {"source": 1, "target": 8},
+        {"source": 1, "target": 9},
+        {"source": 1, "target": 10},
+        {"source": 1, "target": 11},
+        {"source": 1, "target": 12},
+        {"source": 1, "target": 13},
+        {"source": 1, "target": 14},
+        {"source": 1, "target": 15},
+        {"source": 1, "target": 16},
+        {"source": 2, "target": 3},
+        {"source": 3, "target": 4},
+        {"source": 4, "target": 5},
+        {"source": 5, "target": 6},
+        {"source": 6, "target": 7},
+        {"source": 7, "target": 8},
+        {"source": 8, "target": 9},
+        {"source": 9, "target": 10},
+        {"source": 10, "target": 11},
+        {"source": 11, "target": 12},
+        {"source": 12, "target": 13},
+        {"source": 13, "target": 14},
+        {"source": 14, "target": 15},
+        {"source": 15, "target": 16},
+    ],
+    "name": "wheel graph 3",
+}
+
+wheel_1 = nx.node_link_graph(data=wheel_graph_1, edges="edges")
+wheel_2 = nx.node_link_graph(data=wheel_graph_2, edges="edges")
+wheel_3 = nx.node_link_graph(data=wheel_graph_3, edges="edges")

pyotc/otc.py

@@ -0,0 +1,5 @@
+"""Main entry point for otc funcitonality"""
+
+
+def exact_OTC():
+    raise NotImplementedError

pyotc/otc_backend/graph/__init__.py

@@ -0,0 +1,3 @@
+"""
+Routines producing stationary processes on graphs
+"""

pyotc/otc_backend/graph/utils.py

@@ -0,0 +1,109 @@
+import numpy as np
+
+
+def weight(x):
+    """
+    Normalizes a vector into a probability distribution.
+
+    Args:
+        x (np.ndarray): Input vector.
+
+    Returns:
+        np.ndarray: Normalized vector such that the sum is 1.
+    """
+    return x / np.sum(x)
+
+
+def adj_to_trans(A):
+    """
+    Converts an adjacency matrix into a row-stochastic transition matrix.
+
+    Args:
+        A (np.ndarray): Adjacency matrix of shape (n, n).
+
+    Returns:
+        np.ndarray: Transition matrix of shape (n, n), where each row sums to 1.
+    """
+    nrow = A.shape[0]
+    T = np.copy(A).astype(float)
+    for i in range(nrow):
+        row = A[i, :]
+        k = np.where(row != 0)[0]
+        vals = weight(row[k])
+        for idx in range(len(k)):
+            T[i, k[idx]] = vals[idx]
+    row_sums = T.sum(axis=1)
+    return T / row_sums[:, np.newaxis]
+
+
+def get_degree_cost(A1, A2):
+    """
+    Computes a cost matrix based on squared degree differences between nodes.
+
+    Args:
+        A1 (np.ndarray): First adjacency matrix of shape (n1, n1).
+        A2 (np.ndarray): Second adjacency matrix of shape (n2, n2).
+
+    Returns:
+        cost_mat (np.ndarray): Cost matrix of shape (n1, n2) with squared degree differences.
+    """
+    n1 = A1.shape[0]
+    n2 = A2.shape[0]
+    degrees1 = np.sum(A1, axis=1)
+    degrees2 = np.sum(A2, axis=1)
+    cost_mat = np.zeros((n1, n2))
+    for i in range(n1):
+        for j in range(n2):
+            cost_mat[i, j] = (degrees1[i] - degrees2[j]) ** 2
+    return cost_mat
+
+
+def get_01_cost(V1, V2):
+    """
+    Computes a binary cost matrix between node features of two graphs based on inequality.
+
+    Given two vectors representing features of nodes from two graphs, this function
+    returns a binary cost matrix where each entry is 1 if the corresponding features differ,
+    and 0 otherwise.
+
+    Args:
+        V1 (np.ndarray): Feature vector for nodes in graph 1, of shape (n1,).
+        V2 (np.ndarray): Feature vector for nodes in graph 2, of shape (n2,).
+
+    Returns:
+        np.ndarray: Binary cost matrix of shape (n1, n2), where entry (i, j) is 1
+                    if V1[i] != V2[j], else 0.
+    """
+
+    n1 = len(V1)
+    n2 = len(V2)
+    cost_mat = np.zeros((n1, n2))
+    for i in range(n1):
+        for j in range(n2):
+            cost_mat[i, j] = V1[i] != V2[j]
+    return cost_mat
+
+
+def get_sq_cost(V1, V2):
+    """
+    Computes a cost matrix based on squared differences between node features of two graphs.
+
+    Given two vectors representing node features from two graphs, this function computes
+    a cost matrix where each entry (i, j) is the squared difference between the i-th feature
+    in graph 1 and the j-th feature in graph 2.
+
+    Args:
+        V1 (np.ndarray): Feature vector for nodes in graph 1, of shape (n1,).
+        V2 (np.ndarray): Feature vector for nodes in graph 2, of shape (n2,).
+
+    Returns:
+        np.ndarray: Cost matrix of shape (n1, n2), where entry (i, j) = (V1[i] - V2[j]) ** 2.
+    """
+
+    n1 = len(V1)
+    n2 = len(V2)
+    cost_mat = np.zeros((n1, n2))
+    for i in range(n1):
+        for j in range(n2):
+            cost_mat[i, j] = (V1[i] - V2[j]) ** 2
+    return cost_mat

pyotc/otc_backend/optimal_transport/logsinkhorn.py

@@ -0,0 +1,78 @@
+import numpy as np
+
+
+def round_transpoly(X, r, c):
+    A = X.copy()
+    # A = copy.deepcopy(X)
+    n1, n2 = A.shape
+
+    r_A = np.sum(A, axis=1)
+    for i in range(n1):
+        scaling = min(1, r[i] / r_A[i])
+        A[i, :] *= scaling
+
+    c_A = np.sum(A, axis=0)
+    for j in range(n2):
+        scaling = min(1, c[j] / c_A[j])
+        A[:, j] *= scaling
+
+    r_A = np.sum(A, axis=1)
+    c_A = np.sum(A, axis=0)
+    err_r = r_A - r
+    err_c = c_A - c
+
+    if not np.all(err_r == 0) and not np.all(err_c == 0):
+        A += np.outer(err_r, err_c) / np.sum(np.abs(err_r))
+
+    return A
+
+
+def logsumexp(X, axis=None):
+    """
+    Numerically stable log-sum-exp operation.
+
+    Args:
+        X (np.ndarray): Input array.
+        axis (int or tuple of ints, optional): Axis or axes over which to operate.
+
+    Returns:
+        np.ndarray: The result of log(sum(exp(X))) along the specified axis.
+    """
+
+    y = np.max(
+        X, axis=axis, keepdims=True
+    )  # use 'keepdims' to make matrix operation X-y work
+    s = y + np.log(np.sum(np.exp(X - y), axis=axis, keepdims=True))
+
+    return np.squeeze(s, axis=axis)
+
+
+def logsinkhorn(A, r, c, T):
+    """
+    Implementation of classical Sinkhorn algorithm for matrix scaling.
+    Each iteration simply alternately updates (projects) all rows or
+    all columns to have correct marginals.
+
+    Args:
+        A (np.ndarray): Negative scaled cost matrix of shape (dx, dy), e.g., -xi * cost.
+        r (np.ndarray): desired row sums (marginals) (shape: dx,). Should sum to 1.
+        c (np.ndarray): desired column sums (marginals) (shape: dy,). Should sum to 1.
+        T (int): Number of full Sinkhorn iterations.
+
+    Returns:
+        np.ndarray: Final scaled matrix of shape (dx, dy).
+    """
+
+    dx, dy = A.shape
+    f = np.zeros(dx)
+    g = np.zeros(dy)
+
+    for t in range(T):
+        if t % 2 == 0:
+            f = np.log(r) - logsumexp(A + g, axis=1)
+        else:
+            g = np.log(c) - logsumexp(A + f[:, np.newaxis], axis=0)
+
+    P = round_transpoly(np.exp(f[:, np.newaxis] + A + g), r, c)
+
+    return P

pyotc/otc_backend/optimal_transport/native.py

@@ -0,0 +1,49 @@
+"""
+Native linear programming implementation for solving optimal transport (OT) problems.
+"""
+
+import numpy as np
+from scipy.optimize import linprog
+
+
+def computeot_lp(C, r, c):
+    """
+    Solves the optimal transport problem using linear programming (LP) with SciPy.
+
+    Given a cost matrix `C` and distributions `r` and `c`, this function computes the
+    optimal transport plan that minimizes the total transport cost.
+
+    Args:
+        C (np.ndarray): Cost matrix of shape (nx, ny), where C[i, j] represents the cost of transporting
+                        mass from source i to target j.
+        r (np.ndarray): Source distribution (shape: nx,). Should sum to 1.
+        c (np.ndarray): Target distribution (shape: ny,). Should sum to 1.
+
+    Returns:
+        Tuple[np.ndarray, float]:
+            - lp_sol (np.ndarray): Optimal transport plan of shape (nx, ny).
+            - lp_val (float): Total transport cost under the optimal plan.
+    """
+    nx = r.size
+    ny = c.size
+
+    # setup LP
+    Aeq = np.zeros((nx + ny, nx * ny))
+    beq = np.concatenate((r.flatten(), c.flatten()))
+    beq = beq.reshape(-1, 1)
+    for row in range(nx):
+        for t in range(ny):
+            Aeq[row, (row * ny) + t] = 1
+    for row in range(nx, nx + ny):
+        for t in range(nx):
+            Aeq[row, t * ny + (row - nx)] = 1
+    cost = C.reshape(-1, 1)
+
+    # Bound
+    bound = [[0, None]] * (nx * ny)
+
+    # Solve OT LP using linprog
+    res = linprog(cost, A_eq=Aeq, b_eq=beq, bounds=bound, method="highs")
+    lp_sol = res.x
+    lp_val = res.fun
+    return lp_sol, lp_val

pyotc/otc_backend/optimal_transport/native_refactor.py

@@ -0,0 +1,51 @@
+"""Yuning's other other native implementation of lp ot"""
+
+import numpy as np
+from scipy.optimize import linprog
+from typing import Any
+
+
+def setup_rows(Aeq: np.ndarray, nx: int, ny: int) -> None:
+    for row in range(nx):
+        for t in range(ny):
+            Aeq[row, (row * ny) + t] = 1
+    return None
+
+
+def setup_columns(Aeq: np.ndarray, nx: int, ny: int) -> None:
+    for row in range(nx):
+        for t in range(ny):
+            Aeq[row, (row * ny) + t] = 1
+    return None
+
+
+def computeot_lp(C: np.ndarray, r: np.ndarray, c: np.ndarray) -> tuple[Any, Any]:
+    """Compute optimal transport mapping via LP.
+
+    Args:
+        C (np.ndarray): cost
+        r (np.ndarray): _description_
+        c (np.ndarray): _description_
+
+    Returns:
+        tuple[Any, Any]: _description_
+    """
+    nx = r.size
+    ny = c.size
+
+    # setup LP
+    Aeq = np.zeros((nx + ny, nx * ny))
+    beq = np.concatenate((r.flatten(), c.flatten()))
+    beq = beq.reshape(-1, 1)
+    setup_rows(Aeq, nx, ny)
+    setup_columns(Aeq, nx, ny)
+    cost = C.reshape(-1, 1)
+
+    # Bound
+    bound = [[0, None]] * (nx * ny)
+
+    # Solve OT LP using linprog
+    res = linprog(cost, A_eq=Aeq, b_eq=beq, bounds=bound, method="highs")
+    lp_sol = res.x
+    lp_val = res.fun
+    return lp_sol, lp_val

pyotc/otc_backend/optimal_transport/pot.py

@@ -0,0 +1,38 @@
+"""
+A wrapper for the Python Optimal Transport (POT) library.
+
+This module provides a simplified interface for computing optimal transport plans
+and their associated costs using the POT library.
+"""
+
+import numpy as np
+import ot
+
+
+def computeot_pot(C, r, c):
+    """
+    Computes the optimal transport plan and its total cost using the POT library.
+
+    Given a cost matrix `C` and distributions `r` and `c`, this function computes the
+    optimal transport plan that minimizes the total transport cost.
+
+    Args:
+        C (np.ndarray): Cost matrix of shape (n, m), where C[i, j] represents the cost of transporting
+                        mass from source i to target j.
+        r (np.ndarray): Source distribution (shape: n,). Should sum to 1.
+        c (np.ndarray): Target distribution (shape: m,). Should sum to 1.
+
+    Returns:
+        Tuple[np.ndarray, float]:
+            - lp_sol (np.ndarray): Optimal transport plan of shape (n, m).
+            - lp_val (float): Total transport cost under the optimal plan.
+    """
+    # Ensure r and c are numpy arrays
+    r = np.array(r).flatten()
+    c = np.array(c).flatten()
+
+    # Compute the optimal transport plan and the cost using the ot.emd function
+    lp_sol = ot.emd(r, c, C)
+    lp_val = np.sum(lp_sol * C)
+
+    return lp_sol, lp_val