pair_alignment/cli/eval_feedforward.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Feb 11 20:45:05 2025

"""
# general python
import os
import shutil
from tqdm import tqdm
from time import process_time
from time import time as wall_clock_time
import numpy as np
import pandas as pd
pd.options.mode.chained_assignment = None # this is annoying
import pickle
from functools import partial
import platform
import argparse
import json
from datetime import datetime

# jax/flax stuff
import jax
import jax.numpy as jnp
import flax
from flax import linen as nn
import optax

# pytorch imports
from torch.utils.tensorboard import SummaryWriter
from torch.utils.data import DataLoader

# custom function/classes imports
from utils.build_optimizer import build_optimizer
from utils.edit_argparse import enforce_valid_defaults
from train_eval_fns.general_training_wrapper.training_wrapper_helpers import (jit_compile_determine_seqlen_bin,
                                                                              jit_compile_determine_alignlen_bin)
from utils.end_training import write_final_eval_results

# specific to training this model
from neural_models.neural_shared.neural_initializer import create_all_tstates 
from utils.edit_argparse import feedforward_fill_with_default_values as fill_with_default_values
from utils.edit_argparse import feedforward_share_top_level_args as share_top_level_args
from train_eval_fns.feedforward_predict_train_eval_one_batch import eval_one_batch
from train_eval_fns.neural_final_eval_wrapper import final_eval_wrapper


def eval_feedforward( args, 
                      dataloader_dict: dict,
                      training_argparse,
                      **kwargs ):
    ###########################################################################
    ### 0: CHECK CONFIG; IMPORT APPROPRIATE MODULES   #########################
    ###########################################################################
    err = (f"{training_argparse.pred_model_type} is not feedforward; "+
           f"using the wrong training script")
    assert training_argparse.pred_model_type == 'feedforward', err
    del err
    
    # model param filenames
    encoder_save_model_filename = f'ANC_ENC_BEST.pkl'
    decoder_save_model_filename = f'DESC_DEC_BEST.pkl'
    finalpred_save_model_filename = f'FINAL_PRED_BEST.pkl'
    all_save_model_filenames = [encoder_save_model_filename, 
                                decoder_save_model_filename,
                                finalpred_save_model_filename]
    
    fill_with_default_values(training_argparse)
    enforce_valid_defaults(training_argparse)
    share_top_level_args(training_argparse)

    # fill in extra
    args.seq_padding_idx = training_argparse.seq_padding_idx
    if not hasattr(args, 'output_attn_weights'):
        args.output_attn_weights = False

    
    ###########################################################################
    ### 1: SETUP   ############################################################
    ###########################################################################
    ### create the eval working directory, if it doesn't exist
    args.logfile_dir = f'{args.eval_wkdir}/logfiles'
    args.logfile_name = f'{args.logfile_dir}/PROGRESS.log'
    args.out_arrs_dir = f'{args.eval_wkdir}/out_arrs'    
    args.model_ckpts_dir = f'{args.eval_wkdir}/model_ckpts'
    if args.eval_wkdir not in os.listdir():
        os.mkdir(args.eval_wkdir)
        os.mkdir(args.logfile_dir)
        os.mkdir(args.out_arrs_dir)
        os.mkdir(args.model_ckpts_dir)
    
    # create a new logfile
    with open(args.logfile_name,'w') as g:
        g.write(f"{datetime.now()}\n\n")
        
        g.write( f'Loading from {args.training_wkdir} to eval new data\n\n' )
        
        g.write( f'Feedforward network to predict alignment-augmented descendant\n' )
        g.write( f'Ancestor sequence embedder (FULL-CONTEXT): {training_argparse.anc_model_type}\n' )
        g.write( f'Descendant sequence embedder (CAUSAL): {training_argparse.desc_model_type}\n' )
        g.write( f'Combine embeddings with: {training_argparse.pred_config["postproc_model_type"]}\n' )
        g.write( f'when reporting, normalizing losses by: descendant length\n\n' )
    
    
    ### extract data from dataloader_dict
    test_dset = dataloader_dict['test_dset']
    test_dl = dataloader_dict['test_dl']
    
    
    ###########################################################################
    ### 2: INITIALIZE MODEL PARTS, OPTIMIZER  #################################
    ###########################################################################
    print('2: model init')
    with open(args.logfile_name,'a') as g:
        g.write('\n')
        g.write(f'2: model init\n')
    
    # need to intialize an optimizer for compatibility when restoring the state, 
    #   but we're not training so this doesn't really matter?
    tx = build_optimizer(training_argparse)
    
    
    ### determine shapes for init
    # unaligned sequences sizes
    global_seq_max_length = test_dset.global_seq_max_length
    largest_seqs = (args.batch_size, global_seq_max_length)
    
    # aligned datasets sizes
    if args.use_scan_fns:
        max_dim1 = args.chunk_length
    
    elif not args.use_scan_fns:
        max_dim1 = test_dset.global_align_max_length - 1
      
    largest_aligns = (args.batch_size, max_dim1)
    del max_dim1
    
    seq_shapes = [largest_seqs, largest_aligns]
    
    # time
    t_per_sample = training_argparse.pred_config['t_per_sample']
    
    if t_per_sample:
        dummy_t_for_each_sample = jnp.empty( (args.batch_size,) )
    
    elif not t_per_sample:
        dummy_t_for_each_sample = None
    
    # batch provided to train/eval functions consist of:
    # 1.) unaligned sequences (B, L_seq, 2)
    # 2.) aligned data matrices (B, L_align, 4)
    # 3.) time per sample; (B,) if present, None otherwise
    # 4, not used.) sample index (B,)
    seq_shapes = [largest_seqs, largest_aligns, dummy_t_for_each_sample]
    
    
    ### initialize functions, determine concat_fn
    out = create_all_tstates( seq_shapes = seq_shapes, 
                              tx = tx, 
                              model_init_rngkey = jax.random.key(0),
                              tabulate_file_loc = args.model_ckpts_dir,
                              anc_model_type = training_argparse.anc_model_type, 
                              desc_model_type = training_argparse.desc_model_type, 
                              pred_model_type = training_argparse.pred_model_type, 
                              anc_enc_config = training_argparse.anc_enc_config, 
                              desc_dec_config = training_argparse.desc_dec_config, 
                              pred_config = training_argparse.pred_config,
                              t_array_for_all_samples = None )  
    blank_trainstates, all_model_instances, concat_fn = out
    del out
    
    # load parameters
    saved_at = f'{args.training_wkdir}/model_ckpts'
    best_trainstates = []
    for i in range(3):
        param_fname = all_save_model_filenames[i]
        blank_tstate = blank_trainstates[i]
        with open(f'{saved_at}/{param_fname}', 'rb') as f:
            state_dict = pickle.load(f)
        ts = flax.serialization.from_state_dict( blank_tstate, state_dict )
        best_trainstates.append(ts)
        del param_fname, blank_tstate, f, state_dict, ts
    
    del i, blank_trainstates, saved_at
    
    
    ### jit-compilations
    # manage sequence lengths
    jitted_determine_seqlen_bin = jit_compile_determine_seqlen_bin(args)
    jitted_determine_alignlen_bin = jit_compile_determine_alignlen_bin(args)
    
    # pass arguments into eval_one_batch; make a parted_eval_fn 
    interms_for_tboard = {k: False for k in training_argparse.interms_for_tboard.keys()}
    interms_for_tboard['embeddings'] = args.embeddings
    interms_for_tboard['forward_pass_outputs'] = args.forward_pass_outputs
    interms_for_tboard['attn_weights'] = args.output_attn_weights
    extra_args_for_eval = {'output_attn_weights': args.output_attn_weights}

    parted_eval_fn = partial( eval_one_batch,
                              all_model_instances = all_model_instances,
                              interms_for_tboard = interms_for_tboard,
                              concat_fn = concat_fn,
                              norm_loss_by_for_reporting = 'desc_len',  
                              extra_args_for_eval = extra_args_for_eval )
    del extra_args_for_eval

    # jit compile this eval function
    eval_fn_jitted = jax.jit( parted_eval_fn, 
                              static_argnames = ['max_seq_len', 'max_align_len'])
    del parted_eval_fn

    ###########################################################################
    ### 3: EVAL   #############################################################
    ###########################################################################
    print(f'BEGIN EVAL')
    # write to logfile
    with open(args.logfile_name,'a') as g:
        g.write('\n')
        g.write(f'BEGIN EVAL\n')
        
    test_summary_stats = final_eval_wrapper(dataloader = test_dl, 
                                             dataset = test_dset, 
                                             best_trainstates = best_trainstates, 
                                             jitted_determine_seqlen_bin = jitted_determine_seqlen_bin,
                                             jitted_determine_alignlen_bin = jitted_determine_alignlen_bin,
                                             eval_fn_jitted = eval_fn_jitted,
                                             out_alph_size = training_argparse.out_alph_size, 
                                             save_arrs = args.save_arrs,
                                             save_per_sample_losses = args.save_per_sample_losses,
                                             interms_for_tboard = interms_for_tboard, 
                                             logfile_dir = args.logfile_dir,
                                             out_arrs_dir = args.out_arrs_dir,
                                             outfile_prefix = f'test-set')

    # save the trainstate again
    for i in range(len(best_trainstates)):
        new_outfile = f'{args.model_ckpts_dir}/{all_save_model_filenames[i]}'
        new_outfile = new_outfile.replace('.pkl',f'_BEST.pkl')
        with open(new_outfile, 'wb') as g:
            model_state_dict = flax.serialization.to_state_dict(best_trainstates[i])
            pickle.dump(model_state_dict, g)   
    
    # output average losses
    write_final_eval_results(args = args, 
                             summary_stats = test_summary_stats,
                             filename = 'AVE-LOSSES.tsv')