sciv 0.0.83__py3-none-any.whl → 0.0.85__py3-none-any.whl

sciv/tool/_algorithm_.py

@@ -14,7 +14,6 @@ from pandas import DataFrame
 
 from ._matrix_ import (
     matrix_dot_block_storage,
-    matrix_operation_memory_efficient,
     vector_multiply_block_storage
 )
 

sciv/tool/_random_walk_.py

@@ -8,6 +8,7 @@ import torch.nn as nn
 
 from torch import Tensor
 from tqdm import tqdm
+from joblib import Parallel, delayed
 
 import numpy as np
 from anndata import AnnData
@@ -24,7 +25,6 @@ from ..util import (
     check_adata_get,
     enrichment_optional,
     check_gpu_availability,
-    dense_data,
     sparse_data
 )
 
@@ -600,72 +600,80 @@ class RandomWalk:
         if init_data is None:
             init_data = self.init_status
 
-        # seed cell threshold
-        seed_cell_count: collection = np.zeros(len(self.trait_list)).astype(int)
-        seed_cell_threshold: collection = np.zeros(len(self.trait_list))
-        seed_cell_weight: matrix_data = np.zeros(self.trs_adata.shape)
-        seed_cell_index: matrix_data = np.zeros(self.trs_adata.shape)
-        seed_cell_weight_en: matrix_data = np.zeros(self.trs_adata.shape)
+        n_traits = len(self.trait_list)
+        n_cells = self.cell_size
+
+        seed_cell_count = np.zeros(n_traits, dtype=int)
+        seed_cell_threshold = np.zeros(n_traits)
+        seed_cell_weight = np.zeros((n_cells, n_traits))
+        seed_cell_index = np.zeros((n_cells, n_traits), dtype=int)
+        seed_cell_weight_en = np.zeros((n_cells, n_traits))
 
         if not self.is_simple:
-            seed_cell_matrix: matrix_data = np.zeros(self.trs_adata.shape)
-            seed_cell_matrix_en: matrix_data = np.zeros(self.trs_adata.shape)
+            seed_cell_matrix = np.zeros((n_cells, n_traits))
+            seed_cell_matrix_en = np.zeros((n_cells, n_traits))
         else:
-            seed_cell_matrix: matrix_data = np.zeros((1, 1))
-            seed_cell_matrix_en: matrix_data = np.zeros((1, 1))
+            seed_cell_matrix = np.zeros((1, 1))
+            seed_cell_matrix_en = np.zeros((1, 1))
 
-        ul.log(__name__).info(f"Calculate {len(self.trait_list)} traits/diseases for seed cells information.{f' ({info})' if info is not None else ''}")
-        for i in tqdm(self.trait_range):
+        ul.log(__name__).info(f"Calculate {n_traits} traits/diseases for seed cells information.{f' ({info})' if info else ''}")
+
+        trait_values_all = to_dense(init_data.X, is_array=True)
+
+        def _process_single_trait(i: int) -> None:
+            trait_value = trait_values_all[:, i]
+            trait_value_max = trait_value.max()
+            trait_value_min = trait_value.min()
+
+            if trait_value_min == trait_value_max:
+                return
+
+            # Directly obtain descending index
+            trait_value_sort_index = np.argpartition(trait_value, -trait_value.size)[::-1]
+
+            # Calculate the number of cells with>0
+            _gt0_cell_size = (trait_value > 0).sum()
+
+            _seed_cell_size = self._get_seed_cell_size_(_gt0_cell_size)
+
+            seed_cell_count[i] = _seed_cell_size
+            seed_cell_threshold[i] = trait_value[trait_value_sort_index[_seed_cell_size]]
 
-            # Obtain all cell score values in a trait
-            trait_adata: AnnData = init_data[:, i]
-            trait_value: collection = to_dense(trait_adata.X, is_array=True).flatten()
-
-            # Obtain the maximum initial score
-            trait_value_max = np.max(trait_value)
-            trait_value_min = np.min(trait_value)
-
-            if trait_value_min != trait_value_max:
-
-                # Obtain a cell count greater than zero
-                trait_value_sort_index = np.argsort(trait_value).astype(int)
-                trait_value_sort_index = trait_value_sort_index[::-1]
-                _gto_cell_index_ = trait_value > 0
-                _gt0_cell_size_ = trait_value[_gto_cell_index_].size
-
-                _seed_cell_size_ = self._get_seed_cell_size_(_gt0_cell_size_)
-
-                seed_cell_count[i] = _seed_cell_size_
-                seed_cell_threshold[i] = trait_value[trait_value_sort_index[_seed_cell_size_]]
-
-                # Set seed cell weights (reduce noise seed cell weights)
-                _seed_cell_index_ = trait_value_sort_index[0:_seed_cell_size_]
-                seed_cell_index[:, i][_seed_cell_index_] = 1
-                seed_cell_weight[:, i][_seed_cell_index_] = self._get_seed_cell_weight_(seed_cell_index=_seed_cell_index_, value=trait_value)
-
-                _enrichment_start_index_: int = _seed_cell_size_
-                _enrichment_end_index_: int = 2 * _seed_cell_size_ if self.cell_size > 2 * _seed_cell_size_ else _seed_cell_size_ - 1
-
-                if _gt0_cell_size_ == _seed_cell_size_:
-                    _enrichment_start_index_ = int(_seed_cell_size_ - self._enrichment_seed_cell_min_count_) if _seed_cell_size_ > self._enrichment_seed_cell_min_count_ else (
-                        (_seed_cell_size_ - 1) if _seed_cell_size_ > 2 else 0)
-                    _enrichment_end_index_ = _seed_cell_size_
-
-                _seed_cell_en_index_ = trait_value_sort_index[_enrichment_start_index_:_enrichment_end_index_]
-                _seed_cell_en_weight_ = self._get_seed_cell_weight_(
-                    seed_cell_index=_seed_cell_index_ if len(_seed_cell_en_index_) == len(_seed_cell_index_) else _seed_cell_en_index_, value=trait_value,
-                    seed_cell_index_enrichment=_seed_cell_en_index_
-                )
-                seed_cell_weight_en[:, i][_seed_cell_en_index_] = _seed_cell_en_weight_
-
-                if not self.is_simple and self.is_ablation:
-                    # Without weight
-                    seed_cell_value = np.zeros(self.cell_size)
-                    seed_cell_value[_seed_cell_index_] = 1
-                    seed_cell_matrix[:, i] = seed_cell_value / (1 if seed_cell_value.sum() == 0 else seed_cell_value.sum())
-                    seed_cell_en_value = np.zeros(self.cell_size)
-                    seed_cell_en_value[_seed_cell_en_index_] = 1
-                    seed_cell_matrix_en[:, i] = seed_cell_en_value / (1 if seed_cell_en_value.sum() == 0 else seed_cell_en_value.sum())
+            # Set seed cell index and weight
+            _seed_cell_index = trait_value_sort_index[:_seed_cell_size]
+            seed_cell_index[_seed_cell_index, i] = 1
+            seed_cell_weight[_seed_cell_index, i] = self._get_seed_cell_weight_(
+                seed_cell_index=_seed_cell_index, value=trait_value
+            )
+
+            # Enrichment interval index
+            _enrichment_start = _seed_cell_size
+            _enrichment_end = min(2 * _seed_cell_size, self.cell_size - 1)
+
+            if _gt0_cell_size == _seed_cell_size:
+                _enrichment_start = max(_seed_cell_size - self._enrichment_seed_cell_min_count_, 0)
+                _enrichment_end = _seed_cell_size
+
+            _seed_cell_en_index = trait_value_sort_index[_enrichment_start:_enrichment_end]
+            seed_cell_weight_en[_seed_cell_en_index, i] = self._get_seed_cell_weight_(
+                seed_cell_index=_seed_cell_index if len(_seed_cell_en_index) == len(_seed_cell_index) else _seed_cell_en_index,
+                value=trait_value,
+                seed_cell_index_enrichment=_seed_cell_en_index
+            )
+
+            if not self.is_simple and self.is_ablation:
+                seed_cell_value = np.zeros(n_cells)
+                seed_cell_value[_seed_cell_index] = 1
+                seed_cell_matrix[:, i] = seed_cell_value / (1 if seed_cell_value.sum() == 0 else seed_cell_value.sum())
+
+                seed_cell_en_value = np.zeros(n_cells)
+                seed_cell_en_value[_seed_cell_en_index] = 1
+                seed_cell_matrix_en[:, i] = seed_cell_en_value / (1 if seed_cell_en_value.sum() == 0 else seed_cell_en_value.sum())
+
+        # Parallel processing of all traits and real-time display of progress
+        Parallel(n_jobs=-1, backend="threading")(
+            delayed(_process_single_trait)(i) for i in tqdm(self.trait_range, desc="Obtain progress of seed cells with weights")
+        )
 
         return seed_cell_count, seed_cell_threshold, seed_cell_matrix, seed_cell_weight, seed_cell_index, seed_cell_matrix_en, seed_cell_weight_en
 

{sciv-0.0.83.dist-info → sciv-0.0.85.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sciv
-Version: 0.0.83
+Version: 0.0.85
 Summary: Unveiling the pivotal cell types involved in variant function regulation at a single-cell resolution
 Project-URL: github, https://github.com/YuZhengM/sciv
 Author-email: Zheng-Min Yu <yuzmbio@163.com>

{sciv-0.0.83.dist-info → sciv-0.0.85.dist-info}/RECORD

@@ -27,13 +27,13 @@ sciv/preprocessing/_scanpy_.py,sha256=mmkk4cMCzJCziF49RnOuXBiF4frS6aSiwZdUmfDAg4
 sciv/preprocessing/_scvi_.py,sha256=ZIDkQ_4deYmzSMiAbu5C3j_jMMl7hBTFLCBXHCNj3B4,10332
 sciv/preprocessing/_snapatac_.py,sha256=Dq8CHF7Psl3CQszaEokQYO56Oe2uzyWOy_cGlaOywfc,27798
 sciv/tool/__init__.py,sha256=WXzHkWt6RgBC3qqD-98nR5wQmt6oC850ox_VpMrapSU,2468
-sciv/tool/_algorithm_.py,sha256=6xLGB1-FRfRiHSCVb_tHvzY_N-RoMZ79p0O2fEio688,48030
+sciv/tool/_algorithm_.py,sha256=okGpH2OrBTO59LkyznT4gRi5S45oAcnO10Kxo5Xzy4I,47991
 sciv/tool/_matrix_.py,sha256=O1EAhA9wxh06P_eOxEBesK7kO7IExKlhH6uJzGh1HBM,24322
-sciv/tool/_random_walk_.py,sha256=E6QxZWXc1FY6rr0EiBNzX7TA5h9NFjt9YjpI_M4wN34,47567
+sciv/tool/_random_walk_.py,sha256=PyVz11dA0rfbYyGYw3WE9BH9KiTUSRHsNDf1J-wfIn0,47156
 sciv/util/__init__.py,sha256=nOxZ8if27X7AUJ6hZwTwxOJwIBJb0obWlHjqCzjg_Gc,1964
 sciv/util/_constant_.py,sha256=w0wKQd8guLd1ZTW24_5aECrWsIWDiNQmEpLsWlHar1A,3000
 sciv/util/_core_.py,sha256=ZD2uSnEBHVu0i9TmXWzri_3bXZzYKnIZk818gW3zadE,14751
-sciv-0.0.83.dist-info/METADATA,sha256=M5efcCSMDCUU4-8C8CVEQ2fpJw__3ltHPDU2LyYxj9Q,3465
-sciv-0.0.83.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-sciv-0.0.83.dist-info/licenses/LICENSE,sha256=4UvHVf3qCOZjHLs4LkYz8u96XRpXnZrpTKrkUQPs5_A,1075
-sciv-0.0.83.dist-info/RECORD,,
+sciv-0.0.85.dist-info/METADATA,sha256=wJDwU4Oks-klm0j2Lg0TyoV7gqF_Gn0JwKa7_c3iCGA,3465
+sciv-0.0.85.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+sciv-0.0.85.dist-info/licenses/LICENSE,sha256=4UvHVf3qCOZjHLs4LkYz8u96XRpXnZrpTKrkUQPs5_A,1075
+sciv-0.0.85.dist-info/RECORD,,