Puwedeng isulat sa ilang paraan ang iisang salita sa Arabic. احمد ang tina-type ng user; أَحْمَد ang nakasulat sa dokumento. Hindi iyon magtutugma sa search index na eksaktong character ang ikinukumpara, at ganoon din sa keyword na bahagi ng isang RAG pipeline. Inaayos ito ng normalization sa pamamagitan ng paggawa ng mga variant na iisang anyo bago ikumpara. Kapag ginawa nang pabaya, pinagsasama rin nito ang mga salitang magkaiba ang kahulugan. Isa-isang tinatalakay ng post na ito ang bawat patakaran: ano ang ginagawa nito, kailan ilalapat, ano ang sinisira nito, at paano nagkakaiba ang mga pangunahing library. Nagtatapos ito sa tested na Python.
Para sa buong Arabic RAG pipeline (chunking, hybrid search, sagot na may citation), tingnan ang Arabic RAG na gumagana. Mas pinalalalim ng post na ito ang hakbang ng normalization.
Talaga bang nakakatulong ang normalization sa retrieval?
Oo, para sa keyword search, at luma pero malinaw ang ebidensya. Tinest nina Larkey, Ballesteros at Connell (SIGIR 2002) ang Arabic retrieval sa TREC-2001 newswire collection. Bago ang stemming, ni-normalize nila ang corpus at mga query: tinanggal ang diacritics at bantas, pinag-isa ang mga anyo ng alef, at minapa ang ى at ة sa dulo ng salita. Ang mga monolingual na resulta nila, gamit ang mga hindi pinalawak na query:
| Processing | Average precision | Pagbabago kumpara sa raw (mula sa mga ni-round na figure) |
|---|---|---|
| Raw na text | .194 | — |
| Normalized | .238 | +22.7% |
| Normalized + light stemming (light8) | .376 | +93.8% |
Dalawang paalala. Keyword retrieval ito sa balita noong 2002, hindi embedding search. At galing sa light stemming (pagtanggal ng mga prefix gaya ng و at ال at karaniwang suffix) ang pinakamalaking pakinabang, na hiwalay na hakbang sa normalization. Ginagawa ng ArabicAnalyzer ng Lucene at ng arabic analyzer ng Elasticsearch ang dalawa: isang normalizer, saka isang light stemmer.
Ano ang dapat i-normalize, at ano ang kapalit ng bawat patakaran?
| Patakaran | Halimbawa | Search index | Panganib |
|---|---|---|---|
| Unicode NFKC | ﻻ → لا, ا + ٔ → أ | Oo, laging una | Binabago rin ang mga compatibility character sa ibang script |
| Tanggalin ang mga hindi nakikitang marka | zero-width joiner, RLM/LRM, BOM | Oo | Wala para sa Arabic; mahalaga ang ZWNJ sa Persian |
| Tanggalin ang tashkeel | أَحْمَدُ → أحمد | Oo | Pinagsasama ang mga salitang patinig lang ang pinagkaiba |
| Tanggalin ang tatweel (ـ) | الـــمدينة → المدينة | Oo | Wala |
| Pag-isahin ang alef | أ إ آ ٱ → ا | Oo | Pinagsasama ang ilang pares: سأل (nagtanong) at سال (umagos) |
| Alef maksura | ى → ي | Kadalasan | Pinagsasama ang على (sa ibabaw) at علي (Ali) |
| Ta marbuta | ة → ه | Kadalasan | Pinagsasama ang كتابة (pagsulat) at كتابه (ang aklat niya) |
| Hamza seat | ؤ ئ → ء | Opsyonal | Pinagsasama ang مسؤول at مسئول (mabuti) pero pati ang ilang magkaibang salita |
| Persian na letra | ی → ي, ک → ك | Oo, kung may Persian keyboard ang mga user | Wala para sa Arabic text |
| Digit | ٢٠٢٦ at ۲۰۲۶ → 2026 | Oo | Wala; itago ang orihinal para sa display |
Para sa index key at query ang unang column. Nananatiling gaya ng pagkakasulat ang text na ini-store, ipinapakita at ipinapasa mo sa model.
Bakit dapat mauna ang Unicode normalization?
Puwedeng i-store sa iba’t ibang paraan ang iisang nakikitang letra. Puwedeng isang code point ang أ (U+0623) o bare na alef na sinusundan ng combining hamza (U+0627 U+0654). Gumagawa ang mga lumang PDF at ilang keyboard ng Arabic presentation form (U+FB50 hanggang U+FEFF), gaya ng isang-character na lam-alef na ﻻ. Sa ilalim ng Unicode normalization, pinagsasama ng NFC ang hamza sa alef, at binubuksan din ng NFKC ang mga presentation form at ligature. Sa Python, ibinabalik ng unicodedata.normalize("NFKC", "ﻻ") ang لا, at nagiging الله ang ﷲ.
Patakbuhin ito bago ang anupaman. Kung hindi, hindi makikita ng regex na pumapalit sa أ ang decomposed na anyo. May ikalawang bitag: tinatanggal ng dediac_ar ng CAMeL Tools ang mga character sa AR_DIAC_CHARSET nito (U+064B hanggang U+0652 at U+0670). Hindi kasama sa set na iyon ang combining hamza at madda (U+0653 hanggang U+0655), kaya sa decomposed na text ay nakakaligtas sila sa dediacritization. Pinagsasama muna sila ng NFKC.
Compatibility mapping ang NFKC. Binabago rin nito ang mga character sa labas ng Arabic, halimbawa ang mga full-width na Latin na letra. Kadalasang iyon ang gusto mo sa search key, at isa pang dahilan para itago ang orihinal sa tabi nito.
Ano ang hindi dapat i-normalize?
- Ang text na ipinapakita, sinisipi o kino-quote mo. Mukhang mali ang spelling ng normalized na Arabic (المدينه). I-store ang orihinal sa tabi ng key.
- Ang ipinapadala mo sa LLM. Nababasa nang maayos ng mga model ang hamza at tashkeel, at pinananatiling tama ng eksaktong text ang mga pangalan at sipi. Nakakatipid ng kaunting token ang pagtanggal ng tashkeel; i-check kung ilan gamit ang Arabic token counter bago ipagpalit ang katumpakan dito.
- Text na may kahulugan ang mga marka: Quran, hadith, tula, aklat pambata, pagbigkas at diacritization task (tingnan ang paglalagay ng diacritics gamit ang LLM).
- Spelling o grammar correction: binubura ng pag-normalize muna ang mga hamza at taa marbuta error na gusto mong ayusin; tingnan ang Arabic grammar at spelling correction gamit ang LLM.
- Mga identifier. Hindi dapat dumaan sa Arabic na patakaran ang product code, email, URL at Latin na text. Ilapat ang normalization sa mga field na Arabic script lang, o sa mga Arabic na token lang.
- Mga field na eksaktong hinahanap ng tao. Para sa mga legal na pangalan o field na parang ID, mag-index din ng raw na kopya, para mauna pa rin sa ranking ang eksaktong match.
Paano nagkakaiba ang CAMeL Tools, PyArabic at Lucene?
Hindi magkakapareho ang mga patakarang ipinapatupad nila, at kapag pinaghalo, magkakaroon ka ng index at mga query na hindi kailanman magtutugma. Binasa namin ang dokumentasyon at source ng bawat library, at pinatakbo ang PyArabic 0.6.15:
| Function | Ano talaga ang ginagawa |
|---|---|
CAMeL normalize_unicode |
NFKC (o NFC kapag compatibility=False); pinalalawak din ang ﷼ bilang ريال at ang ﷽ sa buong parirala nito |
CAMeL normalize_alef_ar |
إ أ ٱ آ → ا |
CAMeL normalize_alef_maksura_ar |
ى → ي |
CAMeL normalize_teh_marbuta_ar |
ة → ه |
CAMeL dediac_ar |
Tinatanggal ang U+064B hanggang U+0652 at U+0670; iniiwan ang tatweel |
PyArabic strip_tashkeel |
Tinatanggal ang lahat ng harakat kasama ang shadda |
PyArabic strip_tatweel |
Tinatanggal ang ـ |
PyArabic normalize_alef |
Bawat anyo ng alef at ang ى → ا, kaya nagiging الا ang إلى |
PyArabic normalize_hamza |
Ginagawang ء ng default na method ang bawat anyo ng hamza, kasama ang أ, kaya nagiging ءحمد ang أحمد |
Lucene ArabicNormalizer |
Mga hamza-on-alef na anyo → ا, ة → ه, ى → ي, tinatanggal ang harakat at tatweel |
Ikinagugulat ng mga tao ang mga row ng PyArabic. Sinasabi ng docstring ng normalize_alef nito na exception ang alef maksura, pero sa 0.6.15 ay kasama ang ى sa ALEFAT set, at ginagawa itong ا ng function. Ginawa ang normalize_hamza nito para sa hamza-agnostic na matching, hindi para sa pangkalahatang search. Mahalaga rin ang pagkakasunod: patakbuhin muna ang alef normalization, at ؤ, ئ at ء na lang ang gagalawin ng normalize_hamza, kaya parehong nagiging مسءول ang مسؤول at مسئول. Ang tasheel method nito naman ay nagbibigay ng مسوول at مسيول, na hindi magkatugma.
Ginagamit ng arabic_normalization filter ng Elasticsearch ang Lucene normalizer, kaya ang Python pipeline na gustong tumugma sa isang Elasticsearch index ay dapat kopyahin nang eksakto ang mga patakaran ng Lucene. Ibig sabihin, ى → ي, hindi ى → ا.
Ano ang itsura ng isang tested na normalizer?
Sinusunod ng function na ito ang mga pagpili ng Lucene, nagdadagdag ng paghawak sa Unicode, digit at Persian na letra, at ginagawang switchable ang mga mapanganib na patakaran. Standard library lang ang ginagamit nito.
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
Ang ibinalik nito sa mga test string namin:
| Input | Output | Tala |
|---|---|---|
| أَحْمَدُ | احمد | Wala na ang tashkeel at hamza |
| الـــمدينة | المدينه | Tatweel at ta marbuta |
| إلى | الي | Alef at alef maksura |
| ا + U+0654 + مل | امل | Pinagsama ang decomposed na hamza, saka pinag-isa |
| ﻻبد | لابد | Binuksan ang presentation form |
| ٢٠٢٦ / ۱۴۰۵ | 2026 / 1405 | Arabic-Indic at Persian na digit |
| مسؤول / مسئول | Parehong مسءول kapag hamza_seats=True |
Walang pagbabago bilang default |
| فارسی | فارسي | Persian na ya |
Gamitin ito sa dalawang lugar: kapag binubuo mo ang index key at kapag binabasa mo ang isang query. I-store nang magkatabi ang original at normalize(original), mag-search sa ikalawa at ibalik ang una. Hinahayaan ka ng libreng Arabic text normalizer na mag-paste ng text at makita ang epekto ng bawat patakaran bago pumili ng mga setting mo.
Paano pumapasok ang normalization sa embeddings at RAG?
Karaniwang may dalawang retriever ang isang RAG pipeline: keyword search (BM25) at embeddings. Malinaw na nakakatulong ang normalization sa keyword na bahagi. Sa embedding na bahagi, hindi umiiral ang ebidensya sa itaas: sinanay sa raw na text ang mga embedding model, at marami na ang naglalagay sa احمد at أحمد nang magkalapit. Puwedeng makatulong, walang epekto, o makasama ang pag-normalize bago mag-embed. Bumuo ng 50 hanggang 100 totoong query na may alam na sagot, patakbuhin gamit ang raw at normalized na input, at panatilihin kung alin ang mas mataas ang recall. Anuman ang piliin mo, ilapat ito nang magkapareho sa mga dokumento at query.
Bahagya ring ibinababa ng normalization ang bilang ng token, dahil dagdag na character para sa tokenizer ang diacritics at tatweel. Nasa tokenizer efficiency dataset at sa token kada salita sa Arabic ang mga nasukat na ratio. Ginagamit din ang parehong normalization para patas na i-score ang speech recognition; tingnan ang Arabic WER, ipinaliwanag.
Ibang paraan talaga ang kailangan ng Arabizi (Arabic sa Latin na letra): paano hinahawakan ng mga LLM ang Arabizi.
Saan pumapasok ang BroadNet Inference
Sa sarili mong code tumatakbo ang normalization, kaya walang API na kailangan para dito. Pumapasok ang BroadNet Inference pagkatapos ng retrieval. Hindi ito nagbebenta ng embeddings, kaya ipares ang retriever at embeddings provider na gusto mo sa isang BroadNet chat model para sa hakbang ng pagsagot. 1,048,576 token ng context ang kaya ng GLM 5.3 at DeepSeek V4.1 Flash, kaya maipapasa mo ang maraming nakuhang passage sa orihinal at hindi normalized nilang Arabic. Para sa pagpili ng model batay sa kalidad sa Arabic, tingnan ang pagpili ng LLM para sa Arabic. Kung keyword search lang ang kailangan mo, baka sapat na ang built-in na arabic analyzer ng Elasticsearch.
