L’arabo permette di scrivere la stessa parola in più modi. Un utente digita احمد; il documento riporta أَحْمَد. Un indice di ricerca che confronta i caratteri esatti perde la corrispondenza, e lo stesso vale per la metà a parole chiave di una pipeline RAG. La normalizzazione risolve il problema riportando le varianti a un’unica forma prima del confronto. Fatta senza attenzione, però, fonde anche parole che significano cose diverse. Questo articolo procede regola per regola: cosa fa ciascuna, quando applicarla, cosa rompe e come differiscono le principali librerie. Si chiude con codice Python testato.
Per la pipeline RAG completa in arabo (chunking, ricerca ibrida, risposte con citazioni), vedi RAG in arabo che funziona. Questo articolo approfondisce il passaggio di normalizzazione.
La normalizzazione migliora davvero il retrieval?
Sì, per la ricerca per parole chiave, e le prove sono datate ma chiare. Larkey, Ballesteros e Connell (SIGIR 2002) hanno testato il retrieval in arabo sulla collezione di notizie TREC-2001. Prima dello stemming hanno normalizzato corpus e query: rimossi diacritici e punteggiatura, unificate le forme di alef e trasformate ى e ة a fine parola. I loro risultati monolingue, con query non espanse:
| Elaborazione | Precisione media | Variazione rispetto al grezzo (dai valori arrotondati) |
|---|---|---|
| Testo grezzo | 0,194 | — |
| Normalizzato | 0,238 | +22,7% |
| Normalizzato + stemming leggero (light8) | 0,376 | +93,8% |
Due cautele. È retrieval per parole chiave del 2002 su notizie, non ricerca con embedding. E il guadagno maggiore è venuto dallo stemming leggero (rimozione di prefissi come و e ال e dei suffissi comuni), che è un passaggio separato dalla normalizzazione. L’ArabicAnalyzer di Lucene e l’analyzer arabic di Elasticsearch applicano entrambi: prima un normalizzatore, poi uno stemmer leggero.
Cosa normalizzare, e quanto costa ogni regola?
| Regola | Esempio | Indice di ricerca | Rischio |
|---|---|---|---|
| Unicode NFKC | ﻻ → لا, ا + ٔ → أ | Sì, sempre per prima | Riscrive anche i caratteri di compatibilità di altri alfabeti |
| Rimuovere i segni invisibili | zero-width joiner, RLM/LRM, BOM | Sì | Nessuno per l’arabo; lo ZWNJ conta in persiano |
| Togliere il tashkeel | أَحْمَدُ → أحمد | Sì | Fonde parole che si distinguono solo per le vocali |
| Rimuovere il tatweel (ـ) | الـــمدينة → المدينة | Sì | Nessuno |
| Unificare l’alef | أ إ آ ٱ → ا | Sì | Fonde alcune coppie: سأل (chiese) e سال (scorse) |
| Alef maksura | ى → ي | Di solito | Fonde على (su) e علي (Ali) |
| Ta marbuta | ة → ه | Di solito | Fonde كتابة (scrittura) e كتابه (il suo libro) |
| Supporti della hamza | ؤ ئ → ء | Facoltativo | Fonde مسؤول e مسئول (bene) ma anche alcune parole distinte |
| Lettere persiane | ی → ي, ک → ك | Sì, se gli utenti hanno tastiere persiane | Nessuno per il testo arabo |
| Cifre | ٢٠٢٦ e ۲۰۲۶ → 2026 | Sì | Nessuno; conserva l’originale per la visualizzazione |
La terza colonna riguarda la chiave dell’indice e la query. Il testo che salvi, mostri e passi al modello resta com’è scritto.
Perché la normalizzazione Unicode va fatta per prima?
La stessa lettera visibile può essere memorizzata in modi diversi. أ può essere un unico code point (U+0623) o un alef semplice seguito da una hamza combinante (U+0627 U+0654). I PDF più vecchi e alcune tastiere producono forme di presentazione arabe (da U+FB50 a U+FEFF), come il lam-alef ﻻ in un solo carattere. Nella normalizzazione Unicode, NFC compone la hamza sull’alef, e NFKC scompone anche forme di presentazione e legature. In Python, unicodedata.normalize("NFKC", "ﻻ") restituisce لا, e ﷲ diventa الله.
Eseguila prima di tutto il resto. Altrimenti una regex che sostituisce أ non vede la forma scomposta. C’è una seconda trappola: dediac_ar di CAMeL Tools rimuove i caratteri del suo AR_DIAC_CHARSET (da U+064B a U+0652 e U+0670). Quell’insieme esclude i segni combinanti di hamza e madda (da U+0653 a U+0655), quindi sul testo scomposto sopravvivono alla rimozione dei diacritici. NFKC li compone prima.
NFKC è una mappatura di compatibilità. Cambia anche caratteri al di fuori dell’arabo, per esempio le lettere latine a larghezza piena. Di solito in una chiave di ricerca è proprio quello che vuoi, ed è un motivo in più per conservare l’originale accanto.
Cosa non va normalizzato?
- Il testo che mostri, citi o riporti. L’arabo normalizzato sembra scritto male (المدينه). Conserva l’originale accanto alla chiave.
- Quello che invii all’LLM. I modelli leggono senza problemi hamza e tashkeel, e il testo esatto mantiene corretti nomi e citazioni. Togliere il tashkeel fa risparmiare qualche token; controlla quanti con il contatore di token per l’arabo prima di sacrificare l’accuratezza.
- Testi in cui i segni portano significato: Corano, hadith, poesia, libri per bambini, compiti di pronuncia e di diacritizzazione (vedi aggiungere i diacritici con un LLM).
- Correzione ortografica o grammaticale: normalizzare prima cancella proprio gli errori di hamza e taa marbuta che vuoi correggere; vedi correzione grammaticale e ortografica dell’arabo con un LLM.
- Identificatori. Codici prodotto, email, URL e testo latino non devono passare dalle regole dell’arabo. Applica la normalizzazione solo ai campi in alfabeto arabo, o solo ai token arabi.
- Campi che le persone cercano in modo esatto. Per ragioni sociali o campi simili a identificativi, indicizza anche una copia grezza, così una corrispondenza esatta può ancora risultare per prima.
In cosa differiscono CAMeL Tools, PyArabic e Lucene?
Non implementano le stesse regole, e mescolarle produce un indice e delle query che non coincidono mai. Abbiamo letto documentazione e sorgente di ciascuna libreria ed eseguito PyArabic 0.6.15:
| Funzione | Cosa fa davvero |
|---|---|
CAMeL normalize_unicode |
NFKC (o NFC con compatibility=False); espande anche ﷼ in ريال e ﷽ nella sua frase completa |
CAMeL normalize_alef_ar |
إ أ ٱ آ → ا |
CAMeL normalize_alef_maksura_ar |
ى → ي |
CAMeL normalize_teh_marbuta_ar |
ة → ه |
CAMeL dediac_ar |
Rimuove da U+064B a U+0652 e U+0670; lascia il tatweel |
PyArabic strip_tashkeel |
Rimuove tutte le harakat, shadda compresa |
PyArabic strip_tatweel |
Rimuove ـ |
PyArabic normalize_alef |
Ogni forma di alef e ى → ا, quindi إلى diventa الا |
PyArabic normalize_hamza |
Il metodo predefinito trasforma ogni forma di hamza in ء, أ compresa, quindi أحمد diventa ءحمد |
Lucene ArabicNormalizer |
Forme di alef con hamza → ا, ة → ه, ى → ي, rimuove harakat e tatweel |
Le righe di PyArabic sorprendono. La docstring di normalize_alef dice che l’alef maksura è un’eccezione, ma nella 0.6.15 l’insieme ALEFAT include ى, e la funzione la trasforma in ا. normalize_hamza è pensata per un matching indifferente alla hamza, non per la ricerca in generale. Anche l’ordine conta: esegui prima la normalizzazione dell’alef, e a quel punto normalize_hamza tocca solo ؤ, ئ e ء, quindi مسؤول e مسئول diventano entrambe مسءول. Il suo metodo tasheel dà invece مسوول e مسيول, che non coincidono tra loro.
Il filtro arabic_normalization di Elasticsearch usa il normalizzatore di Lucene, quindi una pipeline Python che deve combaciare con un indice Elasticsearch dovrebbe copiare esattamente le regole di Lucene. Cioè ى → ي, non ى → ا.
Com’è fatto un normalizzatore testato?
Questa funzione segue le scelte di Lucene, aggiunge la gestione di Unicode, cifre e lettere persiane e rende attivabili a piacere le regole rischiose. Usa solo la libreria standard.
import re
import unicodedata
DIACRITICS = re.compile("[ً-ٰٟ]") # tashkeel, extra marks, superscript alef
INVISIBLE = re.compile("[---]") # zero-width, bidi
ALEF = re.compile("[آأإٱ]") # آ أ إ ٱ -> ا
DIGITS = str.maketrans("٠١٢٣٤٥٦٧٨٩۰۱۲۳۴۵۶۷۸۹", "0123456789" * 2)
FARSI = str.maketrans({"ی": "ي", "ک": "ك"}) # ی -> ي, ک -> ك
def normalize(text, *, alef=True, alef_maksura=True, ta_marbuta=True,
hamza_seats=False, digits=True):
text = unicodedata.normalize("NFKC", text) # compose marks, unpack ligatures
text = INVISIBLE.sub("", text)
text = DIACRITICS.sub("", text).replace("ـ", "") # tashkeel, tatweel
text = text.translate(FARSI)
if alef:
text = ALEF.sub("ا", text)
if alef_maksura:
text = text.replace("ى", "ي") # ى -> ي
if ta_marbuta:
text = text.replace("ة", "ه") # ة -> ه
if hamza_seats:
text = re.sub("[ؤئ]", "ء", text) # ؤ ئ -> ء
if digits:
text = text.translate(DIGITS)
return text
Cosa ha restituito sulle nostre stringhe di test:
| Input | Output | Nota |
|---|---|---|
| أَحْمَدُ | احمد | Via tashkeel e hamza |
| الـــمدينة | المدينه | Tatweel e ta marbuta |
| إلى | الي | Alef e alef maksura |
| ا + U+0654 + مل | امل | Hamza scomposta composta, poi unificata |
| ﻻبد | لابد | Forma di presentazione scomposta |
| ٢٠٢٦ / ۱۴۰۵ | 2026 / 1405 | Cifre arabo-indiane e persiane |
| مسؤول / مسئول | Entrambe مسءول con hamza_seats=True |
Invariate per impostazione predefinita |
| فارسی | فارسي | Ya persiana |
Usala in due punti: quando costruisci la chiave dell’indice e quando leggi una query. Salva original e normalize(original) uno accanto all’altro, cerca sul secondo e restituisci il primo. Il normalizzatore di testo arabo gratuito ti permette di incollare un testo e vedere l’effetto di ogni regola prima di scegliere le impostazioni.
Come si inserisce la normalizzazione in embedding e RAG?
Una pipeline RAG di solito ha due retriever: la ricerca per parole chiave (BM25) e gli embedding. La normalizzazione aiuta chiaramente la parte a parole chiave. Per la parte con embedding, le prove viste sopra non valgono: i modelli di embedding sono addestrati su testo grezzo, e molti mettono già احمد e أحمد vicini. Normalizzare prima dell’embedding può aiutare, non cambiare nulla o peggiorare. Prepara da 50 a 100 query reali con risposte note, eseguile con input grezzo e normalizzato e tieni la variante con la recall più alta. Qualunque cosa scegli, applicala in modo identico a documenti e query.
La normalizzazione riduce anche leggermente il numero di token, perché diacritici e tatweel sono caratteri in più per il tokenizer. I rapporti misurati sono nel dataset sull’efficienza dei tokenizer e in token per parola in arabo. La stessa normalizzazione serve a valutare in modo equo il riconoscimento vocale; vedi il WER in arabo spiegato.
L’arabizi (l’arabo in caratteri latini) richiede un approccio del tutto diverso: come gli LLM gestiscono l’arabizi.
Dove si colloca BroadNet Inference
La normalizzazione gira nel tuo codice, quindi non serve alcuna API. BroadNet Inference entra in gioco dopo il retrieval. Non vende embedding, quindi abbina un retriever e un fornitore di embedding a tua scelta a un modello di chat di BroadNet per la fase di risposta. GLM 5.3 e DeepSeek V4.1 Flash accettano 1.048.576 token di contesto, quindi puoi passare molti passaggi recuperati nel loro arabo originale, non normalizzato. Per scegliere un modello in base alla qualità in arabo, vedi scegliere un LLM per l’arabo. Se ti serve solo la ricerca per parole chiave, l’analyzer arabic integrato di Elasticsearch potrebbe bastarti.
