facebookresearch/detectron2

This system is a computer vision library for object detection, instance segmentation, and panoptic segmentation, built on PyTorch. It provides a comprehensive framework for training and evaluating models using various backbones, including ResNet, RegNet, and Vision Transformers. The system supports deployment via TorchScript, ONNX, and Caffe2, and includes specialized projects for dense pose estimation and point-supervised segmentation.

46 changes.

This period centered on the Detectron2 v0.6 release, introducing AMD ROCm compatibility, PyTorch 1.8+ support, and a new LazyConfig system for programmatic model construction. It expanded the framework with support for Vision Transformers, panoptic segmentation, and new projects like TensorMask, while refactoring core components for TorchScript and improving data loading performance.

31 changes.

This period focused on significantly expanding the DensePose project with CSE support, HRNet backbones, and modular infrastructure, while introducing new project modules for PointRend, DeepLab, and Panoptic-DeepLab. The work also established robust deployment capabilities through new export tools and C++ examples, alongside comprehensive unit testing and automated wheel packaging to improve stability and distribution.

15 changes.

This period focused on standardizing training configurations through the introduction of common definitions and the LazyConfig system, while expanding support for diverse architectures including Vision Transformers, FCOS, and RetinaNet. It also introduced new capabilities for multi-object tracking, point-supervised instance segmentation, and experimental BatchNorm variants, alongside significant improvements to evaluation metrics and test coverage.

Introduces a new C++ source file (cocoeval.cpp) and header (cocoeval.h) that implement the core COCO evaluation algorithms (sorting, matching, and accumulation) previously handled in Python. This change provides a native C++ backend for the COCOeval module, which is expected to improve performance and reduce overhead for object detection evaluation metrics.

detectron2/layers/csrc/cocoeval · high confidence

The C++ extension now includes a new \cuda\_version.cu\ module to detect and report the runtime CUDA or HIP version, exposing \get\_cuda\_version\ and \has\_cuda\ functions to Python for environment verification. Additionally, the module exposes internal COCO evaluation methods (\COCOevalAccumulate\, \COCOevalEvaluateImages\) and the \InstanceAnnotation\ and \ImageEvaluation\ classes, enabling users to access low-level COCO evaluation logic directly from Python.

detectron2/layers/csrc · high confidence

Introduces a new DeepLab module for Detectron2, providing DeepLabV3 and DeepLabV3+ semantic segmentation heads with support for hard pixel mining loss, a configurable Poly learning rate scheduler, and a DeepLab-specific ResNet stem. The implementation includes a custom ResNet backbone builder that supports dilation settings and multi-grid strategies, along with configuration options for ASPP dilations, depthwise separable convolutions, and input cropping.

projects/DeepLab/deeplab · high confidence

This change introduces configuration files and a README for MViTv2 (Improved Multiscale Vision Transformers) within Detectron2, enabling users to run Cascade Mask R-CNN and Mask R-CNN detection pipelines using MViTv2 backbones. The provided configs cover various model scales (Tiny, Small, Base, Large, Huge) with pre-trained weights from ImageNet-1K and ImageNet-21K, including support for Large Scale Jittering (LSJ) data augmentation and specific training schedules.

projects/MViTv2 · high confidence

Introduces a new Panoptic-DeepLab module for Detectron2, enabling users to perform panoptic segmentation (combining semantic and instance segmentation) on datasets like COCO. This includes the \PanopticDeepLab\ model architecture, a dedicated dataset mapper for handling panoptic labels, target generation for training (center heatmaps and offsets), and post-processing logic to merge semantic and instance predictions into final panoptic results.

_projects/Panoptic-DeepLab/panoptic\deeplab · high confidence

This change introduces the PointRend project module, enabling high-resolution mask prediction through iterative point-based refinement for both instance and semantic segmentation tasks. It adds new model components including \PointRendMaskHead\ and \PointRendSemSegHead\, which utilize uncertainty-based sampling to refine coarse predictions at specific points. The module also includes support for Implicit PointRend, a color augmentation strategy adapted from SSD, and provides the necessary configuration defaults and ROI head integration to use these models within Detectron2.

_projects/PointRend/point\rend · high confidence

Users can now use the new SwapAlign2Nat layer, which implements the operation described in the TensorMask paper (arxiv.org/abs/1903.12174). This layer transforms mask representations from aligned to natural format by swapping unit lengths, supporting both forward and backward passes via custom CUDA kernels for GPU acceleration.

projects/TensorMask/tensormask/layers · high confidence

Introduces TensorMask, a dense sliding-window instance segmentation framework, as a new project within Detectron2. This addition includes the necessary Python package setup (setup.py), a custom training and evaluation script (train\_net.py) that integrates with Detectron2's default trainer, and documentation (README.md) detailing installation, training, and evaluation procedures. The project also provides pre-trained models for ResNet-50 backbones with 1x and 6x learning rate schedules.

projects/TensorMask · high confidence

Introduces the TensorMask architecture for instance segmentation, including the core model implementation, configuration defaults, and necessary utility functions for anchor assignment and mask post-processing within the Detectron2 framework.

projects/TensorMask/tensormask · high confidence

Introduces a new packaging infrastructure in dev/packaging to build and distribute pre-built binary wheels for various combinations of PyTorch (1.8, 1.9, 1.10), CUDA (9.2, 10.0–11.3), and Python (3.7–3.9). The addition includes build scripts (build\_wheel.sh, build\_all\_wheels.sh) that utilize Docker containers for reproducible builds, a helper script (gen\_wheel\_index.sh) to generate HTML indexes for the wheel repositories, and a Python utility (gen\_install\_table.py) to generate installation command tables for documentation. A README.md is also added to guide users and maintainers through the wheel building process.

dev/packaging · high confidence

New shared configuration files are introduced in the \configs/common\ directory to standardize training setups. These include \coco\_schedule.py\ for defining multi-step learning rate schedulers (1x, 2x, 3x, 6x, 9x), \optim.py\ for default SGD and AdamW optimizer settings, and \train.py\ for common training parameters such as output directories, checkpointing, and distributed data parallel options. A README explains that these definitions use lazy instantiation, allowing users to import them or load them via the \model\_zoo.get\_config\ API to customize their own training configurations.

configs/common · high confidence

This change introduces a new project directory containing configuration files and scripts to reproduce detection experiments from the 'Rethinking Batch in BatchNorm' paper. It adds Mask R-CNN configs that enable BatchNorm in the head, including variants using batch statistics during inference, cross-GPU shuffling of head inputs, and SyncBatchNorm. For RetinaNet, it provides configs for SyncBatchNorm in the head, including a shared-training variant that normalizes across all five feature levels, along with a separate evaluation script to apply domain-specific BatchNorm statistics post-training.

projects/Rethinking-BatchNorm · high confidence

Introduces a new point-supervised training mode for instance segmentation in Detectron2. This includes a \PointSupDatasetMapper\ to handle point annotation data and augmentations, custom mask heads (\MaskRCNNConvUpsamplePointSupHead\ and \ImplicitPointRendPointSupHead\) that compute loss using point coordinates and labels instead of full masks, and utilities to register COCO datasets containing point annotations.

_projects/PointSup/point\sup · high confidence

New configuration files have been added for the FCOS, RetinaNet, and Keypoint R-CNN models, enabling users to train these specific architectures on the COCO dataset. The FCOS and RetinaNet configs are set up for standard object detection with instance masks disabled and a learning rate of 0.01, while the Keypoint R-CNN config is tailored for keypoint detection tasks. All new configs utilize a ResNet-50 backbone with ImageNet pre-trained weights.

configs/COCO-Detection · high confidence

A new \ImageResizeTransform\ component has been introduced in the \densepose/data/transform\ module to standardize image preprocessing for DensePose training. This transform automatically resizes input images (BGR uint8 in NCHW format) to a target scale defined by configurable minimum and maximum sizes (defaulting to 800 and 1333 pixels) while preserving the original aspect ratio. It also converts the image data type from uint8 to float32, ensuring the input is in the correct format for model consumption.

projects/DensePose/densepose/data/transform · high confidence

The DensePose predictor logic has been reorganized into individual modules within the \densepose/modeling/predictors\ package, introducing a dedicated registry (\DENSEPOSE\_PREDICTOR\_REGISTRY\) for predictor classes. This change adds new predictor implementations for both chart-based and Continuous Surface Embedding (CSE) modes, including specific variants that estimate confidence scores for segmentation and UV coordinates (e.g., \DensePoseChartWithConfidencePredictor\, \DensePoseEmbeddingWithConfidencePredictor\). Users can now leverage these predictors to obtain uncertainty estimates alongside dense pose predictions, with the underlying architecture supporting configurable confidence models for both coarse/fine segmentation and intrinsic coordinates.

projects/DensePose/densepose/modeling/predictors · high confidence

The \densepose.structures\ module has been expanded to support confidence-aware outputs and efficient result serialization. Predictor outputs for both chart-based and CSE (Continuous Surface Embedding) models can now be decorated with confidence metrics, including sigma, kappa, and segmentation confidence tensors, allowing users to assess prediction uncertainty. Additionally, new result classes enable the quantization and PNG-based compression of DensePose chart results into compact Base64-encoded strings, facilitating storage and transmission without significant loss of detail.

projects/DensePose/densepose/structures · high confidence

The \configs/Misc\ directory now includes several new configuration files for advanced training scenarios and interoperability. Users can now train Mask R-CNN models using SyncBN normalization (\mask\_rcnn\_R\_50\_FPN\_3x\_syncbn.yaml\) and Deformable Convolution v2 (\mask\_rcnn\_R\_50\_FPN\_3x\_dconv\_c3-c5.yaml\). Additionally, new examples demonstrate training from scratch with Group Normalization and SyncBN (\scratch\_mask\_rcnn\_R\_50\_FPN\_9x\_gn.yaml\, \scratch\_mask\_rcnn\_R\_50\_FPN\_9x\_syncbn.yaml\), integrating MMDetection models via \MMDetDetector\ (\mmdet\_mask\_rcnn\_R\_50\_FPN\_1x.py\), and using torchvision models for ImageNet classification (\torchvision\_imagenet\_R\_50.py\). Several existing configs were also reorganized into this directory for better structure.

configs/Misc · high confidence

This change adds a new project module for DeepLab, providing training and evaluation scripts for DeepLabV3 and DeepLabV3+ semantic segmentation models. Users can now train these models on the Cityscapes dataset using the provided configuration files and training script, with support for multi-GPU and multi-machine setups. The entry includes pre-trained model weights and metrics for both DeepLabV3 (R103 backbone) and DeepLabV3+ (R103 backbone), enabling users to reproduce the reported mIoU scores of 78.5 and 80.0 respectively.

projects/DeepLab · high confidence

DensePose now includes a dedicated mesh catalog system that registers predefined 3D meshes (such as SMPL, chimpanzee, cat, and various animals) along with their associated geodesic distances, symmetry maps, and new texture coordinates. This change adds the \texcoords\ attribute to mesh definitions, enabling texture mapping capabilities for these models, and provides a centralized registry for managing mesh data paths and IDs.

projects/DensePose/densepose/data/meshes · high confidence

Adds the core implementation for Category-Specific Embeddings (CSE) in DensePose, including the \Embedder\ container, \VertexDirectEmbedder\, and \VertexFeatureEmbedder\ classes to manage vertex embedding spaces. It also introduces utility functions in \utils.py\ for computing squared Euclidean distance matrices, normalizing embeddings, and finding closest vertices, which are required for the CSE inference pipeline.

projects/DensePose/densepose/modeling/cse · high confidence

The DensePose module now includes a new \converters\ package that provides a generic, registry-based framework for transforming predictor outputs into user-friendly result structures. This change adds specific converters to flip chart outputs horizontally (correcting UV and segmentation semantics), convert chart predictor outputs to \DensePoseChartResult\ (with an option to include confidence metrics), and convert segmentation outputs to \BitMasks\. A base \BaseConverter\ class enables type-based registration and recursive lookup, allowing different predictor output types to be handled uniformly.

projects/DensePose/densepose/converters · high confidence

Detectron2 introduces a new configuration system (LazyConfig) that allows models to be defined and instantiated lazily using Python code instead of static YAML files. This change adds the \LazyCall\ and \LazyConfig\ classes to manage deferred object construction, and the \@configurable\ decorator which enables model components to be initialized directly from configuration objects via \from\_config\ methods. A new \instantiate\ utility is provided to recursively build these object graphs from configuration dictionaries. This shift allows for more flexible, programmatic configuration and easier integration with other tools, while the legacy \CfgNode\-based YAML system remains supported for backward compatibility.

detectron2/config · high confidence

The \detectron2.projects\ package now supports importing specific project modules (PointRend, DeepLab, Panoptic-DeepLab) directly via the \detectron2.projects\ namespace. This is achieved by registering a custom meta-path finder that dynamically resolves these imports to the corresponding directories in the repository's \projects\ folder, enabling in-place installation workflows where standard package directory structures do not apply.

detectron2/projects · high confidence

This update introduces new Atrous Spatial Pyramid Pooling (ASPP) and DepthwiseSeparableConv2d building blocks, along with DIoU and CIoU bounding-box regression losses. It significantly improves compatibility with TorchScript and ONNX export by making mask pasting, NMS, and ROIAlign operations scriptable or traceable, and allows boxes to be passed as tensors to paste\_masks\_in\_image. CPU inference for deformable convolutions is now supported via torchvision, and FrozenBatchNorm2d uses F.batch\_norm for better optimization when gradients are not needed. Additionally, SyncBatchNorm defaults to the official PyTorch implementation for newer versions, and ShapeSpec is converted to a dataclass.

detectron2/layers · high confidence

Added a new C++ example (\torchscript\_mask\_rcnn\) and accompanying build configuration (\CMakeLists.txt\) in \tools/deploy\ that demonstrates how to run inference with a TorchScript Mask R-CNN model. The example supports models exported via tracing, caffe2\_tracing, and scripting methods, handling the specific input/output formats required by each export strategy. This is paired with an updated \export\_model.py\ script that allows exporting detectron2 models to TorchScript, ONNX, or Caffe2 formats using these methods.

tools/deploy · high confidence

The DensePose module now includes a new \samplers\ package that converts model predictions into ground-truth-style annotations for training and evaluation. This adds base and confidence-based samplers for both standard DensePose (chart-based) and CSE (Category-Specific Embeddings) models, allowing users to sample points uniformly or by confidence scores. It also introduces utilities to generate segmentation masks from DensePose predictions and a generic sampler to map prediction fields (boxes, classes) to ground-truth fields.

projects/DensePose/densepose/data/samplers · high confidence

Added Dockerfiles and a docker-compose configuration to run Detectron2 in a containerized environment. The base image uses Ubuntu 18.04 with CUDA 11.1 and PyTorch 1.10, creating a non-root user for security. It includes instructions and a separate Dockerfile for building C++ deployment examples, along with a docker-compose file that configures GPU access and shared memory settings for easier local development and testing.

docker · high confidence

Detectron2 now includes the FCOS (Fully Convolutional One-Stage) object detector, a new dense detector that predicts bounding boxes directly from feature map points without anchor boxes. Additionally, the core meta-architectures (GeneralizedRCNN, RetinaNet, SemanticSegmentor, and PanopticFPN) have been refactored to use a configurable interface, allowing their components (like backbones and heads) to be specified directly rather than relying solely on configuration objects, which simplifies model construction and improves flexibility.

_detectron2/modeling/meta\arch · high confidence

Added new instance segmentation baseline configurations for Mask R-CNN in the \configs/new\_baselines\ directory. These include ResNet-50 and ResNet-101 backbones, as well as RegNetX and RegNetY backbones, all trained with Large Scale Jittering (LSJ) augmentation. The baselines are provided for multiple training durations (50, 100, 200, and 400 epochs), allowing users to choose between faster convergence and higher accuracy. The configurations utilize SyncBN, AMP, and specific head structures (e.g., 4conv1fc box head) to establish new performance standards for instance segmentation.

_configs/new\baselines · high confidence

A new Model Zoo API has been introduced in the \detectron2.model\_zoo\ module, providing functions like \get\, \get\_config\, \get\_config\_file\, and \get\_checkpoint\_url\. This allows users to programmatically retrieve configuration files and download URLs for officially released pre-trained models (such as Faster R-CNN, Mask R-CNN, and RetinaNet variants) directly from the Detectron2 repository, simplifying the process of loading and initializing models without manually managing file paths or checkpoint URLs.

_detectron2/model\zoo · high confidence

Users can now train instance segmentation models using RegNetX and RegNetY backbones (4GF variants) via new Python config files, replacing the default ResNet architectures. Additionally, the COCO instance segmentation configs now support configurable box regression losses; specifically, a new YAML config enables Generalized Intersection over Union (GIoU) loss for both RPN and ROI box heads, offering an alternative to the previous deformable convolution settings.

configs/COCO-InstanceSegmentation · high confidence

Detectron2 now supports Vision Transformer (ViT), Swin Transformer, MViT, and RegNet architectures as backbone feature extractors. This change introduces new implementation files for these models, updates the backbone registry and exports to include them, and enhances the FPN module with square padding support to accommodate ViTDet-style training requirements.

detectron2/modeling/backbone · high confidence

The tools directory now includes \plain\_train\_net.py\ for training with a simple, explicit loop and \lazyconfig\_train\_net.py\ for training using the new LazyConfig system. A new \analyze\_model.py\ script allows users to compute FLOPs, activations, and parameter counts. The \benchmark.py\ script has been updated to support LazyConfig, report RAM usage, and profile AMP training. Additionally, \visualize\_coco\_results.py\ has been renamed to \visualize\_json\_results.py\ to support LVIS datasets, and \visualize\_data.py\ has been refactored to use the new \utils.convert\_image\_to\_rgb\ helper.

tools · high confidence

Added a comprehensive set of base configuration files for common data pipelines (COCO, COCO keypoints, COCO panoptic separated) and model architectures (Cascade R-CNN, FCOS, Keypoint R-CNN, Mask R-CNN with C4 and FPN backbones, Mask R-CNN with ViT-Det backbone, Panoptic FPN, and RetinaNet). These configs define the data loaders, dataset mappers, evaluators, and model structures required to run these standard object detection and segmentation tasks.

configs/common/models · high confidence

The DensePose module now includes a dedicated dataset registration system that automatically registers built-in datasets upon import. This change adds support for the ChimpNSee dataset (specifically for chimpanzee video lists), LVIS datasets (including training, validation, and animal-specific splits), and PoseTrack datasets, in addition to the existing COCO-based DensePose datasets. Users can now train and evaluate models on these new data sources using the standard Detectron2 dataset catalog interface.

projects/DensePose/densepose/data/datasets · high confidence

A new \detectron2/export\ package has been introduced to facilitate model deployment. This module provides a unified API to export Detectron2 models to TorchScript, ONNX, and Caffe2 formats. It includes a \TracingAdapter\ to handle complex input/output structures for tracing, Caffe2-compatible model wrappers (\Caffe2MetaArch\, \ProtobufModel\) for inference, and utilities for ONNX export with specific optimizations for Caffe2 runtime compatibility. The module also deprecates the old \add\_export\_config\ function.

detectron2/export · high confidence

This change introduces several new utility modules to the detectron2.utils package. It adds analysis tools (analysis.py) for counting FLOPs and activations per operator, and for identifying unused model parameters. It includes a new tracing module (tracing.py) with FX-tracing-safe assertions and version checks, and a memory utility (memory.py) that allows functions to automatically retry on CUDA OOM by falling back to CPU. Additionally, it provides developer helpers (develop.py) for creating dummy classes/functions when dependencies are missing, a project-specific PathManager (file\_io.py) using iopath, and updated environment collection (collect\_env.py) that now detects ROCM support and reports GPU architecture flags.

detectron2/utils · high confidence

The \detectron2/tracking\ module now provides a registry-based system for multi-object tracking, introducing several new tracker implementations. Users can now choose between a simple \BBoxIOUTracker\ that assigns IDs based on bounding box Intersection over Union, or more advanced trackers using the Hungarian algorithm (\VanillaHungarianBBoxIOUTracker\ and \IOUWeightedHungarianBBoxIOUTracker\) for optimal assignment between frames. These trackers are registered under \TRACKER\_HEADS\_REGISTRY\ and can be configured via \cfg.TRACKER\_HEADS\, allowing users to easily swap tracking strategies in their pipelines.

detectron2/tracking · high confidence

Added a new \VideoKeyframeDataset\ and supporting frame selection tools in the DensePose video data module. Users can now load video data by sampling specific keyframes using strategies such as selecting the first, last, or random K frames, or all frames. This includes helper functions to list and read keyframes from video files and parse video lists from text files, enabling more efficient processing of video sequences by focusing on key moments rather than every frame.

projects/DensePose/densepose/data/video · high confidence

The PointSup project is now available, providing the codebase for the 'Pointly-Supervised Instance Segmentation' paper. This release includes a training script (train\_net.py) that integrates with Detectron2 to support point-based supervision, a dataset preparation tool to generate point annotations from COCO mask data, and documentation outlining data preparation, training, and evaluation workflows.

projects/PointSup · high confidence

The PointRend project now supports semantic segmentation in addition to instance segmentation, with new pretrained models for Cityscapes (R101-FPN backbone) and updated documentation. A dedicated training script (train\_net.py) is provided, featuring custom augmentation logic for semantic segmentation (including random cropping and color augmentation) and evaluator wiring for COCO, LVIS, Cityscapes instance/semantic, and general semantic segmentation tasks.

projects/PointRend · high confidence

Adds a new project module for Panoptic-DeepLab, providing a training script, configuration files, and documentation for bottom-up panoptic segmentation on Cityscapes and COCO datasets. The implementation includes a custom trainer with specific dataset mapping for panoptic evaluation, support for Depthwise Separable Convolutions (DSConv), and pre-trained model weights for both Cityscapes and COCO benchmarks.

projects/Panoptic-DeepLab · high confidence

Users can now register and prepare the ADE20k scene parsing dataset using the new \prepare\_ade20k\_sem\_seg.py\ script, and evaluate models on LVIS annotations using COCO metrics via the new \prepare\_cocofied\_lvis.py\ tool. The dataset location is now configurable via the \DETECTRON2\_DATASETS\ environment variable (defaulting to \./datasets\), allowing external users to change where datasets are stored. Additionally, the test preparation script now downloads the full mini COCO validation images, and the PanopticFPN preparation script has been updated to use the new import path for COCO categories.

datasets · high confidence

Detectron2 now supports panoptic segmentation tasks by registering new dataset loaders for Cityscapes and COCO. The \cityscapes\_panoptic.py\ module adds a loader for the Cityscapes panoptic dataset, handling the mapping of thing and stuff categories to contiguous IDs and providing the necessary metadata for evaluation. Similarly, \coco\_panoptic.py\ introduces two registration methods: \register\_coco\_panoptic\ for the standard COCO panoptic format and \register\_coco\_panoptic\_separated\ for the format used by PanopticFPN, which merges instance and semantic annotations. These changes enable users to train and evaluate models on panoptic segmentation benchmarks using the existing dataset catalog infrastructure.

detectron2/data/datasets · high confidence

This release adds a complete set of Detectron2 configuration files for the ViTDet object detection framework, enabling users to train and evaluate Mask R-CNN and Cascade Mask R-CNN models using Vision Transformer (ViT), Swin, and MViTv2 backbones. The new configs cover the COCO dataset (with variants for ViT-B/L/H, Swin-B/L, and MViTv2-B/L/H) and the LVIS dataset, providing pre-trained model links and performance metrics in the updated README. Key behavioral changes include the adoption of Large Scale Jittering (LSJ) data augmentation for improved robustness, the use of Layer Normalization in FPN and ROI heads, and specific training schedules (e.g., 100 epochs for ViT, 50 epochs for Swin/MViTv2 on COCO) with learning rate decay strategies tailored to each backbone. For LVIS, the configs incorporate repeated factor training samplers and federated loss to handle long-tailed class distributions.

projects/ViTDet · high confidence

The custom C++ and CUDA source files for ROIAlign (including the header, CPU implementation, and CUDA kernel) have been deleted from the detectron2 codebase. This removes the local implementation of the ROIAlign layer, indicating a shift to rely on an external or alternative implementation (such as torchvision's) rather than maintaining this specific C++ extension code.

detectron2/layers/csrc/ROIAlign · high confidence

The DensePose ROI head implementation has been reorganized into a dedicated \roi\_heads\ module, introducing a registry (\ROI\_DENSEPOSE\_HEAD\_REGISTRY\) for head selection. This change extracts the \DensePoseROIHeads\ class and its associated \Decoder\ into \roi\_head.py\, while separating head architectures into \v1convx.py\ (the standard fully convolutional head) and \deeplab.py\ (a new DeepLabV3-based head with ASPP and non-local blocks). Users can now configure the model to use the DeepLab head via configuration options, and the codebase benefits from cleaner separation of concerns within the ROI head logic.

_projects/DensePose/densepose/modeling/roi\heads · high confidence

This update introduces a DataLoaderBenchmark utility to help users identify performance bottlenecks in their data pipelines. The DatasetMapper has been refactored to accept a configurable list of augmentations instead of relying on config flags, allowing for more flexible data transformation logic. Data loading robustness is improved through better handling of EXIF orientation, support for YUV image formats, and stricter validation of category IDs. Additionally, the system now supports IterableDataset for aspect grouping and implements shared RAM usage for data loader workers to reduce memory overhead.

detectron2/data · high confidence

The deformable convolution operators in detectron2 have been updated to improve compatibility with newer PyTorch versions and to enable support for AMD GPUs. The code now uses the modern \torch/types.h\ header instead of \torch/extension.h\, replaces deprecated \AT\_CHECK\ and \is\_cuda()\ calls with \TORCH\_CHECK\ and \is\_cuda()\, and updates CUDA atomic includes to the current \ATen/cuda/Atomic.cuh\. Additionally, the build configuration has been extended to support AMD's ROCm stack by adding \WITH\_HIP\ checks alongside existing CUDA checks, allowing these operators to run on AMD hardware when compiled with HIP support.

detectron2/layers/csrc/deformable · high confidence

The demo script has been refactored to support MP4 video output by detecting x264 availability and falling back to mp4v, and now properly releases the webcam capture to prevent resource leaks. Input handling has been improved to support glob patterns for image files, and the visualization window is now resizable. The underlying predictor class no longer requires metadata to be instantiated, allowing it to work without specific dataset configurations.

demo · high confidence

The DensePose module has been restructured to support Continuous Surface Embeddings (CSE) alongside the existing IoU-based approach. This change introduces new configuration options for CSE (including embedding dimensions, loss weights, and cycle consistency losses), adds a new CSE evaluator, and modifies the default head parameters (e.g., increasing heatmap size from 56 to 112 and adjusting loss weights). The old dataset registration and evaluator modules have been removed in favor of a new modular structure that supports category mapping, bootstrap datasets, and distributed evaluation with configurable storage.

projects/DensePose/densepose · high confidence

The data loading infrastructure in DensePose has been reorganized into a dedicated \densepose.data\ module, introducing a \CombinedDataLoader\ to mix multiple datasets, an \ImageListDataset\ for simple image lists, and an \InferenceBasedLoader\ that generates training data from model inference results. Training behavior is updated to support class-agnostic training via new category mapping logic and includes a new random rotation augmentation. Additionally, the dataset mapper now generates segmentation masks from DensePose annotations when configured, enabling mask-based training for the coarse segmentation head.

projects/DensePose/densepose/data · high confidence

The DensePose evaluation logic has been reorganized into a dedicated \evaluation\ module, introducing a new \DensePoseCOCOEvaluator\ that supports distributed evaluation and configurable minimum IoU thresholds. A new \MeshAlignmentEvaluator\ has been added to assess 3D mesh alignment using vertex embeddings, with results reported alongside standard GPS and segmentation metrics. The evaluation pipeline now includes a \tensor\_storage\ system for compactly storing and gathering tensor data across distributed processes, and the underlying \DensePoseCocoEval\ engine has been updated to support multiple evaluation modes (GPS, GPSM, IOU) and data modes (IUV, GT, etc.), while also fixing handling of empty segmentation annotations and updating resource paths to public URLs.

projects/DensePose/densepose/evaluation · high confidence

The DensePose loss logic has been reorganized into a dedicated \densepose/modeling/losses\ module, introducing a \DENSEPOSE\_LOSS\_REGISTRY\ to manage loss implementations. This change adds \DensePoseChartWithConfidenceLoss\, which supports UV coordinate confidence modeling (IID isotropic and independent anisotropic Gaussian losses), and \DensePoseCseLoss\, which handles embedding-based training and includes optional shape-to-shape and pixel-to-shape cycle losses. Existing chart-based losses are now cleanly separated, and utility classes for mask/segmentation handling and annotation packing are extracted for reuse across these new loss types.

projects/DensePose/densepose/modeling/losses · high confidence

The DensePose modeling module has been restructured to support new architectural features and improved inference workflows. A new High-Resolution Network (HRNet) backbone and its corresponding HRFPN feature pyramid are now available, with dedicated checkpoint handling to correctly map pretrained HRNet weights. Test-Time Augmentation (TTA) is now supported for DensePose, allowing users to enable rotation and horizontal flip augmentations during inference to improve prediction robustness. Additionally, the module introduces confidence modeling for UV and segmentation outputs, a data filtering mechanism for training, and a modular build system that centralizes the construction of predictors, heads, and losses.

projects/DensePose/densepose/modeling · high confidence

The DensePose project is now installable as a standalone package via setup.py, requiring Python 3.7+ and specific dependencies like av and opencv-python-headless. The apply\_net tool now supports command-line config overrides, uses torch.save instead of pickle for dumping results, and includes new texture-based visualizers (IUV and CSE) with configurable texture atlases. The query\_db tool now uses PathManager for file access and replaces hasattr with getattr for robustness. Training is streamlined by extracting the Trainer into a separate module, enabling Test-Time Augmentation (TTA) evaluation, and introducing distributed inference timeouts.

projects/DensePose · high confidence

The DensePose utility modules have been updated to align with modern Python standards and internal tooling. The \dbhelper.py\ module now uses standard class inheritance syntax (removing \(object)\) and updates type hints, such as making \typespec\ optional in \FieldEntrySelector\ predicates, while adding specific pyre fixme comments to address static analysis warnings. The \logger.py\ module now includes a return type hint for \verbosity\_to\level\. Additionally, new files \\\init\\_.py\ and \transform.py\ were introduced, with the latter providing functions to load DensePose transform data using Detectron2's \PathManager\ and \MetadataCatalog\. These changes reflect a shift towards stricter typing and cleaner code structure within the DensePose project utilities.

projects/DensePose/densepose/utils · high confidence

The visualization logic in the \densepose.vis\ module has been reorganized into separate files to support new capabilities. \densepose\_outputs\_iuv.py\ now handles visualization for DensePoseChartPredictorOutput (I, U, V, and fine segmentation), while \densepose\_outputs\_vertex.py\ introduces visualizers for DensePoseEmbeddingPredictorOutput, enabling Class-Specific Embeddings (CSE) and texture transfer rendering. The original \densepose.py\ has been renamed to \densepose\_results.py\ and updated to work with DensePoseChartResult objects. Additionally, \extractor.py\ now includes extractors for these new output types, and base visualizer classes have been modernized to standard Python classes with updated type hints.

projects/DensePose/densepose/vis · high confidence

This release upgrades the minimum supported PyTorch version to 1.8 and Python to 3.7, dropping support for older versions. It introduces official support for AMD's ROCm stack, allowing the library to be built and run on AMD GPUs alongside NVIDIA CUDA. The installation process is streamlined via \pip install\, and the package now includes model zoo configurations and key research projects (PointRend, DeepLab, Panoptic-DeepLab) directly in the distribution. Additionally, the repository has migrated its default branch from \master\ to \main\, and the \demo.py\ script has been updated to support webcam and video input streams.

(repo-wide) · high confidence

The Detectron2 package version has been incremented from 0.1 to 0.6. This update also includes a modification to the copyright header, removing the 'All Rights Reserved' clause.

detectron2 · high confidence

The \BoxMode\ enum now supports the XYWHA\_ABS format, allowing horizontal models to be trained on rotated datasets via new conversion logic in \BoxMode.convert\. Several data structures (\ImageList\, \Instances\, \Keypoints\, \BitMasks\, \PolygonMasks\) have been updated to improve TorchScript and tracing compatibility, including making \ImageList.from\_tensors\ scriptable, adding \cat\ methods to masks and keypoints, and fixing indexing behavior in \Instances\. Additionally, \ImageList\ now supports square padding constraints, and \BitMasks\ can now generate tight bounding boxes.

detectron2/structures · high confidence

The training engine now supports configurable distributed training timeouts and automatic backend selection (NCCL for GPU, GLOO for CPU) to improve stability on multi-machine setups. A new \BestCheckpointer\ hook allows users to automatically save model weights based on validation metrics, while the \DefaultTrainer\ and \SimpleTrainer\ now expose public setters for the model, optimizer, and data loader, enabling dynamic reconfiguration during training. Additionally, the training loop now synchronizes iteration counts between the trainer and event storage, supports checkpointable hooks via \state\_dict\/\load\_state\_dict\, and ensures evaluation runs at the end of training even if no iterations occur.

detectron2/engine · high confidence

The solver now supports configurable gradient clipping (by value or norm) via a new \SOLVER.CLIP\_GRADIENTS\ config section, which dynamically wraps the optimizer to apply clipping during the step phase. Additionally, the \get\_default\_optimizer\_params\ function allows for more granular control over optimizer parameter groups, enabling specific weight decay and learning rate factors for normalization layers and biases. The learning rate scheduling infrastructure has been updated to leverage \fvcore\'s \ParamScheduler\ classes, introducing \LRMultiplier\ and \WarmupParamScheduler\ for more flexible schedule composition, while retaining backward compatibility with existing schedulers like \WarmupMultiStepLR\ and \WarmupCosineLR\ (now emitting deprecation warnings).

detectron2/solver · high confidence

COCO evaluation is significantly faster via a new C++-backed \COCOeval\_opt\ implementation (opt-in via \use\_fast\_impl=True\). The \COCOEvaluator\ and \LVISEvaluator\ APIs are refactored to accept explicit arguments (e.g., \max\_dets\_per\_image\, \tasks\) instead of relying on a config object, and \COCOEvaluator\ now supports non-COCO datasets by auto-converting annotations. A new \RotatedCOCOEvaluator\ enables COCO-style evaluation for rotated bounding boxes. The inference pipeline (\inference\_on\_dataset\) now provides granular timing for data, compute, and evaluation phases, and the \DatasetEvaluator.process\ method now accepts batched inputs/outputs.

detectron2/evaluation · high confidence

The rotated box Intersection-over-Union (IoU) computation has been updated to fix numerical instability and incorrect results. The algorithm now uses an epsilon tolerance when determining intersection points between rotated boxes, preventing missed intersections due to floating-point precision errors. Additionally, the logic for computing rotated box vertices has been corrected to ensure proper geometric orientation. The CUDA implementation also now supports larger numbers of boxes by transposing inputs when necessary to avoid grid size limits, and enforces float32 input types for consistency.

_detectron2/layers/csrc/box\_iou\rotated · high confidence

The checkpoint system now handles distributed training scenarios more robustly by ensuring checkpoints are only loaded from the main worker and broadcasting model states to other workers if necessary. It also provides clearer logging during Caffe2 weight conversion, grouping matched weights by module and showing shapes, while ignoring missing or unexpected keys for \pixel\_mean\, \pixel\_std\, and \cell\_anchors\ to prevent warnings on legacy models. Additionally, the \ModelCatalog\ has been renamed to \Catalog\, and the \Detectron2Handler\ for resolving \detectron2://\ URLs has been removed, simplifying the path resolution logic.

detectron2/checkpoint · high confidence

Users can now integrate mmdetection backbones and detectors into detectron2 via the new MMDetBackbone and MMDetDetector wrappers, which handle config conversion and output format normalization. Several core modeling components, including the anchor generator, box regression transforms, matcher, and ROI pooler, have been refactored to support TorchScript and FX tracing, enabling better model export and deployment. The anchor generator now supports configurable offsets and non-persistent buffers, while box regression gains DIoU and CIoU loss support and linear transform capabilities for single-stage detectors like FCOS. Additionally, test-time augmentation has been modularized and made more robust, and postprocessing now supports ROIMasks for more efficient mask handling.

detectron2/modeling · high confidence

The data sampling module now includes a new RandomSubsetTrainingSampler, which allows users to randomly sample a subset of training data to estimate accuracy versus data-number curves. The existing RepeatFactorTrainingSampler has been refactored to accept pre-computed repeat factors directly rather than computing them from dataset annotations internally, shifting the computation to a new static method repeat\_factors\_from\_category\_frequency that supports an optional square-root scaling. Additionally, GroupedBatchSampler now uses numpy for group ID handling and no longer requires group IDs to be a continuous range starting from zero.

detectron2/data/samplers · high confidence

A new configuration file (panoptic\_fpn\_R\_50\_1x.py) has been added to define a panoptic segmentation model using a ResNet-50 backbone with pre-trained weights, while the base configuration (Base-Panoptic-FPN.yaml) has been updated to set FILTER\_EMPTY\_ANNOTATIONS to False, ensuring that training samples without annotations are no longer filtered out.

configs/COCO-PanopticSegmentation · high confidence

The ROI head modules (box, mask, keypoint, and cascade) have been refactored to support TorchScript and use a new \@configurable\ initialization pattern. This changes the constructor signatures of head classes (e.g., \FastRCNNConvFCHead\, \BaseKeypointRCNNHead\, \BaseMaskRCNNHead\) to accept explicit arguments like \conv\_dims\, \fc\_dims\, and \num\keypoints\ instead of parsing them directly from the config object in \\\init\\_\. The \FastRCNNConvFCHead\ now inherits from \nn.Sequential\ to improve scripting compatibility. Additionally, a new \RotatedFastRCNNOutputLayers\ and \RROIHeads\ class have been added to support rotated bounding box detection, and the \CascadeROIHeads\ has been updated to use the new configurable interface for its cascade stages.

_detectron2/modeling/roi\heads · high confidence

The ROIAlignRotated operator now supports AMD ROCm backends alongside CUDA, enabling usage on AMD GPUs. The implementation has been updated to use modern PyTorch C++ API conventions, including switching from \torch/extension.h\ to \torch/types.h\, replacing deprecated \input.type()\ checks with \input.is\_cuda()\ and \input.scalar\_type()\, and using \int64\_t\ for integer parameters. Additionally, memory handling is improved by explicitly creating contiguous copies of input tensors before passing them to kernels, and member initialization is corrected to avoid uninitialized memory warnings.

detectron2/layers/csrc/ROIAlignRotated · high confidence

The RPN proposal generation logic has been restructured to support TorchScript tracing and improve numerical stability. The previous \rpn\_outputs.py\ and \rrpn\_outputs.py\ modules were removed; their core functions, such as \find\_top\_rpn\_proposals\ and \find\_top\_rrpn\_proposals\, have been moved to \proposal\_utils.py\. These functions now use \torch.topk\ instead of \sort\ for selecting top proposals, which is required for TorchScript compatibility. Additionally, the code now explicitly handles \inf\ and \nan\ values in predictions: during training, it raises a \FloatingPointError\ if divergence is detected, and during inference, it filters out invalid proposals. The \StandardRPNHead\ and \RRPN\ classes have been updated to use the \@configurable\ decorator, allowing their hyperparameters (like \conv\_dims\ and \box\_dim\) to be configured via the config system while maintaining backward compatibility with existing checkpoints.

_detectron2/modeling/proposal\generator · high confidence

The data augmentation system has been refactored to replace the legacy \TransformGen\ base class with a new \Augmentation\ class, which allows transforms to accept arbitrary input arguments (such as images and segmentation masks) rather than just images. This change introduces new augmentation capabilities including \RandomApply\ (applying transforms with a probability), \RandomFlip\ with vertical flipping support, \RandomRotation\, \MinIoURandomCrop\, and \FixedSizeCrop\. Additionally, \ResizeTransform\ now supports non-uint8 image types via PyTorch interpolation and provides an inverse transform method, while \ExtentTransform\ gains support for grayscale images.

detectron2/data/transforms · high confidence

The DensePose training and evaluation logic has been extracted from the monolithic codebase into a new \densepose.engine\ module. This change introduces a custom \Trainer\ class that extends Detectron2's \DefaultTrainer\, adding support for distributed inference, sample counting metrics, and specific evaluation adapters for COCO and LVIS datasets. The refactoring also includes the addition of a \SampleCountingLoader\ and \SampleCountMetricPrinter\ to track batch statistics during training, and ensures that the embedder is correctly passed to evaluators for CSE (Class-Specific Embedding) evaluation.

projects/DensePose/densepose/engine · high confidence

The rotated Non-Maximum Suppression (NMS) implementation in detectron2 now supports AMD's ROCm stack alongside CUDA, enabling GPU acceleration on AMD hardware. Additionally, the IoU threshold parameter for rotated NMS has been changed from float to double precision, which may affect the exactness of box filtering results. The code also updates deprecated PyTorch C++ API calls (such as .type() to .scalar\_type() and .data() to .data\_ptr()) and ensures input tensors are contiguous before processing.

_detectron2/layers/csrc/nms\rotated · high confidence

The TridentNet implementation has been refactored to align with Detectron2's internal APIs. The custom stage-building logic was replaced by delegating to ResNet.make\_stage, and the first\_stride argument was removed in favor of stride\_per\_block. Additionally, the merge\_branch\_instances function was updated to read NMS thresholds and top-k detection limits directly from the box\_predictor, ensuring consistent configuration handling across TridentRes5ROIHeads and TridentStandardROIHeads.

projects/TridentNet/tridentnet · high confidence

The TridentNet training script (train\_net.py) now uses the updated COCOEvaluator API (passing output\_dir instead of boolean flags), removes the deprecated verify\_results call, and adds a shebang line for direct execution. The README has been updated to reflect these command-line changes, corrects the arXiv reference to the 2019 paper, and adds a results table with download links for TridentNet and Faster R-CNN models on MS-COCO.

projects/TridentNet · high confidence

The developer workflow scripts have been updated to enforce stricter linting standards and adjust test output parsing. The linter now requires black version 25.x and isort version 4.3.21, removing support for older versions and flake8-3. Additionally, the parse\_results.sh script has been modified to extract inference speed from 'Total inference pure' log lines instead of the general 'Total inference' line, providing a more specific metric for developers.

dev · high confidence

Added developer test scripts for DensePose; Added tests for Caffe2 RPN export compatibility; Added tests for LazyConfig and config versioning; Added tests for TensorboardXWriter utility; Added unit tests for DensePose data loading, structures, and evaluation; Added unit tests for SwapAlign2Nat operation; Added unit tests for data loading, COCO evaluation, and image transforms; Added unit tests for structures module; Added unit tests for tracking algorithms; Initial unit test suite for Detectron2; New test coverage for modeling components; Organized layer tests and added coverage for new features.

The documentation build environment has been updated to use specific versions of Sphinx (3.2.0) and docutils (0.16), replacing the previous loose version constraints. Additional dependencies such as recommonmark, cloudpickle, Pillow, future, scipy, timm, and omegaconf have been added to support the documentation build process. The fvcore dependency has been updated to use the HTTPS protocol, and specific PyTorch and torchvision wheel URLs have been included to ensure consistent CPU-based builds.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 59.

• Code Health 88
• Architecture 89
• Maturity 54
• Readiness 55
• Security 59

• 300 commits — 232 feature/other, 68 fixes

• projects/DensePose — 45 commits
• detectron2/data — 35 commits
• detectron2/modeling — 31 commits
• detectron2/utils — 28 commits
• detectron2/layers — 24 commits
• detectron2/engine — 19 commits
• (root) — 12 commits
• detectron2/evaluation — 12 commits
• detectron2/export — 12 commits
• detectron2/config — 8 commits
• detectron2/tracking — 8 commits
• detectron2/solver — 7 commits
• .github/actions — 6 commits
• .github/workflows — 6 commits
• detectron2/structures — 6 commits
• detectron2/checkpoint — 5 commits
• .circleci/config.yml — 4 commits
• tools/deploy — 4 commits
• projects/ViTDet — 3 commits
• docs/requirements.txt — 2 commits

• fix: Added diou and ciou losses for bbox regression
• fix: Bug fix with prefetch_factor
• fix: Bug fix: Handle empty instances in FCOS.
• fix: Fix 2 broken tests caused by D98598165
• fix: Fix CI failure on Circle CI
• fix: Fix CQS signal cppcoreguidelines-pro-type-member-init in fbcode/vision/fair
• fix: Fix CQS signal readability-braces-around-statements in fbcode/vision/fair
• fix: Fix ValueError: Unable to avoid copy while creating an array as requested (numpy 2.0.0)
• fix: Fix detector build issues
• fix: Fix documentation of MMDetWrapper
• fix: Fix federated loss
• fix: Fix for D55776288
• fix: Fix for FileNotFoundError 'output/metrics.json'
• fix: Fix import exceptions in tracing.py for older (<1.12) versions of pytorch
• fix: Fix lint
• fix: Fix longest common prefix (fix #4299)
• fix: Fix padding value to zero for segmentations in FixedSizeCrop
• fix: Fix rrpn proposal validation
• fix: Fix semantic errors in code for calculating IoU metrics in Segmentation evaluator.
• fix: Fix strict ordering checks
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

facebookresearch/detectron2 was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.