Compare extra large YOLO v11, v12 and 2026 models to detect Floorplan

Object Detection Task:

Object Detection is a fundamental challenge in Computer Vision that extends beyond simple image classification. While image classification determines what is present in an image (e.g., “this is a kitchen”), Object Detection answers both “what” and “where” by identifying multiple objects or regions within an image, assigning them to predefined categories, and locating them using bounding boxes.

Traditional Object Detection

Classical object detection was dominated by the R-CNN family of models, which followed a multi-stage detection approach. R-CNN (Region-based Convolutional Neural Network) first generated thousands of candidate object regions using a selective search algorithm and then applied a CNN to classify each region individually. Although R-CNN achieved significant improvements in detection accuracy, it was computationally expensive and slow because each region had to be processed separately. In R-CNN, Non-Maximum Suppression (NMS), was introduced to remove duplicate/overlapping detections by keeping only the highest-confidence box in each region.

To address these limitations, Fast R-CNN was introduced. Instead of running the CNN on every proposed region, Fast R-CNN processed the entire image only once to generate a feature map, from which region features were extracted and classified. This greatly improved training and inference speed while maintaining high accuracy. However, it still relied on the slow selective search algorithm to generate region proposals.

The next advancement, Faster R-CNN, replaced selective search with a learnable Region Proposal Network (RPN) integrated directly into the neural network. The RPN generated candidate object regions much more efficiently, enabling near real-time performance while further improving accuracy. Faster R-CNN became the standard two-stage object detection framework and laid the foundation for many modern detection architectures before the emergence of one-stage detectors such as YOLO.

The YOLO: (You Only Look Once)

YOLO changed the classical “multi-stage” object detection process by detecting and classifying objects in one step. Instead of examining different regions separately, YOLO processes the entire image at once and predicts object locations and categories simultaneously. This makes object detection much faster while maintaining high accuracy, enabling real-time applications such as self-driving cars, security cameras.

3 most recent YOLO Versions used in this study:

Floorplan dataset

Automated floor plan understanding is a practical challenge in architecture, real estate, and smart building systems. Detecting rooms, fixtures, and openings accurately and quickly from 2-D raster floor plans requires a model that can handle highly structured, low-texture imagery — very different from the natural scenes most YOLO benchmarks use.

In this post I compare three state-of-the-art YOLO extra-large (x) variants — YOLO11x, YOLOv12x, and YOLO26x — trained on the same floor plan dataset with 8 classes:

The data can be downloaded from roboflow[https://universe.roboflow.com/simple-floor-plan/floor-plan-f2lla/dataset/7]

• The data is downloaded accordingly to YOLO format containing train and valid folder with images and corresponding labels in bounding box format:

yolo_data/
├── data.yaml
├── train/
│   ├── images/
│   │   ├── image001.jpg
│   │   ├── image002.jpg
│   │   └── ...
│   └── labels/
│       ├── image001.txt
│       ├── image002.txt
│       └── ...
├── valid/
│   ├── images/
│   │   ├── image101.jpg
│   │   ├── image102.jpg
│   │   └── ...
│   └── labels/
│       ├── image101.txt
│       ├── image102.txt
│       └── ...

YOLO Model training and validation

Model download

• Here we download yolo v11, v12 and 2026 extra large model to our system:

https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo11x.pt
https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo12x.pt
https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26x.pt

Model training

• We create a conda environment, then install latest ultralytics package.

pip install -U ultralytics

We train model using train data via CLI in separate folder:

yolo detect train data=data.yaml model=yolo11x.pt epochs=100 imgsz=640 > train_v11.log
yolo detect train data=data.yaml model=yolo12x.pt epochs=100 imgsz=640 > train_v11.log
yolo detect train data=data.yaml model=yolo26x.pt epochs=100 imgsz=640 > train_v26.log

• In the above CLI command, we train each model with 100 epochs, the image resolution is rescaled to 640 and save the output to a log file
• The corresponding output “weight”: last.pt, best.pt from the train model are store in corresponding folder:

runs/detect/train/weight/last.pt
runs/detect/train/weight/best.pt

Model validation

Validate the model on valid data set using the same test set on 3 models in separate folder:

yolo val model=./runs/detect/train/weights/best.pt data=data.yaml > val_v11.log
yolo val model=./runs/detect/train/weights/best.pt data=data.yaml > val_v12.log
yolo val model=./runs/detect/train/weights/best.pt data=data.yaml > val_v26.log

Training Session Comparison (100 Epochs)

All three models were trained for 100 epochs on the same floor plan dataset with identical hyperparameters. Below is a direct comparison of training speed and final convergence metrics.

Training Setup

| Parameter | Value | |—|—| | Epochs | 100 | | Batch Size | 16 | | Optimizer | AdamW (auto-tuned) | | Image Size | 640×640 | | Augmentation | RandAugment, mosaic, mixup disabled | | Hardware | NVIDIA A100-SXM4-80GB |

Training Speed (per-image average, epoch 100)

Overall Validation Metrics

Headline findings

1. YOLO11x leads on every headline metric. It achieves the highest precision (+1.0 pp over the others), recall (+1.2–4.4 pp), mAP@50 (+2.3–4.4 pp), and mAP@50-95 (+1.4–2.5 pp).
2. YOLOv12x is a close second in both mAP figures, but its substantially higher architecture complexity does not translate into a performance gain on this domain.
3. YOLO26x trails the most on recall (0.890), suggesting it misses more objects overall — particularly in low-instance classes — despite being the smallest model.
4. The gap in mAP@50-95 (strict IoU) is more pronounced than at mAP@50, indicating that localisation precision (tight box fitting) differentiates the models more than simple detection presence.

Verdict: For floor plan detection, YOLO11x delivers the best accuracy while using fewer parameters than YOLOv12x.

Inference Speed Breakdown

All times are per-image averages on the A100.

Speed analysis

• YOLO11x has the fastest raw inference at 5.9 ms — 1.7× faster than YOLOv12x and nearly 3× faster than YOLO26x. On latency-sensitive pipelines (e.g., streaming building inspection cameras), this matters.
• YOLO26x has the slowest inference (17.2 ms) but a remarkably fast postprocess step (1.2 ms vs 14.3 ms for YOLO11x). This suggests YOLO26x’s architecture produces sparser, cleaner prediction maps that require minimal NMS filtering — an interesting design trade-off.
• YOLOv12x occupies the middle ground on inference (10.2 ms) but its larger postprocess overhead brings its total time above both competitors.
• In terms of total end-to-end latency, YOLO26x is marginally fastest (~19.9 ms) due to its near-zero postprocess cost, but this advantage vanishes if inference alone is the bottleneck (e.g., batch workloads).

Note on postprocessing: The postprocess phase includes Non-Maximum Suppression (NMS), which removes duplicate/overlapping detections by keeping only the highest-confidence box in each region. Denser prediction maps (YOLO11x, YOLOv12x) require more filtering passes, while YOLO26x’s sparser output naturally needs fewer NMS iterations. This is a key architectural trade-off between inference speed and postprocess efficiency.

Per-Class Performance Deep Dive

mAP@50 per class

mAP@50-95 per class (localisation quality)

Class-level insights

🏠 Easy Classes — Bedroom, Bathroom, Bed, Door

All three models perform near-identically on these high-instance, visually consistent classes (mAP@50 ≥ 0.977). The large number of training samples and distinctive geometric signatures (rectangular rooms, rectangular doors) make them trivially learnable at IoU=0.50.

At strict IoU (mAP@50-95), bathroom is the one exception: YOLOv12x leads at 0.924 vs YOLO11x’s 0.906, possibly because its attention mechanism better localises bathroom walls and fixtures that partially overlap with other rooms.

🚪 Entrance — The Hardest Class

Entrance is the most challenging class across all models, with only 99 instances and high visual ambiguity (entrances can look like doors or open gaps).

• YOLO11x: mAP@50 = 0.966 — excellent despite the challenge
• YOLOv12x: mAP@50 = 0.786 — significant drop (-18.0 pp)
• YOLO26x: mAP@50 = 0.687 — the worst result in the entire benchmark (-27.9 pp vs YOLO11x)

The v11 architecture’s clear superiority here suggests it has better feature representation for this ambiguous, low-frequency class. The recall figures tell the story: YOLO11x achieves 0.773 recall on entrance, while v12 and v2026 drop to 0.636 and 0.626 respectively — both models miss roughly 37% of entrances.

🍳 Kitchen — Moderate Challenge

Kitchen has 99 instances and scores well on YOLO11x (mAP@50 = 0.965) but drops to 0.933 on YOLO26x — a 3.2 pp degradation. YOLOv12x is competitive at 0.963. Kitchen geometry varies (L-shaped, galley, open-plan), making it harder for models with weaker contextual reasoning.

🪟 Window — Lowest mAP@50-95

Windows consistently have the lowest mAP@50-95 across all models (~0.51–0.53). This is expected: windows appear as thin wall breaks or small rectangles whose bounding boxes are intrinsically harder to tighten at IoU > 0.7. YOLO26x marginally leads at 0.532 on strict IoU, while YOLO11x leads at mAP@50 (0.968).

Recall vs Precision Trade-off

YOLO26x has the widest precision–recall gap (0.076), meaning it sacrifices the most recall to maintain precision. In practice, missing more objects (lower recall) is often worse than a few false positives in floor plan analysis, where completeness of detection is critical for downstream tasks like area calculation or BIM integration.

Summary Scorecard

Practical Recommendations

Limitations & Future Work

1. Small validation set (102 images): Statistical significance should be validated on a larger held-out set. The per-class differences for low-count classes (entrance, kitchen, living-room: 99 instances each) may not generalise.
2. Single-resolution evaluation: All models were evaluated at the same input resolution. Multi-scale testing (augment=True) could shift rankings, especially for windows and entrances.
3. A100 hardware bias: The postprocess cost advantage of YOLO26x may be less pronounced on lower-end hardware where NMS is GPU-accelerated less efficiently.
4. Floor plan diversity: The dataset covers simple schematic plans. Results on more complex, hand-drawn, or photo-realistic floor plans may differ.

Conclusion

On the Simple Floor Plan dataset, YOLO11x is the clear winner — it achieves the highest mAP@50 (0.981), mAP@50-95 (0.767), precision (0.976), and recall (0.934), and does so with the fastest inference (5.9 ms). The newer, heavier YOLOv12x architecture does not outperform it despite having 49% more layers and ~2 M more parameters, suggesting that the architectural changes in v12 are optimised for natural image detection rather than structured floor plan imagery. YOLO26x, positioned as the 2026 architecture, shows promise in pipeline efficiency and competitive per-box localisation on some classes, but its significant recall drop on entrance and kitchen classes is a concern for practical deployment.

For practitioners working on floor plan analysis, YOLO11x remains the safest choice today. Monitoring how YOLO26x evolves with fine-tuning and multi-scale inference will be a worthwhile experiment.

Benchmarks run on NVIDIA A100-SXM4-80GB · Ultralytics 8.4.64 · PyTorch 2.7.0+cu126 · Dataset: Roboflow floor-plan-f2lla v7 (CC BY 4.0)