nystrom-ncut 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

nystrom_ncut/nystrom/distance_realization.py

@@ -128,9 +128,9 @@ class DistanceRealization(OnlineNystromSubsampleFit):
         features: torch.Tensor,
         precomputed_sampled_indices: torch.Tensor = None,
     ) -> torch.Tensor:
-        V, L = OnlineNystromSubsampleFit.fit_transform(self, features, precomputed_sampled_indices)
-        return V * (L ** 0.5)
+        V = OnlineNystromSubsampleFit.fit_transform(self, features, precomputed_sampled_indices)
+        return V * (self.eigenvalues_ ** 0.5)
 
     def transform(self, features: torch.Tensor = None) -> torch.Tensor:
-        V, L = OnlineNystromSubsampleFit.transform(self, features)
-        return V * (L ** 0.5)
+        V = OnlineNystromSubsampleFit.transform(self, features)
+        return V * (self.eigenvalues_ ** 0.5)

nystrom_ncut/nystrom/nystrom_utils.py

@@ -20,7 +20,7 @@ EigSolverOptions = Literal["svd_lowrank", "lobpcg", "svd", "eigh"]
 
 
 class OnlineKernel:
-    def fit(self, features: torch.Tensor) -> None:                          # [n x d]
+    def fit(self, features: torch.Tensor) -> "OnlineKernel":                # [n x d]
         raise NotImplementedError()
 
     def update(self, features: torch.Tensor) -> torch.Tensor:               # [m x d] -> [m x n]
@@ -47,7 +47,6 @@ class OnlineNystrom:
         self.n_components: int = n_components
         self.kernel: OnlineKernel = kernel
         self.eig_solver: EigSolverOptions = eig_solver
-        self.inverse_approximation_dim: int = None
 
         self.chunk_size = chunk_size
 
@@ -61,13 +60,13 @@ class OnlineNystrom:
         # Updated matrices
         self.S: torch.Tensor = None                 # [n x n]
         self.transform_matrix: torch.Tensor = None  # [n x n_components]
-        self.LS: torch.Tensor = None                # [n]
+        self.eigenvalues_: torch.Tensor = None      # [n]
 
-    def _update_to_kernel(self) -> Tuple[torch.Tensor, torch.Tensor]:
+    def _update_to_kernel(self, d: int) -> Tuple[torch.Tensor, torch.Tensor]:
         self.A = self.S = self.kernel.transform()
         U, L = solve_eig(
             self.A,
-            num_eig=self.inverse_approximation_dim,
+            num_eig=d + 1,  # d * (d + 3) // 2 + 1,
             eig_solver=self.eig_solver,
         )                                                                                           # [n x (? + 1)], [? + 1]
         self.Ahinv_UL = U * (L ** -0.5)                                                             # [n x (? + 1)]
@@ -75,57 +74,57 @@ class OnlineNystrom:
         self.Ahinv = self.Ahinv_UL @ self.Ahinv_VT                                                  # [n x n]
         return U, L
 
-    def fit(self, features: torch.Tensor):
+    def fit(self, features: torch.Tensor) -> "OnlineNystrom":
         OnlineNystrom.fit_transform(self, features)
         return self
 
-    def fit_transform(self, features: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+    def fit_transform(self, features: torch.Tensor) -> torch.Tensor:
         self.anchor_features = features
 
         self.kernel.fit(self.anchor_features)
-        self.inverse_approximation_dim = max(self.n_components, features.shape[-1] + 1)
-        U, L = self._update_to_kernel()                                                             # [n x (? + 1)], [? + 1]
+        U, L = self._update_to_kernel(features.shape[-1])                                           # [n x (d + 1)], [d + 1]
 
         self.transform_matrix = (U / L)[:, :self.n_components]                                      # [n x n_components]
-        self.LS = L[:self.n_components]                                                             # [n_components]
-        return U[:, :self.n_components], L[:self.n_components]                                      # [n x n_components], [n_components]
+        self.eigenvalues_ = L[:self.n_components]                                                   # [n_components]
+        return U[:, :self.n_components]                                                             # [n x n_components]
 
-    def update(self, features: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+    def update(self, features: torch.Tensor) -> torch.Tensor:
+        d = features.shape[-1]
         n_chunks = ceildiv(len(features), self.chunk_size)
         if n_chunks > 1:
             """ Chunked version """
             chunks = torch.chunk(features, n_chunks, dim=0)
             for chunk in chunks:
                 self.kernel.update(chunk)
-            self._update_to_kernel()
+            self._update_to_kernel(d)
 
-            compressed_BBT = torch.zeros((self.inverse_approximation_dim, self.inverse_approximation_dim))  # [(? + 1) x (? + 1))]
-            for i, chunk in enumerate(chunks):
-                _B = self.kernel.transform(chunk).mT                                                    # [n x _m]
-                _compressed_B = self.Ahinv_VT @ _B                                                      # [(? + 1) x _m]
-                compressed_BBT = compressed_BBT + _compressed_B @ _compressed_B.mT                      # [(? + 1) x (? + 1)]
-            self.S = self.S + self.Ahinv_UL @ compressed_BBT @ self.Ahinv_UL.mT                         # [n x n]
-            US, self.LS = solve_eig(self.S, self.n_components, self.eig_solver)                         # [n x n_components], [n_components]
-            self.transform_matrix = self.Ahinv @ US * (self.LS ** -0.5)                                 # [n x n_components]
+            compressed_BBT = 0.0                                                                    # [(? + 1) x (? + 1))]
+            for chunk in chunks:
+                _B = self.kernel.transform(chunk).mT                                                # [n x _m]
+                _compressed_B = self.Ahinv_VT @ _B                                                  # [(? + 1) x _m]
+                compressed_BBT = compressed_BBT + _compressed_B @ _compressed_B.mT                  # [(? + 1) x (? + 1)]
+            self.S = self.S + self.Ahinv_UL @ compressed_BBT @ self.Ahinv_UL.mT                     # [n x n]
+            US, self.eigenvalues_ = solve_eig(self.S, self.n_components, self.eig_solver)           # [n x n_components], [n_components]
+            self.transform_matrix = self.Ahinv @ US * (self.eigenvalues_ ** -0.5)                   # [n x n_components]
 
             VS = []
             for chunk in chunks:
-                VS.append(self.kernel.transform(chunk) @ self.transform_matrix)                         # [_m x n_components]
+                VS.append(self.kernel.transform(chunk) @ self.transform_matrix)                     # [_m x n_components]
             VS = torch.cat(VS, dim=0)
-            return VS, self.LS                                                                          # [m x n_components], [n_components]
+            return VS                                                                               # [m x n_components]
         else:
             """ Unchunked version """
-            B = self.kernel.update(features).mT                                                         # [n x m]
-            self._update_to_kernel()
-            compressed_B = self.Ahinv_VT @ B                                                            # [indirect_pca_dim x m]
+            B = self.kernel.update(features).mT                                                     # [n x m]
+            self._update_to_kernel(d)
+            compressed_B = self.Ahinv_VT @ B                                                        # [indirect_pca_dim x m]
 
-            self.S = self.S + self.Ahinv_UL @ (compressed_B @ compressed_B.mT) @ self.Ahinv_UL.mT       # [n x n]
-            US, self.LS = solve_eig(self.S, self.n_components, self.eig_solver)                         # [n x n_components], [n_components]
-            self.transform_matrix = self.Ahinv @ US * (self.LS ** -0.5)                                 # [n x n_components]
+            self.S = self.S + self.Ahinv_UL @ (compressed_B @ compressed_B.mT) @ self.Ahinv_UL.mT   # [n x n]
+            US, self.eigenvalues_ = solve_eig(self.S, self.n_components, self.eig_solver)           # [n x n_components], [n_components]
+            self.transform_matrix = self.Ahinv @ US * (self.eigenvalues_ ** -0.5)                   # [n x n_components]
 
-            return B.mT @ self.transform_matrix, self.LS                                                # [m x n_components], [n_components]
+            return B.mT @ self.transform_matrix                                                     # [m x n_components]
 
-    def transform(self, features: torch.Tensor = None) -> Tuple[torch.Tensor, torch.Tensor]:
+    def transform(self, features: torch.Tensor = None) -> torch.Tensor:
         if features is None:
             VS = self.A @ self.transform_matrix                                                     # [n x n_components]
         else:
@@ -135,12 +134,12 @@ class OnlineNystrom:
                 chunks = torch.chunk(features, n_chunks, dim=0)
                 VS = []
                 for chunk in chunks:
-                    VS.append(self.kernel.transform(chunk) @ self.transform_matrix)                     # [_m x n_components]
+                    VS.append(self.kernel.transform(chunk) @ self.transform_matrix)                 # [_m x n_components]
                 VS = torch.cat(VS, dim=0)
             else:
                 """ Unchunked version """
-                VS = self.kernel.transform(features) @ self.transform_matrix                            # [m x n_components]
-        return VS, self.LS                                                                          # [m x n_components], [n_components]
+                VS = self.kernel.transform(features) @ self.transform_matrix                        # [m x n_components]
+        return VS                                                                                   # [m x n_components]
 
 
 class OnlineNystromSubsampleFit(OnlineNystrom):
@@ -192,7 +191,7 @@ class OnlineNystromSubsampleFit(OnlineNystrom):
         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)
+            V_unsampled = OnlineNystrom.update(self, unsampled_features)
         else:
             unsampled_indices = V_unsampled = None
         return unsampled_indices, V_unsampled
@@ -201,7 +200,7 @@ class OnlineNystromSubsampleFit(OnlineNystrom):
         self,
         features: torch.Tensor,
         precomputed_sampled_indices: torch.Tensor = None,
-    ):
+    ) -> "OnlineNystromSubsampleFit":
         """Fit Nystrom Normalized Cut on the input features.
         Args:
             features (torch.Tensor): input features, shape (n_samples, n_features)
@@ -217,7 +216,7 @@ class OnlineNystromSubsampleFit(OnlineNystrom):
         self,
         features: torch.Tensor,
         precomputed_sampled_indices: torch.Tensor = None,
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
+    ) -> torch.Tensor:
         """
         Args:
             features (torch.Tensor): input features, shape (n_samples, n_features)
@@ -229,7 +228,7 @@ class OnlineNystromSubsampleFit(OnlineNystrom):
             (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)
+        V_sampled = OnlineNystrom.transform(self)
 
         if unsampled_indices is not None:
             V = torch.zeros((len(unsampled_indices), self.n_components), device=features.device)
@@ -237,7 +236,7 @@ class OnlineNystromSubsampleFit(OnlineNystrom):
             V[unsampled_indices] = V_unsampled
         else:
             V = V_sampled
-        return V, L
+        return V
 
 
 def solve_eig(

nystrom_ncut/visualize_utils.py

@@ -179,14 +179,13 @@ def _rgb_with_dimensionality_reduction(
     )
 
     _inp = features[subgraph_indices].numpy(force=True)
-    _subgraph_embed = reduction(
+    _subgraph_embed = torch.tensor(reduction(
         n_components=reduction_dim,
         metric=disttype,
         random_state=seed,
         **reduction_kwargs
-    ).fit_transform(_inp)
+    ).fit_transform(_inp), device=features.device, dtype=features.dtype)
 
-    _subgraph_embed = torch.tensor(_subgraph_embed, dtype=torch.float32)
     rgb = rgb_func(extrapolate_knn(
         features[subgraph_indices],
         _subgraph_embed,

{nystrom_ncut-0.1.5.dist-info → nystrom_ncut-0.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nystrom_ncut
-Version: 0.1.5
+Version: 0.1.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.1.5.dist-info → nystrom_ncut-0.1.7.dist-info}/RECORD

@@ -3,13 +3,13 @@ nystrom_ncut/__init__.py,sha256=HifrTcqX2-hYjBDe6xIThHvuIBYMPBA3EzjR8-qPMUM,512
 nystrom_ncut/common.py,sha256=_PGJoImSk_Fb_5Ri-e_IsFoCcSfbGS8CxYUUHVoNM50,2036
 nystrom_ncut/distance_utils.py,sha256=p-pYdpRrJsIhzxM_IxUqja7N8okngx52WGXD9pu_Aec,3129
 nystrom_ncut/sampling_utils.py,sha256=oMmhFcd_N_D15Ht7F0rCGPSgLeitJszAKMD3ICKwHNU,3105
-nystrom_ncut/visualize_utils.py,sha256=RsQVjPhxoIdxDOQ2PI7ifFDuEL23YXpZBdJ0wjjafek,22970
+nystrom_ncut/visualize_utils.py,sha256=_J6YjWUsBe0VqW6KXsQx_iPmRCcO-ie0g6t5mD289UI,22957
 nystrom_ncut/nystrom/__init__.py,sha256=4EpxD3Cmc8Fif4vo8DG-6FpTfCnNanD5zCZxK3WrMwQ,121
-nystrom_ncut/nystrom/distance_realization.py,sha256=YaKEzuiiJfS6tdOTuJ4Ce1jqOWIfrVGb8ilvhzKeW9w,5789
+nystrom_ncut/nystrom/distance_realization.py,sha256=InajllGtRVnLVlZoipZNbHFTGHaTs3zxizKe3kI2Los,5815
 nystrom_ncut/nystrom/normalized_cut.py,sha256=N-M5wkTo59vpbBfIx8evkSQBxlo4j80qCtuoifxQa_A,7578
-nystrom_ncut/nystrom/nystrom_utils.py,sha256=Wq364xlxBhr74lqyCkPWLBxq5YSt2zr-DSfYUHpYfgE,12989
-nystrom_ncut-0.1.5.dist-info/LICENSE,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
-nystrom_ncut-0.1.5.dist-info/METADATA,sha256=7gO_GxpjbitbEBB9juaha7W4e7SWs-hYqgkYfaGmuIg,6058
-nystrom_ncut-0.1.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-nystrom_ncut-0.1.5.dist-info/top_level.txt,sha256=gM8IWWHYysIRTCvCTcdS4RShOyl9pxpylgSwPUZR2XM,22
-nystrom_ncut-0.1.5.dist-info/RECORD,,
+nystrom_ncut/nystrom/nystrom_utils.py,sha256=UVs1tC7vnVq2mWSTpcrP4C19x9wDJ77ACht0EltOO2E,12698
+nystrom_ncut-0.1.7.dist-info/LICENSE,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+nystrom_ncut-0.1.7.dist-info/METADATA,sha256=eb0Q6bwCKC4c5bcuJI_PnIaPW5qFYGSgwbPeuWI7EUk,6058
+nystrom_ncut-0.1.7.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+nystrom_ncut-0.1.7.dist-info/top_level.txt,sha256=gM8IWWHYysIRTCvCTcdS4RShOyl9pxpylgSwPUZR2XM,22
+nystrom_ncut-0.1.7.dist-info/RECORD,,