protocollo-4b / README.md
Dacso's picture
Protocollo 4B v0.1: GGUF Q8_0 e Q4_K_M, adapter LoRA, scheda del modello
551f812 verified
|
Raw History Blame Contribute Delete
6.47 kB
---
license: apache-2.0
language:
- it
base_model: rizzoaiacademy/rizzo-flow
datasets:
- dacso-ai/protocollo-dati
- dacso-ai/protocollo-train-righe
tags:
- gguf
- llama.cpp
- lora
- italian
- documents
- fatturapa
- pec
- phishing
- typed-decisions
pipeline_tag: text-classification
---
# Protocollo 4B v0.1
**Un modello aperto che protocolla la posta di un'azienda italiana: PEC, fatture elettroniche, F24, avvisi del Fisco, atti, mail dei clienti, truffe. Gira in locale, anche senza GPU.**
Non scrive testo: per ogni documento risponde a domande a scelta chiusa con le probabilità di ogni risposta. Che tipo di documento è? A quale ufficio va? Cosa bisogna fare? C'è una scadenza, e fra quanti giorni? Che rischio c'è? È una truffa? Contiene dati sensibili?
È [Rizzo Flow 4B](https://huggingface.co/rizzoaiacademy/rizzo-flow) con un adapter LoRA addestrato sui documenti italiani di [protocollo-dati](https://huggingface.co/datasets/dacso-ai/protocollo-dati). Codice, dati e prove: [github.com/dacso-ai/protocollo](https://github.com/dacso-ai/protocollo).
> **Smista e segnala, non sostituisce il commercialista o l'avvocato.** Le probabilità non sono calibrate su posta reale: i documenti con una possibile scadenza o una possibile truffa vanno sempre visti da una persona.
## File
| File | Dimensione | Uso |
|---|---|---|
| `protocollo-4b-v01-q8_0.gguf` | 4,1 GB | consigliato; è la versione misurata qui sotto |
| `protocollo-4b-v01-q4_k_m.gguf` | 2,4 GB | per PC con poca memoria; **non ancora misurata** |
| `lora/` | 124 MB | l'adapter LoRA (r 16, alpha 32) da applicare a `rizzoaiacademy/rizzo-flow` rev `55633c8` |
| `training/storia.json` | | loss e valutazioni dell'addestramento |
I GGUF sono prodotti con llama.cpp b11081 da [addestramento/esporta.py](https://github.com/dacso-ai/protocollo/blob/main/addestramento/esporta.py). La stessa catena, applicata con un adapter vuoto, riproduce byte per byte il GGUF Q8_0 ufficiale di Rizzo Flow.
## Come si usa
Con il server di [Rizzo Flow](https://github.com/Rizzo-AI-Academy/rizzo-flow) (llama.cpp, su CPU, Apple, NVIDIA o AMD):
```bash
uv run rizzo serve --model protocollo-4b-v01-q8_0.gguf
```
Le domande sono in [protocollo/domande.json](https://github.com/dacso-ai/protocollo/blob/main/protocollo/domande.json) e vanno inviate a `POST /v1/decisions` così come sono. Lo stato è il testo del documento, con in testa la riga "Ricevuto il ...", che serve a contare i giorni alla scadenza:
```bash
curl http://127.0.0.1:8017/v1/decisions -H 'Content-Type: application/json' -d '{
"state": "Ricevuto il 30/10/2026 via mail da amministrazione@fornitore-srl.com\nSpett.le cliente, il nostro conto è cambiato: pagate le fatture aperte sul nuovo IBAN LT12 ... Non contattate la banca.",
"questions": {"phishing": {"type": "boolean", "instructions": "È una truffa? Per esempio un finto ente, una finta fattura con un link da cliccare, un fornitore che chiede di pagare su un IBAN nuovo."}}
}'
```
Il modello è stato addestrato con quelle domande e con quel prompt (compilato da Rizzo Flow, `spark-decisions-v3`). Con domande diverse funziona come Rizzo Flow, ma non è stato misurato.
## Risultati
Prova zero: 50 documenti (28 dal generatore, 22 scritti a mano), 399 decisioni, stesso server per tutti e due i modelli (Q8_0, Mac Pro, solo CPU).
| | Rizzo Flow 4B | **Protocollo 4B v0.1** |
|---|---|---|
| Decisioni giuste | 328/399 (82%) | **394/399 (99%)** |
| Documenti scritti a mano | 121/157 (77%) | **154/157 (98%)** |
| Scadenze mancate | 0 su 25 | 0 su 25 |
| Truffe non viste | 1 su 3 | **0 su 3** |
| Documento | Rizzo Flow | Protocollo v0.1 |
|---|---|---|
| Nota di credito | fattura, da pagare | nota di credito, archiviare |
| Decreto ingiuntivo (40 giorni) | da pagare | all'avvocato |
| Cambio IBAN da un dominio simile | rispondere, non è una truffa | truffa, cestinare |
**Come leggere questi numeri.** Sono un buon segnale, non ancora una prova indipendente. I documenti generati vengono dallo stesso generatore dell'addestramento, anche se con semi diversi. Quelli scritti a mano li ha scritti chi ha disegnato anche gli scenari del dataset. Le risposte di procedura (per esempio "inoltrare" un avviso bonario al commercialista) sono scelte nostre, e il modello le ha imparate. La misura indipendente sarà un benchmark etichettato da commercialisti, avvocati e amministrativi su documenti che non abbiamo scritto noi.
Sulle 800 domande di controllo del dataset l'accuratezza è passata da 0,74 a 0,99 durante l'addestramento.
## Addestramento
- Base: `rizzoaiacademy/rizzo-flow`, revisione `55633c8` (Spark-X2.5-4B con il LoRA di Rizzo Flow già unito, Apache-2.0).
- LoRA r 16, alpha 32, dropout 0,05 su `q_k_v_proj`, `g_proj`, `out_proj`, `gate_proj`, `up_proj`, `down_proj`; 32,4 M parametri addestrabili.
- Loss: cross-entropy morbida sulle sole lettere di risposta all'ultima posizione del prompt, come Rizzo Flow. Nessun testo generato.
- Dati: 13.082 domande da [protocollo-train-righe](https://huggingface.co/datasets/dacso-ai/protocollo-train-righe), una passata. AdamW, lr 5e-5 con coseno, 16 domande per passo, 765 passi.
- Hardware: una NVIDIA T4 gratuita di Kaggle, fp16 con GradScaler, 9,4 ore. Notebook: [protocollo_lora_kaggle.ipynb](https://github.com/dacso-ai/protocollo/blob/main/addestramento/protocollo_lora_kaggle.ipynb).
## Limiti
- Dati di addestramento sintetici: la posta vera è più disordinata (scansioni, allegati, inoltri a catena).
- Prompt di più di 2.048 token esclusi dall'addestramento: le fatture XML molto lunghe sono poco rappresentate.
- Sulla CPU (Xeon a 16 core) risponde in circa 20 secondi a documento con 8-12 domande. Con una GPU, secondo i numeri di Rizzo Flow, i tempi scendono a frazioni di secondo.
- Gli errori rimasti nella prova zero: un acconto letto come TD01, due conteggi di giorni sbagliati, un reclamo per ritardo mandato al commerciale, una conferma d'ordine segnata come "da pagare".
## Licenza e crediti
Apache-2.0, come il modello base. L'idea dei modelli "System One" è di [TypeSafe](https://typesafe.ai) (Jev). Modello base, prompt e server sono di [Rizzo Flow](https://github.com/Rizzo-AI-Academy/rizzo-flow) (Rizzo AI Academy), a sua volta basato su [Spark-X2.5](https://huggingface.co/XHToken/Spark-X2.5-4B) e ispirato a [SemIf](https://github.com/TheoLeeCJ/SemIf). Protocollo non è affiliato a nessuno di questi progetti.
Un progetto di [DACSO](https://dacso.it), Crema.