CenterNet

https://github.com/xingyizhou/centernet
Admin
CenterNet is an object detection framework that detects objects as points at their bounding box...
Tokens:12,105
Snippets:119
Trust Score:8.6
License:MIT
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install COCOAPI

Source: https://github.com/xingyizhou/centernet/blob/master/readme/INSTALL.md

Clone and install the COCOAPI library required for dataset evaluation.

```bash
# COCOAPI=/path/to/clone/cocoapi
git clone https://github.com/cocodataset/cocoapi.git $COCOAPI
cd $COCOAPI/PythonAPI
make
python setup.py install --user
```

--------------------------------

### Install Requirements

Source: https://github.com/xingyizhou/centernet/blob/master/readme/INSTALL.md

Install Python dependencies listed in the requirements file.

```bash
pip install -r requirements.txt
```

--------------------------------

### Dataset Initialization File Example

Source: https://github.com/xingyizhou/centernet/blob/master/readme/DEVELOP.md

Template for creating a dataset initialization file. Typically involves copying an existing file (e.g., coco.py) and modifying category information and annotation paths.

```python
src/lib/datasets/dataset/coco.py
```

--------------------------------

### Install CenterNet with Conda

Source: https://context7.com/xingyizhou/centernet/llms.txt

Sets up the CenterNet environment using conda, installs PyTorch, clones the repository, and installs necessary dependencies including the COCO API and deformable convolutions.

```bash
conda create --name CenterNet python=3.6
conda activate CenterNet

conda install pytorch=0.4.1 torchvision -c pytorch

CenterNet_ROOT=/path/to/clone/CenterNet
git clone https://github.com/xingyizhou/CenterNet $CenterNet_ROOT

git clone https://github.com/cocodataset/cocoapi.git
cd cocoapi/PythonAPI
make
python setup.py install --user

cd $CenterNet_ROOT
pip install -r requirements.txt

cd $CenterNet_ROOT/src/lib/models/networks/DCNv2
./make.sh

cd $CenterNet_ROOT/src/lib/external
make
```

--------------------------------

### Build DCN V2

Source: https://github.com/xingyizhou/centernet/blob/master/src/lib/models/networks/DCNv2/README.md

Use this script to build the DCN V2 library. After building, run the Python script to execute examples and perform gradient checks.

```bash
./make.sh         # build
python test.py    # run examples and gradient check 
```

--------------------------------

### Convert KITTI to COCO Format

Source: https://github.com/xingyizhou/centernet/blob/master/readme/DEVELOP.md

Example script for converting KITTI dataset annotations to COCO format. This is a prerequisite for adding a new dataset.

```python
src/tools/convert_kitti_to_coco.py
```

--------------------------------

### Deformable ROI Pooling Example

Source: https://github.com/xingyizhou/centernet/blob/master/src/lib/models/networks/DCNv2/README.md

Shows how to implement deformable ROI pooling using DCN V2. This requires input data, batch indices, and ROI coordinates, all on the CUDA device.

```python
from dcn_v2 import DCNPooling
input = torch.randn(2, 32, 64, 64).cuda()
batch_inds = torch.randint(2, (20, 1)).cuda().float()
x = torch.randint(256, (20, 1)).cuda().float()
y = torch.randint(256, (20, 1)).cuda().float()
w = torch.randint(64, (20, 1)).cuda().float()
h = torch.randint(64, (20, 1)).cuda().float()
rois = torch.cat((batch_inds, x, y, x + w, y + h), dim=1)

# mdformable pooling (V2)
# wrap all things (offset and mask) in DCNPooling
dpooling = DCNPooling(spatial_scale=1.0 / 4,
 pooled_size=7,
 output_dim=32,
 no_trans=False,
 group_size=1,
 trans_std=0.1).cuda()

dout = dpooling(input, rois)
```

--------------------------------

### Deformable Convolution Example

Source: https://github.com/xingyizhou/centernet/blob/master/src/lib/models/networks/DCNv2/README.md

Demonstrates how to use the DCN V2 deformable convolution layer. Ensure DCN V2 is imported and the input tensor is on the CUDA device.

```python
from dcn_v2 import DCN
input = torch.randn(2, 64, 128, 128).cuda()
# wrap all things (offset and mask) in DCN
dcn = DCN(64, 64, kernel_size=(3,3), stride=1, padding=1, deformable_groups=2).cuda()
output = dcn(input)
print(output.shape)
```

--------------------------------

### Install PyTorch and Patch cuDNN

Source: https://github.com/xingyizhou/centernet/blob/master/readme/INSTALL.md

Install PyTorch v0.4.1 and apply a patch to disable cuDNN batch normalization to avoid known issues.

```bash
conda install pytorch=0.4.1 torchvision -c pytorch
```

```bash
# PYTORCH=/path/to/pytorch # usually ~/anaconda3/envs/CenterNet/lib/python3.6/site-packages/
# for pytorch v0.4.0
sed -i "1194s/torch\.backends\.cudnn\.enabled/False/g" ${PYTORCH}/torch/nn/functional.py
# for pytorch v0.4.1
sed -i "1254s/torch\.backends\.cudnn\.enabled/False/g" ${PYTORCH}/torch/nn/functional.py
```

--------------------------------

### Register and Train Custom Dataset

Source: https://context7.com/xingyizhou/centernet/llms.txt

Steps to register the dataset in the factory and launch training.

```bash
# Step 3: Register in dataset_factory.py
# Add to src/lib/datasets/dataset_factory.py:
# from .dataset.custom import CUSTOM
# dataset_factory = {
#     'coco': COCO,
#     'custom': CUSTOM,  # Add this line
#     ...
# }

# Step 4: Train on custom dataset
# python main.py ctdet --exp_id custom_dla --dataset custom --num_classes 2 ...
```

--------------------------------

### Run CenterNet Webcam Object Detection Demo

Source: https://github.com/xingyizhou/centernet/blob/master/README.md

Use this command for real-time object detection using a webcam feed. The specified model path must be correct.

```bash
python demo.py ctdet --demo webcam --load_model ../models/ctdet_coco_dla_2x.pth
```

--------------------------------

### Download and Prepare Pascal VOC

Source: https://github.com/xingyizhou/centernet/blob/master/readme/DATA.md

Automated script to download and prepare Pascal VOC data.

```bash
cd $CenterNet_ROOT/tools/
bash get_pascal_voc.sh
```

--------------------------------

### Run CenterNet Object Detection Demo

Source: https://github.com/xingyizhou/centernet/blob/master/README.md

Execute this command to perform object detection on images, folders, or videos. Ensure models are downloaded and placed in the correct directory.

```bash
python demo.py ctdet --demo /path/to/image/or/folder/or/video --load_model ../models/ctdet_coco_dla_2x.pth
```

--------------------------------

### Run CenterNet Human Pose Estimation Demo

Source: https://context7.com/xingyizhou/centernet/llms.txt

Executes the CenterNet multi-person human pose estimation demo (multi_pose) on images, videos, or webcam. Requires a specific pre-trained model.

```bash
cd $CenterNet_ROOT/src
python demo.py multi_pose --demo ../images/ \
    --load_model ../models/multi_pose_dla_3x.pth
```

```bash
python demo.py multi_pose --demo /path/to/video.mp4 \
    --load_model ../models/multi_pose_dla_3x.pth
```

```bash
python demo.py multi_pose --demo webcam \
    --load_model ../models/multi_pose_dla_3x.pth
```

```bash
python demo.py multi_pose --demo ../images/ \
    --load_model ../models/multi_pose_dla_3x.pth \
    --flip_test
```

```bash
python demo.py multi_pose --demo ../images/ \
    --load_model ../models/multi_pose_dla_3x.pth \
    --debug 2
```

--------------------------------

### Train Object Detection Models

Source: https://context7.com/xingyizhou/centernet/llms.txt

Configure and execute training runs with various hardware and hyperparameter settings.

```bash
cd $CenterNet_ROOT/src

# Train COCO detection with DLA-34 on 2 GPUs (default schedule)
python main.py ctdet --exp_id coco_dla \
    --batch_size 32 --master_batch 15 \
    --lr 1.25e-4 --gpus 0,1

# Train on single GPU with smaller batch size
python main.py ctdet --exp_id coco_dla_1gpu \
    --batch_size 16 --lr 0.625e-4 --gpus 0

# Train with different backbone (ResNet-18)
python main.py ctdet --exp_id coco_res18 \
    --arch resdcn_18 \
    --batch_size 32 --lr 1.25e-4 --gpus 0,1

# Resume interrupted training
python main.py ctdet --exp_id coco_dla \
    --batch_size 32 --lr 1.25e-4 --gpus 0,1 \
    --resume

# Train with custom number of epochs and learning rate schedule
python main.py ctdet --exp_id coco_dla_custom \
    --batch_size 32 --lr 1.25e-4 --gpus 0,1 \
    --num_epochs 230 --lr_step 180,210
```

--------------------------------

### CenterNet Configuration Options

Source: https://context7.com/xingyizhou/centernet/llms.txt

Reference for command-line arguments used to control model architecture, training, and inference.

```bash
# Task options
--task              # ctdet | ddd | multi_pose | exdet

# Model architecture
--arch              # dla_34 | hourglass | res_18 | res_101 | resdcn_18 | resdcn_101
--head_conv         # Conv channels for output head (256 for dla, 64 for resnet)
--down_ratio        # Output stride, default=4

# Input settings
--input_res         # Input resolution (default from dataset)
--input_h           # Input height
--input_w           # Input width

# Training parameters
--lr                # Learning rate (default: 1.25e-4 for batch 32)
--lr_step           # Epochs to drop lr (default: 90,120)
--num_epochs        # Total training epochs (default: 140)
--batch_size        # Batch size (default: 32)
--gpus              # GPU ids (-1 for CPU)

# Test augmentation
--flip_test         # Enable flip augmentation
--test_scales       # Multi-scale test (e.g., 0.5,0.75,1,1.25,1.5)
--keep_res          # Keep original resolution
--fix_res           # Fix resolution to input_res

# Detection settings
--K                 # Max detections per image (default: 100)
--vis_thresh        # Visualization threshold (default: 0.3)
--nms               # Apply NMS in testing

# Loss weights (ctdet)
--hm_weight         # Heatmap loss weight (default: 1)
--wh_weight         # Size regression weight (default: 0.1)
--off_weight        # Offset loss weight (default: 1)

# Dataset
--dataset           # coco | kitti | pascal | coco_hp
--data_dir          # Data directory path

# Experiment
--exp_id            # Experiment identifier
--load_model        # Path to pretrained model
--resume            # Resume training from last checkpoint
--debug             # Debug level (0-4)
```

--------------------------------

### Benchmark KITTI 3D Detection

Source: https://context7.com/xingyizhou/centernet/llms.txt

Compile the evaluation tool and run 3D bounding box detection on KITTI splits.

```bash
cd $CenterNet_ROOT/src

# First compile the KITTI evaluation tool
cd $CenterNet_ROOT/src/tools/kitti_eval
g++ -o evaluate_object_3d_offline evaluate_object_3d_offline.cpp -O3

# Evaluate 3D detection on KITTI 3DOP split
cd $CenterNet_ROOT/src
python test.py ddd --exp_id 3dop --dataset kitti \
    --kitti_split 3dop \
    --load_model ../models/ddd_3dop.pth

# Evaluate on SubCNN split
python test.py ddd --exp_id subcnn --dataset kitti \
    --kitti_split subcnn \
    --load_model ../models/ddd_sub.pth
```

--------------------------------

### Perform Pose Estimation

Source: https://context7.com/xingyizhou/centernet/llms.txt

Initialize a pose detector and process keypoint results.

```python
# For pose estimation, initialize with multi_pose task
POSE_MODEL_PATH = '/path/to/models/multi_pose_dla_3x.pth'
opt_pose = opts().init('multi_pose --load_model {}'.format(POSE_MODEL_PATH).split(' '))
pose_detector = detector_factory[opt_pose.task](opt_pose)

ret_pose = pose_detector.run(image_path)
pose_results = ret_pose['results']

# Pose results format: {1: [[x1, y1, x2, y2, score, kp1_x, kp1_y, ..., kp17_x, kp17_y], ...]}
for bbox_and_kps in pose_results[1]:
    bbox = bbox_and_kps[:4]
    score = bbox_and_kps[4]
    keypoints = bbox_and_kps[5:39]  # 17 keypoints x 2 (x, y)
    if score > 0.3:
        print(f"Person: bbox={bbox}, score={score:.3f}")
        print(f"Keypoints: {keypoints}")
```

--------------------------------

### Add New Task Files

Source: https://github.com/xingyizhou/centernet/blob/master/readme/DEVELOP.md

Directories where files specifying data generation during training, training targets, and testing should be added for new tasks.

```python
src/lib/datasets/sample/
```

```python
src/lib/datasets/trains/
```

```python
src/lib/datasets/detectors/
```

--------------------------------

### Create and Activate Conda Environment

Source: https://github.com/xingyizhou/centernet/blob/master/readme/INSTALL.md

Commands to initialize a dedicated Python 3.6 environment for CenterNet.

```bash
conda create --name CenterNet python=3.6
```

```bash
conda activate CenterNet
```

--------------------------------

### Run CenterNet Human Pose Estimation Demo

Source: https://github.com/xingyizhou/centernet/blob/master/README.md

Command to run human pose estimation for images, folders, videos, or webcam. Requires the appropriate pose estimation model.

```bash
python demo.py multi_pose --demo /path/to/image/or/folder/or/video/or/webcam --load_model ../models/multi_pose_dla_3x.pth
```

--------------------------------

### Import New Dataset

Source: https://github.com/xingyizhou/centernet/blob/master/readme/DEVELOP.md

Location to import your custom dataset initialization file within the dataset factory.

```python
src/lib/datasets/dataset_factory.py
```

--------------------------------

### Run KITTI evaluation

Source: https://github.com/xingyizhou/centernet/blob/master/src/tools/kitti_eval/README.md

Execute the compiled evaluation binary by providing the directories containing ground truth and result files.

```bash
./evaluate_object_3d_offline groundtruth_dir result_dir
```

--------------------------------

### Link KITTI Image Folder

Source: https://github.com/xingyizhou/centernet/blob/master/readme/DATA.md

Commands to create the required symbolic link for KITTI images.

```bash
cd ${CenterNet_ROOT}/data/kitti/
mkdir images
ln -s training/image_2 images/trainval
```

--------------------------------

### Resume Training

Source: https://github.com/xingyizhou/centernet/blob/master/readme/GETTING_STARTED.md

Use the `--resume` flag with the same command to resume a terminated training session. The system will automatically find the latest model with the specified `exp_id`.

```bash
python main.py ctdet --exp_id coco_dla --batch_size 32 --master_batch 15 --lr 1.25e-4  --gpus 0,1 --resume
```

--------------------------------

### Benchmark Pascal VOC

Source: https://context7.com/xingyizhou/centernet/llms.txt

Evaluate object detection performance on the Pascal VOC test2007 dataset.

```bash
cd $CenterNet_ROOT/src

# Evaluate on Pascal VOC with DLA backbone
python test.py ctdet --exp_id dla --dataset pascal \
    --load_model ../models/ctdet_pascal_dla.pth --flip_test

# With different input resolution (512x512)
python test.py ctdet --exp_id dla --dataset pascal \
    --load_model ../models/ctdet_pascal_dla_512.pth \
    --flip_test --input_res 512

# Using ResNet-101 backbone
python test.py ctdet --exp_id resdcn101 --dataset pascal \
    --arch resdcn_101 \
    --load_model ../models/ctdet_pascal_resdcn101_512.pth \
    --flip_test --input_res 512
```

--------------------------------

### Run CenterNet Object Detection Demo

Source: https://context7.com/xingyizhou/centernet/llms.txt

Executes the CenterNet object detection demo (ctdet) on images, image folders, videos, or webcam feeds. Requires downloading a pre-trained model.

```bash
cd $CenterNet_ROOT/src
python demo.py ctdet --demo ../images/17790319373_bd19b24cfc_k.jpg \
    --load_model ../models/ctdet_coco_dla_2x.pth
```

```bash
python demo.py ctdet --demo ../images/ \
    --load_model ../models/ctdet_coco_dla_2x.pth
```

```bash
python demo.py ctdet --demo /path/to/video.mp4 \
    --load_model ../models/ctdet_coco_dla_2x.pth
```

```bash
python demo.py ctdet --demo webcam \
    --load_model ../models/ctdet_coco_dla_2x.pth
```

```bash
python demo.py ctdet --demo ../images/ \
    --load_model ../models/ctdet_coco_dla_2x.pth \
    --debug 2
```

```bash
python demo.py ctdet --demo ../images/ \
    --load_model ../models/ctdet_coco_dla_2x.pth \
    --flip_test
```

--------------------------------

### Add New Model Architecture

Source: https://github.com/xingyizhou/centernet/blob/master/readme/DEVELOP.md

Location to add your custom model file. The model should accept a 'heads' dictionary specifying output names and channels, and return a list of dictionaries.

```python
src/lib/models/networks/
```

--------------------------------

### Integrate CenterNet Python API

Source: https://context7.com/xingyizhou/centernet/llms.txt

Demonstrates how to use CenterNet as a Python library for object detection or pose estimation. Requires adding the CenterNet 'src/lib' directory to the Python path.

```python
import sys
import cv2

# Add CenterNet to path
CENTERNET_PATH = '/path/to/CenterNet/src/lib/'
sys.path.insert(0, CENTERNET_PATH)

from detectors.detector_factory import detector_factory
from opts import opts

# Initialize detector for object detection
MODEL_PATH = '/path/to/models/ctdet_coco_dla_2x.pth'
TASK = 'ctdet'  # 'ctdet' for detection, 'multi_pose' for pose estimation

# Parse options and create detector
opt = opts().init('{} --load_model {}'.format(TASK, MODEL_PATH).split(' '))
detector = detector_factory[opt.task](opt)

# Run detection on image path
image_path = '/path/to/image.jpg'
ret = detector.run(image_path)
results = ret['results']

```

--------------------------------

### Clone CenterNet Repository

Source: https://github.com/xingyizhou/centernet/blob/master/readme/INSTALL.md

Clone the project repository to a local directory.

```bash
CenterNet_ROOT=/path/to/clone/CenterNet
git clone https://github.com/xingyizhou/CenterNet $CenterNet_ROOT
```

--------------------------------

### Compile NMS

Source: https://github.com/xingyizhou/centernet/blob/master/readme/INSTALL.md

Compile the NMS module for multi-scale testing or ExtremeNet usage.

```bash
cd $CenterNet_ROOT/src/lib/external
make
```

--------------------------------

### Run Inference and Access Timing

Source: https://context7.com/xingyizhou/centernet/llms.txt

Execute detection on an image and retrieve performance metrics.

```python
# Run detection on numpy array (BGR format)
image = cv2.imread('/path/to/image.jpg')
ret = detector.run(image)
results = ret['results']

# Access timing information
print(f"Total time: {ret['tot']:.3f}s")
print(f"Network time: {ret['net']:.3f}s")
print(f"Decode time: {ret['dec']:.3f}s")
print(f"Post-process time: {ret['post']:.3f}s")
```

--------------------------------

### Final KITTI Directory Structure

Source: https://github.com/xingyizhou/centernet/blob/master/readme/DATA.md

The final required directory structure for KITTI after conversion and linking.

```text
${CenterNet_ROOT}
|-- data
`-- |-- kitti
    `-- |-- annotations
        |   |-- kitti_3dop_train.json
        |   |-- kitti_3dop_val.json
        |   |-- kitti_subcnn_train.json
        |   |-- kitti_subcnn_val.json
        `-- images
            |-- trainval
            |-- test
```

--------------------------------

### Register New Model in Factory

Source: https://github.com/xingyizhou/centernet/blob/master/readme/DEVELOP.md

Location to register your new model architecture within the model factory.

```python
src/lib/models/model.py
```

--------------------------------

### Create and Load CenterNet Models

Source: https://context7.com/xingyizhou/centernet/llms.txt

Python code to create and load CenterNet models with different backbone architectures (DLA, Hourglass, ResNet) and heads for object detection, pose estimation, or 3D detection. Ensure the path to the CenterNet library is correctly added to sys.path.

```python
import sys
sys.path.insert(0, '/path/to/CenterNet/src/lib/')

from models.model import create_model, load_model

# Available architectures:
# - 'dla_34': DLA-34 with deformable convolutions (default, best speed-accuracy)
# - 'hourglass': Stacked Hourglass-104 (highest accuracy)
# - 'res_18', 'res_101': ResNet without deformable conv
# - 'resdcn_18', 'resdcn_101': ResNet with deformable conv
# - 'dlav0_34': DLA without deformable conv

# Define output heads for object detection
heads = {
    'hm': 80,    # heatmap for 80 COCO classes
    'wh': 2,     # width and height regression
    'reg': 2    # local offset regression
}

# Create model with DLA-34 backbone
model = create_model('dla_34', heads, head_conv=256)
print(f"Model parameters: {sum(p.numel() for p in model.parameters()):,}")

# Create model with Hourglass backbone
model_hg = create_model('hourglass', heads, head_conv=64)

# Create model with ResNet-101 + DCN
model_res = create_model('resdcn_101', heads, head_conv=64)

# Load pre-trained weights
model = load_model(model, '/path/to/model.pth')
model = model.cuda()
model.eval()

# Heads for pose estimation
pose_heads = {
    'hm': 1,       # person heatmap
    'wh': 2,       # bbox size
    'hps': 34,     # 17 keypoints x 2 (x, y offsets)
    'reg': 2,      # local offset
    'hm_hp': 17,   # keypoint heatmaps
    'hp_offset': 2 # keypoint local offsets
}

model_pose = create_model('dla_34', pose_heads, head_conv=256)

# Heads for 3D detection
ddd_heads = {
    'hm': 3,      # 3 classes (Car, Pedestrian, Cyclist)
    'dep': 1,     # depth
    'rot': 8,     # rotation (sin, cos for 2 bins x 2)
    'dim': 3,     # 3D dimensions (h, w, l)
    'wh': 2,      # 2D bbox size
    'reg': 2      # local offset
}

model_3d = create_model('dla_34', ddd_heads, head_conv=256)
```

--------------------------------

### KITTI Dataset Directory Structure

Source: https://github.com/xingyizhou/centernet/blob/master/readme/DATA.md

Expected directory layout for the KITTI dataset.

```text
${CenterNet_ROOT}
|-- data
`-- |-- kitti
    `-- |-- training
        |   |-- image_2
        |   |-- label_2
        |   |-- calib
        |-- ImageSets_3dop
        |   |-- test.txt
        |   |-- train.txt
        |   |-- val.txt
        |   |-- trainval.txt
        `-- ImageSets_subcnn
            |-- test.txt
            |-- train.txt
            |-- val.txt
            |-- trainval.txt
```

--------------------------------

### Visualize Heatmap Outputs in CenterNet

Source: https://github.com/xingyizhou/centernet/blob/master/README.md

Add the `--debug 2` flag to visualize heatmap outputs during demo execution. This helps in understanding the model's internal representations.

```bash
python demo.py ctdet --demo /path/to/image/or/folder/or/video --load_model ../models/ctdet_coco_dla_2x.pth --debug 2
```

--------------------------------

### Train Human Pose Estimation Model

Source: https://context7.com/xingyizhou/centernet/llms.txt

Commands for training multi-person pose estimation models on the COCO keypoints dataset. Includes options for a full schedule (2x) and a shorter schedule (1x). Ensure CenterNet root is set correctly.

```bash
cd $CenterNet_ROOT/src

# Train pose estimation with DLA backbone (fine-tune from detection model)
python main.py multi_pose --exp_id dla_pose \
    --batch_size 32 --lr 1.25e-4 --gpus 0,1,2,3,4,5,6,7 \
    --load_model ../models/ctdet_coco_dla_2x.pth \
    --num_epochs 320 --lr_step 270,300

# Train with shorter schedule (1x)
python main.py multi_pose --exp_id dla_pose_1x \
    --batch_size 32 --lr 1.25e-4 --gpus 0,1,2,3,4,5,6,7 \
    --load_model ../models/ctdet_coco_dla_2x.pth \
    --num_epochs 140 --lr_step 90,120
```

--------------------------------

### Pascal VOC Directory Structure

Source: https://github.com/xingyizhou/centernet/blob/master/readme/DATA.md

Expected directory layout for the Pascal VOC dataset.

```text
${CenterNet_ROOT}
|-- data
`-- |-- voc
    `-- |-- annotations
        |   |-- pascal_trainval0712.json
        |   |-- pascal_test2017.json
        |-- images
        |   |-- 000001.jpg
        |   ......
        `-- VOCdevkit
```

--------------------------------

### Train CenterNet on Pascal VOC

Source: https://context7.com/xingyizhou/centernet/llms.txt

Use this command to train the CenterNet object detection model on the Pascal VOC dataset. Adjust batch size, learning rate, GPUs, and training epochs as needed.

```bash
python main.py ctdet --exp_id pascal_dla \
    --dataset pascal \
    --batch_size 32 --lr 1.25e-4 --gpus 0,1 \
    --num_epochs 70 --lr_step 45,60
```

--------------------------------

### Enable Flip Test in CenterNet

Source: https://github.com/xingyizhou/centernet/blob/master/README.md

Append the `--flip_test` flag to the demo command to enable flip testing, which can sometimes improve detection accuracy.

```bash
python demo.py ctdet --demo /path/to/image/or/folder/or/video --load_model ../models/ctdet_coco_dla_2x.pth --flip_test
```

--------------------------------

### Implement Custom Dataset Class

Source: https://context7.com/xingyizhou/centernet/llms.txt

Define a new dataset class inheriting from the base structure to load custom data.

```python
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import pycocotools.coco as coco
from pycocotools.cocoeval import COCOeval
import numpy as np
import os

class CUSTOM:
    num_classes = 2  # Number of your classes
    default_resolution = [512, 512]
    mean = np.array([0.408, 0.447, 0.470], dtype=np.float32)
    std = np.array([0.289, 0.274, 0.278], dtype=np.float32)

    def __init__(self, opt, split):
        super(CUSTOM, self).__init__()
        self.data_dir = os.path.join(opt.data_dir, 'custom')
        self.img_dir = os.path.join(self.data_dir, 'images')

        if split == 'train':
            self.annot_path = os.path.join(self.data_dir, 'annotations', 'train.json')
        else:
            self.annot_path = os.path.join(self.data_dir, 'annotations', 'val.json')

        self.coco = coco.COCO(self.annot_path)
        self.images = self.coco.getImgIds()
        self.num_samples = len(self.images)

    # ... implement other required methods similar to coco.py
```

--------------------------------

### Compile KITTI Evaluation Tool

Source: https://github.com/xingyizhou/centernet/blob/master/readme/GETTING_STARTED.md

Compile the C++ evaluation tool for the KITTI dataset. This is a prerequisite for running KITTI evaluations.

```bash
cd CenterNet_ROOT/src/tools/kitti_eval
g++ -o evaluate_object_3d_offline evaluate_object_3d_offline.cpp -O3
```

--------------------------------

### Evaluate COCO Human Pose Estimation with DLA

Source: https://github.com/xingyizhou/centernet/blob/master/readme/GETTING_STARTED.md

Run this command to evaluate COCO human pose estimation using the DLA architecture. Includes options for flip testing.

```bash
python test.py multi_pose --exp_id dla --keep_res --load_model ../models/multi_pose_dla_3x.pth --flip_test
```

--------------------------------

### Evaluate Pascal VOC Object Detection

Source: https://github.com/xingyizhou/centernet/blob/master/readme/GETTING_STARTED.md

Evaluate object detection performance on the Pascal VOC 2007 test set using a DLA model. Note that resolution is fixed during testing.

```bash
python test.py ctdet --exp_id dla --dataset pascal --load_model ../models/ctdet_pascal_dla.pth --flip_test
```

--------------------------------

### Process Detection Results

Source: https://context7.com/xingyizhou/centernet/llms.txt

Iterate through detection results to filter by confidence threshold and print bounding box coordinates.

```python
# Results format: {category_id: [[x1, y1, x2, y2, score], ...]}
for category_id, detections in results.items():
    for det in detections:
        x1, y1, x2, y2, score = det[:5]
        if score > 0.3:  # confidence threshold
            print(f"Category {category_id}: bbox=({x1:.1f}, {y1:.1f}, {x2:.1f}, {y2:.1f}), score={score:.3f}")
```

--------------------------------

### Integrate CenterNet into Custom Python Projects

Source: https://github.com/xingyizhou/centernet/blob/master/README.md

This Python code demonstrates how to import and use CenterNet programmatically within your own projects. Ensure the CENTERNET_PATH and MODEL_PATH are correctly set.

```python
import sys
CENTERNET_PATH = '/path/to/CenterNet/src/lib/'
sys.path.insert(0, CENTERNET_PATH)

from detectors.detector_factory import detector_factory
from opts import opts

MODEL_PATH = '/path/to/model'
TASK = 'ctdet' # or 'multi_pose' for human pose estimation
opt = opts().init('{} --load_model {}'.format(TASK, MODEL_PATH).split(' '))
detector = detector_factory[opt.task](opt)

img = image/or/path/to/your/image/
ret = detector.run(img)['results']

```

--------------------------------

### Evaluate COCO Human Pose Estimation with Hourglass

Source: https://github.com/xingyizhou/centernet/blob/master/readme/GETTING_STARTED.md

Evaluate COCO human pose estimation using the Hourglass architecture. This command includes options for flip testing.

```bash
python test.py multi_pose --exp_id hg --arch hourglass --keep_res --load_model ../models/multi_pose_dla_3x.pth --flip_test
```

--------------------------------

### Generate Extreme Point Annotations

Source: https://github.com/xingyizhou/centernet/blob/master/readme/DATA.md

Script to generate extreme point annotations from segmentation masks for ExtremeNet training.

```bash
cd $CenterNet_ROOT/tools/
python gen_coco_extreme_points.py
```

--------------------------------

### Compile Deformable Convolutional Layers

Source: https://github.com/xingyizhou/centernet/blob/master/readme/INSTALL.md

Compile the DCNv2 module required for the network architecture.

```bash
cd $CenterNet_ROOT/src/lib/models/networks/DCNv2
./make.sh
```

--------------------------------

### Benchmark COCO Models

Source: https://context7.com/xingyizhou/centernet/llms.txt

Evaluate pre-trained models on the COCO validation set using various test-time augmentations.

```bash
cd $CenterNet_ROOT/src

# Basic evaluation with DLA-34 backbone (37.4 AP)
python test.py ctdet --exp_id coco_dla --keep_res \
    --load_model ../models/ctdet_coco_dla_2x.pth

# With flip test augmentation (39.2 AP)
python test.py ctdet --exp_id coco_dla --keep_res \
    --load_model ../models/ctdet_coco_dla_2x.pth \
    --flip_test

# Multi-scale test augmentation (41.7 AP)
python test.py ctdet --exp_id coco_dla --keep_res \
    --load_model ../models/ctdet_coco_dla_2x.pth \
    --flip_test --test_scales 0.5,0.75,1,1.25,1.5

# Evaluation with Hourglass backbone (40.3 / 42.2 / 45.1 AP)
python test.py ctdet --exp_id coco_hg --arch hourglass --fix_res \
    --load_model ../models/ctdet_coco_hg.pth

# Human pose estimation evaluation (58.9 AP with DLA)
python test.py multi_pose --exp_id dla --keep_res \
    --load_model ../models/multi_pose_dla_3x.pth --flip_test

# Human pose with Hourglass (64.0 AP)
python test.py multi_pose --exp_id hg --arch hourglass --keep_res \
    --load_model ../models/multi_pose_hg_3x.pth --flip_test
```

--------------------------------

### Convert Hourglass Weight Format

Source: https://github.com/xingyizhou/centernet/blob/master/readme/GETTING_STARTED.md

Convert the pre-trained ExtremeNet model weights to the format required for HourglassNet training. This script is necessary before loading the converted model for fine-tuning.

```python
python convert_hourglass_weight.py
```

--------------------------------

### Evaluate KITTI 3D Object Detection

Source: https://github.com/xingyizhou/centernet/blob/master/readme/GETTING_STARTED.md

Evaluate 3D object detection on the KITTI dataset for the 3DOP split using a pre-trained model. For the subcnn split, adjust the `--kitti_split` and model path accordingly.

```bash
python test.py ddd --exp_id 3dop --dataset kitti --kitti_split 3dop --load_model ../models/ddd_3dop.pth
```

--------------------------------

### Train COCO Object Detection with DLA on 2 GPUs

Source: https://github.com/xingyizhou/centernet/blob/master/readme/GETTING_STARTED.md

Train the COCO object detection model with a DLA architecture on 2 GPUs. Adjust `--batch_size` and `--lr` according to the number of GPUs and linear learning rate scaling rules.

```bash
python main.py ctdet --exp_id coco_dla --batch_size 32 --master_batch 15 --lr 1.25e-4  --gpus 0,1
```

--------------------------------

### Evaluate COCO Object Detection with Hourglass Net

Source: https://github.com/xingyizhou/centernet/blob/master/readme/GETTING_STARTED.md

Evaluate COCO object detection using the Hourglass network architecture. Ensure the `--fix_res` flag is used for fixed resolution testing.

```bash
python test.py ctdet --exp_id coco_hg --arch hourglass --fix_res --load_model ../models/ctdet_coco_hg.pth
```

--------------------------------

### Evaluate COCO Object Detection with DLA

Source: https://github.com/xingyizhou/centernet/blob/master/readme/GETTING_STARTED.md

Use this command to evaluate COCO object detection with a DLA architecture. The `--keep_res` flag preserves original image resolution; omitting it resizes images to 512x512. Flip and multi-scale testing can be enabled with additional flags.

```bash
python test.py ctdet --exp_id coco_dla --keep_res --load_model ../models/ctdet_coco_dla_2x.pth
```

```bash
python test.py ctdet --exp_id coco_dla --keep_res --load_model ../models/ctdet_coco_dla_2x.pth --flip_test
```

```bash
python test.py ctdet --exp_id coco_dla --keep_res --load_model ../models/ctdet_coco_dla_2x.pth --flip_test --test_scales 0.5,0.75,1,1.25,1.5
```

--------------------------------

### COCO Dataset Directory Structure

Source: https://github.com/xingyizhou/centernet/blob/master/readme/DATA.md

Expected directory layout for the COCO dataset within the CenterNet root folder.

```text
${CenterNet_ROOT}
|-- data
`-- |-- coco
    `-- |-- annotations
        |   |-- instances_train2017.json
        |   |-- instances_val2017.json
        |   |-- person_keypoints_train2017.json
        |   |-- person_keypoints_val2017.json
        |   |-- image_info_test-dev2017.json
        |---|-- train2017
        |---|-- val2017
        `---|-- test2017
```

--------------------------------

### Convert Custom Dataset to COCO Format

Source: https://context7.com/xingyizhou/centernet/llms.txt

Script to convert custom annotations into the COCO JSON format required by CenterNet.

```python
import json
import os

def convert_custom_to_coco(data_dir, output_path):
    """Convert custom dataset annotations to COCO format."""

    coco_output = {
        "images": [],
        "annotations": [],
        "categories": [
            {"id": 1, "name": "class1"},
            {"id": 2, "name": "class2"},
            # Add your categories
        ]
    }

    annotation_id = 1
    for img_id, img_file in enumerate(os.listdir(data_dir)):
        if not img_file.endswith('.jpg'):
            continue

        # Add image entry
        coco_output["images"].append({
            "id": img_id,
            "file_name": img_file,
            "width": 1920,  # Your image width
            "height": 1080  # Your image height
        })

        # Add annotations (load from your format)
        # Example: bbox = [x, y, width, height]
        coco_output["annotations"].append({
            "id": annotation_id,
            "image_id": img_id,
            "category_id": 1,
            "bbox": [100, 100, 200, 150],  # [x, y, w, h]
            "area": 200 * 150,
            "iscrowd": 0
        })
        annotation_id += 1

    with open(output_path, 'w') as f:
        json.dump(coco_output, f)
```

--------------------------------

### Verify 3D Detection Output Shape

Source: https://context7.com/xingyizhou/centernet/llms.txt

Check the shape of the 3D detection output tensor.

```python
print(f"3D detection shape: {ddd_detections.shape}")
```

--------------------------------

### Decode Human Pose Estimation Outputs

Source: https://context7.com/xingyizhou/centernet/llms.txt

Python code to decode network outputs for multi-person pose estimation using `multi_pose_decode`. This function converts heatmap, regression, and offset predictions into bounding boxes and keypoint coordinates. Ensure the path to the CenterNet library is correctly added to sys.path.

```python
import torch
sys.path.insert(0, '/path/to/CenterNet/src/lib/')

from models.decode import ctdet_decode, multi_pose_decode, ddd_decode

# Example: Pose estimation decoding
hm_pose = torch.randn(batch_size, 1, height, width).sigmoid().cuda()  # person heatmap
wh_pose = torch.randn(batch_size, 2, height, width).cuda()
kps = torch.randn(batch_size, 34, height, width).cuda()  # 17 keypoints x 2
hm_hp = torch.randn(batch_size, 17, height, width).sigmoid().cuda()  # keypoint heatmaps
hp_offset = torch.randn(batch_size, 2, height, width).cuda()

pose_detections = multi_pose_decode(
    hm_pose, wh_pose, kps,
    reg=reg, hm_hp=hm_hp, hp_offset=hp_offset, K=100
)
# Output shape: [batch, K, 40] -> [x1, y1, x2, y2, score, kp1_x, kp1_y, ..., kp17_x, kp17_y, class]

print(f"Pose detection shape: {pose_detections.shape}")
```

--------------------------------

### Decode Object Detection Outputs

Source: https://context7.com/xingyizhou/centernet/llms.txt

Python code to decode network outputs for object detection using `ctdet_decode`. This function converts heatmap, regression, and offset predictions into bounding boxes, scores, and class labels. Ensure the path to the CenterNet library is correctly added to sys.path.

```python
import torch
sys.path.insert(0, '/path/to/CenterNet/src/lib/')

from models.decode import ctdet_decode, multi_pose_decode, ddd_decode

# Example: Object detection decoding
# Network outputs (simulated)
batch_size = 1
num_classes = 80
height, width = 128, 128

hm = torch.randn(batch_size, num_classes, height, width).sigmoid().cuda()
wh = torch.randn(batch_size, 2, height, width).cuda()
reg = torch.randn(batch_size, 2, height, width).cuda()

# Decode detections (K=100 top detections)
detections = ctdet_decode(hm, wh, reg=reg, K=100)
# Output shape: [batch, K, 6] -> [x1, y1, x2, y2, score, class]

print(f"Detection shape: {detections.shape}")
det_np = detections[0].cpu().numpy()
for i in range(min(10, len(det_np))):
    x1, y1, x2, y2, score, cls = det_np[i]
    if score > 0.3:
        print(f"Detection {i}: class={int(cls)}, score={score:.3f}, bbox=({x1:.1f}, {y1:.1f}, {x2:.1f}, {y2:.1f})")
```

--------------------------------

### Decode 3D Detection Outputs

Source: https://context7.com/xingyizhou/centernet/llms.txt

Python code to decode network outputs for 3D object detection using `ddd_decode`. This function converts heatmap, rotation, depth, and dimension predictions into 3D bounding boxes. Ensure the path to the CenterNet library is correctly added to sys.path.

```python
import torch
sys.path.insert(0, '/path/to/CenterNet/src/lib/')

from models.decode import ctdet_decode, multi_pose_decode, ddd_decode

# Example: 3D detection decoding
hm_3d = torch.randn(batch_size, 3, height, width).sigmoid().cuda()  # 3 classes
rot = torch.randn(batch_size, 8, height, width).cuda()  # rotation
depth = torch.randn(batch_size, 1, height, width).sigmoid().cuda()  # depth
dim = torch.randn(batch_size, 3, height, width).cuda()  # 3D dimensions

ddd_detections = ddd_decode(hm_3d, rot, depth, dim, wh=wh, reg=reg, K=40)
```
Tokens:
Raw