lint

Signed-off-by: R. Garcia-Dias <rafaelagd@gmail.com>

Author: garciadias

monai/apps/auto3dseg/bundle_gen.py

@@ -264,21 +264,16 @@ def _run_cmd(self, cmd: str, devices_info: str = "") -> subprocess.CompletedProc
                 look_up_option(self.device_setting["MN_START_METHOD"], ["bcprun"])
             except ValueError as err:
                 raise NotImplementedError(
-                    f"{self.device_setting['MN_START_METHOD']} is not supported yet."
-                    "Try modify BundleAlgo._run_cmd for your cluster."
+                    f"{self.device_setting['MN_START_METHOD']} is not supported yet.Try modify BundleAlgo._run_cmd for your cluster."
                 ) from err
 
             return _run_cmd_bcprun(cmd, n=self.device_setting["NUM_NODES"], p=self.device_setting["n_devices"])
         elif int(self.device_setting["n_devices"]) > 1:
-            return _run_cmd_torchrun(
-                cmd, nnodes=1, nproc_per_node=self.device_setting["n_devices"], env=ps_environ, check=True
-            )
+            return _run_cmd_torchrun(cmd, nnodes=1, nproc_per_node=self.device_setting["n_devices"], env=ps_environ, check=True)
         else:
             return run_cmd(cmd.split(), run_cmd_verbose=True, env=ps_environ, check=True)
 
-    def train(
-        self, train_params: None | dict = None, device_setting: None | dict = None
-    ) -> subprocess.CompletedProcess:
+    def train(self, train_params: None | dict = None, device_setting: None | dict = None) -> subprocess.CompletedProcess:
         """
         Load the run function in the training script of each model. Training parameter is predefined by the
         algo_config.yaml file, which is pre-filled by the fill_template_config function in the same instance.
@@ -369,9 +364,7 @@ def get_output_path(self):
 
 
 # path to download the algo_templates
-default_algo_zip = (
-    f"https://github.com/Project-MONAI/research-contributions/releases/download/algo_templates/{ALGO_HASH}.tar.gz"
-)
+default_algo_zip = f"https://github.com/Project-MONAI/research-contributions/releases/download/algo_templates/{ALGO_HASH}.tar.gz"
 
 # default algorithms
 default_algos = {
@@ -396,7 +389,7 @@ def _download_algos_url(url: str, at_path: str) -> dict[str, dict[str, str]]:
         try:
             download_and_extract(url=url, filepath=algo_compressed_file, output_dir=os.path.dirname(at_path))
         except Exception as e:
-            msg = f"Download and extract of {url} failed, attempt {i+1}/{download_attempts}."
+            msg = f"Download and extract of {url} failed, attempt {i + 1}/{download_attempts}."
             if i < download_attempts - 1:
                 warnings.warn(msg)
                 time.sleep(i)
@@ -660,6 +653,7 @@ def generate(
                     gen_algo.export_to_disk(output_folder, name, fold=f_id)
 
                 algo_to_pickle(gen_algo, template_path=algo.template_path)
-                self.history.append(
-                    {AlgoKeys.ID: name, AlgoKeys.ALGO: gen_algo}
-                )  # track the previous, may create a persistent history
+                self.history.append({
+                    AlgoKeys.ID: name,
+                    AlgoKeys.ALGO: gen_algo,
+                })  # track the previous, may create a persistent history

monai/apps/detection/networks/retinanet_detector.py

@@ -59,9 +59,7 @@
 from monai.networks.nets import resnet
 from monai.utils import BlendMode, PytorchPadMode, ensure_tuple_rep, optional_import
 
-BalancedPositiveNegativeSampler, _ = optional_import(
-    "torchvision.models.detection._utils", name="BalancedPositiveNegativeSampler"
-)
+BalancedPositiveNegativeSampler, _ = optional_import("torchvision.models.detection._utils", name="BalancedPositiveNegativeSampler")
 Matcher, _ = optional_import("torchvision.models.detection._utils", name="Matcher")
 
 
@@ -328,9 +326,7 @@ def set_box_regression_loss(self, box_loss: nn.Module, encode_gt: bool, decode_p
         self.encode_gt = encode_gt
         self.decode_pred = decode_pred
 
-    def set_regular_matcher(
-        self, fg_iou_thresh: float, bg_iou_thresh: float, allow_low_quality_matches: bool = True
-    ) -> None:
+    def set_regular_matcher(self, fg_iou_thresh: float, bg_iou_thresh: float, allow_low_quality_matches: bool = True) -> None:
         """
         Using for training. Set torchvision matcher that matches anchors with ground truth boxes.
 
@@ -342,12 +338,9 @@ def set_regular_matcher(
         """
         if fg_iou_thresh < bg_iou_thresh:
             raise ValueError(
-                "Require fg_iou_thresh >= bg_iou_thresh. "
-                f"Got fg_iou_thresh={fg_iou_thresh}, bg_iou_thresh={bg_iou_thresh}."
+                f"Require fg_iou_thresh >= bg_iou_thresh. Got fg_iou_thresh={fg_iou_thresh}, bg_iou_thresh={bg_iou_thresh}."
             )
-        self.proposal_matcher = Matcher(
-            fg_iou_thresh, bg_iou_thresh, allow_low_quality_matches=allow_low_quality_matches
-        )
+        self.proposal_matcher = Matcher(fg_iou_thresh, bg_iou_thresh, allow_low_quality_matches=allow_low_quality_matches)
 
     def set_atss_matcher(self, num_candidates: int = 4, center_in_gt: bool = False) -> None:
         """
@@ -496,9 +489,7 @@ def forward(
         """
         # 1. Check if input arguments are valid
         if self.training:
-            targets = check_training_targets(
-                input_images, targets, self.spatial_dims, self.target_label_key, self.target_box_key
-            )
+            targets = check_training_targets(input_images, targets, self.spatial_dims, self.target_label_key, self.target_box_key)
             self._check_detector_training_components()
 
         # 2. Pad list of images to a single Tensor `images` with spatial size divisible by self.size_divisible.
@@ -518,12 +509,8 @@ def forward(
                 ensure_dict_value_to_list_(head_outputs)
         else:
             if self.inferer is None:
-                raise ValueError(
-                    "`self.inferer` is not defined." "Please refer to function self.set_sliding_window_inferer(*)."
-                )
-            head_outputs = predict_with_inferer(
-                images, self.network, keys=[self.cls_key, self.box_reg_key], inferer=self.inferer
-            )
+                raise ValueError("`self.inferer` is not defined.Please refer to function self.set_sliding_window_inferer(*).")
+            head_outputs = predict_with_inferer(images, self.network, keys=[self.cls_key, self.box_reg_key], inferer=self.inferer)
 
         # 4. Generate anchors and store it in self.anchors: List[Tensor]
         self.generate_anchors(images, head_outputs)
@@ -545,7 +532,10 @@ def forward(
 
         # 6(2). If during inference, return detection results
         detections = self.postprocess_detections(
-            head_outputs, self.anchors, image_sizes, num_anchor_locs_per_level  # type: ignore
+            head_outputs,
+            self.anchors,
+            image_sizes,
+            num_anchor_locs_per_level,  # type: ignore
         )
         return detections
 
@@ -554,9 +544,7 @@ def _check_detector_training_components(self):
         Check if self.proposal_matcher and self.fg_bg_sampler have been set for training.
         """
         if not hasattr(self, "proposal_matcher"):
-            raise AttributeError(
-                "Matcher is not set. Please refer to self.set_regular_matcher(*) or self.set_atss_matcher(*)."
-            )
+            raise AttributeError("Matcher is not set. Please refer to self.set_regular_matcher(*) or self.set_atss_matcher(*).")
         if self.fg_bg_sampler is None and self.debug:
             warnings.warn(
                 "No balanced sampler is used. Negative samples are likely to "
@@ -653,9 +641,7 @@ def postprocess_detections(
         """
 
         # recover level sizes, HWA or HWDA for each level
-        num_anchors_per_level = [
-            num_anchor_locs * self.num_anchors_per_loc for num_anchor_locs in num_anchor_locs_per_level
-        ]
+        num_anchors_per_level = [num_anchor_locs * self.num_anchors_per_loc for num_anchor_locs in num_anchor_locs_per_level]
 
         # split outputs per level
         split_head_outputs: dict[str, list[Tensor]] = {}
@@ -672,9 +658,7 @@ def postprocess_detections(
         detections: list[dict[str, Tensor]] = []
 
         for index in range(num_images):
-            box_regression_per_image = [
-                br[index] for br in box_regression
-            ]  # List[Tensor], each sized (HWA, 2*spatial_dims)
+            box_regression_per_image = [br[index] for br in box_regression]  # List[Tensor], each sized (HWA, 2*spatial_dims)
             logits_per_image = [cl[index] for cl in class_logits]  # List[Tensor], each sized (HWA, self.num_classes)
             anchors_per_image, img_spatial_size = split_anchors[index], image_sizes[index]
             # decode box regression into boxes
@@ -687,13 +671,11 @@ def postprocess_detections(
                 boxes_per_image, logits_per_image, img_spatial_size
             )
 
-            detections.append(
-                {
-                    self.target_box_key: selected_boxes,  # Tensor, sized (N, 2*spatial_dims)
-                    self.pred_score_key: selected_scores,  # Tensor, sized (N, )
-                    self.target_label_key: selected_labels,  # Tensor, sized (N, )
-                }
-            )
+            detections.append({
+                self.target_box_key: selected_boxes,  # Tensor, sized (N, 2*spatial_dims)
+                self.pred_score_key: selected_scores,  # Tensor, sized (N, )
+                self.target_label_key: selected_labels,  # Tensor, sized (N, )
+            })
 
         return detections
 
@@ -722,9 +704,7 @@ def compute_loss(
         """
         matched_idxs = self.compute_anchor_matched_idxs(anchors, targets, num_anchor_locs_per_level)
         losses_cls = self.compute_cls_loss(head_outputs_reshape[self.cls_key], targets, matched_idxs)
-        losses_box_regression = self.compute_box_loss(
-            head_outputs_reshape[self.box_reg_key], targets, anchors, matched_idxs
-        )
+        losses_box_regression = self.compute_box_loss(head_outputs_reshape[self.box_reg_key], targets, anchors, matched_idxs)
         return {self.cls_key: losses_cls, self.box_reg_key: losses_box_regression}
 
     def compute_anchor_matched_idxs(
@@ -757,9 +737,7 @@ def compute_anchor_matched_idxs(
             # anchors_per_image: Tensor, targets_per_image: Dice[str, Tensor]
             if targets_per_image[self.target_box_key].numel() == 0:
                 # if no GT boxes
-                matched_idxs.append(
-                    torch.full((anchors_per_image.size(0),), -1, dtype=torch.int64, device=anchors_per_image.device)
-                )
+                matched_idxs.append(torch.full((anchors_per_image.size(0),), -1, dtype=torch.int64, device=anchors_per_image.device))
                 continue
 
             # matched_idxs_per_image (Tensor[int64]): Tensor sized (sum(HWA),) or (sum(HWDA),)
@@ -787,7 +765,7 @@ def compute_anchor_matched_idxs(
                 )
 
             if self.debug:
-                print(f"Max box overlap between anchors and gt boxes: {torch.max(match_quality_matrix,dim=1)[0]}.")
+                print(f"Max box overlap between anchors and gt boxes: {torch.max(match_quality_matrix, dim=1)[0]}.")
 
             if torch.max(matched_idxs_per_image) < 0:
                 warnings.warn(
@@ -799,9 +777,7 @@ def compute_anchor_matched_idxs(
             matched_idxs.append(matched_idxs_per_image)
         return matched_idxs
 
-    def compute_cls_loss(
-        self, cls_logits: Tensor, targets: list[dict[str, Tensor]], matched_idxs: list[Tensor]
-    ) -> Tensor:
+    def compute_cls_loss(self, cls_logits: Tensor, targets: list[dict[str, Tensor]], matched_idxs: list[Tensor]) -> Tensor:
         """
         Compute classification losses.
 
@@ -919,9 +895,7 @@ def get_cls_train_sample_per_image(
         gt_classes_target = torch.zeros_like(cls_logits_per_image)  # (sum(HW(D)A), self.num_classes)
         gt_classes_target[
             foreground_idxs_per_image,  # fg anchor idx in
-            targets_per_image[self.target_label_key][
-                matched_idxs_per_image[foreground_idxs_per_image]
-            ],  # fg class label
+            targets_per_image[self.target_label_key][matched_idxs_per_image[foreground_idxs_per_image]],  # fg class label
         ] = 1.0
 
         if self.fg_bg_sampler is None:
@@ -993,9 +967,9 @@ def get_box_train_sample_per_image(
 
         # select only the foreground boxes
         # matched GT boxes for foreground anchors
-        matched_gt_boxes_per_image = targets_per_image[self.target_box_key][
-            matched_idxs_per_image[foreground_idxs_per_image]
-        ].to(box_regression_per_image.device)
+        matched_gt_boxes_per_image = targets_per_image[self.target_box_key][matched_idxs_per_image[foreground_idxs_per_image]].to(
+            box_regression_per_image.device
+        )
         # predicted box regression for foreground anchors
         box_regression_per_image = box_regression_per_image[foreground_idxs_per_image, :]
         # foreground anchors

monai/apps/detection/utils/anchor_utils.py

@@ -136,9 +136,7 @@ def __init__(
         self.indexing = look_up_option(indexing, ["ij", "xy"])
 
         self.aspect_ratios = aspect_ratios
-        self.cell_anchors = [
-            self.generate_anchors(size, aspect_ratio) for size, aspect_ratio in zip(self.sizes, aspect_ratios)
-        ]
+        self.cell_anchors = [self.generate_anchors(size, aspect_ratio) for size, aspect_ratio in zip(self.sizes, aspect_ratios)]
 
     # This comment comes from torchvision.
     # TODO: https://github.com/pytorch/pytorch/issues/26792
@@ -174,13 +172,13 @@ def generate_anchors(
         if (self.spatial_dims >= 3) and (len(aspect_ratios_t.shape) != 2):
             raise ValueError(
                 f"In {self.spatial_dims}-D image, aspect_ratios for each level should be \
-                {len(aspect_ratios_t.shape)-1}-D. But got aspect_ratios with shape {aspect_ratios_t.shape}."
+                {len(aspect_ratios_t.shape) - 1}-D. But got aspect_ratios with shape {aspect_ratios_t.shape}."
             )
 
         if (self.spatial_dims >= 3) and (aspect_ratios_t.shape[1] != self.spatial_dims - 1):
             raise ValueError(
                 f"In {self.spatial_dims}-D image, aspect_ratios for each level should has \
-                shape (_,{self.spatial_dims-1}). But got aspect_ratios with shape {aspect_ratios_t.shape}."
+                shape (_,{self.spatial_dims - 1}). But got aspect_ratios with shape {aspect_ratios_t.shape}."
             )
 
         # if 2d, w:h = 1:aspect_ratios
@@ -253,8 +251,7 @@ def grid_anchors(self, grid_sizes: list[list[int]], strides: list[list[Tensor]])
             # compute anchor centers regarding to the image.
             # shifts_centers is [x_center, y_center] or [x_center, y_center, z_center]
             shifts_centers = [
-                torch.arange(0, size[axis], dtype=torch.int32, device=device) * stride[axis]
-                for axis in range(self.spatial_dims)
+                torch.arange(0, size[axis], dtype=torch.int32, device=device) * stride[axis] for axis in range(self.spatial_dims)
             ]
 
             # to support torchscript, cannot directly use torch.meshgrid(shifts_centers).
@@ -307,10 +304,7 @@ def forward(self, images: Tensor, feature_maps: list[Tensor]) -> list[Tensor]:
         batchsize = images.shape[0]
         dtype, device = feature_maps[0].dtype, feature_maps[0].device
         strides = [
-            [
-                torch.tensor(image_size[axis] // g[axis], dtype=torch.int64, device=device)
-                for axis in range(self.spatial_dims)
-            ]
+            [torch.tensor(image_size[axis] // g[axis], dtype=torch.int64, device=device) for axis in range(self.spatial_dims)]
             for g in grid_sizes
         ]
 

monai/apps/detection/utils/detector_utils.py

@@ -80,9 +80,7 @@ def check_training_targets(
     for i in range(len(targets)):
         target = targets[i]
         if (target_label_key not in target.keys()) or (target_box_key not in target.keys()):
-            raise ValueError(
-                f"{target_label_key} and {target_box_key} are expected keys in targets. Got {target.keys()}."
-            )
+            raise ValueError(f"{target_label_key} and {target_box_key} are expected keys in targets. Got {target.keys()}.")
 
         boxes = target[target_box_key]
         if not isinstance(boxes, torch.Tensor):
@@ -91,12 +89,10 @@ def check_training_targets(
             if boxes.numel() == 0:
                 warnings.warn(
                     f"Warning: Given target boxes has shape of {boxes.shape}. "
-                    f"The detector reshaped it with boxes = torch.reshape(boxes, [0, {2* spatial_dims}])."
+                    f"The detector reshaped it with boxes = torch.reshape(boxes, [0, {2 * spatial_dims}])."
                 )
             else:
-                raise ValueError(
-                    f"Expected target boxes to be a tensor of shape [N, {2* spatial_dims}], got {boxes.shape}.)."
-                )
+                raise ValueError(f"Expected target boxes to be a tensor of shape [N, {2 * spatial_dims}], got {boxes.shape}.).")
         if not torch.is_floating_point(boxes):
             raise ValueError(f"Expected target boxes to be a float tensor, got {boxes.dtype}.")
         targets[i][target_box_key] = standardize_empty_box(boxes, spatial_dims=spatial_dims)  # type: ignore