Upload CIDM-v3 D1 time-variable distillation

FormalTraining/V3_D1_TimeVariable_Distillation/final/cidm_v3_time_variable_distilled_model.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+from typing import Sequence
+import torch
+import torch.nn as nn
+
+from cidm_v3_product_model import (
+    CapacityScaledSingleStateCIDM,
+    ProductModelConfig,
+)
+
+class LeadVariableIncrementAdapter(nn.Module):
+    def __init__(
+        self,
+        variable_to_group: Sequence[int],
+        steps: int = 60,
+        maximum_scale_deviation: float = 0.65,
+        maximum_bias: float = 0.12,
+    ):
+        super().__init__()
+        mapping = torch.as_tensor(
+            variable_to_group,
+            dtype=torch.long,
+        )
+        self.register_buffer(
+            "variable_to_group",
+            mapping,
+            persistent=True,
+        )
+        self.steps = int(steps)
+        self.group_count = int(mapping.max().item() + 1)
+        self.maximum_scale_deviation = float(
+            maximum_scale_deviation
+        )
+        self.maximum_bias = float(maximum_bias)
+
+        self.raw_scale = nn.Parameter(
+            torch.zeros(self.steps, self.group_count)
+        )
+        self.raw_bias = nn.Parameter(
+            torch.zeros(self.steps, self.group_count)
+        )
+
+        bias_mask = torch.ones(
+            len(mapping),
+            dtype=torch.float32,
+        )
+        bias_mask[[12, 13]] = 0.0
+        self.register_buffer(
+            "variable_bias_mask",
+            bias_mask,
+            persistent=True,
+        )
+
+    def forward(
+        self,
+        base_prediction,
+        persistence,
+        mask,
+        lead_index: int,
+    ):
+        group_scale = (
+            1.0
+            + self.maximum_scale_deviation
+            * torch.tanh(
+                self.raw_scale[lead_index]
+            )
+        )
+        group_bias = (
+            self.maximum_bias
+            * torch.tanh(
+                self.raw_bias[lead_index]
+            )
+        )
+        scale = group_scale[
+            self.variable_to_group
+        ][None, :, None, None]
+        bias = (
+            group_bias[
+                self.variable_to_group
+            ]
+            * self.variable_bias_mask
+        )[None, :, None, None]
+
+        return (
+            persistence
+            + scale
+            * (
+                base_prediction
+                - persistence
+            )
+            + bias
+        ) * mask
+
+class TimeVariableDistilledCIDM(nn.Module):
+    def __init__(
+        self,
+        base_model,
+        adapter,
+    ):
+        super().__init__()
+        self.base_model = base_model
+        self.adapter = adapter
+
+    def forward(
+        self,
+        history,
+        mask,
+        steps=60,
+        gradient_checkpointing=False,
+    ):
+        outputs = self.base_model(
+            history,
+            mask,
+            steps,
+            gradient_checkpointing=gradient_checkpointing,
+        )
+        persistence = history[:, -1]
+        return [
+            self.adapter(
+                output,
+                persistence,
+                mask,
+                lead_index,
+            )
+            for lead_index, output
+            in enumerate(outputs)
+        ]
+
+def load_distilled_checkpoint(
+    checkpoint_path,
+    map_location="cpu",
+):
+    try:
+        payload = torch.load(
+            checkpoint_path,
+            map_location=map_location,
+            weights_only=False,
+        )
+    except TypeError:
+        payload = torch.load(
+            checkpoint_path,
+            map_location=map_location,
+        )
+
+    config = ProductModelConfig(
+        **payload["model_config"]
+    )
+    base_model = CapacityScaledSingleStateCIDM(
+        config
+    )
+    base_model.load_state_dict(
+        payload["model_state"],
+        strict=True,
+    )
+
+    adapter_config = payload["adapter_config"]
+    adapter = LeadVariableIncrementAdapter(
+        adapter_config["variable_to_group"],
+        adapter_config["steps"],
+        adapter_config[
+            "maximum_scale_deviation"
+        ],
+        adapter_config["maximum_bias"],
+    )
+    adapter.load_state_dict(
+        payload["adapter_state"],
+        strict=True,
+    )
+
+    model = TimeVariableDistilledCIDM(
+        base_model,
+        adapter,
+    )
+    return model, payload