nystrom-ncut 0.0.8__tar.gz → 0.0.9__tar.gz

{nystrom_ncut-0.0.8/src/nystrom_ncut.egg-info → nystrom_ncut-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nystrom_ncut
-Version: 0.0.8
+Version: 0.0.9
 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 → nystrom_ncut-0.0.9}/pyproject.toml

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

nystrom_ncut-0.0.9/src/nystrom_ncut/common.py

@@ -0,0 +1,61 @@
+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)
+
+
+def lazy_normalize(x: torch.Tensor, n: int = 1000, **normalize_kwargs: Any) -> torch.Tensor:
+    numel = np.prod(x.shape[:-1])
+    n = min(n, numel)
+    random_indices = torch.randperm(numel)[:n]
+    _x = x.flatten(0, -2)[random_indices]
+    if torch.allclose(torch.norm(_x, **normalize_kwargs), torch.ones(n, device=x.device)):
+        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-0.0.8 → nystrom_ncut-0.0.9}/src/nystrom_ncut/nystrom.py

@@ -2,7 +2,9 @@ from typing import Literal, Tuple
 
 import torch
 
-from .common import ceildiv
+from .common import (
+    ceildiv,
+)
 
 
 EigSolverOptions = Literal["svd_lowrank", "lobpcg", "svd", "eigh"]

{nystrom_ncut-0.0.8 → nystrom_ncut-0.0.9}/src/nystrom_ncut/propagation_utils.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Literal
 
 import numpy as np
 import torch
@@ -256,40 +255,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-0.0.8 → nystrom_ncut-0.0.9}/src/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,22 +26,22 @@ 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,
-            features,
-            features,
-            distance="cosine",
-        )
+    features = extrapolate_knn(
+        features,
+        features,
+        features,
+        distance="cosine",
+    )
 
     subgraph_indices = run_subgraph_sampling(
         features,
@@ -78,10 +76,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 +104,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 +120,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 +148,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 +163,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 +207,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 +224,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 +244,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 +262,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 +289,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 +308,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 +328,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 → nystrom_ncut-0.0.9/src/nystrom_ncut.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nystrom_ncut
-Version: 0.0.8
+Version: 0.0.9
 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/src/nystrom_ncut/common.py

@@ -1,24 +0,0 @@
-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)
-
-
-def lazy_normalize(x: torch.Tensor, n: int = 1000, **normalize_kwargs: Any) -> torch.Tensor:
-    numel = np.prod(x.shape[:-1])
-    n = min(n, numel)
-    random_indices = torch.randperm(numel)[:n]
-    _x = x.flatten(0, -2)[random_indices]
-    if torch.allclose(torch.norm(_x, **normalize_kwargs), torch.ones(n, device=x.device)):
-        return x
-    else:
-        return Fn.normalize(x, **normalize_kwargs)