# Aggiornamento 2026-05-17 20:57

## Obiettivo

Provare la strada del dataset aumentato per il riconoscimento OCR numerico via YOLO, senza integrare ancora nulla in `flywms`.

## Dataset aumentato

Creato lo script:

```text
C:\devel\yolo-ocr\tools\augment_yolo_dataset.py
```

Generato il dataset:

```text
C:\devel\yolo-ocr\dataset_augmented
```

Composizione:

```text
train: 247 immagini, 1482 bbox
val:     5 immagini,   30 bbox
test:    2 immagini,   12 bbox
```

Nota importante: l'aumento dati e' applicato solo al train. Validation e test restano immagini originali, quindi sono utili per misurare se il modello generalizza.

Augmentation applicate:

- piccole rotazioni;
- piccole traslazioni;
- scala leggera;
- contrasto/luminosita';
- CLAHE;
- sharpening;
- blur leggero;
- rumore;
- compressione JPEG simulata.

## Training GPU

Addestramento eseguito sulla RTX 3050:

```powershell
yolo detect train data=C:\devel\yolo-ocr\dataset_augmented\data.yaml model=yolov8n.pt epochs=120 imgsz=640 batch=16 workers=0 device=0 project=C:\devel\yolo-ocr\training_runs name=digits_yolov8n_aug_gpu patience=30 seed=42
```

Il training e' terminato con early stopping:

```text
Best epoch: 11
Epoch completate: 41
Durata: circa 0.098 ore
```

Metriche YOLO finali su validation:

```text
precision: 0.826
recall:    0.873
mAP50:     0.990
mAP50-95:  0.745
```

Velocita' indicativa:

```text
preprocess: 0.6 ms
inference:  7.7 ms
postprocess: 4.1 ms
```

## Artefatti

Peso PyTorch:

```text
C:\devel\yolo-ocr\models\udc_digits_yolov8n_aug.pt
```

Export ONNX:

```text
C:\devel\yolo-ocr\models\udc_digits_yolov8n_aug.onnx
```

Run originale:

```text
C:\devel\yolo-ocr\training_runs\digits_yolov8n_aug_gpu
```

## Valutazione codice intero

Con soglia standard:

```powershell
python C:\devel\yolo-ocr\tools\evaluate_code_accuracy.py --model C:\devel\yolo-ocr\training_runs\digits_yolov8n_aug_gpu\weights\best.pt --dataset C:\devel\yolo-ocr\dataset_augmented --split test --device 0 --conf 0.25 --iou 0.50 --output C:\devel\yolo-ocr\outputs\code_eval_aug_test
```

Risultato su test:

```text
images=2
code_ok=0
code_accuracy=0.0000
char_accuracy=0.3333
```

Il problema era una cifra mancante nei due codici:

```text
187184 -> 17184
182368 -> 18268
```

Abbassando la soglia a `conf=0.15`, sui 2 test il codice completo diventa corretto:

```text
conf=0.15, iou=0.35..0.65
code_accuracy=1.0000
char_accuracy=1.0000
```

Pero' sulla validation originale, sempre con `conf=0.15`, il risultato resta insufficiente:

```text
images=5
code_ok=1
code_accuracy=0.2000
char_accuracy=0.7812
```

Esempi validation:

```text
187184 -> 187184   OK
182430 -> 18243601 NO
182519 -> 182610   NO
182511 -> 182611   NO
182242 -> 18224    NO
```

## Conclusione

La strada del dataset aumentato e' utile: le metriche YOLO sugli oggetti sono migliorate molto e la GPU funziona bene.

Pero' il problema reale non e' ancora risolto, perche' noi non dobbiamo solo rilevare cifre: dobbiamo ricostruire un codice numerico affidabile. Il modello ora e' sensibile alla soglia di confidenza e produce ancora cifre duplicate, mancanti o confuse.

Non conviene integrare questo OCR in `flywms` in questa forma.

## Prossimo passo tecnico

Prima di altro training, serve migliorare il post-processing del codice:

- soglia bassa controllata;
- ordinamento sinistra-destra;
- clustering/merge dei bbox vicini;
- vincolo codice a 6 cifre;
- gestione duplicati;
- report per capire quali cifre sono davvero ambigue.

Solo dopo questa fase ha senso decidere se aumentare ancora il dataset o cambiare architettura.