Blame for scripts/model.py

r"""
model.py — AtmosIQ V1, faithful to MODEL_BLUEPRINT v1.1 + Architecture v1.1 FROZEN.

Custom modules: PhysicsBiasedGAT (ADR-014 Am.1 + ADR-019), LogStudentTHead (ADR-015).
No torch_scatter / PyG (pin 4b: hand-rolled segment softmax IS the spec).

Feature contract (F_total=54, four groups, NEVER merged pre-embed):
  A satellite 18 -> 32   B meteorology 12 -> 24   C static 13 -> 16   D calendar 11 -> 16
  fusion Linear(88 -> 96).  Per-group [MASK] tokens (SSL + cloud-blindness).
Encoder: spatial PhysicsBiasedGAT xL=2  BEFORE  temporal Transformer (T=7), last-step pool.
Head input = [N, 96+1] (window-completeness scalar). Output [N, horizons=4, P=7, 3].
SSL recon reads PRE-POOL [N,T,96] per timestep -> 29 continuous channels (discarded after pretrain).
"""
from __future__ import annotations
import torch, torch.nn as nn, torch.nn.functional as F

# ------------------------------------------------------------------ physics bias
def phys_log_bias(w_u1330, w_v1330, blh, src, e_hat, n_hat, eps=1e-4, f_min=0.05):
    """Architecture v1.5: g_ij = relu(w_i,1330 . u_hat_ij) * f(BLH), f in (f_min,1].
    sigma(lambda)=0 baseline -> returns log(g_ij + eps) exactly (ADR-014 Am.1)."""
    w_along = w_u1330[src]*e_hat + w_v1330[src]*n_hat                 # directed: e_ij != e_ji
    f = f_min + (1.0 - f_min)*torch.sigmoid((blh[src]-500.0)/500.0)   # strictly in (f_min,1]
    g = F.relu(w_along) * f
    return torch.log(g + eps)

# ------------------------------------------------------------- PhysicsBiasedGAT (BLUEPRINT §4 verbatim)
class PhysicsBiasedGAT(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.h, self.dh = n_heads, d_model // n_heads
        self.W = nn.Linear(d_model, d_model, bias=False)
        self.a_src = nn.Parameter(torch.empty(n_heads, self.dh))
        self.a_dst = nn.Parameter(torch.empty(n_heads, self.dh))
        self.self_bias = nn.Parameter(torch.zeros(n_heads))          # learned per-head self term
        self.out = nn.Linear(d_model, d_model)
        nn.init.xavier_uniform_(self.a_src); nn.init.xavier_uniform_(self.a_dst)

    def forward(self, x, edge_index, phys_log_bias, return_attn=False):
        N = x.size(0)
        Wx = self.W(x).view(N, self.h, self.dh)
        src, dst = edge_index[0], edge_index[1]
        e = (Wx[src]*self.a_src).sum(-1) + (Wx[dst]*self.a_dst).sum(-1)
        e = F.leaky_relu(e, 0.2) + phys_log_bias.unsqueeze(-1)       # [E,h]
        e_self = F.leaky_relu((Wx*self.a_src).sum(-1) + (Wx*self.a_dst).sum(-1), 0.2)
        e_self = e_self + self.self_bias                             # [N,h] learned self term
        m = e_self.clone()
        m = m.index_reduce_(0, dst, e, reduce="amax", include_self=True)
        ex = torch.exp(e - m[dst]); ex_self = torch.exp(e_self - m)
        denom = ex_self.clone(); denom.index_add_(0, dst, ex)
        alpha = ex / denom[dst]; alpha_self = ex_self / denom
        out = alpha_self.unsqueeze(-1) * Wx
        out.index_add_(0, dst, alpha.unsqueeze(-1) * Wx[src])
        out = self.out(out.reshape(N, self.h*self.dh))
        if return_attn:
            return out, {"alpha_self": alpha_self, "alpha_edge": alpha, "edge_index": edge_index}
        return out

# ------------------------------------------------------------- group assembly + [MASK]
class GroupAssembler(nn.Module):
    """Four sub-embedders + categorical embeddings (land_use->4, grap->3) -> fusion.
    Per-group learned [MASK] tokens (SSL + cloud-blindness)."""
    def __init__(self, dims, sub, cat, d_model):
        super().__init__()
        self.sub = sub
        self.emb_sat = nn.Linear(dims["satellite"], sub["satellite"])
        self.emb_met = nn.Linear(dims["meteorology"], sub["meteorology"])
        self.emb_static = nn.Linear(dims["static"], sub["static"])      # 13 = 9 numeric + 4 landuse-emb
        self.emb_cal = nn.Linear(dims["calendar"], sub["calendar"])     # 11 = 8 numeric + 3 grap-emb
        self.landuse = nn.Embedding(cat.get("n_landuse",11), cat.get("land_use_class",4))
        self.grap    = nn.Embedding(cat.get("n_grap",5),     cat.get("grap_stage",3))
        self.fusion  = nn.Linear(sum(sub.values()), d_model)
        self.mask_tok = nn.ParameterDict({g: nn.Parameter(torch.zeros(sub[g]))
                                          for g in ["satellite","meteorology","static","calendar"]})

    def forward(self, g, group_mask=None):
        """g keys: satellite[N,18], meteorology[N,12], static_num[N,9], landuse[N] long,
                   calendar_num[N,8], grap[N] long. group_mask: dict grp->[N] (1=mask)."""
        static = torch.cat([g["static_num"], self.landuse(g["landuse"])], -1)   # [N,13]
        cal    = torch.cat([g["calendar_num"], self.grap(g["grap"])], -1)       # [N,11]
        h = {"satellite": self.emb_sat(g["satellite"]), "meteorology": self.emb_met(g["meteorology"]),
             "static": self.emb_static(static), "calendar": self.emb_cal(cal)}
        if group_mask is not None:
            for grp in h:
                if grp in group_mask:
                    mk = group_mask[grp].unsqueeze(-1).float()
                    mk = mk.to(h[grp].device)
                    h[grp] = h[grp]*(1-mk) + self.mask_tok[grp].unsqueeze(0)*mk
        return self.fusion(torch.cat([h["satellite"],h["meteorology"],h["static"],h["calendar"]], -1))

# ------------------------------------------------------------- temporal
class TemporalEncoder(nn.Module):
    def __init__(self, d_model, n_heads, ff, layers, T=7):
        super().__init__()
        enc = nn.TransformerEncoderLayer(d_model, n_heads, ff, batch_first=True, dropout=0.1)
        self.tr = nn.TransformerEncoder(enc, layers)
        self.slot = nn.Parameter(torch.randn(1, T, d_model)*0.02)     # learned slot positions
    def forward(self, H):                                            # H:[N,T,d]
        return self.tr(H + self.slot[:, :H.size(1)])                 # returns [N,T,d] (pre-pool)

# ------------------------------------------------------------- heads
class LogStudentTHead(nn.Module):                                    # ADR-015
    def __init__(self, d_model, horizons=4, P=7):
        super().__init__()
        self.H, self.P = horizons, P
        self.trunk = nn.Linear(d_model+1, d_model)                   # +1 window-completeness scalar
        self.mu = nn.Linear(d_model, horizons*P)
        self.log_sigma = nn.Linear(d_model, horizons*P)
        self.log_nu = nn.Parameter(torch.zeros(P))                   # nu per pollutant
    def forward(self, z, completeness):
        h = F.gelu(self.trunk(torch.cat([z, completeness.unsqueeze(-1)], -1)))
        N = z.size(0)
        mu = self.mu(h).view(N, self.H, self.P)
        log_sigma = self.log_sigma(h).view(N, self.H, self.P).clamp(-7.0, 7.0)   # bound sigma in (~1e-3, ~1e3): kills backward blow-up
        nu = (F.softplus(self.log_nu) + 2.0).clamp(max=100.0)       # >2 finite variance, capped
        return mu, log_sigma, nu

class ReconHead(nn.Module):                                          # SSL, pre-pool per-timestep
    def __init__(self, d_model, n_cont=29):
        super().__init__(); self.lin = nn.Linear(d_model, n_cont)
    def forward(self, h_seq): return self.lin(h_seq)                # [N,T,29]

# ------------------------------------------------------------- full model
class AtmosIQNet(nn.Module):
    def __init__(self, cfg=None):
        super().__init__()
        cfg = cfg or {}
        d = cfg.get("d_model",96); heads = cfg.get("n_heads",4); ff = cfg.get("ff_dim",384)
        L = cfg.get("n_blocks_L",2); T = cfg.get("seq_len_T",7)
        cat  = cfg.get("categorical",        {"land_use_class":4,"grap_stage":3,"n_landuse":18,"n_grap":5})
        cal_num = cfg.get("calendar_num_dim", 16)                          # Group D numeric width (from meta.json)
        dims = cfg.get("feature_group_dims", {"satellite":18,"meteorology":12,"static":13,
                                              "calendar": cal_num + cat.get("grap_stage",3)})
        sub  = cfg.get("sub_embed_dims",     {"satellite":32,"meteorology":24,"static":16,"calendar":16})
        P = len(cfg.get("pollutants", ["pm2_5","pm10","no2","so2","co","o3","nh3"]))
        horizons = len(cfg.get("horizons",[0,1,2,3]))
        self.assemble = GroupAssembler(dims, sub, cat, d)
        self.gats = nn.ModuleList([PhysicsBiasedGAT(d, heads) for _ in range(L)])
        self.temporal = TemporalEncoder(d, heads, ff, L, T)
        self.head = LogStudentTHead(d, horizons, P)
        self.recon = ReconHead(d, n_cont=cfg.get("n_recon_channels",29))

    def encode(self, groups_t, ei, e_hat, n_hat, wu, wv, blh, group_mask_t=None):
        """Window encode. Spatial GAT is BATCHED across T timesteps (block-diagonal graph):
        T*N nodes, edges replicated + offset by t*N, physics bias per timestep. One GAT pass
        instead of a Python T-loop -> big GPU speedup. Timesteps stay disconnected."""
        T = len(groups_t); N = groups_t[0]["satellite"].shape[0]
        src, dst = ei[0], ei[1]; E = src.numel()
        # assemble each timestep (cheap Linears) -> [T*N, d]
        H = torch.cat([self.assemble(groups_t[t], None if group_mask_t is None else group_mask_t[t])
                       for t in range(T)], 0)                        # [T*N, d]
        # replicate edges for each timestep, offset by t*N
        offs = (torch.arange(T, device=src.device)*N).view(T,1)
        src_b = (src.unsqueeze(0)+offs).reshape(-1); dst_b = (dst.unsqueeze(0)+offs).reshape(-1)
        ei_b = torch.stack([src_b, dst_b])                          # [2, T*E]
        # physics bias per timestep (cheap) -> [T*E]
        lb = torch.cat([phys_log_bias(wu[t], wv[t], blh[t], src, e_hat, n_hat) for t in range(T)])
        for gat in self.gats: H = gat(H, ei_b, lb)                  # ONE batched spatial pass per layer
        H = H.view(T, N, -1).permute(1,0,2)                         # [N,T,d]
        return self.temporal(H)                                    # [N,T,d] pre-pool

    def forward(self, groups_t, ei, e_hat, n_hat, wu, wv, blh, completeness, group_mask_t=None):
        h_seq = self.encode(groups_t, ei, e_hat, n_hat, wu, wv, blh, group_mask_t)
        z = h_seq[:, -1]                                            # last-step pooling (pinned)
        mu, log_sigma, nu = self.head(z, completeness)
        return dict(mu=mu, log_sigma=log_sigma, nu=nu, h_seq=h_seq)

# ------------------------------------------------------------- losses
def student_t_nll(mu, log_sigma, nu, y, mask, y_logmean=None, y_logstd=None, y_eps=1e-3):
    """log-Student-t NLL on PER-POLLUTANT STANDARDIZED log(y+eps). mu is in standardized log space."""
    import math
    yl = torch.log(y.clamp_min(0) + y_eps)
    if y_logmean is not None:
        yl = (yl - y_logmean.view(1,1,-1)) / y_logstd.view(1,1,-1)   # standardize per pollutant
    sigma = F.softplus(log_sigma) + 1e-3                       # log_sigma already clamped in head
    nu = nu.clamp(2.05, 100.0).view(1,1,-1)
    z = ((yl - mu) / sigma).clamp(-1e3, 1e3)
    nll = (torch.lgamma(nu/2) - torch.lgamma((nu+1)/2) + 0.5*torch.log(nu*math.pi)
           + torch.log(sigma) + (nu+1)/2*torch.log1p((z*z/nu).clamp(max=1e6)))
    nll = torch.nan_to_num(nll, nan=0.0, posinf=1e4, neginf=0.0)  # last-resort guard
    return (nll*mask).sum()/mask.sum().clamp_min(1)

def ssl_recon_loss(recon, target, masked_and_observed):
    """SSL_ROADMAP §2: MSE over {masked AND originally-observed} standardized channels."""
    d = (recon - target)**2 * masked_and_observed
    return d.sum()/masked_and_observed.sum().clamp_min(1)

if __name__ == "__main__":
    torch.manual_seed(0)
    net = AtmosIQNet()
    n = sum(p.numel() for p in net.parameters())
    print(f"AtmosIQNet params: {n:,}  (blueprint target ~287k)")
    N, E, T = 600, 4000, 7
    groups_t = [{"satellite":torch.randn(N,18),"meteorology":torch.randn(N,12),
                 "static_num":torch.randn(N,9),"landuse":torch.randint(0,11,(N,)),
                 "calendar_num":torch.randn(N,16),"grap":torch.randint(0,5,(N,))} for _ in range(T)]
    ei = torch.randint(0,N,(2,E)); e_hat=torch.randn(E); n_hat=torch.randn(E)
    wu=torch.randn(T,N); wv=torch.randn(T,N); blh=torch.rand(T,N)*1000; comp=torch.rand(N)
    out = net(groups_t, ei, e_hat, n_hat, wu, wv, blh, comp)
    print("forward OK. mu", tuple(out["mu"].shape), "nu", tuple(out["nu"].shape), "h_seq", tuple(out["h_seq"].shape))
    y = torch.rand(N,4,7)*100; m=(torch.rand(N,4,7)>0.5).float()
    nll = student_t_nll(out["mu"], out["log_sigma"], out["nu"], y, m)
    rec = net.recon(out["h_seq"]); tgt=torch.randn(N,T,29); mo=(torch.rand(N,T,29)>0.7).float()
    ssl = ssl_recon_loss(rec, tgt, mo)
    (nll+0.5*ssl).backward()
    print(f"nll={nll.item():.3f} ssl={ssl.item():.3f} — backward OK")