---
title: "Correttore ortografico e grammaticale arabo con un LLM"
description: "Correggi ortografia e grammatica arabe con un’API LLM: prompt a modifiche minime, controllo anti-riscrittura, modifiche per tipo di errore e punteggio M2."
url: https://broadrouter.com/it/blog/arabic-grammar-spelling-correction-llm/
lang: it
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Tradotto dall’inglese con l’aiuto dell’IA. [Leggi l’originale in inglese](https://broadrouter.com/blog/arabic-grammar-spelling-correction-llm/) (aggiornato il 2026-11-16).

# Correzione grammaticale e ortografica dell’arabo con un LLM: guida

A cura del team di BroadNet Inference · 8 min di lettura · Pubblicato 2026-11-15 · Aggiornato 2026-11-16

Chiedi al modello solo il testo corretto, con il minor numero possibile di modifiche e senza riformulare. Poi confronta nel codice la risposta con l’input: scarta le risposte che cambiano troppo ed etichetta ogni modifica a livello di parola come hamza, taa marbuta, alef maqsura, unione, separazione o altro. Valuta un campione corretto a mano sulle modifiche, con precision, recall e F0.5.

## Punti chiave

-   Sul test set QALB-2014, GPT-4 con cinque esempi ha ottenuto 65,49 di F1, contro 67,70 di un AraT5v2 con fine-tuning (Kwon et al., ArabicNLP 2023). Gli LLM con prompt sono utilizzabili, non automaticamente migliori.
-   Secondo gli organizzatori dello shared task QALB, gli alif con hamza e la confusione tra alef maqsura e ya sono gli errori ortografici più comuni in arabo.
-   La correzione si valuta sulle modifiche, non sulle frasi intere. Estrai dalla risposta le modifiche a livello di parola, confrontale con quelle di riferimento e riporta F0.5, che pesa la precision il doppio della recall.
-   Non normalizzare mai il testo prima di correggerlo. La normalizzazione trasforma di proposito أ إ آ in ا e ة in ه, cancellando proprio gli errori che vuoi correggere.
-   Proteggiti dalle riscritture nel codice: se a livello di caratteri la risposta è simile all’input meno dell’80%, tieni l’originale e registra la risposta nei log.

**In questa pagina**

1.  Quanto sono bravi gli LLM a correggere la grammatica araba?
2.  Perché non normalizzare semplicemente il testo?
3.  Cosa deve dire il prompt?
4.  Come si controlla la risposta del modello?
5.  Quali classi di errore conviene monitorare?
6.  Come si dà un punteggio a un correttore?
7.  E Tibyan e i dati sintetici?
8.  Quale modello BroadNet usare?
9.  Dove si colloca BroadNet Inference

La correzione di bozze in arabo sembra un prompt da una riga: «correggi questo testo». In pratica il modello riformula anche, aggiunge diacritici, sostituisce una parola dialettale con una formale e spiega le sue modifiche, e tu non puoi capire quali fossero necessarie. Questo articolo costruisce, su un LLM compatibile con OpenAI, un correttore che fa il minor numero di modifiche, controlla la risposta nel codice, etichetta ogni modifica per tipo di errore e valuta il tutto come fanno i benchmark di ricerca.

## Quanto sono bravi gli LLM a correggere la grammatica araba?

I benchmark di riferimento sono gli shared task QALB. QALB-2014 ha usato commenti in arabo standard moderno dal sito di Al Jazeera: oltre un milione di parole di testo di addestramento con circa 306.000 correzioni, e test set di circa 50.000 parole. QALB-2015 ha aggiunto un secondo track con temi di studenti di arabo come lingua straniera (L2). Entrambi hanno valutato i sistemi sulle modifiche con l’M2 scorer. I punteggi migliori, in F1 (più alto è meglio):

| Test set | F1 del sistema migliore | Testo |
| --- | --- | --- |
| Test QALB-2014 | 67,91 | Commenti a notizie scritti da madrelingua |
| Test QALB-2015 madrelingua | 72,87 | Commenti a notizie scritti da madrelingua |
| Test QALB-2015 L2 | 41,20 | Temi di studenti |

La riga L2 è l’avvertenza utile. Il testo degli studenti ha più errori di scelta lessicale e parole mancanti, e il sistema migliore ha ottenuto molto meno. Se i tuoi utenti stanno imparando l’arabo, aspettati numeri più simili a quella riga.

Kwon, Bhatia, Nagoudi e Abdul-Mageed (ArabicNLP 2023) hanno poi provato ChatGPT e GPT-4 sul test set QALB-2014. Con lo stesso scorer:

| Sistema | F1 |
| --- | --- |
| ChatGPT, 1 esempio | 53,59 |
| ChatGPT, 5 esempi | 63,98 |
| GPT-4, 5 esempi | 65,49 |
| AraT5v2, con fine-tuning | 67,70 |

Due dettagli contano per il tuo prompt. Più esempi hanno aiutato molto. E i prompt zero-shot e quelli in arabo hanno prodotto risposte piene di spiegazioni che gli autori non riuscivano a valutare in automatico. Un correttore ha bisogno di un output che un programma possa confrontare con un diff.

## Perché non normalizzare semplicemente il testo?

Il [normalizzatore di testo arabo](https://broadrouter.com/tools/arabic-text-normalizer/) di questo sito toglie tashkeel e tatweel, trasforma أ إ آ in ا e, a scelta, ى in ي e ة in ه. È il passaggio giusto per la ricerca, perché chi digita احمد deve trovare أحمد. È il passaggio sbagliato prima della correzione, perché cancella proprio la distinzione che il correttore deve ripristinare. Dopo la normalizzazione, انا e أنا sono la stessa stringa: l’errore di hamza sparisce, e con lui la correzione.

Se ti servono entrambe le cose, tieni tre copie: il testo originale, il testo corretto che mostri agli utenti e una copia normalizzata del testo corretto per l’indice di ricerca. [Normalizzazione del testo arabo per la ricerca](https://broadrouter.com/it/blog/arabic-text-normalization-search/) tratta la parte di indicizzazione. Un solo passaggio di normalizzazione va fatto prima della correzione: Unicode NFC, che unisce un alif scomposto più la hamza combinante in un unico carattere, così il diff non segnala una modifica che non c’è.

## Cosa deve dire il prompt?

Chiedi modifiche minime, nomina i tipi di errore che ti interessano, vieta le modifiche che non vuoi e chiedi solo il testo corretto. Scrivere le istruzioni in inglese o in arabo è una tua scelta; [prompt engineering in arabo](https://broadrouter.com/it/blog/arabic-prompt-engineering/) spiega i pro e i contro. Kwon et al. hanno ottenuto output utilizzabili da istruzioni in inglese con esempi. Aggiungere da tre a cinque coppie di frasi corrette prese dai tuoi dati (few-shot) è il miglioramento più economico da provare per primo.

Imposta la temperatura a 0: vuoi la stessa correzione ogni volta. Se il testo è in un dialetto, come l’arabo egiziano o del Golfo, specifica se mantenerlo. Il prompt qui sotto presuppone l’arabo standard moderno ([MSA](https://broadrouter.com/it/glossary/msa/)) e dice al modello di non cambiare stile, il che copre anche il dialetto.

## Come si controlla la risposta del modello?

Il codice fa una richiesta, misura quanto la risposta differisce dall’input, estrae le modifiche a livello di parola ed etichetta ciascuna.

```python
import difflib, os, re, unicodedata
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

SYSTEM = """You are an Arabic proofreader. Correct spelling, grammar and punctuation
errors in the user's Modern Standard Arabic text with the fewest possible edits.
Rules:
- Fix hamza, taa marbuta (ة/ه), alef maqsura (ى/ي), agreement, missing or extra
  letters, wrongly split or merged words, and punctuation.
- Do not rephrase, reorder, shorten, translate or change the style or dialect.
- Do not add or remove diacritics (tashkeel).
- If the text is already correct, return it unchanged.
Reply with the corrected text only: no explanation, no quotes, no list of changes."""

def tokens(s: str) -> list[str]:
    s = unicodedata.normalize("NFC", s)        # composed hamza forms, so أ is one character
    return re.findall(r"\w+|[^\w\s]", s)       # Arabic letters are \w; ، ؟ ؛ become tokens

def edits(src: str, hyp: str) -> list[tuple]:
    """Word-level edits (start, end, replacement, original): the idea behind an M2 file's A lines."""
    a, b = tokens(src), tokens(hyp)
    out = []
    for op, i1, i2, j1, j2 in difflib.SequenceMatcher(None, a, b, autojunk=False).get_opcodes():
        i, j = i1, j1
        while op != "equal" and (i < i2 or j < j2):     # split the block into one-word edits
            if i + 1 < i2 and j < j2 and a[i] + a[i + 1] == b[j]:      # و قابلت -> وقابلت
                out.append((i, i + 2, b[j], f"{a[i]} {a[i + 1]}")); i += 2; j += 1
            elif i < i2 and j + 1 < j2 and a[i] == b[j] + b[j + 1]:    # عبدالله -> عبد الله
                out.append((i, i + 1, f"{b[j]} {b[j + 1]}", a[i])); i += 1; j += 2
            elif i < i2 and j < j2:
                out.append((i, i + 1, b[j], a[i])); i += 1; j += 1
            elif i < i2:                                                # deleted word
                out.append((i, i + 1, "", a[i])); i += 1
            else:                                                       # inserted word
                out.append((i, i, b[j], "")); j += 1
    return out

HAMZA = str.maketrans("أإآٱؤئ", "ااااوي")
RULES = [("hamza", lambda w: w.translate(HAMZA).replace("ء", "")),
         ("taa marbuta", lambda w: w.replace("ة", "ه")),
         ("alef maqsura", lambda w: w.replace("ى", "ي"))]

def error_class(orig: str, corr: str) -> str:
    if all(not c.isalnum() for c in (orig + corr).replace(" ", "")):
        return "punctuation"
    if orig != corr and orig.replace(" ", "") == corr.replace(" ", ""):
        return "merge" if " " in orig else "split"
    for name, f in RULES:
        if orig != corr and f(orig) == f(corr):
            return name
    both = lambda w: RULES[2][1](RULES[1][1](RULES[0][1](w)))
    if both(orig) == both(corr):
        return "mixed orthography"
    return "other"

def correct(text: str, model="broadnet/qwen3.8-27b", min_similarity=0.8) -> dict:
    r = client.chat.completions.create(
        model=model, temperature=0, max_tokens=2000,
        messages=[{"role": "system", "content": SYSTEM}, {"role": "user", "content": text}])
    out = r.choices[0].message.content.strip()
    sim = difflib.SequenceMatcher(None, text, out, autojunk=False).ratio()
    if sim < min_similarity:             # a rewrite, not a correction: keep the original
        return {"text": text, "edits": [], "rejected": out, "similarity": round(sim, 2)}
    return {"text": out, "similarity": round(sim, 2),
            "edits": [{"from": o, "to": c, "class": error_class(o, c)} for _, _, c, o in edits(text, out)]}
```

L’abbiamo eseguito contro un server mock locale con risposte preimpostate (nessuna chiamata all’API reale, perché il mock restituisce quello che abbiamo scritto noi). Per ذهبت الى المدرسه و قابلت المعلمه في الصباح, una risposta ذهبت إلى المدرسة وقابلت المعلمة في الصباح ha dato quattro modifiche: الى in إلى (hamza), المدرسه in المدرسة (taa marbuta), و قابلت in وقابلت (unione) e المعلمه in المعلمة (taa marbuta). Per مشي الي ha elencato مشي in مشى (alef maqsura) e الي in إلى (ortografia mista, perché corregge insieme hamza e alef maqsura). Una risposta preimpostata che trasformava الطقس جميل اليوم in una frase lunga il doppio ha ottenuto 0,52 di similarità, quindi il codice ha tenuto l’originale e registrato la risposta.

Note sul codice:

-   **Il controllo di similarità è uno strumento grezzo.** Una frase con molti errori può legittimamente scendere vicino a 0,8. Regola la soglia sui tuoi dati e manda le risposte scartate a una persona, non nel cestino.
-   **`max_tokens=2000`** lascia spazio al ragionamento. Secondo la documentazione di BroadNet, DeepSeek V4.1 Flash, GLM 5.3 e Qwen3.8 27B ragionano prima di rispondere e il ragionamento conta in `max_tokens`; puoi anche impostare `reasoning_effort` su low. Vedi [risposte vuote dai modelli di ragionamento](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/).
-   **Le etichette di classe sono regole, non un parser.** «Other» comprende lettere mancanti (مسؤل in مسؤول), concordanza e scelta lessicale. Per una tassonomia completa, esegui ARETA (vedi sotto) sulle stesse coppie.

## Quali classi di errore conviene monitorare?

Gli organizzatori di QALB indicano gli alif con hamza e la confusione tra alef maqsura e ya come gli errori ortografici più comuni in arabo. ARETA, l’annotatore di tipi di errore di CAMeL Lab (Belkebir e Habash, CoNLL 2021), usa un tagset basato sull’Arabic Learner Corpus. I suoi tag ortografici includono OH (hamza), OT (ha e taa marbuta) e OA (alif e ya), accanto a tag morfologici, sintattici, semantici, di punteggiatura, di unione (MG) e di separazione (SP). Il paper riporta un F1 micro-medio dell’85,8% rispetto a testo di studenti etichettato a mano.

| Classe | Sbagliato | Giusto | Cosa va storto |
| --- | --- | --- | --- |
| Hamza | انا، الى، مسأله | أنا، إلى، مسألة | Hamza mancante, sul supporto sbagliato o dal lato sbagliato dell’alif |
| Taa marbuta | المدرسه | المدرسة | ة finale scritta come ه, o il contrario |
| Alef maqsura | مشي، علي (preposizione) | مشى، على | ى finale scritta come ي; علي è anche un nome, quindi decide il contesto |
| Unione o separazione | و قابلت، عبدالله | وقابلت، عبد الله | Spazi attorno a و e ال, nomi composti |
| Punteggiatura | ، o ؟ mancanti | aggiunti | È sulla punteggiatura che gli annotatori di QALB erano meno d’accordo |

Monitora la recall per classe. Un modello che corregge la taa marbuta ma non vede la hamza dopo una preposizione ha bisogno di esempi di quello schema, non di un altro modello.

## Come si dà un punteggio a un correttore?

La correzione degli errori grammaticali (GEC) si valuta sulle modifiche. Confronta le modifiche che trasformano la fonte in una frase di riferimento corretta a mano con quelle che la trasformano nell’output del modello. La precision è la quota di modifiche del modello che coincidono con il riferimento. La recall è la quota di modifiche di riferimento che il modello ha fatto. QALB riportava F1; lavori successivi, tra cui Kwon et al., riportano anche F0.5, che pesa la precision il doppio della recall, perché una «correzione» sbagliata infastidisce gli utenti più di una mancata.

```python
from collections import Counter

def score(sources, golds, hyps, beta=0.5):
    """Exact-match edit scoring: an edit counts only if span and replacement both match gold."""
    tp = fp = fn = 0
    by_class = Counter()
    for s, g, h in zip(sources, golds, hyps):
        G = {e[:3] for e in edits(s, g)}
        H = {e[:3] for e in edits(s, h)}
        tp += len(G & H); fp += len(H - G); fn += len(G - H)
        for e in edits(s, g):
            by_class[(error_class(e[3], e[2]), e[:3] in H)] += 1
    p = tp / (tp + fp) if tp + fp else 1.0
    r = tp / (tp + fn) if tp + fn else 1.0
    f = (1 + beta**2) * p * r / (beta**2 * p + r) if p + r else 0.0
    recall = {c: f"{by_class[(c, True)]}/{by_class[(c, True)] + by_class[(c, False)]}"
              for c in sorted({c for c, _ in by_class})}
    return {"P": round(p, 3), "R": round(r, 3), f"F{beta}": round(f, 3), "recall by class": recall}
```

Su un set giocattolo di due frasi con sette modifiche di riferimento, in cui l’output mancava l’unione e una taa marbuta e aggiungeva un punto, ha stampato P 0.833, R 0.714 e F0.5 0.806, con recall per classe: hamza 2/2, taa marbuta 2/3, unione 0/1.

È l’idea di M2, semplificata. L’M2 scorer ufficiale cerca l’allineamento delle modifiche del sistema che meglio corrisponde al riferimento, quindi una correzione giusta ma suddivisa in modifiche in modo diverso non viene penalizzata. Il nostro confronto esatto è più severo. Usa lo scorer ufficiale quando ti confronti con numeri pubblicati (la sua versione per sviluppatori richiede ancora Python 2). ERRANT fa la stessa estrazione delle modifiche, ma solo per l’inglese.

Costruisci il set di riferimento da testo reale degli utenti, da 100 a 200 frasi, corrette da un unico annotatore attento con le stesse regole di modifica minima che hai dato al modello. Esegui ogni modello e prompt candidato e confronta F0.5 e recall per classe. [Come valutare un LLM prima di cambiarlo](https://broadrouter.com/it/blog/evaluate-llm-before-switching/) spiega come fare questo confronto in modo equo.

## E Tibyan e i dati sintetici?

I dati etichettati per la correzione dell’arabo sono pochi. Alrehili e Alhothali fanno notare che QALB-14 e QALB-15 insieme contengono circa 20.500 esempi paralleli. Il loro corpus Tibyan (arXiv 2024, poi in PeerJ Computer Science) ha usato ChatGPT per generare coppie di frasi con errore e corrette a partire da libri sugli errori comuni in arabo, revisionate da linguisti. Contiene circa 600.000 token, con sette tipi di errore: ortografia, morfologia, sintassi, semantica, punteggiatura, unione e separazione. Gli autori dicono che il corpus è pubblico; non abbiamo trovato un link per scaricarlo e verificarne la licenza. È utile per esempi few-shot e stress test, ma è sintetico: non usarlo come test di accettazione.

Se ti serve una baseline senza LLM, il repository arabic-gec di CAMeL Lab pubblica codice e modelli di Alhafni et al. (EMNLP 2023). Per la sola ortografia, il pacchetto ar-corrector suggerisce parole del dizionario entro una o due modifiche; non gestisce la grammatica e la sua ultima release è del 2021.

## Quale modello BroadNet usare?

I prezzi sono per 1M di token, dalla pagina prezzi di BroadNet. L’output di una correzione è lungo più o meno quanto l’input, quindi conta il prezzo dell’output.

| Modello | Perché | Input / output |
| --- | --- | --- |
| [Qwen3.8 27B](https://broadrouter.com/it/models/qwen3.8-27b/) | Ragionamento documentato; BroadNet riporta test in arabo, inclusa la comprensione dei dialetti del Golfo ed egiziano | $0.175 / $2.17 |
| [GLM 5.3](https://broadrouter.com/it/models/glm-5.3/) | Ragionamento documentato; contesto lungo per documenti interi | $0.78 / $3.46 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/it/models/deepseek-v4.1-flash/) | Il prezzo di output più basso tra i modelli di ragionamento qui elencati; disponibile anche con piani a sessione a prezzo fisso | $0.175 / $0.52 |
| [Gemma 4 VL 26B](https://broadrouter.com/it/models/gemma-4-vl-26b/) | Funziona con il credito iniziale di $5, quindi puoi costruire la pipeline prima di ricaricare | $0.10 / $0.22 |

Esegui lo scorer con ogni modello sul tuo set di riferimento e scegli in base a F0.5 e prezzo. L’arabo di solito richiede più token per parola dell’inglese; incolla un campione nel [contatore di token per l’arabo](https://broadrouter.com/tools/arabic-token-counter/) e stima la spesa con il [calcolatore dei costi delle API LLM](https://broadrouter.com/tools/llm-api-cost-calculator/). Per correggere un grande archivio: BroadNet non ha una Batch API; [elaborazione in batch senza una Batch API](https://broadrouter.com/it/blog/llm-batch-processing-without-batch-api/) mostra come farlo con concorrenza limitata, oppure su una sessione DeepSeek a $15 a settimana (una richiesta alla volta per sessione).

## Dove si colloca BroadNet Inference

BroadRouter è il sito di BroadNet. [BroadNet Inference](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-arabic-grammar-spelling-correction-llm&utm_content=body) dà accesso compatibile con OpenAI ai modelli qui sopra, quindi il codice funziona con l’[SDK Python di OpenAI](https://broadrouter.com/it/guides/openai-python-sdk/) cambiando la base URL. Non ha un endpoint di correzione bozze e non pubblica un proprio benchmark di correzione dell’arabo, quindi misura sul tuo testo. La sua informativa privacy dice che i contenuti dell’inferenza non vengono conservati, e questo conta quando correggi messaggi dei clienti. Se ti serve un correttore self-hosted per volumi molto alti, un modello con fine-tuning come quelli di CAMeL Lab può costare meno ed essere più costante; i punteggi pubblicati qui sopra sono il motivo per provarli entrambi.

Strumenti gratuiti sul tema (in inglese)

-   [Arabic token counter](https://broadrouter.com/tools/arabic-token-counter/) Arabic vs English token counts per tokenizer: the "Arabic tax" in tokens and money.
-   [Arabic text normalizer](https://broadrouter.com/tools/arabic-text-normalizer/) Tashkeel, tatweel, alef, ya, ta marbuta, digits and invisible characters, with a matching Python function.
-   [Speech-to-text cost calculator](https://broadrouter.com/tools/speech-to-text-cost-calculator/) Hours, calls or voice notes to a monthly transcription bill, against your current provider.

[Strumenti gratuiti (in inglese)](https://broadrouter.com/tools/)

## Termini in questo articolo

[Hamza (lettera araba)](https://broadrouter.com/it/glossary/hamza/)

La hamza (ء) è la lettera araba che indica il colpo di glottide. Si scrive da sola o su un supporto: alef (أ إ), waw (ؤ) o yeh (ئ), e آ unisce alef e madda. Dato che il testo digitato la usa in modo incoerente, motori di ricerca e valutazione del parlato spesso riducono le forme con alef a ا.

[Tā’ marbūṭa (taa marbuta, ة)](https://broadrouter.com/it/glossary/taa-marbuta/)

La taa marbuta (ة, U+0629) è una lettera araba che compare solo alla fine di una parola e spesso segna sostantivi e aggettivi femminili. Somiglia a una heh (ه, U+0647) con due punti, quindi nel testo digitato le due si confondono, e molti normalizzatori per la ricerca mappano ة su ه.

[Token](https://broadrouter.com/it/glossary/token/)

Un token è l’unità di testo che un modello linguistico legge e scrive: una parola, una parte di parola, un segno di punteggiatura o una sequenza di byte prodotta dal tokenizer del modello. Le API LLM contano, limitano e di solito fatturano l’uso in token.

[Arabo standard moderno (MSA)](https://broadrouter.com/it/glossary/msa/)

L’arabo standard moderno (MSA) è la forma standardizzata dell’arabo usata nella scrittura, nei notiziari, nell’istruzione e nei discorsi formali in tutto il mondo arabo. Non è la lingua madre quotidiana di nessuno: le persone parlano dialetti regionali, come l’egiziano o l’arabo del Golfo, e passano all’MSA nei contesti formali.

[Tool calling (chiamata di strumenti)](https://broadrouter.com/it/glossary/tool-calling/)

Il tool calling, detto anche function calling, è una funzionalità delle API LLM in cui il modello restituisce una richiesta strutturata di eseguire una funzione definita dallo sviluppatore, con argomenti JSON. L’applicazione esegue la funzione e rimanda il risultato; il modello non esegue mai codice da solo.

[Base URL (URL di base)](https://broadrouter.com/it/glossary/base-url/)

La base URL è l’indirizzo radice fisso di un’API, come https://api.example.com/v1, che un client antepone a ogni percorso di endpoint, come /chat/completions. Negli SDK compatibili con OpenAI, cambiare la base URL, insieme alla chiave API e all’ID del modello, punta lo stesso codice verso un altro provider.

[Batch API](https://broadrouter.com/it/glossary/batch-api/)

Una batch API è un endpoint LLM asincrono che accetta molte richieste insieme, di solito come file, le elabora entro una finestra prestabilita invece che subito, e restituisce i risultati tutti insieme. Provider come OpenAI e Anthropic applicano alle richieste batch uno sconto rispetto alle loro API standard.

[Fine-tuning (addestramento di un LLM)](https://broadrouter.com/it/glossary/fine-tuning/)

Il fine-tuning è il processo con cui si continua ad addestrare un modello linguistico già pre-addestrato su un dataset più piccolo e specifico, come conversazioni di esempio, così che i suoi pesi cambino e svolga quel compito o quello stile in modo più affidabile, senza istruzioni lunghe o esempi in ogni prompt.

## Domande frequenti

### ChatGPT o un altro LLM possono correggere la grammatica araba?

Sì, con dei limiti. In un test pubblicato sul benchmark QALB-2014, GPT-4 con cinque esempi ha raggiunto 65,49 di F1, vicino ma sotto un AraT5v2 con fine-tuning a 67,70. Usa un prompt a modifiche minime, controlla la risposta nel codice e misura su un campione del tuo testo.

### Quali sono gli errori di ortografia più comuni in arabo?

La hamza sull’alif (انا per أنا, الى per إلى), l’alef maqsura scritta come ya (مشي per مشى), la taa marbuta scritta come ha (المدرسه per المدرسة) e le parole separate o unite per errore, come و قابلت per وقابلت. Gli organizzatori di QALB indicano come più comuni gli alif con hamza e la confusione tra alef maqsura e ya.

### Normalizzare il testo arabo è la stessa cosa che correggerlo?

No. La normalizzazione unifica di proposito le varianti grafiche, come أ e ا, perché ricerca e matching le ignorino. La correzione decide quale variante è giusta nel contesto. Correggi il testo originale e normalizza solo la copia che indicizzi per la ricerca.

### Come si valuta un correttore grammaticale per l’arabo?

Correggi a mano da 100 a 200 frasi reali con modifiche minime. Estrai le modifiche a livello di parola dalla fonte al riferimento e dalla fonte all’output del modello, poi conta quelle che coincidono per calcolare precision, recall e F0.5. L’M2 scorer usato da QALB fa la stessa cosa con un allineamento delle modifiche più furbo.

### Esiste una libreria Python per controllare la grammatica araba?

Per la sola ortografia, ar-corrector suggerisce parole del dizionario entro una o due modifiche. Per la grammatica, CAMeL Lab pubblica codice e modelli GEC di ricerca (arabic-gec). Un’API LLM è il modo più rapido per iniziare; un modello con fine-tuning può essere più costante su grandi volumi.

## Continua a leggere

-   [Normalizzare il testo arabo per ricerca e RAG: cosa cambiare, cosa no](https://broadrouter.com/it/blog/arabic-text-normalization-search/)
-   [Aggiungere i diacritici all’arabo con un LLM: prompt, controlli, DER](https://broadrouter.com/it/blog/arabic-diacritization-llm/)
-   [Prompt engineering in arabo: registro, RTL, cifre e testo misto](https://broadrouter.com/it/blog/arabic-prompt-engineering/)
-   [Estrarre entità nominate dall’arabo con un LLM: JSON, date e controlli](https://broadrouter.com/it/blog/arabic-named-entity-extraction-llm/)
-   [Scegliere un’API LLM per l’arabo: cosa testare](https://broadrouter.com/it/blog/choosing-an-llm-for-arabic/)
-   [Come valutare un LLM prima di cambiare provider](https://broadrouter.com/it/blog/evaluate-llm-before-switching/)
-   [Elaborazione batch con LLM senza Batch API: un runner riprendibile](https://broadrouter.com/it/blog/llm-batch-processing-without-batch-api/)
-   [Verbali di riunioni in arabo dalle registrazioni: una pipeline API](https://broadrouter.com/it/blog/arabic-meeting-minutes-from-recordings/)
-   [API OCR per l’arabo a confronto: Google, Azure, Textract, Mistral, LLM](https://broadrouter.com/it/blog/arabic-ocr-api-comparison/)
-   [Guida: Usare l’SDK Python di OpenAI con BroadNet Inference](https://broadrouter.com/it/guides/openai-python-sdk/)
-   [Guida: Perché un modello di ragionamento restituisce una risposta vuota](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/)

Provalo sul tuo carico di lavoro reale. I nuovi account partono con USD 5 di credito per Gemma e trascrizione. DeepSeek, GLM e Qwen3.8 richiedono una ricarica.

[Inizia](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-arabic-grammar-spelling-correction-llm&utm_content=page-cta) ·

**Fonti**

-   [Mohit et al., The First QALB Shared Task on Automatic Text Correction for Arabic, workshop ANLP a EMNLP 2014: dati, M2 scorer, tabelle 3 e 7 (consultato il 2026-11-15)](https://aclanthology.org/W14-3605/)
-   [Rozovskaya et al., The Second QALB Shared Task on Automatic Text Correction for Arabic, WANLP 2015: track per madrelingua e L2, tabelle 4, 8 e 9 (consultato il 2026-11-15)](https://aclanthology.org/W15-3204/)
-   [Kwon, Bhatia, Nagoudi e Abdul-Mageed, Beyond English: Evaluating LLMs for Arabic Grammatical Error Correction, ArabicNLP 2023, tabella 2 (consultato il 2026-11-15)](https://aclanthology.org/2023.arabicnlp-1.9/)
-   [Alrehili e Alhothali, Tibyan Corpus: Balanced and Comprehensive Error Coverage Corpus Using ChatGPT for Arabic GEC, arXiv 2411.04588 (consultato il 2026-11-15)](https://arxiv.org/abs/2411.04588)
-   [Belkebir e Habash, Automatic Error Type Annotation for Arabic (ARETA), CoNLL 2021 (consultato il 2026-11-15)](https://aclanthology.org/2021.conll-1.47/)
-   [CAMeL Lab, ARETA su GitHub (MIT): tag di errore basati su ALC come OH hamza, OT ha/ta marbuta, OA alif/ya, MG unione, SP separazione (consultato il 2026-11-15)](https://github.com/CAMeL-Lab/arabic_error_type_annotation)
-   [Alhafni, Inoue, Khairallah e Habash, Advancements in Arabic Grammatical Error Detection and Correction, EMNLP 2023; codice e modelli in CAMeL-Lab/arabic-gec (consultato il 2026-11-15)](https://aclanthology.org/2023.emnlp-main.396/)
-   [NUS M2Scorer su GitHub: precision, recall e F-beta a livello di modifica per la GEC; la versione per sviluppatori richiede Python 2 (consultato il 2026-11-15)](https://github.com/nusnlp/m2scorer)
-   [ERRANT su GitHub: estrae e classifica le modifiche in formato M2; solo inglese (consultato il 2026-11-15)](https://github.com/chrisjbryant/errant)
-   [ar-corrector su PyPI: correttore a dizionario, oltre 500.000 parole, candidati a 1-2 modifiche, versione 1.1.6 di aprile 2021 (consultato il 2026-11-15)](https://pypi.org/project/ar-corrector/)
-   [Riferimento API di BroadNet Inference: ID dei modelli, il ragionamento conta in max\_tokens, reasoning\_effort (consultato il 2026-11-15) (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-arabic-grammar-spelling-correction-llm&utm_content=sources)
