geney 1.2.20__py2.py3-none-any.whl → 1.2.22__py2.py3-none-any.whl

geney/performance_utils.py

@@ -1,138 +0,0 @@
-import pandas as pd
-import numpy as np
-from sklearn.metrics import precision_score, recall_score, accuracy_score
-from sklearn.metrics import roc_auc_score, roc_curve
-import matplotlib.pyplot as plt
-
-
-# def plot_performance(true_values, predictions):
-#     clinsig_map = {'Benign': 0, 'Pathogenic': 1}
-#     true_values = [clinsig_map[t] for t in true_values]
-#     predictions = scale_predictions(predictions)
-#
-#     fpr, tpr, thresholds_roc = roc_curve(true_values, predictions)
-#
-#     # Calculate Precision-Recall curve
-#     precision, recall, thresholds_pr = precision_recall_curve(true_values, predictions)
-#
-#     # Plotting ROC curve
-#     plt.figure(figsize=(20, 5))
-#
-#     plt.subplot(1, 4, 1)
-#     plt.plot(fpr, tpr)
-#     plt.title('ROC Curve')
-#     plt.xlabel('False Positive Rate')
-#     plt.ylabel('True Positive Rate')
-#
-#     # Plotting Precision-Recall curve
-#     plt.subplot(1, 4, 2)
-#     plt.plot(recall, precision)
-#     plt.title('Precision-Recall Curve')
-#     plt.xlabel('Recall')
-#     plt.ylabel('Precision')
-#
-#     # Plotting Precision vs. Thresholds
-#     plt.subplot(1, 4, 3)
-#     plt.plot(thresholds_pr, precision[:-1])  # Precision and thresholds have off-by-one lengths
-#     plt.title('Precision vs. Threshold')
-#     plt.xlabel('Threshold')
-#     plt.ylabel('Precision')
-#
-#     # Plotting Sample Percentage Captured vs. Thresholds
-#     plt.subplot(1, 4, 4)
-#     # Assuming 'tpr' or another appropriate metric represents the cumulative percentage
-#     plt.plot(thresholds_roc, tpr)  # Update 'tpr' with the correct metric if necessary
-#     plt.title('Cumulative Percentage vs. Threshold')
-#     plt.xlabel('Threshold')
-#     plt.ylabel('Cumulative Percentage of Population')
-#
-#     plt.tight_layout()
-#     plt.show()
-#
-#
-#
-# def plot_auc_curve(y_true, y_pred_proba):
-#     """
-#     Plots the AUC curve.
-#
-#     Args:
-#         y_true (array-like): True labels (0 or 1).
-#         y_pred_proba (array-like): Predicted probabilities for positive class.
-#
-#     Returns:
-#         None
-#     """
-#     fpr, tpr, _ = roc_curve(y_true, y_pred_proba)
-#     auc_value = roc_auc_score(y_true, y_pred_proba)
-#
-#     plt.figure(figsize=(8, 6))
-#     plt.plot(fpr, tpr, label=f"AUC = {auc_value:.2f}")
-#     plt.plot([0, 1], [0, 1], 'k--')
-#     plt.xlabel("False Positive Rate")
-#     plt.ylabel("True Positive Rate")
-#     plt.title("Receiver Operating Characteristic (ROC) Curve")
-#     plt.legend()
-#     plt.show()
-#     return auc_value
-#
-#
-# def optimal_ppv(dataframe, feature_name, plot=False):
-#     """
-#     Calculates the optimal positive predictive value (PPV) for a given feature.
-#
-#     Args:
-#         dataframe (pd.DataFrame): Input dataframe.
-#         feature_name (str): Name of the feature column.
-#
-#     Returns:
-#         float: Optimal PPV.
-#     """
-#     # Assuming 'target' is the binary target column (0 or 1)
-#     threshold_values = pd.qcut(dataframe[feature_name], 100, duplicates='drop')
-#     ppv_values = []
-#
-#     for threshold in threshold_values:
-#         predictions = (dataframe[feature_name] >= threshold).astype(int)
-#         ppv = precision_score(dataframe['target'], predictions)
-#         ppv_values.append(ppv)
-#
-#     optimal_threshold = threshold_values[np.argmax(ppv_values)]
-#     optimal_ppv = max(ppv_values)
-#     if plot:
-#         plt.figure(figsize=(8, 6))
-#         plt.scatter(threshold_values, ppv_values)
-#         plt.xlabel("Threshold")
-#         plt.ylabel("Positive Predictive Value (PPV)")
-#         plt.title("Optimal Positive Predictive Value (PPV)")
-#         plt.show()
-#
-#     return optimal_ppv, optimal_threshold
-#
-#
-# def measure_prediction_quality(prediction_vector, quality_vector):
-#     """
-#     Measure the quality of the predictions using the quality_vector as the characteristic to check.
-#     """
-#     pass
-#
-#
-#
-# def create_ppv_vector(prediction_vector, true_value_vector):
-#     """
-#     Create a vector of positive predictive values (PPV) for the prediction_vector using the true_value_vector as the true values.
-#     """
-#     df = pd.DataFrame({'prediction': prediction_vector, 'true_value': true_value_vector})
-#     df.sort_values('prediction', ascending=True, inplace=True)
-#     df['bin'] = pd.qcut(df['prediction'], 100, labels=False, duplicates=True, retbins=True)
-#     for bin in df.bin.unique():
-#         temp_df = df[df.bin >= bin].
-#
-#
-# def group_retention(predictions, predictor):
-#     # first i need to get the ratio of values that are retained at particular values
-#     predictions.sort_values(predictor, inplace=True)
-#     _, thresholds = pd.qcut(predictions[predictor], 100, duplicates='drop')
-#     tracker = []
-#     for th in thresholds:
-#
-#

geney/pipelines/dask_utils.py

@@ -1,153 +0,0 @@
-from dask_jobqueue import PBSCluster
-from dask.distributed import Client, wait
-import os
-from tqdm import tqdm
-from pathlib import Path
-from geney.oncosplice import oncosplice
-from geney import config_setup
-from geney.utils import contains, available_genes
-import warnings
-import gc
-import pandas as pd
-import argparse
-
-tqdm.pandas()
-warnings.filterwarnings('ignore')
-
-
-def launch_dask_cluster(memory_size="3GB", num_workers=10, queue="tamirQ",
-                        walltime="24:00:00", dashboard_address=":23154",
-                        log_directory="dask-logs"):
-    """
-    Launch a Dask cluster using PBS.
-
-    Parameters:
-    memory_size (str): Memory for each worker.
-    num_workers (int): Number of workers to scale to.
-    queue (str): Queue name for PBS.
-    walltime (str): Walltime for PBS.
-    dashboard_address (str): Address for the Dask dashboard.
-    log_directory (str): Directory for Dask logs.
-
-    Returns:
-    tuple: A tuple containing the Dask client and cluster objects.
-    """
-    try:
-        dask_cluster = PBSCluster(
-            cores=1,
-            memory=memory_size,
-            processes=1,
-            queue=queue,
-            walltime=walltime,
-            scheduler_options={"dashboard_address": dashboard_address},
-            log_directory=log_directory,
-            job_script_prologue=[f"cd {config_setup['BASE']}"]
-        )
-        dask_cluster.scale(num_workers)
-        dask_client = Client(dask_cluster)
-        return dask_client, dask_cluster
-    except Exception as e:
-        print(f"An error occurred: {e}")
-        return None, None
-
-
-def main_single(mut_id):
-    try:
-        res = oncosplice(mut_id, sai_threshold=0.5).dropna(axis=1)
-    except Exception as e:
-        print(f"An error occurred: {e}")
-        res = None
-    return res
-
-
-def process_and_save_tasks(tasks, dask_client, save_loc=None, num_workers=10, save_increment=20, file_index=0):
-    """
-    Process a list of tasks using Dask, saving the results incrementally.
-    Parameters:
-    tasks (list): List of tasks to be processed.
-    save_loc (str): Location to save results.
-    dask_client (Client): Dask client for task submission.
-    num_workers (int): Number of workers to use.
-    save_increment (int): Number of iterations after which to save results.
-    file_index (int): Starting index for output files.
-    Returns:
-    None
-    """
-    def save_results(results, index):
-        if results:
-            df = pd.concat(results)
-            df.to_csv(os.path.join(save_loc, f'results_{index}.csv'))
-            return []
-        return results
-
-    futures, all_results = [], []
-    for i, task in tqdm(enumerate(tasks), total=len(tasks)):
-        futures.append(dask_client.submit(main_single, task))
-        if (i + 1) % num_workers == 0:
-            wait(futures)
-            all_results.extend([f.result() for f in futures if f.status == 'finished' and f.result() is not None])
-            futures = []
-
-        if (i + 1) % (save_increment * num_workers) == 0:
-            all_results = save_results(all_results, file_index)
-            file_index += 1
-            gc.collect()
-    wait(futures)
-    all_results.extend([f.result() for f in futures if f.status == 'finished' and f.result() is not None])
-    save_results(all_results, file_index)
-
-
-def restart_checkpoint(result_dir):
-    """
-    Reloads processed results from CSV files, extracting unique mutation IDs and the highest checkpoint.
-
-    Parameters:
-    result_dir (str): Directory containing result CSV files.
-
-    Returns:
-    list: List of unique mutation IDs processed.
-    int: The highest checkpoint value from the files.
-    """
-    result_path = Path(result_dir)
-    files = sorted(result_path.glob('*'), key=lambda x: int(x.stem.split('_')[-1]), reverse=True)
-
-    if not files:
-        return [], 0
-
-    try:
-        data = []
-        latest_file = files[0]
-        for file in files:
-            data.append(pd.read_csv(file))
-        processed_muts = pd.concat(data).mut_id.unique().tolist()
-        highest_checkpoint = int(latest_file.stem.split('_')[-1])
-        return processed_muts, highest_checkpoint
-
-    except Exception as e:
-        print(f"Error processing file {files}: {e}")
-        return [], 0
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description='Run oncosplice with dask.')
-    parser.add_argument('--input_file', '-i', required=True, help='input text file')
-    parser.add_argument('--results_directory', '-r', required=False, help='result directory', default=config_setup['ONCOSPLICE'])
-    parser.add_argument('--num_workers', '-n', type=int, required=False, help='number of dask workers to recruit', default=10)
-    parser.add_argument('--worker_size', '-m', type=str, required=False, help='dask worker memory allocation', default="3GB")
-    args = parser.parse_args()
-
-    client, cluster = launch_dask_cluster(memory_size=args.worker_size, num_workers=args.num_workers)
-    muts = open(args.input_file, 'r').read().splitlines()
-    processed_mutations, last_count = restart_checkpoint(args.results_directory)
-    processed_mutations = sorted(list(set(processed_mutations)))
-    muts = [m for m in tqdm(muts) if not contains(processed_mutations, m)]
-    valid_genes = available_genes()
-    muts = [m for m in muts if contains(valid_genes, m.split(':')[0])]
-    print(f"Valid mutations: {len(muts)}")
-    process_and_save_tasks(tasks=muts,
-                           save_loc=args.results_directory,
-                           dask_client=client,
-                           file_index=last_count + 1,
-                           num_workers=args.num_workers)
-    print("Done.")
-

geney/splicing/__init__.py

@@ -1,2 +0,0 @@
-from .splicing_utils import *
-from geney import config_setup

geney/splicing/spliceai_utils.py

@@ -1,253 +0,0 @@
-from geney.utils import reverse_complement, find_files_by_gene_name, unload_json, dump_json, unload_pickle
-from geney.Fasta_segment import Fasta_segment
-from geney.mutations.variant_utils import generate_mut_variant
-from geney import config_setup
-
-'''
-SpliceAI util functions.
-'''
-import numpy as np
-import tensorflow as tf
-from keras.models import load_model
-from pkg_resources import resource_filename
-from spliceai.utils import one_hot_encode
-
-tf.config.threading.set_intra_op_parallelism_threads(1)
-tf.config.threading.set_inter_op_parallelism_threads(1)
-
-sai_paths = ('models/spliceai{}.h5'.format(x) for x in range(1, 6))
-sai_models = [load_model(resource_filename('spliceai', x)) for x in sai_paths]
-
-def sai_predict_probs(seq: str, models: list) -> list:
-    '''
-    Predicts the donor and acceptor junction probability of each
-    NT in seq using SpliceAI.
-
-    Let m:=2*sai_mrg_context + L be the input seq length. It is assumed
-    that the input seq has the following structure:
-
-          seq = |<sai_mrg_context NTs><L NTs><sai_mrg_context NTs>|
-
-    The returned probability matrix is of size 2XL, where
-    the first row is the acceptor probability and the second row
-    is the donor probability. These probabilities corresponds to the
-    middel <L NTs> NTs of the input seq.
-    '''
-    x = one_hot_encode(seq)[None, :]
-    y = np.mean([models[m].predict(x) for m in range(5)], axis=0)
-    return y[0,:,1:].T
-
-
-def get_actual_sai_seq(seq: str, sai_mrg_context: int=5000) -> str:
-    '''
-    This dfunction assumes that the input seq has the following structure:
-
-         seq = |<sai_mrg_context NTs><L NTs><sai_mrg_context NTs>|.
-
-    Then, the function returns the sequence: |<L NTs>|
-    '''
-    return seq[sai_mrg_context:-sai_mrg_context]
-
-
-############################################################################################
-############################################################################################
-############# BEGIN CUSTOM SAI USE CASES ###################################################
-############################################################################################
-############################################################################################
-
-
-def find_ss_changes(ref_dct, mut_dct, known_splice_sites, threshold=0.5):
-    '''
-    :param ref_dct:  the spliceai probabilities for each nucleotide (by genomic position) as a dictionary for the reference sequence
-    :param mut_dct:  the spliceai probabilities for each nucleotide (by genomic position) as a dictionary for the mutated sequence
-    :param known_splice_sites: the indices (by genomic position) that serve as known splice sites
-    :param threshold: the threshold for detection (difference between reference and mutated probabilities)
-    :return: two dictionaries; discovered_pos is a dictionary containing all the positions that meat the threshold for discovery
-            and deleted_pos containing all the positions that meet the threshold for missing and the condition for missing
-    '''
-
-    new_dict = {v: mut_dct.get(v, 0) - ref_dct.get(v, 0) for v in
-                list(set(list(ref_dct.keys()) + list(mut_dct.keys())))}
-
-    discovered_pos = {k: {'delta': round(float(v), 3), 'absolute': round(float(mut_dct[k]), 3)} for k, v in
-                      new_dict.items() if (k not in known_splice_sites and v >= threshold) or (v > 0.45)}
-
-    deleted_pos = {k: {'delta': round(float(v), 3), 'absolute': round(float(mut_dct.get(k, 0)), 3)} for k, v in
-                   new_dict.items() if k in known_splice_sites and v <= -threshold}
-
-
-    return discovered_pos, deleted_pos
-
-
-def run_spliceai(mutations, gene_data, sai_mrg_context=5000, min_coverage=2500, sai_threshold=0.5):
-    positions = mutations.positions #[m.start for m in mutations]
-    seq_start_pos = min(positions) - sai_mrg_context - min_coverage
-    seq_end_pos = max(positions) + sai_mrg_context + min_coverage  # + 1
-
-    # ref_seq, ref_indices = pull_fasta_seq_endpoints(mutations.chrom, seq_start_pos, seq_end_pos)
-    fasta_obj = Fasta_segment()
-    ref_seq, ref_indices = fasta_obj.read_segment_endpoints(config_setup['CHROM_SOURCE'] / f'chr{mutations.chrom}.fasta',
-                                                seq_start_pos,
-                                                seq_end_pos)
-
-
-    # gene_data = unload_pickle(
-    #     find_files_by_gene_name(gene_name=mutations.gene))
-    gene_start, gene_end, rev = gene_data.gene_start, gene_data.gene_end, gene_data.rev
-
-    mrna_acceptors = sorted(list(set([lst for lsts in
-                                      [mrna.get('acceptors', []) for mrna in gene_data.transcripts.values() if
-                                       mrna['transcript_biotype'] == 'protein_coding'] for lst in lsts])))
-    mrna_donors = sorted(list(set([lst for lsts in
-                                   [mrna.get('donors', []) for mrna in gene_data.transcripts.values() if
-                                    mrna['transcript_biotype'] == 'protein_coding'] for lst in lsts])))
-
-    visible_donors = np.intersect1d(mrna_donors, ref_indices)
-    visible_acceptors = np.intersect1d(mrna_acceptors, ref_indices)
-
-    start_pad = ref_indices.index(gene_start) if gene_start in ref_indices else 0
-    end_cutoff = ref_indices.index(gene_end) if gene_end in ref_indices else len(ref_indices)  # - 1
-    end_pad = len(ref_indices) - end_cutoff
-    ref_seq = 'N' * start_pad + ref_seq[start_pad:end_cutoff] + 'N' * end_pad
-    ref_indices = [-1] * start_pad + ref_indices[start_pad:end_cutoff] + [-1] * end_pad
-    mut_seq, mut_indices = ref_seq, ref_indices
-
-    for mut in mutations:
-        mut_seq, mut_indices, _, _ = generate_mut_variant(seq=mut_seq, indices=mut_indices, mut=mut)
-
-    ref_indices = ref_indices[sai_mrg_context:-sai_mrg_context]
-    mut_indices = mut_indices[sai_mrg_context:-sai_mrg_context]
-
-    if rev:
-        ref_seq = reverse_complement(ref_seq)
-        mut_seq = reverse_complement(mut_seq)
-        ref_indices = ref_indices[::-1]
-        mut_indices = mut_indices[::-1]
-
-    ref_seq_probs_temp = sai_predict_probs(ref_seq, sai_models)
-    mut_seq_probs_temp = sai_predict_probs(mut_seq, sai_models)
-
-    ref_seq_acceptor_probs, ref_seq_donor_probs = ref_seq_probs_temp[0, :], ref_seq_probs_temp[1, :]
-    mut_seq_acceptor_probs, mut_seq_donor_probs = mut_seq_probs_temp[0, :], mut_seq_probs_temp[1, :]
-
-    assert len(ref_indices) == len(ref_seq_acceptor_probs), 'Reference pos not the same'
-    assert len(mut_indices) == len(mut_seq_acceptor_probs), 'Mut pos not the same'
-
-    iap, dap = find_ss_changes({p: v for p, v in list(zip(ref_indices, ref_seq_acceptor_probs))},
-                               {p: v for p, v in list(zip(mut_indices, mut_seq_acceptor_probs))},
-                               visible_acceptors,
-                               threshold=sai_threshold)
-
-    assert len(ref_indices) == len(ref_seq_donor_probs), 'Reference pos not the same'
-    assert len(mut_indices) == len(mut_seq_donor_probs), 'Mut pos not the same'
-
-    idp, ddp = find_ss_changes({p: v for p, v in list(zip(ref_indices, ref_seq_donor_probs))},
-                               {p: v for p, v in list(zip(mut_indices, mut_seq_donor_probs))},
-                               visible_donors,
-                               threshold=sai_threshold)
-
-    missplicing = {'missed_acceptors': dap, 'missed_donors': ddp, 'discovered_acceptors': iap, 'discovered_donors': idp}
-    missplicing = {outk: {float(k): v for k, v in outv.items()} for outk, outv in missplicing.items()}
-    return {outk: {int(k) if k.is_integer() else k: v for k, v in outv.items()} for outk, outv in missplicing.items()}
-
-
-
-class PredictSpliceAI:
-    def __init__(self, mutation, gene_data, threshold=0.5, force=False, sai_mrg_context=5000, min_coverage=2500):
-        self.modification = mutation
-        self.threshold = threshold
-
-        # if '|' in mutation.mut_id:
-        self.spliceai_db = config_setup['MISSPLICING_PATH'] / f'spliceai_epistatic'
-        # else:
-        #     self.spliceai_db = config_setup['MISSPLICING_PATH'] / f'spliceai_individual'
-
-        self.missplicing = {}
-
-        if self.prediction_file_exists() and not force:
-            self.missplicing = self.load_sai_predictions()
-
-        else:
-            self.missplicing = run_spliceai(self.modification, gene_data=gene_data, sai_mrg_context=sai_mrg_context, min_coverage=min_coverage, sai_threshold=0.1)
-            self.save_sai_predictions()
-
-    def __repr__(self):
-        return f'Missplicing({self.modification.mut_id}) --> {self.missplicing}'
-
-    def __str__(self):
-        return self.aberrant_splicing
-    def __bool__(self):
-        for event, details in self.aberrant_splicing.items():
-            if details:
-                return True
-        return False
-
-    def __eq__(self, alt_splicing):
-        flag, _ = check_splicing_difference(self.missplicing, alt_splicing, self.threshold)
-        return not flag
-
-    @property
-    def aberrant_splicing(self):
-        return self.apply_sai_threshold(self.missplicing, self.threshold)
-
-    @property
-    def prediction_file(self):
-        return self.spliceai_db / self.modification.gene / self.modification.file_identifier_json
-
-    def prediction_file_exists(self):
-        return self.prediction_file.exists()
-
-    def load_sai_predictions(self):
-        missplicing = unload_json(self.prediction_file)
-        missplicing = {outk: {float(k): v for k, v in outv.items()} for outk, outv in missplicing.items()}
-        missplicing = {outk: {int(k) if k.is_integer() or 'missed' in outk else k: v for k, v in outv.items()} for
-                       outk, outv in
-                       missplicing.items()}
-        return missplicing
-
-    def save_sai_predictions(self):
-        self.prediction_file.parent.mkdir(parents=True, exist_ok=True)
-        dump_json(self.prediction_file, self.missplicing)
-    def apply_sai_threshold(self, splicing_dict=None, threshold=None):
-        splicing_dict = self.missplicing if not splicing_dict else splicing_dict
-        threshold = self.threshold if not threshold else threshold
-        new_dict = {}
-        for event, details in splicing_dict.items():
-            for e, d in details.items():
-                if abs(d['delta']) >= threshold:
-                    return splicing_dict
-            new_dict[event] = {}        #{k: v for k, v in details.items() if abs(v['delta']) >= threshold}
-        return new_dict
-
-    def get_max_missplicing_delta(self):
-        max_delta = 0
-        for event, details in self.missplicing.items():
-            for e, d in details.items():
-                if abs(d['delta']) > max_delta:
-                    max_delta = abs(d['delta'])
-        return max_delta
-
-def check_splicing_difference(missplicing1, missplicing2, threshold=None):
-    flag = False
-    true_differences = {}
-    for event in ['missed_acceptors', 'missed_donors']:
-        td = {}
-        dct1 = missplicing1[event]
-        dct2 = missplicing2[event]
-        for k in list(set(list(dct1.keys()) + list(dct2.keys()))):
-            diff = abs(dct1.get(k, {'delta': 0})['delta']) - abs(dct2.get(k, {'delta': 0})['delta'])
-            if abs(diff) >= threshold:
-                flag = True
-                td[k] = diff
-        true_differences[event] = td
-    for event in ['discovered_acceptors', 'discovered_donors']:
-        td = {}
-        dct1 = missplicing1[event]
-        dct2 = missplicing2[event]
-        for k in list(set(list(dct1.keys()) + list(dct2.keys()))):
-            diff = abs(dct1.get(k, {'delta': 0})['delta']) - abs(dct2.get(k, {'delta': 0})['delta'])
-            if abs(diff) >= threshold:
-                flag = True
-                td[k] = diff
-        true_differences[event] = td
-    return flag, true_differences