BroadRouter

Correção gramatical e ortográfica do árabe com um LLM: passo a passo

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

Peça ao modelo só o texto corrigido, com o mínimo possível de edições e sem reformular. Depois compare a resposta com a entrada no código: rejeite respostas que mudaram demais e rotule cada edição de palavra como hamza, taa marbuta, alef maqsura, junção, separação ou outra. Avalie uma amostra corrigida à mão pelas edições, com precision, recall e F0.5.

Revisar texto em árabe parece um prompt de uma linha: “corrija este texto”. Na prática, o modelo também reformula, adiciona diacríticos, troca uma palavra dialetal por uma formal e explica as mudanças, e você não consegue saber quais edições eram necessárias. Este post constrói, sobre um LLM compatível com a OpenAI, um corretor que faz o mínimo de edições, confere a resposta no código, rotula cada edição por tipo de erro e avalia o conjunto do jeito que os benchmarks de pesquisa fazem.

Quão bons são os LLMs em corrigir a gramática do árabe?

Os benchmarks de referência são as shared tasks QALB. O QALB-2014 usou comentários em árabe padrão moderno do site da Al Jazeera: mais de um milhão de palavras de texto de treino com cerca de 306.000 correções, e conjuntos de teste de cerca de 50.000 palavras. O QALB-2015 acrescentou uma segunda trilha com redações de estudantes de árabe como língua estrangeira (L2). Os dois avaliaram os sistemas pelas edições, com o M2 scorer. As melhores pontuações, em F1 (quanto maior, melhor):

Conjunto de teste F1 do melhor sistema Texto
Teste QALB-2014 67,91 Comentários de notícias escritos por nativos
Teste QALB-2015 nativos 72,87 Comentários de notícias escritos por nativos
Teste QALB-2015 L2 41,20 Redações de estudantes

A linha L2 é o alerta útil. Texto de estudantes tem mais erros de escolha lexical e palavras faltando, e o melhor sistema pontuou bem menos. Se os seus usuários estão aprendendo árabe, espere números mais parecidos com essa linha.

Kwon, Bhatia, Nagoudi e Abdul-Mageed (ArabicNLP 2023) rodaram depois o ChatGPT e o GPT-4 no conjunto de teste QALB-2014. Com o mesmo scorer:

Sistema F1
ChatGPT, 1 exemplo 53,59
ChatGPT, 5 exemplos 63,98
GPT-4, 5 exemplos 65,49
AraT5v2, com fine-tuning 67,70

Dois detalhes importam para o seu prompt. Mais exemplos ajudaram muito. E prompts zero-shot e prompts em árabe geraram respostas cheias de explicações que os autores não conseguiam avaliar automaticamente. Um corretor precisa de uma saída que um programa consiga comparar com um diff.

Por que não simplesmente normalizar o texto?

O normalizador de texto em árabe deste site remove tashkeel e tatweel, transforma أ إ آ em ا e, opcionalmente, ى em ي e ة em ه. É o passo certo para a busca, porque quem digita احمد deve encontrar أحمد. É o passo errado antes da correção, porque apaga a distinção que o corretor precisa restaurar. Depois da normalização, انا e أنا viram a mesma string: o erro de hamza some, e a correção junto.

Se você precisa das duas coisas, mantenha três cópias: o texto original, o texto corrigido que você mostra aos usuários e uma cópia normalizada do texto corrigido para o índice de busca. Normalização de texto em árabe para busca cobre o lado da indexação. Um único passo de normalização deve vir antes da correção: Unicode NFC, que junta um alif decomposto mais a hamza combinante num só caractere, para que o diff não aponte uma mudança que não existe.

O que o prompt deve dizer?

Peça edições mínimas, nomeie os tipos de erro que interessam, proíba as mudanças que você não quer e peça só o texto corrigido. Escrever as instruções em inglês ou em árabe é escolha sua; engenharia de prompt em árabe discute os prós e contras. Kwon et al. obtiveram saídas utilizáveis com instruções em inglês e exemplos. Acrescentar de três a cinco pares de frases corrigidas dos seus próprios dados (few-shot) é a melhoria mais barata para testar primeiro.

Use temperatura 0: você quer a mesma correção sempre. Se o texto estiver num dialeto, como o árabe egípcio ou do Golfo, diga se o dialeto deve ser mantido. O prompt abaixo assume árabe padrão moderno (MSA) e manda o modelo não mudar o estilo, o que também cobre o dialeto.

Como conferir a resposta do modelo?

O código faz uma requisição, mede quanto a resposta difere da entrada, extrai as edições no nível da palavra e rotula cada uma.

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)]}

Rodamos isso contra um servidor mock local com respostas prontas (nenhuma chamada à API real, já que o mock devolve o que nós escrevemos). Para ذهبت الى المدرسه و قابلت المعلمه في الصباح, a resposta ذهبت إلى المدرسة وقابلت المعلمة في الصباح gerou quatro edições: الى para إلى (hamza), المدرسه para المدرسة (taa marbuta), و قابلت para وقابلت (junção) e المعلمه para المعلمة (taa marbuta). Para مشي الي, listou مشي para مشى (alef maqsura) e الي para إلى (ortografia mista, porque corrige hamza e alef maqsura de uma vez). Uma resposta pronta que transformava الطقس جميل اليوم numa frase com o dobro do tamanho teve 0,52 de similaridade, então o código manteve o original e registrou a resposta em log.

Observações sobre o código:

  • A proteção por similaridade é uma ferramenta grosseira. Uma frase com muitos erros pode, legitimamente, ficar perto de 0,8. Ajuste o limite nos seus dados e mande as respostas rejeitadas para uma pessoa, não para o lixo.
  • max_tokens=2000 deixa espaço para o raciocínio. A documentação da BroadNet diz que DeepSeek V4.1 Flash, GLM 5.3 e Qwen3.8 27B raciocinam antes de responder e que o raciocínio conta para max_tokens; você também pode definir reasoning_effort como low. Veja respostas vazias de modelos de raciocínio.
  • Os rótulos de classe são regras, não um parser. “Other” inclui letras faltando (مسؤل para مسؤول), concordância e escolha de palavras. Para uma taxonomia completa, rode o ARETA (abaixo) nos mesmos pares.

Quais classes de erro você deve acompanhar?

Os organizadores do QALB apontam os alifs com hamza e a confusão entre alef maqsura e ya como os erros ortográficos mais comuns do árabe. O ARETA, anotador de tipos de erro do CAMeL Lab (Belkebir e Habash, CoNLL 2021), usa um conjunto de tags baseado no Arabic Learner Corpus. Suas tags ortográficas incluem OH (hamza), OT (ha e taa marbuta) e OA (alif e ya), ao lado de tags morfológicas, sintáticas, semânticas, de pontuação, de junção (MG) e de separação (SP). O artigo informa 85,8% de F1 micro-médio contra texto de estudantes rotulado à mão.

Classe Errado Certo O que dá errado
Hamza انا، الى، مسأله أنا، إلى، مسألة Hamza faltando, no suporte errado ou do lado errado do alif
Taa marbuta المدرسه المدرسة ة final escrito como ه, ou o contrário
Alef maqsura مشي، علي (preposição) مشى، على ى final escrito como ي; علي também é um nome, então o contexto decide
Junção ou separação و قابلت، عبدالله وقابلت، عبد الله Espaços ao redor de و e ال, nomes compostos
Pontuação ، ou ؟ faltando adicionados Foi na pontuação que os anotadores do QALB menos concordaram

Acompanhe a recall por classe. Um modelo que corrige o taa marbuta mas deixa passar a hamza depois de uma preposição precisa de exemplos desse padrão, não de outro modelo.

Como pontuar um corretor?

A correção de erros gramaticais (GEC) é avaliada por edições. Compare as edições que transformam a fonte numa frase de referência corrigida à mão com as edições que a transformam na saída do modelo. A precision é a proporção de edições do modelo que coincidem com a referência. A recall é a proporção de edições de referência que o modelo fez. O QALB informava F1; trabalhos posteriores, inclusive o de Kwon et al., também informam F0.5, que dá à precision o dobro do peso da recall, porque uma “correção” errada irrita mais o usuário do que uma que faltou.

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}

Num conjunto de brinquedo de duas frases com sete edições de referência, em que a saída deixou passar a junção e um taa marbuta e acrescentou um ponto final, o script imprimiu P 0.833, R 0.714 e F0.5 0.806, com recall por classe: hamza 2/2, taa marbuta 2/3, junção 0/1.

Essa é a ideia do M2, simplificada. O M2 scorer oficial procura o alinhamento das edições do sistema que melhor bate com a referência, então uma correção certa dividida em edições de outro jeito não é penalizada. A nossa correspondência exata é mais rígida. Use o scorer oficial quando for comparar com números publicados (a versão de desenvolvimento ainda exige Python 2). O ERRANT faz a mesma extração de edições, mas só para inglês.

Monte o conjunto de referência com texto real de usuários, de 100 a 200 frases, corrigidas por um único anotador cuidadoso com as mesmas regras de edição mínima que você deu ao modelo. Rode cada modelo e prompt candidato sobre ele e compare o F0.5 e a recall por classe. Como avaliar um LLM antes de trocar explica como fazer essa comparação de forma justa.

E o Tibyan e os dados sintéticos?

Dados rotulados de correção em árabe são escassos. Alrehili e Alhothali observam que o QALB-14 e o QALB-15 juntos têm cerca de 20.500 exemplos paralelos. O corpus Tibyan deles (arXiv 2024, depois na PeerJ Computer Science) usou o ChatGPT para gerar pares de frases com erro e corrigidas a partir de livros sobre erros comuns do árabe, revisados por linguistas. Ele tem cerca de 600.000 tokens, com sete tipos de erro: ortografia, morfologia, sintaxe, semântica, pontuação, junção e separação. Os autores dizem que o corpus é público; não encontramos um link de download para conferir a licença. Ele é útil para exemplos few-shot e testes de estresse, mas é sintético, então não o use como teste de aceitação.

Se você precisa de uma baseline sem LLM, o repositório arabic-gec do CAMeL Lab publica o código e os modelos de Alhafni et al. (EMNLP 2023). Só para ortografia, o pacote ar-corrector sugere palavras do dicionário a uma ou duas edições de distância; ele não trata gramática, e o último lançamento foi em 2021.

Qual modelo da BroadNet usar?

Os preços são por 1M de tokens, da página de preços da BroadNet. A saída de uma correção tem mais ou menos o tamanho da entrada, então o preço de saída pesa.

Modelo Por quê Entrada / saída
Qwen3.8 27B Raciocínio documentado; a BroadNet informa testes em árabe, incluindo a compreensão dos dialetos do Golfo e egípcio $0.175 / $2.17
GLM 5.3 Raciocínio documentado; contexto longo para documentos inteiros $0.78 / $3.46
DeepSeek V4.1 Flash O menor preço de saída entre os modelos de raciocínio daqui; também disponível em planos de sessão com preço fixo $0.175 / $0.52
Gemma 4 VL 26B Roda com o crédito inicial de $5, então você monta o pipeline antes de recarregar $0.10 / $0.22

Rode o scorer com cada modelo no seu conjunto de referência e escolha pelo F0.5 e pelo preço. O árabe costuma usar mais tokens por palavra que o inglês; cole uma amostra no contador de tokens para árabe e estime a conta com a calculadora de custo de API de LLM. Para revisar um grande acervo: a BroadNet não tem Batch API; processamento em lote sem uma Batch API mostra como fazer com concorrência limitada, ou numa sessão DeepSeek por $15 por semana (uma requisição por vez por sessão).

Onde a BroadNet Inference entra

O BroadRouter é o site da própria BroadNet. A BroadNet Inference dá acesso compatível com a OpenAI aos modelos acima, então o código roda com o SDK Python da OpenAI depois de trocar a base URL. Ela não tem endpoint de revisão de texto e não publica benchmark próprio de correção em árabe, então meça no seu texto. A declaração de privacidade dela diz que o conteúdo da inferência não é retido, o que importa quando você revisa mensagens de clientes. Se você precisa de um corretor auto-hospedado para volume muito alto, um modelo com fine-tuning como os do CAMeL Lab pode ser mais barato e mais consistente; as pontuações publicadas acima são o motivo para testar os dois.

Perguntas frequentes

O ChatGPT ou outro LLM consegue corrigir a gramática do árabe?

Sim, com limites. Num teste publicado no benchmark QALB-2014, o GPT-4 com cinco exemplos chegou a 65,49 de F1, perto mas abaixo de um AraT5v2 com fine-tuning, que fez 67,70. Use um prompt de edição mínima, confira a resposta no código e meça numa amostra do seu próprio texto.

Quais são os erros de ortografia mais comuns em árabe?

Hamza sobre o alif (انا por أنا, الى por إلى), alef maqsura escrito como ya (مشي por مشى), taa marbuta escrito como ha (المدرسه por المدرسة) e palavras separadas ou juntadas por engano, como و قابلت por وقابلت. Os organizadores do QALB apontam os alifs com hamza e a confusão entre alef maqsura e ya como os mais comuns.

Normalizar texto em árabe é o mesmo que corrigir a ortografia?

Não. A normalização junta de propósito variantes de grafia, como أ e ا, para que a busca e o matching as ignorem. A correção decide qual variante está certa no contexto. Corrija o texto original e normalize só a cópia que você indexa para a busca.

Como avaliar um corretor gramatical de árabe?

Corrija à mão de 100 a 200 frases reais com edições mínimas. Extraia as edições no nível da palavra da fonte para a referência e da fonte para a saída do modelo, depois conte as que coincidem para calcular precision, recall e F0.5. O M2 scorer usado no QALB faz isso com um alinhamento de edições mais esperto.

Existe uma biblioteca Python para checar a gramática do árabe?

Só para ortografia, o ar-corrector sugere palavras do dicionário a uma ou duas edições de distância. Para gramática, o CAMeL Lab publica código e modelos de GEC de pesquisa (arabic-gec). Uma API de LLM é o jeito mais rápido de começar; um modelo com fine-tuning pode ser mais consistente em alto volume.

Ler em MarkdownPerguntar ao ChatGPTPerguntar ao ClaudePerguntar ao Perplexity

Fontes