pdeinvbench/lightning_modules/inversemodule.py

import os
from typing import Callable, Dict, List, Tuple, Union

import lightning as L
import torch
import typeguard
from functorch.dim import tree_map
from jaxtyping import Float, jaxtyped
from lightning.pytorch.utilities import grad_norm
from pdeinvbench.utils.pytorch_utils import compute_grad_norm
from lightning.pytorch.loggers import WandbLogger
from pdeinvbench.data.utils import unnormalize_params
from pdeinvbench.utils.logging_utils import get_best_model_weights
from copy import deepcopy
import time

from pdeinvbench.losses import (
    get_param_metric,
    get_pde_residual_function,
    pde_residual_reduction,
)
from pdeinvbench.losses.metrics import (
    classification_metrics_darcy_flow,
    param_relative_loss,
)
from pdeinvbench.models.inverse_model import InverseModel
from pdeinvbench.utils import pytorch_utils as ptu
from pdeinvbench.utils.types import (
    PDE,
    DataMetrics,
    ParamMetrics,
    TypeBatch,
    TypeBatch1D,
    TypeBatch2D,
    TypeLossDict,
    TypeParam,
    TypePredict1D,
    TypePredict2D,
)


class InverseModule(L.LightningModule):
    """
    Inverse Problem Module. Takes a set of conditioning frames from a PDE trajectory and predicts the value of the PDE parameter(s).
    :param model: Model.
    :param optimizer: Optimizer.
    :param lr_scheduler: Learning rate scheduler.
    :param pde: enum of the PDE to use for the residual calculation.
    :param param_loss_metric: Metric to use for the parameter loss.
    :param inverse_residual_loss_weight: Weight for the PDE residual loss obtained from the predicted parameters.
    :param n_past: Number of past frames to condition on.
    :param use_partials: whether to append the partial derivatives to the input.
    :param params_to_predict: list of strings of parameters to predict.
    :param residual_filter: Whether to use residual filtering.
    :param batch_size: Batch size.
    """

    def __init__(
        self,
        model: InverseModel,
        optimizer: torch.optim.Optimizer,
        lr_scheduler: torch.optim.lr_scheduler,
        pde: PDE,
        param_loss_metric: ParamMetrics,
        inverse_residual_loss_weight: float,
        inverse_param_loss_weight: float,
        n_past: int,
        use_partials: bool,
        params_to_predict: List[str],
        residual_filter: bool,
        batch_size: int,
    ):
        super().__init__()
        self.save_hyperparameters(ignore=["model"])
        self.model = model
        self.old_inverse_model = None
        self.new_inverse_model = None
        self.pde_residual = get_pde_residual_function(pde)
        self.pde = pde
        self.param_loss_metric = get_param_metric(param_loss_metric)
        self.inverse_residual_loss_weight = inverse_residual_loss_weight
        self.inverse_param_loss_weight = inverse_param_loss_weight

        self.validation_step_outputs = []
        self.validation_step_targets = []
        """
        Loss dicts for validation. Each element is a tuple of (losses, pde_params).
        PDE_params comes directly from the dataloader.
        Loss: Dict[str, torch.Tensor] with keys (shape) 
        'data_loss' (B), 'residual_loss' (B), 'loss' (), 'data_loss_per_batch_element' (B), 'residual_per_batch_element' (B).
        """
        self.validation_step_loss_dicts = []
        self.n_past = n_past
        self.use_partials = use_partials
        self.params_to_predict = params_to_predict
        self.optimizer = optimizer
        self.lr_scheduler = lr_scheduler
        self.residual_filter = residual_filter
        self.batch_size = batch_size

    @jaxtyped(typechecker=typeguard.typechecked)
    def predict_with_loss(
        self,
        batch: Union[TypeBatch1D, TypeBatch2D],
        stage: str,
        gumbel: bool = False,
    ) -> Tuple[TypeParam, TypeParam, Dict[str, Union[torch.tensor, TypeBatch]]]:
        """
        Common method which computes a prediction of the PDE parameter from the conditioning frames and returns the loss.
        :param batch: Batch of data.
        :param stage: Which of "train", "validation", "test","tailoring" is the current stage.
        """
        _, _, initial_frames, _, _, _, _ = batch
        start_time = time.time()
        # To fix batching issue. Sometimes the input batch_size is less than the defined batch_size.
        # This causes logging issues downstream during logging. This snippet repeats the final batch element
        # to match the specified input batch_size.
        num_repeat_elements = 0
        if initial_frames.shape[0] < self.batch_size:
            num_repeat_elements = self.batch_size - initial_frames.shape[0]
            batch = tree_map(
                lambda x: torch.cat(
                    [x] + [x[-1].unsqueeze(0) for _ in range(num_repeat_elements)]
                ),
                batch,
            )
        spatial_grid, t, initial_frames, _, _, _, pde_params = batch

        forward_pass_start_time = time.time()
        predicted_pde_params, residual, true_residual = self.model(
            initial_frames, pde_params, spatial_grid, t, gumbel=gumbel
        )
        forward_pass_end_time = time.time()
        forward_pass_time = forward_pass_end_time - forward_pass_start_time
        if self.residual_filter:
            ids = [
                true_residual.reshape(true_residual.shape[0], -1).max(dim=1)[0] < 100
            ]
            residual = residual[ids]
            true_residual = true_residual[ids]

            for key in pde_params:
                predicted_pde_params[key] = predicted_pde_params[key][ids]
                pde_params[key] = pde_params[key][ids]

        residual_loss = pde_residual_reduction(
            residual
        )  # Convert residual tensor to float loss
        true_residual_loss = pde_residual_reduction(true_residual)
        param_losses = self.param_loss_metric(
            predicted_pde_params,
            pde_params,
            reduction="mean",
        )

        relative_param_losses = param_relative_loss(
            {param: prediction for param, prediction in predicted_pde_params.items()},
            pde_params,
            reduction="mean",
        )

        # To avoid scenario where the averaged loss is computed with zero errors corresponding to params
        # that are not predicted for darcy flow.
        backprop_losses: list[torch.Tensor]
        if self.pde == PDE.DarcyFlow2D and stage != "tailoring":
            backprop_losses = [v for v in param_losses.values() if v.item() != 0]
        else:
            backprop_losses = list(param_losses.values())

        param_loss = torch.stack(backprop_losses).mean()

        individual_param_losses = {
            f"param_loss_{k}": v for k, v in param_losses.items()
        }
        individual_relative_param_losses = {
            f"relative_param_loss_{k}": v for k, v in relative_param_losses.items()
        }

        weighted_param_loss = self.inverse_param_loss_weight * param_loss

        weighted_residual_loss = self.inverse_residual_loss_weight * residual_loss

        loss = weighted_param_loss + weighted_residual_loss
        losses = {
            "param_loss": param_loss,
            "residual_loss": residual_loss,
            "true_residual_loss": true_residual_loss,
            "loss": loss,
            **individual_param_losses,
            **individual_relative_param_losses,
        }

        if self.pde == PDE.DarcyFlow2D:
            # Additional metrics for darcy flow to be consistent with PINO
            darcy_losses: dict[str, float] = classification_metrics_darcy_flow(
                predicted_coeff=predicted_pde_params["coeff"],
                true_coeff=pde_params["coeff"],
            )
            losses.update(darcy_losses)

        # In the case of validation, we want to handle some additional metrics
        if "validation" in stage or "test" in stage or "tailoring" in stage:
            # we want to stratify the losses based on PDE parameter
            # Stratification happens in the plotting callback - this performs bookkeeping.
            param_loss_per_batch_element, residual_per_batch_element = (
                self.stratify_losses(
                    predicted_pde_params,
                    pde_params,
                    residual,
                )
            )
            losses["param_loss_per_batch_element"] = param_loss_per_batch_element
            losses["residual_per_batch_element"] = residual_per_batch_element

        # reset batch to original size by removing the repeated last element in orginal batch
        if num_repeat_elements > 0:
            predicted_pde_params = tree_map(
                lambda x: x[: -1 * num_repeat_elements], predicted_pde_params
            )
            pde_params = tree_map(lambda x: x[: -1 * num_repeat_elements], pde_params)
            losses = tree_map(
                lambda x: x[: -1 * num_repeat_elements] if x.numel() > 1 else x, losses
            )
        end_time = time.time()
        losses["timing_metrics"] = {
            "predict_with_loss_time": end_time - start_time,
            "forward_pass_time": forward_pass_time,
        }
        return predicted_pde_params, pde_params, losses

    @jaxtyped(typechecker=typeguard.typechecked)
    def training_step(
        self,
        batch: Union[TypeBatch1D, TypeBatch2D],
        batch_idx: int,
    ) -> TypeLossDict:
        stage = "train"
        _, _, losses = self.predict_with_loss(batch, stage="train")
        self.log_metrics(stage, losses)
        return losses

    @jaxtyped(typechecker=typeguard.typechecked)
    def validation_step(
        self,
        batch: Union[TypeBatch1D, TypeBatch2D],
        batch_idx: int,
        dataloader_idx: int = 0,
        stage: str = None,
    ) -> Union[None, TypeLossDict]:
        stage = "validation" if stage == None else stage
        prediction, target, losses = self.predict_with_loss(batch, stage=stage)

        #### Bookkeeping for plotting. See logging_callbacks.py for plotting. #####

        # NOTE: If we dont convert to numpy, there will be an OOM exception
        if self.pde == PDE.DarcyFlow2D:
            for k in prediction.keys():
                prediction[k] = prediction[k].cpu().numpy()
                target[k] = target[k].cpu().numpy()
                self.validation_step_outputs.append(prediction)
                self.validation_step_targets.append(target)
                self.validation_step_loss_dicts.append(
                    (
                        ptu.torch_dict_to_numpy(losses),
                        ptu.torch_dict_to_numpy(batch[-1]),
                    )
                )
        else:
            self.validation_step_outputs.append(prediction)
            self.validation_step_targets.append(target)
            self.validation_step_loss_dicts.append((losses, batch[-1]))
        losses["predictions"] = prediction
        losses["targets"] = target
        self.log_metrics(stage, losses)
        return losses

    @jaxtyped(typechecker=typeguard.typechecked)
    def test_step(
        self,
        batch: Union[TypeBatch1D, TypeBatch2D],
        batch_idx: int,
        dataloader_idx: int = 0,
    ) -> TypeLossDict:
        stage = "test"
        self.model.train()
        test_losses = self.validation_step(batch, batch_idx, dataloader_idx, stage)
        return test_losses

    def log_metrics(self, stage, losses, prefix_dir=""):
        if "validation" in stage or "test" in stage:
            on_step = False
            on_epoch = True
        else:
            on_step = True
            on_epoch = False

        main_loss_type = "param_loss"

        self.log(
            os.path.join(stage, prefix_dir, main_loss_type),
            losses["param_loss"],
            prog_bar=True,
            on_step=on_step,
            on_epoch=on_epoch,
        )

        for param in self.params_to_predict:
            self.log(
                os.path.join(stage, prefix_dir, f"{main_loss_type}_{param}"),
                losses[f"param_loss_{param}"],
                prog_bar=True,
                on_step=on_step,
                on_epoch=on_epoch,
            )

            self.log(
                os.path.join(stage, prefix_dir, f"relative_param_loss_{param}"),
                losses[f"relative_param_loss_{param}"],
                prog_bar=True,
                on_step=on_step,
                on_epoch=on_epoch,
            )

        self.log(
            os.path.join(stage, prefix_dir, "residual_loss"),
            losses["residual_loss"],
            prog_bar=True,
            on_step=on_step,
            on_epoch=on_epoch,
        )

        self.log(
            os.path.join(stage, prefix_dir, "true_residual_loss"),
            losses["true_residual_loss"],
            prog_bar=True,
            on_step=on_step,
            on_epoch=on_epoch,
        )

        if isinstance(self.model, InverseModel):

            # Check for darcy inverse model
            if self.pde == PDE.DarcyFlow2D:
                self.log(
                    os.path.join(
                        stage, prefix_dir, "darcy_flow_classification_accuracy"
                    ),
                    losses["darcy_flow_classification_accuracy"],
                    prog_bar=True,
                    on_step=on_step,
                    on_epoch=on_epoch,
                )
                self.log(
                    os.path.join(stage, prefix_dir, "darcy_flow_classification_iou"),
                    losses["darcy_flow_classification_iou"],
                    prog_bar=True,
                    on_step=on_step,
                    on_epoch=on_epoch,
                )

        self.log(
            os.path.join(stage, prefix_dir, "loss"),
            losses["loss"],
            on_step=on_step,
            on_epoch=on_epoch,
        )

        if "timing_metrics" in losses:
            self.log(
                os.path.join(stage, prefix_dir, "predict_with_loss_time"),
                losses["timing_metrics"]["predict_with_loss_time"],
                on_step=on_step,
                on_epoch=on_epoch,
            )

            self.log(
                os.path.join(stage, prefix_dir, "forward_pass_time"),
                losses["timing_metrics"]["forward_pass_time"],
                on_step=on_step,
                on_epoch=on_epoch,
            )

    def configure_optimizers(self):
        optimizer = self.optimizer
        lr_scheduler = self.lr_scheduler
        return [optimizer], [lr_scheduler]

    def on_before_optimizer_step(self, optimizer):
        # logging the sum of the l2 norms of both the forward and inverse model

        self.old_inverse_model = torch.cat(
            [p.flatten() for p in self.model.parameters()]
        )
        inverse_norms = grad_norm(self.model, 2)
        inverse_total_norm = sum(inverse_norms.values())
        self.log(
            f"outer_loss_grad_norms/inverse_model",
            inverse_total_norm,
            on_step=True,
        )

    def optimizer_step(self, *args, **kwargs):
        super().optimizer_step(*args, **kwargs)

        self.new_inverse_model = torch.cat(
            [p.flatten() for p in self.model.parameters()]
        )
        param_diff_norm = torch.norm(self.new_inverse_model - self.old_inverse_model)
        original_param_norm = torch.norm(self.old_inverse_model)
        rel_diff = param_diff_norm / original_param_norm
        self.log(
            "outer_loss_grad_norms/callback_inverse_param_rel_diff",
            rel_diff,
            on_step=True,
        )

    def stratify_losses(self, predicted_pde_params, pde_params, residual):
        # Compute the per trajectory param loss & residual
        param_loss_per_batch_element = self.param_loss_metric(
            predicted_pde_params, pde_params, reduction="none"
        )

        # Edge case where we instead sum the error for darcy flow
        if self.pde == PDE.DarcyFlow2D:
            coeff = param_loss_per_batch_element["coeff"]
            # In the case we use a relative error, we don't need to do this
            if len(coeff.shape) == 4:
                coeff = torch.flatten(coeff, start_dim=2).sum(axis=2)

            param_loss_per_batch_element["coeff"] = coeff

        param_loss_per_batch_element = (
            torch.stack(list(param_loss_per_batch_element.values()))
            .squeeze(-1)
            .mean(dim=0)
        )
        residual_per_batch_element = pde_residual_reduction(
            residual, dim=tuple(range(1, residual.dim()))
        )

        return param_loss_per_batch_element, residual_per_batch_element

    def on_test_epoch_start(self):
        super().on_test_epoch_start()