facebookresearch/detectron2
57.5
Adequate · 15 November 2026
55.5k
lines of production code
Python
primary language
5
measurements over time
What this system is
Features
Add DeepLabV3 and DeepLabV3+ semantic segmentation models
Introduces DeepLabV3 and DeepLabV3+ heads for semantic segmentation, including a configurable DeepLabV3PlusHead that supports ASPP with optional depthwise separable convolutions and a DeepLabV3Head. Adds a DeepLab-specific ResNet stem and backbone configuration (e.g., res4/res5 dilation, multi-grid) via the ResNet registry, and registers a WarmupPolyLR scheduler for training. Includes a DeepLabCE loss implementing hard pixel mining and config defaults for cropping, loss type, and ASPP parameters.
projects/DeepLab/deeplab · high confidence
Add DeepLabV3/V3+ project with training and evaluation scripts
Introduces a new project directory for DeepLabV3 and DeepLabV3+ semantic segmentation models within Detectron2. This includes a training script (train\_net.py) that supports multi-node training, custom data augmentation for semantic segmentation, and integration with Cityscapes and standard semantic segmentation evaluators, along with pre-trained model weights and configuration examples for Cityscapes.
projects/DeepLab · high confidence
Add MViTv2 detection configs and documentation
This change introduces configuration files and a README for MViTv2 (Improved Multiscale Vision Transformers) within Detectron2. It adds support for Cascade Mask R-CNN and Mask R-CNN architectures using MViTv2 backbones (Tiny, Small, Base, Large, and Huge variants) with pre-trained weights from ImageNet-1K and ImageNet-21K. The configs include specific training schedules, data loaders with Large Scale Jittering (LSJ) augmentations, and hyperparameters tailored for object detection and instance segmentation on COCO.
projects/MViTv2 · high confidence
Add Panoptic-DeepLab panoptic segmentation model and training pipeline
Introduces the Panoptic-DeepLab architecture to Detectron2, enabling users to perform panoptic segmentation (combining semantic and instance segmentation) on datasets like COCO. This change adds the \PanopticDeepLab\ model class, a dedicated dataset mapper for handling panoptic ground truth, a target generator for creating center heatmaps and offsets, and post-processing logic to merge semantic and instance predictions. The implementation includes configuration options for ASPP and DeepLab decoder heads, supports DepthwiseSeparableConv2d for efficiency, and exposes specific hyperparameters for instance embedding and post-processing thresholds.
_projects/Panoptic-DeepLab/panoptic\deeplab · high confidence
Add PointRend instance and semantic segmentation models
This change introduces the PointRend project module, adding support for high-quality instance and semantic segmentation via iterative point-based refinement. It includes new model components such as \PointRendMaskHead\ and \PointRendSemSegHead\, along with \StandardPointHead\ and \ImplicitPointRendMaskHead\ for mask prediction. The update also adds \ColorAugSSDTransform\ for data augmentation, configuration options in \config.py\, and registration hooks in \roi\_heads.py\ to integrate these heads into the detection pipeline.
_projects/PointRend/point\rend · high confidence
Add SwapAlign2Nat layer for TensorMask
Users can now use the SwapAlign2Nat operation within TensorMask models. This new layer, implemented in C++/CUDA and exposed via Python, transforms mask representations from aligned to natural coordinates by swapping unit lengths, as described in the TensorMask paper. It is available as both a functional API (\swap\_align2nat\) and a PyTorch module (\SwapAlign2Nat\) with configurable lambda and padding parameters.
projects/TensorMask/tensormask/layers · high confidence
Add TensorMask dense object segmentation project
Introduces the TensorMask project for Detectron2, providing a dense sliding-window instance segmentation framework. This release includes the necessary setup configuration (setup.py) to compile the custom C++/CUDA extension (swap\_align2nat), a training and evaluation script (train\_net.py) compatible with Detectron2's default trainer, and a README with installation instructions and links to pre-trained models.
projects/TensorMask · high confidence
Add TensorMask object detection model
Introduces the TensorMask architecture for object detection, including the main model implementation, configuration options, and necessary layers. This adds a new meta-architecture to Detectron2 that supports anchor-based detection with specific settings for classification, box regression, and mask prediction towers.
projects/TensorMask/tensormask · high confidence
Add ViTDet model configurations for COCO and LVIS datasets
This change introduces a new set of Detectron2 configuration files for the ViTDet project, providing pre-trained Mask R-CNN and Cascade Mask R-CNN models based on Vision Transformer (ViT) backbones (ViT-B/L/H), MViTv2, and Swin Transformer. The configs cover training on both COCO and LVIS datasets, utilizing Large Scale Jittering (LSJ) data augmentation and pre-trained weights from MAE and ImageNet-21K. Users can now leverage these specific architectural settings and hyperparameters for object detection tasks on these benchmarks.
projects/ViTDet · high confidence
Add experimental configs for BatchNorm variants in Mask R-CNN and RetinaNet
This change introduces a new project directory containing configuration files and scripts to reproduce detection experiments from the 'Rethinking Batch in BatchNorm' paper. It provides Mask R-CNN configs that place BatchNorm in the head, including variants using batch statistics during inference, cross-GPU shuffling of head inputs, and SyncBatchNorm. For RetinaNet, it adds configs for SyncBatchNorm in the head, including a shared training mode that normalizes across all five feature levels, along with a separate evaluation script to recompute domain-specific statistics for improved performance.
projects/Rethinking-BatchNorm · high confidence
Add panoptic segmentation dataset support for Cityscapes and COCO
Users can now train and evaluate panoptic segmentation models on Cityscapes and COCO datasets. This change introduces new dataset registration modules (\cityscapes\_panoptic.py\ and \coco\_panoptic.py\) that load panoptic ground truth annotations, mapping category IDs to contiguous training IDs and handling both 'thing' and 'stuff' classes. It also adds the LVIS v1 category definitions (\lvis\_v1\_categories.py\) to support panoptic evaluation on the LVIS dataset.
detectron2/data/datasets · high confidence
Add point-supervised instance segmentation support
Introduces a new point-supervised training mode for instance segmentation, allowing models to be trained using sparse point annotations (point coordinates and labels) instead of full mask masks. This includes a new dataset mapper that handles point coordinate transformations and sampling, utility functions to convert point annotations into model-ready instances, and specialized mask heads (MaskRCNNConvUpsamplePointSupHead and ImplicitPointRendPointSupHead) that compute loss based on point samples. Additionally, it provides registration functions for COCO datasets containing point annotations.
_projects/PointSup/point\sup · high confidence
Added FCOS, RetinaNet, and Keypoint R-CNN detection configs
New configuration files have been added for 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.
configs/COCO-Detection · high confidence
Added image resize transform for DensePose training
A new \ImageResizeTransform\ class has been introduced in the DensePose data pipeline to standardize input images for training. This transform resizes batches of BGR images (NCHW format) to a specified minimum and maximum size while preserving aspect ratio, and converts the data type from uint8 to float32, ensuring inputs are ready for DensePose model consumption.
projects/DensePose/densepose/data/transform · high confidence
Automated pre-built wheel generation for CUDA and PyTorch combinations
The dev/packaging directory now includes a complete toolchain for building and distributing pre-built binary wheels. This introduces scripts to build individual wheels (build\_wheel.sh) and batch-build wheels across multiple CUDA versions (cu92, cu100, cu101, cu102, cu110, cu111, cu113) and PyTorch versions (1.8, 1.9, 1.10) for Python 3.7–3.9 using Docker containers. It also adds utilities to generate wheel index pages (gen\_wheel\_index.sh) and installation instruction tables (gen\_install\_table.py), enabling users to easily install the correct binary package for their specific hardware and software stack.
dev/packaging · high confidence
DensePose predictor refactoring and confidence estimation support
The DensePose modeling code has been reorganized into a modular predictor package with a central registry (DENSEPOSE\_PREDICTOR\_REGISTRY). This introduces base predictors for both chart-based (DensePoseChartPredictor) and continuous surface embedding (DensePoseEmbeddingPredictor) approaches, alongside new confidence-aware variants (DensePoseChartWithConfidencePredictor and DensePoseEmbeddingWithConfidencePredictor) that estimate uncertainty for segmentation and UV/embedding outputs. Users can now select predictors via the registry and, when enabled, receive confidence estimates alongside standard DensePose predictions.
projects/DensePose/densepose/modeling/predictors · high confidence
DensePose structures now include confidence estimates and result compression
The \densepose.structures\ module has been expanded to support uncertainty quantification and efficient serialization for DensePose outputs. Predictor outputs for both chart-based and CSE (Continuous Surface Embedding) models can now include confidence metrics, such as sigma and kappa parameters for chart methods and coarse segmentation confidence for CSE, accessible via new \\*WithConfidences\ dataclasses. Additionally, chart-based results can now be quantized to uint8 and compressed into Base64-encoded PNG strings to reduce memory footprint, while mesh attributes like geodesic distances and texture coordinates are loaded lazily only when needed.
projects/DensePose/densepose/structures · high confidence
Initial Docker support for development and C++ deployment
Added Dockerfiles, a docker-compose configuration, and documentation to run Detectron2 in containers. The base image uses Ubuntu 18.04 with CUDA 11.1 and installs PyTorch 1.10 and Detectron2 as a non-root user to avoid OpenCV compatibility issues. A separate deployment Dockerfile is provided to build C++ examples, and the docker-compose setup simplifies GPU access and X11 forwarding for interactive use.
docker · high confidence
Introduce CSE embedder infrastructure for mesh-specific vertex embeddings
This change adds the core embedding modules for DensePose's Coordinate Space Embedding (CSE) feature within the \projects/DensePose/densepose/modeling/cse\ directory. It introduces the \Embedder\ container class, which manages multiple mesh-specific embedders, and two concrete embedder types: \VertexDirectEmbedder\ (which stores embeddings directly as learnable parameters) and \VertexFeatureEmbedder\ (which maps vertex features into the embedding space). The \Embedder\ class handles configuration parsing, initialization from pickle files or model checkpoints, and provides a unified interface to retrieve vertex embeddings for a given mesh name. Utility functions for computing squared Euclidean distance matrices and normalizing embeddings are also included to support the embedding logic.
projects/DensePose/densepose/modeling/cse · high confidence
Introduce FCOS detector and refactor meta-architectures for configurability
This change adds the FCOS (Fully Convolutional One-Object Detection) model as a new dense detector, inheriting from the newly introduced \DenseDetector\ base class which standardizes image preprocessing and device handling for fully-convolutional models. It also refactors existing meta-architectures (\GeneralizedRCNN\, \RetinaNet\, \SemanticSegmentor\, \PanopticFPN\) to use a \@configurable\ interface, moving configuration logic from \\_\init\\_\ to \from\_config\ and replacing manual device management with registered buffers for pixel mean and standard deviation. \PanopticFPN\ is updated to inherit from \GeneralizedRCNN\ to share common detection logic.
_detectron2/modeling/meta\arch · high confidence
Introduce Pointly-Supervised Instance Segmentation project
Adds the PointSup project, enabling instance segmentation training with point-level annotations instead of full masks. This includes a training script (train\_net.py) that integrates point-supervised data mapping and configuration, and a utility tool to generate point annotations from existing COCO mask datasets.
projects/PointSup · high confidence
Introduce mesh catalog with texture coordinates and symmetry data
DensePose now includes a structured mesh catalog that registers 3D meshes for humans and various animals (such as SMPL, chimpanzees, cats, and dogs). This update adds support for texture coordinates and mesh symmetry data alongside existing geodesic distance information, enabling more accurate UV mapping and symmetric pose estimation for these additional species.
projects/DensePose/densepose/data/meshes · high confidence
Introduce new DensePose data samplers for training and evaluation
The DensePose module now includes a new data sampler package that provides multiple strategies for generating ground-truth-like annotations from model predictions. Users can now select between uniform sampling and confidence-based sampling (using sigma\_2, fine segmentation, or coarse segmentation confidence) for standard DensePose, as well as dedicated samplers for the Class-Specific Embeddings (CSE) approach. Additionally, a generic \PredictionToGroundTruthSampler\ is available to map prediction fields (boxes, classes, scores) directly to ground-truth fields, and a \MaskFromDensePoseSampler\ converts DensePose outputs into binary masks.
projects/DensePose/densepose/data/samplers · high confidence
Introduces LazyConfig and configurable decorators for model construction
Detectron2 adds a new configuration system centered on \LazyCall\ and \LazyConfig\ classes, allowing users to define model architectures as lazy, serializable objects that are instantiated only when needed via the new \instantiate()\ function. This is supported by a \@configurable\ decorator that enables classes and functions to be constructed directly from configuration nodes using a \from\_config\ method, simplifying the wiring of model components. The \config\ module now exports these new tools alongside the existing \CfgNode\, providing a more flexible and explicit way to build models compared to the previous implicit construction.
detectron2/config · high confidence
Make projects importable under detectron2.projects
The \detectron2.projects\ package now supports importing sub-projects (PointRend, DeepLab, Panoptic-DeepLab) directly via the \detectron2.projects\ namespace. This is achieved by registering a custom meta-path finder that dynamically resolves project modules from the external \projects\ directory, enabling in-place installations to access these features seamlessly.
detectron2/projects · high confidence
New ASPP and DepthwiseSeparableConv layers, DIoU/CIoU losses, and improved TorchScript/quantization support
This update adds new building blocks for segmentation models, including the Atrous Spatial Pyramid Pooling (ASPP) layer and DepthwiseSeparableConv2d, alongside Distance IoU (DIoU) and Complete IoU (CIoU) loss functions for bounding-box regression. It also enhances model deployment and efficiency: FrozenBatchNorm2d now uses F.batch\_norm for better inference performance, supports conversion to BatchNorm2d for quantization, and handles half-precision inputs; ROIAlign and mask pasting operations are made scriptable and traceable, with ROIAlign now delegating to torchvision; and deformable convolutions gain CPU support via torchvision on non-CUDA devices.
detectron2/layers · high confidence
New C++ TorchScript deployment example and export script
Added a new C++ example (\torchscript\_mask\_rcnn.cpp\) and build configuration (\CMakeLists.txt\) in \tools/deploy\ to run inference with TorchScript Mask R-CNN models, supporting tracing, scripting, and caffe2\_tracing export methods. Included an \export\_model.py\ script to export Detectron2 models to TorchScript, ONNX, or Caffe2 formats, and updated the README with usage instructions and dependency requirements (libtorch, OpenCV, TorchVision).
tools/deploy · high confidence
New Mask R-CNN baselines with ResNet and RegNet backbones
Added new instance segmentation baseline configurations for Mask R-CNN in the \configs/new\_baselines\ directory. These include ResNet-50 and ResNet-101 backbones with 50, 100, 200, and 400 epoch training schedules, as well as RegNetX and RegNetY backbones with 100, 200, and 400 epoch schedules. All new configs adopt the Large Scale Jitter (LSJ) augmentation pipeline, including random scaling, fixed-size cropping, and horizontal flipping, along with synchronized batch normalization and training from scratch.
_configs/new\baselines · high confidence
New Model Zoo API for loading pre-trained models
Users can now programmatically access Detectron2's pre-trained models and configurations via the new \detectron2.model\_zoo\ module. This API provides functions like \get\, \get\_config\, and \get\_checkpoint\_url\ to retrieve model architectures, configuration files, and pre-trained weight URLs directly by their config path (e.g., \COCO-InstanceSegmentation/mask\_rcnn\_R\_50\_FPN\_1x\), simplifying the process of loading official baselines without manual file management.
_detectron2/model\zoo · high confidence
New RegNet backbones and configurable GIoU loss for instance segmentation
Users can now train instance segmentation models using RegNetX-4GF and RegNetY-4GF backbones (replacing the default ResNet) via new configuration files, and can enable GIoU loss for both RPN and ROI box regression to improve bounding box accuracy. The GIoU loss is configured by setting BBOX\_REG\_LOSS\_TYPE to "giou" with specific weights (2.0 for RPN, 10.0 for ROI Box Head), as demonstrated in the new mask\_rcnn\_R\_50\_FPN\_1x\_giou.yaml config.
configs/COCO-InstanceSegmentation · high confidence
New ViT, MViT, Swin, and RegNet backbone support
Detectron2 now includes four new backbone architectures: Vision Transformer (ViT), Multi-Scale Vision Transformer (MViT), Swin Transformer, and RegNet. These are implemented in new files (vit.py, mvit.py, swin.py, regnet.py) and registered in the backbone module, allowing users to leverage these modern architectures for feature extraction. The change also introduces a \padding\_constraints\ property to the base \Backbone\ class and adds a \square\_pad\ argument to the FPN module to support square padding requirements common in ViT-based detection pipelines.
detectron2/modeling/backbone · high confidence
New and updated model analysis and training tools
The tools directory now includes \analyze\_model.py\ for computing FLOPs, activations, and parameter counts, and \convert-torchvision-to-d2.py\ to convert torchvision ResNet weights for use in detectron2. Training workflows are expanded with \plain\_train\_net.py\ (a minimal loop without the Trainer abstraction), \lazyconfig\_train\_net.py\ (supporting Python-based LazyConfig files), and \lightning\_train\_net.py\ (integrating PyTorch Lightning). The \train\_net.py\ script now uses dataset-specific evaluators (e.g., \CityscapesInstanceEvaluator\) and supports evaluation-only modes. Additionally, \benchmark.py\ has been enhanced to support LazyConfig, AMP profiling, and detailed data loading metrics, while \visualize\_json\_results.py\ (renamed from \visualize\_coco\_results.py\) now supports LVIS datasets and handles empty predictions.
tools · high confidence
New common model and data configurations for Detectron2
This change introduces a suite of reusable configuration files for the Detectron2 framework, located in configs/common/models and configs/common/data. It adds data loaders and evaluation settings for COCO object detection, keypoint detection, and panoptic segmentation. New model architectures are provided as base configurations, including FCOS, RetinaNet, Cascade R-CNN, Keypoint R-CNN, Mask R-CNN (both FPN and C4 backbones), Panoptic FPN, and a Vision Transformer-based Mask R-CNN (ViTDet). These configs standardize hyperparameters, backbone definitions, and head structures, allowing users to easily instantiate or extend these specific detection and segmentation pipelines.
configs/common/models · high confidence
New common training configuration definitions
The \configs/common\ directory now provides reusable, lazily-instantiated definitions for common training components, including learning-rate schedulers (supporting 1x, 2x, 3x, 6x, and 9x COCO schedules), optimizer settings (SGD and AdamW with default parameter handling), and general training parameters (such as output directory, checkpointing, and distributed data parallel options). These definitions can be imported or loaded via the \model\_zoo.get\_config\ API to simplify user configuration.
configs/common · high confidence
New dataset preparation scripts and updated documentation for ADE20k and LVIS
Users can now prepare the ADE20k scene parsing dataset using the new \prepare\_ade20k\_sem\_seg.py\ script and evaluate models on LVIS using COCO metrics via the new \prepare\_cocofied\_lvis.py\ script. The dataset location is now configurable via the \DETECTRON2\_DATASETS\ environment variable, and the \prepare\_for\_tests.sh\ script has been updated to download the full COCO validation images alongside annotations for more comprehensive testing. Documentation has been updated to reflect these new datasets and configuration options.
datasets · high confidence
New dataset registrations for ChimpNSee, LVIS, and PoseTrack
The DensePose module now registers several new datasets via the \densepose.data.datasets\ package. Users can now train and evaluate on the ChimpNSee dataset (specifically for chimpanzee pose estimation), LVIS datasets (including \densepose\_lvis\_v1\ variants for training, validation, and animal-specific subsets), and PoseTrack 2017 datasets. These additions are implemented in \builtin.py\, \chimpnsee.py\, \lvis.py\, and \coco.py\, which define the dataset metadata, annotation paths, and loading logic for these specific data sources.
projects/DensePose/densepose/data/datasets · high confidence
New export module for TorchScript, ONNX, and Caffe2 model deployment
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 during tracing, Caffe2-compatible model wrappers (\Caffe2Tracer\, \Caffe2Model\, \ProtobufModel\) for inference, and utilities for ONNX export and Caffe2 protobuf conversion. The module also deprecates the legacy \add\_export\_config\ function.
detectron2/export · high confidence
New model analysis and environment diagnostics utilities
The \detectron2/utils\ package now includes new capabilities for model analysis and environment diagnostics. Users can analyze model complexity by counting FLOPs and activations per operator using the new \FlopCountAnalysis\ class and \flop\_count\_operators\/\activation\_count\_operators\ functions in \analysis.py\. The \collect\_env.py\ module has been significantly expanded to provide detailed system information, including GPU architecture flags, ROCM support detection, and compiler versions, aiding in troubleshooting setup issues. Additionally, \memory.py\ introduces a \retry\_if\_cuda\_oom\ decorator that automatically retries operations on the CPU if a CUDA Out-Of-Memory error occurs, improving robustness during inference or training.
detectron2/utils · high confidence
New modular converter framework for DensePose outputs
The DensePose module now includes a new \converters\ package that provides a structured way to transform predictor outputs into user-facing results. This introduces a \BaseConverter\ class with a registry system, allowing specific converters to be registered for different output types. New capabilities include converting DensePose chart predictor outputs to \DensePoseChartResult\ (with an optional variant that includes confidence scores) and converting predictor outputs to \BitMasks\. Additionally, a horizontal flip converter is added to handle data augmentation transformations on predictor outputs.
projects/DensePose/densepose/converters · high confidence
New multi-object tracking algorithms added to Detectron2
The \detectron2/tracking\ module now includes a registry-based infrastructure for multi-object tracking, introducing three new tracker implementations: \BBoxIOUTracker\ (simple IoU-based matching), \VanillaHungarianBBoxIOUTracker\ (Hungarian algorithm using IoU as the cost metric), and \IOUWeightedHungarianBBoxIOUTracker\ (Hungarian algorithm weighted by IoU values). These trackers allow users to assign and maintain consistent IDs across video frames based on bounding box overlap, with configurable parameters for video dimensions, maximum instances, lost frame counts, and IoU thresholds.
detectron2/tracking · high confidence
New training configurations for SyncBN, Deformable Conv, and external model integration
The \configs/Misc\ directory now includes several new example configurations: \mask\_rcnn\_R\_50\_FPN\_3x\_syncbn.yaml\ and its scratch variant (\scratch\_mask\_rcnn\_R\_50\_FPN\_9x\_syncbn.yaml\) enable training with SyncBatchNorm, while \cascade\_mask\_rcnn\_R\_50\_FPN\_3x.yaml\ and \mask\_rcnn\_R\_50\_FPN\_3x\_dconv\_c3-c5.yaml\ provide setups for Cascade R-CNN and Deformable Convolution (DCN). Additionally, \mmdet\_mask\_rcnn\_R\_50\_FPN\_1x.py\ demonstrates how to wrap and train an mmdetection model using detectron2, and \torchvision\_imagenet\_R\_50.py\ shows how to use detectron2 as a general engine to train a torchvision ImageNet classifier. Several existing configs (class-agnostic mask R-CNN, semantic segmentation, and GN-based scratch training) have been moved to this directory with updated base paths.
configs/Misc · high confidence
New video keyframe dataset and frame selection utilities
Added a new \VideoKeyframeDataset\ and associated frame selection tools in \projects/DensePose/densepose/data/video\. Users can now load video data by selecting specific keyframes using strategies such as random, first, or last K frames, or by reading pre-defined keyframe lists from CSV files. This enables more efficient processing of video inputs by focusing on representative frames rather than every frame in a sequence.
projects/DensePose/densepose/data/video · high confidence
PointRend project adds semantic segmentation support and training infrastructure
The PointRend project now supports semantic segmentation in addition to instance segmentation, introducing a dedicated training script (train\_net.py) that handles dataset-specific evaluation (COCO, LVIS, Cityscapes, and semantic segmentation) and custom training augmentations like random cropping for semantic tasks. The project also provides pretrained models for both instance segmentation (on COCO and Cityscapes) and semantic segmentation (on Cityscapes), along with a Colab tutorial for visualization and usage.
projects/PointRend · high confidence
Reproduce Panoptic-DeepLab in Detectron2
Adds a new project module that reproduces the Panoptic-DeepLab bottom-up panoptic segmentation baseline within Detectron2. This includes a dedicated training script (train\_net.py) with a custom Trainer class, dataset mapper, and optimizer configuration, along with a README documenting installation, training, evaluation, and benchmarking for Cityscapes and COCO datasets.
projects/Panoptic-DeepLab · high confidence
Removals
Remove custom ROIAlign C++/CUDA implementation
The custom C++ and CUDA source files for ROIAlign (including the header, CPU, and CUDA implementations) have been deleted from the detectron2 codebase. This removes the in-house ROIAlign layer implementation, indicating a shift to rely on an external or alternative implementation (such as torchvision's) rather than maintaining this specific custom code path.
detectron2/layers/csrc/ROIAlign · high confidence
Architecture
Extract DensePose ROI heads into a dedicated module
The DensePose ROI head implementations (including the V1ConvX and DeepLab heads, the decoder, and the main ROI heads class) have been extracted from their previous location into a new \projects/DensePose/densepose/modeling/roi\_heads\ package. This change introduces a dedicated registry (\ROI\_DENSEPOSE\_HEAD\_REGISTRY\) and organizes the head logic into separate files (\v1convx.py\, \deeplab.py\, \roi\_head.py\, \registry.py\), improving code structure and maintainability without altering the external API or model behavior.
_projects/DensePose/densepose/modeling/roi\heads · high confidence
Behavioural changes
Add CUDA/HIP version detection and expose COCO evaluation internals
The C++ extension now detects and exposes the CUDA or HIP runtime version via new \get\_cuda\_version\ and \has\_cuda\ Python bindings, enabling the library to report its accelerator environment accurately. Additionally, internal COCO evaluation classes (\COCOeval::Accumulate\, \COCOeval::EvaluateImages\, and related structs) are now exposed to Python, allowing users to access low-level evaluation logic directly. The module also migrates several operators (NMS, box IoU, rotated ROI-Align) to the \TORCH\_LIBRARY\ registration API.
detectron2/layers/csrc · high confidence
C++ implementation of COCO evaluation metrics
Added a C++ implementation of the COCO evaluation logic (cocoeval) to replace the previous Python-based approach, aiming to speed up the computation of precision-recall curves and detection metrics.
detectron2/layers/csrc/cocoeval · high confidence
Data loading performance, configurability, and robustness improvements
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
Deformable Convolution updates for PyTorch compatibility and AMD ROCm support
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
Demo tool refactored with MP4 support and improved webcam handling
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
DensePose architecture refactored to support Continuous Surface Embeddings (CSE) and new evaluation modes
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
DensePose data loading refactored with new loaders and category mapping
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
DensePose evaluation restructured with mesh alignment and tensor storage support
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
DensePose losses refactored into a modular registry with CSE and confidence-aware variants
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
DensePose modeling refactored with HRNet backbone and Test-Time Augmentation support
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
DensePose packaging, visualization, and training enhancements
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
DensePose utility module modernization and type annotation updates
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
DensePose visualizers split into specialized modules and updated to support CSE and texture transfer
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
Detectron2 v0.6 release with PyTorch 1.8+ support and AMD ROCm compatibility
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
Detectron2 version updated to 0.6
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
Enhanced box mode support and structure tracing compatibility
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
Enhanced distributed training, checkpointing, and training loop control
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
Enhanced optimizer configuration and gradient clipping support
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
Evaluation speed, API, and rotated box support
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
Improved accuracy and stability for rotated box IoU calculations
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
Improved checkpoint loading reliability and logging in distributed training
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
Introduce mmdetection wrapper and enhance model scriptability
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
New RandomSubsetTrainingSampler and updated RepeatFactorTrainingSampler API
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
New panoptic segmentation config and empty annotation filtering disabled
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
ROI heads refactored for TorchScript support and configurability
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
ROIAlignRotated updated for modern PyTorch API and ROCm support
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
RPN proposal generation refactored for TorchScript compatibility and robustness
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
Refactor DensePose engine with distributed evaluation and mesh alignment support
The DensePose engine module has been restructured to support more flexible evaluation workflows. A new \Trainer\ class extends \DefaultTrainer\ to explicitly pass the model's embedder to evaluators, enabling accurate evaluation for models using Continuous Semantic Embeddings (CSE). The evaluation logic now supports distributed inference via a new \DENSEPOSE\_EVALUATION.DISTRIBUTED\_INFERENCE\ configuration flag and allows specifying a minimum IoU threshold (\DENSEPOSE\_EVALUATION.MIN\_IOU\_THRESHOLD\) for metrics. Additionally, the system now supports evaluating mesh alignment (\DENSEPOSE\_EVALUATION.EVALUATE\_MESH\_ALIGNMENT\) and uses a unified \Detectron2COCOEvaluatorAdapter\ for both COCO and LVIS datasets to ensure compatible metric reporting.
projects/DensePose/densepose/engine · high confidence
Refactor data augmentation system with new Augmentation API and expanded transforms
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
Rotated NMS now supports AMD ROCm and uses double-precision IoU thresholds
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
TridentNet backbone refactoring and API alignment
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
TridentNet training script updated and documentation refreshed
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
Updated developer linting tools and test script behavior
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
Test coverage
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.
Dependencies
Update documentation build dependencies
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 cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 58 → 57 (-0.8)
- Rubric changed (rubric-2026.11.1 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 71 → 66 (-5.4)
- Architecture 83 → 86 (+2.7)
- Maturity 54 → 56 (+2.0)
- Readiness 53 → 51 (-1.7)
- Security 69 → 69 (+0.0)
Resolved (9)
- Duplicated block (11–12 lines × 2) (projects/PointRend/point_rend/mask_head.py)
- Duplicated block (16 lines × 2) (detectron2/layers/losses.py)
- Duplicated block (2–20 lines × 3) (detectron2/checkpoint/c2_model_loading.py)
- Duplicated block (5 lines × 2) (detectron2/checkpoint/c2_model_loading.py)
- Duplicated block (5 lines × 2) (detectron2/checkpoint/c2_model_loading.py)
- Further sole-owners (lower concentration)
- Most significant orphaned file (detectron2/utils/visualizer.py)
- Off-boarding risk: anonymized user #1
- Projects may be oversized for their cohesion
New (118)
- Edited copies of one member (3 members, 62+ corresponding lines) (detectron2/modeling/backbone/resnet.py)
- Edited copies of one member (3 members, 8+ corresponding lines) (projects/DensePose/densepose/evaluation/densepose_coco_evaluation.py)
- Edited copies of one member (4 members, 13+ corresponding lines) (detectron2/modeling/meta_arch/semantic_seg.py)
- Edited copies of one member (4 members, 15+ corresponding lines) (detectron2/structures/boxes.py)
- Edited copy of a member (10 corresponding lines) (detectron2/data/datasets/lvis.py)
- Edited copy of a member (10 corresponding lines) (detectron2/layers/deform_conv.py)
- Edited copy of a member (10 corresponding lines) (detectron2/modeling/meta_arch/fcos.py)
- Edited copy of a member (10 corresponding lines) (projects/Panoptic-DeepLab/panoptic_deeplab/panoptic_seg.py)
- Edited copy of a member (106 corresponding lines) (detectron2/evaluation/coco_evaluation.py)
- Edited copy of a member (11 corresponding lines) (detectron2/modeling/proposal_generator/rpn.py)
- Edited copy of a member (11 corresponding lines) (tools/analyze_model.py)
- Edited copy of a member (12 corresponding lines) (detectron2/engine/hooks.py)
- Edited copy of a member (12 corresponding lines) (detectron2/modeling/meta_arch/rcnn.py)
- Edited copy of a member (12 corresponding lines) (projects/DensePose/densepose/modeling/losses/embed_utils.py)
- Edited copy of a member (13 corresponding lines) (detectron2/modeling/anchor_generator.py)
- Edited copy of a member (13 corresponding lines) (detectron2/structures/boxes.py)
- Edited copy of a member (13 corresponding lines) (projects/DensePose/densepose/modeling/cse/vertex_direct_embedder.py)
- Edited copy of a member (14 corresponding lines) (detectron2/modeling/meta_arch/fcos.py)
- Edited copy of a member (14 corresponding lines) (detectron2/modeling/roi_heads/cascade_rcnn.py)
- Edited copy of a member (14 corresponding lines) (projects/DensePose/densepose/engine/trainer.py)
- …and 98 more
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
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.
About this page
- The score is its most recent published measurement, taken on 15 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 247691a1c292654867deb35cabb27f18d75a1363 — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.73+preprod-52de90b74216.