nystrom-ncut 0.0.5__tar.gz → 0.0.7__tar.gz

{nystrom_ncut-0.0.5/src/nystrom_ncut.egg-info → nystrom_ncut-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: nystrom_ncut
-Version: 0.0.5
+Version: 0.0.7
 Summary: Normalized Cut and Nyström Approximation
 Author-email: Huzheng Yang <huze.yann@gmail.com>, Wentinn Liao <wentinn.liao@gmail.com>
 Project-URL: Documentation, https://github.com/JophiArcana/Nystrom-NCUT/

{nystrom_ncut-0.0.5 → nystrom_ncut-0.0.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nystrom_ncut"
-version = "0.0.5"
+version = "0.0.7"
 authors = [
     { name = "Huzheng Yang", email = "huze.yann@gmail.com" },
     { name = "Wentinn Liao", email = "wentinn.liao@gmail.com" },

{nystrom_ncut-0.0.5 → nystrom_ncut-0.0.7}/src/nystrom_ncut/__init__.py

@@ -4,8 +4,8 @@ from .ncut_pytorch import (
 )
 from .propagation_utils import (
     affinity_from_features,
-    propagate_eigenvectors,
-    propagate_knn,
+    extrapolate_knn_with_subsampling,
+    extrapolate_knn,
     quantile_normalize,
 )
 from .visualize_utils import (
@@ -17,6 +17,5 @@ from .visualize_utils import (
     rgb_from_cosine_tsne_3d,
     rotate_rgb_cube,
     convert_to_lab_color,
-    propagate_rgb_color,
     get_mask,
 )

{nystrom_ncut-0.0.5 → nystrom_ncut-0.0.7}/src/nystrom_ncut/common.py

@@ -1,10 +1,14 @@
-from typing import Any
+from typing import Any, Literal
 
 import numpy as np
 import torch
 import torch.nn.functional as Fn
 
 
+DistanceOptions = Literal["cosine", "euclidean", "rbf"]
+SampleOptions = Literal["farthest", "random"]
+
+
 def ceildiv(a: int, b: int) -> int:
     return -(-a // b)
 

{nystrom_ncut-0.0.5 → nystrom_ncut-0.0.7}/src/nystrom_ncut/ncut_pytorch.py

@@ -4,6 +4,10 @@ from typing import Literal, Tuple
 import torch
 import torch.nn.functional as Fn
 
+from .common import (
+    DistanceOptions,
+    SampleOptions,
+)
 from .nystrom import (
     EigSolverOptions,
     OnlineKernel,
@@ -16,9 +20,6 @@ from .propagation_utils import (
 )
 
 
-DistanceOptions = Literal["cosine", "euclidean", "rbf"]
-
-
 class LaplacianKernel(OnlineKernel):
     def __init__(
         self,
@@ -46,9 +47,10 @@ class LaplacianKernel(OnlineKernel):
             affinity_focal_gamma=self.affinity_focal_gamma,
             distance=self.distance,
         )                                                       # [n x n]
+        d = features.shape[-1]
         U, L = solve_eig(
             self.A,
-            num_eig=features.shape[-1] + 1,
+            num_eig=d + 1,  # d * (d + 3) // 2 + 1,
             eig_solver=self.eig_solver,
         )                                                       # [n x (d + 1)], [d + 1]
         self.Ainv = U @ torch.diag(1 / L) @ U.mT                # [n x n]
@@ -97,11 +99,10 @@ class NCUT(OnlineNystrom):
         n_components: int = 100,
         affinity_focal_gamma: float = 1.0,
         num_sample: int = 10000,
-        sample_method: Literal["farthest", "random"] = "farthest",
+        sample_method: SampleOptions = "farthest",
         distance: DistanceOptions = "cosine",
         eig_solver: EigSolverOptions = "svd_lowrank",
         normalize_features: bool = None,
-        move_output_to_cpu: bool = False,
         chunk_size: int = 8192,
     ):
         """
@@ -117,7 +118,6 @@ class NCUT(OnlineNystrom):
             eig_solver (str): eigen decompose solver, ['svd_lowrank', 'lobpcg', 'svd', 'eigh'].
             normalize_features (bool): normalize input features before computing affinity matrix,
                 default 'None' is True for cosine distance, False for euclidean distance and rbf
-            move_output_to_cpu (bool): move output to CPU, set to True if you have memory issue
             chunk_size (int): chunk size for large-scale matrix multiplication
         """
         OnlineNystrom.__init__(
@@ -127,18 +127,18 @@ class NCUT(OnlineNystrom):
             eig_solver=eig_solver,
             chunk_size=chunk_size,
         )
-        self.num_sample = num_sample
-        self.sample_method = sample_method
-        self.distance = distance
-        self.normalize_features = normalize_features
+        self.num_sample: int = num_sample
+        self.sample_method: SampleOptions = sample_method
+        self.anchor_indices: torch.Tensor = None
+        self.distance: DistanceOptions = distance
+        self.normalize_features: bool = normalize_features
         if self.normalize_features is None:
             if distance in ["cosine"]:
                 self.normalize_features = True
             if distance in ["euclidean", "rbf"]:
                 self.normalize_features = False
 
-        self.move_output_to_cpu = move_output_to_cpu
-        self.chunk_size = chunk_size
+        self.chunk_size: int = chunk_size
 
     def _fit_helper(
         self,
@@ -152,16 +152,6 @@ class NCUT(OnlineNystrom):
             )
             self.num_sample = _n
 
-        # check if features dimension greater than num_eig
-        if self.eig_solver in ["svd_lowrank", "lobpcg"]:
-            assert (
-                _n >= self.n_components * 2
-            ), "number of nodes should be greater than 2*num_eig"
-        elif self.eig_solver in ["svd", "eigh"]:
-            assert (
-                _n >= self.n_components
-            ), "number of nodes should be greater than num_eig"
-
         assert self.distance in ["cosine", "euclidean", "rbf"], "distance should be 'cosine', 'euclidean', 'rbf'"
 
         if self.normalize_features:
@@ -169,20 +159,20 @@ class NCUT(OnlineNystrom):
             features = torch.nn.functional.normalize(features, dim=-1)
 
         if precomputed_sampled_indices is not None:
-            sampled_indices = precomputed_sampled_indices
+            _sampled_indices = precomputed_sampled_indices
         else:
-            sampled_indices = run_subgraph_sampling(
+            _sampled_indices = run_subgraph_sampling(
                 features,
                 self.num_sample,
                 sample_method=self.sample_method,
             )
-        sampled_indices = torch.sort(sampled_indices).values
-        sampled_features = features[sampled_indices]
+        self.anchor_indices = torch.sort(_sampled_indices).values
+        sampled_features = features[self.anchor_indices]
         OnlineNystrom.fit(self, sampled_features)
 
         _n_not_sampled = _n - len(sampled_features)
         if _n_not_sampled > 0:
-            unsampled_indices = torch.full((_n,), True, device=features.device).scatter_(0, sampled_indices, False)
+            unsampled_indices = torch.full((_n,), True, device=features.device).scatter_(0, self.anchor_indices, False)
             unsampled_features = features[unsampled_indices]
             V_unsampled, _ = OnlineNystrom.update(self, unsampled_features)
         else:

{nystrom_ncut-0.0.5 → nystrom_ncut-0.0.7}/src/nystrom_ncut/nystrom.py

@@ -72,7 +72,7 @@ class OnlineNystrom:
         self.anchor_features = features
 
         self.kernel.fit(self.anchor_features)
-        self.inverse_approximation_dim = max(self.n_components, features.shape[-1]) + 1
+        self.inverse_approximation_dim = max(self.n_components, features.shape[-1] + 1)
         U, L = self._update_to_kernel()                                                             # [n x (? + 1)], [? + 1]
 
         self.transform_matrix = (U / L)[:, :self.n_components]                                      # [n x n_components]
@@ -135,7 +135,7 @@ class OnlineNystrom:
 def solve_eig(
     A: torch.Tensor,
     num_eig: int,
-    eig_solver: Literal["svd_lowrank", "lobpcg", "svd", "eigh"],
+    eig_solver: EigSolverOptions,
 ) -> Tuple[torch.Tensor, torch.Tensor]:
     """PyTorch implementation of Eigensolver cut without Nystrom-like approximation.
 

{nystrom_ncut-0.0.5 → nystrom_ncut-0.0.7}/src/nystrom_ncut/propagation_utils.py

@@ -3,9 +3,14 @@ from typing import Literal
 
 import numpy as np
 import torch
-import torch.nn.functional as F
+import torch.nn.functional as Fn
 
-from .common import ceildiv, lazy_normalize
+from .common import (
+    DistanceOptions,
+    SampleOptions,
+    ceildiv,
+    lazy_normalize,
+)
 
 
 @torch.no_grad()
@@ -13,7 +18,7 @@ def run_subgraph_sampling(
     features: torch.Tensor,
     num_sample: int,
     max_draw: int = 1000000,
-    sample_method: Literal["farthest", "random"] = "farthest",
+    sample_method: SampleOptions = "farthest",
 ):
     if num_sample >= features.shape[0]:
         # if too many samples, use all samples and bypass Nystrom-like approximation
@@ -74,7 +79,7 @@ def farthest_point_sampling(
 def distance_from_features(
     features: torch.Tensor,
     features_B: torch.Tensor,
-    distance: Literal["cosine", "euclidean", "rbf"],
+    distance: DistanceOptions,
 ):
     """Compute affinity matrix from input features.
     Args:
@@ -96,7 +101,6 @@ def distance_from_features(
         D = D / (2 * features.var(dim=0).sum())
     else:
         raise ValueError("distance should be 'cosine' or 'euclidean', 'rbf'")
-
     return D
 
 
@@ -104,7 +108,7 @@ def affinity_from_features(
     features: torch.Tensor,
     features_B: torch.Tensor = None,
     affinity_focal_gamma: float = 1.0,
-    distance: Literal["cosine", "euclidean", "rbf"] = "cosine",
+    distance: DistanceOptions = "cosine",
 ):
     """Compute affinity matrix from input features.
 
@@ -132,23 +136,23 @@ def affinity_from_features(
     return A
 
 
-def propagate_knn(
-    subgraph_output: torch.Tensor,
-    inp_features: torch.Tensor,
-    subgraph_features: torch.Tensor,
-    knn: int = 10,
-    distance: Literal["cosine", "euclidean", "rbf"] = "cosine",
+def extrapolate_knn(
+    anchor_features: torch.Tensor,          # [n x d]
+    anchor_output: torch.Tensor,            # [n x d']
+    extrapolation_features: torch.Tensor,   # [m x d]
+    knn: int = 10,                          # k
+    distance: DistanceOptions = "cosine",
     affinity_focal_gamma: float = 1.0,
     chunk_size: int = 8192,
     device: str = None,
-    move_output_to_cpu: bool = False,
-):
+    move_output_to_cpu: bool = False
+) -> torch.Tensor:                          # [m x d']
     """A generic function to propagate new nodes using KNN.
 
     Args:
-        subgraph_output (torch.Tensor): output from subgraph, shape (num_sample, D)
-        inp_features (torch.Tensor): features from existing nodes, shape (new_num_samples, n_features)
-        subgraph_features (torch.Tensor): features from subgraph, shape (num_sample, n_features)
+        anchor_features (torch.Tensor): features from subgraph, shape (num_sample, n_features)
+        anchor_output (torch.Tensor): output from subgraph, shape (num_sample, D)
+        extrapolation_features (torch.Tensor): features from existing nodes, shape (new_num_samples, n_features)
         knn (int): number of KNN to propagate eige nvectors
         distance (str): distance metric, 'cosine' (default) or 'euclidean', 'rbf'
         chunk_size (int): chunk size for matrix multiplication
@@ -160,97 +164,77 @@ def propagate_knn(
         >>> old_eigenvectors = torch.randn(3000, 20)
         >>> old_features = torch.randn(3000, 100)
         >>> new_features = torch.randn(200, 100)
-        >>> new_eigenvectors = propagate_knn(old_eigenvectors, new_features, old_features, knn=3)
+        >>> new_eigenvectors = extrapolate_knn(old_features,old_eigenvectors,new_features,knn=3)
         >>> # new_eigenvectors.shape = (200, 20)
 
     """
-    device = subgraph_output.device if device is None else device
-
-    if knn == 1:
-        return propagate_nearest(
-            subgraph_output,
-            inp_features,
-            subgraph_features,
-            chunk_size=chunk_size,
-            device=device,
-            move_output_to_cpu=move_output_to_cpu,
-        )
+    device = anchor_output.device if device is None else device
 
     # used in nystrom_ncut
     # propagate eigen_vector from subgraph to full graph
-    subgraph_output = subgraph_output.to(device)
+    anchor_output = anchor_output.to(device)
 
-    n_chunks = ceildiv(inp_features.shape[0], chunk_size)
+    n_chunks = ceildiv(extrapolation_features.shape[0], chunk_size)
     V_list = []
-    for _v in torch.chunk(inp_features, n_chunks, dim=0):
-        _v = _v.to(device)
-        _A = affinity_from_features(subgraph_features, _v, affinity_focal_gamma, distance).mT
-
+    for _v in torch.chunk(extrapolation_features, n_chunks, dim=0):
+        _v = _v.to(device)                                                                              # [_m x d]
+        _A = affinity_from_features(anchor_features, _v, affinity_focal_gamma, distance).mT             # [_m x n]
         if knn is not None:
-            mask = torch.full_like(_A, True, dtype=torch.bool)
-            mask[torch.arange(len(_v))[:, None], _A.topk(knn, dim=-1, largest=True).indices] = False
-            _A[mask] = 0.0
-        _A = F.normalize(_A, p=1, dim=-1)
-
-        _V = _A @ subgraph_output
-        if move_output_to_cpu:
-            _V = _V.cpu()
-        V_list.append(_V)
-
-    subgraph_output = torch.cat(V_list, dim=0)
-    return subgraph_output
-
-
-def propagate_nearest(
-    subgraph_output: torch.Tensor,
-    inp_features: torch.Tensor,
-    subgraph_features: torch.Tensor,
-    distance: Literal["cosine", "euclidean", "rbf"] = "cosine",
-    chunk_size: int = 8192,
-    device: str = None,
-    move_output_to_cpu: bool = False,
-):
-    device = subgraph_output.device if device is None else device
-    if distance == 'cosine':
-        inp_features = lazy_normalize(inp_features, dim=-1)
-        subgraph_features = lazy_normalize(subgraph_features, dim=-1)
-
-    # used in nystrom_tsne, equivalent to propagate_by_knn with knn=1
-    # propagate tSNE from subgraph to full graph
-    V_list = []
-    subgraph_features = subgraph_features.to(device)
-    for i in range(0, inp_features.shape[0], chunk_size):
-        end = min(i + chunk_size, inp_features.shape[0])
-        _v = inp_features[i:end].to(device)
-        _A = -distance_from_features(subgraph_features, _v, distance).mT
-
-        # keep top1 for each row
-        top_idx = _A.argmax(dim=-1).cpu()
-        _V = subgraph_output[top_idx]
+            _A, indices = _A.topk(k=knn, dim=-1, largest=True)                                          # [_m x k], [_m x k]
+            _anchor_output = anchor_output[indices]                                                     # [_m x k x d]
+        else:
+            _anchor_output = anchor_output[None]                                                        # [1 x n x d]
+        _A = Fn.normalize(_A, p=1, dim=-1)
+
+        # if distance == 'cosine':
+        #     _A = _v @ subgraph_features.T
+        # elif distance == 'euclidean':
+        #     _A = - torch.cdist(_v, subgraph_features, p=2)
+        # elif distance == 'rbf':
+        #     _A = - torch.cdist(_v, subgraph_features, p=2) ** 2
+        # else:
+        #     raise ValueError("distance should be 'cosine' or 'euclidean', 'rbf'")
+        #
+        # # keep topk KNN for each row
+        # topk_sim, topk_idx = _A.topk(knn, dim=-1, largest=True)
+        # row_id = torch.arange(topk_idx.shape[0], device=_A.device)[:, None].expand(
+        #     -1, topk_idx.shape[1]
+        # )
+        # _A = torch.sparse_coo_tensor(
+        #     torch.stack([row_id, topk_idx], dim=-1).reshape(-1, 2).T,
+        #     topk_sim.reshape(-1),
+        #     size=(_A.shape[0], _A.shape[1]),
+        #     device=_A.device,
+        # )
+        # _A = _A.to_dense().to(dtype=subgraph_output.dtype)
+        # _D = _A.sum(-1)
+        # _A /= _D[:, None]
+
+        _V = (_A[:, None, :] @ _anchor_output).squeeze(1)
         if move_output_to_cpu:
             _V = _V.cpu()
         V_list.append(_V)
 
-    subgraph_output = torch.cat(V_list, dim=0)
-    return subgraph_output
+    anchor_output = torch.cat(V_list, dim=0)
+    return anchor_output
 
 
 # wrapper functions for adding new nodes to existing graph
-def propagate_eigenvectors(
-    eigenvectors: torch.Tensor,
-    features: torch.Tensor,
-    new_features: torch.Tensor,
+def extrapolate_knn_with_subsampling(
+    full_features: torch.Tensor,
+    full_output: torch.Tensor,
+    extrapolation_features: torch.Tensor,
     knn: int,
     num_sample: int,
-    sample_method: Literal["farthest", "random"],
+    sample_method: SampleOptions,
     chunk_size: int,
-    device: str,
+    device: str
 ):
     """Propagate eigenvectors to new nodes using KNN. Note: this is equivalent to the class API `NCUT.tranform(new_features)`, expect for the sampling is re-done in this function.
     Args:
-        eigenvectors (torch.Tensor): eigenvectors from existing nodes, shape (num_sample, num_eig)
-        features (torch.Tensor): features from existing nodes, shape (n_samples, n_features)
-        new_features (torch.Tensor): features from new nodes, shape (n_new_samples, n_features)
+        full_output (torch.Tensor): eigenvectors from existing nodes, shape (num_sample, num_eig)
+        full_features (torch.Tensor): features from existing nodes, shape (n_samples, n_features)
+        extrapolation_features (torch.Tensor): features from new nodes, shape (n_new_samples, n_features)
         knn (int): number of KNN to propagate eigenvectors, default 3
         num_sample (int): number of samples for subgraph sampling, default 50000
         sample_method (str): sample method, 'farthest' (default) or 'random'
@@ -263,31 +247,31 @@ def propagate_eigenvectors(
         >>> old_eigenvectors = torch.randn(3000, 20)
         >>> old_features = torch.randn(3000, 100)
         >>> new_features = torch.randn(200, 100)
-        >>> new_eigenvectors = propagate_eigenvectors(old_eigenvectors, new_features, old_features, knn=3)
+        >>> new_eigenvectors = extrapolate_knn_with_subsampling(extrapolation_features,old_eigenvectors,old_features,knn=3,num_sample=,sample_method=,chunk_size=,device=)
         >>> # new_eigenvectors.shape = (200, 20)
     """
 
-    device = eigenvectors.device if device is None else device
+    device = full_output.device if device is None else device
 
     # sample subgraph
-    subgraph_indices = run_subgraph_sampling(
-        features,
+    anchor_indices = run_subgraph_sampling(
+        full_features,
         num_sample,
         sample_method=sample_method,
     )
 
-    subgraph_eigenvectors = eigenvectors[subgraph_indices].to(device)
-    subgraph_features = features[subgraph_indices].to(device)
-    new_features = new_features.to(device)
+    anchor_output = full_output[anchor_indices].to(device)
+    anchor_features = full_features[anchor_indices].to(device)
+    extrapolation_features = extrapolation_features.to(device)
 
     # propagate eigenvectors from subgraph to new nodes
-    new_eigenvectors = propagate_knn(
-        subgraph_eigenvectors,
-        new_features,
-        subgraph_features,
+    new_eigenvectors = extrapolate_knn(
+        anchor_features,
+        anchor_output,
+        extrapolation_features,
         knn=knn,
         chunk_size=chunk_size,
-        device=device,
+        device=device
     )
     return new_eigenvectors
 

{nystrom_ncut-0.0.5 → nystrom_ncut-0.0.7}/src/nystrom_ncut/visualize_utils.py

@@ -6,11 +6,14 @@ import torch
 import torch.nn.functional as F
 from sklearn.base import BaseEstimator
 
-from .common import lazy_normalize
+from .common import (
+    DistanceOptions,
+    lazy_normalize,
+)
 from .propagation_utils import (
     run_subgraph_sampling,
-    propagate_knn,
-    propagate_eigenvectors,
+    extrapolate_knn,
+    extrapolate_knn_with_subsampling,
     quantile_min_max,
     quantile_normalize
 )
@@ -31,14 +34,29 @@ def _rgb_with_dimensionality_reduction(
     reduction_dim: int,
     reduction_kwargs: Dict[str, Any],
     transform_func: Callable[[torch.Tensor], torch.Tensor] = _identity,
+    pre_smooth: bool = True,
 ) -> Tuple[torch.Tensor, torch.Tensor]:
+
+    if pre_smooth:
+        _subgraph_indices = run_subgraph_sampling(
+            features,
+            num_sample,
+            sample_method="farthest",
+        )
+        features = extrapolate_knn(
+            features[_subgraph_indices],
+            features[_subgraph_indices],
+            features,
+            distance="cosine",
+        )
+
     subgraph_indices = run_subgraph_sampling(
         features,
         num_sample,
         sample_method="farthest",
     )
 
-    _inp = features[subgraph_indices].cpu().numpy()
+    _inp = features[subgraph_indices].numpy(force=True)
     _subgraph_embed = reduction(
         n_components=reduction_dim,
         metric=metric,
@@ -47,14 +65,14 @@ def _rgb_with_dimensionality_reduction(
     ).fit_transform(_inp)
 
     _subgraph_embed = torch.tensor(_subgraph_embed, dtype=torch.float32)
-    X_nd = transform_func(propagate_knn(
+    X_nd = transform_func(extrapolate_knn(
+        features[subgraph_indices],
         _subgraph_embed,
         features,
-        features[subgraph_indices],
-        distance=metric,
         knn=knn,
+        distance=metric,
         device=device,
-        move_output_to_cpu=True,
+        move_output_to_cpu=True
     ))
     rgb = rgb_func(X_nd, q)
     return X_nd, rgb
@@ -413,48 +431,6 @@ def rgb_from_2d_colormap(X_2d, q=0.95):
     return rgb
 
 
-def propagate_rgb_color(
-    rgb: torch.Tensor,
-    eigenvectors: torch.Tensor,
-    new_eigenvectors: torch.Tensor,
-    knn: int = 10,
-    num_sample: int = 1000,
-    sample_method: Literal["farthest", "random"] = "farthest",
-    chunk_size: int = 8192,
-    device: str = None,
-):
-    """Propagate RGB color to new nodes using KNN.
-    Args:
-        rgb (torch.Tensor): RGB color for each data sample, shape (n_samples, 3)
-        features (torch.Tensor): features from existing nodes, shape (n_samples, n_features)
-        new_features (torch.Tensor): features from new nodes, shape (n_new_samples, n_features)
-        knn (int): number of KNN to propagate RGB color, default 1
-        num_sample (int): number of samples for subgraph sampling, default 50000
-        sample_method (str): sample method, 'farthest' (default) or 'random'
-        chunk_size (int): chunk size for matrix multiplication, default 8192
-        device (str): device to use for computation, if None, will not change device
-    Returns:
-        torch.Tensor: propagated RGB color for each data sample, shape (n_new_samples, 3)
-
-    Examples:
-        >>> old_rgb = torch.randn(3000, 3)
-        >>> old_eigenvectors = torch.randn(3000, 20)
-        >>> new_eigenvectors = torch.randn(200, 20)
-        >>> new_rgb = propagate_rgb_color(old_rgb, new_eigenvectors, old_eigenvectors)
-        >>> # new_eigenvectors.shape = (200, 3)
-    """
-    return propagate_eigenvectors(
-        eigenvectors=rgb,
-        features=eigenvectors,
-        new_features=new_eigenvectors,
-        knn=knn,
-        num_sample=num_sample,
-        sample_method=sample_method,
-        chunk_size=chunk_size,
-        device=device,
-    )
-
-
 # application: get segmentation mask fron a reference eigenvector (point prompt)
 def _transform_heatmap(heatmap, gamma=1.0):
     """Transform the heatmap using gamma, normalize and min-max normalization.

{nystrom_ncut-0.0.5 → nystrom_ncut-0.0.7/src/nystrom_ncut.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: nystrom_ncut
-Version: 0.0.5
+Version: 0.0.7
 Summary: Normalized Cut and Nyström Approximation
 Author-email: Huzheng Yang <huze.yann@gmail.com>, Wentinn Liao <wentinn.liao@gmail.com>
 Project-URL: Documentation, https://github.com/JophiArcana/Nystrom-NCUT/

nystrom_ncut-0.0.7/tests/test.py

@@ -0,0 +1,190 @@
+import numpy as np
+import torch
+import torch.nn.functional as Fn
+from matplotlib import pyplot as plt
+
+from src.nystrom_ncut.ncut_pytorch import NCUT, axis_align, affinity_from_features
+from ncut_pytorch import NCUT as OldNCUT
+# from ncut_pytorch.src import rgb_from_umap_sphere
+# from ncut_pytorch.src.new_ncut_pytorch import NewNCUT
+
+# from ncut_pytorch.ncut_pytorch.backbone_text import load_text_model
+
+
+if __name__ == "__main__":
+    # torch.manual_seed(1212)
+    # M = torch.randn((7, 3))
+    # W = torch.nn.functional.cosine_similarity(M[:, None], M[None, :], dim=-1)
+    # A = torch.exp(W - 1)
+    # D_s2 = torch.sum(A, dim=-1, keepdim=True) ** -0.5
+    # # print(A)
+    # print(A * D_s2 * D_s2.mT)
+    #
+    # ncut = NCUT(num_eig=7, knn=1, eig_solver="svd")
+    # V, L = ncut.fit_transform(M)
+    # print(V @ torch.diag(L) @ V.mT)
+    # raise Exception()
+
+    # print(load_text_model("meta-llama/Meta-Llama-3.1-8B").cuda())
+    # print(AutoModelForCausalLM.from_pretrained(
+    #     "meta-llama/Meta-Llama-3.1-8B",
+    #     token="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",
+    # ))
+    # # print(transformers.pipeline(
+    # #     "text-generation",
+    # #     model="meta-llama/Meta-Llama-3.1-8B",
+    # #     model_kwargs={"torch_dtype": torch.bfloat16},
+    # #     token="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",
+    # #     device="cpu",
+    # # ))
+    # raise Exception(
+
+    torch.set_printoptions(precision=8, sci_mode=False, linewidth=400)
+    torch.set_default_dtype(torch.float64)
+    torch.manual_seed(1212)
+    np.random.seed(1212)
+
+    n = 120
+    num_sample = 100
+
+    M = torch.rand((n, 12))
+    distance = "rbf"
+
+    A = affinity_from_features(M, distance=distance)
+    R = torch.diag(torch.sum(A, dim=-1) ** -0.5)
+    L = R @ A @ R
+
+    # C = L[num_sample:, num_sample:]
+    #
+    # _A = L[:num_sample, :num_sample]
+    # _B = L[:num_sample, num_sample:]
+    # extrapolated_C = _B.mT @ torch.inverse(_A) @ _B
+    #
+    # RE = torch.abs(extrapolated_C / C - 1)
+    # print(torch.max(RE).item(), torch.mean(RE).item(), torch.min(RE).item())
+
+    n_components = 30   # num_sample
+    eig_solver = "svd"
+
+    def rel_error(X, eigs):
+        _L = X @ torch.diag(eigs) @ X.mT
+        return torch.abs(_L / L - 1)
+
+    def print_re(re):
+        print(f"max: {re.max().item()}, mean: {re.mean().item()}, min: {re.min().item()}")
+
+    nc0 = NCUT(n_components=n_components, num_sample=num_sample, distance=distance, eig_solver=eig_solver)
+    X0, eigs0 = nc0.fit_transform(M)
+
+    re0 = rel_error(X0, eigs0)
+    print_re(re0)
+
+    plt.imshow(re0)
+    plt.colorbar()
+    plt.show()
+
+    plt.scatter(torch.arange(n), torch.linalg.norm(X0, dim=-1))
+    plt.show()
+    raise Exception()
+
+
+    #
+    # # plt.scatter(torch.arange(n), torch.linalg.norm(X0, dim=-1))
+    # # plt.show()
+    # # raise Exception()
+    #
+    # def align_to(X, eigs):
+    #     sign = torch.sign(torch.sum(X0 * X, dim=0))
+    #     return X * sign, eigs
+    #
+    # Xs = []
+    # n_trials = 20
+    # sum_X, sum_eigs = 0.0, 0.0
+    # for _ in range(n_trials):
+    #     nc = NCUT(n_components=n_components, num_sample=num_sample, distance=distance, eig_solver=eig_solver)
+    #     X, eigs = align_to(*nc.fit_transform(M))
+    #     Xs.append(X)
+    #
+    #     re = rel_error(X, eigs)
+    #     print(f"max: {re.max().item()}, mean: {re.mean().item()}, min: {re.min().item()}")
+    #
+    #     # print(X[:3, :10])
+    #     # print(eigs[:10])
+    #
+    #     sum_X = sum_X + X
+    #     sum_eigs = sum_eigs + eigs
+    #
+    # # print(torch.diag(Xs[0].mT @ Xs[1]))
+    # # raise Exception()
+    #
+    # print("=" * 120)
+    # mean_X, mean_eigs = sum_X / n_trials, sum_eigs / n_trials
+    # mean_re = rel_error(mean_X, mean_eigs)
+    # print(f"max: {mean_re.max().item()}, mean: {mean_re.mean().item()}, min: {mean_re.min().item()}")
+    #
+    # raise Exception()
+
+
+
+    ncs = [
+        NCUT(n_components=n_components, num_sample=n, distance=distance, eig_solver=eig_solver),
+        NCUT(n_components=n_components, num_sample=num_sample, distance=distance, eig_solver=eig_solver),
+        # OldNCUT(num_eig=n_components, num_sample=num_sample, knn=10, distance=distance, eig_solver=eig_solver, make_orthogonal=True),
+    ]
+
+    for NC in ncs:
+        torch.manual_seed(1212)
+        np.random.seed(1212)
+        X, eigs = NC.fit_transform(M)
+
+        RE = rel_error(X, eigs)
+        print(f"max: {RE.max().item()}, mean: {RE.mean().item()}, min: {RE.min().item()}")
+
+    # torch.manual_seed(1212)
+    # np.random.seed(1212)
+    #
+    # aX, R = axis_align(X)
+    # print(aX[:3])
+    # print(R)
+    # print(R @ R.mT)
+
+
+
+
+    # import time
+    # n_trials = 10
+    #
+    # with torch.no_grad():
+    #     start_t = time.perf_counter()
+    #     for _ in range(n_trials):
+    #         X, eigs = NC.fit_transform(M)
+    #     end_t = time.perf_counter()
+    #     print(X.min().item(), X.max().item(), eigs)
+    #     print(f"{1e3 * (end_t - start_t) / n_trials}ms")
+    #
+    #     start_t = time.perf_counter()
+    #     for _ in range(n_trials):
+    #         nX, neigs = nNC.fit_transform(M)
+    #     end_t = time.perf_counter()
+    #     print(nX.min().item(), nX.max().item(), neigs)
+    #     print(f"{1e3 * (end_t - start_t) / n_trials}ms")
+    # raise Exception()
+
+    # assert torch.all(torch.isclose(X, torch.Tensor([
+    #     [0.320216, 0.144101, -0.110744, -0.560543, -0.007982],
+    #     [0.297634, 0.662867, 0.146107, 0.277893, 0.553959],
+    #     [0.324994, -0.057295, 0.052916, 0.391666, -0.460911],
+    #     [0.301703, -0.460709, 0.528563, 0.222525, 0.325546],
+    #     [0.316614, 0.043475, -0.526899, 0.100665, -0.030259],
+    #     [0.325425, -0.127884, 0.294540, -0.012173, -0.303528],
+    #     [0.318136, -0.288952, -0.065148, -0.470192, 0.244805],
+    #     [0.309522, -0.352693, -0.473237, 0.234057, 0.276185],
+    #     [0.320464, 0.229301, 0.281134, -0.308938, -0.169746],
+    #     [0.326147, 0.213536, -0.112246, 0.155114, -0.341439]
+    # ]), atol=1e-6)), "Failed assertion"
+
+    # torch.manual_seed(1212)
+    # np.random.seed(1212)
+    # X_2d, rgb = rgb_from_umap_sphere(X)
+    # # X_3d, rgb = rgb_from_cosine_tsne_3d(X)
+    # print(rgb)

nystrom_ncut-0.0.5/tests/test.py

@@ -1,111 +0,0 @@
-import numpy as np
-import torch
-import torch.nn.functional as Fn
-
-from src.nystrom_ncut.ncut_pytorch import NCUT, axis_align
-# from ncut_pytorch.src import rgb_from_umap_sphere
-# from ncut_pytorch.src.new_ncut_pytorch import NewNCUT
-
-# from ncut_pytorch.ncut_pytorch.backbone_text import load_text_model
-
-
-if __name__ == "__main__":
-    # torch.manual_seed(1212)
-    # M = torch.randn((7, 3))
-    # W = torch.nn.functional.cosine_similarity(M[:, None], M[None, :], dim=-1)
-    # A = torch.exp(W - 1)
-    # D_s2 = torch.sum(A, dim=-1, keepdim=True) ** -0.5
-    # # print(A)
-    # print(A * D_s2 * D_s2.mT)
-    #
-    # ncut = NCUT(num_eig=7, knn=1, eig_solver="svd")
-    # V, L = ncut.fit_transform(M)
-    # print(V @ torch.diag(L) @ V.mT)
-    # raise Exception()
-
-    # print(load_text_model("meta-llama/Meta-Llama-3.1-8B").cuda())
-    # print(AutoModelForCausalLM.from_pretrained(
-    #     "meta-llama/Meta-Llama-3.1-8B",
-    #     token="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",
-    # ))
-    # # print(transformers.pipeline(
-    # #     "text-generation",
-    # #     model="meta-llama/Meta-Llama-3.1-8B",
-    # #     model_kwargs={"torch_dtype": torch.bfloat16},
-    # #     token="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",
-    # #     device="cpu",
-    # # ))
-    # raise Exception(
-
-    torch.set_printoptions(precision=8, sci_mode=False, linewidth=400)
-    torch.set_default_dtype(torch.float64)
-    torch.manual_seed(1212)
-    np.random.seed(1212)
-
-    M = torch.rand((12000, 12))
-    NC = NCUT(n_components=12, num_sample=10000, sample_method="farthest")
-
-    torch.manual_seed(1212)
-    np.random.seed(1212)
-    X, eigs = NC.fit_transform(M)
-    print(eigs)
-
-    normalized_M = Fn.normalize(M, p=2, dim=-1)
-    A = torch.exp(-(1 - normalized_M @ normalized_M.mT))
-    R = torch.diag(torch.sum(A, dim=-1) ** -0.5)
-    L = R @ A @ R
-    # print(L)
-    # print(X @ torch.diag(eigs) @ X.mT)
-    # print(L)
-    RE = torch.abs(X @ torch.diag(eigs) @ X.mT / L - 1)
-    print(RE.max().item(), RE.mean().item())
-
-    # torch.manual_seed(1212)
-    # np.random.seed(1212)
-    #
-    # aX, R = axis_align(X)
-    # print(aX[:3])
-    # print(R)
-    # print(R @ R.mT)
-    raise Exception()
-
-
-
-
-    # import time
-    # n_trials = 10
-    #
-    # with torch.no_grad():
-    #     start_t = time.perf_counter()
-    #     for _ in range(n_trials):
-    #         X, eigs = NC.fit_transform(M)
-    #     end_t = time.perf_counter()
-    #     print(X.min().item(), X.max().item(), eigs)
-    #     print(f"{1e3 * (end_t - start_t) / n_trials}ms")
-    #
-    #     start_t = time.perf_counter()
-    #     for _ in range(n_trials):
-    #         nX, neigs = nNC.fit_transform(M)
-    #     end_t = time.perf_counter()
-    #     print(nX.min().item(), nX.max().item(), neigs)
-    #     print(f"{1e3 * (end_t - start_t) / n_trials}ms")
-    # raise Exception()
-
-    # assert torch.all(torch.isclose(X, torch.Tensor([
-    #     [0.320216, 0.144101, -0.110744, -0.560543, -0.007982],
-    #     [0.297634, 0.662867, 0.146107, 0.277893, 0.553959],
-    #     [0.324994, -0.057295, 0.052916, 0.391666, -0.460911],
-    #     [0.301703, -0.460709, 0.528563, 0.222525, 0.325546],
-    #     [0.316614, 0.043475, -0.526899, 0.100665, -0.030259],
-    #     [0.325425, -0.127884, 0.294540, -0.012173, -0.303528],
-    #     [0.318136, -0.288952, -0.065148, -0.470192, 0.244805],
-    #     [0.309522, -0.352693, -0.473237, 0.234057, 0.276185],
-    #     [0.320464, 0.229301, 0.281134, -0.308938, -0.169746],
-    #     [0.326147, 0.213536, -0.112246, 0.155114, -0.341439]
-    # ]), atol=1e-6)), "Failed assertion"
-
-    torch.manual_seed(1212)
-    np.random.seed(1212)
-    X_2d, rgb = rgb_from_umap_sphere(X)
-    # X_3d, rgb = rgb_from_cosine_tsne_3d(X)
-    print(rgb)