SURE-tools 2.1.8__py3-none-any.whl → 2.1.10__py3-none-any.whl

SURE/flow/__init__.py

@@ -1,2 +1,2 @@
 from .plot_quiver import plot_quiver
-from .flow_stats import calculate_direction_stats,calculate_movement_stats,calculate_movement_energy,calculate_movement_divergence
+from .flow_stats import calculate_direction_stats,calculate_movement_stats,calculate_movement_energy,calculate_movement_divergence,VectorFieldEval

SURE/flow/flow_stats.py

@@ -1,6 +1,34 @@
 import numpy as np
 from scipy.spatial.distance import pdist, squareform
+from sklearn.decomposition import PCA
+from scipy.stats import pearsonr
+from sklearn.neighbors import NearestNeighbors
 
+class VectorFieldEval:
+    def __init__(self):
+        pass 
+    
+    def directional_alignment(self, vectors, weighted=False):
+        if weighted:
+            return weighted_alignment(vectors=vectors)
+        else:
+            return directional_alignment(vectors=vectors)
+        
+    def flow_coherence(self, vectors, pca=False):
+        if pca:
+            return pca_based_coherence(vectors=vectors)
+        else:
+            return flow_coherence_index(vectors=vectors)
+        
+    def momentum_flow_metric(self, vectors, masses=None):
+        return momentum_flow_metric(vectors=vectors, masses=masses)
+            
+    def multi_scale_coherence(self, vectors, positoins, scale_factors=[1.0, 0.5, 0.1]):
+        return multi_scale_coherence(vectors=vectors, positions=positoins, scale_factors=scale_factors)
+    
+    def vector_field_coherence_score(self, vectors, positions=None, weights=None):
+        return vector_field_coherence_score(vectors=vectors, positions=positions, weights=weights)
+        
 def calculate_movement_stats(vectors):
     """
     计算移动矢量的基本统计量
@@ -75,4 +103,196 @@ def calculate_movement_divergence(positions, vectors):
     return {
         'volume_expansion': volume_ratio,  # >1扩张, <1收缩
         'expansion_factor': volume_ratio**(1/positions.shape[1])
-    }
+    }
+    
+
+def directional_alignment(vectors):
+    """
+    计算向量场的方向一致性
+    返回值: 0-1之间，1表示完全一致
+    """
+    # 归一化向量
+    norms = np.linalg.norm(vectors, axis=1, keepdims=True)
+    unit_vectors = vectors / (norms + 1e-8)  # 避免除零
+    
+    # 计算平均方向向量
+    mean_direction = np.mean(unit_vectors, axis=0)
+    mean_direction_norm = np.linalg.norm(mean_direction)
+    
+    return mean_direction_norm
+
+def weighted_alignment(vectors):
+    """
+    根据移动强度加权的方向一致性
+    """
+    norms = np.linalg.norm(vectors, axis=1)
+    unit_vectors = vectors / norms[:, np.newaxis]
+    
+    # 用移动强度加权
+    weights = norms / np.sum(norms)
+    weighted_mean = np.sum(unit_vectors * weights[:, np.newaxis], axis=0)
+    
+    return np.linalg.norm(weighted_mean)
+
+
+def flow_coherence_index(vectors, alpha=0.5):
+    """
+    流动一致性指数：综合方向和强度
+    Args:
+        alpha: 方向权重 (0-1)，强度权重为 1-alpha
+    Returns:
+        0-1之间的值，越大表示越一致的大规模移动
+    """
+    # 1. 方向一致性成分
+    norms = np.linalg.norm(vectors, axis=1)
+    unit_vectors = vectors / norms[:, np.newaxis]
+    direction_consistency = np.linalg.norm(np.mean(unit_vectors, axis=0))
+    
+    # 2. 移动强度成分（标准化）
+    intensity = np.mean(norms) / (np.std(norms) + 1e-8)  # 均值/标准差
+    normalized_intensity = 1 - np.exp(-intensity)  # 映射到0-1
+    
+    # 3. 综合指标
+    fci = alpha * direction_consistency + (1 - alpha) * normalized_intensity
+    return fci, direction_consistency, normalized_intensity
+
+
+def pca_based_coherence(vectors):
+    """
+    基于PCA的流动一致性分析
+    """    
+    # 计算协方差矩阵的特征值
+    cov_matrix = np.cov(vectors.T)
+    eigenvalues = np.linalg.eigvals(cov_matrix)
+    eigenvalues = np.sort(eigenvalues)[::-1]  # 降序排列
+    
+    # 第一主成分解释的方差比例
+    explained_variance_ratio = eigenvalues[0] / np.sum(eigenvalues)
+    
+    # 方向一致性（第一主成分的方向重要性）
+    pca = PCA(n_components=1)
+    pca.fit(vectors)
+    principal_component = pca.components_[0]
+    
+    # 计算向量与主成分的夹角一致性
+    unit_vectors = vectors / np.linalg.norm(vectors, axis=1, keepdims=True)
+    cos_similarities = np.abs(np.dot(unit_vectors, principal_component))
+    alignment_with_pc = np.mean(cos_similarities)
+    
+    return explained_variance_ratio, alignment_with_pc
+
+def momentum_flow_metric(vectors, masses=None):
+    """
+    类比物理动量的一致性度量
+    """
+    if masses is None:
+        masses = np.ones(len(vectors))  # 默认单位质量
+    
+    # 计算总动量
+    momenta = vectors * masses[:, np.newaxis]  # p = m*v
+    total_momentum = np.sum(momenta, axis=0)
+    
+    # 计算总动能
+    kinetic_energies = 0.5 * masses * np.sum(vectors**2, axis=1)
+    total_energy = np.sum(kinetic_energies)
+    
+    # 一致性指标：总动量大小 / 总能量（类比速度一致性）
+    if total_energy > 0:
+        coherence = np.linalg.norm(total_momentum) / (2 * total_energy) ** 0.5
+    else:
+        coherence = 0
+    
+    # 方向一致性（动量方向与个体方向的平均对齐）
+    if np.linalg.norm(total_momentum) > 0:
+        momentum_direction = total_momentum / np.linalg.norm(total_momentum)
+        unit_vectors = vectors / np.linalg.norm(vectors, axis=1, keepdims=True)
+        directional_alignment = np.mean(np.abs(np.dot(unit_vectors, momentum_direction)))
+    else:
+        directional_alignment = 0
+    
+    return coherence, directional_alignment, np.linalg.norm(total_momentum)
+
+
+
+def multi_scale_coherence(vectors, positions=None, scale_factors=[1.0, 0.5, 0.1]):
+    """
+    多尺度一致性分析：检测不同空间尺度的一致性
+    """
+    if positions is None:
+        positions = np.random.rand(len(vectors), 2)  # 随机位置
+    
+    coherence_scores = []
+    
+    for scale in scale_factors:
+        # 根据空间距离加权
+        if len(positions) > 0:
+            distances = squareform(pdist(positions))
+            weights = np.exp(-distances / scale)  # 距离衰减权重
+            
+            # 计算加权方向一致性
+            unit_vectors = vectors / np.linalg.norm(vectors, axis=1, keepdims=True)
+            weighted_avg = np.zeros_like(unit_vectors[0])
+            
+            for i in range(len(vectors)):
+                neighbor_weights = weights[i] / np.sum(weights[i])
+                weighted_avg += np.sum(unit_vectors * neighbor_weights[:, np.newaxis], axis=0)
+            
+            scale_coherence = np.linalg.norm(weighted_avg) / len(vectors)
+            coherence_scores.append(scale_coherence)
+        else:
+            coherence_scores.append(directional_alignment(vectors))
+    
+    return dict(zip(scale_factors, coherence_scores))
+
+def vector_field_coherence_score(vectors, positions=None, weights=None):
+    """
+    向量场一致性综合评分 (0-100分)
+    """
+    # 1. 基础方向一致性 (0-1)
+    dir_consistency = directional_alignment(vectors)
+    
+    # 2. 移动强度指标
+    magnitudes = np.linalg.norm(vectors, axis=1)
+    intensity_score = np.mean(magnitudes) / (np.std(magnitudes) + 1e-8)
+    intensity_score = min(1.0, intensity_score / 3.0)  # 标准化到0-1
+    
+    # 3. 空间相关性（如果有位置信息）
+    if positions is not None and len(positions) > 10:
+        nbrs = NearestNeighbors(n_neighbors=5).fit(positions)
+        distances, indices = nbrs.kneighbors(positions)
+        
+        neighbor_correlations = []
+        for i, neighbors in enumerate(indices):
+            if len(neighbors) > 1:
+                # 计算与邻居的方向相似度
+                unit_vec = vectors[i] / np.linalg.norm(vectors[i])
+                neighbor_vecs = vectors[neighbors[1:]]  # 排除自身
+                neighbor_units = neighbor_vecs / np.linalg.norm(neighbor_vecs, axis=1, keepdims=True)
+                correlations = np.abs(np.dot(neighbor_units, unit_vec))
+                neighbor_correlations.extend(correlations)
+        
+        spatial_consistency = np.mean(neighbor_correlations) if neighbor_correlations else 0.5
+    else:
+        spatial_consistency = 0.5  # 默认值
+    
+    # 4. 综合评分 (加权平均)
+    weights = weights or [0.4, 0.3, 0.3]  # 方向、强度、空间权重
+    composite_score = (weights[0] * dir_consistency + 
+                      weights[1] * intensity_score + 
+                      weights[2] * spatial_consistency)
+    
+    # 转换为0-100分
+    vfcs = composite_score * 100
+    
+    return {
+        'vfcs': vfcs,
+        'direction_consistency': dir_consistency * 100,
+        'intensity_score': intensity_score * 100,
+        'spatial_consistency': spatial_consistency * 100,
+        'components': {
+            'direction': dir_consistency,
+            'intensity': intensity_score, 
+            'spatial': spatial_consistency
+        }
+    }
+

SURE/perturb/perturb.py

@@ -15,10 +15,12 @@ class LabelMatrix:
             mat, self.labels_ = vectorized_label_to_matrix(labels=labels, sep_pattern=sep_pattern)
         elif speedup=='parallel':
             mat, self.labels_ = parallel_label_to_matrix(labels=labels, sep_pattern=sep_pattern)
+            
+        self.labels_ = np.array(self.labels_)
         return mat
             
     def inverse_transform(self, matrix):
-        matrix_to_labels(matrix=matrix, unique_labels=self.labels_)
+        return matrix_to_labels(matrix=matrix, unique_labels=self.labels_)
         
 def label_to_matrix(labels, sep_pattern=r'[;_\-\s]'):
     """

{sure_tools-2.1.8.dist-info → sure_tools-2.1.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SURE-tools
-Version: 2.1.8
+Version: 2.1.10
 Summary: Succinct Representation of Single Cells
 Home-page: https://github.com/ZengFLab/SURE
 Author: Feng Zeng

{sure_tools-2.1.8.dist-info → sure_tools-2.1.10.dist-info}/RECORD

@@ -9,19 +9,19 @@ SURE/atac/__init__.py,sha256=3smP8IKHfwNCd1G_sZH3pKHXuLkLpFuLtjUTUSy7_As,34
 SURE/atac/utils.py,sha256=m4NYwpy9O5T1pXTzgCOCcmlwrC6GTi-cQ5sm2wZu2O8,4354
 SURE/codebook/__init__.py,sha256=2T5gjp8JIaBayrXAnOJYSebQHsWprOs87difpR1OPNw,243
 SURE/codebook/codebook.py,sha256=ZlN6gRX9Gj2D2u3P5KeOsbZri0MoMAiJo9lNeL-MK-I,17117
-SURE/flow/__init__.py,sha256=eIcHeeISEOXEB0zRW-uiRlDz5IEUbA7rZZ1htUxhLVU,167
-SURE/flow/flow_stats.py,sha256=wpIxmOpYPU7YcgxqXKS8EDmnZ3oGh-YdBjiBiEmHcoU,2360
+SURE/flow/__init__.py,sha256=rsAjYsh1xVIrxBCuwOE0Q_6N5th1wBgjJceV0ABPG3c,183
+SURE/flow/flow_stats.py,sha256=3F3waCuEbIQ7bsiGga4cUvJphYdWA307SyGwEh8EzM8,10514
 SURE/flow/plot_quiver.py,sha256=spcPC0BDpvC-FBk9XIu6rcJI64bS-U-IVmmKLYHHXgs,1865
 SURE/flow/quiver.py,sha256=_euFqSaRrDoZ_oOabOx20LOoUTJ__XPhLW-vzLNQfAo,1859
 SURE/perturb/__init__.py,sha256=ouxShhbxZM4r5Gf7GmKiutrsmtyq7QL8rHjhgF0BU08,32
-SURE/perturb/perturb.py,sha256=LhrQSZEka7GFc9x4YfMhzHEYE-oHWwDg5tlhIRXVtGg,3237
+SURE/perturb/perturb.py,sha256=CqO3xPfNA3cG175tadDidKvGsTu_yKfJRRLn_93awKM,3303
 SURE/utils/__init__.py,sha256=Htqv4KqVKcRiaaTBsR-6yZ4LSlbhbzutjNKXGD9-uds,660
 SURE/utils/custom_mlp.py,sha256=07TYX1HgxfEjb_3i5MpiZfNhOhx3dKntuwGkrpteWiM,7036
 SURE/utils/queue.py,sha256=E_5PA5EWcBoGAZj8BkKQnkCK0p4C-4-xcTPqdIXaPXU,1892
 SURE/utils/utils.py,sha256=IUHjDDtYaAYllCWsZyIzqQwaLul6fJRvHRH4vIYcR-c,8462
-sure_tools-2.1.8.dist-info/licenses/LICENSE,sha256=TFHKwmrAViXQbSX5W-NDItkWFjm45HWOeUniDrqmnu0,1065
-sure_tools-2.1.8.dist-info/METADATA,sha256=DJqLBtteAneDszgl4HiVf-Fucqzn9thAXoXzPq6b6_Y,2650
-sure_tools-2.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sure_tools-2.1.8.dist-info/entry_points.txt,sha256=-nJI8rVe_qqrR0HmfAODzj-JNfEqCcSsyVh6okSqyHk,83
-sure_tools-2.1.8.dist-info/top_level.txt,sha256=BtFTebdiJeqra4r6mm-uEtwVRFLZ_IjYsQ7OnalrOvY,5
-sure_tools-2.1.8.dist-info/RECORD,,
+sure_tools-2.1.10.dist-info/licenses/LICENSE,sha256=TFHKwmrAViXQbSX5W-NDItkWFjm45HWOeUniDrqmnu0,1065
+sure_tools-2.1.10.dist-info/METADATA,sha256=2KG05qwCqT3IfABXzhHK2_h0mjgUmVpOYw1mwy078MU,2651
+sure_tools-2.1.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sure_tools-2.1.10.dist-info/entry_points.txt,sha256=-nJI8rVe_qqrR0HmfAODzj-JNfEqCcSsyVh6okSqyHk,83
+sure_tools-2.1.10.dist-info/top_level.txt,sha256=BtFTebdiJeqra4r6mm-uEtwVRFLZ_IjYsQ7OnalrOvY,5
+sure_tools-2.1.10.dist-info/RECORD,,