preprocess_data/prepare_for_featurization/make_splits.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import math
import pandas as pd
pd.options.mode.chained_assignment = None  # default='warn'



def make_splits(pfam_seed_file: str,
                num_splits: int = 10,
                rand_key: int = 6,
                topk1_valid: int = 3,
                topk2_valid: int = 8):
    """
    split pfams into OOD validation set + {num_splits} folds
    
    when I made splits:
        num_splits = 10
        rand_key = 6
        topk1_valid = 3
        topk2_valid = 8
    
    inputs:
    -------
        - pfam_seed_file (str): the original seed file; use for getting file 
                                prefix
        - num_splits (int): number of folds for in-distribution train+test set
        - rand_key (int): random key for numpy
        - topk1_valid (int): when making OOD Valid set, how many of the 
                             widest pfams to hold out 
        - topk2_valid (int): when making OOD Valid set, how many of the 
                             widest pfams to hold out
    
    returns:
    --------
        (None)
    
    outputs:
    --------
        - split_pfam_meta_file: a version of the previous pfam_level_metadata_file,
                                but with split information added
        - split_metadata_file: metadata about the splits
        - plain text files for each fold, with names of pfams in the folds
    """
    prefix = pfam_seed_file.split('.')[0]
    pfam_level_metadata_file = f'{prefix}_PFAM-METADATA.tsv'
        
    df = pd.read_csv(pfam_level_metadata_file, 
                     sep='\t', 
                     index_col=0)
    
    def num_pairs(n):
        return (n * (n-1) ) / 2
    
    df['possible_pairs'] = num_pairs(df['msa_depth'])
    
    
    ############################
    ### PFAMS WITH CLAN LABELS #
    ############################
    pfams_with_clans = df[~df['clan_name'].isna()]
    
    def add_stat(colname, fn, new_lab):
        clans_to_stat = {}
        for clan in list(set(pfams_with_clans['clan_name'])):
            subdf = pfams_with_clans[pfams_with_clans['clan_name'] == clan]
            stat = fn(subdf[colname])
            clans_to_stat[clan] = stat
            del subdf, stat, clan
        
        pfams_with_clans[new_lab] = pfams_with_clans['clan_name'].apply(lambda x: clans_to_stat[x])
    
    
    ### clan stats
    # sizes
    add_stat(colname = 'possible_pairs',
             fn = sum,
             new_lab = 'CLAN_possible_pairs')
    
    # add average MSA width for the clan
    add_stat(colname = 'msa_width',
             fn = lambda x: x.mean(),
             new_lab = 'CLAN-AVE_msa_width')
    
    
    # add average percent indels for the clan
    add_stat(colname = 'percent_gaps',
             fn = lambda x: x.mean(),
             new_lab = 'CLAN-AVE_percent_gaps')
    
    
    # clan-level dataframe; remove any particularly large clans
    col_lst = ['clan_name',
               'CLAN_possible_pairs',
               'CLAN-AVE_msa_width', 
               'CLAN-AVE_percent_gaps']
    clan_meta = pfams_with_clans.drop_duplicates(subset = 'clan_name', 
                                                 keep = 'first')[col_lst]
    clan_meta = clan_meta[clan_meta['CLAN_possible_pairs'] < 800000]
    
    # widest MSAs
    widest = clan_meta.nlargest(n=topk1_valid, 
                                columns='CLAN-AVE_msa_width', 
                                keep='all')
    
    # gappiest MSAs
    gappiest =  clan_meta.nlargest(n=topk2_valid, 
                                   columns='CLAN-AVE_percent_gaps', 
                                   keep='all')
    
    
    ##############################
    ### SPLIT OFF VALIDATION SET #
    ##############################
    # how many pairs, if I extract these pfams?
    validation_clans = list(set(widest['clan_name'].tolist() + gappiest['clan_name'].tolist()))
    sub_df = clan_meta[clan_meta['clan_name'].isin(validation_clans)]
    num_validation_pairs = sub_df['CLAN_possible_pairs'].sum()
    perc_data = num_validation_pairs / df['possible_pairs'].sum()
    
    
    validation_pfams = df[df['clan_name'].isin(validation_clans)]['pfam'].tolist()
    remaining = pfams_with_clans[~pfams_with_clans['clan_name'].isin(validation_clans)]
    del col_lst, clan_meta, widest, gappiest, sub_df
    del perc_data
    
    
    #################################################
    ### START SPILTTING PFAMS WITH CLANS INTO FOLDS #
    #################################################
    col_lst = ['clan_name',
                'CLAN_possible_pairs',
                'CLAN-AVE_msa_width', 
                'CLAN-AVE_percent_gaps']
    clan_meta = remaining.drop_duplicates(subset = 'clan_name', 
                                          keep = 'first')[col_lst]
    
    total_samples = clan_meta['CLAN_possible_pairs'].sum()
    max_size = math.ceil(total_samples / num_splits)
    
    train_test_clans = {i: [] for i in range(num_splits)}
    train_test_pfams = {i: [] for i in range(num_splits)}
    split_sizes = {i:0 for i in range(num_splits)}
    
    # shuffle before assigning splits
    clan_meta = clan_meta.sample(frac=1, random_state=rand_key).reset_index(drop=True)
    to_place = []
    split_ids = list(range(num_splits))
    for clan in clan_meta['clan_name']:
        sub_df = clan_meta[clan_meta['clan_name'] == clan]
        pfams = pfams_with_clans[pfams_with_clans['clan_name']==clan]['pfam'].tolist()
        num_pairs = sub_df['CLAN_possible_pairs'].sum()
        
        # try placing in one of num_splits splits
        placed = False
        for i in split_ids:
            if split_sizes[i] < max_size:
                placed = True
                train_test_clans[i].append(clan)
                train_test_pfams[i] += pfams
                split_sizes[i] += num_pairs
                break
        
        if not placed:
            to_place.append(clan)
        
        # rotate list before next iteration
        split_ids = split_ids[1:] + split_ids[:1]
    
    assert len(to_place) == 0
    
    del col_lst, clan_meta, total_samples, max_size, to_place, split_ids
    
    
    ##############################################
    ### START SPILTTING PFAMS WITH NO CLAN LABEL #
    ##############################################
    pfams_without_clans = df[df['clan_name'].isna()]
    
    total_samples = pfams_without_clans['possible_pairs'].sum()
    max_size = math.ceil(total_samples / num_splits)
    
    more_train_test_pfams = {i: [] for i in range(num_splits)}
    more_split_sizes = {i:0 for i in range(num_splits)}
    
    # shuffle before assigning splits
    pfams_without_clans = pfams_without_clans.sample(frac=1, 
                                                     random_state=rand_key).reset_index(drop=True)
    if len(pfams_without_clans) > 0:
        to_place = []
        split_ids = list(range(num_splits))
        for _, row in pfams_without_clans.iterrows():
            pfam_name = row['pfam']
            num_pairs = row['possible_pairs']
            
            # try placing in one of 5 splits
            placed = False
            for i in split_ids:
                if more_split_sizes[i] < max_size:
                    placed = True
                    more_train_test_pfams[i].append( pfam_name )
                    more_split_sizes[i] += num_pairs
                    break
            
            if not placed:
                to_place.append(pfam_name)
            
            # rotate list before next iteration
            split_ids = split_ids[1:] + split_ids[:1]
        
        assert len(to_place) == 0
        del pfams_without_clans, total_samples, max_size, to_place, split_ids, row
        del pfam_name, num_pairs, placed, i
    
    
    #############################################################
    ### COMBINE PFAM AND CLAN LISTS; MAKE FINAL META DATAFRAMES #
    #############################################################
    checksum = 0
    for i in range(num_splits):
        train_test_pfams[i] = train_test_pfams[i]+more_train_test_pfams[i]
        split_sizes[i] = split_sizes[i]+more_split_sizes[i]
        checksum += split_sizes[i]
    
    checksum +=num_validation_pairs
    
    # make sure all pairs are accounted for
    assert checksum == df['possible_pairs'].sum()
    
    # add one-hot label to main dataframe (easier to check for duplication)
    for i in range(num_splits):
        pfams_in_split = train_test_pfams[i]
        one_hot = df['pfam'].isin(pfams_in_split)
        df[f'in_split{i}'] = one_hot
    
    df['in_OOD_valid'] = df['pfam'].isin(validation_pfams)
    
    del checksum, i, train_test_pfams, split_sizes, more_train_test_pfams
    del more_split_sizes, pfams_in_split, one_hot, validation_pfams
    del num_validation_pairs, validation_clans, train_test_clans
    
    
    ####################################################################
    ### FINAL CHECK OF SPLITS, OUTPUT METADATA AT PFAM AND CLAN LEVELS #
    ####################################################################
    # make sure all pfams only belong to one split
    col_lst = ['in_OOD_valid'] + [f'in_split{i}' for i in range(num_splits)]
    sub_df = df[col_lst]
    rowsum = sub_df.sum(axis=1)
    assert (rowsum == 1).all()
    print('no data bleed :)')
    
    # metadata per split: num_pfams, num_clans (if any), num_seqs, 
    #   num_possible_pairs, percent_of_dataset
    split_meta = []
    for col in col_lst:
        sub_df = df[df[col]]
        
        num_pfams = len(sub_df)
        num_clans = len(list(set(sub_df['clan_name'].tolist())))
        num_seqs = sub_df['msa_depth'].sum()
        num_possible_pairs = sub_df['possible_pairs'].sum()
        percent_by_seqs = num_seqs / df['msa_depth'].sum()
        percent_by_pairs = num_possible_pairs / df['possible_pairs'].sum()
        
        ave_msa_depth = sub_df['msa_depth'].mean()
        ave_msa_width = sub_df['msa_width'].mean()
        ave_percent_gaps = sub_df['percent_gaps'].mean()
        
        out_dict = {'split': col,
                    'num_pfams': num_pfams,
                    'num_clans': num_clans,
                    'num_seqs': num_seqs,
                    'num_possible_pairs': num_possible_pairs,
                    'ave_msa_depth': ave_msa_depth,
                    'ave_msa_width': ave_msa_width,
                    'ave_percent_gaps': ave_percent_gaps,
                    'percent_by_seqs': percent_by_seqs,
                    'percent_by_pairs': percent_by_pairs}
        
        split_meta.append(out_dict)
        
        # also write pfams to separate file
        sub_df['pfam'].to_csv(f'pfams_{col}.tsv', sep='\t', header=False, index=False)
            
    
    split_meta = pd.DataFrame(split_meta)
    
    del col_lst, sub_df, rowsum, col, num_pfams, num_clans, num_seqs
    del num_possible_pairs, percent_by_seqs, percent_by_pairs
    del ave_msa_depth, ave_msa_width, ave_percent_gaps, out_dict
    
    
    # output metadata with split annotations
    pfam_level_metadata_file = f'{prefix}_PFAM-METADATA.tsv'
    split_pfam_meta_file = pfam_level_metadata_file.replace('METADATA','METADATA_withSplitLabels')
    split_metadata_file = f'{prefix}_SPLIT-METADATA.tsv'
    
    df.to_csv(split_pfam_meta_file, sep='\t')
    split_meta.to_csv(split_metadata_file, sep='\t')