yolov3

Ultralytics YOLOv3 is a PyTorch implementation of the YOLOv3 (You Only Look Once, version 3) real-time object detection model. YOLOv3 frames detection as a single regression problem, predicting bounding boxes and class probabilities directly from full images in one forward pass — making it fast, accurate, and straightforward to train and deploy.

This repository packages the three classic YOLOv3 detection models — YOLOv3, YOLOv3-SPP, and YOLOv3-tiny — with training, validation, inference, and export tooling, and reuses shared utilities from the ultralytics package.

Find detailed guidance in the Ultralytics YOLOv3 Docs. Get support via GitHub Issues, and join the conversation on Discord, Reddit, and the Ultralytics Forums.

For commercial use, request an Enterprise License at Ultralytics Licensing.

Documentation

See the Ultralytics YOLOv3 Docs for full documentation. The quickstart examples below cover installation, inference, and training with this repository.

Install

Clone the repository and install the dependencies from requirements.txt in a Python>=3.8.0 environment with PyTorch>=1.8.

# Clone the YOLOv3 repository
git clone https://github.com/ultralytics/yolov3

# Navigate to the cloned directory
cd yolov3

# Install required packages
pip install -r requirements.txt

Inference with PyTorch Hub

Load YOLOv3 directly through PyTorch Hub. Weights download automatically on first use.

import torch

# Load a YOLOv3 model (choices: 'yolov3', 'yolov3_spp', 'yolov3_tiny')
model = torch.hub.load("ultralytics/yolov3", "yolov3", pretrained=True)

# Run inference on an image (local file, URL, PIL image, OpenCV frame, or numpy array)
results = model("https://ultralytics.com/images/zidane.jpg")

# Inspect the results
results.print()  # print detections to the console
results.show()  # display the annotated image
results.save()  # save the annotated image to runs/detect/exp

Inference with detect.py

detect.py runs inference on a wide range of sources, downloading models automatically and saving results to runs/detect.

…

Training

Train YOLOv3 on the COCO dataset. Models and datasets download automatically. Use the largest --batch-size your hardware allows.

# Train YOLOv3-tiny
python train.py --data coco.yaml --epochs 300 --weights '' --cfg yolov3-tiny.yaml --batch-size 64

# Train YOLOv3
python train.py --data coco.yaml --epochs 300 --weights '' --cfg yolov3.yaml --batch-size 32

# Train YOLOv3-SPP
python train.py --data coco.yaml --epochs 300 --weights '' --cfg yolov3-spp.yaml --batch-size 16

Validate accuracy with python val.py --weights yolov3.pt --data coco.yaml, and export to other formats (TorchScript, ONNX, OpenVINO, TensorRT, CoreML, and PaddlePaddle) with python export.py --weights yolov3.pt --include onnx.

Tutorials

These guides cover the shared Ultralytics training framework and apply to YOLOv3:

• Train Custom Data — train on your own dataset.
• Tips for Best Training Results — get the most out of training.
• Multi-GPU Training — scale training across GPUs.
• PyTorch Hub Loading — load models programmatically.
• Model Export — deploy to ONNX, TensorRT, CoreML, and more.
• Test-Time Augmentation (TTA) — improve accuracy at inference.
• Model Ensembling — combine models for better results.
• Hyperparameter Tuning — tune hyperparameters automatically.
• Transfer Learning with Frozen Layers — adapt pretrained models efficiently.

Architecture

YOLOv3 builds detection on a few core ideas that make it both accurate and fast:

• Darknet-53 backbone — a 53-layer convolutional feature extractor with residual (skip) connections, deeper and more accurate than the Darknet-19 backbone of YOLOv2 while staying efficient.
• Multi-scale detection — predictions are made at three feature-map scales using a feature-pyramid-style design (upsampling and concatenating earlier feature maps), so the model detects small, medium, and large objects well.
• Anchor boxes — boxes are predicted relative to dimension-cluster anchor priors, with three anchors per scale (nine total) and a sigmoid offset parameterization for stable training.
• Independent class prediction — each class is scored with an independent logistic classifier rather than a softmax, so one box can carry multiple non-mutually-exclusive labels.

The repository ships three variants of this architecture:

• YOLOv3 — the full Darknet-53 model; the best balance of speed and accuracy.
• YOLOv3-SPP — adds a Spatial Pyramid Pooling block that pools features at multiple kernel sizes for a larger effective receptive field and a small accuracy gain.
• YOLOv3-tiny — a compact backbone with detection at two scales, optimized for CPU and edge devices where speed matters most.

Models are defined declaratively in models/*.yaml and built by parse_model() in models/yolo.py, so the architecture can be inspected and modified without writing Python.

️ Pretrained Checkpoints

All three models are trained on COCO (80 classes) and download automatically from the YOLOv3 release assets on first use.

Model	Description
yolov3-tiny.pt	Lightweight two-scale model — the fastest option, ideal for CPU and edge devices.
yolov3.pt	The original Darknet-53 model — a strong balance of speed and accuracy.
yolov3-spp.pt	Adds Spatial Pyramid Pooling for a larger receptive field and improved accuracy.

Integrations

Ultralytics integrates with leading AI platforms to extend dataset labeling, training, visualization, and model management. Explore how partners such as Weights & Biases, Comet ML, Roboflow, and Intel OpenVINO can streamline your workflow at Ultralytics Integrations.

Why YOLOv3?

YOLOv3 was a landmark in real-time object detection and remains a dependable, well-understood baseline:

• Real-time single-stage detection — one forward pass produces all detections, with no separate region-proposal stage.
• Strong across object sizes — multi-scale predictions handle small, medium, and large objects.
• Multi-label friendly — independent logistic classifiers allow overlapping class labels.
• Simple and portable — a fully-convolutional design that trains and exports cleanly to many deployment formats.

For the broader family of Ultralytics YOLO models, see the Ultralytics repository.

☁️ Environments

Get started quickly with pre-configured environments. Click an icon below for setup details.

Contribute

Contributions are welcome! Please see the Contributing Guide to get started, and share your feedback through the Ultralytics Survey. Thank you to all our contributors!

License

Ultralytics offers two licensing options:

• AGPL-3.0 License: An OSI-approved open-source license ideal for research and collaboration. See the LICENSE file for details.
• Enterprise License: For commercial use, this license allows integration of Ultralytics software and models into commercial products without AGPL-3.0 obligations. Contact us via Ultralytics Licensing.

Contact

For bug reports and feature requests, please use GitHub Issues. For questions and discussion, join our Discord, Reddit, and the Ultralytics Forums.