pair_alignment/neural_models/neural_shared/postprocessing_models.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Jan 27 12:44:26 2025


About:
=======
Concatenated outputs from both sequence embedders and postprocess for 
downstream blocks that create logits, features, etc.


classes available:
==================
1.) SelectMask: concatenate outputs from sequence embedders, possibly norm
2.) FeedforwardPostproc: repeat blocks of norm -> dense -> act -> dropout

"""
from flax import linen as nn
import jax
import jax.numpy as jnp

from typing import Optional

from utils.BaseClasses import ModuleBase


class SelectMask(ModuleBase):
    config: dict
    name: str
    
    def setup(self):
        self.use_anc_emb = self.config['use_anc_emb']
        self.use_desc_emb = self.config['use_desc_emb']
        self.use_prev_align_info = self.config['use_prev_align_info']
        self.use_t_per_sample = self.config.get('t_per_sample', False)
        self.normalize_seq_embeddings_before_block = self.config.get('normalize_seq_embeddings_before_block', False)
        
        if self.normalize_seq_embeddings_before_block:
            self.norm = nn.LayerNorm( reduction_axes= -1, 
                                      feature_axes=-1,
                                      name = f'{self.name}/InstanceNorm')
    
    def _mask_padding_tokens( self,
                             x: jnp.array, 
                             mask: jnp.array ):
        expanded_mask = jnp.broadcast_to( mask[...,None], x.shape ) 
        return jnp.multiply(expanded_mask, x)
    
    
    def _concatenate_and_norm( self,
                               padding_mask: jnp.array,
                               anc_emb: Optional[jnp.array] = None,
                               desc_causal_emb: Optional[jnp.array] = None,
                               prev_align_one_hot_vec: Optional[jnp.array] = None,
                               t_array: Optional[jnp.array] = None,
                               norm_fn = None ):
        ### combine sequence embeddings
        to_concat = []
        if self.use_anc_emb and (anc_emb is not None):
            to_concat.append( anc_emb )
            
        if self.use_desc_emb and (desc_causal_emb is not None):
            to_concat.append( desc_causal_emb )
        
        # concatenate, mask; embeddings_datamat could be:
        #   (B, L_align, H): (use_anc_emb | use_desc_emb) 
        #   (B, L_align, 2H): (use_anc_emb & use_desc_emb) 
        embeddings_datamat = jnp.concatenate( to_concat, axis = -1 ) # (B, L, n*H)
        del to_concat
        
        # possibly normalize and mask
        embeddings_datamat = norm_fn(embeddings_datamat) # (B, L, n*H)
        embeddings_datamat = self._mask_padding_tokens( x = embeddings_datamat,
                                                        mask = padding_mask ) # (B, L, n*H)
            
        
        ### possibly concat other things (outside of normalization)
        to_concat = [embeddings_datamat]
        
        if self.use_prev_align_info and (prev_align_one_hot_vec is not None):
            to_concat.append(prev_align_one_hot_vec) #(B, L, 5)
        
        if self.use_t_per_sample and (t_array is not None):
            B = t_array.shape[0]
            L = embeddings_datamat.shape[1]
            out_shape = ( (B, L, 1) )
            t_array_exp = jnp.broadcast_to( t_array[..., None, None], out_shape ) #(B, L, 1)
            to_concat.append( t_array_exp )
            
        datamat = jnp.concatenate( [] + to_concat, axis=-1 ) #(B, L, H_out)
        
        # mask again
        datamat = self._mask_padding_tokens( x = datamat,
                                             mask = padding_mask )
        
        return datamat
    
        
    def __call__(self,
                 sow_flax_intermeds: bool,
                 anc_emb: Optional[jnp.array] = None,
                 desc_causal_emb: Optional[jnp.array] = None,
                 prev_align_one_hot_vec: Optional[jnp.array] = None,
                 t_array: Optional[jnp.array] = None,
                 padding_mask: Optional[jnp.array] = None,
                 *args,
                 **kwargs):
        """
        B: batch size
        L_align: length of alignment
        
        Arguments
        ----------
        sow_flax_intermeds : bool

        anc_emb : ArrayLike, (B, L, H) or None
        
        desc_causal_emb : ArrayLike, (B, L, H) or None
        
        prev_align_one_hot_vec : ArrayLike, (B, L, 5) or None
        
        t_array : ArrayLike, (B,) or None
            > note: this is ONE unique time per branch length!

        padding_mask : ArrayLike, (B, L) or None
        
        Returns
        --------
        datamat : ArrayLike, (B, L_align, H_out)
            concatenated/masked data
            
        """
        datamat = self._concatenate_and_norm( padding_mask = padding_mask,
                                              anc_emb = anc_emb, 
                                              desc_causal_emb = desc_causal_emb,
                                              prev_align_one_hot_vec = prev_align_one_hot_vec,
                                              t_array = t_array,
                                              norm_fn = lambda x: x if not self.normalize_seq_embeddings_before_block else self.norm )
        
        # possibly sow values
        self.maybe_sow(sow_flax_intermeds = sow_flax_intermeds,
                       vals = datamat,
                       label = f'{self.name}/concatenated_embeddings_features',
                       include_min_max = True,
                       include_perc_zeros = True)
        
        return datamat
        

class FeedforwardPostproc(SelectMask):
    """
    apply this blocks as many times as specified by layer_sizes: 
        [norm -> dense -> activation -> dropout]
    """
    config: dict
    name: str
    
    def setup(self):
        """
        B = batch size
        L_align = alignment length
        A = alphabet size
        
        """
        ### read config
        # required
        self.layer_sizes = self.config['layer_sizes']
        self.use_anc_emb = self.config['use_anc_emb']
        self.use_desc_emb = self.config['use_desc_emb']
        self.use_prev_align_info = self.config['use_prev_align_info']
        
        # optional
        self.use_t_per_sample = self.config.get('use_t_per_sample', False)
        self.normalize_seq_embeddings_before_block = self.config.get("normalize_seq_embeddings_before_block", True)
        self.dropout = self.config.get("dropout", 0.0)
        use_bias = self.config.get("use_bias", True)
        
        
        ### set up parameterized layers of the MLP
        dense_layers = []
        norm_layers = []
        
        # first layer: possible instance norm and dense
        if self.normalize_seq_embeddings_before_block:
            norm_layers.append( nn.LayerNorm( reduction_axes= -1, 
                                              feature_axes=-1,
                                              name = f'{self.name}/instance norm 0') )
        
        elif not self.normalize_seq_embeddings_before_block:
            norm_layers.append( lambda x: x )
        
        dense_layers.append( nn.Dense(features = self.layer_sizes[0], 
                                      use_bias = use_bias, 
                                      kernel_init = nn.initializers.lecun_normal(),
                                      name=f'{self.name}/feedforward layer 0') )
        
        # subsequent normalization and dense layers
        for i, hid_dim in enumerate(self.layer_sizes[1:]):
            layer_idx = i + 1
            norm_layers.append( nn.LayerNorm( reduction_axes= -1, 
                                              feature_axes=-1,
                                              name = f'{self.name}/instance norm {layer_idx}') )
            dense_layers.append( nn.Dense(features = hid_dim, 
                                          use_bias = use_bias, 
                                          kernel_init = nn.initializers.lecun_normal(),
                                          name=f'{self.name}/feedforward layer {layer_idx}') )
            
        self.dense_layers = dense_layers
        self.norm_layers = norm_layers
        self.act= nn.silu 
    
    @nn.compact
    def __call__(self, 
                 sow_flax_intermeds: bool,
                 training: bool,
                 anc_emb: Optional[jnp.array] = None,
                 desc_causal_emb: Optional[jnp.array] = None,
                 prev_align_one_hot_vec: Optional[jnp.array] = None,
                 t_array: Optional[jnp.array] = None,
                 padding_mask: Optional[jnp.array] = None,
                 *args,
                 **kwargs):
        """
        B: batch size
        L_align: length of alignment
        H_in, H_out: size of embedding dimension in/out of this block
        
        Arguments
        ----------
        sow_flax_intermeds : bool

        anc_emb : ArrayLike, (B, L, H) or None
        
        desc_causal_emb : ArrayLike, (B, L, H) or None
        
        prev_align_one_hot_vec : ArrayLike, (B, L, 5) or None
        
        t_array : ArrayLike, (B,) or None
            > note: this is ONE unique time per branch length!

        padding_mask : ArrayLike, (B, L) or None
        
        Returns
        --------
        datamat : ArrayLike, (B, L_align, H_out)
            concatenated and post-processed data
            > n=1, if only using ancestor embedding OR descendant embedding
            > n=2, if using both embeddings
        """
        ### First block
        # 1.) select (potentially concat+norm) the ancestor and descendant embeddings
        # padding tokens are masked in this function
        datamat = self._concatenate_and_norm( padding_mask = padding_mask,
                                              anc_emb = anc_emb, 
                                              desc_causal_emb = desc_causal_emb,
                                              prev_align_one_hot_vec = prev_align_one_hot_vec,
                                              t_array = t_array,
                                              norm_fn = None if not self.normalize_seq_embeddings_before_block else self.norm_layers[0] ) #(B, L, H_out)
        
        # 2.) dense layer, mask
        datamat = self.dense_layers[0](datamat) #(B, L, hid_dim[0] )
        datamat = self._mask_padding_tokens( x=datamat,
                                             mask=padding_mask ) #(B, L, hid_dim[0] )
        
        # 3.) activation
        datamat = self.act(datamat) #(B, L, hid_dim[0] )
        
        # 4.) dropout
        datamat = nn.Dropout(rate = self.dropout)(datamat,
                                            deterministic = not training)  #(B, L, layer_sizes[0] )
         
        # record results from first block
        self.maybe_sow(sow_flax_intermeds = sow_flax_intermeds,
                       vals = datamat,
                       label = f'{self.name}/final_feedforward_layer_0/after_dropout',
                       include_min_max = True,
                       include_perc_zeros = False)
        
        # mask tokens after block
        datamat = self._mask_padding_tokens( x=datamat,
                                             mask=padding_mask ) #(B, L, layer_sizes[0] )
        
        
        ### Subsequent blocks: norm -> dense -> activation -> dropout
        for i in range( len(self.layer_sizes[1:]) ):
            layer_idx = i + 1
             
            # 1.) instance norm, mask
            datamat = self.norm_layers[layer_idx](datamat) #(B, L, layer_sizes[layer_idx-1])
            datamat = self._mask_padding_tokens( x=datamat,
                                                 mask=padding_mask ) #(B, L, layer_sizes[layer_idx-1])
            
            # 2.) dense, mask
            datamat = self.dense_layers[layer_idx](datamat) #(B, L, layer_sizes[layer_idx-1])
            datamat = self._mask_padding_tokens( x=datamat,
                                                 mask=padding_mask ) #(B, L, layer_sizes[layer_idx-1])
            
            # 3.) activation
            datamat = self.act(datamat) #(B, L, layer_sizes[layer_idx-1])
            
            # 4.) dropout
            datamat = nn.Dropout(rate = self.dropout)(datamat,
                                                deterministic = not training) #(B, L, layer_sizes[layer_idx-1])
            
            # record results from first block
            self.maybe_sow(sow_flax_intermeds = sow_flax_intermeds,
                           vals = datamat,
                           label = (f'{self.name}/'+
                                    f'final_feedforward_layer_{layer_idx}/'+
                                    f'after_dropout'),
                           include_min_max = True,
                           include_perc_zeros = False)
        
            # mask out padding tokens after block
            datamat = self._mask_padding_tokens( x=datamat,
                                                 mask=padding_mask ) #(B, L, layer_sizes[-1])
            
        return datamat  #(B, L, layer_sizes[-1])