yolov11s-warehouse-pallets-1280

YOLOv11 Warehouse Pallet Detector

A family of fine-tuned YOLOv11 models for real-time detection of pallets (wooden skid + stacked products) in warehouse environments. Available in 2 YOLOv11 sizes — nano (2.6M params, edge-ready) and small (9.4M params, best accuracy). Optimized for foreground pallet identification in operational warehouse settings with forklifts, racks, and dynamic lighting.

Try It

→ Interactive demo on Hugging Face Spaces — upload a warehouse image and run detection with any variant in the browser.

Examples

Real detections from the validation set using the nano @ 640p variant:

Clean foreground pallet

Single foreground pallet detected at 0.86 confidence. Nano-640 is the edge workhorse — fast, clean, high-confidence on unambiguous shots.

Heavy motion blur

Same camera in motion — pallet detected at 0.58 confidence despite the entire frame being smeared. Lower confidence than a clean shot, as expected, but the detection holds.

Cluttered multi-pallet scene

16 of ~20 ground-truth pallets detected with confidence ranging 0.30–0.83 in a cluttered aisle. Real deployments should expect this kind of variable-confidence output in dense scenes; post-filter by your target threshold.

Model Variants

The nano variant is published at four resolutions covering everything from microcontroller-class edge hardware to high-resolution production cameras. The small variant is published at 640p and 1280p, the two resolutions where additional capacity materially helps accuracy.

320p Models (Ultra-Edge)

640p Models (Standard Resolution)

960p Models (Production Middle)

1280p Models (Native High Resolution)

All variants share the same training data, augmentation pipeline, and hyperparameters. Medium, large, and extra-large variants were tested but showed no accuracy improvement over small with the current dataset, so only nano and small are published. Metrics for the 320p and 960p nano variants are marked TBD — training is in progress.

Model Description

This model detects complete pallet units (wooden skid base + all products stacked on top) in warehouse imagery. It was trained on real-world warehouse photos captured during normal operations, making it robust to common warehouse conditions: motion blur, variable lighting, partial occlusions by forklifts and personnel, and cluttered backgrounds.

Unlike generic object detection models, this model is specifically trained to:

• Detect foreground pallets that are fully within the frame
• Distinguish pallets from visually similar structures (ceiling rafters, doors, rack uprights)
• Handle pallets stacked 2-high as separate detections per level
• Work reliably with motion-blurred images from moving cameras

Intended Use

• Warehouse automation: Real-time pallet counting and position tracking
• Forklift guidance: Detecting pallets in the robot/forklift field of view
• Inventory management: Automated pallet inventory from security or mounted cameras
• 3D warehouse mapping: Input to multi-view reconstruction pipelines for spatial pallet localization

Out of Scope

• Empty pallet (wooden skid only) detection without products
• Pallet type classification (EUR, GMA, block, stringer)
• Damaged pallet assessment
• Outdoor or non-warehouse environments

Training Details

Architecture

The nano variant is trained at four resolutions (320, 640, 960, 1280) and the small variant at two (640, 1280), yielding 6 models total. All variants share the same architecture per size; only the training input resolution differs. Higher resolutions improve detection of small/distant pallets at the cost of slower inference.

Dataset

Training uses the full available dataset (no image cap). Exact counts depend on the number of labeled images at training time.

Labeling Pipeline: Images were auto-labeled using Qwen3.5-9B (natively multimodal vision-language model) with structured prompts to identify pallet bounding boxes, followed by human review of preview images. Negative examples (images with no pallets) are included as hard negatives.

Label Format: YOLO format (class_id, x_center, y_center, width, height) normalized 0-1.

Training Configuration

Data Augmentation Details:

hsv_h=0.015, hsv_s=0.7, hsv_v=0.4
degrees=10.0, translate=0.1, scale=0.5
fliplr=0.5, mosaic=1.0

Evaluation Results

Test Set Performance (All Variants)

Benchmark Comparison

There is no established standard benchmark for warehouse pallet detection. The table below compares against results reported in published literature on similar (but not identical) datasets, to provide context for this model's performance.

Notes on comparison:

• No standard benchmark exists for warehouse pallet detection (unlike COCO or KITTI for general/driving OD). Each study uses its own private dataset, making direct comparison difficult.
• The NVIDIA SDG model is the most production-ready alternative, trained on ~25K synthetic images via Omniverse, targeting pallet side-face centers/corners. It detects wood, metal, and plastic pallets but focuses on pallet pocket localization for forklift docking rather than full pallet unit detection.
• The synthetic-data model (0.995 mAP) was evaluated on simple single-pallet scenes, not cluttered warehouses.
• This model is the first dedicated pallet detection model published to Hugging Face Hub — no fine-tuned pallet model previously existed in the HF ecosystem.
• This model is specifically optimized for foreground pallet detection in real operational environments.

Performance by Scenario

Usage

Quick Start

from ultralytics import YOLO

# Pick a repo in the form: EFFGRP/yolov11{size}-warehouse-pallets-{resolution}
#   size:       "n" = nano (fastest, edge)      "s" = small (best accuracy)
#   resolution: 320, 640, 960, or 1280 for nano; 640 or 1280 for small
# See "Choosing a Variant" below for recommended combinations.
model = YOLO("EFFGRP/yolov11n-warehouse-pallets-640")

# Run inference on an image
results = model.predict("warehouse_photo.jpg", conf=0.25)

# Process results
for result in results:
    for box in result.boxes:
        cls_id = int(box.cls[0])
        confidence = float(box.conf[0])
        x1, y1, x2, y2 = box.xyxy[0].tolist()
        print(f"Pallet detected: conf={confidence:.2f}, bbox=({x1:.0f},{y1:.0f},{x2:.0f},{y2:.0f})")

Choosing a Variant

from ultralytics import YOLO

# Ultra-edge (ESP32-S3, Coral Edge TPU, RPi Zero, hobby boards)
model = YOLO("EFFGRP/yolov11n-warehouse-pallets-320")

# Edge deployment (Jetson Nano, RPi 4, mobile) — nano at 640p
model = YOLO("EFFGRP/yolov11n-warehouse-pallets-640")

# General warehouse camera system — small at 640p as the best balanced tradeoff
model = YOLO("EFFGRP/yolov11s-warehouse-pallets-640")

# Production middle-ground (Jetson Orin Nano, 1080p cameras) — nano at 960p
model = YOLO("EFFGRP/yolov11n-warehouse-pallets-960")

# Edge with high-res cameras — nano at 1280p
model = YOLO("EFFGRP/yolov11n-warehouse-pallets-1280")

# High-res camera with small/distant pallets — small at 1280p (best accuracy)
model = YOLO("EFFGRP/yolov11s-warehouse-pallets-1280")

Batch Processing

from ultralytics import YOLO
from pathlib import Path

# Small @ 1280p for highest-accuracy offline batch processing
model = YOLO("EFFGRP/yolov11s-warehouse-pallets-1280")

# Process a directory of images
image_dir = Path("warehouse_photos/")
results = model.predict(
    source=str(image_dir),
    conf=0.25,
    save=True,           # Save annotated images
    save_txt=True,       # Save YOLO-format labels
    project="output/",
    name="pallet_detections"
)

Export to ONNX for Edge Deployment

from ultralytics import YOLO

# Export nano @ 640p for edge deployment (swap the repo + imgsz for other variants)
model = YOLO("EFFGRP/yolov11n-warehouse-pallets-640")
model.export(format="onnx", imgsz=640, simplify=True)
# Produces a .onnx file alongside the .pt for deployment on edge devices

Integration with Warehouse Systems

This model is designed to work as part of a larger warehouse automation pipeline. Example integration with a Redis message queue:

import json
import redis
from ultralytics import YOLO

model = YOLO("EFFGRP/yolov11s-warehouse-pallets-1280")
r = redis.Redis()

def process_frame(image_path):
    results = model.predict(image_path, conf=0.25, verbose=False)
    detections = []
    for box in results[0].boxes:
        detections.append({
            "confidence": float(box.conf[0]),
            "bbox": box.xyxy[0].tolist(),
            "center": box.xywh[0][:2].tolist(),
        })
    r.lpush("pallet_detections", json.dumps({
        "image": str(image_path),
        "count": len(detections),
        "detections": detections,
    }))

Model Files

Each variant repository contains:

Where {size} is one of: n (nano), s (small). {resolution} is 320, 640, 960, or 1280 for nano; 640 or 1280 for small.

Limitations

• Single class: Only detects "pallet" (complete unit). Does not distinguish pallet types, contents, or conditions.
• Foreground bias: Trained primarily on foreground pallets. Background or distant pallets may be missed.
• Domain specific: Trained on a single warehouse environment. Performance may degrade in visually different warehouses (outdoor yards, cold storage, etc.). Fine-tuning on your own data is recommended.
• Partial occlusion: Pallets significantly occluded by other pallets (not people or forklifts) are intentionally excluded from training labels.
• Dataset size: Performance improves with more training data. Fine-tuning on your own warehouse data is recommended.

Ethical Considerations

This model is intended for warehouse automation and logistics optimization. It does not process personal biometric data. However, warehouse images may incidentally contain workers - this model does not detect or track people, but users should ensure compliance with workplace surveillance regulations when deploying camera systems.

Citation

If you use this model in your research, please cite:

@misc{effgrp-warehouse-pallets-2026,
  title={YOLOv11 Warehouse Pallet Detector},
  author={EFFGRP},
  year={2026},
  publisher={Hugging Face},
  url={https://huggingface.co/EFFGRP/yolov11s-warehouse-pallets-1280}
}

Landscape: Why This Model Exists

As of March 2026, no dedicated pallet detection model exists on Hugging Face. The HF Hub has ~21 models tagged "logistics" but none are pallet-specific. The closest alternatives are:

• NVIDIA SDG Pallet Model (GitHub) — trained on ~25K synthetic images via Omniverse, focuses on pallet side-face and pocket localization for autonomous forklift docking. Production-ready but targets a different task (pocket detection vs. full pallet unit detection).
• Roboflow Universe (pallets) — community datasets with 1,755+ images and some pre-trained models, but fragmented across projects with inconsistent annotation guidelines.
• Academic models — published in papers but weights/code not publicly shared on model hubs.

This model fills the gap as a ready-to-use, real-world-trained pallet unit detector for the Hugging Face ecosystem.

Related Work

• NVIDIA SDG Pallet Model (2024) - Synthetic data + Omniverse for pallet pocket localization
• NVIDIA Pallet Detection Blog - OpenUSD synthetic data pipeline
• Pallet Detection and Localisation From Synthetic Data (2025) - Unity domain randomization + YOLOv8
• Improving Pallet Detection Using Synthetic Data (2024) - 69% mAP improvement on stacked pallets with synthetic augmentation
• Learning-Based Vision Systems for Semi-Autonomous Forklift (2025) - YOLOv8/v11 comparison for forklift pallet detection
• Enhanced Pallet Detection: AM-Mask R-CNN (2025) - Attention-enhanced Mask R-CNN for complex warehouses
• A Comparison of Deep Learning Models for Pallet Detection (IEEE, 2020) - Benchmark comparing Faster R-CNN, SSD, YOLOv4 on 1,344 images
• Pallet Detection and Distance Estimation with YOLO + Fiducial Markers (2023) - YOLOv5 + ArUco for distance estimation
• Amazon ARMBench (2023) - Large-scale warehouse manipulation benchmark (450K+ labels)
• CBAM-Enhanced Pallet Tracking (2025) - YOLOv8 + attention + DeepSORT for tracking
• Roboflow Pallet Datasets - Community-contributed pallet detection datasets (1,755+ images)
• EmaroLab PDT - Pallet Detection and Tracking with Faster R-CNN + 2D LRF