Upload folder using huggingface_hub

5032722 verified 4 months ago

15.1 kB

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
ABOUT:
======
precompute counts for HMM inputs
updated on Sept 26 2024 for (B, L, 2) input sizes
"""
import jax
from jax import numpy as jnp


######################
### HELPER FUNCTIONS #
######################
# these get called in summarize_alignment
def count_substitutions(one_sample, one_sample_bool):
    """
    vectorized way to count types of substitutions i.e. emissions at
    match states
    yields a (20, 20) matrix per site in max_len
     
    this will get vmapped over the batch dimension
    """
    # identify what the pair is, using an indicator matrix: 
    #    (rows = anc, cols = desc)
    # subtract index by 3, because there's three special tokens at beginning 
    # of alphabet: pad, bos, and eos
    # finally, multiply by sample boolean i.e. mask the whole matrix if 
    # the position is NOT a match position
    one_sample_bool = jnp.expand_dims(one_sample_bool, 1)
    
    def encode_pairs(vec_at_pos, bool_at_pos):
        indc_mat = jnp.zeros((20,20),dtype='uint8')
        anc_tok, desc_tok = vec_at_pos
        indc_mat = indc_mat.at[anc_tok-3, desc_tok-3].add(1)
        indc_mat = indc_mat * bool_at_pos
        return indc_mat
    vmapped_encode_pairs = jax.vmap(encode_pairs, in_axes=0)
    
    subCounts_persite_persamp = vmapped_encode_pairs(one_sample, one_sample_bool)
    subCounts = subCounts_persite_persamp.sum(axis=0)
    
    return subCounts


def count_insertions(batch, ins_pos_mask):
    """
    count different types of insertions i.e. emissions at insert states
    yields a (20,) vector for the whole batch
    
    unlike other counting methods, this can operate on the whole batch at once
    """
    ### use insertion positions as a mask on the batch
    # look at DESCENDANT SEQ to see what types of insertions happen
    all_inserts = batch[:, :, 1] * ins_pos_mask
    
    ### count the number of valid tokens
    # this gets vmapped over the valid alphabet
    valid_toks = jnp.arange(3, 23)
    def count_insertions(tok):
        return (all_inserts == tok).sum(axis=1)
    vmapped_count_insertions = jax.vmap(count_insertions, in_axes=0)
    
    insCounts = vmapped_count_insertions(valid_toks)
    return insCounts.T


def count_deletions(batch, del_pos_mask):
    """
    count different types of deletions 
    yields a (20,) vector for the whole batch
    
    unlike other counting methods, this can operate on the whole batch at once
    """
    ### use deletion positions as a mask on the batch
    # look at ANCESTOR SEQ to see what aas got deleted
    all_deletes = batch[:, :, 0] * del_pos_mask
    
    ### count the number of valid tokens
    # this gets vmapped over the valid alphabet
    valid_toks = jnp.arange(3, 23)
    def count_deletions(tok):
        return (all_deletes == tok).sum(axis=1)
    vmapped_count_deletions = jax.vmap(count_deletions, in_axes=0)
    
    delCounts = vmapped_count_deletions(valid_toks)
    return delCounts.T


def count_transitions(one_alignment_path, start_idxes):
    """
    vectorized way to count types of transitions (M, I, D)
    yields a (3, 3) matrix for the sample
     
    this will get vmapped over the batch dimension
    """
    # this is vmapped over the length of start_idxes, to get a sliding
    # window effect on one_alignment_path
    def identify_pair_type(start_idx):
        indicator_mat = jnp.zeros((4,4))
        from_tok, to_tok = one_alignment_path[(start_idx, start_idx+1),]
        indicator_mat = indicator_mat.at[from_tok, to_tok].add(1)
        return indicator_mat
    vmapped_subpairs = jax.vmap(identify_pair_type, in_axes=0)
    
    # indicator matrix is (4,4), but first row and column are transitions
    # to padding characters and don't really count; cut them off
    out = vmapped_subpairs(start_idxes)
    transition_counts = out[:, 1:, 1:]
    
    # sum over whole sequence length to get all transitions for this 
    # alignment path
    transition_counts = jnp.sum(transition_counts, axis=0)
    return transition_counts





###################
### MAIN FUNCTION #
###################
def summarize_alignment(batch, align_len, gap_tok=43):
    """
    batch should be a tensor of aligned sequences that are categorically 
    encoded, with the following non-alphabet tokens:
         0: <pad>
         1: <bos> (not included in pairHMM data, but still reserved token)
         2: <eos> (not included in pairHMM data, but still reserved token)
        43: default gap char (but can be changed)
    
    batch is of size (batch_size, max_seq_len, 2), where-
        dim2=0: ancestor sequence, aligned (i.e. with gaps)
        dim2=1: descendant sequence, aligned (i.e. with gaps)
    
    align_len is a vector of size (batch_size,) that has the length of the 
        alignments
    
    """
    #######################################
    ### COMPRESS ALIGNMENT REPRESENTATION #
    #######################################
    ### split into gaps vs not gaps
    non_gaps = jnp.where((batch != gap_tok) & (batch != 0), 1, 0)
    gaps = jnp.where((batch == gap_tok), batch, 0)
    
    ### find matches, inserts, and deletions
    # matches found using non_gaps vector
    match_pos = jnp.where(jnp.sum(non_gaps, axis=2) == 2, 1, 0)
    
    # inserts mean ancestor char == gap_tok
    ins_pos = jnp.where(gaps[:,:,0] == gap_tok, 1, 0)
    
    # deletions means descendant char == gap_tok
    del_pos = jnp.where(gaps[:,:,1] == gap_tok, 1, 0)
    
    # combine all into one vec for later
    # M = 1, I = 2, D = 3; padding is 0
    paths_compressed = (match_pos + (ins_pos*2) + (del_pos*3))
    
    
    ### ADD ADDITIONAL MATCH STATES AT BEGINNING AND END OF ALIGNMENT PATHS
    ### this is part of the LG05, RS07, and H20 assumptions
    # add match at the end of the paths
    extra_end_col = jnp.zeros((batch.shape[0], 1))
    to_adjust = jnp.concatenate([paths_compressed, extra_end_col], axis=1)
    x_idxes = (jnp.arange(0, batch.shape[0]))
    with_extra_end_match = to_adjust.at[x_idxes, align_len].add(1)
    
    # add extra start at the beginning of the paths
    extra_start_col = jnp.ones((batch.shape[0], 1))
    paths_with_extra_start_end_matches = jnp.concatenate([extra_start_col, 
                                                          with_extra_end_match], 
                                                          axis=1).astype(int)
    
    
    ### clean up variables
    del non_gaps, gaps, paths_compressed
    
    
    ######################################
    ### COUNT EMISSIONS FROM MATCH STATE #
    ######################################
    ### use count_substitutions function, defined above
    ### vmap it along the batch dimension (dim0)
    match_pos = match_pos.astype(bool)
    countsubs_vmapped = jax.vmap(count_substitutions, 
                                 in_axes = (0,0))
    subCounts_persamp = countsubs_vmapped(batch, 
                                          match_pos)
    
    
    #######################################
    ### COUNT EMISSIONS FROM INSERT STATE #
    #######################################
    insCounts_persamp = count_insertions(batch = batch, 
                                         ins_pos_mask = ins_pos)
    del ins_pos
    
    ################################################
    ### COUNT TYPES OF DELETIONS FROM DELETE STATE #
    ################################################
    delCounts_persamp = count_deletions(batch = batch, 
                                        del_pos_mask = del_pos)
    del del_pos
    
    
    #######################
    ### COUNT TRANSITIONS #
    #######################
    ### use count_transitions function, defined above
    ### vmap it along the batch dimension (dim0)
    counttrans_vmapped = jax.vmap(count_transitions, 
                                  in_axes=(0, None))
    start_idxes = jnp.arange(start = 0, 
                             stop = paths_with_extra_start_end_matches.shape[1] - 1).astype(int)
    transCounts_persamp = counttrans_vmapped(paths_with_extra_start_end_matches, 
                                             start_idxes)

    return (subCounts_persamp, insCounts_persamp,
            delCounts_persamp, transCounts_persamp)


######################################
### overal equilibrium distributions #
######################################
def get_aa_counts(seq_mat):
    valid_aas = jnp.arange(3, 23)
    
    # vmap this over valid_aas
    def count_aas(aa, dset):
        return (dset == aa).sum()
    
    vmapped_count_aas = jax.vmap(count_aas, in_axes=(0, None))
    counts = vmapped_count_aas(valid_aas, seq_mat)
    return counts

def safe_convert(mat):
    assert mat.max() <= 65535
    assert mat.max() >= 0
    return mat.astype('uint16')


##############################################
### functional wrappers that also save files #
##############################################
def get_equilib_counts(in_dir, split, gap_tok=43):
    print(f'Working on split: {split}')
    
    ### read file
    with open(f'{in_dir}/{split}_pair_alignments.npy', 'rb') as f:
        # B, L, 2
        hmm_paths = np.load(f)
        assert hmm_paths.shape[1] == 2324
        del f
    
    ### run get_aa_counts to get equilibrium distribution across all positions
    AA_counts = get_aa_counts(hmm_paths)
    
    out_file = f'{split}_AAcounts.npy'
    with open(out_file, 'wb') as g:
        np.save(out_file, AA_counts)
    del AA_counts, out_file
    
    
    ### mask to only select match positions
    # split into gaps vs not gaps
    non_gaps = np.where((hmm_paths != gap_tok) & (hmm_paths != 0), 1, 0)
        
    
    # find matches positions, use it to create a mask to only keep values at 
    # match sites
    match_pos = np.where(np.sum(non_gaps, axis=-1) == 2, True, False)[:,:,None]
    del non_gaps
    
    match_mask = np.repeat(match_pos, 2, axis=-1)
    del match_pos
    
    masked_hmm_paths = hmm_paths * match_mask
    del match_mask
    
    
    ### run get_aa_counts as normal on this masked matrix to get equilibrium
    ### distribution ONLY at match positions
    AA_counts_subsOnly = get_aa_counts(masked_hmm_paths)
    
    out_file = f'{split}_AAcounts_subsOnly.npy'
    with open(out_file, 'wb') as g:
        np.save(out_file, AA_counts_subsOnly)
        
        
def summarize_trans_emiss_counts_wrapper(in_dir, split):
    print(f'Processing {split}')
    ### initialize the pytorch dataset object
    dset = pairAlign_dloader(in_dir = in_dir,
                             split = split)
    
    ### create a dataloader that returns jax arrays
    dload = DataLoader(dset, 
                       batch_size = batch_size, 
                       shuffle = False,
                       collate_fn = jax_collator)
    
    subCounts_lst = []
    insCounts_lst = []
    delCounts_lst = []
    transCounts_lst = []
    for i, batch in enumerate(dload):
        # batch is (batchsize, max_len, 2)
        # lens will be (batchsize, max_len)
        lens = (batch != 0).sum(axis=1)[:,0]
        if i == 0:
            jitted_summarize_alignment = jax.jit(summarize_alignment)
            
            
        ### use jit-compiled summarize alignment
        out = jitted_summarize_alignment(batch, lens)
        batch_subCounts_persamp = out[0]
        batch_insCounts_persamp = out[1]
        batch_delCounts_persamp = out[2]
        batch_transCounts_persamp = out[3]
        del out
        
        # adjust types
        batch_subCounts_persamp = safe_convert(batch_subCounts_persamp)
        batch_insCounts_persamp = safe_convert(batch_insCounts_persamp)
        batch_delCounts_persamp = safe_convert(batch_delCounts_persamp)
        batch_transCounts_persamp = safe_convert(batch_transCounts_persamp)
        
        # append
        subCounts_lst.append(batch_subCounts_persamp)
        insCounts_lst.append(batch_insCounts_persamp)
        delCounts_lst.append(batch_delCounts_persamp)
        transCounts_lst.append(batch_transCounts_persamp)
    
    
    # concatenate
    subCounts_persamp = jnp.concatenate(subCounts_lst, axis=0)
    assert subCounts_persamp.shape == (len(dset), 20, 20), f'subCounts shape is wrong: {subCounts_persamp.shape}'
    del subCounts_lst
    
    insCounts_persamp = jnp.concatenate(insCounts_lst, axis=0)
    assert insCounts_persamp.shape == (len(dset), 20), f'insCounts shape is wrong: {insCounts_persamp.shape}'
    del insCounts_lst
    
    delCounts_persamp = jnp.concatenate(delCounts_lst, axis=0)
    assert delCounts_persamp.shape == (len(dset), 20), f'delCounts shape is wrong: {delCounts_persamp.shape}'
    del delCounts_lst
    
    transCounts_persamp = jnp.concatenate(transCounts_lst, axis=0)
    assert transCounts_persamp.shape == (len(dset), 3, 3), f'transCounts shape is wrong: {transCounts_persamp.shape}'
    del transCounts_lst
    
    
    # output
    with open(f'./precalculated_counts/{split}_subCounts.npy', 'wb') as g:
        jnp.save(g, subCounts_persamp)
    
    with open(f'./precalculated_counts/{split}_insCounts.npy', 'wb') as g:
        jnp.save(g, insCounts_persamp)
    
    with open(f'./precalculated_counts/{split}_delCounts.npy', 'wb') as g:
        jnp.save(g, delCounts_persamp)
    
    with open(f'./precalculated_counts/{split}_transCounts.npy', 'wb') as g:
        jnp.save(g, transCounts_persamp)


if __name__ == '__main__':
    import os
    import numpy as np
    from pairAlign_dloader import pairAlign_dloader, jax_collator
    from tqdm import tqdm
    
    ### make sure this still works as expected
    # (M->M) (added START)
    # (M->D)
    # (D->I)
    # (I->M) (added END)
    fake_align = jnp.array([[3,  4, 43, 0],
                            [3, 43,  5, 0]]).T[None,:,:]
    
    true_trans_mat = jnp.array([[1, 0, 1],
                                [1, 0, 0],
                                [0, 1, 0]])
    
    true_match_mat = jnp.zeros( (20, 20) )
    true_match_mat = true_match_mat.at[0,0].add(1)
    
    true_del_vec = jnp.zeros( (20,) )
    true_del_vec = true_del_vec.at[1].add(1)
    
    true_ins_vec = jnp.zeros( (20,) )
    true_ins_vec = true_ins_vec.at[2].add(1)
    
    out = summarize_alignment(fake_align, 
                              3, 
                              gap_tok=43)
    
    pred_match_mat = out[0][0]
    pred_ins_vec = out[1][0]
    pred_del_vec = out[2][0]
    pred_trans_mat = out[3][0]
    del out
    
    assert jnp.allclose(true_match_mat, pred_match_mat)
    assert jnp.allclose(true_del_vec, pred_del_vec)
    assert jnp.allclose(true_ins_vec, pred_ins_vec)
    assert jnp.allclose(true_trans_mat, pred_trans_mat)
    
    
    
    # ### do this for all regular spilts
    # splitnames = [f'TENPERC_split{i}' for i in range(5)]
    # batch_size = 1500
    
    # for split in splitnames:
    #     get_equilib_counts(in_dir = 'tenperc_data_pairAlignments',  
    #                        split = split, 
    #                        gap_tok = 43)
        
    #     summarize_trans_emiss_counts_wrapper(in_dir = 'tenperc_data_pairAlignments',  
    #                                          split = split)
        
    

	#!/usr/bin/env python3
	# -- coding: utf-8 --
	"""
	ABOUT:
	======
	precompute counts for HMM inputs

	updated on Sept 26 2024 for (B, L, 2) input sizes

	"""
	import jax
	from jax import numpy as jnp


	######################
	### HELPER FUNCTIONS #
	######################
	# these get called in summarize_alignment
	def count_substitutions(one_sample, one_sample_bool):
	"""
	vectorized way to count types of substitutions i.e. emissions at
	match states
	yields a (20, 20) matrix per site in max_len

	this will get vmapped over the batch dimension
	"""
	# identify what the pair is, using an indicator matrix:
	# (rows = anc, cols = desc)
	# subtract index by 3, because there's three special tokens at beginning
	# of alphabet: pad, bos, and eos
	# finally, multiply by sample boolean i.e. mask the whole matrix if
	# the position is NOT a match position
	one_sample_bool = jnp.expand_dims(one_sample_bool, 1)

	def encode_pairs(vec_at_pos, bool_at_pos):
	indc_mat = jnp.zeros((20,20),dtype='uint8')
	anc_tok, desc_tok = vec_at_pos
	indc_mat = indc_mat.at[anc_tok-3, desc_tok-3].add(1)
	indc_mat = indc_mat * bool_at_pos
	return indc_mat
	vmapped_encode_pairs = jax.vmap(encode_pairs, in_axes=0)

	subCounts_persite_persamp = vmapped_encode_pairs(one_sample, one_sample_bool)
	subCounts = subCounts_persite_persamp.sum(axis=0)

	return subCounts


	def count_insertions(batch, ins_pos_mask):
	"""
	count different types of insertions i.e. emissions at insert states
	yields a (20,) vector for the whole batch

	unlike other counting methods, this can operate on the whole batch at once
	"""
	### use insertion positions as a mask on the batch
	# look at DESCENDANT SEQ to see what types of insertions happen
	all_inserts = batch[:, :, 1] * ins_pos_mask

	### count the number of valid tokens
	# this gets vmapped over the valid alphabet
	valid_toks = jnp.arange(3, 23)
	def count_insertions(tok):
	return (all_inserts == tok).sum(axis=1)
	vmapped_count_insertions = jax.vmap(count_insertions, in_axes=0)

	insCounts = vmapped_count_insertions(valid_toks)
	return insCounts.T


	def count_deletions(batch, del_pos_mask):
	"""
	count different types of deletions
	yields a (20,) vector for the whole batch

	unlike other counting methods, this can operate on the whole batch at once
	"""
	### use deletion positions as a mask on the batch
	# look at ANCESTOR SEQ to see what aas got deleted
	all_deletes = batch[:, :, 0] * del_pos_mask

	### count the number of valid tokens
	# this gets vmapped over the valid alphabet
	valid_toks = jnp.arange(3, 23)
	def count_deletions(tok):
	return (all_deletes == tok).sum(axis=1)
	vmapped_count_deletions = jax.vmap(count_deletions, in_axes=0)

	delCounts = vmapped_count_deletions(valid_toks)
	return delCounts.T


	def count_transitions(one_alignment_path, start_idxes):
	"""
	vectorized way to count types of transitions (M, I, D)
	yields a (3, 3) matrix for the sample

	this will get vmapped over the batch dimension
	"""
	# this is vmapped over the length of start_idxes, to get a sliding
	# window effect on one_alignment_path
	def identify_pair_type(start_idx):
	indicator_mat = jnp.zeros((4,4))
	from_tok, to_tok = one_alignment_path[(start_idx, start_idx+1),]
	indicator_mat = indicator_mat.at[from_tok, to_tok].add(1)
	return indicator_mat
	vmapped_subpairs = jax.vmap(identify_pair_type, in_axes=0)

	# indicator matrix is (4,4), but first row and column are transitions
	# to padding characters and don't really count; cut them off
	out = vmapped_subpairs(start_idxes)
	transition_counts = out[:, 1:, 1:]

	# sum over whole sequence length to get all transitions for this
	# alignment path
	transition_counts = jnp.sum(transition_counts, axis=0)
	return transition_counts





	###################
	### MAIN FUNCTION #
	###################
	def summarize_alignment(batch, align_len, gap_tok=43):
	"""
	batch should be a tensor of aligned sequences that are categorically
	encoded, with the following non-alphabet tokens:
	0: <pad>
	1: <bos> (not included in pairHMM data, but still reserved token)
	2: <eos> (not included in pairHMM data, but still reserved token)
	43: default gap char (but can be changed)

	batch is of size (batch_size, max_seq_len, 2), where-
	dim2=0: ancestor sequence, aligned (i.e. with gaps)
	dim2=1: descendant sequence, aligned (i.e. with gaps)

	align_len is a vector of size (batch_size,) that has the length of the
	alignments

	"""
	#######################################
	### COMPRESS ALIGNMENT REPRESENTATION #
	#######################################
	### split into gaps vs not gaps
	non_gaps = jnp.where((batch != gap_tok) & (batch != 0), 1, 0)
	gaps = jnp.where((batch == gap_tok), batch, 0)

	### find matches, inserts, and deletions
	# matches found using non_gaps vector
	match_pos = jnp.where(jnp.sum(non_gaps, axis=2) == 2, 1, 0)

	# inserts mean ancestor char == gap_tok
	ins_pos = jnp.where(gaps[:,:,0] == gap_tok, 1, 0)

	# deletions means descendant char == gap_tok
	del_pos = jnp.where(gaps[:,:,1] == gap_tok, 1, 0)

	# combine all into one vec for later
	# M = 1, I = 2, D = 3; padding is 0
	paths_compressed = (match_pos + (ins_pos2) + (del_pos3))


	### ADD ADDITIONAL MATCH STATES AT BEGINNING AND END OF ALIGNMENT PATHS
	### this is part of the LG05, RS07, and H20 assumptions
	# add match at the end of the paths
	extra_end_col = jnp.zeros((batch.shape[0], 1))
	to_adjust = jnp.concatenate([paths_compressed, extra_end_col], axis=1)
	x_idxes = (jnp.arange(0, batch.shape[0]))
	with_extra_end_match = to_adjust.at[x_idxes, align_len].add(1)

	# add extra start at the beginning of the paths
	extra_start_col = jnp.ones((batch.shape[0], 1))
	paths_with_extra_start_end_matches = jnp.concatenate([extra_start_col,
	with_extra_end_match],
	axis=1).astype(int)


	### clean up variables
	del non_gaps, gaps, paths_compressed


	######################################
	### COUNT EMISSIONS FROM MATCH STATE #
	######################################
	### use count_substitutions function, defined above
	### vmap it along the batch dimension (dim0)
	match_pos = match_pos.astype(bool)
	countsubs_vmapped = jax.vmap(count_substitutions,
	in_axes = (0,0))
	subCounts_persamp = countsubs_vmapped(batch,
	match_pos)


	#######################################
	### COUNT EMISSIONS FROM INSERT STATE #
	#######################################
	insCounts_persamp = count_insertions(batch = batch,
	ins_pos_mask = ins_pos)
	del ins_pos

	################################################
	### COUNT TYPES OF DELETIONS FROM DELETE STATE #
	################################################
	delCounts_persamp = count_deletions(batch = batch,
	del_pos_mask = del_pos)
	del del_pos


	#######################
	### COUNT TRANSITIONS #
	#######################
	### use count_transitions function, defined above
	### vmap it along the batch dimension (dim0)
	counttrans_vmapped = jax.vmap(count_transitions,
	in_axes=(0, None))
	start_idxes = jnp.arange(start = 0,
	stop = paths_with_extra_start_end_matches.shape[1] - 1).astype(int)
	transCounts_persamp = counttrans_vmapped(paths_with_extra_start_end_matches,
	start_idxes)

	return (subCounts_persamp, insCounts_persamp,
	delCounts_persamp, transCounts_persamp)


	######################################
	### overal equilibrium distributions #
	######################################
	def get_aa_counts(seq_mat):
	valid_aas = jnp.arange(3, 23)

	# vmap this over valid_aas
	def count_aas(aa, dset):
	return (dset == aa).sum()

	vmapped_count_aas = jax.vmap(count_aas, in_axes=(0, None))
	counts = vmapped_count_aas(valid_aas, seq_mat)
	return counts

	def safe_convert(mat):
	assert mat.max() <= 65535
	assert mat.max() >= 0
	return mat.astype('uint16')


	##############################################
	### functional wrappers that also save files #
	##############################################
	def get_equilib_counts(in_dir, split, gap_tok=43):
	print(f'Working on split: {split}')

	### read file
	with open(f'{in_dir}/{split}_pair_alignments.npy', 'rb') as f:
	# B, L, 2
	hmm_paths = np.load(f)
	assert hmm_paths.shape[1] == 2324
	del f

	### run get_aa_counts to get equilibrium distribution across all positions
	AA_counts = get_aa_counts(hmm_paths)

	out_file = f'{split}_AAcounts.npy'
	with open(out_file, 'wb') as g:
	np.save(out_file, AA_counts)
	del AA_counts, out_file


	### mask to only select match positions
	# split into gaps vs not gaps
	non_gaps = np.where((hmm_paths != gap_tok) & (hmm_paths != 0), 1, 0)


	# find matches positions, use it to create a mask to only keep values at
	# match sites
	match_pos = np.where(np.sum(non_gaps, axis=-1) == 2, True, False)[:,:,None]
	del non_gaps

	match_mask = np.repeat(match_pos, 2, axis=-1)
	del match_pos

	masked_hmm_paths = hmm_paths * match_mask
	del match_mask


	### run get_aa_counts as normal on this masked matrix to get equilibrium
	### distribution ONLY at match positions
	AA_counts_subsOnly = get_aa_counts(masked_hmm_paths)

	out_file = f'{split}_AAcounts_subsOnly.npy'
	with open(out_file, 'wb') as g:
	np.save(out_file, AA_counts_subsOnly)


	def summarize_trans_emiss_counts_wrapper(in_dir, split):
	print(f'Processing {split}')
	### initialize the pytorch dataset object
	dset = pairAlign_dloader(in_dir = in_dir,
	split = split)

	### create a dataloader that returns jax arrays
	dload = DataLoader(dset,
	batch_size = batch_size,
	shuffle = False,
	collate_fn = jax_collator)

	subCounts_lst = []
	insCounts_lst = []
	delCounts_lst = []
	transCounts_lst = []
	for i, batch in enumerate(dload):
	# batch is (batchsize, max_len, 2)
	# lens will be (batchsize, max_len)
	lens = (batch != 0).sum(axis=1)[:,0]
	if i == 0:
	jitted_summarize_alignment = jax.jit(summarize_alignment)


	### use jit-compiled summarize alignment
	out = jitted_summarize_alignment(batch, lens)
	batch_subCounts_persamp = out[0]
	batch_insCounts_persamp = out[1]
	batch_delCounts_persamp = out[2]
	batch_transCounts_persamp = out[3]
	del out

	# adjust types
	batch_subCounts_persamp = safe_convert(batch_subCounts_persamp)
	batch_insCounts_persamp = safe_convert(batch_insCounts_persamp)
	batch_delCounts_persamp = safe_convert(batch_delCounts_persamp)
	batch_transCounts_persamp = safe_convert(batch_transCounts_persamp)

	# append
	subCounts_lst.append(batch_subCounts_persamp)
	insCounts_lst.append(batch_insCounts_persamp)
	delCounts_lst.append(batch_delCounts_persamp)
	transCounts_lst.append(batch_transCounts_persamp)


	# concatenate
	subCounts_persamp = jnp.concatenate(subCounts_lst, axis=0)
	assert subCounts_persamp.shape == (len(dset), 20, 20), f'subCounts shape is wrong: {subCounts_persamp.shape}'
	del subCounts_lst

	insCounts_persamp = jnp.concatenate(insCounts_lst, axis=0)
	assert insCounts_persamp.shape == (len(dset), 20), f'insCounts shape is wrong: {insCounts_persamp.shape}'
	del insCounts_lst

	delCounts_persamp = jnp.concatenate(delCounts_lst, axis=0)
	assert delCounts_persamp.shape == (len(dset), 20), f'delCounts shape is wrong: {delCounts_persamp.shape}'
	del delCounts_lst

	transCounts_persamp = jnp.concatenate(transCounts_lst, axis=0)
	assert transCounts_persamp.shape == (len(dset), 3, 3), f'transCounts shape is wrong: {transCounts_persamp.shape}'
	del transCounts_lst


	# output
	with open(f'./precalculated_counts/{split}_subCounts.npy', 'wb') as g:
	jnp.save(g, subCounts_persamp)

	with open(f'./precalculated_counts/{split}_insCounts.npy', 'wb') as g:
	jnp.save(g, insCounts_persamp)

	with open(f'./precalculated_counts/{split}_delCounts.npy', 'wb') as g:
	jnp.save(g, delCounts_persamp)

	with open(f'./precalculated_counts/{split}_transCounts.npy', 'wb') as g:
	jnp.save(g, transCounts_persamp)


	if __name__ == '__main__':
	import os
	import numpy as np
	from pairAlign_dloader import pairAlign_dloader, jax_collator
	from tqdm import tqdm

	### make sure this still works as expected
	# (M->M) (added START)
	# (M->D)
	# (D->I)
	# (I->M) (added END)
	fake_align = jnp.array([[3, 4, 43, 0],
	[3, 43, 5, 0]]).T[None,:,:]

	true_trans_mat = jnp.array([[1, 0, 1],
	[1, 0, 0],
	[0, 1, 0]])

	true_match_mat = jnp.zeros( (20, 20) )
	true_match_mat = true_match_mat.at[0,0].add(1)

	true_del_vec = jnp.zeros( (20,) )
	true_del_vec = true_del_vec.at[1].add(1)

	true_ins_vec = jnp.zeros( (20,) )
	true_ins_vec = true_ins_vec.at[2].add(1)

	out = summarize_alignment(fake_align,
	3,
	gap_tok=43)

	pred_match_mat = out[0][0]
	pred_ins_vec = out[1][0]
	pred_del_vec = out[2][0]
	pred_trans_mat = out[3][0]
	del out

	assert jnp.allclose(true_match_mat, pred_match_mat)
	assert jnp.allclose(true_del_vec, pred_del_vec)
	assert jnp.allclose(true_ins_vec, pred_ins_vec)
	assert jnp.allclose(true_trans_mat, pred_trans_mat)



	# ### do this for all regular spilts
	# splitnames = [f'TENPERC_split{i}' for i in range(5)]
	# batch_size = 1500

	# for split in splitnames:
	# get_equilib_counts(in_dir = 'tenperc_data_pairAlignments',
	# split = split,
	# gap_tok = 43)

	# summarize_trans_emiss_counts_wrapper(in_dir = 'tenperc_data_pairAlignments',
	# split = split)