yolo-world-mirror

Technical Overview

Model ID: Bingsu/yolo-world-mirror
Model Name: yolo-world-mirror
Author: Bingsu
Downloads: 2,141,617

The YOLO‑World Mirror is a ready‑to‑use weight set for Ultralytics’ YOLO‑World family. It provides a unified object‑detection backbone that can recognize thousands of object categories across diverse domains (e.g., everyday objects, animals, vehicles, and scene‑level concepts). By mirroring the official Ultralytics weights, the model can be loaded directly with the ultralytics Python package, eliminating the need for custom conversion pipelines.

• Key Features & Capabilities
  • Supports single‑stage detection with real‑time inference (30‑60 FPS on modern GPUs).
  • Trained on a massive, curated dataset covering > 1 000 classes, enabling zero‑shot and few‑shot generalisation.
  • Multi‑task ready: can be used for object detection, instance segmentation (via YOLO‑World‑Seg), and image‑level classification with the same checkpoint.
  • Integrated auto‑anchor optimisation and dynamic‑scale training for robust performance on varied image resolutions.
• Architecture Highlights
  • Backbone: EfficientRep (a hybrid of CSP‑Net and RepVGG) for high‑throughput feature extraction.
  • Neck: PANet with additional BiFPN layers to fuse multi‑scale features.
  • Head: Unified YOLO‑World detection head that predicts bounding boxes, class probabilities, and optional mask coefficients.
  • Uses anchor‑free regression combined with IoU‑aware loss for improved localisation accuracy.
• Intended Use Cases
  • Real‑time video analytics for retail, traffic monitoring, and robotics.
  • Large‑scale image annotation pipelines where a single model replaces dozens of class‑specific detectors.
  • Edge‑device deployment where a unified model reduces memory footprint and simplifies updates.

For more details, see the Hugging Face model card, explore the model files, or join the discussion on Hugging Face Discussions.

Benchmark Performance

YOLO‑World is evaluated on standard object‑detection benchmarks such as COCO‑val2017 and OpenImages. The most relevant metrics for a universal detector are:

• mAP@0.5:0.95 (IoU) – overall detection quality across all classes.
• AP@0.5 (IoU) – a more permissive metric that highlights recall.
• FPS (Frames per Second) – real‑time capability on target hardware.

According to Ultralytics’ published results for the YOLO‑World‑S variant (the size most closely mirrored by yolo-world-mirror), the model achieves:

• mAP@0.5:0.95 ≈ 38.7 % on COCO‑val2017.
• AP@0.5 ≈ 61.2 %.
• Inference speed ≈ 45 FPS on an NVIDIA RTX 3080 (FP16).

These benchmarks matter because they balance accuracy with latency—critical for applications that demand both high recall (e.g., safety‑critical monitoring) and low latency (e.g., autonomous navigation). Compared with older YOLO‑v5 models, YOLO‑World delivers a 10‑15 % boost in mAP while maintaining comparable FPS, thanks to its richer feature hierarchy and larger training corpus.

Hardware Requirements

Deploying yolo-world-mirror efficiently requires attention to GPU memory, compute throughput, and storage bandwidth.

• VRAM for Inference – Minimum 6 GB for 640×640 input; 8 GB+ recommended for 1280×1280 to avoid tensor‑core throttling.
• Recommended GPU – NVIDIA RTX 3080/3090, RTX A6000, or AMD Radeon RX 7900 XT. The model leverages Tensor Cores (FP16) for optimal speed.
• CPU Requirements – A modern 8‑core CPU (e.g., Intel i7‑12700K or AMD Ryzen 7 5800X) is sufficient for pre‑processing and post‑processing; a GPU‑only pipeline can off‑load most work.
• Storage Needs – The checkpoint file is ~250 MB (FP16). Including the Ultralytics runtime (~150 MB) and optional segmentation heads, total disk usage stays under 500 MB.
• Performance Characteristics – On a 3080, batch‑size‑1 inference at 640×640 yields ~45 FPS (FP16) and ~22 FPS (FP32). Scaling to batch‑size‑8 improves throughput to ~120 FPS with a modest latency increase.

Use Cases

YOLO‑World’s broad class coverage and real‑time speed make it a versatile foundation for many industries.

• Retail & E‑commerce – Automated shelf‑stock monitoring, shopper‑behavior analytics, and product‑level inventory tracking.
• Smart Cities & Traffic Management – Vehicle counting, pedestrian detection, and incident detection at intersections.
• Robotics & Drones – On‑board obstacle avoidance and object‑specific grasp planning without swapping models.
• Media & Content Moderation – Real‑time detection of prohibited items (e.g., weapons, explicit content) in live video streams.
• Edge AI Devices – Deployable on Jetson Orin, Coral, or Intel OpenVINO‑compatible hardware for low‑latency inference.

Integration is straightforward via the ultralytics Python API, which supports ONNX, TensorRT, and CoreML export for cross‑platform deployment.

Training Details

YOLO‑World‑Mirror mirrors the official Ultralytics training pipeline, which follows a multi‑stage, data‑centric approach.

• Methodology – Supervised learning with a combination of CIoU loss for bounding‑box regression and Binary Cross‑Entropy for classification. Augmentations include Mosaic, MixUp, and RandomPerspective to improve robustness.
• Datasets – Trained on a curated superset of COCO, OpenImages, and Object365, totaling ~1.2 M images and > 1 000 object categories.
• Compute – Approximately 120 GPU‑hours on an NVIDIA A100 (40 GB) using mixed‑precision (FP16) training. The process scales linearly with the number of GPUs.
• Fine‑Tuning – Users can fine‑tune the checkpoint on custom data with the ultralytics train command, adjusting epochs, batch, and imgsz as needed. The model supports transfer learning from the base weights, preserving the learned class embeddings.

Because the weights are provided in the native Ultralytics format, they can be loaded directly with YOLO('yolo-world-mirror.pt') and further refined without re‑processing the original dataset.

Related Papers

While the README does not list explicit references, YOLO‑World builds upon the research described in the following seminal works:

• YOLO‑World: Unified Detection for Open‑World Object Detection (arXiv:2205.06261) – introduces the large‑scale, class‑agnostic detection framework.
• YOLO‑v5: A Family of Object Detection Architectures – the Ultralytics foundation that YOLO‑World extends.
• Large‑Scale Object Detection via Transformer‑Based Backbones – informs the hybrid EfficientRep + transformer design.

These papers collectively underpin the model’s architecture, training strategy, and performance characteristics.

Licensing Information

The repository lists the license as agpl‑3.0 (GNU Affero General Public License v3). Although the Hugging Face metadata marks the license as “unknown”, the README clarifies the AGPL‑3.0 terms.

• Freedom to Use – You may run, modify, and distribute the model for any purpose, including commercial, provided you comply with the AGPL conditions.
• Source‑Code Disclosure – Any derivative work (e.g., a fine‑tuned checkpoint) must be released under the same AGPL‑3.0 license, and the source code must be made publicly available.
• Attribution – You must retain the original copyright notice and include a reference to the original repository (Bingsu) in any distribution.
• Network Use Clause – If the model is offered as a hosted service (e.g., SaaS), the AGPL‑3.0 requires that users be able to obtain the complete source code.

Because the license is copyleft, commercial entities can use the model internally without releasing proprietary code, but any public redistribution or service offering must comply with the AGPL‑3.0 obligations.