4. Detecció d'objectes

1. Introducció. Descripció breu de YOLO

https://docs.ultralytics.com/es

YOLO (You Only Look Once) és una família de models de deep learning enfocats en la detecció d'objectes en imatges o vídeos. Es caracteritza per la seva velocitat i precisió en temps real, ja que el model processa tota la imatge d'una sola vegada per predir les regions on es troben els objectes i la seva classe.

Com s'entrena un model YOLO:

Recopilació de dades: Es recullen imatges etiquetades amb les coordenades dels objectes i les seves categories.
Preparació de dades: Es estructuren les etiquetes en un format compatible (per exemple, COCO o YOLO).
Configuració de l'entrenament: Es tria l'arquitectura YOLO (p. ex. YOLOv5, YOLOv7, YOLOv8, etc.), la mida del lot (batch size) i els hiperparàmetres (èpoques, taxa d'aprenentatge, etc.).
Procés d'entrenament: Amb cada batch d'imatges, la xarxa ajusta els pesos per minimitzar la diferència entre les prediccions i les etiquetes reals.
Validació i ajust: S'avalua el rendiment en un conjunt de validació per ajustar hiperparàmetres i evitar sobreajust.*

2. Dataset

La estructura del dataset se divide en dos carpetas y archivos de configuración

Bash
dataset/
 ├─ data.yaml
 ├─ images/
 │   ├─ train/
 │   │   ├─ foto1.jpg
 │   │   ├─ foto2.jpg
 │   │   └─ ...
 │   └─ val/
 │       ├─ fotoX.jpg
 │       └─ ...
 └─ labels/
     ├─ train/
     │   ├─ foto1.txt
     │   ├─ foto2.txt
     │   └─ ...
     └─ val/
         ├─ fotoX.txt
         └─ ...

on:

Per cada fotoX.jpg a images/train, hi ha un corresponent fotoX.txt a labels/train que descriu totes les caixes d'objectes d'aquesta imatge (una línia per objecte).
El mateix per a la carpeta de validació val.

Pots trobar un exemple aquí https://universe.roboflow.com/vc/matriculas-espanolas/dataset/1

2.1. Format txt

El format TXT que utilitza YOLO (tant v5, v7, v8, etc.) per a les etiquetes de detecció d'objectes segueix una estructura molt concreta. Cada imatge té associat un fitxer .txt amb el mateix nom (excepte l'extensió). Dins del fitxer d'etiquetes, cada línia descriu un bounding box (caixa delimitadora) d'un objecte detectat/anotat a la imatge. La línia es compon de:

Bash
class_id  x_center  y_center  width  height

tots els valors estan normalitzats en el rang 0-1 respecte a les dimensions de la imatge:

class_id: Identificador de la classe (objecte) en format enter (0, 1, 2...).
Si només tens una classe (p. ex. license_plate), serà sempre 0. Si, per exemple, tens matrícules i faro-izq i faro-der, matrícula seria el 0, faro_izq seria el 1 i faro_der seria el 2.
x_center: Coordenada X del centre de la caixa, normalitzada (dividida entre l'amplada de la imatge).
y_center: Coordenada Y del centre de la caixa, normalitzada (dividida entre l'altura de la imatge).
width: Amplada de la caixa, també normalitzada (dividida entre l'amplada de la imatge).
height: Altura de la caixa, normalitzada (dividida entre l'altura de la imatge).

Exemple d'una BB

Imagina que la teua imatge té una amplada de 1280 px i una altura de 720 px, i la caixa delimitadora que t'interessa va de (x1=600, y1=200) a (x2=750, y2=300).

Valors reals:

Amplada de la caixa → x2 - x1 = 150 px
Altura de la caixa → y2 - y1 = 100 px
Centre X → (x1 + x2)/2 = (600 + 750)/2 = 675 px
Centre Y v (y1 + y2)/2 = (200 + 300)/2 = 250 px

Valors normalitzats: - Amplada normalitzada → 150 / 1280 ≈ 0.1172 - Altura normalitzada → 100 / 720 ≈ 0.1389 - Centre X normalitzat → 675 / 1280 ≈ 0.5273 - Centre Y normalitzat → 250 / 720 ≈ 0.3472

Si class_id=0, la línia al teu fitxer .txt seria:

Text Only
1	`0 0.5273 0.3472 0.1172 0.1389`

En definitiva, quan YOLO entrena (o infereix), buscarà aquests fitxers .txt per saber on es troben els objectes (en el teu cas, les matrícules) i amb quina classe associar-los. Això és fonamental perquè el model aprengui de manera supervisada.

Després, en inferència o predicció, el model generarà les seves pròpies coordenades de sortida, també normalment en un sistema similar, però te les proporcionarà en escala absoluta o normalitzada segons la llibreria que estiguis utilitzant.

2.2. `data.yaml`

En el cas de YOLO (especialment en variants com YOLOv5 o YOLOv8), l'arxiu .yaml que es troba a la carpeta principal (o a l'arrel del dataset) serveix per descriure la configuració del conjunt de dades.

En general, aquest arxiu .yaml conté informació com:

Rutes de les dades:
La ruta o path on es troben les imatges d'entrenament (train).
La ruta on es troben les imatges de validació (val).
(Opcionalment) la ruta a les imatges de prova (test).
Quantitat i nom de les classes:
- Un llistat amb els noms de cada classe (per exemple, ['gos', 'gat', 'persona']).
- El nombre total de classes al dataset.
Paràmetres addicionals (opcional):
- Rutes d'anotacions, si es gestionen en diferents carpetes.
- Configuracions específiques per a l'entrenament (encara que aquest tipus d'informació a vegades es troba en un altre arxiu diferent).
- Identificadors o camps extres que permetin integrar el dataset en un flux de treball més complex.

Un exemple senzill d'un arxiu data.yaml (per a YOLOv5, per exemple) es veuria així:

YAML
train: ../train/images
val: ../valid/images
test: ../test/images

nc: 3
names: ['matricula','faro_izq','faro_der']

Atenció

En algunes versions ens podrà apareixer un error de la ruta del dataset. Això és degut a que te una referència al "datasets_dir": "",. Haurem de comprovar-ho cas de mostrar el missatge que no troba el dataset. Podem veure-ho amb el comandament yolo settings

2.3. Augmentació del Dataset

Com sabem, una de les parts més complicades és la generació del dataset. Podem incrementar la quantitat d'imatges de dues maneres:

2.3.1. Augmentació en línea (on-the-fly)

Aquest tipus d'augmentació es fa durant l'entrenament. La majoria d'implementacions recents de YOLO (p. ex., YOLOv5, YOLOv7, YOLOv8) ja inclouen una sèrie de transformacions aplicades automàticament.

Configuració d'hiperparàmetres

En molts repositoris (com el de YOLOv5), trobes un fitxer d'hiperparàmetres, sovint anomenat hyp.yaml o similar. Dins d'aquest fitxer, pots ajustar diferents paràmetres d'augmentació com:

hsv_h, hsv_s, hsv_v: Augments de to, saturació i valor en espai de color HSV.
degrees: Rotació.
translate: Translació (moviment de la imatge).
scale: Escalat.
shear: Efecte de cisallament (shear).
flipud: Volteig vertical.
fliplr: Volteig horitzontal.

Per exemple, a YOLOv5 (dins del seu repositori oficial) existeix un fitxer hyp.yaml amb paràmetres predefinits. Pots editar-lo per ajustar la intensitat de cada transformació.

YAML
# Exemple (simplificat) hyp.yaml
augments:
  degrees: 0.0
  translate: 0.1
  scale: 0.9
  shear: 0.0
  flipud: 0.0
  fliplr: 0.5
  hsv_h: 0.015
  hsv_s: 0.7
  hsv_v: 0.4

Al entrenar el teu model (per exemple python train.py --hyp hyp.yaml ...) o mitjançant un script python, YOLO aplicarà automàticament aquestes transformacions en carregar cada lot (batch) d'imatges.

2.3.2. Augmentació prèvia (offline)

La idea aquí és crear còpies augmentades de les imatges (i les seves etiquetes corresponents) abans d'iniciar l'entrenament. Per a això, es poden utilitzar llibreries com Albumentations, imgaug o les transformacions de torchvision.

Flux general amb Albumentations

Instal·lació:

Bash
1	`pip install albumentations`

Configurar un script d'augmentació:

Definir les transformacions que desitges aplicar (p. ex., rotacions, flips, canvis de brillantor, etc.).
Carregar cada imatge i la seva anotació, aplicar la transformació i després exportar la imatge augmentada i la seva nova anotació. Després de cada transformació, és probable que les caixes delimitadores (bounding boxes) canviïn, per la qual cosa has de guardar-les amb el nou format (per exemple, en un fitxer .txt amb format YOLO).
Guardar imatges augmentades: Pots emmagatzemar-les en carpetes com images/train_aug, per exemple, i utilitzar aquesta carpeta ampliada per entrenar.

Aquest mètode crea nous fitxers al disc, augmentant explícitament el nombre d'imatges al teu dataset. No obstant això, tingues en compte que això ocupa més espai i requereix temps addicional per a la generació. A canvi, pot ser beneficiós si vols realitzar un control molt precís de les teves dades o si entrenes amb plataformes que no admeten fàcilment l'augmentació en línia.

Per etiquetar un conjunt d'imatges, podem utilitzar eines com:

2.4. Eina d'etiquetat local del dataset

Investiga i etiqueta un conjunt d'imatges teues amb l'eina https://labelstud.io

Bash
pip install label-studio
label-studio start

![Label Studio](./img/label-studio.png){width=75%}

3. Configuració del model

Ara ha arribat el moment de entrenar el model. Aquest pas és molt senzill si hem definit el arxiu yaml d'abans, el qual completarem. Anem a veure un exemple al qual descriurem alguna de les parts:

YAML
# Modelo
model_type: "yolov8s"                # Tipo de modelo a utilizar (puede ser yolov5s, yolov5m, etc.)

# yolo_config.yaml
batch_size: 16
img_size: 1920
epochs: 50
learning_rate: 0.001
momentum: 0.937
weight_decay: 0.0005
pretrained_weights: "yolov8s.pt"   # Modelo preentrenado para continuar el entrenamiento

# Datos
train: "../data/train"            # Directorio donde están las imágenes de entrenamiento
val: "../data/val"         # Directorio donde están las imágenes de validación


# Clases
nc: 7       # number of classes
names:
  0: 'Chewbacca'
  1: 'Leia'
  2: 'Luke'
  3: 'ObiWan'
  4: 'Solo'
  5: 'StormTrooper'
  6: 'Vader'


# add
name: "yolo_sw"

model_type: Aquest paràmetre especifica el tipus de model de YOLO que s'utilitzarà. Els models de YOLO es presenten en diverses variants amb diferents mides i capacitats:
yolo_vX_[mida]-opt:
- vx és la versió: 8, 9, 11, etc.
- mida és una lletra que defineix la mida del model preentrenat. Com més gran sigui, millor serà el resultat, però també augmentarà el cost d'entrenament per la quantitat d'hiperparàmetres. Valors possibles (la inicial): nano, small, medium, large i xtraLarge.
- opt és per escollir el tipus de detecció que es farà amb el model.

![Versions de Yolo](./img/Yolo_versions.png){width=75%}

batch_size: És el nombre d'imatges que es processen en cada pas d'entrenament abans d'actualitzar els pesos del model. Un valor de 16 significa que el model processarà 16 imatges alhora. Un batch_size més gran pot accelerar l'entrenament, però també requereix més memòria GPU, mentre que un valor petit farà que el model sigui més estable però més lent.
img_size: La mida de la imatge a la qual es redimensionaran totes les imatges d'entrada abans de ser alimentades al model. En aquest cas. Una resolució més gran permet que el model capti més detalls, però també requereix més memòria i pot ser més lent.
epochs: És el nombre total de vegades que el model passarà per tot el conjunt de dades durant l'entrenament. Si el model no millora després de diverses èpoques, pots aturar l'entrenament per evitar el sobreajust.
learning_rate: La taxa d'aprenentatge és la mida del pas que l'optimitzador fa per ajustar els pesos del model en cada iteració. Un valor de 0.001 significa que l'optimitzador ajustarà els pesos amb un pas petit en cada iteració. Un valor més alt pot fer que el model aprengui més ràpid, però pot ser menys estable. Un valor més baix pot fer que el model aprengui de manera més estable, però més lentament.
momentum: És un paràmetre que ajuda a accelerar l'entrenament, especialment en les primeres etapes. Un valor de 0.937 és força comú i millora la convergència de l'optimitzador, ajudant que el model no quedi atrapat en mínims locals.
weight_decay: És una tècnica de regularització utilitzada per prevenir el sobreajust, penalitzant els pesos grans durant l'entrenament. Un valor de 0.0005 és força baix i és una regularització moderada. Un valor més alt de weight_decay pot reduir el risc de sobreajust, però també pot evitar que el model aprengui massa dels dades.
pretrained_weights: Especifica si s'utilitzarà un model preentrenat. Utilitzar pesos preentrenats accelera el procés d'entrenament i millora la precisió del model, especialment si el conjunt de dades és petit. Els models preentrenats s'entrenen amb grans datasets com COCO, cosa que ajuda que el model tingui una bona base per aprendre a detectar objectes.
train: Especifica la ruta al directori que conté les imatges d'entrenament. Les imatges d'entrenament s'utilitzen per entrenar el model a reconèixer objectes.
val: Especifica la ruta al directori que conté les imatges de validació. Les imatges de validació s'utilitzen per avaluar el model durant l'entrenament, assegurant-se que no estigui sobreajustant les dades d'entrenament.
nc: Aquest paràmetre especifica el nombre de classes en el conjunt de dades. En aquest cas, 7 classes. És important que el nombre de classes coincideixi amb el nombre de classes definides als fitxers d'etiquetes.
names: Aquest és un diccionari que mapeja un índex de classe (començant des de 0) al seu nom corresponent. Pot ser una llista numerada com l'exemple o algunes versions permeten un array:
names: ["Chewbacca", "Leia", "Luke", "ObiWan", "Solo", "StormTrooper", "Vader"]

3.2. Entrenament del model

Al següent exemple podem veure com queda un programa per entrenar el model

Entrenament del model

Python
from ultralytics import YOLO
model = YOLO("models/yolov8s.pt")   

results = model.train(
    data="yolo_config.yaml",       # arxiu de configuració vist abans
    device='cpu'                   # '0' per a GPU; 'cpu' per a CPU
)

Com podem veure:

Es fa servir el model yolov8s. La primera execució es descarrega desde ultralycs i es guarda en la carpeta model
Posteriorment comença l'entrenament i va mostrant per pantalla les iteracions i les èpoques

Ademès

Altres arguments interesants son:

save_period=n per a guardar el estat dels hiperparàmetres cada n èpoques i
resume=True per a reprendre l'entrenament. L'entrenament pot parar-se en força bruta (CTRL+C, CTRL+Z).

També comentar que els models parcials i finals es guarden dins d'una carpeta que es crea anomenada runs i on es creen train_n on n indica el número d'execucions o llançaments que fem del model.

Dins d'aquest run trobarem al final un model anomenat best.pt amb la millor versió dels hiperparàmetres

Bash
Logging results to runs/detect/train5
Starting training for 100 epochs...

      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
      1/100         0G      2.471      9.334      2.092          3        640: 100%|██████████| 2/2 [01:59<00:00, 59.93s/it] 
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 1/1 [00:10<00:00, 10.33s/it]
                   all          4         14     0.0158      0.667     0.0967     0.0237


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
      2/100         0G      1.762      5.048      1.539         13        640: 100%|██████████| 2/2 [01:26<00:00, 43.25s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 1/1 [00:02<00:00,  2.96s/it]
                   all          4         14      0.373      0.262      0.098     0.0352

Per guardar el millor model, per example de l'execució numero 5 (train5):

Python
import shutil

shutil.copy('runs/detect/train5/weights/best.pt', 'models/best.pt')

Aquest model és el que farem servir a continuació per a les prediccions

Tota la informació la pots trobar a https://docs.ultralytics.com/modes/train/

4. Predicció del modelo

Finalment ha arribat el moment de probar el model, a veure si funciona de manera adequada.

Els passos a seguir son:

Carregar el model entrenat
Indicar quina imatge volem processar
Fer la predicció
Analitzar els resultats
Mostrar els resultats

Mirem-ho pas a pas:

Python
model_Path='runs/detect/train5/weights/best.pt'
model=YOLO(model_Path)
source_image='data/val/images/ba2b2dbd-captura_20250318-161749.png'

images=[
    'data/val/images/ba2b2dbd-captura_20250318-161749.png',
    'data/val/images/be627c47-captura_20250318-161845.png'
]

results = model.predict(
    source=images,
    conf=0.25,    # Umbral de confianza
    save=False,   # No que dibuje YOLO; lo haremos manualmente con OpenCV
    verbose=False
)

Com podem veure la carrega del model i la predicció no te complicació. Fixar-se que podem fer la predicció per a una o diverses imatges, i el resultat dependrà d'això. La variable result contindrà un llistat amb variables de tipus Results, una per imatge que fem predicció. Tens la informació completa a la seua web en aquest link

Aquesta variable depenent del model que hem entrenat tindrà uns resultats o altres. En el cas que ens segueix, que és la detecció d'objectes, ens interessen els elements:

names: diccionari amb les classes de objectes que detecta el nostre model. Coincideix amb les classes que hem entrenat.
boxes: un objecte que conté els elements detectats, que son de tipus Boxes
len(Results): ens dona quants elements s'han detectat.

Per a cada element de tipus boxes trobarem, per avaluar el resultat:

cls: la id de la classe del objecte detectat
conf: la confiança en tant per 1 del objecte detectat
xyxy: les coordenades dels extrems de la BB, en valors reals
xyxyn: igual que l'anterior però normalitzat segons el tamany de la imatge d'entrada
xywh: la coordenada del centre de la caixa, ample i llarg
xywhn: el mateix, però normalitzat al tamany de la imatge d'entrada

::: note

Text Only
Tots aquests valors de retorn són tensors (matrius), per tant per accedir al valor _real_ hem d'agafar el primer element com si fos un array, `cls[0]`, `conf[0]`, etc

Pintem la informació sobre la imatge

Python
import cv2 
import matplotlib.pyplot as plt

orig_img=cv2.imread(source_image)
orig_img=cv2.cvtColor(orig_img, cv2.COLOR_BGR2RGB)

predictions = results[0]
print(len(predictions))
for box in predictions.boxes:
    x1, y1, x2, y2 = box.xyxy[0]

    # Convertir a int para dibujar con OpenCV
    x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)

    # ID de la clase detectada
    cls_id = int(box.cls[0])

    # Confianza de la detección
    conf = float(box.conf[0])

    # Nombre de la clase (basado en model.names)
    class_name = model.names[cls_id] if model.names and cls_id < len(model.names) else f"cls_{cls_id}"

    print(f"Clase: {class_name}, confianza: {conf:.2f}")
    # Dibujo del rectángulo
    color = (0, 255, 0)  # Verde
    thickness = 2
    cv2.rectangle(orig_img, (x1, y1), (x2, y2), color, thickness)

    # Texto (etiqueta + confianza)
    label = f"{class_name} {conf:.2f}"
    # Para dibujar el fondo del texto (opcional, para que sea legible)
    (tw, th), baseline = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)
    # Caja para el texto encima del bounding box
    cv2.rectangle(orig_img, (x1, y1 - th - baseline), (x1 + tw, y1), color, -1)
    cv2.putText(orig_img, label, (x1, y1 - baseline),
                cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1)

plt.figure(figsize=(16, 9))
plt.imshow(orig_img)
plt.show()