---
title: "Mario-1: un modello italiano che gira su una CPU, YecoAI Research"
description: "Mario-1 è un modello italiano da 0,8 miliardi di parametri che gira su CPU. Come l'abbiamo addestrato, i benchmark confrontati con Emma-6 e Qwen2.5, e i limiti dichiarati con onestà."
url: "https://yecoai.com/it/research/mario-1"
locale: "it"
published: "2026-10-30"
updated: "2026-10-30"
category: "Research"
---

# Mario-1: un modello italiano che gira su una CPU

Un modello linguistico da 0,8 miliardi di parametri, addestrato per l'italiano. Gira su CPU senza GPU e sa riconoscere le trappole, ammettere ciò che non sa e fare calcoli affidabili.

*30 Oct 2026 · Research*

Mario-1 è un modello linguistico da 0,8 miliardi di parametri, costruito da YecoAI per parlare bene l'italiano. La sua caratteristica più concreta è che gira su un server normale, senza GPU: risponde in pochi secondi. La seconda è che non si limita a generare testo. Riconosce le domande con trappola, ammette quando non sa, tiene una conversazione per più turni e fa i conti in modo affidabile.

- **Parametri:** 0,8 B (0%). Un modello piccolo, ma non minuscolo
- **Token al secondo:** ~30 (0%). Con 4-6 thread su CPU standard
- **RAM:** < 1 GB (0%, lower is better). Il modello caricato in memoria
- **Tempo di risposta:** 3-5 s (0%, lower is better). Per una risposta tipica

## Il problema: i piccoli modelli pensano in inglese

I modelli aperti di dimensioni ridotte sono quasi sempre pensati per l'inglese. Il vocabolario è spezzettato male sull'italiano, e l'attenzione al comportamento è minima. Il risultato è un modello che può essere perfetto nella grammatica e inutile nella sostanza: inventa un dato, si presenta come un altro assistente, cade in una domanda capziosa e non ammette di non sapere.

Mario-1 nasce al contrario. Il vocabolario è nativo italiano, quindi le parole comuni occupano meno token e le risposte arrivano prima. L'addestramento tratta il comportamento come parte del lavoro: chi è, cosa sa e cosa non sa conta quanto la conoscenza stessa.

## Come l'abbiamo addestrato

Due fasi. Prima un pretraining su un corpus italiano, poi un fine-tuning mirato su dieci aree: matematica, geografia, storia, cultura, creatività, ironia, identità, trappole, limiti e conversazione. Ma il vero lavoro è stato nel modo di scegliere quale versione tenere.

- **Due esami, non uno.** Ogni versione è testata sul set di domande ufficiale e su un set di parafrasi. Se va bene solo sulle formulazioni note, sta memorizzando, non sapendo.
- **Soglie decise prima.** Ogni candidato viene accettato o scartato con criteri fissati prima degli esperimenti, non giudicati a posteriori.
- **Controllo della contaminazione.** Abbiamo confrontato automaticamente i dati di addestramento con le domande di valutazione. Una parte del dataset storico conteneva quasi-duplicati delle domande di test, quindi alcune metriche precedenti erano troppo ottimiste. Le abbiamo corrette.

## Il risultato più importante: il tetto dello 0,8B

Abbiamo provato tre strade per migliorare la release, cambiando una sola variabile alla volta: dosi di dati corrette, dati più puliti, addestramento più corto. Il risultato è stato sempre lo stesso. Ogni guadagno nelle aree di conoscenza costava un calo nel comportamento (conversazione, identità, limiti), e viceversa. Non è un problema di ricetta: è il limite di capacità di un modello da 0,8B. Per questo il prossimo passo richiede un base model più grande.

## CALC: calcoli affidabili senza riaddestrare

I piccoli modelli sbagliano l'aritmetica in modo sistematico, e spesso lo fanno due volte: sbagliano il calcolo, poi scrivono nella risposta un numero diverso da quello del proprio strumento. CALC risolve entrambe le cose a tempo di inferenza e a costo zero. Le espressioni vengono ricalcolate in un ambiente sicuro e la risposta viene riallineata al risultato corretto. Se il calcolo non è ricostruibile, il numero viene tolto invece di essere inventato. Effetto misurato: +2 punti sull'area matematica, senza toccare il modello.

## I risultati interni

Ogni area è valutata su 0-100, sul set ufficiale più le parafrasi. Il profilo è netto: il modello è forte dove conta l'identità e i limiti, più debole dove serve creatività e conversazione lunga. La media è circa 72.

### Mario-1 v14e: punteggio per area

Punteggio interno per area, più alto è meglio

|  | Mario-1 v14e |
|---|---|
| Identità | 100 |
| Limiti | 95 |
| Storia | 90 |
| Cultura | 75 |
| Trappole | 75 |
| Matematica (con CALC) | 73 |
| Geografia | 65 |
| Ironia | 65 |
| Conversazione multi-turno | 60 |
| Creatività | 50 |

Set ufficiale più parafrasi, scala 0-100.

## Contro Emma-6, il principale concorrente italiano

Emma-6 ha 1,55 miliardi di parametri, quasi il doppio di Mario-1. Mario-1 vince sulla media ITA-Bench (39,9 contro 37,6) e su BoolQ e Belebele-it. Emma-6 resta avanti su ARC-Challenge, HellaSwag e TruthfulQA, dove le differenze sono piccole. Belebele-it non rientra nella media ITA-Bench.

### Mario-1 (0,8B) contro Emma-6 (1,55B)

Accuratezza su benchmark italiani, più alto è meglio

|  | Mario-1 (0,8B) | Emma-6 (1,55B) |
|---|---|---|
| ARC-Challenge | 26.5 | 31 |
| HellaSwag | 40 | 41.5 |
| BoolQ | 60.5 | 43.5 |
| TruthfulQA | 29.5 | 30.5 |
| Belebele-it | 30 | 23 |
| Media ITA-Bench | 39.9 | 37.6 |

Accuratezza %, zero-shot. Belebele-it escluso dalla media ITA-Bench.

## Contro i modelli di frontiera della stessa classe

Qwen2.5-0.5B-Instruct e Llama-3.2-1B-Instruct sono modelli di riferimento per la loro classe, addestrati su trilioni di token con budget stimati nell'ordine dei milioni di dollari. Mario-1 li supera su BoolQ e Belebele-it, e resta indietro sulla media ITA-Bench, dove Qwen2.5 è il migliore.

### Mario-1 contro Qwen2.5 e Llama 3.2 (1B)

Accuratezza su benchmark italiani, più alto è meglio

|  | Mario-1 (0,8B) | Qwen2.5-0.5B-Instruct | Llama-3.2-1B-Instruct |
|---|---|---|---|
| ARC-Challenge | 26.5 | 27.5 | 30 |
| HellaSwag | 40 | 38 | 44.5 |
| BoolQ | 60.5 | 59 | 49.5 |
| TruthfulQA | 29.5 | 31.5 | 32 |
| Belebele-it | 30 | 25 | 29.5 |
| Media ITA-Bench | 39.9 | 42.6 | 41.8 |

Accuratezza %, zero-shot. Belebele-it escluso dalla media ITA-Bench.

## Servire un modello piccolo, davvero

Un modello da 0,8B è utile solo se gira ovunque. Mario-1 è ottimizzato per l'inferenza su CPU: circa 30 token al secondo con 4-6 thread e meno di 1 GB di RAM. Portarlo in produzione ha richiesto di risolvere differenze sottili tra i framework nella gestione delle posizioni, del tokenizer e del formato di conversazione incorporato nel file finale. Il risultato è verificato: le risposte del modello servito sono identiche, parola per parola, a quelle del modello di riferimento interno.

## Cosa non sa fare ancora

- Creatività e conversazione lunga sono le aree più deboli. È il tetto di capacità descritto sopra, non un difetto di addestramento.
- I calcoli sono affidabili solo nei tipi di problema che CALC riconosce. Fuori da lì il modello può sbagliare.
- I documenti lunghi restano un punto debole: non erano un obiettivo dell'addestramento.
- La conoscenza è reale ma non del tutto robusta alle parafrasi: 93 sul set ufficiale, 87 sulle parafrasi.

## Cosa viene dopo

Tutto il metodo costruito su Mario-1, cioè dataset verificati contro la contaminazione, doppia valutazione, soglie fissate in anticipo e ottimizzazioni di deploy, passa al prossimo modello YecoAI, costruito su un base model più grande. Lì le aree oggi al tetto possono crescere senza sacrificare il comportamento.

> Un modello piccolo non deve essere un giocattolo: deve essere onesto su ciò che sa e su ciò che non sa.

```json
{
  "@context": "https://schema.org",
  "@id": "https://yecoai.com/it/research/mario-1#page",
  "url": "https://yecoai.com/it/research/mario-1",
  "name": "Mario-1: un modello italiano che gira su una CPU, YecoAI Research",
  "description": "Mario-1 è un modello italiano da 0,8 miliardi di parametri che gira su CPU. Come l'abbiamo addestrato, i benchmark confrontati con Emma-6 e Qwen2.5, e i limiti dichiarati con onestà.",
  "inLanguage": "it",
  "isPartOf": {
    "@id": "https://yecoai.com/#website"
  },
  "image": "https://yecoai.com/api/media/file/mario-1.svg",
  "@type": "ScholarlyArticle",
  "headline": "Mario-1: un modello italiano che gira su una CPU",
  "mainEntityOfPage": "https://yecoai.com/it/research/mario-1",
  "datePublished": "2026-10-30T00:00:00.000Z",
  "dateModified": "2026-10-30T12:10:47.051Z",
  "articleSection": "Research",
  "author": {
    "@id": "https://yecoai.com/#organization"
  },
  "publisher": {
    "@id": "https://yecoai.com/#organization"
  }
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home YecoAI",
      "item": "https://yecoai.com/it"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Research",
      "item": "https://yecoai.com/it/research"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Mario-1: un modello italiano che gira su una CPU",
      "item": "https://yecoai.com/it/research/mario-1"
    }
  ]
}
```