File size: 1,860 Bytes
dadf189 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 | from __future__ import annotations
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class SensorInvarianceLoss(nn.Module):
"""Cross-sensor pair + adversarial sensor loss.
Returns a 3-tuple ``(total, l_pair_detached, l_adv_detached)`` so callers
can log sub-components without extra forward passes.
GRL anti-correlation fix: l_adv is clamped at the random-guess baseline
``log(num_sensors)`` before being weighted into the total. This prevents
the backbone from overshooting — i.e. learning to actively anti-encode
sensor identity — while still driving the discriminator toward confusion.
Once l_adv >= log(N) the adversarial pressure on the backbone drops to
zero and the GRL game reaches a stable equilibrium instead of cycling.
"""
def __init__(self, delta: float = 0.05, lambda_adv: float = 0.3):
super().__init__()
self.delta = float(delta)
self.lambda_adv = float(lambda_adv)
def forward(
self,
score_s1: torch.Tensor,
score_s2: torch.Tensor,
sensor_logits: torch.Tensor,
sensor_labels: torch.Tensor,
) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
l_pair = F.relu((score_s1 - score_s2).abs() - self.delta).mean()
l_adv = F.cross_entropy(sensor_logits, sensor_labels)
# Clamp adversarial contribution at the random-guess CE baseline.
# Above this ceiling the backbone is already fooling the discriminator
# sufficiently; continued gradient reversal only creates anti-correlation
# oscillation without improving sensor invariance.
rand_ce = math.log(sensor_logits.size(1))
l_adv_clamped = l_adv.clamp(max=rand_ce)
total = l_pair + self.lambda_adv * l_adv_clamped
return total, l_pair.detach(), l_adv.detach()
|