---
license: agpl-3.0
tags:
- object-detection
- yolo
- yolo26
- ultralytics
- pytorch
- computer-vision
- coco
pipeline_tag: object-detection
---

# YOLO26n Object Detector (COCO, 80 classes)

## Overview

This repository contains a YOLO26n (nano-scale) object detection checkpoint, trained with the [Ultralytics](https://github.com/ultralytics/ultralytics) framework (v8.4.14) to detect the 80 standard COCO object categories — everyday items such as people, vehicles, animals, furniture, and food. It is a lightweight, general-purpose detector suitable for fast inference on images or video.

All facts below were extracted directly from the checkpoint's embedded metadata (`train_args`, `train_metrics`, `train_results`, and `model.names`) — no external logs or claims are assumed beyond what is stored in the file itself.

## Classes

The model detects the 80 standard COCO classes (read from the checkpoint's `model.names`):

`airplane, apple, backpack, banana, baseball bat, baseball glove, bear, bed, bench, bicycle, bird, boat, book, bottle, bowl, broccoli, bus, cake, car, carrot, cat, cell phone, chair, clock, couch, cow, cup, dining table, dog, donut, elephant, fire hydrant, fork, frisbee, giraffe, hair drier, handbag, horse, hot dog, keyboard, kite, knife, laptop, microwave, motorcycle, mouse, orange, oven, parking meter, person, pizza, potted plant, refrigerator, remote, sandwich, scissors, sheep, sink, skateboard, skis, snowboard, spoon, sports ball, stop sign, suitcase, surfboard, teddy bear, tennis racket, tie, toaster, toilet, toothbrush, traffic light, train, truck, tv, umbrella, vase, wine glass, zebra`

## Training Details

All values below are read directly from the checkpoint's saved `train_args`, `train_results`, and `train_metrics`:

| Item | Value |
|---|---|
| Architecture | YOLO26n ("nano" scale, `yolo26n.yaml`) |
| Base/pretrained weights | `yolo26n.pt` (Ultralytics COCO-pretrained checkpoint) |
| Framework | Ultralytics `8.4.14` |
| Parameters | ~2.57M |
| Training data | COCO-format dataset (`dataset.yaml`, 80 classes) |
| Epochs | 10 |
| Batch size | 16 |
| Image size | 640 x 640 |
| Optimizer | auto-selected by Ultralytics (`lr0=0.001`, momentum `0.937`, weight decay `0.0005`) |
| Mixed precision | enabled (AMP) |
| Hardware | single GPU (trained on Google Colab, inferred from the dataset path `/content/coco_yolo/...`) |
| Training date | 2026-02-19 (per checkpoint metadata) |

### Final logged validation metrics (epoch 10)

These are the exact values stored in the checkpoint's `train_metrics` after the last training epoch — not independently re-verified:

| Metric | Value |
|---|---|
| Precision (B) | 0.676 |
| Recall (B) | 0.516 |
| mAP@0.5 (B) | 0.573 |
| mAP@0.5:0.95 (B) | 0.412 |
| Val box loss | 1.346 |
| Val cls loss | 1.400 |
| Val dfl loss | 0.011 |

## Intended Use

- General-purpose object detection prototyping across common household, outdoor, and everyday-object scenes covered by the 80 COCO categories.
- A lightweight baseline for benchmarking or comparing against other YOLO variants (nano scale, ~2.57M parameters — optimized for speed over accuracy).
- Educational/demo use for learning the Ultralytics YOLO training and inference workflow.

Not intended for safety-critical, medical, or high-stakes decision-making applications.

## How to Use

This checkpoint is a native **Ultralytics** `.pt` file (not a `transformers`-format model — there is no `config.json` or `preprocessor_config.json` in this repo). Load it with the `ultralytics` package:

```bash
pip install ultralytics huggingface_hub
```

```python
from huggingface_hub import hf_hub_download
from ultralytics import YOLO

# Download the checkpoint from the Hub
weights_path = hf_hub_download(
    repo_id="Ephraimmm/object_detection",
    filename="best (1).pt",
)

# Load and run inference
model = YOLO(weights_path)
results = model("path/to/image.jpg")

results[0].show()   # display predictions
results[0].save()   # save annotated image
print(results[0].boxes)  # bounding boxes, classes, confidences
```

## Limitations

- Trained for only 10 epochs — short relative to typical YOLO training recipes (often 100–300 epochs) — so accuracy is moderate (mAP@0.5:0.95 = 0.412) and likely below what longer training would achieve.
- Nano-scale architecture (~2.57M parameters) trades detection accuracy for speed and small model size; larger YOLO26 scales (s/m/l/x) would likely perform better but are slower and heavier.
- Metrics above come solely from the training run's own logged validation split; no independent third-party benchmark or held-out test set evaluation has been performed.
- Limited to the 80 COCO categories — objects outside this label set will not be detected or will be misclassified into the nearest known category.
- Licensed under AGPL-3.0 (per Ultralytics YOLO licensing) — review license terms before commercial or closed-source use.

## Author

Developed by [Ephraimmm](https://huggingface.co/Ephraimmm)