scMultiChat 0.1.0__tar.gz → 0.1.2__tar.gz

{scmultichat-0.1.0 → scmultichat-0.1.2}/MultiChat/Analysis/Intra_strength.py

@@ -272,10 +272,15 @@ def calculate_r_tf_tg_cor(
     receptors: List[str],
     tf_tg_pairs: List[str],
     reg_dir: str = "R_TF_TG_Reg",  
-    output_dir: str = "output_cells_cor"
+    output_dir: str = "output_cells_cor",
+    align_method: str = "pca",
+    target_dim: int = 50
 ) -> Tuple[Dict[str, csr_matrix], csr_matrix]:
     """
-    Get correlation score
+     Get correlation score with automatic feature alignment.
+     
+     If feature dimensions of cell/gene/tf representations do not match,     
+     the function will automatically align them using PCA or truncation.
     """
     os.makedirs(output_dir, exist_ok=True)
     
@@ -294,9 +299,58 @@ def calculate_r_tf_tg_cor(
         tf, tg = pair.split("->")
         parsed_pairs.append((tf, tg, gene_index.get(tg, -1)))
     
+    # print("Precomputing PCC matrices...")
+    # cell_gene_pcc_matrix = 1 - cdist(cell_rep.values, gene_rep.values, metric='correlation')
+    # cell_tf_pcc_matrix = 1 - cdist(cell_rep.values, tf_rep.values, metric='correlation')
+    
+    cell_arr = cell_rep.values
+    gene_arr = gene_rep.values
+    tf_arr = tf_rep.values
+
+    d_cell = cell_arr.shape[1]
+    d_gene = gene_arr.shape[1]
+    d_tf = tf_arr.shape[1]
+
+    print(f"[Info] Original dimensions: cell={d_cell}, gene={d_gene}, tf={d_tf}")
+
+    if not (d_cell == d_gene == d_tf):
+        print("[Info] Feature dimensions are inconsistent!")
+        
+        if align_method == "pca":
+            from sklearn.decomposition import PCA
+
+            new_dim = min(target_dim, d_cell, d_gene, d_tf)
+            print(f"[Info] Applying PCA to align all representations to {new_dim} dimensions.")
+
+            pca = PCA(n_components=new_dim)
+
+            cell_arr = pca.fit_transform(cell_arr)
+            gene_arr = pca.fit_transform(gene_arr)
+            tf_arr = pca.fit_transform(tf_arr)
+
+        elif align_method == "truncate":
+            new_dim = min(d_cell, d_gene, d_tf)
+            print(f"[Info] Truncating all representations to {new_dim} dimensions.")
+
+            cell_arr = cell_arr[:, :new_dim]
+            gene_arr = gene_arr[:, :new_dim]
+            tf_arr = tf_arr[:, :new_dim]
+
+        else:
+            raise ValueError("align_method must be 'pca' or 'truncate'")
+
+    else:
+        print("[Info] Feature dimensions are already aligned. No processing needed.")
+
+    print(f"[Info] Final aligned dimension: {cell_arr.shape[1]}")
+
+    # ===============================
+    # PCC computation
+    # ===============================
     print("Precomputing PCC matrices...")
-    cell_gene_pcc_matrix = 1 - cdist(cell_rep.values, gene_rep.values, metric='correlation')
-    cell_tf_pcc_matrix = 1 - cdist(cell_rep.values, tf_rep.values, metric='correlation')
+    cell_gene_pcc_matrix = 1 - cdist(cell_arr, gene_arr, metric='correlation')
+    cell_tf_pcc_matrix = 1 - cdist(cell_arr, tf_arr, metric='correlation')
+    
     cell_gene_pcc_matrix = np.abs(cell_gene_pcc_matrix)  
     cell_tf_pcc_matrix = np.abs(cell_tf_pcc_matrix)      
     
@@ -1755,4 +1809,221 @@ def Identify_concat_paths_celltype(sig_LR_pair_celltype,vola_LR_pair_celltype,ou
     
     sig_LR_pair_celltype_updated.to_csv(out_path, sep=",", index=False)
     print(f"sig_Path_pair_celltype_updated saved to {out_path}")
-    return sig_LR_pair_celltype_updated
+    return sig_LR_pair_celltype_updated
+
+
+def sig_LR_with_source_target(base_path,db,cell_type):
+    
+    ligand_unique = db['Ligand_Symbol'].unique()
+
+    to_lst = []
+    path_lst = []
+    comm_score_lst = []
+    z_score_lst = []
+    from_lst = []
+    source_lst = []
+    target_lst = []
+    
+    sig_df = pd.read_csv(base_path+f'CCC/Significant_LRs.csv', index_col=None)
+    Nei_adj = pd.read_csv(f'{base_path}CCC/Nei_adj.csv', index_col=None, header=None, sep='\t')
+    rna_smooth = pd.read_csv(base_path+ f'CCC/expression_smooth.txt', index_col=0, sep='\t')
+    Nei_adj_type = Nei_adj.copy()     
+    
+    for idx, row in sig_df.iterrows():
+        lr_symbol = row['LR_Symbol']
+        lig, rec = lr_symbol.split('->')
+        Nei_adj_cur = Nei_adj_type.copy()
+        
+        Nei_adj_cur.index = cell_type.index     
+        Nei_adj_cur = pd.concat([cell_type, Nei_adj_cur], axis=1)
+        to_cell = row['Sample_Name']
+        if to_cell not in Nei_adj_cur.index:
+            continue
+        from_cell_lst = Nei_adj_cur.index[Nei_adj_cur.loc[to_cell][1:-1].to_list()].to_list()
+        for from_cell in from_cell_lst:
+            if pd.isna(from_cell) or from_cell not in rna_smooth.columns:
+                continue
+            if lig in rna_smooth.index:
+                lig_exp = rna_smooth.loc[lig, from_cell]
+                if lig_exp > 0:
+                    to_lst.append(to_cell)
+                    path_lst.append(row['LR_Symbol'])
+                    comm_score_lst.append(row['Inter_Score'])
+                    z_score_lst.append(row['Z_Score'])
+                    from_lst.append(from_cell)
+                    source_lst.append(Nei_adj_cur.loc[from_cell]['cell_type'])
+                    target_lst.append(Nei_adj_cur.loc[to_cell]['cell_type'])
+
+    results_df = pd.DataFrame({
+        'from_cell': from_lst,
+        'to_cell': to_lst,
+        'source': source_lst,
+        'target': target_lst,
+        'path_symbol': path_lst,
+        'comm_score': comm_score_lst,
+        'z_score': z_score_lst
+    })
+    results_df.to_csv(os.path.join(base_path, f'CCC/Significant_LRs_res.csv'), index=False)
+    print(f"Saved results for Significant_LRs to {os.path.join(base_path, f'CCC/Significant_LRs_res.csv')}, shape: {results_df.shape}")
+    
+    
+def Identify_significant_lr_pairs_celltypes(sif_df, agg_method='mean', min_cells_count=10):
+    if not isinstance(sif_df, pd.DataFrame):
+        raise ValueError("input needs to be pandas DataFrame")
+    
+    required_cols = ['path_symbol', 'source', 'target', 'comm_score', 'z_score']
+    missing = set(required_cols) - set(sif_df.columns)
+    if missing:
+        raise ValueError(f"sif_df is missing required columns: {missing}")
+    
+    group_cols = ['path_symbol', 'source', 'target']
+    count_df = sif_df.groupby(group_cols).size().reset_index(name='cells_count')
+    valid_groups = count_df[count_df['cells_count'] >= min_cells_count]
+    
+    sig_df_filtered = sif_df.merge(
+        valid_groups[group_cols],
+        on=group_cols,
+        how='inner'
+    )
+    
+    result_df = (sig_df_filtered.groupby(group_cols).agg({
+        'comm_score': agg_method,
+        'z_score': agg_method
+    }).reset_index())
+    
+    result_df = result_df.rename(columns={'path_symbol': 'LR_Symbol',
+                                          'source': 'Source_Type',
+                                          'target': 'Target_Type',
+                                          'comm_score': 'Comm_Score',
+                                          'z_score': 'Z_Score'})
+    return result_df
+
+
+def sig_path_with_source_target(base_path,db, cell_type):
+    ligand_unique = db['Ligand_Symbol'].unique()
+    to_lst = []
+    path_lst = []
+    comm_score_lst = []
+    z_score_lst = []
+    from_lst = []
+    source_lst = []
+    target_lst = []
+    
+    cell_type = pd.read_csv('/home/nas2/biod/zhencaiwei/RegChatz_V2/Datasets/ISSAAC/inputs/celltype_info.csv', index_col=0, sep="\t")     
+    cell_type.rename(columns={'celltype': 'cell_type'}, inplace=True)     
+    Nei_adj = pd.read_csv(f'{base_path}CCC/Nei_adj.csv', index_col=None, header=None, sep='\t')
+    
+    Nei_adj_type = Nei_adj.copy()
+    Nei_adj_type.index = cell_type.index
+    Nei_adj_type = pd.concat([cell_type, Nei_adj_type], axis=1)
+    
+    for ligand in tqdm(ligand_unique, desc="Processing ligands"):
+        sig_path_file = base_path+'CCC/Stats_results_Lig/Significant_paths_'+ligand+'.csv'
+        if not os.path.exists(sig_path_file):
+            print(f"Warning: File not found - {sig_path_file}")
+            continue
+        sig_df = pd.read_csv(sig_path_file, index_col=None)
+        for idx, row in sig_df.iterrows():
+            to_cell = row['Sample_Name']
+            from_cell_lst = Nei_adj_type.index[Nei_adj_type.loc[to_cell][1:-1].to_list()].to_list()
+            for from_cell in from_cell_lst:
+                to_lst.append(to_cell)
+                path_lst.append(row['Path_Symbol'])
+                comm_score_lst.append(row['Comm_Score'])
+                z_score_lst.append(row['Z_Score'])
+                from_lst.append(from_cell)
+                source_lst.append(Nei_adj_type.loc[from_cell]['cell_type'])
+                target_lst.append(Nei_adj_type.loc[to_cell]['cell_type'])
+    results_df = pd.DataFrame({
+        'from_cell': from_lst,
+        'to_cell': to_lst,
+        'source': source_lst,
+        'target': target_lst,
+        'path_symbol': path_lst,
+        'comm_score': comm_score_lst,
+        'z_score': z_score_lst
+    })
+    results_df.to_csv(os.path.join(base_path, f'CCC/Significant_paths_res.csv'), index=False)     
+    print(f"Saved results for Significant_paths to {os.path.join(base_path, f'CCC/Significant_paths_res.csv')}, shape: {results_df.shape}")
+
+
+
+def Identify_significant_lrfg_paths_celltypes(sif_df, agg_method='mean', min_cells_count=10):
+    if not isinstance(sif_df, pd.DataFrame):
+        raise ValueError("input needs to be pandas DataFrame")
+    
+    required_cols = ['path_symbol', 'source', 'target', 'comm_score', 'z_score']
+    missing = set(required_cols) - set(sif_df.columns)
+    if missing:
+        raise ValueError(f"sif_df is missing required columns: {missing}")
+    
+    group_cols = ['path_symbol', 'source', 'target']
+    count_df = sif_df.groupby(group_cols).size().reset_index(name='cells_count')
+    valid_groups = count_df[count_df['cells_count'] >= min_cells_count]
+    
+    sig_df_filtered = sif_df.merge(
+        valid_groups[group_cols],
+        on=group_cols,
+        how='inner'
+    )
+    
+    result_df = (sig_df_filtered.groupby(group_cols).agg({
+        'comm_score': agg_method,
+        'z_score': agg_method
+    }).reset_index())
+    
+    result_df = result_df.rename(columns={'path_symbol': 'LR_Symbol',
+                                          'source': 'Source_Type',
+                                          'target': 'Target_Type',
+                                          'comm_score': 'Comm_Score',
+                                          'z_score': 'Z_Score'})
+    return result_df
+
+
+
+def calculate_all_tf_tg_scores_ablation(rna_mat, tf_list, tg_list, path):
+    """
+    Calculate TF-TG score after ablation of ATAC information (dependent only on RNA expression level)
+    """
+    
+    os.makedirs(path, exist_ok=True)
+    samples = rna_mat.columns
+    
+    tfs = list(set(tf_list))
+    tgs = list(set(tg_list))
+    
+    tf_tg_columns = [f"{tf}->{tg}" for tf in tfs for tg in tgs]
+    
+    final_results = pd.DataFrame(
+        index=samples,
+        columns=tf_tg_columns,
+        dtype=float
+    )
+    
+    for sample in tqdm(samples, desc="Processing cells (Ablation Mode)"):
+        sample_file = os.path.join(path, f"{sample}.csv")
+        
+        if os.path.exists(sample_file):
+            try:
+                sample_results = pd.read_csv(sample_file, index_col=0)
+                if sample_results.shape[0] == len(tfs) and sample_results.shape[1] == len(tgs):
+                    final_results.loc[sample] = sample_results.values.ravel()
+                    continue
+            except:
+                pass
+        
+        sample_rna = rna_mat[sample]
+        
+        tf_vals = sample_rna.reindex(tfs, fill_value=0.0).values
+        tg_vals = sample_rna.reindex(tgs, fill_value=0.0).values
+        
+        score_matrix = np.outer(tf_vals, tg_vals)
+        
+        sample_results = pd.DataFrame(score_matrix, index=tfs, columns=tgs)
+        sample_results.to_csv(sample_file)
+        
+        final_results.loc[sample] = score_matrix.ravel()
+        
+    final_results.to_csv(os.path.join(path, "all_samples_tf_tg_scores.csv"))
+    
+    return final_results