nystrom-ncut 0.0.8__py3-none-any.whl → 0.0.10__py3-none-any.whl

nystrom_ncut/__init__.py

@@ -1,12 +1,13 @@
-from .ncut_pytorch import (
-    NCUT,
+from .nystrom import (
+    DistanceRealization,
+    NCut,
     axis_align,
 )
 from .propagation_utils import (
+    distance_from_features,
     affinity_from_features,
     extrapolate_knn_with_subsampling,
     extrapolate_knn,
-    quantile_normalize,
 )
 from .visualize_utils import (
     rgb_from_tsne_3d,

nystrom_ncut/common.py

@@ -22,3 +22,40 @@ def lazy_normalize(x: torch.Tensor, n: int = 1000, **normalize_kwargs: Any) -> t
         return x
     else:
         return Fn.normalize(x, **normalize_kwargs)
+
+
+def quantile_min_max(x, q1=0.01, q2=0.99, n_sample=10000):
+    if x.shape[0] > n_sample:
+        np.random.seed(0)
+        random_idx = np.random.choice(x.shape[0], n_sample, replace=False)
+        vmin, vmax = x[random_idx].quantile(q1), x[random_idx].quantile(q2)
+    else:
+        vmin, vmax = x.quantile(q1), x.quantile(q2)
+    return vmin, vmax
+
+
+def quantile_normalize(x, q=0.95):
+    """normalize each dimension of x to [0, 1], take 95-th percentage, this robust to outliers
+        </br> 1. sort x
+        </br> 2. take q-th quantile
+        </br>     min_value -> (1-q)-th quantile
+        </br>     max_value -> q-th quantile
+        </br> 3. normalize
+        </br> x = (x - min_value) / (max_value - min_value)
+
+    Args:
+        x (torch.Tensor): input tensor, shape (n_samples, n_features)
+            normalize each feature to 0-1 range
+        q (float): quantile, default 0.95
+
+    Returns:
+        torch.Tensor: quantile normalized tensor
+    """
+    # normalize x to 0-1 range, max value is q-th quantile
+    # quantile makes the normalization robust to outliers
+    if isinstance(x, np.ndarray):
+        x = torch.tensor(x)
+    vmax, vmin = quantile_min_max(x, q, 1 - q)
+    x = (x - vmin) / (vmax - vmin)
+    x = x.clamp(0, 1)
+    return x

nystrom_ncut/nystrom/__init__.py

@@ -0,0 +1,7 @@
+from .distance_realization import (
+    DistanceRealization,
+)
+from .normalized_cut import (
+    NCut,
+    axis_align,
+)

nystrom_ncut/nystrom/distance_realization.py

@@ -0,0 +1,127 @@
+import torch
+
+from .nystrom import (
+    EigSolverOptions,
+    OnlineKernel,
+    OnlineNystromSubsampleFit,
+    solve_eig,
+)
+from ..common import (
+    DistanceOptions,
+    SampleOptions,
+)
+from ..propagation_utils import (
+    distance_from_features,
+)
+
+
+class GramKernel(OnlineKernel):
+    def __init__(
+        self,
+        distance: DistanceOptions,
+        eig_solver: EigSolverOptions,
+    ):
+        self.distance: DistanceOptions = distance
+        self.eig_solver: EigSolverOptions = eig_solver
+
+        # Anchor matrices
+        self.anchor_features: torch.Tensor = None               # [n x d]
+        self.A: torch.Tensor = None                             # [n x n]
+        self.Ainv: torch.Tensor = None                          # [n x n]
+
+        # Updated matrices
+        self.a_r: torch.Tensor = None                           # [n]
+        self.b_r: torch.Tensor = None                           # [n]
+        self.matrix_sum: torch.Tensor = torch.zeros(())         # []
+        self.n_features: int = None                             # N
+
+    def fit(self, features: torch.Tensor) -> None:
+        self.anchor_features = features                         # [n x d]
+        self.A = -0.5 * distance_from_features(
+            self.anchor_features,                               # [n x d]
+            self.anchor_features,
+            distance=self.distance,
+        )                                                       # [n x n]
+        d = features.shape[-1]
+        U, L = solve_eig(
+            self.A,
+            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]
+        self.a_r = torch.sum(self.A, dim=-1)                    # [n]
+        self.b_r = torch.zeros_like(self.a_r)                   # [n]
+        self.matrix_sum = torch.sum(self.a_r)                   # []
+        self.n_features = features.shape[0]                     # n
+
+    def update(self, features: torch.Tensor) -> torch.Tensor:
+        B = -0.5 * distance_from_features(
+            self.anchor_features,                               # [n x d]
+            features,                                           # [m x d]
+            distance=self.distance,
+        )                                                       # [n x m]
+        b_r = torch.sum(B, dim=-1)                              # [n]
+        b_c = torch.sum(B, dim=-2)                              # [m]
+        self.b_r = self.b_r + b_r                               # [n]
+        self.matrix_sum = (
+            torch.sum(self.a_r)
+            + 2 * torch.sum(self.b_r)
+            + self.Ainv @ self.b_r @ self.b_r
+        )                                                       # []
+        self.n_features += features.shape[0]                    # N
+
+        row_sum = self.a_r + self.b_r                           # [n]
+        col_sum = b_c + B.mT @ self.Ainv @ self.b_r             # [m]
+        shift = -(row_sum[:, None] + col_sum) / self.n_features + self.matrix_sum / (self.n_features ** 2)  # [n x m]
+        return (B + shift).mT                                   # [m x n]
+
+    def transform(self, features: torch.Tensor = None) -> torch.Tensor:
+        row_sum = self.a_r + self.b_r
+        if features is None:
+            B = self.A                                          # [n x n]
+            col_sum = row_sum                                   # [n]
+        else:
+            B = -0.5 * distance_from_features(
+                self.anchor_features,
+                features,
+                distance=self.distance,
+            )
+            b_c = torch.sum(B, dim=-2)                          # [m]
+            col_sum = b_c + B.mT @ self.Ainv @ self.b_r         # [m]
+        shift = -(row_sum[:, None] + col_sum) / self.n_features + self.matrix_sum / (self.n_features ** 2)  # [n x m]
+        return (B + shift).mT                                   # [m x n]
+
+
+class DistanceRealization(OnlineNystromSubsampleFit):
+    """Nystrom Distance Realization for large scale graph."""
+
+    def __init__(
+        self,
+        n_components: int = 100,
+        num_sample: int = 10000,
+        sample_method: SampleOptions = "farthest",
+        distance: DistanceOptions = "cosine",
+        eig_solver: EigSolverOptions = "svd_lowrank",
+        chunk_size: int = 8192,
+    ):
+        """
+        Args:
+            n_components (int): number of top eigenvectors to return
+            num_sample (int): number of samples for Nystrom-like approximation,
+                reduce only if memory is not enough, increase for better approximation
+            sample_method (str): subgraph sampling, ['farthest', 'random'].
+                farthest point sampling is recommended for better Nystrom-approximation accuracy
+            distance (str): distance metric for affinity matrix, ['cosine', 'euclidean', 'rbf'].
+            eig_solver (str): eigen decompose solver, ['svd_lowrank', 'lobpcg', 'svd', 'eigh'].
+            chunk_size (int): chunk size for large-scale matrix multiplication
+        """
+        OnlineNystromSubsampleFit.__init__(
+            self,
+            n_components=n_components,
+            kernel=GramKernel(distance, eig_solver),
+            num_sample=num_sample,
+            sample_method=sample_method,
+            eig_solver=eig_solver,
+            chunk_size=chunk_size,
+        )
+        self.distance: DistanceOptions = distance

nystrom_ncut/{ncut_pytorch.py → nystrom/normalized_cut.py}

@@ -1,22 +1,18 @@
-import logging
-from typing import Tuple
-
 import torch
 import torch.nn.functional as Fn
 
-from .common import (
-    DistanceOptions,
-    SampleOptions,
-)
 from .nystrom import (
     EigSolverOptions,
     OnlineKernel,
-    OnlineNystrom,
+    OnlineNystromSubsampleFit,
     solve_eig,
 )
-from .propagation_utils import (
+from ..common import (
+    DistanceOptions,
+    SampleOptions,
+)
+from ..propagation_utils import (
     affinity_from_features,
-    run_subgraph_sampling,
 )
 
 
@@ -68,16 +64,16 @@ class LaplacianKernel(OnlineKernel):
         b_c = torch.sum(B, dim=-2)                              # [m]
         self.b_r = self.b_r + b_r                               # [n]
 
-        rowscale = self.a_r + self.b_r                          # [n]
-        colscale = b_c + B.mT @ self.Ainv @ self.b_r            # [m]
-        scale = (rowscale[:, None] * colscale) ** -0.5          # [n x m]
+        row_sum = self.a_r + self.b_r                           # [n]
+        col_sum = b_c + B.mT @ self.Ainv @ self.b_r             # [m]
+        scale = (row_sum[:, None] * col_sum) ** -0.5            # [n x m]
         return (B * scale).mT                                   # [m x n]
 
     def transform(self, features: torch.Tensor = None) -> torch.Tensor:
-        rowscale = self.a_r + self.b_r                          # [n]
+        row_sum = self.a_r + self.b_r                           # [n]
         if features is None:
             B = self.A                                          # [n x n]
-            colscale = rowscale                                 # [n]
+            col_sum = row_sum                                   # [n]
         else:
             B = affinity_from_features(
                 self.anchor_features,                           # [n x d]
@@ -86,12 +82,12 @@ class LaplacianKernel(OnlineKernel):
                 distance=self.distance,
             )                                                   # [n x m]
             b_c = torch.sum(B, dim=-2)                          # [m]
-            colscale = b_c + B.mT @ self.Ainv @ self.b_r        # [m]
-        scale = (rowscale[:, None] * colscale) ** -0.5          # [n x m]
+            col_sum = b_c + B.mT @ self.Ainv @ self.b_r         # [m]
+        scale = (row_sum[:, None] * col_sum) ** -0.5            # [n x m]
         return (B * scale).mT                                   # [m x n]
 
 
-class NCUT(OnlineNystrom):
+class NCut(OnlineNystromSubsampleFit):
     """Nystrom Normalized Cut for large scale graph."""
 
     def __init__(
@@ -102,7 +98,6 @@ class NCUT(OnlineNystrom):
         sample_method: SampleOptions = "farthest",
         distance: DistanceOptions = "cosine",
         eig_solver: EigSolverOptions = "svd_lowrank",
-        normalize_features: bool = None,
         chunk_size: int = 8192,
     ):
         """
@@ -116,110 +111,18 @@ class NCUT(OnlineNystrom):
                 farthest point sampling is recommended for better Nystrom-approximation accuracy
             distance (str): distance metric for affinity matrix, ['cosine', 'euclidean', 'rbf'].
             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
             chunk_size (int): chunk size for large-scale matrix multiplication
         """
-        OnlineNystrom.__init__(
+        OnlineNystromSubsampleFit.__init__(
             self,
             n_components=n_components,
             kernel=LaplacianKernel(affinity_focal_gamma, distance, eig_solver),
+            num_sample=num_sample,
+            sample_method=sample_method,
             eig_solver=eig_solver,
             chunk_size=chunk_size,
         )
-        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.chunk_size: int = chunk_size
-
-    def _fit_helper(
-        self,
-        features: torch.Tensor,
-        precomputed_sampled_indices: torch.Tensor,
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
-        _n = features.shape[0]
-        if self.num_sample >= _n:
-            logging.info(
-                f"NCUT nystrom num_sample is larger than number of input samples, nyström approximation is not needed, setting num_sample={_n}"
-            )
-            self.num_sample = _n
-
-        assert self.distance in ["cosine", "euclidean", "rbf"], "distance should be 'cosine', 'euclidean', 'rbf'"
-
-        if self.normalize_features:
-            # features need to be normalized for affinity matrix computation (cosine distance)
-            features = torch.nn.functional.normalize(features, dim=-1)
-
-        if precomputed_sampled_indices is not None:
-            _sampled_indices = precomputed_sampled_indices
-        else:
-            _sampled_indices = run_subgraph_sampling(
-                features,
-                self.num_sample,
-                sample_method=self.sample_method,
-            )
-        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, self.anchor_indices, False)
-            unsampled_features = features[unsampled_indices]
-            V_unsampled, _ = OnlineNystrom.update(self, unsampled_features)
-        else:
-            unsampled_indices = V_unsampled = None
-        return unsampled_indices, V_unsampled
-
-    def fit(
-        self,
-        features: torch.Tensor,
-        precomputed_sampled_indices: torch.Tensor = None,
-    ):
-        """Fit Nystrom Normalized Cut on the input features.
-        Args:
-            features (torch.Tensor): input features, shape (n_samples, n_features)
-            precomputed_sampled_indices (torch.Tensor): precomputed sampled indices, shape (num_sample,)
-                override the sample_method, if not None
-        Returns:
-            (NCUT): self
-        """
-        NCUT._fit_helper(self, features, precomputed_sampled_indices)
-        return self
-
-    def fit_transform(
-        self,
-        features: torch.Tensor,
-        precomputed_sampled_indices: torch.Tensor = None,
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
-        """
-        Args:
-            features (torch.Tensor): input features, shape (n_samples, n_features)
-            precomputed_sampled_indices (torch.Tensor): precomputed sampled indices, shape (num_sample,)
-                override the sample_method, if not None
-
-        Returns:
-            (torch.Tensor): eigen_vectors, shape (n_samples, num_eig)
-            (torch.Tensor): eigen_values, sorted in descending order, shape (num_eig,)
-        """
-        unsampled_indices, V_unsampled = NCUT._fit_helper(self, features, precomputed_sampled_indices)
-        V_sampled, L = OnlineNystrom.transform(self)
-
-        if unsampled_indices is not None:
-            V = torch.zeros((len(unsampled_indices), self.n_components), device=features.device)
-            V[~unsampled_indices] = V_sampled
-            V[unsampled_indices] = V_unsampled
-        else:
-            V = V_sampled
-        return V, L
 
 
 def axis_align(eigen_vectors: torch.Tensor, max_iter=300):

nystrom_ncut/{nystrom.py → nystrom/nystrom.py}

@@ -1,8 +1,15 @@
+import logging
 from typing import Literal, Tuple
 
 import torch
 
-from .common import ceildiv
+from ..common import (
+    SampleOptions,
+    ceildiv,
+)
+from ..propagation_utils import (
+    run_subgraph_sampling,
+)
 
 
 EigSolverOptions = Literal["svd_lowrank", "lobpcg", "svd", "eigh"]
@@ -132,6 +139,102 @@ class OnlineNystrom:
         return VS, self.LS                                                                          # [m x n_components], [n_components]
 
 
+class OnlineNystromSubsampleFit(OnlineNystrom):
+    def __init__(
+        self,
+        n_components: int,
+        kernel: OnlineKernel,
+        num_sample: int,
+        sample_method: SampleOptions,
+        eig_solver: EigSolverOptions = "svd_lowrank",
+        chunk_size: int = 8192,
+    ):
+        OnlineNystrom.__init__(
+            self,
+            n_components=n_components,
+            kernel=kernel,
+            eig_solver=eig_solver,
+            chunk_size=chunk_size,
+        )
+        self.num_sample: int = num_sample
+        self.sample_method: SampleOptions = sample_method
+        self.anchor_indices: torch.Tensor = None
+
+    def _fit_helper(
+        self,
+        features: torch.Tensor,
+        precomputed_sampled_indices: torch.Tensor,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        _n = features.shape[0]
+        if self.num_sample >= _n:
+            logging.info(
+                f"NCUT nystrom num_sample is larger than number of input samples, nyström approximation is not needed, setting num_sample={_n}"
+            )
+            self.num_sample = _n
+
+        if precomputed_sampled_indices is not None:
+            self.anchor_indices = precomputed_sampled_indices
+        else:
+            self.anchor_indices = run_subgraph_sampling(
+                features,
+                self.num_sample,
+                sample_method=self.sample_method,
+            )
+        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, self.anchor_indices, False)
+            unsampled_features = features[unsampled_indices]
+            V_unsampled, _ = OnlineNystrom.update(self, unsampled_features)
+        else:
+            unsampled_indices = V_unsampled = None
+        return unsampled_indices, V_unsampled
+
+    def fit(
+        self,
+        features: torch.Tensor,
+        precomputed_sampled_indices: torch.Tensor = None,
+    ):
+        """Fit Nystrom Normalized Cut on the input features.
+        Args:
+            features (torch.Tensor): input features, shape (n_samples, n_features)
+            precomputed_sampled_indices (torch.Tensor): precomputed sampled indices, shape (num_sample,)
+                override the sample_method, if not None
+        Returns:
+            (NCut): self
+        """
+        OnlineNystromSubsampleFit._fit_helper(self, features, precomputed_sampled_indices)
+        return self
+
+    def fit_transform(
+        self,
+        features: torch.Tensor,
+        precomputed_sampled_indices: torch.Tensor = None,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Args:
+            features (torch.Tensor): input features, shape (n_samples, n_features)
+            precomputed_sampled_indices (torch.Tensor): precomputed sampled indices, shape (num_sample,)
+                override the sample_method, if not None
+
+        Returns:
+            (torch.Tensor): eigen_vectors, shape (n_samples, num_eig)
+            (torch.Tensor): eigen_values, sorted in descending order, shape (num_eig,)
+        """
+        unsampled_indices, V_unsampled = OnlineNystromSubsampleFit._fit_helper(self, features, precomputed_sampled_indices)
+        V_sampled, L = OnlineNystrom.transform(self)
+
+        if unsampled_indices is not None:
+            V = torch.zeros((len(unsampled_indices), self.n_components), device=features.device)
+            V[~unsampled_indices] = V_sampled
+            V[unsampled_indices] = V_unsampled
+        else:
+            V = V_sampled
+        return V, L
+
+
 def solve_eig(
     A: torch.Tensor,
     num_eig: int,

nystrom_ncut/propagation_utils.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Literal
 
 import numpy as np
 import torch
@@ -48,6 +47,7 @@ def run_subgraph_sampling(
             sampled_indices = torch.randperm(features.shape[0])[:num_sample]
         else:
             raise ValueError("sample_method should be 'farthest' or 'random'")
+        sampled_indices = torch.sort(sampled_indices).values
     return sampled_indices.to(features.device)
 
 
@@ -256,40 +256,3 @@ def extrapolate_knn_with_subsampling(
         device=device
     )
     return new_eigenvectors
-
-
-def quantile_min_max(x, q1=0.01, q2=0.99, n_sample=10000):
-    if x.shape[0] > n_sample:
-        np.random.seed(0)
-        random_idx = np.random.choice(x.shape[0], n_sample, replace=False)
-        vmin, vmax = x[random_idx].quantile(q1), x[random_idx].quantile(q2)
-    else:
-        vmin, vmax = x.quantile(q1), x.quantile(q2)
-    return vmin, vmax
-
-
-def quantile_normalize(x, q=0.95):
-    """normalize each dimension of x to [0, 1], take 95-th percentage, this robust to outliers
-        </br> 1. sort x
-        </br> 2. take q-th quantile
-        </br>     min_value -> (1-q)-th quantile
-        </br>     max_value -> q-th quantile
-        </br> 3. normalize
-        </br> x = (x - min_value) / (max_value - min_value)
-
-    Args:
-        x (torch.Tensor): input tensor, shape (n_samples, n_features)
-            normalize each feature to 0-1 range
-        q (float): quantile, default 0.95
-
-    Returns:
-        torch.Tensor: quantile normalized tensor
-    """
-    # normalize x to 0-1 range, max value is q-th quantile
-    # quantile makes the normalization robust to outliers
-    if isinstance(x, np.ndarray):
-        x = torch.tensor(x)
-    vmax, vmin = quantile_min_max(x, q, 1 - q)
-    x = (x - vmin) / (vmax - vmin)
-    x = x.clamp(0, 1)
-    return x

nystrom_ncut/visualize_utils.py

@@ -7,15 +7,13 @@ import torch.nn.functional as F
 from sklearn.base import BaseEstimator
 
 from .common import (
-    DistanceOptions,
     lazy_normalize,
+    quantile_min_max,
+    quantile_normalize,
 )
 from .propagation_utils import (
     run_subgraph_sampling,
     extrapolate_knn,
-    extrapolate_knn_with_subsampling,
-    quantile_min_max,
-    quantile_normalize
 )
 
 
@@ -28,19 +26,25 @@ def _rgb_with_dimensionality_reduction(
     num_sample: int,
     metric: Literal["cosine", "euclidean"],
     rgb_func: Callable[[torch.Tensor, float], torch.Tensor],
-    q: float, knn: int,
-    seed: int, device: str,
+    q: float,
+    knn: int,
     reduction: Callable[..., BaseEstimator],
     reduction_dim: int,
     reduction_kwargs: Dict[str, Any],
-    transform_func: Callable[[torch.Tensor], torch.Tensor] = _identity,
-    pre_smooth: bool = True,
+    transform_func: Callable[[torch.Tensor], torch.Tensor],
+    seed: int,
+    device: str,
 ) -> Tuple[torch.Tensor, torch.Tensor]:
 
-    if pre_smooth:
-        features = extrapolate_knn(
-            features,
+    if True:
+        _subgraph_indices = run_subgraph_sampling(
             features,
+            num_sample=10000,
+            sample_method="farthest",
+        )
+        features = extrapolate_knn(
+            features[_subgraph_indices],
+            features[_subgraph_indices],
             features,
             distance="cosine",
         )
@@ -78,10 +82,10 @@ def rgb_from_tsne_2d(
     num_sample: int = 1000,
     perplexity: int = 150,
     metric: Literal["cosine", "euclidean"] = "cosine",
-    device: str = None,
-    seed: int = 0,
     q: float = 0.95,
     knn: int = 10,
+    seed: int = 0,
+    device: str = None,
 ):
     """
     Returns:
@@ -106,11 +110,13 @@ def rgb_from_tsne_2d(
         num_sample=num_sample,
         metric=metric,
         rgb_func=rgb_from_2d_colormap,
-        q=q, knn=knn,
-        seed=seed, device=device,
+        q=q,
+        knn=knn,
         reduction=TSNE, reduction_dim=2, reduction_kwargs={
             "perplexity": perplexity,
-        },
+        }, transform_func=_identity,
+        seed=seed,
+        device=device,
     )
     return x2d, rgb
 
@@ -120,10 +126,10 @@ def rgb_from_tsne_3d(
     num_sample: int = 1000,
     perplexity: int = 150,
     metric: Literal["cosine", "euclidean"] = "cosine",
-    device: str = None,
-    seed: int = 0,
     q: float = 0.95,
     knn: int = 10,
+    seed: int = 0,
+    device: str = None,
 ):
     """
     Returns:
@@ -148,11 +154,13 @@ def rgb_from_tsne_3d(
         num_sample=num_sample,
         metric=metric,
         rgb_func=rgb_from_3d_rgb_cube,
-        q=q, knn=knn,
-        seed=seed, device=device,
+        q=q,
+        knn=knn,
         reduction=TSNE, reduction_dim=3, reduction_kwargs={
             "perplexity": perplexity,
-        },
+        }, transform_func=_identity,
+        seed=seed,
+        device=device,
     )
     return x3d, rgb
 
@@ -161,10 +169,10 @@ def rgb_from_cosine_tsne_3d(
     features: torch.Tensor,
     num_sample: int = 1000,
     perplexity: int = 150,
-    device: str = None,
-    seed: int = 0,
     q: float = 0.95,
     knn: int = 10,
+    seed: int = 0,
+    device: str = None
 ):
     """
     Returns:
@@ -205,11 +213,13 @@ def rgb_from_cosine_tsne_3d(
         num_sample=num_sample,
         metric="cosine",
         rgb_func=rgb_from_cosine,
-        q=q, knn=knn,
-        seed=seed, device=device,
+        q=q,
+        knn=knn,
         reduction=TSNE, reduction_dim=3, reduction_kwargs={
             "perplexity": perplexity,
-        },
+        }, transform_func=_identity,
+        seed=seed,
+        device=device,
     )
     return x3d, rgb
 
@@ -220,10 +230,10 @@ def rgb_from_umap_2d(
     n_neighbors: int = 150,
     min_dist: float = 0.1,
     metric: Literal["cosine", "euclidean"] = "cosine",
-    device: str = None,
-    seed: int = 0,
     q: float = 0.95,
     knn: int = 10,
+    seed: int = 0,
+    device: str = None,
 ):
     """
     Returns:
@@ -240,12 +250,14 @@ def rgb_from_umap_2d(
         num_sample=num_sample,
         metric=metric,
         rgb_func=rgb_from_2d_colormap,
-        q=q, knn=knn,
-        seed=seed, device=device,
+        q=q,
+        knn=knn,
         reduction=UMAP, reduction_dim=2, reduction_kwargs={
             "n_neighbors": n_neighbors,
             "min_dist": min_dist,
-        },
+        }, transform_func=_identity,
+        seed=seed,
+        device=device,
     )
     return x2d, rgb
 
@@ -256,10 +268,10 @@ def rgb_from_umap_sphere(
     n_neighbors: int = 150,
     min_dist: float = 0.1,
     metric: Literal["cosine", "euclidean"] = "cosine",
-    device: str = None,
-    seed: int = 0,
     q: float = 0.95,
     knn: int = 10,
+    seed: int = 0,
+    device: str = None,
 ):
     """
     Returns:
@@ -283,14 +295,15 @@ def rgb_from_umap_sphere(
         num_sample=num_sample,
         metric=metric,
         rgb_func=rgb_from_3d_rgb_cube,
-        q=q, knn=knn,
-        seed=seed, device=device,
+        q=q,
+        knn=knn,
         reduction=UMAP, reduction_dim=2, reduction_kwargs={
             "n_neighbors": n_neighbors,
             "min_dist": min_dist,
             "output_metric": "haversine",
-        },
-        transform_func=transform_func
+        }, transform_func=transform_func,
+        seed=seed,
+        device=device,
     )
     return x3d, rgb
 
@@ -301,10 +314,10 @@ def rgb_from_umap_3d(
     n_neighbors: int = 150,
     min_dist: float = 0.1,
     metric: Literal["cosine", "euclidean"] = "cosine",
-    device: str = None,
-    seed: int = 0,
     q: float = 0.95,
     knn: int = 10,
+    seed: int = 0,
+    device: str = None,
 ):
     """
     Returns:
@@ -321,12 +334,14 @@ def rgb_from_umap_3d(
         num_sample=num_sample,
         metric=metric,
         rgb_func=rgb_from_3d_rgb_cube,
-        q=q, knn=knn,
-        seed=seed, device=device,
+        q=q,
+        knn=knn,
         reduction=UMAP, reduction_dim=3, reduction_kwargs={
             "n_neighbors": n_neighbors,
             "min_dist": min_dist,
-        },
+        }, transform_func=_identity,
+        seed=seed,
+        device=device,
     )
     return x3d, rgb
 

{nystrom_ncut-0.0.8.dist-info → nystrom_ncut-0.0.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nystrom_ncut
-Version: 0.0.8
+Version: 0.0.10
 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.10.dist-info/RECORD

@@ -0,0 +1,14 @@
+__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nystrom_ncut/__init__.py,sha256=JKfF6atok5T9V692RhlhgeRO5a2cN-bfAVa9irmTLfs,463
+nystrom_ncut/common.py,sha256=RMPQvg9R2s7V-q7zAStN9YCZt7gpc5Ut-KSKtvELBQ4,1934
+nystrom_ncut/propagation_utils.py,sha256=WeWKxRBm01ITILMgjsit5_fCe9oW1kJOPmAjjcmliMo,10340
+nystrom_ncut/visualize_utils.py,sha256=Z_bcoxwmWpTxhQ_yoAXqTnYDf269IuT0b0Sm2EVQpRw,17422
+nystrom_ncut/nystrom/__init__.py,sha256=4EpxD3Cmc8Fif4vo8DG-6FpTfCnNanD5zCZxK3WrMwQ,121
+nystrom_ncut/nystrom/distance_realization.py,sha256=8AWUlZKZEPfhQHxYTZt0uzKedVp8ZB1wb__7M2Fy-Eo,5529
+nystrom_ncut/nystrom/normalized_cut.py,sha256=_U3zrbe6V-5TQ4uWmqckxs2JTIhygQlnRDTFBI1ghD4,7194
+nystrom_ncut/nystrom/nystrom.py,sha256=VJPA17I8cVvjILUABJjkVA5kkXbTmHDyrtcWvu5xs-0,12571
+nystrom_ncut-0.0.10.dist-info/LICENSE,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+nystrom_ncut-0.0.10.dist-info/METADATA,sha256=sqs2WHdNbJeT5zvlq_WWHHRvHTz1mHVbDL3PsE1NMBI,6059
+nystrom_ncut-0.0.10.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+nystrom_ncut-0.0.10.dist-info/top_level.txt,sha256=gM8IWWHYysIRTCvCTcdS4RShOyl9pxpylgSwPUZR2XM,22
+nystrom_ncut-0.0.10.dist-info/RECORD,,

{nystrom_ncut-0.0.8.dist-info → nystrom_ncut-0.0.10.dist-info}/top_level.txt

@@ -1 +1,2 @@
+__init__
 nystrom_ncut

nystrom_ncut-0.0.8.dist-info/RECORD

@@ -1,11 +0,0 @@
-nystrom_ncut/__init__.py,sha256=Vlc_iAlfvTNUiJXpZLWUOaL2Q-YqZqgr7WoG6cVnD0g,439
-nystrom_ncut/common.py,sha256=G6w_8_BfBUMc6r8WFgA0NH4K6am7AzZCSdrQEVjra7U,671
-nystrom_ncut/ncut_pytorch.py,sha256=-SKs9AdkafJSGkeYt4LwhbKZr8oq9JA5caAqjiVDAzU,11220
-nystrom_ncut/nystrom.py,sha256=-l26oiJ0oPReSGlMlYV3gftszgFdAAHAi7OFtGPZ4Ic,8802
-nystrom_ncut/propagation_utils.py,sha256=0d2VhT0JrLRurd44hZbnxBvBh-QscPKxtV7VrwYtTdo,11569
-nystrom_ncut/visualize_utils.py,sha256=jDjuyZ9rdd25jqrPObJgK8zCLHc3Oms0fQnaIetHk-U,17112
-nystrom_ncut-0.0.8.dist-info/LICENSE,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
-nystrom_ncut-0.0.8.dist-info/METADATA,sha256=zQpx3REOOckpJSuc7N6UNpXZoqgsM5UoFWV6__DuaRQ,6058
-nystrom_ncut-0.0.8.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-nystrom_ncut-0.0.8.dist-info/top_level.txt,sha256=j7g_j0S048EvguFFnGgD5Ewd3r2H6klsxd5A4dd-wHw,13
-nystrom_ncut-0.0.8.dist-info/RECORD,,