#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Fri Aug 9 15:52:59 2024 about: ======= ModuleBase: gives each model the sow_flax_intermeds and summary_stats helpers, for tensorboard writing neuralTKFModuleBase: adds functions for automatically applying key activations: bound_sigmoid and log_softmax SeqEmbBase: inherits ModuleBase and adds extra helpers for sequence embedding applying encoder and decoder in training/eval; the following models will need newer versions (and why): - LSTM (uses "datalens" in argument list) - Transformer (handle "output attn weights" argument) - if you ever want to implement BatchNorm, rage quit and migrate to flax.NNX (jk) """ from flax import linen as nn import jax import jax.numpy as jnp import optax from neural_models.neural_hmm_predict.model_functions import bound_sigmoid from typing import Callable, Literal from numpy.typing import ArrayLike class ModuleBase(nn.Module): def summary_stats(self, mat: ArrayLike, key_prefix: str, include_min_max: bool = False, include_perc_zeros: bool = False ): """ extract metrics from matrix NOTE: metrics could be skewed with many zeros arguments --------- mat : ArrayLike the matrix of interest key_prefix : str the variable name include_min_max, include per_zeros : bool if true, also include max, min, and percent zeros returns ------- out_dict : dict dictionary containing summary stats """ if mat.size == 1: out_dict = {f'{key_prefix}': jnp.squeeze(mat)} else: # always include: L2 norm, mean, variance l2_norm = jnp.linalg.norm(mat.reshape(-1), ord=2) mean = mat.mean() variance = mat.var() out_dict = {f'{key_prefix}/L2_NORM': l2_norm, f'{key_prefix}/MEAN': mean, f'{key_prefix}/VAR': variance} # optional inclusions if include_min_max: out_dict[f'{key_prefix}/MAX'] = mat.max() out_dict[f'{key_prefix}/MIN'] = mat.min() if include_perc_zeros: out_dict[f'{key_prefix}/PERC_ZEROS'] = (mat==0).sum() / mat.size return out_dict def sow_flax_intermeds(self, mat: ArrayLike, label: str, include_min_max: bool = False, include_perc_zeros: bool = False): """ helper to sow intermediate values arguments --------- mat : ArrayLike the matrix of interest label : str the variable name """ # summarize out_dict = self.summary_stats(mat=mat, key_prefix=label, include_min_max=include_min_max, include_perc_zeros=include_perc_zeros) # sow; only keep the most recent value for name, value in out_dict.items(): self.sow(col = "sowed_intermeds", name = name, value = value, reduce_fn = lambda a, b: b) def maybe_sow(self, sow_flax_intermeds: bool, vals: ArrayLike, label: str, include_min_max: bool = False, include_perc_zeros: bool = False): """ sow_flax_intermeds : bool do this function or not vals : ArrayLike values to summarize and record label : str parameter name include_min_max, include_perc_zeros : bool include min, max, and zeros (I don't always need to do this) """ if sow_flax_intermeds: self.sow_flax_intermeds(mat=vals, label=label, include_min_max=include_min_max, include_perc_zeros=include_perc_zeros) class neuralTKFModuleBase(ModuleBase): """ base class for neural TKF / neural HMM models methods: --------- maybe_sow : a wrapper around sow_flax_intermeds apply_bound_sigmoid_activation : a wrapper around bound_sigmoid apply_log_softmax_activation : a wrapper around log_softmax inherited from ModuleBase: -------------------------- maybe_sow sow_flax_intermeds summary_stats """ def apply_bound_sigmoid_activation(self, logits: ArrayLike, min_val: float, max_val: float, param_name: str, sow_flax_intermeds: bool, include_min_max: bool = False, include_perc_zeros: bool = False): """ sigmoid(x) = 1 / ( 1 + exp(-x) ) bound_sigmoid(x, min, max) = min + ( ( max - min ) / ( 1 + exp(-x) ) ) """ params = bound_sigmoid(logits, min_val, max_val) self.maybe_sow( vals = params, label = f'{self.name}/{param_name}', sow_flax_intermeds = sow_flax_intermeds, include_min_max=include_min_max, include_perc_zeros=include_perc_zeros ) return params def apply_log_softmax_activation(self, logits: ArrayLike, param_name: str, sow_flax_intermeds: bool, include_min_max: bool = False, include_perc_zeros: bool = False): """ log_softmax(x) = log( softmax(x) ) """ params = nn.log_softmax( logits, axis = -1 ) self.maybe_sow( vals = params, label = f'{self.name}/{param_name}', sow_flax_intermeds = sow_flax_intermeds, include_min_max=include_min_max, include_perc_zeros=include_perc_zeros ) return params class SeqEmbBase(ModuleBase): """ base class for neural sequence embedding models methods: --------- apply_seq_embedder_in_training : apply model during training update_seq_embedder_tstate : update parameters based on gradients apply_seq_embedder_in_eval : apply model during training inherited from ModuleBase: -------------------------- maybe_sow sow_flax_intermeds summary_stats """ def apply_seq_embedder_in_training(self, seqs: ArrayLike, tstate, rng_key, params_for_apply: dict, sow_flax_intermeds: bool, *args, **kwargs): """ apply model during training arguments ---------- seqs : ArrayLike inputs for function tstate : Flax.Trainstate trainstate for sequence embedder rng_key : Jax rng (whatever type that is) rng key if needed (for example: for dropout) params_for_apply : dict parameters for trainstate object sow_flax_intermeds : bool whether or not to record intermediates, broadly never record min, max, or percent zeros for these returns ------- out_embeddings : ArrayLike per-position sequence embeddings aux_data : dict contains output, weight, and gradient from flax.sow, as well as any additional values needed for embedding the ancestor """ # embed the sequence out_embeddings, out_aux_dict = tstate.apply_fn(variables = params_for_apply, datamat = seqs, training = True, sow_flax_intermeds = sow_flax_intermeds, mutable = ["sowed_intermeds"] if sow_flax_intermeds else [], rngs={'dropout': rng_key}) # pack up all the auxilary data metrics_dict_name = f'{self.embedding_which}_layer_intermediates' aux_data = {f'{metrics_dict_name}/sowed_intermeds' : out_aux_dict.get("sowed_intermeds", dict()) } # if you ever use batch norm in ancestor sequence embedder, need # to replace this whole method and extract batch_stats from out_aux_dict if self.embedding_which == 'anc': aux_data['anc_aux'] = None return (out_embeddings, aux_data) def update_seq_embedder_tstate(self, tstate, new_opt_state, optim_updates, *args, **kwargs): """ If you apply batch norm ever, you'll need a new one of these arguments ---------- tstate : Flax.Trainstate trainstate for sequence embedder new_opt_state : optimizer to overwrite optim_updates : updates to apply returns -------- new_tstate : Flax.Trainstate updated trainstate """ new_params = optax.apply_updates(tstate.params, optim_updates) new_tstate = tstate.replace(params = new_params, opt_state = new_opt_state) return new_tstate def apply_seq_embedder_in_eval(self, seqs: ArrayLike, tstate, sow_flax_intermeds: bool, *args, **kwargs): """ apply model during eval steps arguments ---------- seqs : ArrayLike inputs for function tstate : Flax.Trainstate trainstate for sequence embedder sow_flax_intermeds : bool whether or not to record intermediates, broadly never record min, max, or percent zeros for these returns ------- out_embeddings : ArrayLike per-position sequence embeddings aux_data : dict contains output, weight, and gradient from flax.sow, as well as any additional values needed for embedding the ancestor """ # embed the sequence out_embeddings, out_aux_dict = tstate.apply_fn(variables = tstate.params, datamat = seqs, training = False, sow_flax_intermeds = sow_flax_intermeds, mutable = ["sowed_intermeds"] if sow_flax_intermeds else []) # pack up all the auxilary data metrics_dict_name = f'{self.embedding_which}_layer_intermediates' aux_data = {f'{metrics_dict_name}/sowed_intermeds' : out_aux_dict.get("sowed_intermeds", dict()) } # if you ever use batch norm in ancestor sequence embedder, need # to replace this whole method and extract batch_stats from out_aux_dict if self.embedding_which == 'anc': aux_data['anc_aux'] = None return (out_embeddings, aux_data)