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

birder/net/detection/deformable_detr.py

@@ -9,7 +9,7 @@ https://arxiv.org/abs/2010.04159
 
 Changes from original:
 * Removed two stage support
-* Zero cost matrix elements on overflow (HungarianMatcher)
+* Penalize cost matrix elements on overflow (HungarianMatcher)
 """
 
 # Reference license: Apache-2.0 (both)
@@ -58,7 +58,7 @@ class HungarianMatcher(nn.Module):
         self, class_logits: torch.Tensor, box_regression: torch.Tensor, targets: list[dict[str, torch.Tensor]]
     ) -> list[torch.Tensor]:
         with torch.no_grad():
-            (B, num_queries) = class_logits.shape[:2]
+            B, num_queries = class_logits.shape[:2]
 
             # We flatten to compute the cost matrices in a batch
             out_prob = class_logits.flatten(0, 1).sigmoid()  # [batch_size * num_queries, num_classes]
@@ -89,7 +89,10 @@ class HungarianMatcher(nn.Module):
             # Final cost matrix
             C = self.cost_bbox * cost_bbox + self.cost_class * cost_class + self.cost_giou * cost_giou
             C = C.view(B, num_queries, -1).cpu()
-            C[C.isnan() | C.isinf()] = 0.0
+            finite = torch.isfinite(C)
+            if not torch.all(finite):
+                penalty = C[finite].max().item() + 1.0 if finite.any().item() else 1.0
+                C.nan_to_num_(nan=penalty, posinf=penalty, neginf=penalty)
 
             sizes = [len(v["boxes"]) for v in targets]
             indices = [linear_sum_assignment(c[i]) for i, c in enumerate(C.split(sizes, -1))]
@@ -108,8 +111,7 @@ def inverse_sigmoid(x: torch.Tensor, eps: float = 1e-5) -> torch.Tensor:
 class MultiScaleDeformableAttention(nn.Module):
     def __init__(self, d_model: int, n_levels: int, n_heads: int, n_points: int) -> None:
         super().__init__()
-        if d_model % n_heads != 0:
-            raise ValueError(f"d_model must be divisible by n_heads, but got {d_model} and {n_heads}")
+        assert d_model % n_heads == 0, "d_model must be divisible by n_heads"
 
         # Ensure dim_per_head is power of 2
         dim_per_head = d_model // n_heads
@@ -130,9 +132,9 @@ class MultiScaleDeformableAttention(nn.Module):
         self.value_proj = nn.Linear(d_model, d_model)
         self.output_proj = nn.Linear(d_model, d_model)
 
-        self._reset_parameters()
+        self.reset_parameters()
 
-    def _reset_parameters(self) -> None:
+    def reset_parameters(self) -> None:
         nn.init.constant_(self.sampling_offsets.weight, 0.0)
         thetas = torch.arange(self.n_heads, dtype=torch.float32) * (2.0 * math.pi / self.n_heads)
         grid_init = torch.stack([thetas.cos(), thetas.sin()], -1)
@@ -163,8 +165,8 @@ class MultiScaleDeformableAttention(nn.Module):
         input_level_start_index: torch.Tensor,
         input_padding_mask: Optional[torch.Tensor] = None,
     ) -> torch.Tensor:
-        (N, num_queries, _) = query.size()
-        (N, sequence_length, _) = input_flatten.size()
+        N, num_queries, _ = query.size()
+        N, sequence_length, _ = input_flatten.size()
         assert (input_spatial_shapes[:, 0] * input_spatial_shapes[:, 1]).sum() == sequence_length
 
         value = self.value_proj(input_flatten)
@@ -280,7 +282,7 @@ class DeformableTransformerDecoderLayer(nn.Module):
         q = tgt + query_pos
         k = tgt + query_pos
 
-        (tgt2, _) = self.self_attn(
+        tgt2, _ = self.self_attn(
             q.transpose(0, 1), k.transpose(0, 1), tgt.transpose(0, 1), need_weights=False, attn_mask=self_attn_mask
         )
         tgt2 = tgt2.transpose(0, 1)
@@ -315,7 +317,7 @@ class DeformableTransformerEncoder(nn.Module):
         for lvl, spatial_shape in enumerate(spatial_shapes):
             H = spatial_shape[0]
             W = spatial_shape[1]
-            (ref_y, ref_x) = torch.meshgrid(
+            ref_y, ref_x = torch.meshgrid(
                 torch.linspace(0.5, H - 0.5, H, dtype=torch.float32, device=device),
                 torch.linspace(0.5, W - 0.5, W, dtype=torch.float32, device=device),
                 indexing="ij",
@@ -451,7 +453,7 @@ class DeformableTransformer(nn.Module):
 
         for m in self.modules():
             if isinstance(m, MultiScaleDeformableAttention):
-                m._reset_parameters()
+                m.reset_parameters()
 
             nn.init.xavier_uniform_(self.reference_points.weight, gain=1.0)
             nn.init.zeros_(self.reference_points.bias)
@@ -459,7 +461,7 @@ class DeformableTransformer(nn.Module):
         nn.init.normal_(self.level_embed)
 
     def get_valid_ratio(self, mask: torch.Tensor) -> torch.Tensor:
-        (_, H, W) = mask.size()
+        _, H, W = mask.size()
         valid_h = torch.sum(~mask[:, :, 0], 1)
         valid_w = torch.sum(~mask[:, 0, :], 1)
         valid_ratio_h = valid_h.float() / H
@@ -482,7 +484,7 @@ class DeformableTransformer(nn.Module):
         mask_list = []
         spatial_shape_list: list[list[int]] = []  # list[tuple[int, int]] not supported on TorchScript
         for lvl, (src, pos_embed, mask) in enumerate(zip(srcs, pos_embeds, masks)):
-            (_, _, H, W) = src.size()
+            _, _, H, W = src.size()
             spatial_shape_list.append([H, W])
             src = src.flatten(2).transpose(1, 2)
             pos_embed = pos_embed.flatten(2).transpose(1, 2)
@@ -505,14 +507,14 @@ class DeformableTransformer(nn.Module):
         )
 
         # Prepare input for decoder
-        (B, _, C) = memory.size()
+        B, _, C = memory.size()
         query_embed, tgt = torch.split(query_embed, C, dim=1)
         query_embed = query_embed.unsqueeze(0).expand(B, -1, -1)
         tgt = tgt.unsqueeze(0).expand(B, -1, -1)
         reference_points = self.reference_points(query_embed).sigmoid()
 
         # Decoder
-        (hs, inter_references) = self.decoder(
+        hs, inter_references = self.decoder(
             tgt, reference_points, memory, spatial_shapes, level_start_index, query_embed, valid_ratios, mask_flatten
         )
 
@@ -629,7 +631,7 @@ class Deformable_DETR(DetectionBaseNet):
         prior_prob = 0.01
         bias_value = -math.log((1 - prior_prob) / prior_prob)
         for class_embed in self.class_embed:
-            class_embed.bias.data = torch.ones(self.num_classes) * bias_value
+            nn.init.constant_(class_embed.bias, bias_value)
 
     def freeze(self, freeze_classifier: bool = True) -> None:
         for param in self.parameters():
@@ -653,20 +655,19 @@ class Deformable_DETR(DetectionBaseNet):
     ) -> torch.Tensor:
         idx = self._get_src_permutation_idx(indices)
         target_classes_o = torch.concat([t["labels"][J] for t, (_, J) in zip(targets, indices)], dim=0)
-        target_classes = torch.full(cls_logits.shape[:2], self.num_classes, dtype=torch.int64, device=cls_logits.device)
-        target_classes[idx] = target_classes_o
 
         target_classes_onehot = torch.zeros(
-            [cls_logits.shape[0], cls_logits.shape[1], cls_logits.shape[2] + 1],
+            cls_logits.size(0),
+            cls_logits.size(1),
+            cls_logits.size(2) + 1,
             dtype=cls_logits.dtype,
-            layout=cls_logits.layout,
             device=cls_logits.device,
         )
-        target_classes_onehot.scatter_(2, target_classes.unsqueeze(-1), 1)
-
+        target_classes_onehot[idx[0], idx[1], target_classes_o] = 1
         target_classes_onehot = target_classes_onehot[:, :, :-1]
+
         loss = sigmoid_focal_loss(cls_logits, target_classes_onehot, alpha=0.25, gamma=2.0)
-        loss_ce = (loss.mean(1).sum() / num_boxes) * cls_logits.shape[1]
+        loss_ce = (loss.mean(1).sum() / num_boxes) * cls_logits.size(1)
 
         return loss_ce
 
@@ -716,7 +717,7 @@ class Deformable_DETR(DetectionBaseNet):
         for idx in range(cls_logits.size(0)):
             indices = self.matcher(cls_logits[idx], box_output[idx], targets)
             loss_ce_i = self._class_loss(cls_logits[idx], targets, indices, num_boxes)
-            (loss_bbox_i, loss_giou_i) = self._box_loss(box_output[idx], targets, indices, num_boxes)
+            loss_bbox_i, loss_giou_i = self._box_loss(box_output[idx], targets, indices, num_boxes)
             loss_ce_list.append(loss_ce_i)
             loss_bbox_list.append(loss_bbox_i)
             loss_giou_list.append(loss_giou_i)
@@ -736,7 +737,7 @@ class Deformable_DETR(DetectionBaseNet):
         self, class_logits: torch.Tensor, box_regression: torch.Tensor, image_shapes: list[tuple[int, int]]
     ) -> list[dict[str, torch.Tensor]]:
         prob = class_logits.sigmoid()
-        (topk_values, topk_indexes) = torch.topk(prob.view(class_logits.shape[0], -1), k=100, dim=1)
+        topk_values, topk_indexes = torch.topk(prob.view(class_logits.shape[0], -1), k=100, dim=1)
         scores = topk_values
         topk_boxes = topk_indexes // class_logits.shape[2]
         labels = topk_indexes % class_logits.shape[2]
@@ -749,7 +750,7 @@ class Deformable_DETR(DetectionBaseNet):
         boxes = torch.gather(boxes, 1, topk_boxes.unsqueeze(-1).repeat(1, 1, 4))
 
         # Convert from relative [0, 1] to absolute [0, height] coordinates
-        (img_h, img_w) = target_sizes.unbind(1)
+        img_h, img_w = target_sizes.unbind(1)
         scale_fct = torch.stack([img_w, img_h, img_w, img_h], dim=1)
         boxes = boxes * scale_fct[:, None, :]
 
@@ -757,7 +758,7 @@ class Deformable_DETR(DetectionBaseNet):
         for s, l, b in zip(scores, labels, boxes):
             # Non-maximum suppression
             if self.soft_nms is not None:
-                (soft_scores, keep) = self.soft_nms(b, s, l, score_threshold=0.001)
+                soft_scores, keep = self.soft_nms(b, s, l, score_threshold=0.001)
                 s[keep] = soft_scores
 
                 b = b[keep]
@@ -794,14 +795,14 @@ class Deformable_DETR(DetectionBaseNet):
                 mask_size = feature_list[idx].shape[-2:]
                 m = F.interpolate(masks[None].float(), size=mask_size, mode="nearest").to(torch.bool)[0]
             else:
-                (B, _, H, W) = feature_list[idx].size()
+                B, _, H, W = feature_list[idx].size()
                 m = torch.zeros(B, H, W, dtype=torch.bool, device=x.device)
 
             feature_list[idx] = proj(feature_list[idx])
             mask_list.append(m)
             pos_list.append(self.pos_enc(feature_list[idx], m))
 
-        (hs, init_reference, inter_references) = self.transformer(
+        hs, init_reference, inter_references = self.transformer(
             feature_list, pos_list, self.query_embed.weight, mask_list
         )
         outputs_classes = []

birder/net/detection/detr.py

@@ -6,7 +6,7 @@ Paper "End-to-End Object Detection with Transformers", https://arxiv.org/abs/200
 
 Changes from original:
 * Move background index to first from last (to be inline with the rest of Birder detectors)
-* Zero cost matrix elements on overflow (HungarianMatcher)
+* Penalize cost matrix elements on overflow (HungarianMatcher)
 """
 
 # Reference license: Apache-2.0
@@ -51,7 +51,7 @@ class HungarianMatcher(nn.Module):
         self, class_logits: torch.Tensor, box_regression: torch.Tensor, targets: list[dict[str, torch.Tensor]]
     ) -> list[torch.Tensor]:
         with torch.no_grad():
-            (B, num_queries) = class_logits.shape[:2]
+            B, num_queries = class_logits.shape[:2]
 
             # We flatten to compute the cost matrices in a batch
             out_prob = class_logits.flatten(0, 1).softmax(-1)  # [batch_size * num_queries, num_classes]
@@ -78,7 +78,10 @@ class HungarianMatcher(nn.Module):
             # Final cost matrix
             C = self.cost_bbox * cost_bbox + self.cost_class * cost_class + self.cost_giou * cost_giou
             C = C.view(B, num_queries, -1).cpu()
-            C[C.isnan() | C.isinf()] = 0.0
+            finite = torch.isfinite(C)
+            if not torch.all(finite):
+                penalty = C[finite].max().item() + 1.0 if finite.any().item() else 1.0
+                C.nan_to_num_(nan=penalty, posinf=penalty, neginf=penalty)
 
             sizes = [len(v["boxes"]) for v in targets]
             indices = [linear_sum_assignment(c[i]) for i, c in enumerate(C.split(sizes, -1))]
@@ -108,7 +111,7 @@ class TransformerEncoderLayer(nn.Module):
         q = src + pos
         k = src + pos
 
-        (src2, _) = self.self_attn(q, k, value=src, key_padding_mask=src_key_padding_mask, need_weights=False)
+        src2, _ = self.self_attn(q, k, value=src, key_padding_mask=src_key_padding_mask, need_weights=False)
         src = src + self.dropout1(src2)
         src = self.norm1(src)
         src2 = self.linear2(self.dropout(self.activation(self.linear1(src))))
@@ -148,10 +151,10 @@ class TransformerDecoderLayer(nn.Module):
         q = tgt + query_pos
         k = tgt + query_pos
 
-        (tgt2, _) = self.self_attn(q, k, value=tgt, need_weights=False)
+        tgt2, _ = self.self_attn(q, k, value=tgt, need_weights=False)
         tgt = tgt + self.dropout1(tgt2)
         tgt = self.norm1(tgt)
-        (tgt2, _) = self.multihead_attn(
+        tgt2, _ = self.multihead_attn(
             query=tgt + query_pos,
             key=memory + pos,
             value=memory,
@@ -267,7 +270,7 @@ class PositionEmbeddingSine(nn.Module):
 
     def forward(self, x: torch.Tensor, mask: Optional[torch.Tensor] = None) -> torch.Tensor:
         if mask is None:
-            (B, _, H, W) = x.size()
+            B, _, H, W = x.size()
             mask = torch.zeros(B, H, W, dtype=torch.bool, device=x.device)
 
         not_mask = ~mask
@@ -427,7 +430,7 @@ class DETR(DetectionBaseNet):
         for idx in range(cls_logits.size(0)):
             indices = self.matcher(cls_logits[idx], box_output[idx], targets)
             loss_ce_i = self._class_loss(cls_logits[idx], targets, indices)
-            (loss_bbox_i, loss_giou_i) = self._box_loss(box_output[idx], targets, indices, num_boxes)
+            loss_bbox_i, loss_giou_i = self._box_loss(box_output[idx], targets, indices, num_boxes)
             loss_ce_list.append(loss_ce_i)
             loss_bbox_list.append(loss_bbox_i)
             loss_giou_list.append(loss_giou_i)
@@ -447,7 +450,7 @@ class DETR(DetectionBaseNet):
         self, class_logits: torch.Tensor, box_regression: torch.Tensor, image_shapes: list[tuple[int, int]]
     ) -> list[dict[str, torch.Tensor]]:
         prob = F.softmax(class_logits, -1)
-        (scores, labels) = prob[..., 1:].max(-1)
+        scores, labels = prob[..., 1:].max(-1)
         labels = labels + 1
 
         # TorchScript doesn't support creating tensor from tuples, convert everything to lists
@@ -457,7 +460,7 @@ class DETR(DetectionBaseNet):
         boxes = box_ops.box_convert(box_regression, in_fmt="cxcywh", out_fmt="xyxy")
 
         # Convert from relative [0, 1] to absolute [0, height] coordinates
-        (img_h, img_w) = target_sizes.unbind(1)
+        img_h, img_w = target_sizes.unbind(1)
         scale_fct = torch.stack([img_w, img_h, img_w, img_h], dim=1)
         boxes = boxes * scale_fct[:, None, :]
 
@@ -465,7 +468,7 @@ class DETR(DetectionBaseNet):
         for s, l, b in zip(scores, labels, boxes):
             # Non-maximum suppression
             if self.soft_nms is not None:
-                (soft_scores, keep) = self.soft_nms(b, s, l, score_threshold=0.001)
+                soft_scores, keep = self.soft_nms(b, s, l, score_threshold=0.001)
                 s[keep] = soft_scores
 
                 b = b[keep]

birder/net/detection/efficientdet.py

@@ -136,8 +136,8 @@ class ResampleFeatureMap(nn.Module):
         if self.conv is not None:
             x = self.conv(x)
 
-        (in_h, in_w) = x.shape[-2:]
-        (target_h, target_w) = target_size
+        in_h, in_w = x.shape[-2:]
+        target_h, target_w = target_size
         if in_h == target_h and in_w == target_w:
             return x
 
@@ -195,7 +195,7 @@ class FpnCombine(nn.Module):
             )
 
         if weight_method in {"attn", "fastattn"}:
-            self.edge_weights = nn.Parameter(torch.ones(len(inputs_offsets)), requires_grad=True)  # WSM
+            self.edge_weights = nn.Parameter(torch.ones(len(inputs_offsets)))  # WSM
         else:
             self.edge_weights = None
 
@@ -358,13 +358,7 @@ class HeadNet(nn.Module):
         for _ in range(repeats):
             layers.append(
                 nn.Conv2d(
-                    fpn_channels,
-                    fpn_channels,
-                    kernel_size=(3, 3),
-                    stride=(1, 1),
-                    padding=(1, 1),
-                    groups=fpn_channels,
-                    bias=True,
+                    fpn_channels, fpn_channels, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=fpn_channels
                 )
             )
             layers.append(
@@ -383,22 +377,9 @@ class HeadNet(nn.Module):
         self.conv_repeat = nn.Sequential(*layers)
         self.predict = nn.Sequential(
             nn.Conv2d(
-                fpn_channels,
-                fpn_channels,
-                kernel_size=(3, 3),
-                stride=(1, 1),
-                padding=(1, 1),
-                groups=fpn_channels,
-                bias=True,
-            ),
-            nn.Conv2d(
-                fpn_channels,
-                num_outputs * num_anchors,
-                kernel_size=(1, 1),
-                stride=(1, 1),
-                padding=(0, 0),
-                bias=True,
+                fpn_channels, fpn_channels, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=fpn_channels
             ),
+            nn.Conv2d(fpn_channels, num_outputs * num_anchors, kernel_size=(1, 1), stride=(1, 1), padding=(0, 0)),
         )
 
     def forward(self, x: list[torch.Tensor]) -> torch.Tensor:
@@ -453,7 +434,7 @@ class ClassificationHead(HeadNet):
             cls_logits = self.predict(cls_logits)
 
             # Permute classification output from (N, A * K, H, W) to (N, HWA, K).
-            (N, _, H, W) = cls_logits.shape
+            N, _, H, W = cls_logits.shape
             cls_logits = cls_logits.view(N, -1, self.num_outputs, H, W)
             cls_logits = cls_logits.permute(0, 3, 4, 1, 2)
             cls_logits = cls_logits.reshape(N, -1, self.num_outputs)  # Size=(N, HWA, K)
@@ -504,7 +485,7 @@ class RegressionHead(HeadNet):
             bbox_regression = self.predict(bbox_regression)
 
             # Permute bbox regression output from (N, 4 * A, H, W) to (N, HWA, 4).
-            (N, _, H, W) = bbox_regression.shape
+            N, _, H, W = bbox_regression.shape
             bbox_regression = bbox_regression.view(N, -1, 4, H, W)
             bbox_regression = bbox_regression.permute(0, 3, 4, 1, 2)
             bbox_regression = bbox_regression.reshape(N, -1, 4)  # Size=(N, HWA, 4)
@@ -663,7 +644,7 @@ class EfficientDet(DetectionBaseNet):
 
                 # Keep only topk scoring predictions
                 num_topk = min(self.topk_candidates, int(topk_idxs.size(0)))
-                (scores_per_level, idxs) = scores_per_level.topk(num_topk)
+                scores_per_level, idxs = scores_per_level.topk(num_topk)
                 topk_idxs = topk_idxs[idxs]
 
                 anchor_idxs = torch.div(topk_idxs, num_classes, rounding_mode="floor")
@@ -685,7 +666,7 @@ class EfficientDet(DetectionBaseNet):
 
             # Non-maximum suppression
             if self.soft_nms is not None:
-                (soft_scores, keep) = self.soft_nms(image_boxes, image_scores, image_labels, score_threshold=0.001)
+                soft_scores, keep = self.soft_nms(image_boxes, image_scores, image_labels, score_threshold=0.001)
                 image_scores[keep] = soft_scores
             else:
                 keep = box_ops.batched_nms(image_boxes, image_scores, image_labels, self.nms_thresh)

birder/net/detection/faster_rcnn.py

@@ -150,7 +150,7 @@ def concat_box_prediction_layers(
     # all feature levels concatenated, so we keep the same representation
     # for the objectness and the box_regression
     for box_cls_per_level, box_regression_per_level in zip(box_cls, box_regression):
-        (N, AxC, H, W) = box_cls_per_level.shape  # pylint: disable=invalid-name
+        N, AxC, H, W = box_cls_per_level.shape  # pylint: disable=invalid-name
         Ax4 = box_regression_per_level.shape[1]  # pylint: disable=invalid-name
         A = Ax4 // 4
         C = AxC // A
@@ -240,7 +240,7 @@ class RegionProposalNetwork(nn.Module):
 
                 # Get the targets corresponding GT for each proposal
                 # NB: need to clamp the indices because we can have a single
-                # GT in the image, and matched_idxs can be -2, which goes out of bounds
+                # GT in the image and matched_idxs can be -2, which goes out of bounds
                 matched_gt_boxes_per_image = gt_boxes[matched_idxs.clamp(min=0)]
 
                 labels_per_image = matched_idxs >= 0
@@ -265,7 +265,7 @@ class RegionProposalNetwork(nn.Module):
         for ob in objectness.split(num_anchors_per_level, 1):
             num_anchors = ob.shape[1]
             pre_nms_top_n = min(self.pre_nms_top_n(), int(ob.size(1)))
-            (_, top_n_idx) = ob.topk(pre_nms_top_n, dim=1)
+            _, top_n_idx = ob.topk(pre_nms_top_n, dim=1)
             r.append(top_n_idx + offset)
             offset += num_anchors
 
@@ -310,19 +310,19 @@ class RegionProposalNetwork(nn.Module):
 
             # Remove small boxes
             keep = box_ops.remove_small_boxes(boxes, self.min_size)
-            (boxes, scores, lvl) = boxes[keep], scores[keep], lvl[keep]
+            boxes, scores, lvl = boxes[keep], scores[keep], lvl[keep]
 
             # Remove low scoring boxes
             # use >= for Backwards compatibility
             keep = torch.where(scores >= self.score_thresh)[0]
-            (boxes, scores, lvl) = boxes[keep], scores[keep], lvl[keep]
+            boxes, scores, lvl = boxes[keep], scores[keep], lvl[keep]
 
             # Non-maximum suppression, independently done per level
             keep = box_ops.batched_nms(boxes, scores, lvl, self.nms_thresh)
 
             # Keep only topk scoring predictions
             keep = keep[: self.post_nms_top_n()]
-            (boxes, scores) = boxes[keep], scores[keep]
+            boxes, scores = boxes[keep], scores[keep]
 
             final_boxes.append(boxes)
             final_scores.append(scores)
@@ -336,7 +336,7 @@ class RegionProposalNetwork(nn.Module):
         labels: list[torch.Tensor],
         regression_targets: list[torch.Tensor],
     ) -> tuple[torch.Tensor, torch.Tensor]:
-        (sampled_pos_idxs, sampled_neg_idxs) = self.fg_bg_sampler(labels)
+        sampled_pos_idxs, sampled_neg_idxs = self.fg_bg_sampler(labels)
         sampled_pos_idxs = torch.where(torch.concat(sampled_pos_idxs, dim=0))[0]
         sampled_neg_idxs = torch.where(torch.concat(sampled_neg_idxs, dim=0))[0]
 
@@ -364,29 +364,29 @@ class RegionProposalNetwork(nn.Module):
     ) -> tuple[list[torch.Tensor], dict[str, torch.Tensor]]:
         # RPN uses all feature maps that are available
         features_list = list(features.values())
-        (objectness, pred_bbox_deltas) = self.head(features_list)
+        objectness, pred_bbox_deltas = self.head(features_list)
         anchors = self.anchor_generator(images, features_list)
 
         num_images = len(anchors)
         num_anchors_per_level_shape_tensors = [o[0].shape for o in objectness]
         num_anchors_per_level = [s[0] * s[1] * s[2] for s in num_anchors_per_level_shape_tensors]
-        (objectness, pred_bbox_deltas) = concat_box_prediction_layers(objectness, pred_bbox_deltas)
+        objectness, pred_bbox_deltas = concat_box_prediction_layers(objectness, pred_bbox_deltas)
 
         # Apply pred_bbox_deltas to anchors to obtain the decoded proposals
         # note that we detach the deltas because Faster R-CNN do not backprop through
         # the proposals
         proposals = self.box_coder.decode(pred_bbox_deltas.detach(), anchors)
         proposals = proposals.view(num_images, -1, 4)
-        (boxes, _scores) = self.filter_proposals(proposals, objectness, images.image_sizes, num_anchors_per_level)
+        boxes, _scores = self.filter_proposals(proposals, objectness, images.image_sizes, num_anchors_per_level)
 
         losses: dict[str, torch.Tensor] = {}
         if self.training is True:
             if targets is None:
                 raise ValueError("targets should not be None")
 
-            (labels, matched_gt_boxes) = self.assign_targets_to_anchors(anchors, targets)
+            labels, matched_gt_boxes = self.assign_targets_to_anchors(anchors, targets)
             regression_targets = self.box_coder.encode(matched_gt_boxes, anchors)
-            (loss_objectness, loss_rpn_box_reg) = self.compute_loss(
+            loss_objectness, loss_rpn_box_reg = self.compute_loss(
                 objectness, pred_bbox_deltas, labels, regression_targets
             )
             losses = {
@@ -405,7 +405,7 @@ class FastRCNNConvFCHead(nn.Sequential):
         fc_layers: list[int],
         norm_layer: Optional[Callable[..., nn.Module]] = None,
     ):
-        (in_channels, in_height, in_width) = input_size
+        in_channels, in_height, in_width = input_size
 
         blocks = []
         previous_channels = in_channels
@@ -481,7 +481,7 @@ def faster_rcnn_loss(
     # advanced indexing
     sampled_pos_idxs_subset = torch.where(labels > 0)[0]
     labels_pos = labels[sampled_pos_idxs_subset]
-    (N, _num_classes) = class_logits.shape
+    N, _num_classes = class_logits.shape
     box_regression = box_regression.reshape(N, box_regression.size(-1) // 4, 4)
 
     box_loss = F.smooth_l1_loss(
@@ -573,7 +573,7 @@ class RoIHeads(nn.Module):
         return (matched_idxs, labels)
 
     def subsample(self, labels: list[torch.Tensor]) -> list[torch.Tensor]:
-        (sampled_pos_idxs, sampled_neg_idxs) = self.fg_bg_sampler(labels)
+        sampled_pos_idxs, sampled_neg_idxs = self.fg_bg_sampler(labels)
         sampled_idxs = []
         for pos_idxs_img, neg_idxs_img in zip(sampled_pos_idxs, sampled_neg_idxs):
             img_sampled_idxs = torch.where(pos_idxs_img | neg_idxs_img)[0]
@@ -610,7 +610,7 @@ class RoIHeads(nn.Module):
         proposals = self.add_gt_proposals(proposals, gt_boxes)
 
         # Get matching gt indices for each proposal
-        (matched_idxs, labels) = self.assign_targets_to_proposals(proposals, gt_boxes, gt_labels)
+        matched_idxs, labels = self.assign_targets_to_proposals(proposals, gt_boxes, gt_labels)
 
         # Sample a fixed proportion of positive-negative proposals
         sampled_idxs = self.subsample(labels)
@@ -713,7 +713,7 @@ class RoIHeads(nn.Module):
                     raise TypeError(f"target labels must of int64 type, instead got {t['labels'].dtype}")
 
         if self.training is True:
-            (proposals, _matched_idxs, labels, regression_targets) = self.select_training_samples(proposals, targets)
+            proposals, _matched_idxs, labels, regression_targets = self.select_training_samples(proposals, targets)
         else:
             labels = None
             regression_targets = None
@@ -721,7 +721,7 @@ class RoIHeads(nn.Module):
 
         box_features = self.box_roi_pool(features, proposals, image_shapes)
         box_features = self.box_head(box_features)
-        (class_logits, box_regression) = self.box_predictor(box_features)
+        class_logits, box_regression = self.box_predictor(box_features)
 
         losses = {}
         result: list[dict[str, torch.Tensor]] = []
@@ -731,11 +731,11 @@ class RoIHeads(nn.Module):
             if regression_targets is None:
                 raise ValueError("regression_targets cannot be None")
 
-            (loss_classifier, loss_box_reg) = faster_rcnn_loss(class_logits, box_regression, labels, regression_targets)
+            loss_classifier, loss_box_reg = faster_rcnn_loss(class_logits, box_regression, labels, regression_targets)
             losses = {"loss_classifier": loss_classifier, "loss_box_reg": loss_box_reg}
 
         else:
-            (boxes, scores, labels) = self.postprocess_detections(class_logits, box_regression, proposals, image_shapes)
+            boxes, scores, labels = self.postprocess_detections(class_logits, box_regression, proposals, image_shapes)
             num_images = len(boxes)
             for i in range(num_images):
                 result.append(
@@ -868,8 +868,8 @@ class Faster_RCNN(DetectionBaseNet):
         images = self._to_img_list(x, image_sizes)
 
         features = self.backbone_with_fpn(x)
-        (proposals, proposal_losses) = self.rpn(images, features, targets)
-        (detections, detector_losses) = self.roi_heads(features, proposals, images.image_sizes, targets)
+        proposals, proposal_losses = self.rpn(images, features, targets)
+        detections, detector_losses = self.roi_heads(features, proposals, images.image_sizes, targets)
 
         losses = {}
         losses.update(detector_losses)

birder/net/detection/fcos.py

@@ -125,7 +125,7 @@ class FCOSClassificationHead(nn.Module):
             cls_logits = self.cls_logits(cls_logits)
 
             # Permute classification output from (N, A * K, H, W) to (N, HWA, K).
-            (N, _, H, W) = cls_logits.size()
+            N, _, H, W = cls_logits.size()
             cls_logits = cls_logits.view(N, -1, self.num_classes, H, W)
             cls_logits = cls_logits.permute(0, 3, 4, 1, 2)
             cls_logits = cls_logits.reshape(N, -1, self.num_classes)  # (N, HWA, 4)
@@ -165,7 +165,7 @@ class FCOSRegressionHead(nn.Module):
             bbox_ctrness = self.bbox_ctrness(bbox_feature)
 
             # Permute bbox regression output from (N, 4 * A, H, W) to (N, HWA, 4).
-            (N, _, H, W) = bbox_regression.size()
+            N, _, H, W = bbox_regression.size()
             bbox_regression = bbox_regression.view(N, -1, 4, H, W)
             bbox_regression = bbox_regression.permute(0, 3, 4, 1, 2)
             bbox_regression = bbox_regression.reshape(N, -1, 4)  # (N, HWA, 4)
@@ -262,7 +262,7 @@ class FCOSHead(nn.Module):
 
     def forward(self, x: list[torch.Tensor]) -> dict[str, torch.Tensor]:
         cls_logits = self.classification_head(x)
-        (bbox_regression, bbox_ctrness) = self.regression_head(x)
+        bbox_regression, bbox_ctrness = self.regression_head(x)
 
         return {
             "cls_logits": cls_logits,
@@ -370,8 +370,8 @@ class FCOS(DetectionBaseNet):
             ).values < self.center_sampling_radius * anchor_sizes[:, None]
 
             # Compute pairwise distance between N points and M boxes
-            (x, y) = anchor_centers.unsqueeze(dim=2).unbind(dim=1)  # (N, 1)
-            (x0, y0, x1, y1) = gt_boxes.unsqueeze(dim=0).unbind(dim=2)  # (1, M)
+            x, y = anchor_centers.unsqueeze(dim=2).unbind(dim=1)  # (N, 1)
+            x0, y0, x1, y1 = gt_boxes.unsqueeze(dim=0).unbind(dim=2)  # (1, M)
             pairwise_dist = torch.stack([x - x0, y - y0, x1 - x, y1 - y], dim=2)  # (N, M)
 
             # Anchor point must be inside gt
@@ -388,7 +388,7 @@ class FCOS(DetectionBaseNet):
             # Match the GT box with minimum area, if there are multiple GT matches
             gt_areas = (gt_boxes[:, 2] - gt_boxes[:, 0]) * (gt_boxes[:, 3] - gt_boxes[:, 1])  # N
             pairwise_match = pairwise_match.to(torch.float32) * (1e8 - gt_areas[None, :])
-            (min_values, matched_idx) = pairwise_match.max(dim=1)  # R, per-anchor match
+            min_values, matched_idx = pairwise_match.max(dim=1)  # R, per-anchor match
             matched_idx[min_values < 1e-5] = -1  # Unmatched anchors are assigned -1
 
             matched_idxs.append(matched_idx)
@@ -433,7 +433,7 @@ class FCOS(DetectionBaseNet):
 
                 # Keep only topk scoring predictions
                 num_topk = min(self.topk_candidates, int(topk_idxs.size(0)))
-                (scores_per_level, idxs) = scores_per_level.topk(num_topk)
+                scores_per_level, idxs = scores_per_level.topk(num_topk)
                 topk_idxs = topk_idxs[idxs]
 
                 anchor_idxs = torch.div(topk_idxs, num_classes, rounding_mode="floor")
@@ -455,7 +455,7 @@ class FCOS(DetectionBaseNet):
 
             # Non-maximum suppression
             if self.soft_nms is not None:
-                (soft_scores, keep) = self.soft_nms(image_boxes, image_scores, image_labels, score_threshold=0.001)
+                soft_scores, keep = self.soft_nms(image_boxes, image_scores, image_labels, score_threshold=0.001)
                 image_scores[keep] = soft_scores
             else:
                 keep = box_ops.batched_nms(image_boxes, image_scores, image_labels, self.nms_thresh)