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

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/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/ncut_pytorch.py

@@ -1,9 +1,13 @@
 import logging
-from typing import Literal, Tuple
+from typing import 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/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/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:
@@ -93,7 +98,11 @@ def distance_from_features(
         D = torch.cdist(features, features_B, p=2)
     elif distance == "rbf":
         D = torch.cdist(features, features_B, p=2) ** 2
-        D = D / (2 * features.var(dim=0).sum())
+
+        # Outlier-robust scale invariance using quantiles to estimate standard deviation
+        stds = torch.quantile(features, q=torch.tensor((0.158655, 0.841345), device=features.device), dim=0)
+        stds = (stds[1] - stds[0]) / 2
+        D = D / (2 * torch.linalg.norm(stds) ** 2)
     else:
         raise ValueError("distance should be 'cosine' or 'euclidean', 'rbf'")
     return D
@@ -103,7 +112,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.
 
@@ -131,23 +140,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
@@ -159,121 +168,55 @@ 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
-        # 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)
-
-        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 @ subgraph_output
-        if move_output_to_cpu:
-            _V = _V.cpu()
-        V_list.append(_V)
+    for _v in torch.chunk(extrapolation_features, n_chunks, dim=0):
+        _v = _v.to(device)                                                                              # [_m x d]
 
-    subgraph_output = torch.cat(V_list, dim=0)
-    return subgraph_output
+        _A = affinity_from_features(anchor_features, _v, affinity_focal_gamma, distance).mT             # [_m x n]
+        if knn is not None:
+            _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)                                                              # [_m x k]
+        _V = (_A[:, None, :] @ _anchor_output).squeeze(1)                                               # [_m x d]
 
-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]
         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'
@@ -286,31 +229,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/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,24 @@ 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:
+        features = extrapolate_knn(
+            features,
+            features,
+            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 +60,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 +426,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.6.dist-info → nystrom_ncut-0.0.8.dist-info}/METADATA

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

@@ -0,0 +1,11 @@
+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,,

nystrom_ncut-0.0.6.dist-info/RECORD

@@ -1,11 +0,0 @@
-nystrom_ncut/__init__.py,sha256=Cww-_OsyQHLKpgw_Wh28_tUOvIMMr7Ey8w-tH7v99xQ,452
-nystrom_ncut/common.py,sha256=qdR_JwknT9H1Cv5LopwdwZfORFx-O8MLiRI6ZF1Qohc,558
-nystrom_ncut/ncut_pytorch.py,sha256=wRQXUPBOW2_vutocKf0J19HrFVkBYQePAYUEfotLfx4,11701
-nystrom_ncut/nystrom.py,sha256=HbwON9pLW3gEZvOmbDJwkQNHolOo1EBvwBPeh2p2uJE,8833
-nystrom_ncut/propagation_utils.py,sha256=OCqnv7P9kzDlwqeJzNWpJ3TdTEpk7AD0rJhX8MazZYs,13061
-nystrom_ncut/visualize_utils.py,sha256=QmBatlX7Q-ZWF_iJ1zFDnPHFuofz3tCmtoNeeoMPw3U,18558
-nystrom_ncut-0.0.6.dist-info/LICENSE,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
-nystrom_ncut-0.0.6.dist-info/METADATA,sha256=FD53Ov3g9u4tbBP_Sxxd2hf1yUdg_Hy3ShWq_xGOZFA,6058
-nystrom_ncut-0.0.6.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-nystrom_ncut-0.0.6.dist-info/top_level.txt,sha256=j7g_j0S048EvguFFnGgD5Ewd3r2H6klsxd5A4dd-wHw,13
-nystrom_ncut-0.0.6.dist-info/RECORD,,