ChickEye

The quality of your training data determines the quality of your model. Use the camera in its final installed position — the model learns the specific viewpoint, lighting, and resolution it's trained on.

• Record at least 30–60 minutes of footage across multiple sessions
• Capture different times of day (morning, noon, evening) for varied lighting conditions
• Record each individual chicken separately, so you have clear examples of each class
• Record all chickens together to teach the model to differentiate them
• Include challenging cases: partially hidden chickens, chickens close together, chickens in motion
• Ensure your recording resolution matches what the final system will use (e.g. 640 × 480 or 1280 × 720)

Extract frames at a rate that gives enough diversity without excessive redundancy. Every 1–2 seconds (every 30–60th frame at 30 FPS) usually works well. Aim for 500–2 000 images total across all chickens.

import cv2
import os

def extract_frames(video_path, output_dir, frame_interval=30):
    """Extract one frame every `frame_interval` frames."""
    os.makedirs(output_dir, exist_ok=True)
    cap = cv2.VideoCapture(video_path)
    frame_count = 0
    saved_count = 0

    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break
        if frame_count % frame_interval == 0:
            filename = f"{output_dir}/frame{saved_count:06d}.jpg"
            cv2.imwrite(filename, frame)
            saved_count += 1
        frame_count += 1

    cap.release()
    print(f"Saved {saved_count} frames from {frame_count} total")

# Usage
extract_frames("coop_recording.mp4", "data/images", frame_interval=30)

Labeling is the most time-intensive step. Use a tool like Roboflow, Label Studio, or labelImg to annotate bounding boxes and export in YOLO format.

• Draw tight bounding boxes that encompass the full body of each chicken
• Use a separate class for each individual chicken (e.g. Babette, Matilda, Lottie)
• Aim to label at least 100–200 images per class for reliable accuracy
• Roboflow offers a free tier with annotation tools and automatic train/val splitting
• Export in YOLOv8 format — this generates a .txt file alongside each image

YOLO expects a specific folder layout with a central data.yaml config file. An 80 / 20 train / validation split is a good starting point.

dataset/chicken/
├── data.yaml              ← dataset config
├── images/
│   ├── train/             ← training images (.jpg)
│   └── val/               ← validation images (.jpg)
└── labels/
    ├── train/             ← training labels (.txt)
    └── val/               ← validation labels (.txt)

path: ./dataset/chicken   # root directory of the dataset
train: images/train       # training images (relative to path)
val: images/val           # validation images

names:
  0: Babette
  1: Matilda
  2: Eggbert
  3: Lottie

Start from a pretrained YOLO checkpoint — this is called transfer learning and dramatically reduces both training time and the amount of labeled data you need. The yolo11n.pt (nano) or yolo11m.pt (medium) are good starting points depending on your hardware. These base weights are not included in the repository — Ultralytics downloads them automatically on first use. To use them in the built-in Train tab, place the downloaded .pt file into the models/ folder first.

Install the Ultralytics library first:

pip install ultralytics opencv-python

from ultralytics import YOLO

# Load a pretrained YOLO11 checkpoint
model = YOLO('yolo11n.pt')   # nano   — fastest, good for most hardware
# model = YOLO('yolo11m.pt') # medium — better accuracy, needs more VRAM
# model = YOLO('yolo11l.pt') # large  — highest accuracy, GPU recommended

# Train on your labeled dataset
model.train(
    data='dataset/chicken/data.yaml',  # path to your dataset config
    epochs=100,                        # training epochs
    imgsz=640,                         # input image size
    project='/tmp/yolo_runs',          # output directory
    name='train',
    exist_ok=True,
)
# Trained weights saved to /tmp/yolo_runs/train/weights/best.pt
# Copy best.pt into your models/ folder and select it in the Setup tab

After training, YOLO saves metrics and plots to runs/train/chickeye_v1/. Check results.csv and the generated charts for these key metrics:

• mAP50 — Mean Average Precision at 50% IoU. Aim for > 0.85 for reliable detection
• Precision — How often a detection is actually correct (minimizes false positives)
• Recall — How often chickens are successfully detected (minimizes misses)

from ultralytics import YOLO

# Load your trained model
model = YOLO('models/best11n.pt')  # path to your trained model

# Run validation to see full metrics
metrics = model.val(data='dataset/chicken/data.yaml')
print(f"mAP50:    {metrics.box.map50:.3f}")
print(f"mAP50-95: {metrics.box.map:.3f}")

# Test on a single image — shows bounding boxes in a preview window
results = model('dataset/chicken/images/val/chicken_00007.jpg', conf=0.6)
results[0].show()

# Save predictions to disk
results[0].save(filename='prediction.jpg')

If accuracy is insufficient, common improvements:

• Add more labeled images, especially for underperforming classes
• Try a larger model variant (yolo11m.pt or yolo11l.pt)
• Lower the confidence threshold to catch more chickens (at the cost of more false positives)
• Add data augmentation or train for more epochs
• Review mislabeled annotations — label quality is often the limiting factor