birder 0.3.3__py3-none-any.whl → 0.4.1__py3-none-any.whl

birder/net/deit3.py

@@ -15,12 +15,19 @@ from torch import nn
 
 from birder.common.masking import mask_tensor
 from birder.model_registry import registry
+from birder.net._vit_configs import BASE
+from birder.net._vit_configs import HUGE
+from birder.net._vit_configs import LARGE
+from birder.net._vit_configs import MEDIUM
+from birder.net._vit_configs import SMALL
+from birder.net._vit_configs import TINY
 from birder.net.base import DetectorBackbone
 from birder.net.base import MaskedTokenOmissionMixin
 from birder.net.base import MaskedTokenRetentionMixin
 from birder.net.base import PreTrainEncoder
 from birder.net.base import TokenOmissionResultType
 from birder.net.base import TokenRetentionResultType
+from birder.net.base import normalize_out_indices
 from birder.net.vit import Encoder
 from birder.net.vit import EncoderBlock
 from birder.net.vit import PatchEmbed
@@ -53,6 +60,7 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
         mlp_dim: int = self.config["mlp_dim"]
         layer_scale_init_value: Optional[float] = self.config.get("layer_scale_init_value", 1e-5)
         num_reg_tokens: int = self.config.get("num_reg_tokens", 0)
+        out_indices: Optional[list[int]] = self.config.get("out_indices", None)
         drop_path_rate: float = self.config["drop_path_rate"]
 
         torch._assert(image_size[0] % patch_size == 0, "Input shape indivisible by patch size!")
@@ -64,6 +72,7 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
         self.num_reg_tokens = num_reg_tokens
         self.num_special_tokens = 1 + self.num_reg_tokens
         self.pos_embed_special_tokens = pos_embed_special_tokens
+        self.out_indices = normalize_out_indices(out_indices, num_layers)
         dpr = [x.item() for x in torch.linspace(0, drop_path_rate, num_layers)]  # Stochastic depth decay rule
 
         self.conv_proj = nn.Conv2d(
@@ -72,7 +81,6 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
             kernel_size=(patch_size, patch_size),
             stride=(patch_size, patch_size),
             padding=(0, 0),
-            bias=True,
         )
         self.patch_embed = PatchEmbed()
 
@@ -106,8 +114,9 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
         )
         self.norm = nn.LayerNorm(hidden_dim, eps=1e-6)
 
-        self.return_stages = ["neck"]  # Actually meaningless, just for completeness
-        self.return_channels = [hidden_dim]
+        num_return_stages = len(self.out_indices) if self.out_indices is not None else 1
+        self.return_stages = [f"stage{stage_idx + 1}" for stage_idx in range(num_return_stages)]
+        self.return_channels = [hidden_dim] * num_return_stages
         self.embedding_size = hidden_dim
         self.classifier = self.create_classifier()
 
@@ -153,7 +162,7 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
         )
 
     def detection_features(self, x: torch.Tensor) -> dict[str, torch.Tensor]:
-        (H, W) = x.shape[-2:]
+        H, W = x.shape[-2:]
 
         x = self.conv_proj(x)
         x = self.patch_embed(x)
@@ -170,15 +179,20 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
             x = x + self._get_pos_embed(H, W)
             x = torch.concat([batch_special_tokens, x], dim=1)
 
-        x = self.encoder(x)
-        x = self.norm(x)
+        if self.out_indices is None:
+            xs = [self.encoder(x)]
+        else:
+            xs = self.encoder.forward_features(x, out_indices=self.out_indices)
 
-        x = x[:, self.num_special_tokens :]
-        x = x.permute(0, 2, 1)
-        (B, C, _) = x.size()
-        x = x.reshape(B, C, H // self.patch_size, W // self.patch_size)
+        out: dict[str, torch.Tensor] = {}
+        for stage_name, stage_x in zip(self.return_stages, xs):
+            stage_x = stage_x[:, self.num_special_tokens :]
+            stage_x = stage_x.permute(0, 2, 1)
+            B, C, _ = stage_x.size()
+            stage_x = stage_x.reshape(B, C, H // self.patch_size, W // self.patch_size)
+            out[stage_name] = stage_x
 
-        return {self.return_stages[0]: x}
+        return out
 
     def freeze_stages(self, up_to_stage: int) -> None:
         for param in self.conv_proj.parameters():
@@ -193,6 +207,10 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
             for param in module.parameters():
                 param.requires_grad_(False)
 
+    def transform_to_backbone(self) -> None:
+        super().transform_to_backbone()
+        self.norm = nn.Identity()
+
     def set_causal_attention(self, is_causal: bool = True) -> None:
         self.encoder.set_causal_attention(is_causal)
 
@@ -203,7 +221,7 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
         return_all_features: bool = False,
         return_keys: Literal["all", "tokens", "embedding"] = "tokens",
     ) -> TokenOmissionResultType:
-        (H, W) = x.shape[-2:]
+        H, W = x.shape[-2:]
 
         # Reshape and permute the input tensor
         x = self.conv_proj(x)
@@ -266,7 +284,7 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
         mask_token: Optional[torch.Tensor] = None,
         return_keys: Literal["all", "features", "embedding"] = "features",
     ) -> TokenRetentionResultType:
-        (H, W) = x.shape[-2:]
+        H, W = x.shape[-2:]
 
         x = self.conv_proj(x)
         x = mask_tensor(x, mask, mask_token=mask_token, patch_factor=self.max_stride // self.stem_stride)
@@ -296,7 +314,7 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
         if return_keys in ("all", "features"):
             features = x[:, self.num_special_tokens :]
             features = features.permute(0, 2, 1)
-            (B, C, _) = features.size()
+            B, C, _ = features.size()
             features = features.reshape(B, C, H // self.patch_size, W // self.patch_size)
             result["features"] = features
 
@@ -306,7 +324,7 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
         return result
 
     def forward_features(self, x: torch.Tensor) -> torch.Tensor:
-        (H, W) = x.shape[-2:]
+        H, W = x.shape[-2:]
 
         # Reshape and permute the input tensor
         x = self.conv_proj(x)
@@ -368,279 +386,126 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
 registry.register_model_config(
     "deit3_t16",
     DeiT3,
-    config={
-        "patch_size": 16,
-        "num_layers": 12,
-        "num_heads": 3,
-        "hidden_dim": 192,
-        "mlp_dim": 768,
-        "drop_path_rate": 0.0,
-    },
+    config={"patch_size": 16, **TINY},
+)
+registry.register_model_config(
+    "deit3_t14",
+    DeiT3,
+    config={"patch_size": 14, **TINY},
 )
 registry.register_model_config(
     "deit3_s16",
     DeiT3,
-    config={
-        "patch_size": 16,
-        "num_layers": 12,
-        "num_heads": 6,
-        "hidden_dim": 384,
-        "mlp_dim": 1536,
-        "drop_path_rate": 0.05,
-    },
+    config={"patch_size": 16, **SMALL, "drop_path_rate": 0.05},
 )
 registry.register_model_config(
     "deit3_s14",
     DeiT3,
-    config={
-        "patch_size": 14,
-        "num_layers": 12,
-        "num_heads": 6,
-        "hidden_dim": 384,
-        "mlp_dim": 1536,
-        "drop_path_rate": 0.05,
-    },
+    config={"patch_size": 14, **SMALL, "drop_path_rate": 0.05},
 )
 registry.register_model_config(
     "deit3_m16",
     DeiT3,
-    config={
-        "patch_size": 16,
-        "num_layers": 12,
-        "num_heads": 8,
-        "hidden_dim": 512,
-        "mlp_dim": 2048,
-        "drop_path_rate": 0.1,
-    },
+    config={"patch_size": 16, **MEDIUM, "drop_path_rate": 0.1},
 )
 registry.register_model_config(
     "deit3_m14",
     DeiT3,
-    config={
-        "patch_size": 14,
-        "num_layers": 12,
-        "num_heads": 8,
-        "hidden_dim": 512,
-        "mlp_dim": 2048,
-        "drop_path_rate": 0.1,
-    },
+    config={"patch_size": 14, **MEDIUM, "drop_path_rate": 0.1},
 )
 registry.register_model_config(
     "deit3_b16",
     DeiT3,
-    config={
-        "patch_size": 16,
-        "num_layers": 12,
-        "num_heads": 12,
-        "hidden_dim": 768,
-        "mlp_dim": 3072,
-        "drop_path_rate": 0.2,
-    },
+    config={"patch_size": 16, **BASE, "drop_path_rate": 0.2},
 )
 registry.register_model_config(
     "deit3_b14",
     DeiT3,
-    config={
-        "patch_size": 14,
-        "num_layers": 12,
-        "num_heads": 12,
-        "hidden_dim": 768,
-        "mlp_dim": 3072,
-        "drop_path_rate": 0.2,
-    },
+    config={"patch_size": 14, **BASE, "drop_path_rate": 0.2},
 )
 registry.register_model_config(
     "deit3_l16",
     DeiT3,
-    config={
-        "patch_size": 16,
-        "num_layers": 24,
-        "num_heads": 16,
-        "hidden_dim": 1024,
-        "mlp_dim": 4096,
-        "drop_path_rate": 0.45,
-    },
+    config={"patch_size": 16, **LARGE, "drop_path_rate": 0.45},
 )
 registry.register_model_config(
     "deit3_l14",
     DeiT3,
-    config={
-        "patch_size": 14,
-        "num_layers": 24,
-        "num_heads": 16,
-        "hidden_dim": 1024,
-        "mlp_dim": 4096,
-        "drop_path_rate": 0.45,
-    },
+    config={"patch_size": 14, **LARGE, "drop_path_rate": 0.45},
 )
 registry.register_model_config(
     "deit3_h16",
     DeiT3,
-    config={
-        "patch_size": 16,
-        "num_layers": 32,
-        "num_heads": 16,
-        "hidden_dim": 1280,
-        "mlp_dim": 5120,
-        "drop_path_rate": 0.55,
-    },
+    config={"patch_size": 16, **HUGE, "drop_path_rate": 0.55},
 )
 registry.register_model_config(
     "deit3_h14",
     DeiT3,
-    config={
-        "patch_size": 14,
-        "num_layers": 32,
-        "num_heads": 16,
-        "hidden_dim": 1280,
-        "mlp_dim": 5120,
-        "drop_path_rate": 0.55,
-    },
+    config={"patch_size": 14, **HUGE, "drop_path_rate": 0.55},
 )
 
 # With registers
+####################
+
 registry.register_model_config(
     "deit3_reg4_t16",
     DeiT3,
-    config={
-        "patch_size": 16,
-        "num_layers": 12,
-        "num_heads": 3,
-        "hidden_dim": 192,
-        "mlp_dim": 768,
-        "num_reg_tokens": 4,
-        "drop_path_rate": 0.0,
-    },
+    config={"patch_size": 16, **TINY, "num_reg_tokens": 4},
+)
+registry.register_model_config(
+    "deit3_reg4_t14",
+    DeiT3,
+    config={"patch_size": 14, **TINY, "num_reg_tokens": 4},
 )
 registry.register_model_config(
     "deit3_reg4_s16",
     DeiT3,
-    config={
-        "patch_size": 16,
-        "num_layers": 12,
-        "num_heads": 6,
-        "hidden_dim": 384,
-        "mlp_dim": 1536,
-        "num_reg_tokens": 4,
-        "drop_path_rate": 0.05,
-    },
+    config={"patch_size": 16, **SMALL, "num_reg_tokens": 4, "drop_path_rate": 0.05},
 )
 registry.register_model_config(
     "deit3_reg4_s14",
     DeiT3,
-    config={
-        "patch_size": 14,
-        "num_layers": 12,
-        "num_heads": 6,
-        "hidden_dim": 384,
-        "mlp_dim": 1536,
-        "num_reg_tokens": 4,
-        "drop_path_rate": 0.05,
-    },
+    config={"patch_size": 14, **SMALL, "num_reg_tokens": 4, "drop_path_rate": 0.05},
 )
 registry.register_model_config(
     "deit3_reg4_m16",
     DeiT3,
-    config={
-        "patch_size": 16,
-        "num_layers": 12,
-        "num_heads": 8,
-        "hidden_dim": 512,
-        "mlp_dim": 2048,
-        "num_reg_tokens": 4,
-        "drop_path_rate": 0.1,
-    },
+    config={"patch_size": 16, **MEDIUM, "num_reg_tokens": 4, "drop_path_rate": 0.1},
 )
 registry.register_model_config(
     "deit3_reg4_m14",
     DeiT3,
-    config={
-        "patch_size": 14,
-        "num_layers": 12,
-        "num_heads": 8,
-        "hidden_dim": 512,
-        "mlp_dim": 2048,
-        "num_reg_tokens": 4,
-        "drop_path_rate": 0.1,
-    },
+    config={"patch_size": 14, **MEDIUM, "num_reg_tokens": 4, "drop_path_rate": 0.1},
 )
 registry.register_model_config(
     "deit3_reg4_b16",
     DeiT3,
-    config={
-        "patch_size": 16,
-        "num_layers": 12,
-        "num_heads": 12,
-        "hidden_dim": 768,
-        "mlp_dim": 3072,
-        "num_reg_tokens": 4,
-        "drop_path_rate": 0.2,
-    },
+    config={"patch_size": 16, **BASE, "num_reg_tokens": 4, "drop_path_rate": 0.2},
 )
 registry.register_model_config(
     "deit3_reg4_b14",
     DeiT3,
-    config={
-        "patch_size": 14,
-        "num_layers": 12,
-        "num_heads": 12,
-        "hidden_dim": 768,
-        "mlp_dim": 3072,
-        "num_reg_tokens": 4,
-        "drop_path_rate": 0.2,
-    },
+    config={"patch_size": 14, **BASE, "num_reg_tokens": 4, "drop_path_rate": 0.2},
 )
 registry.register_model_config(
     "deit3_reg4_l16",
     DeiT3,
-    config={
-        "patch_size": 16,
-        "num_layers": 24,
-        "num_heads": 16,
-        "hidden_dim": 1024,
-        "mlp_dim": 4096,
-        "num_reg_tokens": 4,
-        "drop_path_rate": 0.45,
-    },
+    config={"patch_size": 16, **LARGE, "num_reg_tokens": 4, "drop_path_rate": 0.45},
 )
 registry.register_model_config(
     "deit3_reg4_l14",
     DeiT3,
-    config={
-        "patch_size": 14,
-        "num_layers": 24,
-        "num_heads": 16,
-        "hidden_dim": 1024,
-        "mlp_dim": 4096,
-        "num_reg_tokens": 4,
-        "drop_path_rate": 0.45,
-    },
+    config={"patch_size": 14, **LARGE, "num_reg_tokens": 4, "drop_path_rate": 0.45},
 )
 registry.register_model_config(
     "deit3_reg4_h16",
     DeiT3,
-    config={
-        "patch_size": 16,
-        "num_layers": 32,
-        "num_heads": 16,
-        "hidden_dim": 1280,
-        "mlp_dim": 5120,
-        "num_reg_tokens": 4,
-        "drop_path_rate": 0.55,
-    },
+    config={"patch_size": 16, **HUGE, "num_reg_tokens": 4, "drop_path_rate": 0.55},
 )
 registry.register_model_config(
     "deit3_reg4_h14",
     DeiT3,
-    config={
-        "patch_size": 14,
-        "num_layers": 32,
-        "num_heads": 16,
-        "hidden_dim": 1280,
-        "mlp_dim": 5120,
-        "num_reg_tokens": 4,
-        "drop_path_rate": 0.55,
-    },
+    config={"patch_size": 14, **HUGE, "num_reg_tokens": 4, "drop_path_rate": 0.55},
 )
 
 registry.register_weights(
@@ -651,7 +516,7 @@ registry.register_weights(
         "formats": {
             "pt": {
                 "file_size": 21.5,
-                "sha256": "6cd9749a9522f8ff61088e38702553fb1c4d2547b417c499652e3bfa6a81e77a",
+                "sha256": "a04141c7f6c459ae075a48ccdee5b82d191bbaa82337673140c06ef82f0a8dc5",
             }
         },
         "net": {"network": "deit3_t16", "tag": "il-common"},
@@ -665,7 +530,7 @@ registry.register_weights(
         "formats": {
             "pt": {
                 "file_size": 21.5,
-                "sha256": "6806a5ae7d45f1c84b25e9869a9cbc7de94368fe9573dc3777acf2da8c83dc4e",
+                "sha256": "d26320462da64df6d62b307f7fb35d09c86a5f073002dfb24a51f014074e65c3",
             }
         },
         "net": {"network": "deit3_reg4_t16", "tag": "il-common"},

birder/net/densenet.py

@@ -104,19 +104,20 @@ class DenseNet(DetectorBackbone):
         num_features = num_init_features
         stages: OrderedDict[str, nn.Module] = OrderedDict()
         return_channels: list[int] = []
-        layers = []
         for i, num_layers in enumerate(layer_list):
+            stage_layers = []
+            if i != 0:
+                stage_layers.append(TransitionBlock(num_features, num_features // 2))
+                num_features = num_features // 2
 
-            layers.append(DenseBlock(num_features, num_layers=num_layers, growth_rate=growth_rate))
+            stage_layers.append(DenseBlock(num_features, num_layers=num_layers, growth_rate=growth_rate))
             num_features = num_features + (num_layers * growth_rate)
+            if i == len(layer_list) - 1:
+                stage_layers.append(nn.BatchNorm2d(num_features))
+                stage_layers.append(nn.ReLU(inplace=True))
 
-            stages[f"stage{i+1}"] = nn.Sequential(*layers)
+            stages[f"stage{i+1}"] = nn.Sequential(*stage_layers)
             return_channels.append(num_features)
-            layers = []
-
-            if i != len(layer_list) - 1:
-                layers.append(TransitionBlock(num_features, num_features // 2))
-                num_features = num_features // 2
 
         self.body = nn.Sequential(stages)
         self.features = nn.Sequential(

birder/net/detection/__init__.py

@@ -3,8 +3,10 @@ from birder.net.detection.detr import DETR
 from birder.net.detection.efficientdet import EfficientDet
 from birder.net.detection.faster_rcnn import Faster_RCNN
 from birder.net.detection.fcos import FCOS
+from birder.net.detection.plain_detr import Plain_DETR
 from birder.net.detection.retinanet import RetinaNet
 from birder.net.detection.rt_detr_v1 import RT_DETR_v1
+from birder.net.detection.rt_detr_v2 import RT_DETR_v2
 from birder.net.detection.ssd import SSD
 from birder.net.detection.ssdlite import SSDLite
 from birder.net.detection.vitdet import ViTDet
@@ -19,8 +21,10 @@ __all__ = [
     "EfficientDet",
     "Faster_RCNN",
     "FCOS",
+    "Plain_DETR",
     "RetinaNet",
     "RT_DETR_v1",
+    "RT_DETR_v2",
     "SSD",
     "SSDLite",
     "ViTDet",

birder/net/detection/{yolo_anchors.py → _yolo_anchors.py}

@@ -71,7 +71,7 @@ def scale_anchors(anchors: AnchorGroups, from_size: tuple[int, int], to_size: tu
 
 
 def scale_anchors(anchors: AnchorLike, from_size: tuple[int, int], to_size: tuple[int, int]) -> AnchorLike:
-    (anchor_groups, single) = _normalize_anchor_groups(anchors)
+    anchor_groups, single = _normalize_anchor_groups(anchors)
 
     if from_size == to_size:
         # Avoid aliasing default anchors in case they are mutated later
@@ -100,7 +100,7 @@ def pixels_to_grid(anchors: AnchorGroups, strides: Sequence[int]) -> AnchorGroup
 
 
 def pixels_to_grid(anchors: AnchorLike, strides: Sequence[int]) -> AnchorLike:
-    (anchor_groups, single) = _normalize_anchor_groups(anchors)
+    anchor_groups, single = _normalize_anchor_groups(anchors)
     if len(anchor_groups) != len(strides):
         raise ValueError("strides must provide one value per anchor scale")
 
@@ -123,7 +123,7 @@ def grid_to_pixels(anchors: AnchorGroups, strides: Sequence[int]) -> AnchorGroup
 
 
 def grid_to_pixels(anchors: AnchorLike, strides: Sequence[int]) -> AnchorLike:
-    (anchor_groups, single) = _normalize_anchor_groups(anchors)
+    anchor_groups, single = _normalize_anchor_groups(anchors)
     if len(anchor_groups) != len(strides):
         raise ValueError("strides must provide one value per anchor scale")
 
@@ -187,7 +187,7 @@ def resolve_anchor_group(
     preset: str, *, anchor_format: str, model_size: tuple[int, int], model_strides: Sequence[int]
 ) -> AnchorGroup:
     anchors = _resolve_anchors(preset, anchor_format=anchor_format, model_size=model_size, model_strides=model_strides)
-    (anchor_groups, single) = _normalize_anchor_groups(anchors)
+    anchor_groups, single = _normalize_anchor_groups(anchors)
     if single is False:
         raise ValueError("Expected a single anchor group for this model")
 
@@ -198,7 +198,7 @@ def resolve_anchor_groups(
     preset: str, *, anchor_format: str, model_size: tuple[int, int], model_strides: Sequence[int]
 ) -> AnchorGroups:
     anchors = _resolve_anchors(preset, anchor_format=anchor_format, model_size=model_size, model_strides=model_strides)
-    (anchor_groups, single) = _normalize_anchor_groups(anchors)
+    anchor_groups, single = _normalize_anchor_groups(anchors)
     if single is True:
         raise ValueError("Expected multiple anchor groups for this model")
 

birder/net/detection/base.py

@@ -41,6 +41,7 @@ def get_detection_signature(input_shape: tuple[int, ...], num_outputs: int, dyna
 
 class DetectionBaseNet(nn.Module):
     default_size: tuple[int, int]
+    block_group_regex: Optional[str]
     auto_register = False
     scriptable = True
     task = str(Task.OBJECT_DETECTION)
@@ -308,7 +309,7 @@ class SimpleFeaturePyramidNetwork(nn.Module):
             names.append(f"stage{idx+1}")
 
         if self.extra_blocks is not None:
-            (results, names) = self.extra_blocks(results, [x], names)
+            results, names = self.extra_blocks(results, [x], names)
 
         out = OrderedDict(list(zip(names, results)))
 
@@ -432,7 +433,7 @@ class BoxCoder:
         ctr_x = boxes[:, 0] + 0.5 * widths
         ctr_y = boxes[:, 1] + 0.5 * heights
 
-        (wx, wy, ww, wh) = self.weights
+        wx, wy, ww, wh = self.weights
         dx = rel_codes[:, 0::4] / wx
         dy = rel_codes[:, 1::4] / wy
         dw = rel_codes[:, 2::4] / ww
@@ -510,8 +511,8 @@ class AnchorGenerator(nn.Module):
         )
 
         for size, stride, base_anchors in zip(grid_sizes, strides, cell_anchors):
-            (grid_height, grid_width) = size
-            (stride_height, stride_width) = stride
+            grid_height, grid_width = size
+            stride_height, stride_width = stride
             device = base_anchors.device
 
             # For output anchor, compute [x_center, y_center, x_center, y_center]
@@ -656,7 +657,7 @@ class Matcher(nn.Module):
         #  tensor([39796, 32055, 32070, 39190, 40255, 40390, 41455, 45470, 45325, 46390]))
         # Each element in the first tensor is a gt index,
         # and each element in second tensor is a prediction index
-        # Note how gt items 1, 2, 3, and 5 each have two ties
+        # Note how gt items 1, 2, 3 and 5 each have two ties
 
         pred_idx_to_update = gt_pred_pairs_of_highest_quality[1]
         matches[pred_idx_to_update] = all_matches[pred_idx_to_update]