prefusion 2.4.1__tar.gz

prefusion-2.4.1/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: prefusion
+Version: 2.4.1
+Summary: MMEngine-based core framework for Prefusion projects
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: cachetools
+Requires-Dist: copious>=0.1.23
+Requires-Dist: easydict==1.13
+Requires-Dist: loguru
+Requires-Dist: matplotlib
+Requires-Dist: mmengine<0.11,>=0.10.5
+Requires-Dist: mmdet<3.3,>=3.2.0
+Requires-Dist: mtv4d
+Requires-Dist: numba==0.60.0
+Requires-Dist: numpy==1.26.4
+Requires-Dist: nuscenes-devkit
+Requires-Dist: opencv-python-headless
+Requires-Dist: open3d==0.18.0
+Requires-Dist: pandas
+Requires-Dist: polars==1.28.1
+Requires-Dist: pydantic>=2
+Requires-Dist: pypcd-imp==0.1.5
+Requires-Dist: redis==5.2.0
+Requires-Dist: requests
+Requires-Dist: scipy==1.14.1
+Requires-Dist: shapely
+Requires-Dist: tabulate
+Requires-Dist: tensorboard==2.17.1
+Requires-Dist: torch==2.4.1
+Requires-Dist: torchvision==0.19.1
+Requires-Dist: tqdm
+Requires-Dist: virtual-camera>=0.0.4.3
+Provides-Extra: test
+Requires-Dist: pytest==8.3.3; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+
+# Prefusion
+
+`prefusion` is the MMEngine-based core framework shared by Prefusion task projects.
+
+Install the framework with:
+
+```bash
+pip install prefusion
+```
+
+Task-specific models and configurations live in the separately installable
+[`prefusion-contrib`](../prefusion-contrib) project. The public Python API is
+kept stable as `prefusion.*`.
+
+## Development validation
+
+```bash
+python -m pip wheel --no-deps --wheel-dir dist .
+python -m pytest tests
+```

prefusion-2.4.1/README.md

@@ -0,0 +1,20 @@
+# Prefusion
+
+`prefusion` is the MMEngine-based core framework shared by Prefusion task projects.
+
+Install the framework with:
+
+```bash
+pip install prefusion
+```
+
+Task-specific models and configurations live in the separately installable
+[`prefusion-contrib`](../prefusion-contrib) project. The public Python API is
+kept stable as `prefusion.*`.
+
+## Development validation
+
+```bash
+python -m pip wheel --no-deps --wheel-dir dist .
+python -m pytest tests
+```

prefusion-2.4.1/prefusion/__init__.py

@@ -0,0 +1,6 @@
+from .dataset import *
+from .hooks import *
+from .loss import *
+from .models import *
+from .runner import *
+from .utils import *

prefusion-2.4.1/prefusion/dataset/__init__.py

@@ -0,0 +1,12 @@
+from .dataset import *
+from .index_info import *
+from .model_feeder import *
+from .sampler import *
+from .sequence_sampler import *
+from .streaming_collate import *
+from .streaming_dataset import *
+from .streaming_sampler import *
+from .subepoch_manager import *
+from .tensor_smith import *
+from .transform import *
+from .transformable_loader import *

prefusion-2.4.1/prefusion/dataset/dataset.py

@@ -0,0 +1,334 @@
+# Written by AlphaLFC. All rights reserved.
+import copy
+import functools
+import logging
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional, Union
+
+from cachetools import Cache, cached
+from mmengine.logging import print_log
+from torch.utils.data import Dataset
+
+from prefusion.dataset.subepoch_manager import EndOfAllSubEpochs
+from prefusion.dataset.transform import (
+    Bbox3D,
+    CameraDepthSet,
+    CameraImageSet,
+    CameraSegMaskSet,
+    EgoPoseSet,
+    LidarPoints,
+    OccSdf3D,
+    OccSdfBev,
+    ParkingSlot3D,
+    Polygon3D,
+    Polyline3D,
+    SegBev,
+)
+from prefusion.dataset.transformable_loader import (
+    Bbox3DLoader,
+    CameraDepthSetLoader,
+    CameraImageSetLoader,
+    CameraSegMaskSetLoader,
+    EgoPoseSetLoader,
+    LidarPointsLoader,
+    OccSdf3DLoader,
+    OccSdfBevLoader,
+    ParkingSlot3DLoader,
+    Polygon3DLoader,
+    Polyline3DLoader,
+    SegBevLoader,
+    TransformableLoader,
+)
+from prefusion.registry import DATASETS, MMENGINE_FUNCTIONS, TENSOR_SMITHS
+
+from .utils import (
+    build_model_feeder,
+    build_sequence_sampler,
+    build_subepoch_manager,
+    build_tensor_smith,
+    build_transformable_loader,
+    build_transforms,
+    divide,
+    load_frame_info,
+    read_frame_pickle,
+)
+
+if TYPE_CHECKING:
+    from .index_info import IndexInfo
+    from .model_feeder import BaseModelFeeder
+    from .sequence_sampler import (
+        SequenceSampler,
+    )
+    from .subepoch_manager import SubEpochManager
+    from .tensor_smith import TensorSmith
+    from .transform import Transform, Transformable
+
+__all__ = ["SequenceBatchDataset"]
+
+
+@MMENGINE_FUNCTIONS.register_module()
+def collate_dict(batch):
+    return batch[0]
+
+
+SequenceBatch = list[list[dict]]
+
+_print_log = functools.partial(print_log, logger="current")
+
+
+@DATASETS.register_module()
+class SequenceBatchDataset(Dataset):
+    """
+    A novel dataset class for batching sequences for multi-module data.
+    """
+
+    # TODO: implement visualization?
+    DEFAULT_LOADERS = {
+        CameraImageSet.__name__: CameraImageSetLoader,
+        CameraDepthSet.__name__: CameraDepthSetLoader,
+        CameraSegMaskSet.__name__: CameraSegMaskSetLoader,
+        LidarPoints.__name__: LidarPointsLoader,
+        EgoPoseSet.__name__: EgoPoseSetLoader,
+        Bbox3D.__name__: Bbox3DLoader,
+        Polyline3D.__name__: Polyline3DLoader,
+        Polygon3D.__name__: Polygon3DLoader,
+        ParkingSlot3D.__name__: ParkingSlot3DLoader,
+        OccSdfBev.__name__: OccSdfBevLoader,
+        OccSdf3D.__name__: OccSdf3DLoader,
+        SegBev.__name__: SegBevLoader,
+    }
+
+    def __init__(
+        self,
+        name,
+        data_root: str | Path,
+        info_path: str | Path,
+        transformables: dict,
+        transforms: list[Union[dict, "Transform"]] = None,
+        model_feeder: Union["BaseModelFeeder", dict] = None,
+        subepoch_manager: Union["SubEpochManager", dict] = None,
+        sequence_sampler: Union["SequenceSampler", dict] = None,
+        batch_size: int = 1,
+        drop_last: bool = False,
+        sequence_backtime_prob: float = 0.0,
+        seed_dataset: int = None,
+    ):
+        """
+        Initializes the dataset instance.
+
+        Args:
+        - name (str): Name of the dataset.
+        - data_root (str): Root directory of the dataset.
+        - info_path (str): Path to the information file.
+        - transformables (dict): Dict of transformable definitions.
+        - transforms (list): Transform classes for preprocessing transformables. Build by TRANSFORMS.
+        - batch_size (int, optional): Batch size; defualt is 1.
+        - sequence_backtime_prob (float): Probability of sequencing backtime frames.
+        - subepoch_manager (SubEpochManager or dict): Only works for training. If set, only `num_sequence_batches_per_subepoch` will be trained in a epoch and the
+                                                      rest of data will be spit out in the next epoch.
+        - seed_dataset (int): Random seed for dataset
+
+        Notes:
+        - `scene`: a scene contains a sequence of frames
+        - `sequence`: a subset of a scene, when testing, a scene can be one sequence
+        - `frame`: a time instance of a scene
+        - one index should get a batch of sequences, one sequence should be a sequential list
+        - the length of the dataset should be len(self.sequences) // self.batch_size
+        - a frame data is a dictionary containing the transformed data.
+        """
+        super().__init__()
+        self.name = name
+        self.data_root = Path(data_root)
+        self.frame_info = load_frame_info(info_path)
+        self.transformables = transformables
+        self.transforms = build_transforms(transforms)
+        self.model_feeder = build_model_feeder(model_feeder)
+        self.sequence_sampler = build_sequence_sampler(sequence_sampler)
+        self.subepoch_manager = None
+        self.batch_size = batch_size
+        self.drop_last = drop_last
+        self.sequence_backtime_prob = sequence_backtime_prob
+        self.seed_dataset = seed_dataset
+
+        self._sample_sequences()
+
+        if type(self.sequence_sampler).__name__ in [
+            "ClassBalancedSequenceSampler",
+            "SceneLevelBalancedSequenceSampler",
+            "TrainIndexSequenceSampler",
+        ]:
+            self.subepoch_manager = build_subepoch_manager(subepoch_manager, batch_size)
+            if self.subepoch_manager is not None:
+                _print_log(
+                    "Since you have set SubEpochManager, "
+                    "you should consider set a larger max_epochs for your training.",
+                    level=logging.WARNING,
+                )
+                self.subepoch_manager.init(len(self.sequences))
+
+    def _sample_sequences(self):
+        self.sequences = self.sequence_sampler.sample(self.data_root, self.frame_info)
+        self.num_total_sequence_batches = divide(len(self.sequences), self.batch_size, drop_last=self.drop_last)
+
+    @property
+    def sequence_length(self):
+        return self.sequence_sampler.sequence_length
+
+    def __repr__(self):
+        return "".join(
+            [
+                f"An instance of {self.__class__}: (\n",
+                f"    name={self.name}, \n",
+                f"    num_sequences={len(self.sequences)}, \n"
+                f"    batch_size={self.batch_size}, \n"
+                f"    sequence_length={self.sequence_sampler.possible_sequence_lengths}, \n"
+                f"    frame_interval={self.sequence_sampler.possible_frame_intervals}, \n"
+                f"    sequence_backtime_prob={self.sequence_backtime_prob}\n)",
+            ]
+        )
+
+    def load_all_transformables(self, index_info: "IndexInfo") -> dict:
+        transformables = {}
+        frame_data = read_frame_pickle(self.data_root / self.frame_info[index_info.scene_frame_id])
+        for name in self.transformables:
+            _t_cfg = self.transformables[name]
+            loader_cfg = _t_cfg["loader"] if "loader" in _t_cfg else None
+            if not loader_cfg:
+                loader_cfg = self._get_default_loader_cfg(_t_cfg["type"])
+            loader_cfg.update(data_root=self.data_root)
+            tensor_smith_cfg = _t_cfg["tensor_smith"] if "tensor_smith" in _t_cfg else None
+            loader = self._build_transformable_loader(loader_cfg)
+            tensor_smith = build_tensor_smith(tensor_smith_cfg) if "tensor_smith" in _t_cfg else None
+            rest_kwargs = {k: v for k, v in _t_cfg.items() if k not in ["type", "loader", "tensor_smith"]}
+            transformables[name] = self._build_transformable(
+                name,
+                frame_data,
+                index_info,
+                loader,
+                tensor_smith=tensor_smith,
+                **rest_kwargs,
+            )
+
+        return transformables
+
+    @cached(
+        cache=Cache(maxsize=float("inf")),
+        key=lambda self_, cfg: str(sorted((cfg or {}).items())),
+    )
+    def _build_transformable_loader(self, loader_cfg: dict) -> TransformableLoader:
+        loader = build_transformable_loader(loader_cfg)
+        return loader
+
+    def _get_default_loader_cfg(self, transformable_type: str) -> dict:
+        if transformable_type not in self.DEFAULT_LOADERS:
+            raise ValueError(
+                f"No default transformable loader for transformable type: {transformable_type}. Please provide one explicitly."
+            )
+        return {
+            "type": self.DEFAULT_LOADERS[transformable_type],
+            "data_root": self.data_root,
+        }
+
+    @staticmethod
+    def _build_tensor_smith(tensor_smith: dict = None):
+        tensor_smith = copy.deepcopy(tensor_smith)
+        if isinstance(tensor_smith, dict):
+            tensor_smith = TENSOR_SMITHS.build(tensor_smith)
+        return tensor_smith
+
+    def __len__(self):
+        if self.subepoch_manager is None:
+            return self.num_total_sequence_batches
+        return self.subepoch_manager.num_sequence_batches_per_subepoch
+
+    @staticmethod
+    def _batch_sequences(sequence_batch_ind, sequences, batch_size):
+        batched_sequences = []
+        for batch_idx in range(batch_size):
+            sequence_idx = sequence_batch_ind * batch_size + batch_idx
+            if sequence_idx >= len(sequences):
+                sequence_idx = max(0, 2 * (len(sequences) - 1) - sequence_idx)
+            batched_sequences.append(sequences[sequence_idx])
+        return batched_sequences
+
+    def post_epoch_processing(self):
+        if self.subepoch_manager is None:  # training on the normal epoch settings
+            self._sample_sequences()
+            return
+
+        try:  # training on sub-epochs
+            self.subepoch_manager.to_next_sub_epoch()
+        except EndOfAllSubEpochs:
+            # from mmengine.dist import get_dist_info
+            # from loguru import logger
+            # rank, _ = get_dist_info()
+            # logger.debug(f"[rank{rank}] id={id(self.subepoch_manager)}")
+            # logger.debug(f"[rank{rank}] drop_last_sequence_batch={self.subepoch_manager.drop_last_sequence_batch}")
+            # logger.debug(f"[rank{rank}] drop_last_subepoch={self.subepoch_manager.drop_last_subepoch}")
+            # logger.debug(f"[rank{rank}] num_total_sequences={self.subepoch_manager.num_total_sequences}")
+            # logger.debug(f"[rank{rank}] num_total_sequence_batches={self.subepoch_manager.num_total_sequence_batches}")
+            # logger.debug(f"[rank{rank}] num_sequence_batches_per_subepoch={self.subepoch_manager.num_sequence_batches_per_subepoch}")
+            # logger.debug(f"[rank{rank}] batch_size={self.subepoch_manager.batch_size}")
+            # logger.debug(f"[rank{rank}] num_subepochs={self.subepoch_manager.num_subepochs}")
+            # logger.debug(f"[rank{rank}] id(visited)={id(self.subepoch_manager.visited)}")
+            # logger.debug(f"[rank{rank}] visited={self.subepoch_manager.visited.todict().keys()}")
+
+            self._sample_sequences()
+            self.subepoch_manager.reset(len(self.sequences))
+
+    def __getitem__(self, idx) -> SequenceBatch:
+        if self.subepoch_manager is not None:
+            idx = self.subepoch_manager.translate_index(idx)
+
+        batched_sequences = self._batch_sequences(idx, self.sequences, self.batch_size)
+
+        batch = []
+        sequence_batch_seed = int.from_bytes(os.urandom(2), byteorder="big")
+        for sequence in batched_sequences:
+            sequence_of_inputs = []
+            sequence_seed = int.from_bytes(os.urandom(2), byteorder="big")
+            for i, index_info in enumerate(sequence):
+                frame_seed = int.from_bytes(os.urandom(2), byteorder="big")
+                transformables = self.load_all_transformables(index_info)
+                for transform in self.transforms:
+                    transform(
+                        *transformables.values(),
+                        seeds={
+                            "sequence": sequence_seed,
+                            "sequence_batch": sequence_batch_seed,
+                            "frame": frame_seed,
+                        },
+                    )
+                input_dict = {
+                    "index_info": index_info,
+                    "transformables": transformables,
+                }
+                sequence_of_inputs.append(input_dict)
+            batch.append(sequence_of_inputs)
+
+        sequence_batch = []
+        for frame_batch in zip(*batch):
+            sequence_batch.append(frame_batch)
+
+        model_food = self.model_feeder(sequence_batch)
+
+        return model_food
+
+    def _build_transformable(
+        self,
+        name: str,
+        frame_data: dict[str, dict],
+        index_info: "IndexInfo",
+        loader: "TransformableLoader",
+        tensor_smith: Optional["TensorSmith"] = None,
+        **kwargs,
+    ) -> "Transformable":
+        return loader.load(
+            name,
+            self.frame_info,
+            frame_data,
+            index_info,
+            tensor_smith=tensor_smith,
+            **kwargs,
+        )

prefusion-2.4.1/prefusion/dataset/index_info.py

@@ -0,0 +1,163 @@
+import copy
+from typing import Optional, Union
+
+__all__ = ["IndexInfo"]
+
+
+class IndexInfo:
+    def __init__(
+        self,
+        scene_id: str,
+        frame_id: str,
+        s_prev: Optional["IndexInfo"] = None,
+        s_next: Optional["IndexInfo"] = None,
+        q_prev: Optional["IndexInfo"] = None,
+        q_next: Optional["IndexInfo"] = None,
+    ):
+        """Object that stores scene_id and frame_id as well as the adjacent linking relationships.
+
+        Parameters
+        ----------
+        scene_id : str
+            scene id
+        frame_id : str
+            frame id
+        s_prev : IndexInfo, optional
+            previous index_info within the same scene, by default None
+        s_next : IndexInfo, optional
+            next index_info within the same scene, by default None
+        q_prev : IndexInfo, optional
+            previous index_info within the same sequence, by default None
+        q_next : IndexInfo, optional
+            next index_info within the same sequence, by default None
+        """
+        self.scene_id = scene_id
+        self.frame_id = frame_id
+        self.s_prev = s_prev
+        self.s_next = s_next
+        self.q_prev = q_prev
+        self.q_next = q_next
+        if s_prev:
+            s_prev.s_next = self
+        if s_next:
+            s_next.s_prev = self
+        if q_prev:
+            q_prev.q_next = self
+        if q_next:
+            q_next.q_prev = self
+
+    @property
+    def prev(self) -> Union["IndexInfo", None]:
+        return self.q_prev or self.s_prev
+
+    @property
+    def next(self) -> Union["IndexInfo", None]:
+        return self.q_next or self.s_next
+
+    def __repr__(self) -> str:
+        return f"{self.scene_id}/{self.frame_id} (prev: {self.prev.scene_frame_id if self.prev else None}, next: {self.next.scene_frame_id if self.next else None})"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, IndexInfo):
+            return False
+        if not self.two_index_info_are_equal(self.s_prev, other.s_prev):
+            return False
+        if not self.two_index_info_are_equal(self.s_next, other.s_next):
+            return False
+        if not self.two_index_info_are_equal(self.q_prev, other.q_prev):
+            return False
+        if not self.two_index_info_are_equal(self.q_next, other.q_next):
+            return False
+        if self.scene_frame_id != other.scene_frame_id:
+            return False
+
+        return True
+
+    @staticmethod
+    def two_index_info_are_equal(a_index_info, another_index_info):
+        if (a_index_info is None) ^ (another_index_info is None):
+            return False
+        if (
+            a_index_info is not None
+            and another_index_info is not None
+            and a_index_info.scene_frame_id != another_index_info.scene_frame_id
+        ):
+            return False
+        return True
+
+    @property
+    def scene_frame_id(self) -> str:
+        return f"{self.scene_id}/{self.frame_id}"
+
+    def as_dict(self) -> dict:
+        return {
+            "scene_id": self.scene_id,
+            "frame_id": self.frame_id,
+            "s_prev": {"scene_id": self.s_prev.scene_id, "frame_id": self.s_prev.frame_id} if self.s_prev else None,
+            "s_next": {"scene_id": self.s_next.scene_id, "frame_id": self.s_next.frame_id} if self.s_next else None,
+            "q_prev": {"scene_id": self.q_prev.scene_id, "frame_id": self.q_prev.frame_id} if self.q_prev else None,
+            "q_next": {"scene_id": self.q_next.scene_id, "frame_id": self.q_next.frame_id} if self.q_next else None,
+        }
+
+    @classmethod
+    def from_str(
+        cls,
+        index_str: str,
+        s_prev: Optional["IndexInfo"] = None,
+        s_next: Optional["IndexInfo"] = None,
+        q_prev: Optional["IndexInfo"] = None,
+        q_next: Optional["IndexInfo"] = None,
+        sep: str = "/",
+    ):
+        """Create IndexInfo instance from index string.
+
+        Parameters
+        ----------
+        index_str : str
+            expected format: `scene_id/frame_id`
+        s_prev : IndexInfo, optional
+            previous index_info within the same scene, by default None
+        s_next : IndexInfo, optional
+            next index_info within the same scene, by default None
+        q_prev : IndexInfo, optional
+            previous index_info within the same sequence, by default None
+        q_next : IndexInfo, optional
+            next index_info within the same sequence, by default None
+        sep : str, optional
+            separator, by default "/"
+        """
+        scene_id, frame_id = index_str.split(sep)
+        return IndexInfo(scene_id, frame_id, s_prev=s_prev, s_next=s_next, q_prev=q_prev, q_next=q_next)
+
+
+def establish_linkings(index_info_list: list["IndexInfo"], sequence_linking=False) -> list["IndexInfo"]:
+    """Establish doubly-linked list relationships between IndexInfo objects.
+
+    Callers (e.g., sequence samplers using generate_sequences) may pass the same
+    IndexInfo object multiple times in a single list—for instance, when padding
+    short scenes to a fixed sequence length repeats boundary frame indices. To
+    prevent corrupting existing links with self-loops, duplicates are cloned via
+    copy.copy(), preserving scene-level links (s_prev/s_next) while giving each
+    position in the sequence its own independent sequence-level links.
+    """
+    attr_prev = "q_prev" if sequence_linking else "s_prev"
+    attr_next = "q_next" if sequence_linking else "s_next"
+    prev = None
+    seen_ids = set()
+    for i in range(len(index_info_list)):
+        cur = index_info_list[i]
+        if id(cur) in seen_ids:
+            cur = copy.copy(cur)
+            setattr(cur, attr_prev, None)
+            setattr(cur, attr_next, None)
+            index_info_list[i] = cur
+        seen_ids.add(id(cur))
+        setattr(cur, attr_prev, prev)
+        if prev is not None:
+            setattr(prev, attr_next, cur)
+        prev = cur
+    return index_info_list
+
+
+def establish_sequence_linkings(index_info_list: list["IndexInfo"]) -> list["IndexInfo"]:
+    return establish_linkings(index_info_list, sequence_linking=True)

prefusion-2.4.1/prefusion/dataset/model_feeder.py

@@ -0,0 +1,43 @@
+from prefusion.registry import MODEL_FEEDERS
+
+__all__ = ["BaseModelFeeder"]
+
+
+@MODEL_FEEDERS.register_module()
+class BaseModelFeeder:
+    """BaseModelFeeder.
+
+    An alternative implementation of data_preprocessor.
+
+    Args
+    ----
+    Any: Any parameter or keyword arguments.
+
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        pass
+
+    def process(self, frame_batch: list) -> dict | list:
+        """
+        Process frame_batch, make it ready for model inputs
+
+        Parameters
+        ----------
+        frame_batch : list
+            list of input_dicts
+
+        Returns
+        -------
+        processed_frame_batch: dict | list
+        }
+        """
+        processed_frame_batch = frame_batch
+        return processed_frame_batch
+
+    def __call__(self, sequence_batch: list):
+        processed_sequence_batch = []
+        for frame_batch in sequence_batch:
+            processed_sequence_batch.append(self.process(frame_batch))
+
+        return processed_sequence_batch

prefusion-2.4.1/prefusion/dataset/sampler.py

@@ -0,0 +1,40 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import torch
+from mmdet.models.task_modules.samplers import BaseSampler, SamplingResult
+
+from prefusion.registry import DATA_SAMPLERS
+
+__all__ = ["PseudoSampler"]
+
+
+@DATA_SAMPLERS.register_module()
+class PseudoSampler(BaseSampler):
+    """A pseudo sampler that does not do sampling actually."""
+
+    def __init__(self, **kwargs):
+        pass
+
+    def _sample_pos(self, **kwargs):
+        """Sample positive samples."""
+        raise NotImplementedError
+
+    def _sample_neg(self, **kwargs):
+        """Sample negative samples."""
+        raise NotImplementedError
+
+    def sample(self, assign_result, bboxes, gt_bboxes, *args, **kwargs):
+        """Directly returns the positive and negative indices  of samples.
+
+        Args:
+            assign_result (:obj:`AssignResult`): Assigned results
+            bboxes (torch.Tensor): Bounding boxes
+            gt_bboxes (torch.Tensor): Ground truth boxes
+
+        Returns:
+            :obj:`SamplingResult`: sampler results
+        """
+        pos_inds = torch.nonzero(assign_result.gt_inds > 0, as_tuple=False).squeeze(-1).unique()
+        neg_inds = torch.nonzero(assign_result.gt_inds == 0, as_tuple=False).squeeze(-1).unique()
+        gt_flags = bboxes.new_zeros(bboxes.shape[0], dtype=torch.uint8)
+        sampling_result = SamplingResult(pos_inds, neg_inds, bboxes, gt_bboxes, assign_result, gt_flags)
+        return sampling_result