bug fix

app.py

@@ -36,6 +36,7 @@ def configure_runtime_environment() -> None:
     os.environ.setdefault("PYOPENGL_PLATFORM", "egl")
     os.environ.setdefault("MPLBACKEND", "Agg")
     os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+    os.environ.setdefault("TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD", "1")
 
 
 def configure_torch_cuda_arch_list() -> None:

egoforce_runtime_patches.py

@@ -30,6 +30,52 @@ def _torchvision_roi_pool_module():
     return RoIPool
 
 
+def _multiscale_deformable_attention_class():
+    import torch.nn as nn
+
+    class MultiScaleDeformableAttention(nn.Module):
+        """Import-only fallback for mmdet registries when running with mmcv-lite."""
+
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
+            super().__init__()
+
+        def init_weights(self) -> None:
+            return None
+
+        def forward(self, *args: Any, **kwargs: Any) -> Any:
+            raise RuntimeError(
+                "MultiScaleDeformableAttention requires full mmcv with compiled ops. "
+                "The EgoForce demo uses RTMDet and should not execute this layer."
+            )
+
+    return MultiScaleDeformableAttention
+
+
+def _unsupported_module_class(name: str):
+    import torch.nn as nn
+
+    class UnsupportedMMCVOp(nn.Module):
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
+            super().__init__()
+
+        def init_weights(self) -> None:
+            return None
+
+        def forward(self, *args: Any, **kwargs: Any) -> Any:
+            raise RuntimeError(f"{name} requires full mmcv with compiled ops and is not used by the EgoForce RTMDet demo.")
+
+    UnsupportedMMCVOp.__name__ = name
+    return UnsupportedMMCVOp
+
+
+def _unsupported_function(name: str):
+    def unsupported(*args: Any, **kwargs: Any) -> Any:
+        raise RuntimeError(f"{name} requires full mmcv with compiled ops and is not used by the EgoForce RTMDet demo.")
+
+    unsupported.__name__ = name
+    return unsupported
+
+
 def _bbox_overlaps(
     bboxes1: Any,
     bboxes2: Any,
@@ -162,6 +208,100 @@ def _batched_nms(
     return dets, keep
 
 
+def _nms_match(dets: Any, iou_threshold: float) -> list[Any]:
+    """Pure PyTorch fallback for mmcv.ops.nms_match import paths."""
+    import torch
+
+    if dets.numel() == 0:
+        return []
+
+    boxes = dets[:, :4]
+    scores = dets[:, 4]
+    order = scores.argsort(descending=True)
+    groups = []
+
+    while order.numel() > 0:
+        current = order[0]
+        if order.numel() == 1:
+            groups.append(current.reshape(1))
+            break
+
+        rest = order[1:]
+        lt = torch.maximum(boxes[current, :2], boxes[rest, :2])
+        rb = torch.minimum(boxes[current, 2:], boxes[rest, 2:])
+        wh = (rb - lt).clamp(min=0)
+        inter = wh[:, 0] * wh[:, 1]
+        current_area = (boxes[current, 2] - boxes[current, 0]).clamp(min=0) * (
+            boxes[current, 3] - boxes[current, 1]
+        ).clamp(min=0)
+        rest_area = (boxes[rest, 2] - boxes[rest, 0]).clamp(min=0) * (
+            boxes[rest, 3] - boxes[rest, 1]
+        ).clamp(min=0)
+        iou = inter / (current_area + rest_area - inter).clamp(min=1e-6)
+        matched = rest[iou > float(iou_threshold)]
+        groups.append(torch.cat((current.reshape(1), matched)))
+        order = rest[iou <= float(iou_threshold)]
+
+    return groups
+
+
+def _point_sample(input: Any, points: Any, align_corners: bool = False, **kwargs: Any) -> Any:
+    import torch.nn.functional as F
+
+    add_dim = False
+    if points.dim() == 3:
+        add_dim = True
+        points = points.unsqueeze(2)
+
+    output = F.grid_sample(input, points.mul(2).sub(1), align_corners=align_corners, **kwargs)
+    if add_dim:
+        output = output.squeeze(3)
+    return output
+
+
+def _rel_roi_point_to_rel_img_point(rois: Any, rel_roi_points: Any, img_shape: Any) -> Any:
+    x1, y1, x2, y2 = rois[:, 1], rois[:, 2], rois[:, 3], rois[:, 4]
+    roi_w = (x2 - x1).clamp(min=1)
+    roi_h = (y2 - y1).clamp(min=1)
+    img_h, img_w = img_shape[:2]
+    rel_img_points = rel_roi_points.clone()
+    rel_img_points[..., 0] = (x1[:, None] + rel_roi_points[..., 0] * roi_w[:, None]) / float(img_w)
+    rel_img_points[..., 1] = (y1[:, None] + rel_roi_points[..., 1] * roi_h[:, None]) / float(img_h)
+    return rel_img_points
+
+
+def _sigmoid_focal_loss(
+    pred: Any,
+    target: Any,
+    gamma: float = 2.0,
+    alpha: float = 0.25,
+    weight: Any = None,
+    reduction: str = "mean",
+) -> Any:
+    import torch.nn.functional as F
+
+    pred_sigmoid = pred.sigmoid()
+    target = target.type_as(pred)
+    pt = (1 - pred_sigmoid) * target + pred_sigmoid * (1 - target)
+    focal_weight = (alpha * target + (1 - alpha) * (1 - target)) * pt.pow(gamma)
+    loss = F.binary_cross_entropy_with_logits(pred, target, reduction="none") * focal_weight
+    if weight is not None:
+        loss = loss * weight
+    if reduction == "sum":
+        return loss.sum()
+    if reduction == "mean":
+        return loss.mean()
+    return loss
+
+
+def _ensure_module(module_name: str) -> types.ModuleType:
+    module = sys.modules.get(module_name)
+    if module is None:
+        module = types.ModuleType(module_name)
+        sys.modules[module_name] = module
+    return module
+
+
 def apply_runtime_patches() -> None:
     try:
         mmcv = importlib.import_module("mmcv")
@@ -174,26 +314,65 @@ def apply_runtime_patches() -> None:
         sys.modules["mmcv.ops"] = ops_module
     ops_module.__path__ = []
 
-    nms_module = sys.modules.get("mmcv.ops.nms")
-    if nms_module is None:
-        nms_module = types.ModuleType("mmcv.ops.nms")
-        sys.modules["mmcv.ops.nms"] = nms_module
-
-    roi_align_module = sys.modules.get("mmcv.ops.roi_align")
-    if roi_align_module is None:
-        roi_align_module = types.ModuleType("mmcv.ops.roi_align")
-        sys.modules["mmcv.ops.roi_align"] = roi_align_module
+    nms_module = _ensure_module("mmcv.ops.nms")
+
+    roi_align_module = _ensure_module("mmcv.ops.roi_align")
+    deform_conv_module = _ensure_module("mmcv.ops.deform_conv")
+    modulated_deform_conv_module = _ensure_module("mmcv.ops.modulated_deform_conv")
+    carafe_module = _ensure_module("mmcv.ops.carafe")
+    merge_cells_module = _ensure_module("mmcv.ops.merge_cells")
+    multi_scale_deform_attn_module = _ensure_module("mmcv.ops.multi_scale_deform_attn")
+
+    deform_conv2d = _unsupported_function("deform_conv2d")
+    DeformConv2d = _unsupported_module_class("DeformConv2d")
+    ModulatedDeformConv2d = _unsupported_module_class("ModulatedDeformConv2d")
+    MaskedConv2d = _unsupported_module_class("MaskedConv2d")
+    CornerPool = _unsupported_module_class("CornerPool")
+    CARAFEPack = _unsupported_module_class("CARAFEPack")
+    GlobalPoolingCell = _unsupported_module_class("GlobalPoolingCell")
+    SumCell = _unsupported_module_class("SumCell")
+    ConcatCell = _unsupported_module_class("ConcatCell")
+    MultiScaleDeformableAttention = _multiscale_deformable_attention_class()
 
     ops_module.nms = _nms
     ops_module.batched_nms = _batched_nms
+    ops_module.nms_match = _nms_match
+    ops_module.point_sample = _point_sample
+    ops_module.rel_roi_point_to_rel_img_point = _rel_roi_point_to_rel_img_point
+    ops_module.sigmoid_focal_loss = _sigmoid_focal_loss
     ops_module.bbox_overlaps = _bbox_overlaps
     ops_module.roi_align = _torchvision_roi_align()
     ops_module.RoIAlign = _torchvision_roi_align_module()
     ops_module.RoIPool = _torchvision_roi_pool_module()
+    ops_module.deform_conv2d = deform_conv2d
+    ops_module.DeformConv2d = DeformConv2d
+    ops_module.ModulatedDeformConv2d = ModulatedDeformConv2d
+    ops_module.MaskedConv2d = MaskedConv2d
+    ops_module.CornerPool = CornerPool
+    ops_module.CARAFEPack = CARAFEPack
+    ops_module.GlobalPoolingCell = GlobalPoolingCell
+    ops_module.SumCell = SumCell
+    ops_module.ConcatCell = ConcatCell
+    ops_module.MultiScaleDeformableAttention = MultiScaleDeformableAttention
     nms_module.nms = _nms
     nms_module.batched_nms = _batched_nms
     roi_align_module.roi_align = ops_module.roi_align
     roi_align_module.RoIAlign = ops_module.RoIAlign
+    deform_conv_module.deform_conv2d = deform_conv2d
+    deform_conv_module.DeformConv2d = DeformConv2d
+    modulated_deform_conv_module.ModulatedDeformConv2d = ModulatedDeformConv2d
+    carafe_module.CARAFEPack = CARAFEPack
+    merge_cells_module.GlobalPoolingCell = GlobalPoolingCell
+    merge_cells_module.SumCell = SumCell
+    merge_cells_module.ConcatCell = ConcatCell
+    multi_scale_deform_attn_module.MultiScaleDeformableAttention = MultiScaleDeformableAttention
+
+    try:
+        transformer_module = importlib.import_module("mmcv.cnn.bricks.transformer")
+        if not hasattr(transformer_module, "MultiScaleDeformableAttention"):
+            transformer_module.MultiScaleDeformableAttention = MultiScaleDeformableAttention
+    except ImportError:
+        pass
 
     if mmcv is not None:
         mmcv.ops = ops_module

requirements.txt

@@ -9,10 +9,14 @@ pytorch3d==0.7.9+pt2.8.0cu128
 opencv-python==4.11.0.86
 pillow==11.3.0
 matplotlib==3.10.6
+scipy==1.15.3
+shapely==2.1.2
 pyyaml==6.0.2
 easydict==1.13
 h5py==3.15.1
 tqdm==4.67.1
+six==1.17.0
+terminaltables==3.1.10
 aiofiles==24.1.0
 async-lru==2.0.5
 timm==1.0.20