Use configurable for StandardROIHeads

Reviewed By: rbgirshick

Differential Revision: D21386044

fbshipit-source-id: 80fb5481dbaa9bd6c53ed4d594e64108e92ae7a3

detectron2/__init__.py

@@ -7,4 +7,4 @@ setup_environment()
 
 # This line will be programatically read/write by setup.py.
 # Leave them at the bottom of this file and don't touch them.
-__version__ = "0.1.2"
+__version__ = "0.1.3"

detectron2/config/config.py

@@ -135,7 +135,7 @@ def configurable(init_func):
     assert init_func.__name__ == "__init__", "@configurable should only be used for __init__!"
     if init_func.__module__.startswith("detectron2."):
         assert (
-            "experimental" in init_func.__doc__
+            init_func.__doc__ is not None and "experimental" in init_func.__doc__
         ), f"configurable {init_func} should be marked experimental"
 
     @functools.wraps(init_func)

detectron2/modeling/roi_heads/cascade_rcnn.py

 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+from typing import List
 import torch
 from torch import nn
 from torch.autograd.function import Function
 
+from detectron2.config import configurable
 from detectron2.layers import ShapeSpec
 from detectron2.structures import Boxes, Instances, pairwise_iou
 from detectron2.utils.events import get_event_storage
@@ -32,27 +34,77 @@ class CascadeROIHeads(StandardROIHeads):
     Implement :paper:`Cascade R-CNN`.
     """
 
-    def _init_box_head(self, cfg, input_shape):
+    @configurable
+    def __init__(
+        self,
+        *,
+        box_in_features: List[str],
+        box_pooler: ROIPooler,
+        box_heads: List[nn.Module],
+        box_predictors: List[nn.Module],
+        proposal_matchers: List[Matcher],
+        **kwargs,
+    ):
+        """
+        NOTE: this interface is experimental.
+
+        Args:
+            box_pooler (ROIPooler): pooler that extracts region features from given boxes
+            box_heads (list[nn.Module]): box head for each cascade stage
+            box_predictors (list[nn.Module]): box predictor for each cascade stage
+            proposal_matchers (list[Matcher]): matcher with different IoU thresholds to
+                match boxes with ground truth for each stage. The first matcher matches
+                RPN proposals with ground truth, the other matchers use boxes predicted
+                by the previous stage as proposals and match them with ground truth.
+        """
+        assert "proposal_matcher" not in kwargs, (
+            "CascadeROIHeads takes 'proposal_matchers=' for each stage instead "
+            "of one 'proposal_matcher='."
+        )
+        # The first matcher matches RPN proposals with ground truth, done in the base class
+        kwargs["proposal_matcher"] = proposal_matchers[0]
+        num_stages = self.num_cascade_stages = len(box_heads)
+        box_heads = nn.ModuleList(box_heads)
+        box_predictors = nn.ModuleList(box_predictors)
+        assert len(box_predictors) == num_stages, f"{len(box_predictors)} != {num_stages}!"
+        assert len(proposal_matchers) == num_stages, f"{len(proposal_matchers)} != {num_stages}!"
+        super().__init__(
+            box_in_features=box_in_features,
+            box_pooler=box_pooler,
+            box_head=box_heads,
+            box_predictor=box_predictors,
+            **kwargs,
+        )
+        self.proposal_matchers = proposal_matchers
+
+    @classmethod
+    def from_config(cls, cfg, input_shape):
+        ret = super().from_config(cfg, input_shape)
+        ret.pop("proposal_matcher")
+        return ret
+
+    @classmethod
+    def _init_box_head(cls, cfg, input_shape):
         # fmt: off
+        in_features              = cfg.MODEL.ROI_HEADS.IN_FEATURES
         pooler_resolution        = cfg.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION
-        pooler_scales            = tuple(1.0 / input_shape[k].stride for k in self.in_features)
+        pooler_scales            = tuple(1.0 / input_shape[k].stride for k in in_features)
         sampling_ratio           = cfg.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO
         pooler_type              = cfg.MODEL.ROI_BOX_HEAD.POOLER_TYPE
         cascade_bbox_reg_weights = cfg.MODEL.ROI_BOX_CASCADE_HEAD.BBOX_REG_WEIGHTS
         cascade_ious             = cfg.MODEL.ROI_BOX_CASCADE_HEAD.IOUS
-        self.num_cascade_stages  = len(cascade_ious)
-        assert len(cascade_bbox_reg_weights) == self.num_cascade_stages
+        assert len(cascade_bbox_reg_weights) == len(cascade_ious)
         assert cfg.MODEL.ROI_BOX_HEAD.CLS_AGNOSTIC_BBOX_REG,  \
             "CascadeROIHeads only support class-agnostic regression now!"
         assert cascade_ious[0] == cfg.MODEL.ROI_HEADS.IOU_THRESHOLDS[0]
         # fmt: on
 
-        in_channels = [input_shape[f].channels for f in self.in_features]
+        in_channels = [input_shape[f].channels for f in in_features]
         # Check all channel counts are equal
         assert len(set(in_channels)) == 1, in_channels
         in_channels = in_channels[0]
 
-        self.box_pooler = ROIPooler(
+        box_pooler = ROIPooler(
             output_size=pooler_resolution,
             scales=pooler_scales,
             sampling_ratio=sampling_ratio,
@@ -62,29 +114,25 @@ class CascadeROIHeads(StandardROIHeads):
             channels=in_channels, width=pooler_resolution, height=pooler_resolution
         )
 
-        self.box_head = nn.ModuleList()
-        self.box_predictor = nn.ModuleList()
-        self.box2box_transform = []
-        self.proposal_matchers = []
-        for k in range(self.num_cascade_stages):
+        box_heads, box_predictors, proposal_matchers = [], [], []
+        for match_iou, bbox_reg_weights in zip(cascade_ious, cascade_bbox_reg_weights):
             box_head = build_box_head(cfg, pooled_shape)
-            self.box_head.append(box_head)
-            # NOTE: use list of predictor in explicit args?
-            self.box_predictor.append(
+            box_heads.append(box_head)
+            box_predictors.append(
                 FastRCNNOutputLayers(
                     cfg,
                     box_head.output_shape,
-                    box2box_transform=Box2BoxTransform(weights=cascade_bbox_reg_weights[k]),
+                    box2box_transform=Box2BoxTransform(weights=bbox_reg_weights),
                 )
             )
-
-            if k == 0:
-                # The first matching is done by the matcher of ROIHeads (self.proposal_matcher).
-                self.proposal_matchers.append(None)
-            else:
-                self.proposal_matchers.append(
-                    Matcher([cascade_ious[k]], [0, 1], allow_low_quality_matches=False)
-                )
+            proposal_matchers.append(Matcher([match_iou], [0, 1], allow_low_quality_matches=False))
+        return {
+            "box_in_features": in_features,
+            "box_pooler": box_pooler,
+            "box_heads": box_heads,
+            "box_predictors": box_predictors,
+            "proposal_matchers": proposal_matchers,
+        }
 
     def forward(self, images, features, proposals, targets=None):
         del images
@@ -112,7 +160,7 @@ class CascadeROIHeads(StandardROIHeads):
                 Each has fields "proposal_boxes", and "objectness_logits",
                 "gt_classes", "gt_boxes".
         """
-        features = [features[f] for f in self.in_features]
+        features = [features[f] for f in self.box_in_features]
         head_outputs = []  # (predictor, predictions, proposals)
         prev_pred_boxes = None
         image_sizes = [x.image_size for x in proposals]

detectron2/modeling/roi_heads/fast_rcnn.py

@@ -295,7 +295,7 @@ class FastRCNNOutputs(object):
 
     """
     A subclass is expected to have the following methods because
-    they are used to query information about the head predictions.0
+    they are used to query information about the head predictions.
     """
 
     def losses(self):
@@ -370,7 +370,7 @@ class FastRCNNOutputLayers(nn.Module):
             test_topk_per_image (int): number of top predictions to produce per image.
         """
         super().__init__()
-        if isinstance(input_shape, int):  # some backward compatbility
+        if isinstance(input_shape, int):  # some backward compatibility
             input_shape = ShapeSpec(channels=input_shape)
         input_size = input_shape.channels * (input_shape.width or 1) * (input_shape.height or 1)
         # The prediction layer for num_classes foreground classes and one background class

detectron2/modeling/roi_heads/roi_heads.py

 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+import inspect
 import logging
 import numpy as np
 from typing import Dict, List, Optional, Tuple, Union
@@ -476,38 +477,103 @@ class StandardROIHeads(ROIHeads):
     """
     It's "standard" in a sense that there is no ROI transform sharing
     or feature sharing between tasks.
-    The cropped rois go to separate branches (boxes and masks) directly.
-    This way, it is easier to make separate abstractions for different branches.
+    Each head independently processes the input features by each head's
+    own pooler and head.
 
     This class is used by most models, such as FPN and C5.
     To implement more models, you can subclass it and implement a different
     :meth:`forward()` or a head.
     """
 
-    def __init__(self, cfg, input_shape):
-        super().__init__(cfg)
-        self.in_features = cfg.MODEL.ROI_HEADS.IN_FEATURES
-        self._init_box_head(cfg, input_shape)
-        self._init_mask_head(cfg, input_shape)
-        self._init_keypoint_head(cfg, input_shape)
+    @configurable
+    def __init__(
+        self,
+        *,
+        box_in_features: List[str],
+        box_pooler: ROIPooler,
+        box_head: nn.Module,
+        box_predictor: nn.Module,
+        mask_in_features: Optional[List[str]] = None,
+        mask_pooler: Optional[ROIPooler] = None,
+        mask_head: Optional[nn.Module] = None,
+        keypoint_in_features: Optional[List[str]] = None,
+        keypoint_pooler: Optional[ROIPooler] = None,
+        keypoint_head: Optional[nn.Module] = None,
+        train_on_pred_boxes: bool = False,
+        **kwargs
+    ):
+        """
+        NOTE: this interface is experimental.
+
+        Args:
+            box_in_features (list[str]): list of feature names to use for the box head.
+            box_pooler (ROIPooler): pooler to extra region features for box head
+            box_head (nn.Module): transform features to make box predictions
+            box_predictor (nn.Module): make box predictions from the feature.
+                Should have the same interface as :class:`FastRCNNOutputLayers`.
+            mask_in_features (list[str]): list of feature names to use for the mask head.
+                None if not using mask head.
+            mask_pooler (ROIPooler): pooler to extra region features for mask head
+            mask_head (nn.Module): transform features to make mask predictions
+            keypoint_in_features, keypoint_pooler, keypoint_head: similar to ``mask*``.
+            train_on_pred_boxes (bool): whether to use proposal boxes or
+                predicted boxes from the box head to train other heads.
+        """
+        super().__init__(**kwargs)
+        # keep self.in_features for backward compatibility
+        self.in_features = self.box_in_features = box_in_features
+        self.box_pooler = box_pooler
+        self.box_head = box_head
+        self.box_predictor = box_predictor
+
+        self.mask_on = mask_in_features is not None
+        if self.mask_on:
+            self.mask_in_features = mask_in_features
+            self.mask_pooler = mask_pooler
+            self.mask_head = mask_head
+        self.keypoint_on = keypoint_in_features is not None
+        if self.keypoint_on:
+            self.keypoint_in_features = keypoint_in_features
+            self.keypoint_pooler = keypoint_pooler
+            self.keypoint_head = keypoint_head
 
-    def _init_box_head(self, cfg, input_shape):
+        self.train_on_pred_boxes = train_on_pred_boxes
+
+    @classmethod
+    def from_config(cls, cfg, input_shape):
+        ret = super().from_config(cfg)
+        ret["train_on_pred_boxes"] = cfg.MODEL.ROI_BOX_HEAD.TRAIN_ON_PRED_BOXES
+        # Subclasses that have not been updated to use from_config style construction
+        # may have overridden _init_*_head methods. In this case, those overridden methods
+        # will not be classmethods and we need to avoid trying to call them here.
+        # We test for this with ismethod which only returns True for bound methods of cls.
+        # Such subclasses will need to handle calling their overridden _init_*_head methods.
+        if inspect.ismethod(cls._init_box_head):
+            ret.update(cls._init_box_head(cfg, input_shape))
+        if inspect.ismethod(cls._init_mask_head):
+            ret.update(cls._init_mask_head(cfg, input_shape))
+        if inspect.ismethod(cls._init_keypoint_head):
+            ret.update(cls._init_keypoint_head(cfg, input_shape))
+        return ret
+
+    @classmethod
+    def _init_box_head(cls, cfg, input_shape):
         # fmt: off
-        pooler_resolution        = cfg.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION
-        pooler_scales            = tuple(1.0 / input_shape[k].stride for k in self.in_features)
-        sampling_ratio           = cfg.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO
-        pooler_type              = cfg.MODEL.ROI_BOX_HEAD.POOLER_TYPE
-        self.train_on_pred_boxes = cfg.MODEL.ROI_BOX_HEAD.TRAIN_ON_PRED_BOXES
+        in_features       = cfg.MODEL.ROI_HEADS.IN_FEATURES
+        pooler_resolution = cfg.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION
+        pooler_scales     = tuple(1.0 / input_shape[k].stride for k in in_features)
+        sampling_ratio    = cfg.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO
+        pooler_type       = cfg.MODEL.ROI_BOX_HEAD.POOLER_TYPE
         # fmt: on
 
         # If StandardROIHeads is applied on multiple feature maps (as in FPN),
         # then we share the same predictors and therefore the channel counts must be the same
-        in_channels = [input_shape[f].channels for f in self.in_features]
+        in_channels = [input_shape[f].channels for f in in_features]
         # Check all channel counts are equal
         assert len(set(in_channels)) == 1, in_channels
         in_channels = in_channels[0]
 
-        self.box_pooler = ROIPooler(
+        box_pooler = ROIPooler(
             output_size=pooler_resolution,
             scales=pooler_scales,
             sampling_ratio=sampling_ratio,
@@ -516,56 +582,68 @@ class StandardROIHeads(ROIHeads):
         # Here we split "box head" and "box predictor", which is mainly due to historical reasons.
         # They are used together so the "box predictor" layers should be part of the "box head".
         # New subclasses of ROIHeads do not need "box predictor"s.
-        self.box_head = build_box_head(
+        box_head = build_box_head(
             cfg, ShapeSpec(channels=in_channels, height=pooler_resolution, width=pooler_resolution)
         )
-        self.box_predictor = FastRCNNOutputLayers(cfg, self.box_head.output_shape)
+        box_predictor = FastRCNNOutputLayers(cfg, box_head.output_shape)
+        return {
+            "box_in_features": in_features,
+            "box_pooler": box_pooler,
+            "box_head": box_head,
+            "box_predictor": box_predictor,
+        }
 
-    def _init_mask_head(self, cfg, input_shape):
+    @classmethod
+    def _init_mask_head(cls, cfg, input_shape):
+        if not cfg.MODEL.MASK_ON:
+            return {}
         # fmt: off
-        self.mask_on           = cfg.MODEL.MASK_ON
-        if not self.mask_on:
-            return
+        in_features       = cfg.MODEL.ROI_HEADS.IN_FEATURES
         pooler_resolution = cfg.MODEL.ROI_MASK_HEAD.POOLER_RESOLUTION
-        pooler_scales     = tuple(1.0 / input_shape[k].stride for k in self.in_features)
+        pooler_scales     = tuple(1.0 / input_shape[k].stride for k in in_features)
         sampling_ratio    = cfg.MODEL.ROI_MASK_HEAD.POOLER_SAMPLING_RATIO
         pooler_type       = cfg.MODEL.ROI_MASK_HEAD.POOLER_TYPE
         # fmt: on
 
-        in_channels = [input_shape[f].channels for f in self.in_features][0]
+        in_channels = [input_shape[f].channels for f in in_features][0]
 
-        self.mask_pooler = ROIPooler(
+        ret = {"mask_in_features": in_features}
+        ret["mask_pooler"] = ROIPooler(
             output_size=pooler_resolution,
             scales=pooler_scales,
             sampling_ratio=sampling_ratio,
             pooler_type=pooler_type,
         )
-        self.mask_head = build_mask_head(
+        ret["mask_head"] = build_mask_head(
             cfg, ShapeSpec(channels=in_channels, width=pooler_resolution, height=pooler_resolution)
         )
+        return ret
 
-    def _init_keypoint_head(self, cfg, input_shape):
+    @classmethod
+    def _init_keypoint_head(cls, cfg, input_shape):
+        if not cfg.MODEL.KEYPOINT_ON:
+            return {}
         # fmt: off
-        self.keypoint_on  = cfg.MODEL.KEYPOINT_ON
-        if not self.keypoint_on:
-            return
+        in_features       = cfg.MODEL.ROI_HEADS.IN_FEATURES
         pooler_resolution = cfg.MODEL.ROI_KEYPOINT_HEAD.POOLER_RESOLUTION
-        pooler_scales     = tuple(1.0 / input_shape[k].stride for k in self.in_features)  # noqa
+        pooler_scales     = tuple(1.0 / input_shape[k].stride for k in in_features)  # noqa
         sampling_ratio    = cfg.MODEL.ROI_KEYPOINT_HEAD.POOLER_SAMPLING_RATIO
         pooler_type       = cfg.MODEL.ROI_KEYPOINT_HEAD.POOLER_TYPE
         # fmt: on
 
-        in_channels = [input_shape[f].channels for f in self.in_features][0]
+        in_channels = [input_shape[f].channels for f in in_features][0]
 
-        self.keypoint_pooler = ROIPooler(
+        ret = {"keypoint_in_features": in_features}
+        ret["keypoint_pooler"] = ROIPooler(
             output_size=pooler_resolution,
             scales=pooler_scales,
             sampling_ratio=sampling_ratio,
             pooler_type=pooler_type,
         )
-        self.keypoint_head = build_keypoint_head(
+        ret["keypoint_head"] = build_keypoint_head(
             cfg, ShapeSpec(channels=in_channels, width=pooler_resolution, height=pooler_resolution)
         )
+        return ret
 
     def forward(
         self,
@@ -644,7 +722,7 @@ class StandardROIHeads(ROIHeads):
             In training, a dict of losses.
             In inference, a list of `Instances`, the predicted instances.
         """
-        features = [features[f] for f in self.in_features]
+        features = [features[f] for f in self.box_in_features]
         box_features = self.box_pooler(features, [x.proposal_boxes for x in proposals])
         box_features = self.box_head(box_features)
         predictions = self.box_predictor(box_features)
@@ -685,7 +763,7 @@ class StandardROIHeads(ROIHeads):
         if not self.mask_on:
             return {} if self.training else instances
 
-        features = [features[f] for f in self.in_features]
+        features = [features[f] for f in self.mask_in_features]
 
         if self.training:
             # The loss is only defined on positive proposals.
@@ -718,10 +796,10 @@ class StandardROIHeads(ROIHeads):
         if not self.keypoint_on:
             return {} if self.training else instances
 
-        features = [features[f] for f in self.in_features]
+        features = [features[f] for f in self.keypoint_in_features]
 
         if self.training:
-            # The loss is defined on positive proposals with at >=1 visible keypoints.
+            # The loss is defined on positive proposals with >=1 visible keypoints.
             proposals, _ = select_foreground_proposals(instances, self.num_classes)
             proposals = select_proposals_with_visible_keypoints(proposals)
             proposal_boxes = [x.proposal_boxes for x in proposals]

detectron2/modeling/roi_heads/rotated_fast_rcnn.py

 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
 import logging
 import numpy as np
-from typing import Dict
 import torch
 
+from detectron2.config import configurable
 from detectron2.layers import ShapeSpec, batched_nms_rotated
 from detectron2.structures import Instances, RotatedBoxes, pairwise_iou_rotated
 from detectron2.utils.events import get_event_storage
@@ -133,7 +133,7 @@ def fast_rcnn_inference_single_image_rotated(
 
 class RotatedFastRCNNOutputLayers(FastRCNNOutputLayers):
     """
-    A class that stores information about outputs of a Fast R-CNN head with RotatedBoxes.
+    Two linear layers for predicting Rotated Fast R-CNN outputs.
     """
 
     @classmethod
@@ -167,46 +167,51 @@ class RotatedFastRCNNOutputLayers(FastRCNNOutputLayers):
 @ROI_HEADS_REGISTRY.register()
 class RROIHeads(StandardROIHeads):
     """
-    This class is used by Rotated RPN (RRPN).
-    For now, it just supports box head but not mask or keypoints.
+    This class is used by Rotated Fast R-CNN to detect rotated boxes.
+    For now, it only supports box predictions but not mask or keypoints.
     """
 
-    def __init__(self, cfg, input_shape: Dict[str, ShapeSpec]):
-        super().__init__(cfg, input_shape)
+    @configurable
+    def __init__(self, **kwargs):
+        """
+        NOTE: this interface is experimental.
+        """
+        super().__init__(**kwargs)
         assert (
             not self.mask_on and not self.keypoint_on
         ), "Mask/Keypoints not supported in Rotated ROIHeads."
+        assert not self.train_on_pred_boxes, "train_on_pred_boxes not implemented for RROIHeads!"
 
-    def _init_box_head(self, cfg, input_shape):
+    @classmethod
+    def _init_box_head(cls, cfg, input_shape):
         # fmt: off
-        pooler_resolution        = cfg.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION
-        pooler_scales            = tuple(1.0 / input_shape[k].stride for k in self.in_features)
-        sampling_ratio           = cfg.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO
-        pooler_type              = cfg.MODEL.ROI_BOX_HEAD.POOLER_TYPE
-        self.train_on_pred_boxes = cfg.MODEL.ROI_BOX_HEAD.TRAIN_ON_PRED_BOXES
+        in_features       = cfg.MODEL.ROI_HEADS.IN_FEATURES
+        pooler_resolution = cfg.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION
+        pooler_scales     = tuple(1.0 / input_shape[k].stride for k in in_features)
+        sampling_ratio    = cfg.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO
+        pooler_type       = cfg.MODEL.ROI_BOX_HEAD.POOLER_TYPE
         # fmt: on
-        assert not self.train_on_pred_boxes, "Not Implemented!"
+        assert pooler_type in ["ROIAlignRotated"], pooler_type
+        # assume all channel counts are equal
+        in_channels = [input_shape[f].channels for f in in_features][0]
 
-        # If StandardROIHeads is applied on multiple feature maps (as in FPN),
-        # then we share the same predictors and therefore the channel counts must be the same
-        in_channels = [input_shape[f].channels for f in self.in_features]
-        # Check all channel counts are equal
-        assert len(set(in_channels)) == 1, in_channels
-        in_channels = in_channels[0]
-
-        assert pooler_type in ["ROIAlignRotated"]
-
-        self.box_pooler = ROIPooler(
+        box_pooler = ROIPooler(
             output_size=pooler_resolution,
             scales=pooler_scales,
             sampling_ratio=sampling_ratio,
             pooler_type=pooler_type,
         )
-        self.box_head = build_box_head(
+        box_head = build_box_head(
             cfg, ShapeSpec(channels=in_channels, height=pooler_resolution, width=pooler_resolution)
         )
-
-        self.box_predictor = RotatedFastRCNNOutputLayers(cfg, self.box_head.output_shape)
+        # This line is the only difference v.s. StandardROIHeads
+        box_predictor = RotatedFastRCNNOutputLayers(cfg, box_head.output_shape)
+        return {
+            "box_in_features": in_features,
+            "box_pooler": box_pooler,
+            "box_head": box_head,
+            "box_predictor": box_predictor,
+        }
 
     @torch.no_grad()
     def label_and_sample_proposals(self, proposals, targets):

projects/PointRend/point_rend/roi_heads.py

@@ -57,6 +57,11 @@ class PointRendROIHeads(StandardROIHeads):
     variables that correspond to the mask head in the class's namespace.
     """
 
+    def __init__(self, cfg, input_shape):
+        # TODO use explicit args style
+        super().__init__(cfg, input_shape)
+        self._init_mask_head(cfg, input_shape)
+
     def _init_mask_head(self, cfg, input_shape):
         # fmt: off
         self.mask_on                 = cfg.MODEL.MASK_ON

setup.py

@@ -137,7 +137,7 @@ setup(
         "mock",
         "tqdm>4.29.0",
         "tensorboard",
-        "fvcore",
+        "fvcore>=1.1",
         "future",  # used by caffe2
         "pydot",  # used to save caffe2 SVGs
     ],