monet_code/src/trainer.py

from trl import SFTTrainer, SFTConfig
from typing import Optional
import logging
import torch
import os, csv, torch, datetime
import gc
import numpy as np
import math
from time import time
from src.utils import apply_input_img_attn_mask

def compute_latents_only_loss(latents, loss_for_latents):
    '''
    Compute a loss (`loss_for_latents`) that backpropagates only through the latent embeddings `latents`.
    '''
    def _flatten_tensors(x):
                # Flatten nested [list/tuple of Tensors] into a flat list of Tensors
                if isinstance(x, (list, tuple)):
                    out = []
                    for y in x:
                        out.extend(_flatten_tensors(y))
                    return out
                return [x]

    ce_vec_list = _flatten_tensors(latents)
    grads = torch.autograd.grad(
        outputs=loss_for_latents,
        inputs=ce_vec_list,
        retain_graph=True,   # we won't reuse the 3rd graph
        create_graph=False,   # stop higher-order graph
        allow_unused=True     # in case some ce vectors are not used
    )

    # Replace None with zeros for unused elements
    safe_grads = []
    for v, g in zip(ce_vec_list, grads):
        if g is None:
            # Create a zero tensor on the same device/dtype/shape
            g = torch.zeros_like(v)
        safe_grads.append(g.detach())  # detach to stop any 3rd-forward param pathg

    proxy_loss = torch.stack([(v * g).sum() for v, g in zip(ce_vec_list, safe_grads)]).sum()
    return proxy_loss

def load_offline_tensor(tensor_dir, batch_metadata, alignment_layer="all_layers", rep_type="rep", align_poss="obs"):
    '''
    Load precomputed teacher representations (observation tokens for the alignment in SFT stage 2 or the latent embeddings for SFT stage 3)
    '''
    teacher_reps = None
    latents_list = []
    for metadata in batch_metadata:
        dataset_name = metadata['dataset_name']
        sample_id = metadata['sample_id']
        metadata_info = f"{alignment_layer}_{dataset_name}_{sample_id}"
        if align_poss == 'obs':
            metadata_str = f"{rep_type}_{metadata_info}.pt"
        elif align_poss == 'latent_end':
            metadata_str = f"{rep_type}_latent_end_{metadata_info}.pt"
        path = os.path.join(tensor_dir, metadata_str)
        if not os.path.isfile(path):
            latents_list = []
            raise RuntimeError(f"Missing teacher latent file: {path}")
        data = torch.load(path, map_location='cpu')
        latents_list.append(data['latent'].detach())
    if batch_metadata is not None and len(latents_list) == len(batch_metadata):
        teacher_reps = latents_list
    return teacher_reps


class CustomTrainerSFT_STAGE1(SFTTrainer):
    def __init__(self, *args, **kwargs):
        self.exp_name =kwargs.pop('exp_name')
        kwargs.pop('online_teacher', None)  # accepted for symmetry; unused in stage 1
        # accept processing_class (preferred) and fall back to tokenizer for backward compat
        if 'processing_class' not in kwargs and 'tokenizer' in kwargs:
            kwargs['processing_class'] = kwargs.pop('tokenizer')
        super().__init__(*args, **kwargs)
        self.observation_token_acc = 0.
        self.observation_token_acc_step = 0
        self.teacher_ce_cum = 0.0        # cumulative student CE loss
        self.teacher_ce_steps = 0

    def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
        """
        Compute training loss and additionally compute token accuracies
        """
        inputs['latent_mode'] = False
        inputs['input_ids'] = inputs['teacher_input_ids']
        inputs['attention_mask'] = inputs['teacher_attention_mask']
        inputs['pixel_values'] = inputs['teacher_pixel_values']
        inputs['image_grid_thw'] = inputs['teacher_image_grid_thw']
        inputs['labels'] = inputs['teacher_labels']
        inputs['ce_emphasize_poss'] = inputs['teacher_observation_poss']
        # Dynamic warmup factor passed to model.forward
        inputs['ce_emphasize_factor'] = self.args.ce_emphasize_factor
        inputs['loss_type'] = ['ce']
        inputs['compute_emphasize_acc'] = True
        (teacher_ce_loss, teacher_outputs) = super().compute_loss(
                model,
                inputs,
                return_outputs=True, num_items_in_batch=num_items_in_batch
            )

        self.teacher_ce_cum += teacher_ce_loss.item()
        self.teacher_ce_steps += 1

        if getattr(teacher_outputs, 'mean_emphasize_acc', None) is not None:
            self.observation_token_acc += getattr(teacher_outputs, 'mean_emphasize_acc')
            self.observation_token_acc_step += 1

        del teacher_outputs
        gc.collect()
        torch.cuda.empty_cache()

        return (teacher_ce_loss, None) if return_outputs else teacher_ce_loss

    def on_epoch_end(self):
        return super().on_epoch_end()

    def log(self, logs: dict, start_time: float | None = None):
        # Merge our rolling averages into the standard logs once per logging call
        merged = dict(logs)
        if self.teacher_ce_steps > 0:
            merged["student_ce_loss"] = round(self.teacher_ce_cum / max(1, self.teacher_ce_steps), 6)
            self.teacher_ce_cum = 0.0
            self.teacher_ce_steps = 0
        if self.observation_token_acc_step > 0:
            merged["observation_token_acc"] = round(self.observation_token_acc/ max(1, self.observation_token_acc_step), 6)
            self.observation_token_acc = 0.
            self.observation_token_acc_step = 0

        # Call parent to keep default behavior (console/TB/W&B/etc.)
        return super().log(merged, start_time)



class CustomTrainerSFT_STAGE2(SFTTrainer):
    def __init__(self, *args, **kwargs):
        self.exp_name = kwargs.pop('exp_name')
        self.online_teacher = kwargs.pop('online_teacher', None)
        # accept processing_class (preferred) and fall back to tokenizer for backward compat
        if 'processing_class' not in kwargs and 'tokenizer' in kwargs:
            kwargs['processing_class'] = kwargs.pop('tokenizer')
        super().__init__(*args, **kwargs)

        self.ce_emphasize_factor = self.args.ce_emphasize_factor
        self.teacher_ce_loss_cum = 0.0        # cumulative teacher CE loss
        self.teacher_ce_loss_steps = 0
        self.observation_token_acc = 0.
        self.observation_token_acc_step = 0
        self.alignment_loss_cum = 0.
        self.alignment_loss_steps = 0


    def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
        """
        Compute training loss and additionally compute token accuracies
        """
        # ------------------------------------------------------------------
        # Latent forward to get ce_patch_pos (positions of latent embeddings) and ce_patch_vec (latent embeddings).
        # Multiple forward is needed since we need to autoregressively generate latents.
        # ------------------------------------------------------------------
        inputs['latent_mode'] = True
        inputs['loss_type'] = []
        model.gradient_checkpointing_disable() # since we set use_cache=True in latent forward, we must disable grad checkpointing
        outputs = model(**inputs, return_dict=True, output_hidden_states=False)

        # ------------------------------------------------------------------
        # Insert the collected latent embeddings into the latent positions, and forward once.
        # ------------------------------------------------------------------
        model.gradient_checkpointing_enable(gradient_checkpointing_kwargs={"use_reentrant": False})
        inputs['latent_mode'] = False
        inputs['ce_patch_pos'] = outputs.ce_patch_pos
        inputs['ce_patch_vec'] = outputs.ce_patch_vec
        no_text_mode = 'latent_pad_poss' in inputs
        inputs['ce_emphasize_poss'] = [] if no_text_mode else inputs['observation_poss']
        inputs['ce_emphasize_factor'] = self.ce_emphasize_factor
        inputs['loss_type'] = ['ce']
        if self.args.alignment_weight != 0:
            inputs['loss_type'].append('alignment')

        inputs['compute_emphasize_acc'] = False if no_text_mode else True
        # Ensure training forward does NOT request attentions (prevents checkpoint recompute mismatch)
        inputs.pop('output_attentions', None)
        inputs.pop('attn_analysis', None)

        if self.args.alignment_weight != 0:
            # Teacher representations: in-process when --online_teacher is set, otherwise from disk.
            # Both paths return list[CPU Tensor [L+1, N*latent_size, D]] with the same content.
            if self.online_teacher is not None:
                teacher_reps = self.online_teacher(inputs)
            else:
                teacher_reps = load_offline_tensor(
                    self.args.teacher_reps_dir,
                    batch_metadata=inputs['metadata'],
                    alignment_layer=self.args.alignment_layer,
                )
            inputs['alignment_poss'] = inputs['latent_pad_poss'] if no_text_mode else inputs['observation_poss']

            inputs['teacher_hidden_states_for_alignment'] = teacher_reps

        teacher_ce_loss, teacher_output = super().compute_loss(
                model,
                inputs,
                return_outputs=True, num_items_in_batch=num_items_in_batch
            )

        alignment_loss = teacher_output.loss_dict.get('alignment', torch.tensor(0.0))
        if self.args.emphasize_latent_weight != 0.0 and alignment_loss.item() != 0.0: # latent-only backpropagation for alignment loss
            latent_only_loss = compute_latents_only_loss(outputs.ce_patch_vec, self.args.alignment_weight * alignment_loss)
            loss = self.args.emphasize_latent_weight * latent_only_loss + teacher_ce_loss
        else:
            loss = teacher_ce_loss + self.args.alignment_weight * alignment_loss

        if getattr(teacher_output, 'mean_emphasize_acc', None) is not None:
            self.observation_token_acc += getattr(teacher_output, 'mean_emphasize_acc')
            self.observation_token_acc_step += 1

        self.teacher_ce_loss_cum += teacher_ce_loss.item()
        self.teacher_ce_loss_steps += 1
        self.alignment_loss_cum += alignment_loss.item()
        self.alignment_loss_steps += 1

        # Light-touch cleanup without forcing GPU sync every step
        #del teacher_outputs
        step = int(getattr(self.state, 'global_step', 0) or 0)
        if step % 50 == 0:
            try:
                gc.collect()
                # Avoid calling empty_cache() each step
                torch.cuda.empty_cache()
            except Exception:
                pass

        return (loss, None) if return_outputs else loss


    def on_epoch_end(self):
        return super().on_epoch_end()

    def log(self, logs: dict, start_time: float | None = None):
        # Merge our rolling averages into the standard logs once per logging call
        merged = dict(logs)
        if self.teacher_ce_loss_cum > 0:
            merged["teacher_ce_loss"] = round(self.teacher_ce_loss_cum / max(1, self.teacher_ce_loss_steps), 6)
            self.teacher_ce_loss_cum = 0.0
            self.teacher_ce_loss_steps = 0
        if self.alignment_loss_cum > 0:
            merged[f'alignment_loss'] = round(self.alignment_loss_cum / max(1, self.alignment_loss_steps), 6)
            self.alignment_loss_cum = 0.0
            self.alignment_loss_steps = 0
        if self.observation_token_acc_step > 0:
            merged["observation_token_acc"] = round(self.observation_token_acc/ max(1, self.observation_token_acc_step), 6)
            self.observation_token_acc = 0.
            self.observation_token_acc_step = 0


        # Call parent to keep default behavior (console/TB/W&B/etc.)
        return super().log(merged, start_time)

class CustomTrainerSFT_STAGE3(SFTTrainer):
    def __init__(self, *args, **kwargs):
        self.exp_name =kwargs.pop('exp_name')
        self.online_teacher = kwargs.pop('online_teacher', None)
        super().__init__(*args, **kwargs)
        self.alignment_weight = self.args.alignment_weight
        self.ce_emphasize_factor: float = float(getattr(self.args, 'ce_emphasize_factor', 1.0))
        # Where to read precomputed teacher latents (also reused as the online cache dir)
        self.teacher_latent_dir = getattr(self.args, 'teacher_latent_dir', None)
        if self.online_teacher is None and not self.teacher_latent_dir:
            raise ValueError("teacher_latent_dir must be specified for offline SFT Stage 3")

        self.observation_token_acc = 0.
        self.observation_token_acc_step = 0
        self.al_loss_cum = 0.0       # cumulative alignment loss since last log
        self.al_steps = 0            # number of micro-steps accumulated
        self.student_ce_loss_cum = 0.0        # cumulative student CE loss
        self.student_ce_loss_steps = 0

        # ---- Stage-3 input-image attention-mask curriculum ----
        # OFF BY DEFAULT: img_mask_curriculum defaults to False, so the per-step masking block in
        # compute_loss is skipped entirely and training matches the original Monet (no mask).
        # When enabled, decay the answer->input-image masking ratio from `start` to `end` over
        # training so the final steps match inference (where the model sees the full input image).
        # Applied here (not in collate) because only the trainer sees global_step / max_steps.
        self.img_mask_curriculum = bool(getattr(self.args, 'stage3_img_mask_curriculum', False))
        self.img_mask_start = float(getattr(self.args, 'stage3_img_mask_start', 0.7))
        self.img_mask_end = float(getattr(self.args, 'stage3_img_mask_end', 0.0))
        self.img_mask_schedule = str(getattr(self.args, 'stage3_img_mask_schedule', 'linear'))
        self.special_token_ids = getattr(self.args, 'special_token_ids', None)
        self._cur_img_mask_ratio = 0.0  # last applied ratio, for logging
        if self.img_mask_curriculum and self.special_token_ids is None:
            raise ValueError("stage3_img_mask_curriculum requires special_token_ids on training_args")

    def _curriculum_img_mask_ratio(self) -> float:
        """Ratio for the current optimizer step: start -> end as global_step -> max_steps."""
        max_steps = float(getattr(self.state, 'max_steps', 0) or 0)
        step = float(getattr(self.state, 'global_step', 0) or 0)
        progress = min(1.0, max(0.0, step / max_steps)) if max_steps > 0 else 0.0
        if self.img_mask_schedule == 'cosine':
            frac = 0.5 * (1.0 + math.cos(math.pi * progress))  # 1 -> 0
        else:  # linear
            frac = 1.0 - progress
        return self.img_mask_end + (self.img_mask_start - self.img_mask_end) * frac

    def _raise_if_nonfinite_loss(self, name: str, value, inputs):
        if not torch.is_tensor(value):
            return
        value_detached = value.detach()
        if torch.isfinite(value_detached).all().item():
            return

        labels = inputs.get('labels', inputs.get('student_labels'))
        valid_label_count = None
        if torch.is_tensor(labels):
            valid_label_count = int((labels != -100).sum().detach().cpu().item())

        align_poss = inputs.get('alignment_poss', inputs.get('student_alignment_poss', []))
        align_counts = []
        for poss in align_poss:
            try:
                align_counts.append(len(poss))
            except TypeError:
                align_counts.append(None)

        metadata_preview = []
        for item in inputs.get('metadata', [])[:2]:
            if isinstance(item, dict):
                metadata_preview.append({
                    'dataset_name': item.get('dataset_name'),
                    'sample_id': item.get('sample_id'),
                })
            else:
                metadata_preview.append(str(item))

        flat = value_detached.reshape(-1).float()
        first_value = float(flat[0].detach().cpu().item()) if flat.numel() else float('nan')
        raise RuntimeError(
            f"[stage3] non-finite {name}: first_value={first_value}, "
            f"shape={tuple(value_detached.shape)}, global_step={getattr(self.state, 'global_step', None)}, "
            f"valid_label_count={valid_label_count}, alignment_counts={align_counts}, "
            f"metadata={metadata_preview}"
        )

    def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
        """
        Compute training loss for SFT stage3 with optional cached teacher latents.
        """
        # ---- optional param-finiteness probe (env-gated) ----
        if os.environ.get("MONET_NAN_DEBUG", ""):
            _step = int(getattr(self.state, 'global_step', 0) or 0)
            _bad = 0
            for _n, _p in model.named_parameters():
                if _p is not None and _p.numel() and not torch.isfinite(_p.data).all():
                    _bad += 1
                    if _bad <= 3:
                        logging.error(f"[NAN_DEBUG] param NON-FINITE at step={_step}: {_n}")
            if _bad:
                logging.error(f"[NAN_DEBUG] total non-finite params at step={_step}: {_bad}")

        # Teacher latents: in-process when --online_teacher is set, otherwise from disk.
        # Both paths return list[CPU Tensor [L+1, N*latent_size, D]] with the same content.
        if self.online_teacher is not None:
            teacher_latents = self.online_teacher(inputs)
        else:
            teacher_latents = load_offline_tensor(
                self.teacher_latent_dir,
                batch_metadata=inputs['metadata'],
                alignment_layer=self.args.alignment_layer,
                rep_type="latent",
            )

        # ------------------------------------------------------------------
        # Latent forward to get ce_patch_pos (positions of latent embeddings) and ce_patch_vec (latent embeddings)
        # ------------------------------------------------------------------
        inputs['latent_mode'] = True
        inputs['input_ids'] = inputs['student_input_ids']
        inputs['attention_mask'] = inputs['student_attention_mask']
        inputs['pixel_values'] = inputs['student_pixel_values']
        inputs['image_grid_thw'] = inputs['student_image_grid_thw']
        if 'labels' in inputs:
            inputs.pop('labels')
        inputs['alignment_poss'] = inputs['student_alignment_poss']
        # Forward 1 only autoregressively generates student latents. The teacher
        # alignment loss is computed and used in Forward 2 below, so do not pass
        # teacher latents here; otherwise the latent forward does extra unused work
        # and disables the grouped batched latent path.
        inputs.pop('teacher_hidden_states_for_alignment', None)
        model.gradient_checkpointing_disable() # since we set use_cache=True in latent forward, we must disable grad checkpointing
        inputs['loss_type'] = []
        inputs['output_hidden_states'] = False
        student_outputs_latent = model(**inputs)

        # ---- optional NaN localizer (env-gated, no effect when unset) ----
        if os.environ.get("MONET_NAN_DEBUG", ""):
            md = inputs.get('metadata', [])
            for _b, _v in enumerate(student_outputs_latent.ce_patch_vec):
                if torch.is_tensor(_v) and _v.numel() and not torch.isfinite(_v).all():
                    _info = md[_b] if _b < len(md) else _b
                    _amax = _v.abs().float().max().item()
                    logging.error(f"[NAN_DEBUG] Forward-1 ce_patch_vec NON-FINITE for sample={_info} "
                                  f"shape={tuple(_v.shape)} absmax={_amax}")
            for _b, _t in enumerate(teacher_latents or []):
                if torch.is_tensor(_t) and not torch.isfinite(_t).all():
                    _info = md[_b] if _b < len(md) else _b
                    logging.error(f"[NAN_DEBUG] teacher_latent NON-FINITE for sample={_info}")

        # Student CE forward
        inputs['latent_mode'] = False
        inputs['labels'] = inputs['student_labels']
        inputs['ce_patch_pos'] = student_outputs_latent.ce_patch_pos
        inputs['ce_patch_vec'] = student_outputs_latent.ce_patch_vec
        inputs['teacher_hidden_states_for_alignment'] = teacher_latents
        inputs['ce_emphasize_factor'] = self.ce_emphasize_factor
        has_observation_poss = any(inputs.get('observation_poss', []))
        inputs['ce_emphasize_poss'] = inputs['observation_poss'] if has_observation_poss else []
        model.gradient_checkpointing_enable(gradient_checkpointing_kwargs={"use_reentrant": False})
        inputs['loss_type'] = ['ce', 'alignment']
        inputs['compute_emphasize_acc'] = has_observation_poss
        if 'student_attention_mask_4d' in inputs:
            inputs['attention_mask_4d'] = inputs.pop('student_attention_mask_4d')
            # Curriculum: apply the per-step decayed answer->input-image attention mask
            # onto the (Forward-2) 4D mask the collate built with ratio=0.
            if self.img_mask_curriculum and self.special_token_ids is not None:
                ratio = self._curriculum_img_mask_ratio()
                self._cur_img_mask_ratio = ratio
                if ratio > 0.0:
                    apply_input_img_attn_mask(
                        inputs['attention_mask_4d']['full_attention'],
                        inputs['student_input_ids'],
                        self.special_token_ids,
                        ratio,
                    )
        (student_ce_loss, student_outputs) = super().compute_loss(
            model, inputs, return_outputs=True, num_items_in_batch=num_items_in_batch
        )
        if getattr(student_outputs, 'mean_emphasize_acc', None) is not None:
            self.observation_token_acc += getattr(student_outputs, 'mean_emphasize_acc')
            self.observation_token_acc_step += 1
        alignment_loss = student_outputs.loss_dict['alignment']
        self._raise_if_nonfinite_loss('student_ce_loss', student_ce_loss, inputs)
        self._raise_if_nonfinite_loss('alignment_loss', alignment_loss, inputs)
        loss = student_ce_loss + self.alignment_weight * alignment_loss
        self._raise_if_nonfinite_loss('total_loss', loss, inputs)
        outputs_student_loss = student_ce_loss.item()

        del student_outputs
        step = int(getattr(self.state, 'global_step', 0) or 0)
        if step > 0 and (step % 20 == 0):
            try:
                gc.collect()
                torch.cuda.empty_cache()
            except Exception:
                pass

        # Logging
        self.al_loss_cum += float(alignment_loss.detach().item())
        self.al_steps += 1
        self.student_ce_loss_cum += outputs_student_loss
        self.student_ce_loss_steps += 1

        return (loss, None) if return_outputs else loss

    def log(self, logs: dict, start_time: float | None = None):
        # Merge our rolling averages into the standard logs once per logging call
        merged = dict(logs)
        if self.al_steps > 0:
            merged["alignment_loss"] = round(self.al_loss_cum / max(1, self.al_steps), 6)
            self.al_loss_cum = 0.0
            self.al_steps = 0
        if self.student_ce_loss_steps > 0:
            merged["student_ce_loss"] = round(self.student_ce_loss_cum / max(1, self.student_ce_loss_steps), 6)
            self.student_ce_loss_cum = 0.0
            self.student_ce_loss_steps = 0
        if self.observation_token_acc_step > 0:
            merged["observation_token_acc"] = round(self.observation_token_acc/ max(1, self.observation_token_acc_step), 6)
            self.observation_token_acc = 0.
            self.observation_token_acc_step = 0
        if self.img_mask_curriculum:
            merged["img_mask_ratio"] = round(self._cur_img_mask_ratio, 6)

        # Call parent to keep default behavior (console/TB/W&B/etc.)
        return super().log(merged, start_time)