Datasets for YOLOv8 and newer

#1. Image Collection

Before labeling, you need a dataset of images containing the objects you want to detect.

• Ensure a diverse dataset (different backgrounds, angles, lighting).
• Use at least 5000–1000 images for decent results.
• Resize images (if necessary) to a standard resolution (e.g., 640x640).

#2. Annotation (Labeling)

To train a YOLOv8 model, you need to annotate your images with bounding boxes.

#Tools for Labeling

You can use various tools to label your dataset:

• LabelImg (for manual labeling)
• Roboflow Annotate
• CVAT
• LabelMe

#Labeling Process

1. Open the labeling tool and load your images.
2. Draw bounding boxes around each object.
3. Assign a class label to each object.
4. Save the annotations in YOLO format.

#YOLO Annotation Format

Each image should have a corresponding .txt file with the same name, containing lines in this format:

<class_id> <x_center> <y_center> <width> <height>

• class_id: Index of the object class (starting from 0).
• x_center, y_center: Bounding box center (normalized, 0 to 1).
• width, height: Bounding box dimensions (normalized).

Example for a cat (class 0) and dog (class 1):

0 0.45 0.60 0.30 0.40
1 0.70 0.50 0.25 0.35

💡 Tip: Always normalize bounding box coordinates relative to image size.

#3. Organizing Dataset

Your dataset should be structured as follows:

/dataset
 ├── train
 │    ├── images
 │    ├── labels
 │    
 ├── test
 │    ├── images
 │    ├── labels
 │    
 ├── valid
 │    ├── images
 │    ├── labels
 │ 
 ├── data.yaml  (dataset configuration file)

#data.yaml File

Create a data.yaml file that defines your dataset:

train: /path/to/dataset/images/train
val: /path/to/dataset/images/val
test: /path/to/dataset/images/test

nc: 2  # Number of classes
names: ["cat", "dog"]

Replace "cat", "dog" with your actual class names.

---

#4. Training the YOLOv8 Model

Make sure you have installed Ultralytics YOLOv8:

pip install ultralytics

#Start Training

Run the following command to train your model:

from ultralytics import YOLO

model = YOLO("yolov8n.pt")  # Load pre-trained model
results = model.train(data="data.yaml", epochs=50, imgsz=640, batch=16, device="cuda")

#Training Parameters Explained

• "yolov8n.pt" → Start with YOLOv8 nano; switch to yolov8s.pt, yolov8m.pt, or yolov8l.pt for better accuracy.
• epochs=50 → Number of training cycles (increase for better results).
• imgsz=640 → Image size (should match dataset).
• batch=16 → Number of images per batch (adjust based on GPU memory).
• device="cuda" → Use GPU (change to "cpu" if needed).

---

#5. Evaluating the Model

After training, you can evaluate the model:

metrics = model.val()

• mAP (Mean Average Precision) is the key metric for object detection.
• Precision & Recall help measure how well the model detects objects.

#Testing on Images

Run inference on a test image:

results = model("test_image.jpg", show=True, save=True)

This will display and save the output with detected objects.

---

#6. Exporting the Model

You can export the trained model to different formats:

model.export(format="onnx", imgsz=320)  # Convert to ONNX for optimized inference

Supported formats: ONNX

---

#Final Tips

✔ More Data = Better Model
✔ Augment Data = Improve Generalization (flip, rotate, color jitter)
✔ Higher Epochs = Better Accuracy (but watch for overfitting)
✔ Monitor Loss & mAP = Track Performance (tensorboard --logdir=runs)

---