BroadRouter

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

A cura del team di BroadNet Inference · 8 min di lettura · Pubblicato · Aggiornato

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.

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 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 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 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) 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.

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.
  • 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.

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 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 Ragionamento documentato; BroadNet riporta test in arabo, inclusa la comprensione dei dialetti del Golfo ed egiziano $0.175 / $2.17
GLM 5.3 Ragionamento documentato; contesto lungo per documenti interi $0.78 / $3.46
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 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 e stima la spesa con il calcolatore dei costi delle API LLM. Per correggere un grande archivio: BroadNet non ha una Batch API; elaborazione in batch senza una 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 dà accesso compatibile con OpenAI ai modelli qui sopra, quindi il codice funziona con l’SDK Python di OpenAI 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.

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.

Leggi in MarkdownChiedi a ChatGPTChiedi a ClaudeChiedi a Perplexity

Fonti