python-katlas 0.1.4__py3-none-any.whl → 0.2.1__py3-none-any.whl

katlas/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.4"
+__version__ = "0.2.1"

katlas/_modidx.py

@@ -5,105 +5,137 @@ d = { 'settings': { 'branch': 'main',
                 'doc_host': 'https://sky1ove.github.io',
                 'git_url': 'https://github.com/sky1ove/katlas',
                 'lib_path': 'katlas'},
-  'syms': { 'katlas.core': { 'katlas.core.CPTAC': ('core.html#cptac', 'katlas/core.py'),
-                             'katlas.core.CPTAC._fetch_data': ('core.html#cptac._fetch_data', 'katlas/core.py'),
-                             'katlas.core.CPTAC.get_id': ('core.html#cptac.get_id', 'katlas/core.py'),
-                             'katlas.core.CPTAC.list_cancer': ('core.html#cptac.list_cancer', 'katlas/core.py'),
-                             'katlas.core.Data': ('core.html#data', 'katlas/core.py'),
-                             'katlas.core.Data.fetch_data': ('core.html#data.fetch_data', 'katlas/core.py'),
-                             'katlas.core.Data.get_aa_info': ('core.html#data.get_aa_info', 'katlas/core.py'),
-                             'katlas.core.Data.get_aa_morgan': ('core.html#data.get_aa_morgan', 'katlas/core.py'),
-                             'katlas.core.Data.get_aa_rdkit': ('core.html#data.get_aa_rdkit', 'katlas/core.py'),
-                             'katlas.core.Data.get_cddm': ('core.html#data.get_cddm', 'katlas/core.py'),
-                             'katlas.core.Data.get_cddm_others': ('core.html#data.get_cddm_others', 'katlas/core.py'),
-                             'katlas.core.Data.get_cddm_others_info': ('core.html#data.get_cddm_others_info', 'katlas/core.py'),
-                             'katlas.core.Data.get_cddm_upper': ('core.html#data.get_cddm_upper', 'katlas/core.py'),
-                             'katlas.core.Data.get_combine': ('core.html#data.get_combine', 'katlas/core.py'),
-                             'katlas.core.Data.get_combine_site_phosphorylated': ( 'core.html#data.get_combine_site_phosphorylated',
-                                                                                   'katlas/core.py'),
-                             'katlas.core.Data.get_combine_site_psp_ochoa': ('core.html#data.get_combine_site_psp_ochoa', 'katlas/core.py'),
-                             'katlas.core.Data.get_cptac_ensembl_site': ('core.html#data.get_cptac_ensembl_site', 'katlas/core.py'),
-                             'katlas.core.Data.get_cptac_gene_site': ('core.html#data.get_cptac_gene_site', 'katlas/core.py'),
-                             'katlas.core.Data.get_cptac_unique_site': ('core.html#data.get_cptac_unique_site', 'katlas/core.py'),
-                             'katlas.core.Data.get_kinase_info': ('core.html#data.get_kinase_info', 'katlas/core.py'),
-                             'katlas.core.Data.get_ks_dataset': ('core.html#data.get_ks_dataset', 'katlas/core.py'),
-                             'katlas.core.Data.get_num_dict': ('core.html#data.get_num_dict', 'katlas/core.py'),
-                             'katlas.core.Data.get_ochoa_site': ('core.html#data.get_ochoa_site', 'katlas/core.py'),
-                             'katlas.core.Data.get_psp_human_site': ('core.html#data.get_psp_human_site', 'katlas/core.py'),
-                             'katlas.core.Data.get_pspa_all_norm': ('core.html#data.get_pspa_all_norm', 'katlas/core.py'),
-                             'katlas.core.Data.get_pspa_st_norm': ('core.html#data.get_pspa_st_norm', 'katlas/core.py'),
-                             'katlas.core.Data.get_pspa_st_pct': ('core.html#data.get_pspa_st_pct', 'katlas/core.py'),
-                             'katlas.core.Data.get_pspa_tyr_norm': ('core.html#data.get_pspa_tyr_norm', 'katlas/core.py'),
-                             'katlas.core.Data.get_pspa_tyr_pct': ('core.html#data.get_pspa_tyr_pct', 'katlas/core.py'),
-                             'katlas.core.STY2sty': ('core.html#sty2sty', 'katlas/core.py'),
-                             'katlas.core.checker': ('core.html#checker', 'katlas/core.py'),
-                             'katlas.core.convert_string': ('core.html#convert_string', 'katlas/core.py'),
-                             'katlas.core.cut_seq': ('core.html#cut_seq', 'katlas/core.py'),
-                             'katlas.core.extract_site_seq': ('core.html#extract_site_seq', 'katlas/core.py'),
-                             'katlas.core.get_dict': ('core.html#get_dict', 'katlas/core.py'),
-                             'katlas.core.get_freq': ('core.html#get_freq', 'katlas/core.py'),
-                             'katlas.core.get_metaP': ('core.html#get_metap', 'katlas/core.py'),
-                             'katlas.core.get_one_kinase': ('core.html#get_one_kinase', 'katlas/core.py'),
-                             'katlas.core.get_pct': ('core.html#get_pct', 'katlas/core.py'),
-                             'katlas.core.get_pct_df': ('core.html#get_pct_df', 'katlas/core.py'),
-                             'katlas.core.get_pvalue': ('core.html#get_pvalue', 'katlas/core.py'),
-                             'katlas.core.get_unique_site': ('core.html#get_unique_site', 'katlas/core.py'),
-                             'katlas.core.multiply': ('core.html#multiply', 'katlas/core.py'),
-                             'katlas.core.multiply_func': ('core.html#multiply_func', 'katlas/core.py'),
-                             'katlas.core.predict_kinase': ('core.html#predict_kinase', 'katlas/core.py'),
-                             'katlas.core.predict_kinase_df': ('core.html#predict_kinase_df', 'katlas/core.py'),
-                             'katlas.core.raw2norm': ('core.html#raw2norm', 'katlas/core.py'),
-                             'katlas.core.sumup': ('core.html#sumup', 'katlas/core.py')},
-            'katlas.dl': { 'katlas.dl.CNN1D_1': ('dl.html#cnn1d_1', 'katlas/dl.py'),
-                           'katlas.dl.CNN1D_1.__init__': ('dl.html#cnn1d_1.__init__', 'katlas/dl.py'),
-                           'katlas.dl.CNN1D_1.forward': ('dl.html#cnn1d_1.forward', 'katlas/dl.py'),
-                           'katlas.dl.CNN1D_2': ('dl.html#cnn1d_2', 'katlas/dl.py'),
-                           'katlas.dl.CNN1D_2.__init__': ('dl.html#cnn1d_2.__init__', 'katlas/dl.py'),
-                           'katlas.dl.CNN1D_2.forward': ('dl.html#cnn1d_2.forward', 'katlas/dl.py'),
-                           'katlas.dl.GeneralDataset': ('dl.html#generaldataset', 'katlas/dl.py'),
-                           'katlas.dl.GeneralDataset.__getitem__': ('dl.html#generaldataset.__getitem__', 'katlas/dl.py'),
-                           'katlas.dl.GeneralDataset.__init__': ('dl.html#generaldataset.__init__', 'katlas/dl.py'),
-                           'katlas.dl.GeneralDataset.__len__': ('dl.html#generaldataset.__len__', 'katlas/dl.py'),
-                           'katlas.dl.MLP_1': ('dl.html#mlp_1', 'katlas/dl.py'),
-                           'katlas.dl.conv_wn': ('dl.html#conv_wn', 'katlas/dl.py'),
-                           'katlas.dl.get_sampler': ('dl.html#get_sampler', 'katlas/dl.py'),
-                           'katlas.dl.init_weights': ('dl.html#init_weights', 'katlas/dl.py'),
-                           'katlas.dl.lin_wn': ('dl.html#lin_wn', 'katlas/dl.py'),
-                           'katlas.dl.predict_dl': ('dl.html#predict_dl', 'katlas/dl.py'),
-                           'katlas.dl.seed_everything': ('dl.html#seed_everything', 'katlas/dl.py'),
-                           'katlas.dl.train_dl': ('dl.html#train_dl', 'katlas/dl.py'),
-                           'katlas.dl.train_dl_cv': ('dl.html#train_dl_cv', 'katlas/dl.py')},
-            'katlas.feature': { 'katlas.feature.get_esm': ('feature.html#get_esm', 'katlas/feature.py'),
-                                'katlas.feature.get_morgan': ('feature.html#get_morgan', 'katlas/feature.py'),
-                                'katlas.feature.get_rdkit': ('feature.html#get_rdkit', 'katlas/feature.py'),
-                                'katlas.feature.get_t5': ('feature.html#get_t5', 'katlas/feature.py'),
-                                'katlas.feature.get_t5_bfd': ('feature.html#get_t5_bfd', 'katlas/feature.py'),
-                                'katlas.feature.preprocess': ('feature.html#preprocess', 'katlas/feature.py'),
-                                'katlas.feature.reduce_feature': ('feature.html#reduce_feature', 'katlas/feature.py'),
-                                'katlas.feature.remove_hi_corr': ('feature.html#remove_hi_corr', 'katlas/feature.py')},
-            'katlas.imports': {},
-            'katlas.plot': { 'katlas.plot.draw_corr': ('plot.html#draw_corr', 'katlas/plot.py'),
-                             'katlas.plot.get_AUCDF': ('plot.html#get_aucdf', 'katlas/plot.py'),
-                             'katlas.plot.get_color_dict': ('plot.html#get_color_dict', 'katlas/plot.py'),
-                             'katlas.plot.get_logo': ('plot.html#get_logo', 'katlas/plot.py'),
-                             'katlas.plot.get_logo2': ('plot.html#get_logo2', 'katlas/plot.py'),
-                             'katlas.plot.logo_func': ('plot.html#logo_func', 'katlas/plot.py'),
-                             'katlas.plot.plot_2d': ('plot.html#plot_2d', 'katlas/plot.py'),
-                             'katlas.plot.plot_bar': ('plot.html#plot_bar', 'katlas/plot.py'),
-                             'katlas.plot.plot_bokeh': ('plot.html#plot_bokeh', 'katlas/plot.py'),
-                             'katlas.plot.plot_box': ('plot.html#plot_box', 'katlas/plot.py'),
-                             'katlas.plot.plot_cluster': ('plot.html#plot_cluster', 'katlas/plot.py'),
-                             'katlas.plot.plot_confusion_matrix': ('plot.html#plot_confusion_matrix', 'katlas/plot.py'),
-                             'katlas.plot.plot_corr': ('plot.html#plot_corr', 'katlas/plot.py'),
-                             'katlas.plot.plot_count': ('plot.html#plot_count', 'katlas/plot.py'),
-                             'katlas.plot.plot_group_bar': ('plot.html#plot_group_bar', 'katlas/plot.py'),
+  'syms': { 'katlas.common': {},
+            'katlas.compare': { 'katlas.compare.cosine_overall_flat': ('compare.html#cosine_overall_flat', 'katlas/compare.py'),
+                                'katlas.compare.cosine_similarity': ('compare.html#cosine_similarity', 'katlas/compare.py'),
+                                'katlas.compare.js_divergence': ('compare.html#js_divergence', 'katlas/compare.py'),
+                                'katlas.compare.js_divergence_flat': ('compare.html#js_divergence_flat', 'katlas/compare.py'),
+                                'katlas.compare.js_similarity': ('compare.html#js_similarity', 'katlas/compare.py'),
+                                'katlas.compare.js_similarity_flat': ('compare.html#js_similarity_flat', 'katlas/compare.py'),
+                                'katlas.compare.kl_divergence': ('compare.html#kl_divergence', 'katlas/compare.py'),
+                                'katlas.compare.kl_divergence_flat': ('compare.html#kl_divergence_flat', 'katlas/compare.py')},
+            'katlas.data': { 'katlas.data.CPTAC': ('data.html#cptac', 'katlas/data.py'),
+                             'katlas.data.CPTAC._read_file': ('data.html#cptac._read_file', 'katlas/data.py'),
+                             'katlas.data.CPTAC.get_id': ('data.html#cptac.get_id', 'katlas/data.py'),
+                             'katlas.data.CPTAC.list_cancer': ('data.html#cptac.list_cancer', 'katlas/data.py'),
+                             'katlas.data.Data': ('data.html#data', 'katlas/data.py'),
+                             'katlas.data.Data.clear_cache': ('data.html#data.clear_cache', 'katlas/data.py'),
+                             'katlas.data.Data.download': ('data.html#data.download', 'katlas/data.py'),
+                             'katlas.data.Data.get_aa_info': ('data.html#data.get_aa_info', 'katlas/data.py'),
+                             'katlas.data.Data.get_aa_morgan': ('data.html#data.get_aa_morgan', 'katlas/data.py'),
+                             'katlas.data.Data.get_aa_rdkit': ('data.html#data.get_aa_rdkit', 'katlas/data.py'),
+                             'katlas.data.Data.get_cddm': ('data.html#data.get_cddm', 'katlas/data.py'),
+                             'katlas.data.Data.get_cddm_LO': ('data.html#data.get_cddm_lo', 'katlas/data.py'),
+                             'katlas.data.Data.get_cddm_LO_upper': ('data.html#data.get_cddm_lo_upper', 'katlas/data.py'),
+                             'katlas.data.Data.get_cddm_upper': ('data.html#data.get_cddm_upper', 'katlas/data.py'),
+                             'katlas.data.Data.get_combine_site_phosphorylated': ( 'data.html#data.get_combine_site_phosphorylated',
+                                                                                   'katlas/data.py'),
+                             'katlas.data.Data.get_combine_site_psp_ochoa': ('data.html#data.get_combine_site_psp_ochoa', 'katlas/data.py'),
+                             'katlas.data.Data.get_cptac_ensembl_site': ('data.html#data.get_cptac_ensembl_site', 'katlas/data.py'),
+                             'katlas.data.Data.get_cptac_gene_site': ('data.html#data.get_cptac_gene_site', 'katlas/data.py'),
+                             'katlas.data.Data.get_cptac_unique_site': ('data.html#data.get_cptac_unique_site', 'katlas/data.py'),
+                             'katlas.data.Data.get_human_site': ('data.html#data.get_human_site', 'katlas/data.py'),
+                             'katlas.data.Data.get_kd_uniprot': ('data.html#data.get_kd_uniprot', 'katlas/data.py'),
+                             'katlas.data.Data.get_kinase_info': ('data.html#data.get_kinase_info', 'katlas/data.py'),
+                             'katlas.data.Data.get_kinase_uniprot': ('data.html#data.get_kinase_uniprot', 'katlas/data.py'),
+                             'katlas.data.Data.get_ks_background': ('data.html#data.get_ks_background', 'katlas/data.py'),
+                             'katlas.data.Data.get_ks_dataset': ('data.html#data.get_ks_dataset', 'katlas/data.py'),
+                             'katlas.data.Data.get_ks_unique': ('data.html#data.get_ks_unique', 'katlas/data.py'),
+                             'katlas.data.Data.get_num_dict': ('data.html#data.get_num_dict', 'katlas/data.py'),
+                             'katlas.data.Data.get_ochoa_site': ('data.html#data.get_ochoa_site', 'katlas/data.py'),
+                             'katlas.data.Data.get_psp_human_site': ('data.html#data.get_psp_human_site', 'katlas/data.py'),
+                             'katlas.data.Data.get_pspa': ('data.html#data.get_pspa', 'katlas/data.py'),
+                             'katlas.data.Data.get_pspa_raw': ('data.html#data.get_pspa_raw', 'katlas/data.py'),
+                             'katlas.data.Data.get_pspa_scale': ('data.html#data.get_pspa_scale', 'katlas/data.py'),
+                             'katlas.data.Data.get_pspa_st': ('data.html#data.get_pspa_st', 'katlas/data.py'),
+                             'katlas.data.Data.get_pspa_st_pct': ('data.html#data.get_pspa_st_pct', 'katlas/data.py'),
+                             'katlas.data.Data.get_pspa_tyr': ('data.html#data.get_pspa_tyr', 'katlas/data.py'),
+                             'katlas.data.Data.get_pspa_tyr_pct': ('data.html#data.get_pspa_tyr_pct', 'katlas/data.py'),
+                             'katlas.data.Data.get_reactome_pathway': ('data.html#data.get_reactome_pathway', 'katlas/data.py'),
+                             'katlas.data.Data.get_reactome_pathway_lo': ('data.html#data.get_reactome_pathway_lo', 'katlas/data.py'),
+                             'katlas.data.Data.read_file': ('data.html#data.read_file', 'katlas/data.py'),
+                             'katlas.data._default_dataset_dir': ('data.html#_default_dataset_dir', 'katlas/data.py'),
+                             'katlas.data._normalize_dataset_dir': ('data.html#_normalize_dataset_dir', 'katlas/data.py'),
+                             'katlas.data._normalize_required_files': ('data.html#_normalize_required_files', 'katlas/data.py'),
+                             'katlas.data._read_dataset_file_cached': ('data.html#_read_dataset_file_cached', 'katlas/data.py')},
+            'katlas.hierarchical': { 'katlas.hierarchical.get_1d_js': ('hierarchical.html#get_1d_js', 'katlas/hierarchical.py'),
+                                     'katlas.hierarchical.get_1d_js_parallel': ( 'hierarchical.html#get_1d_js_parallel',
+                                                                                 'katlas/hierarchical.py')},
+            'katlas.lo': { 'katlas.lo.get_pssm_LO': ('lo.html#get_pssm_lo', 'katlas/lo.py'),
+                           'katlas.lo.get_pssm_LO_flat': ('lo.html#get_pssm_lo_flat', 'katlas/lo.py'),
+                           'katlas.lo.plot_logo_LO': ('lo.html#plot_logo_lo', 'katlas/lo.py'),
+                           'katlas.lo.plot_logo_heatmap_LO': ('lo.html#plot_logo_heatmap_lo', 'katlas/lo.py')},
+            'katlas.pathway': { 'katlas.pathway.add_reactome_ref': ('pathway.html#add_reactome_ref', 'katlas/pathway.py'),
+                                'katlas.pathway.get_overlap': ('pathway.html#get_overlap', 'katlas/pathway.py'),
+                                'katlas.pathway.get_reactome': ('pathway.html#get_reactome', 'katlas/pathway.py'),
+                                'katlas.pathway.get_reactome_raw': ('pathway.html#get_reactome_raw', 'katlas/pathway.py'),
+                                'katlas.pathway.plot_path': ('pathway.html#plot_path', 'katlas/pathway.py'),
+                                'katlas.pathway.query_reactome': ('pathway.html#query_reactome', 'katlas/pathway.py')},
+            'katlas.plot': { 'katlas.plot.change_center_name': ('plot.html#change_center_name', 'katlas/plot.py'),
+                             'katlas.plot.convert_logo_df': ('plot.html#convert_logo_df', 'katlas/plot.py'),
+                             'katlas.plot.get_logo_IC': ('plot.html#get_logo_ic', 'katlas/plot.py'),
+                             'katlas.plot.get_pos_min_max': ('plot.html#get_pos_min_max', 'katlas/plot.py'),
+                             'katlas.plot.pSTY2sty': ('plot.html#psty2sty', 'katlas/plot.py'),
                              'katlas.plot.plot_heatmap': ('plot.html#plot_heatmap', 'katlas/plot.py'),
-                             'katlas.plot.plot_hist': ('plot.html#plot_hist', 'katlas/plot.py'),
-                             'katlas.plot.plot_rank': ('plot.html#plot_rank', 'katlas/plot.py'),
-                             'katlas.plot.set_sns': ('plot.html#set_sns', 'katlas/plot.py')},
-            'katlas.train': { 'katlas.train.get_splits': ('ml.html#get_splits', 'katlas/train.py'),
-                              'katlas.train.predict_ml': ('ml.html#predict_ml', 'katlas/train.py'),
-                              'katlas.train.score_each': ('ml.html#score_each', 'katlas/train.py'),
-                              'katlas.train.split_data': ('ml.html#split_data', 'katlas/train.py'),
-                              'katlas.train.train_ml': ('ml.html#train_ml', 'katlas/train.py'),
-                              'katlas.train.train_ml_cv': ('ml.html#train_ml_cv', 'katlas/train.py')}}}
+                             'katlas.plot.plot_heatmap_simple': ('plot.html#plot_heatmap_simple', 'katlas/plot.py'),
+                             'katlas.plot.plot_logo': ('plot.html#plot_logo', 'katlas/plot.py'),
+                             'katlas.plot.plot_logo_heatmap': ('plot.html#plot_logo_heatmap', 'katlas/plot.py'),
+                             'katlas.plot.plot_logo_raw': ('plot.html#plot_logo_raw', 'katlas/plot.py'),
+                             'katlas.plot.plot_logos': ('plot.html#plot_logos', 'katlas/plot.py'),
+                             'katlas.plot.plot_logos_idx': ('plot.html#plot_logos_idx', 'katlas/plot.py'),
+                             'katlas.plot.plot_two_heatmaps': ('plot.html#plot_two_heatmaps', 'katlas/plot.py'),
+                             'katlas.plot.scale_pos_neg_values': ('plot.html#scale_pos_neg_values', 'katlas/plot.py'),
+                             'katlas.plot.scale_zero_position': ('plot.html#scale_zero_position', 'katlas/plot.py'),
+                             'katlas.plot.sty2pSTY': ('plot.html#sty2psty', 'katlas/plot.py'),
+                             'katlas.plot.sty2pSTY_df': ('plot.html#sty2psty_df', 'katlas/plot.py')},
+            'katlas.pspa': { 'katlas.pspa.get_logo': ('pspa.html#get_logo', 'katlas/pspa.py'),
+                             'katlas.pspa.get_one_kinase': ('pspa.html#get_one_kinase', 'katlas/pspa.py'),
+                             'katlas.pspa.plot_logo_heatmap_pspa': ('pspa.html#plot_logo_heatmap_pspa', 'katlas/pspa.py'),
+                             'katlas.pspa.plot_logo_pspa': ('pspa.html#plot_logo_pspa', 'katlas/pspa.py'),
+                             'katlas.pspa.preprocess_pspa': ('pspa.html#preprocess_pspa', 'katlas/pspa.py'),
+                             'katlas.pspa.raw2norm': ('pspa.html#raw2norm', 'katlas/pspa.py')},
+            'katlas.pssm': { 'katlas.pssm._clean_zero': ('pssm.html#_clean_zero', 'katlas/pssm.py'),
+                             'katlas.pssm.clean_zero_normalize': ('pssm.html#clean_zero_normalize', 'katlas/pssm.py'),
+                             'katlas.pssm.flatten_pssm': ('pssm.html#flatten_pssm', 'katlas/pssm.py'),
+                             'katlas.pssm.get_IC': ('pssm.html#get_ic', 'katlas/pssm.py'),
+                             'katlas.pssm.get_IC_flat': ('pssm.html#get_ic_flat', 'katlas/pssm.py'),
+                             'katlas.pssm.get_cluster_pssms': ('pssm.html#get_cluster_pssms', 'katlas/pssm.py'),
+                             'katlas.pssm.get_entropy': ('pssm.html#get_entropy', 'katlas/pssm.py'),
+                             'katlas.pssm.get_entropy_flat': ('pssm.html#get_entropy_flat', 'katlas/pssm.py'),
+                             'katlas.pssm.get_prob': ('pssm.html#get_prob', 'katlas/pssm.py'),
+                             'katlas.pssm.get_pssm_seq_labels': ('pssm.html#get_pssm_seq_labels', 'katlas/pssm.py'),
+                             'katlas.pssm.get_pssm_weight': ('pssm.html#get_pssm_weight', 'katlas/pssm.py'),
+                             'katlas.pssm.get_specificity': ('pssm.html#get_specificity', 'katlas/pssm.py'),
+                             'katlas.pssm.get_specificity_flat': ('pssm.html#get_specificity_flat', 'katlas/pssm.py'),
+                             'katlas.pssm.pssm_to_seq': ('pssm.html#pssm_to_seq', 'katlas/pssm.py'),
+                             'katlas.pssm.recover_pssm': ('pssm.html#recover_pssm', 'katlas/pssm.py')},
+            'katlas.scoring': { 'katlas.scoring.Params': ('scoring.html#params', 'katlas/scoring.py'),
+                                'katlas.scoring.STY2sty': ('scoring.html#sty2sty', 'katlas/scoring.py'),
+                                'katlas.scoring.cut_seq': ('scoring.html#cut_seq', 'katlas/scoring.py'),
+                                'katlas.scoring.duplicate_ref_zero': ('scoring.html#duplicate_ref_zero', 'katlas/scoring.py'),
+                                'katlas.scoring.get_dict': ('scoring.html#get_dict', 'katlas/scoring.py'),
+                                'katlas.scoring.get_pct': ('scoring.html#get_pct', 'katlas/scoring.py'),
+                                'katlas.scoring.get_pct_df': ('scoring.html#get_pct_df', 'katlas/scoring.py'),
+                                'katlas.scoring.multiply': ('scoring.html#multiply', 'katlas/scoring.py'),
+                                'katlas.scoring.multiply_generic': ('scoring.html#multiply_generic', 'katlas/scoring.py'),
+                                'katlas.scoring.multiply_pspa': ('scoring.html#multiply_pspa', 'katlas/scoring.py'),
+                                'katlas.scoring.predict_kinase': ('scoring.html#predict_kinase', 'katlas/scoring.py'),
+                                'katlas.scoring.predict_kinase_df': ('scoring.html#predict_kinase_df', 'katlas/scoring.py'),
+                                'katlas.scoring.preprocess_ref': ('scoring.html#preprocess_ref', 'katlas/scoring.py'),
+                                'katlas.scoring.sumup': ('scoring.html#sumup', 'katlas/scoring.py')},
+            'katlas.utils': { 'katlas.utils.aln2df': ('utils.html#aln2df', 'katlas/utils.py'),
+                              'katlas.utils.check_seq': ('utils.html#check_seq', 'katlas/utils.py'),
+                              'katlas.utils.check_seqs': ('utils.html#check_seqs', 'katlas/utils.py'),
+                              'katlas.utils.clean_feat': ('utils.html#clean_feat', 'katlas/utils.py'),
+                              'katlas.utils.extract_site_seq': ('utils.html#extract_site_seq', 'katlas/utils.py'),
+                              'katlas.utils.get_aln_freq': ('utils.html#get_aln_freq', 'katlas/utils.py'),
+                              'katlas.utils.get_fasta': ('utils.html#get_fasta', 'katlas/utils.py'),
+                              'katlas.utils.get_subfamily_color': ('utils.html#get_subfamily_color', 'katlas/utils.py'),
+                              'katlas.utils.phosphorylate_seq': ('utils.html#phosphorylate_seq', 'katlas/utils.py'),
+                              'katlas.utils.phosphorylate_seq_df': ('utils.html#phosphorylate_seq_df', 'katlas/utils.py'),
+                              'katlas.utils.prepare_path': ('utils.html#prepare_path', 'katlas/utils.py'),
+                              'katlas.utils.remove_hi_corr': ('utils.html#remove_hi_corr', 'katlas/utils.py'),
+                              'katlas.utils.run_clustalo': ('utils.html#run_clustalo', 'katlas/utils.py'),
+                              'katlas.utils.standardize': ('utils.html#standardize', 'katlas/utils.py'),
+                              'katlas.utils.validate_site': ('utils.html#validate_site', 'katlas/utils.py'),
+                              'katlas.utils.validate_site_df': ('utils.html#validate_site_df', 'katlas/utils.py')}}}

katlas/common.py

@@ -0,0 +1,10 @@
+from .compare import *
+from .data import *
+from .hierarchical import *
+from .lo import *
+from .pathway import *
+from .plot import *
+from .pspa import *
+from .pssm import *
+from .scoring import *
+from .utils import *

katlas/compare.py

@@ -0,0 +1,118 @@
+"""algorithms about comparing two PSSMs"""
+
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/06_compare.ipynb.
+
+# %% auto #0
+__all__ = ['kl_divergence', 'kl_divergence_flat', 'js_divergence', 'js_divergence_flat', 'js_similarity', 'js_similarity_flat',
+           'cosine_similarity', 'cosine_overall_flat']
+
+# %% ../nbs/06_compare.ipynb #76949d54-f519-4bc6-9da5-d48a05bbfe69
+import numpy as np, pandas as pd
+from .pssm import EPSILON
+
+# %% ../nbs/06_compare.ipynb #b1ef2ee7-70fd-4703-96b4-1c1a9053987f
+def kl_divergence(p1,  # target pssm p (array-like, shape: (AA, positions))
+                  p2,  # pred pssm q (array-like, same shape as p1)
+                 ):
+    """
+    KL divergence D_KL(p1 || p2) over positions.
+    
+    p1 and p2 are arrays (df or np) with index as aa and column as position.
+    Returns average divergence across positions if mean=True, else per-position.
+    """
+    if p1.shape != p2.shape: raise ValueError("Shapes of p1 and p2 must match.")
+    p1, p2 = p1.align(p2, join='inner', axis=None)
+    # Mask invalid positions (both zero)
+    valid = (p1 + p2) > 0
+    p1 = np.where(valid, p1, 0.0)
+    p2 = np.where(valid, p2, 0.0)
+
+    # KL divergence: sum_x p1(x) log(p1(x)/p2(x))
+    kl = np.sum(p1 * np.log((p1 + EPSILON) / (p2 + EPSILON)), axis=0)
+
+    return kl
+
+# %% ../nbs/06_compare.ipynb #71084bb3-169a-4dc2-b5dd-1b802fda8225
+def kl_divergence_flat(p1_flat, # pd.Series of target flattened pssm p
+                       p2_flat, # pd.Series of pred flattened pssm q
+                       ):
+
+    "p1 and p2 are two flattened pd.Series with index as aa and column as position"
+    kld = kl_divergence(p1_flat,p2_flat) # do not do js.mean() because it's 1d
+    total_position = len(p1_flat.index.str.extract(r'(-?\d+)').drop_duplicates())
+    return float(kld/total_position)
+
+# %% ../nbs/06_compare.ipynb #eca99343-fbcd-48c2-a1ff-88af31fd2346
+def js_divergence(p1, # pssm 
+                  p2, # pssm
+                  index=True,
+                 ):
+    "p1 and p2 are two arrays (df or np) with index as aa and column as position"
+    if p1.shape != p2.shape: raise ValueError("Shapes of p1 and p2 must match.")
+    p1, p2 = p1.align(p2, join='inner', axis=None)
+    if index: positions=p1.columns
+    valid = (p1 + p2) > 0
+    p1 = np.where(valid, p1, 0.0)
+    p2 = np.where(valid, p2, 0.0)
+    
+    m = 0.5 * (p1 + p2)
+    
+    js = 0.5 * np.sum(p1 * np.log((p1+ EPSILON) / (m + EPSILON)), axis=0) + \
+         0.5 * np.sum(p2 * np.log((p2+ EPSILON) / (m + EPSILON)), axis=0)
+    return pd.Series(js,index=positions) if index else js
+
+# %% ../nbs/06_compare.ipynb #37553737-13b3-4461-ad93-fe4cf863f25b
+def js_divergence_flat(p1_flat, # pd.Series of flattened pssm
+                       p2_flat, # pd.Series of flattened pssm
+                       ):
+
+    "p1 and p2 are two flattened pd.Series with index as aa and column as position"
+    js = js_divergence(p1_flat,p2_flat,index=False)
+    total_position = len(p1_flat.index.str.extract(r'(-?\d+)').drop_duplicates())
+    return float(js/total_position)
+
+# %% ../nbs/06_compare.ipynb #7e480e54-c5de-4726-b208-c531e07a2adc
+def js_similarity(pssm1,pssm2):
+    "Convert JSD to bits to be in range (0,1) then 1-JSD."
+    distance = js_divergence(pssm1,pssm2)/np.log(2)
+    similarity = 1-distance
+    return similarity
+
+# %% ../nbs/06_compare.ipynb #0c51e8b5-df29-431b-8013-ff46388b4872
+def js_similarity_flat(p1_flat,p2_flat):
+    "Convert JSD to bits to be in range (0,1) then 1-JSD. "
+    return 1-(js_divergence_flat(p1_flat,p2_flat)/np.log(2))
+
+# %% ../nbs/06_compare.ipynb #8d2e228a-8543-4174-8c24-ce6ded317c8d
+def cosine_similarity(pssm1: pd.DataFrame, pssm2: pd.DataFrame) -> pd.Series:
+    "Compute cosine similarity per position (column) between two PSSMs."
+
+    if pssm1.shape != pssm2.shape: raise ValueError("PSSMs must have the same shape")
+
+    sims = {}
+    for pos in pssm1.columns:
+        v1 = pssm1[pos]
+        v2 = pssm2[pos]
+        v1,v2 = v1.align(v2, join='inner') # make sure the aa index match with each other
+
+        norm1 = np.linalg.norm(v1)
+        norm2 = np.linalg.norm(v2)
+
+        if norm1 == 0 or norm2 == 0:
+            sims[pos] = 0.0
+        else:
+            dot_product = np.dot(v1,v2) # sum(v1*v2)
+            sims[pos] = dot_product / (norm1 * norm2)
+
+    return pd.Series(sims)
+
+# %% ../nbs/06_compare.ipynb #d830fbaa-4a9f-4d5d-98ba-289fc91bff8e
+def cosine_overall_flat(pssm1_flat, pssm2_flat):
+    """Compute overall cosine similarity between two PSSMs (flattened)."""
+    # match index for dot product
+    pssm1_flat, pssm2_flat = pssm1_flat.align(pssm2_flat, join='inner')
+    norm1 = np.linalg.norm(pssm1_flat)
+    norm2 = np.linalg.norm(pssm2_flat)
+    if norm1 == 0 or norm2 == 0: return 0.0
+    dot_product = sum(pssm1_flat*pssm2_flat) # np.dot(pssm1_flat, pssm2_flat)
+    return  dot_product/ (norm1 * norm2)