Merge branch 'limengzhang/fix_kwargs' into 'refactor_dev'

[Fix] Delete all **kwargs in Segmentor Forward function

See merge request openmmlab-enterprise/openmmlab-ce/mmsegmentation!52

Author: zhengmiao

mmseg/models/decode_heads/cascade_decode_head.py

@@ -21,8 +21,7 @@ def forward(self, inputs, prev_output):
         pass
 
     def loss(self, inputs: List[Tensor], prev_output: Tensor,
-             batch_data_samples: List[dict], train_cfg: ConfigType,
-             **kwargs) -> Tensor:
+             batch_data_samples: List[dict], train_cfg: ConfigType) -> Tensor:
         """Forward function for training.
 
         Args:
@@ -37,12 +36,12 @@ def loss(self, inputs: List[Tensor], prev_output: Tensor,
             dict[str, Tensor]: a dictionary of loss components
         """
         seg_logits = self.forward(inputs, prev_output)
-        losses = self.loss_by_feat(seg_logits, batch_data_samples, **kwargs)
+        losses = self.loss_by_feat(seg_logits, batch_data_samples)
 
         return losses
 
     def predict(self, inputs: List[Tensor], prev_output: Tensor,
-                batch_img_metas: List[dict], tese_cfg: ConfigType, **kwargs):
+                batch_img_metas: List[dict], tese_cfg: ConfigType):
         """Forward function for testing.
 
         Args:
@@ -60,4 +59,4 @@ def predict(self, inputs: List[Tensor], prev_output: Tensor,
         """
         seg_logits = self.forward(inputs, prev_output)
 
-        return self.predict_by_feat(seg_logits, batch_img_metas, **kwargs)
+        return self.predict_by_feat(seg_logits, batch_img_metas)

mmseg/models/decode_heads/decode_head.py

@@ -205,7 +205,7 @@ def _transform_inputs(self, inputs):
         return inputs
 
     @abstractmethod
-    def forward(self, inputs, **kwargs):
+    def forward(self, inputs):
         """Placeholder of forward function."""
         pass
 
@@ -217,7 +217,7 @@ def cls_seg(self, feat):
         return output
 
     def loss(self, inputs: Tuple[Tensor], batch_data_samples: SampleList,
-             train_cfg: ConfigType, **kwargs) -> dict:
+             train_cfg: ConfigType) -> dict:
         """Forward function for training.
 
         Args:
@@ -230,12 +230,12 @@ def loss(self, inputs: Tuple[Tensor], batch_data_samples: SampleList,
         Returns:
             dict[str, Tensor]: a dictionary of loss components
         """
-        seg_logits = self.forward(inputs, **kwargs)
-        losses = self.loss_by_feat(seg_logits, batch_data_samples, **kwargs)
+        seg_logits = self.forward(inputs)
+        losses = self.loss_by_feat(seg_logits, batch_data_samples)
         return losses
 
     def predict(self, inputs: Tuple[Tensor], batch_img_metas: List[dict],
-                test_cfg: ConfigType, **kwargs) -> List[Tensor]:
+                test_cfg: ConfigType) -> List[Tensor]:
         """Forward function for prediction.
 
         Args:
@@ -250,18 +250,18 @@ def predict(self, inputs: Tuple[Tensor], batch_img_metas: List[dict],
         Returns:
             List[Tensor]: Outputs segmentation logits map.
         """
-        seg_logits = self.forward(inputs, **kwargs)
+        seg_logits = self.forward(inputs)
 
-        return self.predict_by_feat(seg_logits, batch_img_metas, **kwargs)
+        return self.predict_by_feat(seg_logits, batch_img_metas)
 
     def _stack_batch_gt(self, batch_data_samples: SampleList) -> Tensor:
         gt_semantic_segs = [
             data_sample.gt_sem_seg.data for data_sample in batch_data_samples
         ]
         return torch.stack(gt_semantic_segs, dim=0)
 
-    def loss_by_feat(self, seg_logits: Tensor, batch_data_samples: SampleList,
-                     **kwargs) -> dict:
+    def loss_by_feat(self, seg_logits: Tensor,
+                     batch_data_samples: SampleList) -> dict:
         """Compute segmentation loss.
 
         Args:
@@ -309,8 +309,8 @@ def loss_by_feat(self, seg_logits: Tensor, batch_data_samples: SampleList,
             seg_logits, seg_label, ignore_index=self.ignore_index)
         return loss
 
-    def predict_by_feat(self, seg_logits: Tensor, batch_img_metas: List[dict],
-                        **kwargs) -> List[Tensor]:
+    def predict_by_feat(self, seg_logits: Tensor,
+                        batch_img_metas: List[dict]) -> List[Tensor]:
         """Transform a batch of output seg_logits to the input shape.
 
         Args:

mmseg/models/segmentors/base.py

@@ -53,16 +53,15 @@ def extract_feat(self, batch_inputs: Tensor) -> bool:
 
     @abstractmethod
     def encode_decode(self, batch_inputs: Tensor,
-                      batch_data_samples: SampleList, **kwargs):
+                      batch_data_samples: SampleList):
         """Placeholder for encode images with backbone and decode into a
         semantic segmentation map of the same size as input."""
         pass
 
     def forward(self,
                 batch_inputs: Tensor,
                 batch_data_samples: OptSampleList = None,
-                mode: str = 'tensor',
-                **kwargs) -> ForwardResults:
+                mode: str = 'tensor') -> ForwardResults:
         """The unified entry for a forward process in both training and test.
 
         The method should accept three modes: "tensor", "predict" and "loss":
@@ -92,33 +91,33 @@ def forward(self,
             - If ``mode="loss"``, return a dict of tensor.
         """
         if mode == 'loss':
-            return self.loss(batch_inputs, batch_data_samples, **kwargs)
+            return self.loss(batch_inputs, batch_data_samples)
         elif mode == 'predict':
-            return self.predict(batch_inputs, batch_data_samples, **kwargs)
+            return self.predict(batch_inputs, batch_data_samples)
         elif mode == 'tensor':
-            return self._forward(batch_inputs, batch_data_samples, **kwargs)
+            return self._forward(batch_inputs, batch_data_samples)
         else:
             raise RuntimeError(f'Invalid mode "{mode}". '
                                'Only supports loss, predict and tensor mode')
 
     @abstractmethod
-    def loss(self, batch_inputs: Tensor, batch_data_samples: SampleList,
-             **kwargs) -> dict:
+    def loss(self, batch_inputs: Tensor,
+             batch_data_samples: SampleList) -> dict:
         """Calculate losses from a batch of inputs and data samples."""
         pass
 
     @abstractmethod
-    def predict(self, batch_inputs: Tensor, batch_data_samples: SampleList,
-                **kwargs) -> SampleList:
+    def predict(self, batch_inputs: Tensor,
+                batch_data_samples: SampleList) -> SampleList:
         """Predict results from a batch of inputs and data samples with post-
         processing."""
         pass
 
     @abstractmethod
-    def _forward(self,
-                 batch_inputs: Tensor,
-                 batch_data_samples: OptSampleList = None,
-                 **kwargs) -> Tuple[List[Tensor]]:
+    def _forward(
+            self,
+            batch_inputs: Tensor,
+            batch_data_samples: OptSampleList = None) -> Tuple[List[Tensor]]:
         """Network forward process.
 
         Usually includes backbone, neck and head forward without any post-
@@ -127,7 +126,7 @@ def _forward(self,
         pass
 
     @abstractmethod
-    def aug_test(self, batch_inputs, batch_img_metas, **kwargs):
+    def aug_test(self, batch_inputs, batch_img_metas):
         """Placeholder for augmentation test."""
         pass
 

mmseg/models/segmentors/cascade_encoder_decoder.py

@@ -70,29 +70,28 @@ def _init_decode_head(self, decode_head: ConfigType) -> None:
         self.align_corners = self.decode_head[-1].align_corners
         self.num_classes = self.decode_head[-1].num_classes
 
-    def encode_decode(self, batch_inputs: Tensor, batch_img_metas: List[dict],
-                      **kwargs) -> List[Tensor]:
+    def encode_decode(self, batch_inputs: Tensor,
+                      batch_img_metas: List[dict]) -> List[Tensor]:
         """Encode images with backbone and decode into a semantic segmentation
         map of the same size as input."""
         x = self.extract_feat(batch_inputs)
-        out = self.decode_head[0].forward(x, **kwargs)
+        out = self.decode_head[0].forward(x)
         for i in range(1, self.num_stages - 1):
-            out = self.decode_head[i].forward(x, out, **kwargs)
+            out = self.decode_head[i].forward(x, out)
         seg_logits_list = self.decode_head[-1].predict(x, out, batch_img_metas,
-                                                       self.test_cfg, **kwargs)
+                                                       self.test_cfg)
 
         return seg_logits_list
 
     def _decode_head_forward_train(self, batch_inputs: Tensor,
-                                   batch_data_samples: SampleList,
-                                   **kwargs) -> dict:
+                                   batch_data_samples: SampleList) -> dict:
         """Run forward function and calculate loss for decode head in
         training."""
         losses = dict()
 
         loss_decode = self.decode_head[0].loss(batch_inputs,
                                                batch_data_samples,
-                                               self.train_cfg, **kwargs)
+                                               self.train_cfg)
 
         losses.update(add_prefix(loss_decode, 'decode_0'))
         # get batch_img_metas
@@ -105,22 +104,20 @@ def _decode_head_forward_train(self, batch_inputs: Tensor,
         for i in range(1, self.num_stages):
             # forward test again, maybe unnecessary for most methods.
             if i == 1:
-                prev_outputs = self.decode_head[0].forward(
-                    batch_inputs, **kwargs)
+                prev_outputs = self.decode_head[0].forward(batch_inputs)
             else:
                 prev_outputs = self.decode_head[i - 1].forward(
-                    batch_inputs, prev_outputs, **kwargs)
+                    batch_inputs, prev_outputs)
             loss_decode = self.decode_head[i].loss(batch_inputs, prev_outputs,
                                                    batch_data_samples,
-                                                   self.train_cfg, **kwargs)
+                                                   self.train_cfg)
             losses.update(add_prefix(loss_decode, f'decode_{i}'))
 
         return losses
 
     def _forward(self,
                  batch_inputs: Tensor,
-                 data_samples: OptSampleList = None,
-                 **kwargs) -> Tensor:
+                 data_samples: OptSampleList = None) -> Tensor:
         """Network forward process.
 
         Args:
@@ -137,6 +134,6 @@ def _forward(self,
         out = self.decode_head[0].forward(x)
         for i in range(1, self.num_stages):
             # TODO support PointRend tensor mode
-            out = self.decode_head[i].forward(x, out, **kwargs)
+            out = self.decode_head[i].forward(x, out)
 
         return out