BroadRouter

Normalizar texto em árabe para busca e RAG: o que mudar e o que não

Pela equipe da BroadNet Inference · 7 min de leitura · Publicado em · Atualizado em

Para índices de busca e RAG, normalize do mesmo jeito a cópia indexada e cada consulta: Unicode NFKC, remoção de tashkeel e tatweel, unificação das formas de alef, ى para ي e ة para ه, conversão de dígitos. Guarde o texto original para exibição e para o LLM. Trate os suportes da hamza e o ta marbuta como ajustáveis: aumentam a recall, mas juntam algumas palavras distintas.

O árabe permite escrever a mesma palavra de vários jeitos. O usuário digita احمد; o documento traz أَحْمَد. Um índice de busca que compara caracteres exatos perde essa correspondência, e o mesmo acontece com a metade de palavras-chave de um pipeline RAG. A normalização resolve isso levando as variantes a uma única forma antes da comparação. Feita sem cuidado, ela também junta palavras que significam coisas diferentes. Este post vai regra por regra: o que cada uma faz, quando aplicá-la, o que ela quebra e como as principais bibliotecas diferem. No fim, há código Python testado.

Para o pipeline RAG completo em árabe (chunking, busca híbrida, respostas com citações), veja RAG em árabe que funciona. Este post se aprofunda na etapa de normalização.

A normalização realmente melhora a recuperação?

Sim, para busca por palavras-chave, e as evidências são antigas, mas claras. Larkey, Ballesteros e Connell (SIGIR 2002) testaram recuperação em árabe na coleção de notícias do TREC-2001. Antes do stemming, eles normalizaram corpus e consultas: removeram diacríticos e pontuação, unificaram as formas de alef e converteram ى e ة no fim das palavras. Os resultados monolíngues, com consultas não expandidas:

Processamento Precisão média Variação em relação ao bruto (a partir dos valores arredondados)
Texto bruto 0,194 —
Normalizado 0,238 +22,7%
Normalizado + stemming leve (light8) 0,376 +93,8%

Duas ressalvas. Isso é recuperação por palavras-chave de 2002 sobre notícias, não busca por embeddings. E o maior ganho veio do stemming leve (remoção de prefixos como و e ال e de sufixos comuns), que é uma etapa separada da normalização. O ArabicAnalyzer do Lucene e o analyzer arabic do Elasticsearch aplicam os dois: um normalizador e depois um stemmer leve.

O que normalizar, e quanto custa cada regra?

Regra Exemplo Índice de busca Risco
Unicode NFKC ﻻ → لا, ا + ٔ → أ Sim, sempre primeiro Também reescreve caracteres de compatibilidade de outros alfabetos
Remover marcas invisíveis zero-width joiners, RLM/LRM, BOM Sim Nenhum para o árabe; o ZWNJ importa em persa
Remover tashkeel أَحْمَدُ → أحمد Sim Junta palavras que só se distinguem pelas vogais
Remover tatweel (ـ) الـــمدينة → المدينة Sim Nenhum
Unificar alef أ إ آ ٱ → ا Sim Junta alguns pares: سأل (perguntou) e سال (escorreu)
Alef maksura ى → ي Normalmente Junta على (sobre) e علي (Ali)
Ta marbuta ة → ه Normalmente Junta كتابة (escrita) e كتابه (o livro dele)
Suportes da hamza ؤ ئ → ء Opcional Junta مسؤول e مسئول (bom), mas também algumas palavras distintas
Letras persas ی → ي, ک → ك Sim, se os usuários têm teclado persa Nenhum para texto em árabe
Dígitos ٢٠٢٦ e ۲۰۲۶ → 2026 Sim Nenhum; guarde o original para exibição

A terceira coluna vale para a chave do índice e para a consulta. O texto que você armazena, exibe e passa ao modelo fica como foi escrito.

Por que a normalização Unicode deve vir primeiro?

A mesma letra visível pode ser armazenada de jeitos diferentes. أ pode ser um único code point (U+0623) ou um alef simples seguido de uma hamza combinante (U+0627 U+0654). PDFs mais antigos e alguns teclados produzem formas de apresentação árabes (de U+FB50 a U+FEFF), como o lam-alef ﻻ num único caractere. Na normalização Unicode, o NFC compõe a hamza sobre o alef, e o NFKC também desfaz formas de apresentação e ligaduras. Em Python, unicodedata.normalize("NFKC", "ﻻ") retorna لا, e ﷲ vira الله.

Rode isso antes de qualquer outra coisa. Senão, uma regex que substitui أ deixa passar a forma decomposta. Há uma segunda armadilha: o dediac_ar do CAMeL Tools remove os caracteres do seu AR_DIAC_CHARSET (de U+064B a U+0652 e U+0670). Esse conjunto deixa de fora as marcas combinantes de hamza e madda (de U+0653 a U+0655), então, em texto decomposto, elas sobrevivem à remoção de diacríticos. O NFKC as compõe antes.

O NFKC é um mapeamento de compatibilidade. Ele também altera caracteres fora do árabe, por exemplo letras latinas de largura total. Numa chave de busca, isso costuma ser o que você quer, e é mais um motivo para guardar o original ao lado.

O que não normalizar?

  • O texto que você exibe, cita ou reproduz. Árabe normalizado parece escrito errado (المدينه). Guarde o original ao lado da chave.
  • O que você envia ao LLM. Os modelos leem hamza e tashkeel sem problema, e o texto exato mantém nomes e citações corretos. Remover o tashkeel economiza alguns tokens; veja quantos com o contador de tokens para árabe antes de trocar precisão por isso.
  • Textos em que as marcas carregam sentido: Alcorão, hadith, poesia, livros infantis, tarefas de pronúncia e de diacritização (veja como adicionar diacríticos com um LLM).
  • Correção ortográfica ou gramatical: normalizar antes apaga justamente os erros de hamza e taa marbuta que você quer corrigir; veja correção gramatical e ortográfica do árabe com um LLM.
  • Identificadores. Códigos de produto, e-mails, URLs e texto latino não podem passar pelas regras do árabe. Aplique a normalização só a campos em alfabeto árabe, ou só a tokens em árabe.
  • Campos que as pessoas buscam de forma exata. Para razões sociais ou campos parecidos com identificadores, indexe também uma cópia bruta, para que uma correspondência exata ainda possa aparecer em primeiro.

Em que CAMeL Tools, PyArabic e Lucene diferem?

Elas não implementam as mesmas regras, e misturá-las gera um índice e consultas que nunca batem. Lemos a documentação e o código-fonte de cada biblioteca e rodamos o PyArabic 0.6.15:

Função O que ela faz de fato
CAMeL normalize_unicode NFKC (ou NFC com compatibility=False); também expande ﷼ para ريال e ﷽ para a frase completa
CAMeL normalize_alef_ar إ أ ٱ آ → ا
CAMeL normalize_alef_maksura_ar ى → ي
CAMeL normalize_teh_marbuta_ar ة → ه
CAMeL dediac_ar Remove de U+064B a U+0652 e U+0670; mantém o tatweel
PyArabic strip_tashkeel Remove todas as harakat, inclusive o shadda
PyArabic strip_tatweel Remove ـ
PyArabic normalize_alef Toda forma de alef e o ى → ا, então إلى vira الا
PyArabic normalize_hamza O método padrão transforma toda forma de hamza em ء, inclusive أ, então أحمد vira ءحمد
Lucene ArabicNormalizer Formas de alef com hamza → ا, ة → ه, ى → ي, remove harakat e tatweel

As linhas do PyArabic surpreendem. A docstring de normalize_alef diz que o alef maksura é uma exceção, mas na 0.6.15 o conjunto ALEFAT inclui ى, e a função o transforma em ا. O normalize_hamza foi feito para matching que ignora a hamza, não para busca em geral. A ordem também importa: rode primeiro a normalização do alef, e aí o normalize_hamza só mexe em ؤ, ئ e ء, então مسؤول e مسئول viram ambos مسءول. O método tasheel dele gera مسوول e مسيول, que não batem entre si.

O filtro arabic_normalization do Elasticsearch usa o normalizador do Lucene, então um pipeline em Python que precisa bater com um índice do Elasticsearch deve copiar exatamente as regras do Lucene. Ou seja, ى → ي, não ى → ا.

Como é um normalizador testado?

Esta função segue as escolhas do Lucene, acrescenta tratamento de Unicode, dígitos e letras persas e deixa as regras arriscadas configuráveis. Ela usa só a biblioteca padrão.

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

O que ela retornou nas nossas strings de teste:

Entrada Saída Observação
أَحْمَدُ احمد Tashkeel e hamza removidos
الـــمدينة المدينه Tatweel e ta marbuta
إلى الي Alef e alef maksura
ا + U+0654 + مل امل Hamza decomposta composta e depois unificada
ﻻبد لابد Forma de apresentação desfeita
٢٠٢٦ / ۱۴۰۵ 2026 / 1405 Dígitos arábico-índicos e persas
مسؤول / مسئول Ambos مسءول com hamza_seats=True Sem alteração por padrão
فارسی فارسي Ya persa

Use-a em dois lugares: ao montar a chave do índice e ao ler uma consulta. Armazene original e normalize(original) lado a lado, busque no segundo e retorne o primeiro. O normalizador de texto em árabe gratuito permite colar um texto e ver o efeito de cada regra antes de escolher as configurações.

Como a normalização se encaixa em embeddings e RAG?

Um pipeline RAG costuma ter dois recuperadores: busca por palavras-chave (BM25) e embeddings. A normalização claramente ajuda o lado das palavras-chave. Para o lado dos embeddings, as evidências acima não valem: modelos de embedding são treinados com texto bruto, e muitos já colocam احمد e أحمد perto um do outro. Normalizar antes do embedding pode ajudar, não fazer diferença ou atrapalhar. Monte de 50 a 100 consultas reais com respostas conhecidas, rode-as com entrada bruta e normalizada e fique com a que tiver mais recall. O que você escolher, aplique de forma idêntica a documentos e consultas.

A normalização também reduz um pouco a contagem de tokens, porque diacríticos e tatweel são caracteres extras para o tokenizador. As proporções medidas estão no dataset de eficiência de tokenizadores e em tokens por palavra em árabe. A mesma normalização é usada para avaliar com justiça o reconhecimento de fala; veja WER em árabe explicado.

O arabizi (árabe em letras latinas) exige uma abordagem totalmente diferente: como os LLMs lidam com arabizi.

Onde a BroadNet Inference entra

A normalização roda no seu próprio código, então não precisa de API. A BroadNet Inference entra depois da recuperação. Ela não vende embeddings, então combine um recuperador e um provedor de embeddings da sua escolha com um modelo de chat da BroadNet para a etapa de resposta. O GLM 5.3 e o DeepSeek V4.1 Flash aceitam 1.048.576 tokens de contexto, então você pode passar muitos trechos recuperados no árabe original, sem normalização. Para escolher um modelo pela qualidade em árabe, veja como escolher um LLM para árabe. Se você só precisa de busca por palavras-chave, o analyzer arabic embutido do Elasticsearch pode ser tudo de que você precisa.

Perguntas frequentes

Devo remover o tashkeel (diacríticos) antes de indexar texto em árabe?

Para busca, sim: a maioria das consultas e dos textos modernos não tem diacríticos, então documentos com diacríticos deixariam de ser encontrados. Remova-os da chave do índice e da consulta, guarde o texto original para exibição e mantenha-os para Alcorão, poesia ou tarefas de pronúncia, em que eles carregam sentido.

O ta marbuta (ة) deve ser normalizado para ha (ه)?

Normalmente sim, para busca, porque muita gente digita ه no fim da palavra. Mas isso junta alguns pares, como كتابة (escrita) e كتابه (o livro dele). Se essas colisões importam no seu domínio, mantenha o ة e teste as duas configurações.

O que a normalização de árabe faz no Elasticsearch?

O filtro de token arabic_normalization usa o ArabicNormalizer do Lucene: formas de alef com hamza viram alef simples, ta marbuta vira ha, alef maksura vira ya, e harakat e tatweel são removidos. O analyzer arabic embutido acrescenta stop words e um stemmer que remove artigos, conjunções, preposições e sufixos comuns colados à palavra.

Normalizar o árabe ajuda a busca por embeddings?

Isso não está comprovado. Os ganhos medidos vêm da recuperação por palavras-chave. Modelos de embedding aprendem com texto bruto e muitas vezes já lidam com variantes de grafia, então monte um pequeno conjunto de consultas reais e compare a recall com e sem normalização antes de decidir.

Devo normalizar o texto em árabe antes de enviá-lo a um LLM?

Em geral, não. Envie o texto original para que citações, nomes e referências fiquem exatos. Remover o tashkeel economiza alguns tokens, mas só faça isso quando a tarefa não precisar das marcas.

Ler em MarkdownPerguntar ao ChatGPTPerguntar ao ClaudePerguntar ao Perplexity