LLM italiani nel 2024: Minerva, LLaMAntino e i primi modelli nativi

Context 2024: Perché i modelli italiani erano necessari

Nel 2023-2024, i servizi AI cloud proprietari dominavano il mercato, ma avevano limiti gravi per il contesto italiano: costi di inferenza proibitivi, latenza inaccettabile per applicazioni real-time, e violazione della privacy per dati sensibili (medici, legali, finanziari). I modelli multilingue (LLaMA 7B, Mistral 7B base) avevano performance degradate sull'italiano rispetto all'inglese — problema noto come "english bias".

La necessità di modelli specializzati in italiano divenne evidente a livello di ricerca (Sapienza NLP, UniMi) e dalle startup italiane che volevano privacy first e costi operativi prevedibili. Nel 2024 compaiono i primi modelli monolinguistici o bene-adattati all'italiano.

Modello 1: Minerva — LLM nativo italiano da Sapienza NLP

Architettura e Training

Minerva è un modello Transformer autoregressive, base da scratch su ~10 miliardi di token di testo italiano. A differenza di altri modelli adattati, Minerva è stato addestrato from-scratch con un curriculum learning specifico per il dialetto italiano. Il vocabolario (tokenizer SentencePiece) è ottimizzato per morfologia italiana.

Dataset di training: Wikipedia italiano, corpus giuridico italiano, news archive, forum tecnici italiani — circa 50 GB di testo grezzo, deduplicated e filtrato per qualità.

Parametri: versioni da 3B e 7B nel 2024; la versione 3B è deployabile su hardware modesto (GPU A100 40GB o RTX 4090).

Benchmark e Performance

Su benchmark EVALITA (Italian Language Evaluation) 2024, Minerva-7B supera LLaMA-7B base del 15-22% su task come entity recognition, sentiment analysis e question-answering in italiano. Su compiti generici (perplexity, generazione creativa), la performance è simile a LLaMA-7B, ma con latenza 30% inferiore grazie al tokenizer ottimizzato.

Limiti 2024: context window limitato a 2048 token (vs 4096 di LLaMA 2), nessuna versione chat-tuned ufficiale (richiede fine-tuning custom), e memoria GPU ancora importante per 7B.

Deployment via Ollama

Minerva è disponibile su Hugging Face in formato GGML (quantizzato), totalmente compatibile con Ollama:

# Pull Minerva 7B da Hugging Face (tramite Ollama)
ollama pull sapienzanlp/minerva-7b

# Esegui in locale
ollama run sapienzanlp/minerva-7b

# Interattivo
$ Che cos'è la filosofia?
La filosofia è lo studio sistematico dei concetti fondamentali della realtà,
della conoscenza e dei valori. Affonda le radici nella Grecia antica...
  

Modello 2: LLaMAntino — Adattamento LLaMA per italiano

Strategy: Continual Pretraining

LLaMAntino parte da LLaMA 7B base (Meta) e applica continual pretraining su corpus italiano per ~2 miliardi di token aggiuntivi. La strategia è più economica che training from-scratch (una GPU A100 per 1-2 settimane vs mesi), e mantiene le capacità di lingua inglese del modello originale.

Vantaggio: eredita la stabilità di training di LLaMA e l'ecosystem di fine-tuning già sviluppato. Svantaggio: l'english bias non viene eliminato del tutto — rimane performance leggermente degradata su compiti puramente italiani vs modelli nativi.

Dataset e Vocabolario

Corpus: Wikipedia italiano, archivi giornalistici italiani (Repubblica, Corriere), repository GitHub italiani (documentazione), ed estratti da social media filtrati. Vocabolario: riusa tokenizer SentencePiece di LLaMA, aggiungendo ~3000 token speciali per parole italiane frequenti.

Risultati Empirici 2024

Su EVALITA, LLaMAntino-7B ottiene 8-12% migliore di LLaMA-7B base sull'italiano, ma 5-7% peggio di Minerva su NER e task grammaticali. Su generazione creativa (racconti, articoli), LLaMAntino è più versatile grazie al corpus di training inglese-italiano misto.

Modello 3: Camoscio — Instruction-Tuned Italian Model

Camoscio è una versione instruction-tuned di un base model italiano (LLaMA adattato), fine-tuned su una raccolta di istruzioni e risposte in italiano. A differenza di Minerva (base), Camoscio è già pronto per chat e task di istruzioni.

Instruction Dataset

~50k instruction-response pair curate manualmente + generate con i modelli stessi (auto-distillation). Copertura: translation, summarization, Q&A, creative writing, coding task in italiano.

Performance vs. Base Models

Su compiti di istruzioni, Camoscio-7B supera Minerva base e LLaMAntino base di 20-30% (user preference studies). Su benchmark BLEU per translation è inferiore specializzato di un punto, ma offre migliore UX per chat conversazionale.

Modello 4: Fauno — Generalist Open-Source Model

Fauno è un modello multilingue open-source italiano-centrico, con ottime performance sia su italiano che inglese. Disponibile in versioni 3B, 7B, e 13B. A differenza di Minerva (monolinguistico), Fauno mantiene capacità multilingue, utile per applicazioni che richiedono code-switching o multi-lingua.

Use Cases Primari

• RAG italiano: Fauno è efficiente in embedding + retrieval su corpus italiano, supporta context window 4k
• Multilingual chat: Genera in italiano, inglese, spagnolo senza degradazione significativa
• Fine-tuning verticale: Fauno 7B è altamente efficiente per domain adaptation (legal, medical)

Architettura Transformer Comune (Attention)

Tutti e quattro i modelli (Minerva, LLaMAntino, Camoscio, Fauno) seguono la stessa architettura base: Transformer decoder-only con self-attention e feed-forward layer. La differenza è nel vocabolario, nei dati di training, e in eventuali fine-tuning successivi.

# Carica Minerva via transformers (alternativa a Ollama per inference batch)
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_name = "sapienzanlp/minerva-7b"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    device_map="auto",
    torch_dtype=torch.float16,  # Quantizzazione a 16-bit
)

# Generazione
prompt = "La ricerca scientifica in Italia"
inputs = tokenizer(prompt, return_tensors="pt")
outputs = model.generate(
    inputs.input_ids,
    max_new_tokens=256,
    temperature=0.7,
    top_p=0.9,
)
text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(text)
  

Dataset e Benchmark Pubblici EVALITA 2024

Corpus di Training

La qualità dei dataset è critica. Nel 2024, i dataset italiani sono ancora limitati rispetto all'inglese:

• Wikipedia italiano: ~1.7M articoli, ~19GB testo grezzo
• Italian News Archive: ~2M articoli da stampa nazionale, 2010-2024
• Italian Legal Corpus: Codice Civile, Costituzione, sentenze (filtrate per anonimato)
• GitHub repos italiano: README, documentation, issues (~500M token)

EVALITA Benchmark 2024

EVALITA (Evaluation of NLP and Speech Tools for Italian) organizza annual shared task. Nel 2024 include:

• Named Entity Recognition (NER): Riconoscimento persone, organizzazioni, luoghi in testi news
• Sentiment Analysis: Classificazione sentimento su social media italiani (polarità positiva/negativa/neutra)
• Coreference Resolution: Linking pronomi al referente corretto in testi lunghi
• Question Answering: Domande in italiano su Wikipedia e documenti

Ranking EVALITA 2024 (punteggio medio F1):

1. Minerva-7B          : 81.3 (NER), 84.1 (Sentiment), 79.2 (QA)
2. Fauno-7B            : 80.1 (NER), 83.5 (Sentiment), 78.9 (QA)
3. LLaMAntino-7B       : 78.9 (NER), 82.3 (Sentiment), 77.6 (QA)
4. Camoscio-7B         : 79.8 (NER), 83.1 (Sentiment), 76.3 (QA)
5. LLaMA-2-7B (base)   : 74.2 (NER), 78.9 (Sentiment), 72.1 (QA)
  

Limitazioni Critiche nel 2024

Context Window Limitato

La maggior parte dei modelli italiani nel 2024 ha context window di 2k-4k token, insufficiente per document understanding lunghi o RAG su corpus esteso. Minerva base: 2k token. LLaMAntino e Fauno: 4k. Questo limita l'applicabilità su task come "riassumi un intero report di 50 pagine".

Mancanza di Multilingual Reasoning

Modelli come Minerva (monolinguistici) hanno difficoltà quando il prompt include frammenti di codice (spesso in inglese) o citazioni in altra lingua. LLaMAntino ereditato da LLaMA gestisce meglio questo, ma non è ottimale.

Assenza di Vision (2024)

Nessun modello vision-language italiano nel 2024 (CLIP italiano, LLaVA italiano). Se serve elaborare immagini con QA in italiano, è necessario fallback a modelli multilingue generici.

Hallucinazione su Dominio Specializzato

Su compiti medici, legali, scientifici altamente specializzati, anche i migliori modelli italiani hanno tasso di hallucination (generazione fattualmente errata) del 15-25%, simile ai modelli base. Fine-tuning verticale è essenziale per questi use case.

Esecuzione Locale via Ollama on-Premises

Setup Minimalista

L'infrastruttura richiesta per servire un modello italiano 7B è modesta rispetto ai servizi AI cloud proprietari:

# 1. Installa Ollama su Linux
curl https://ollama.ai/install.sh | sh

# 2. Start Ollama daemon
ollama serve

# 3. Pull modello (una sola volta)
# In un'altro terminale:
ollama pull sapienzanlp/minerva-7b

# 4. Interroga via REST API
curl http://localhost:11434/api/generate -d '{
  "model": "sapienzanlp/minerva-7b",
  "prompt": "Descrivi brevemente la storia della filosofia italiana",
  "stream": false
}'

# Response:
# {
#   "model": "sapienzanlp/minerva-7b",
#   "created_at": "2024-07-15T10:00:00Z",
#   "response": "La filosofia italiana affonda le radici nel Rinascimento...",
#   "done": true,
#   "total_duration": 1250000000,
#   "load_duration": 250000000,
#   "prompt_eval_count": 12,
#   "eval_count": 128
# }
  

Performance Hardware Minima (2024)

• Minerva-3B: GPU 8GB (RTX 3060), CPU 4-core, RAM 16GB. Latency: 150-300ms per token
• Minerva-7B: GPU 24GB (RTX 4090, A100 40GB), CPU 8-core, RAM 32GB. Latency: 80-150ms per token
• Fauno-13B: GPU 40GB (A100), CPU 16-core, RAM 64GB. Latency: 50-100ms per token

Integrazione in Production (FastAPI + Ollama)

# FastAPI service che wrappa Ollama per RAG italiano
from fastapi import FastAPI, HTTPException
import httpx
import asyncio

app = FastAPI()

OLLAMA_BASE_URL = "http://localhost:11434"
MODEL = "sapienzanlp/minerva-7b"

@app.post("/api/generate")
async def generate_text(prompt: str, max_tokens: int = 256):
    """
    Wrappa Ollama con error handling e rate limiting.
    """
    try:
        async with httpx.AsyncClient() as client:
            resp = await client.post(
                f"{OLLAMA_BASE_URL}/api/generate",
                json={
                    "model": MODEL,
                    "prompt": prompt,
                    "stream": False,
                    "num_predict": max_tokens,
                },
                timeout=30.0,
            )
            resp.raise_for_status()
            return resp.json()
    except httpx.ConnectError:
        raise HTTPException(status_code=503, detail="Ollama service unavailable")

# Test
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)
  

Fine-tuning Verticale: Adattare Modelli per Dominio Specializzato

Nel 2024, il vero differenziale non è il modello base, ma la capacità di fine-tuning veloce per dominio. Esempio: Minerva-7B fine-tuned su 10k example medici-italiani supera Minerva base di 30% su task medici.

Tecnica: Low-Rank Adaptation (LoRA), che riduce i parametri trainable da 7B a ~1-2M. Con 1 GPU A100 e 10k example, il training richiede 4-6 ore.

# Fine-tuning Minerva via LoRA (pseudo-code)
from peft import LoraConfig, get_peft_model
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    Trainer,
    TrainingArguments,
)

model_name = "sapienzanlp/minerva-7b"
model = AutoModelForCausalLM.from_pretrained(
    model_name, torch_dtype=torch.float16, device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Configura LoRA
lora_config = LoraConfig(
    r=8,                          # Rank ridotto
    lora_alpha=16,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

model = get_peft_model(model, lora_config)

# Training
training_args = TrainingArguments(
    output_dir="./minerva-medical-lora",
    per_device_train_batch_size=4,
    num_train_epochs=3,
    learning_rate=1e-4,
    save_steps=100,
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=medical_italian_dataset,
)

trainer.train()
  

Comparazione Veloce: 2024 vs Provider Cloud

Roadmap 2025: Cosa Aspettarsi

Nel 2024 il panorama italiano è ancora nascente. Il 2025 porterà:

• Modelli con context window 8k-16k (miglior RAG)
• Versioni vision (CLIP italiano, LLaVA italic) — ancora assenti
• Modelli specializzati verticali (legal, medical, coding)
• Benchmark pubblici standardizzati per comparazione affidabile

FAQ: Domande Comuni nel 2024

D: Minerva è pronto per produzione?

R: Sì, con caveat. Per compiti NER, sentiment, Q&A ha performance sufficiente. Per dominio altamente specializzato (medico, legale), richiede fine-tuning. Non è adatto per low-latency real-time (>500ms accettabile per chat, ma critico per automotive).

D: Posso usare LLaMAntino su un laptop con sola CPU?

R: Tecnicamente sì, ma è lentissimo — ~500ms per token. Pratica: serve almeno GPU 8GB (RTX 3060 o equivalente). Un laptop M2 MacBook è borderline (16GB unified memory).

D: Come faccio RAG su 10k documenti italiani con Ollama?

R: Vedi l'articolo RAG system con Ollama: retrieval-augmented generation on-prem. Riassunto: embedding via sentence-transformers italiano, vector store (FAISS o Milvus), retrieval + prompt composition.

D: Devo scegliere tra Minerva e Fauno?

R: Minerva se serve massima performance italiana pura. Fauno se serve multilinguismo (code-switching, supporto EN+IT+ES). LLaMAntino se già conosci il LLaMA ecosystem e vuoi continuità.

D: I modelli italiani allucinano?

R: Sì, come tutti gli LLM. Tasso di hallucination ~15-20% su compiti fattici. Usare sempre RAG o verification step per task mission-critical.