61 lines
2.3 KiB
Python
61 lines
2.3 KiB
Python
from __future__ import annotations
|
|
|
|
from dataclasses import dataclass
|
|
|
|
import torch
|
|
import torch.nn.functional as F
|
|
from scipy.optimize import linear_sum_assignment
|
|
|
|
|
|
@dataclass
|
|
class MatchingOutput:
|
|
loss: torch.Tensor
|
|
assignments: list[tuple[torch.Tensor, torch.Tensor]]
|
|
|
|
|
|
def hungarian_matching_loss(
|
|
predictions: dict[str, torch.Tensor],
|
|
targets: list[torch.Tensor],
|
|
valid_weight: float = 0.5,
|
|
) -> MatchingOutput:
|
|
subject_logp = predictions["subject_logits"].log_softmax(-1)
|
|
predicate_logp = predictions["predicate_logits"].log_softmax(-1)
|
|
object_logp = predictions["object_logits"].log_softmax(-1)
|
|
valid_logits = predictions["valid_logits"]
|
|
device = subject_logp.device
|
|
total = subject_logp.sum() * 0.0
|
|
assignments = []
|
|
|
|
for batch_index, facts in enumerate(targets):
|
|
facts = facts.to(device)
|
|
num_slots = subject_logp.shape[1]
|
|
if len(facts):
|
|
cost = -(
|
|
subject_logp[batch_index, :, facts[:, 0]]
|
|
+ predicate_logp[batch_index, :, facts[:, 1]]
|
|
+ object_logp[batch_index, :, facts[:, 2]]
|
|
)
|
|
slot_index, fact_index = linear_sum_assignment(cost.detach().cpu().numpy())
|
|
slots = torch.as_tensor(slot_index, dtype=torch.long, device=device)
|
|
matched = torch.as_tensor(fact_index, dtype=torch.long, device=device)
|
|
selected = facts[matched]
|
|
total = total + F.cross_entropy(
|
|
predictions["subject_logits"][batch_index, slots], selected[:, 0]
|
|
)
|
|
total = total + F.cross_entropy(
|
|
predictions["predicate_logits"][batch_index, slots], selected[:, 1]
|
|
)
|
|
total = total + F.cross_entropy(
|
|
predictions["object_logits"][batch_index, slots], selected[:, 2]
|
|
)
|
|
else:
|
|
slots = torch.empty(0, dtype=torch.long, device=device)
|
|
matched = torch.empty(0, dtype=torch.long, device=device)
|
|
valid_target = torch.zeros(num_slots, dtype=torch.long, device=device)
|
|
valid_target[slots] = 1
|
|
total = total + valid_weight * F.cross_entropy(valid_logits[batch_index], valid_target)
|
|
assignments.append((slots, matched))
|
|
|
|
return MatchingOutput(total / len(targets), assignments)
|
|
|