Fix bugs in metrics

These bugs could substantially distort absolute metric values (especially NDCG), but as far as we can judge it did not change the relative ranking

P.S. Thanks to Kirill Khrylchenko for identifying these issues

benchmarks/yambda/evaluation/metrics.py

@@ -47,7 +47,8 @@ class Recall(Metric):
             num_positives = targets.lengths.to(torch.float32)
             num_positives[num_positives == 0] = torch.inf
 
-            values[k] = target_mask[:, :k].to(torch.float32).sum(dim=-1) / num_positives
+            # there was a bug: we divided by num_positives instead of max(num_positives, k)
+            values[k] = target_mask[:, :k].to(torch.float32).sum(dim=-1) / torch.clamp(num_positives, max=k)
 
             values[k] = torch.mean(values[k]).item()
 
@@ -134,16 +135,39 @@ class NDCG(Metric):
     def __call__(
         self, ranked: Ranked | None, targets: Targets, target_mask: torch.Tensor, ks: Iterable[int]
     ) -> dict[int, float]:
-        actual_dcg = DCG()(ranked, targets, target_mask, ks)
+
+        # there was a bug: we computed (dcg_1 + ... + dcg_n) / (idcg_1 + ... + idcg_n)
+        # instead of (1 / n) * (dcg_1 / idcg_1 + ... + dcg_n / idcg_n)
+
+        assert all(0 < k <= target_mask.shape[1] for k in ks)
+
+        def calc_dcg(target_mask: torch.Tensor) -> dict[int, torch.Tensor]:
+            values = {}
+
+            discounts = 1.0 / torch.log2(
+                torch.arange(2, target_mask.shape[1] + 2, device=target_mask.device, dtype=torch.float32)
+            )
+
+            for k in ks:
+                dcg_k = torch.sum(target_mask[:, :k] * discounts[:k], dim=1)
+                values[k] = dcg_k
+            return values
+
+        actual_dcg = calc_dcg(target_mask)
 
         ideal_target_mask = (
             torch.arange(target_mask.shape[1], device=targets.device)[None, :] < targets.lengths[:, None]
         ).to(torch.float32)
         assert target_mask.shape == ideal_target_mask.shape
 
-        ideal_dcg = DCG()(ranked, targets, ideal_target_mask, ks)
+        ideal_dcg = calc_dcg(target_mask)
+
+        def divide(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+            assert x.shape == y.shape
+            assert x.shape[0] == target_mask.shape[0]
+            return torch.where(y == 0, 0, x / y).mean()
 
-        ndcg_values = {k: (actual_dcg[k] / ideal_dcg[k] if ideal_dcg[k] != 0 else 0.0) for k in ks}
+        ndcg_values = {k: divide(actual_dcg[k], ideal_dcg[k]).item() for k in ks}
 
         return ndcg_values