---
title: "Correcteur d’orthographe et de grammaire arabe par LLM"
description: "Corriger l’orthographe et la grammaire arabes via une API LLM : prompt à modifications minimales, garde-fou anti-réécriture, éditions par type d’erreur, score M2."
url: https://broadrouter.com/fr/blog/arabic-grammar-spelling-correction-llm/
lang: fr
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/blog/arabic-grammar-spelling-correction-llm/) (mis à jour le 2026-11-16).

# Correction grammaticale et orthographique de l’arabe par LLM : guide

Par l’équipe BroadNet Inference · 8 min de lecture · Publié 2026-11-15 · Mis à jour 2026-11-16

Demandez au modèle le texte corrigé seul, avec le moins de modifications possible et sans reformulation. Comparez ensuite la réponse à l’entrée dans le code : rejetez les réponses qui changent trop de choses, et classez chaque édition au niveau du mot en hamza, taa marbouta, alif maqsoura, fusion, séparation ou autre. Évaluez un échantillon corrigé à la main sur les éditions, avec précision, rappel et F0.5.

## À retenir

-   Sur le jeu de test QALB-2014, GPT-4 avec cinq exemples obtient 65,49 de F1 contre 67,70 pour un AraT5v2 affiné (Kwon et al., ArabicNLP 2023). Les LLM pilotés par prompt sont utilisables, pas automatiquement meilleurs.
-   Les alifs portant une hamza et la confusion alif maqsoura/ya sont les fautes d’orthographe arabes les plus courantes, selon les organisateurs de la tâche partagée QALB.
-   La correction s’évalue sur les éditions, pas sur des phrases entières. Extrayez les éditions au niveau du mot, comparez-les aux éditions de référence et donnez le F0.5, qui pondère la précision deux fois plus que le rappel.
-   Ne normalisez jamais un texte avant de le corriger. La normalisation ramène volontairement أ إ آ à ا et ة à ه, ce qui efface précisément les fautes que vous voulez corriger.
-   Protégez-vous des réécritures dans le code : si la réponse est nettement moins de 80 % similaire à l’entrée au niveau des caractères, gardez l’original et journalisez la réponse.

**Sur cette page**

1.  Les LLM sont-ils bons en correction grammaticale arabe ?
2.  Pourquoi ne pas simplement normaliser le texte ?
3.  Que doit dire le prompt ?
4.  Comment contrôler la réponse du modèle ?
5.  Quelles classes d’erreurs suivre ?
6.  Comment évaluer un correcteur ?
7.  Et Tibyan, et les données synthétiques ?
8.  Quel modèle BroadNet utiliser ?
9.  Où se situe BroadNet Inference

Relire de l’arabe semble tenir en un prompt d’une ligne : « corrige ce texte ». En pratique, le modèle reformule aussi, ajoute des diacritiques, remplace un mot dialectal par un mot soutenu et explique ses changements, et vous ne pouvez plus savoir quelles éditions étaient nécessaires. Cet article construit, sur un LLM compatible OpenAI, un correcteur qui fait le moins d’éditions possible, contrôle la réponse dans le code, classe chaque édition par type d’erreur et évalue le tout comme le font les benchmarks de recherche.

## Les LLM sont-ils bons en correction grammaticale arabe ?

Les benchmarks de référence sont les tâches partagées QALB. QALB-2014 utilisait des commentaires en arabe standard moderne publiés sur le site d’Al Jazeera : plus d’un million de mots d’entraînement avec environ 306 000 corrections, et des jeux de test d’environ 50 000 mots. QALB-2015 a ajouté une seconde piste avec des rédactions d’apprenants de l’arabe langue étrangère (L2). Les deux évaluaient les systèmes sur les éditions avec le M2 scorer. Les meilleurs scores, en F1 (plus haut, c’est mieux) :

| Jeu de test | F1 du meilleur système | Texte |
| --- | --- | --- |
| QALB-2014 test | 67.91 | Commentaires de presse de locuteurs natifs |
| QALB-2015 native test | 72.87 | Commentaires de presse de locuteurs natifs |
| QALB-2015 L2 test | 41.20 | Rédactions d’apprenants |

La ligne L2 est l’avertissement utile. Les textes d’apprenants contiennent plus d’erreurs de choix lexical et de mots manquants, et le meilleur système a obtenu un score bien plus bas. Si vos utilisateurs sont des apprenants, attendez-vous à des chiffres proches de cette ligne.

Kwon, Bhatia, Nagoudi et Abdul-Mageed (ArabicNLP 2023) ont ensuite fait passer ChatGPT et GPT-4 sur le jeu de test QALB-2014. Avec le même scorer :

| Système | F1 |
| --- | --- |
| ChatGPT, 1 exemple | 53.59 |
| ChatGPT, 5 exemples | 63.98 |
| GPT-4, 5 exemples | 65.49 |
| AraT5v2, affiné | 67.70 |

Deux détails comptent pour votre prompt. Davantage d’exemples aidaient beaucoup. Et les prompts zero-shot ainsi que les prompts rédigés en arabe produisaient des réponses truffées d’explications que les auteurs ne pouvaient pas évaluer automatiquement. Un correcteur a besoin d’une sortie qu’un programme peut comparer par diff.

## Pourquoi ne pas simplement normaliser le texte ?

Le [normaliseur de texte arabe](https://broadrouter.com/tools/arabic-text-normalizer/) de ce site retire le tachkil et le tatweel, ramène أ إ آ à ا et, en option, ى à ي et ة à ه. C’est la bonne étape pour la recherche, car un utilisateur qui tape احمد doit trouver أحمد. C’est la mauvaise étape avant une correction, car elle efface la distinction que le correcteur doit rétablir. Après normalisation, انا et أنا sont la même chaîne : la faute de hamza disparaît, et la correction avec.

Gardez trois copies si vous avez besoin des deux : le texte original, le texte corrigé affiché aux utilisateurs, et une copie normalisée du texte corrigé pour votre index de recherche. [Normalisation du texte arabe pour la recherche](https://broadrouter.com/fr/blog/arabic-text-normalization-search/) couvre le côté indexation. Une étape de normalisation a pourtant sa place avant la correction : Unicode NFC, qui réunit un alif décomposé et une hamza combinante en un seul caractère, pour que le diff ne signale pas un changement inexistant.

## Que doit dire le prompt ?

Demandez des éditions minimales, nommez les types d’erreur qui vous importent, interdisez les changements dont vous ne voulez pas et demandez uniquement le texte corrigé. Rédiger les instructions en anglais ou en arabe est votre choix ; [Prompt engineering en arabe](https://broadrouter.com/fr/blog/arabic-prompt-engineering/) détaille le compromis. Kwon et al. ont obtenu des sorties exploitables avec des instructions en anglais accompagnées d’exemples. Ajouter trois à cinq paires de phrases corrigées tirées de vos données (few-shot) est l’amélioration la moins chère à essayer en premier.

Réglez temperature à 0. Vous voulez la même correction à chaque fois. Si le texte est dans un dialecte comme l’égyptien ou l’arabe du Golfe, précisez s’il faut conserver le dialecte. Le prompt ci-dessous suppose de l’arabe standard moderne ([MSA](https://broadrouter.com/fr/glossary/msa/)) et demande au modèle de ne pas changer le style, ce qui couvre aussi le dialecte.

## Comment contrôler la réponse du modèle ?

Le code envoie une requête, mesure à quel point la réponse diffère de l’entrée, extrait les éditions au niveau du mot et classe chacune.

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

Nous l’avons exécuté contre un serveur fictif local avec des réponses préenregistrées (aucun appel à l’API réelle, puisque le serveur fictif renvoie ce que nous y avons écrit). Pour ذهبت الى المدرسه و قابلت المعلمه في الصباح, la réponse ذهبت إلى المدرسة وقابلت المعلمة في الصباح a donné quatre éditions : الى en إلى (hamza), المدرسه en المدرسة (taa marbouta), و قابلت en وقابلت (fusion) et المعلمه en المعلمة (taa marbouta). Pour مشي الي, il a listé مشي en مشى (alif maqsoura) et الي en إلى (orthographe mixte, puisque la hamza et l’alif maqsoura sont corrigés à la fois). Une réponse préenregistrée qui transformait الطقس جميل اليوم en une phrase deux fois plus longue a obtenu 0,52 de similarité ; le code a donc gardé l’original et journalisé la réponse.

Remarques sur le code :

-   **Le garde-fou de similarité est un outil grossier.** Une phrase truffée de fautes peut légitimement tomber près de 0,8. Ajustez le seuil sur vos propres données, et envoyez les réponses rejetées à une personne, pas à la corbeille.
-   **`max_tokens=2000`** laisse de la place au raisonnement. D’après la documentation de BroadNet, DeepSeek V4.1 Flash, GLM 5.3 et Qwen3.8 27B raisonnent avant de répondre, et ce raisonnement compte dans `max_tokens` ; vous pouvez aussi régler `reasoning_effort` sur low. Voir [réponses vides des modèles de raisonnement](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/).
-   **Les classes sont des règles, pas un analyseur.** La classe « other » regroupe les lettres manquantes (مسؤل en مسؤول), l’accord et le choix des mots. Pour une taxonomie complète, faites passer ARETA (ci-dessous) sur les mêmes paires.

## Quelles classes d’erreurs suivre ?

Les organisateurs de QALB citent les alifs à hamza et la confusion alif maqsoura/ya comme les fautes d’orthographe arabes les plus courantes. ARETA, l’annotateur de types d’erreurs du CAMeL Lab (Belkebir et Habash, CoNLL 2021), utilise un jeu d’étiquettes fondé sur l’Arabic Learner Corpus. Ses étiquettes orthographiques comprennent OH (hamza), OT (ha et taa marbouta) et OA (alif et ya), à côté d’étiquettes morphologiques, syntaxiques, sémantiques, de ponctuation, de fusion (MG) et de séparation (SP). Son article annonce 85,8 % de F1 en micro-moyenne face à des textes d’apprenants annotés à la main.

| Classe | Fautif | Correct | Ce qui cloche |
| --- | --- | --- | --- |
| Hamza | انا، الى، مسأله | أنا، إلى، مسألة | Hamza absente, sur le mauvais support ou du mauvais côté de l’alif |
| Taa marbouta | المدرسه | المدرسة | ة final écrit ه, ou l’inverse |
| Alif maqsoura | مشي، علي (préposition) | مشى، على | ى final écrit ي ; علي est aussi un prénom, le contexte tranche |
| Fusion ou séparation | و قابلت، عبدالله | وقابلت، عبد الله | Espaces autour de و et ال, noms composés |
| Ponctuation | ، ou ؟ manquant | ajouté | C’est sur la ponctuation que les annotateurs de QALB s’accordaient le moins |

Suivez le rappel par classe. Un modèle qui corrige le taa marbouta mais rate la hamza après une préposition a besoin d’exemples de ce cas, pas d’un autre modèle.

## Comment évaluer un correcteur ?

La correction grammaticale s’évalue sur les éditions. Comparez les éditions qui transforment la source en phrase de référence corrigée à la main avec celles qui la transforment en sortie du modèle. La précision est la part des éditions du modèle qui correspondent à la référence. Le rappel est la part des éditions de référence que le modèle a faites. QALB donnait le F1 ; les travaux plus récents, dont Kwon et al., donnent aussi le F0.5, qui pondère la précision deux fois plus que le rappel, car une « correction » fausse agace davantage les utilisateurs qu’une faute oubliée.

```python
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}
```

Sur un jeu jouet de deux phrases avec sept éditions de référence, où la sortie ratait la fusion et un taa marbouta et ajoutait un point, il a affiché P 0.833, R 0.714 et F0.5 0.806, avec le rappel par classe : hamza 2/2, taa marbouta 2/3, fusion 0/1.

C’est l’idée du M2, simplifiée. Le M2 scorer officiel cherche l’alignement des éditions du système qui correspond le mieux à la référence, si bien qu’une correction juste découpée autrement que la référence n’est pas pénalisée. Notre correspondance exacte est plus stricte. Utilisez le scorer officiel pour vous comparer à des chiffres publiés (sa version de développement exige encore Python 2). ERRANT fait la même extraction d’éditions, mais pour l’anglais seulement.

Constituez la référence à partir de vrais textes d’utilisateurs, 100 à 200 phrases, corrigées par un annotateur rigoureux avec les mêmes règles de modifications minimales que celles données au modèle. Faites passer chaque modèle et chaque prompt candidat, puis comparez le F0.5 et le rappel par classe. [Évaluer un LLM avant d’en changer](https://broadrouter.com/fr/blog/evaluate-llm-before-switching/) explique comment mener cette comparaison équitablement.

## Et Tibyan, et les données synthétiques ?

Les données annotées de correction arabe sont rares. Alrehili et Alhothali soulignent que QALB-14 et QALB-15 réunissent environ 20 500 exemples parallèles. Leur corpus Tibyan (arXiv 2024, puis PeerJ Computer Science) a utilisé ChatGPT pour générer des paires de phrases fautives et correctes à partir d’ouvrages sur les fautes courantes de l’arabe, relues par des linguistes. Il compte environ 600 000 tokens et sept types d’erreurs : orthographe, morphologie, syntaxe, sémantique, ponctuation, fusion et séparation. Les auteurs indiquent que le corpus est public ; nous n’avons pas trouvé de lien de téléchargement pour vérifier sa licence. Il est utile pour des exemples few-shot et des tests de résistance, mais il est synthétique : ne l’utilisez pas comme test d’acceptation.

S’il vous faut une base de comparaison sans LLM, le dépôt arabic-gec du CAMeL Lab publie le code et les modèles d’Alhafni et al. (EMNLP 2023). Pour l’orthographe seule, le paquet ar-corrector propose des mots du dictionnaire à une ou deux éditions près ; il ne traite pas la grammaire, et sa dernière version date de 2021.

## Quel modèle BroadNet utiliser ?

Prix par million de tokens d’après la page des tarifs de BroadNet. La sortie d’une correction est à peu près aussi longue que l’entrée, le prix de sortie compte donc.

| Modèle | Pourquoi | Entrée / sortie |
| --- | --- | --- |
| [Qwen3.8 27B](https://broadrouter.com/fr/models/qwen3.8-27b/) | Raisonnement documenté ; BroadNet fait état de tests en arabe, y compris la compréhension des dialectes du Golfe et égyptien | $0.175 / $2.17 |
| [GLM 5.3](https://broadrouter.com/fr/models/glm-5.3/) | Raisonnement documenté ; long contexte pour des documents entiers | $0.78 / $3.46 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/fr/models/deepseek-v4.1-flash/) | Prix de sortie le plus bas des modèles de raisonnement présentés ici ; aussi disponible en forfaits de session | $0.175 / $0.52 |
| [Gemma 4 VL 26B](https://broadrouter.com/fr/models/gemma-4-vl-26b/) | Fonctionne avec le crédit de départ de $5, vous pouvez donc construire la chaîne avant de recharger | $0.10 / $0.22 |

Faites tourner le scorer avec chaque modèle sur votre jeu de référence et choisissez selon le F0.5 et le prix. L’arabe demande en général plus de tokens par mot que l’anglais ; collez un échantillon dans le [compteur de tokens arabe](https://broadrouter.com/tools/arabic-token-counter/) et estimez la facture avec le [calculateur de coût d’API LLM](https://broadrouter.com/tools/llm-api-cost-calculator/). Pour relire une grande archive, BroadNet n’a pas de Batch API ; [traitement par lots sans Batch API](https://broadrouter.com/fr/blog/llm-batch-processing-without-batch-api/) montre comment procéder avec une concurrence bornée, ou sur une session DeepSeek à $15 la semaine (une requête à la fois par session).

## Où se situe BroadNet Inference

BroadRouter est le site de BroadNet. [BroadNet Inference](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-arabic-grammar-spelling-correction-llm&utm_content=body) donne un accès compatible OpenAI aux modèles ci-dessus ; le code tourne donc avec le [SDK Python d’OpenAI](https://broadrouter.com/fr/guides/openai-python-sdk/) après changement de l’URL de base. Il n’a pas d’endpoint de relecture et ne publie aucun benchmark de correction de l’arabe : mesurez sur vos textes. Sa déclaration de confidentialité indique que le contenu d’inférence n’est pas conservé, ce qui compte quand vous corrigez des messages de clients. S’il vous faut un correcteur auto-hébergé pour de très gros volumes, un modèle affiné comme ceux du CAMeL Lab peut être moins cher et plus constant ; les scores publiés ci-dessus sont la raison de tester les deux.

Outils gratuits sur ce sujet (en anglais)

-   [Arabic token counter](https://broadrouter.com/tools/arabic-token-counter/) Arabic vs English token counts per tokenizer: the "Arabic tax" in tokens and money.
-   [Arabic text normalizer](https://broadrouter.com/tools/arabic-text-normalizer/) Tashkeel, tatweel, alef, ya, ta marbuta, digits and invisible characters, with a matching Python function.
-   [Speech-to-text cost calculator](https://broadrouter.com/tools/speech-to-text-cost-calculator/) Hours, calls or voice notes to a monthly transcription bill, against your current provider.

[Outils gratuits (en anglais)](https://broadrouter.com/tools/)

## Termes de cet article

[Hamza](https://broadrouter.com/fr/glossary/hamza/)

La hamza (ء) est la lettre arabe qui note le coup de glotte. Elle s’écrit seule ou sur un support : alif (أ إ), waw (ؤ) ou ya (ئ), et آ combine alif et madda. Comme le texte saisi l’écrit de façon irrégulière, les moteurs de recherche et l’évaluation de la parole ramènent souvent les formes d’alif à ا.

[Token](https://broadrouter.com/fr/glossary/token/)

Un token est l’unité de texte qu’un modèle de langage lit et écrit : un mot, une partie de mot, un signe de ponctuation ou une suite d’octets produite par le tokenizer du modèle. Les API LLM comptent, limitent et facturent généralement l’usage en tokens.

[Tâ’ marbûta (ة)](https://broadrouter.com/fr/glossary/taa-marbuta/)

Le tâ’ marbûta (ة, U+0629) est une lettre arabe qui n’apparaît qu’en fin de mot et marque souvent les noms et adjectifs féminins. Il ressemble au hâ’ (ه, U+0647) surmonté de deux points : les textes saisis mélangent donc les deux, et de nombreux normaliseurs de recherche remplacent ة par ه.

[API batch (traitement par lots)](https://broadrouter.com/fr/glossary/batch-api/)

Une API batch est un endpoint LLM asynchrone qui accepte de nombreuses requêtes d’un coup, généralement sous forme de fichier, les traite dans une fenêtre définie plutôt qu’immédiatement et renvoie les résultats ensemble. Des fournisseurs comme OpenAI et Anthropic facturent les requêtes batch avec une remise par rapport à leurs API standard.

[Arabe standard moderne (MSA)](https://broadrouter.com/fr/glossary/msa/)

L’arabe standard moderne (MSA) est la forme standardisée de l’arabe utilisée à l’écrit, dans l’information, l’enseignement et le discours formel dans tout le monde arabe. Ce n’est la langue maternelle de personne : on parle au quotidien des dialectes régionaux, comme l’égyptien ou l’arabe du Golfe, et on passe au MSA dans les contextes formels.

[Appel d’outils (tool calling, function calling)](https://broadrouter.com/fr/glossary/tool-calling/)

L’appel d’outils, aussi appelé function calling, est une fonctionnalité des API LLM dans laquelle le modèle renvoie une demande structurée d’exécution d’une fonction définie par le développeur, avec des arguments JSON. L’application exécute la fonction et renvoie le résultat ; le modèle n’exécute jamais de code lui-même.

[Few-shot prompting (prompt avec exemples)](https://broadrouter.com/fr/glossary/few-shot-prompting/)

Le few-shot prompting est une technique où le prompt contient quelques exemples entrée-sortie résolus avant l’entrée réelle, pour qu’un modèle de langage en déduise la tâche et le format. Les poids du modèle ne changent pas ; le zero-shot n’utilise aucun exemple et le one-shot un seul.

[API compatible OpenAI](https://broadrouter.com/fr/glossary/openai-compatible-api/)

Une API compatible OpenAI est une API HTTP qui accepte les mêmes formats de requête et de réponse que l’API OpenAI, comme POST /v1/chat/completions. Les SDK et outils OpenAI peuvent donc l’utiliser en changeant seulement l’URL de base, la clé d’API et le nom du modèle.

## Questions fréquentes

### ChatGPT ou un autre LLM peut-il corriger la grammaire arabe ?

Oui, avec des limites. Dans un test publié sur le benchmark QALB-2014, GPT-4 avec cinq exemples atteint 65,49 de F1, proche mais en dessous d’un AraT5v2 affiné à 67,70. Utilisez un prompt à modifications minimales, contrôlez la réponse dans le code et mesurez sur un échantillon de vos propres textes.

### Quelles sont les fautes d’orthographe les plus courantes en arabe ?

La hamza sur l’alif (انا pour أنا, الى pour إلى), l’alif maqsoura écrit comme un ya (مشي pour مشى), le taa marbouta écrit comme un ha (المدرسه pour المدرسة), et les mots séparés ou soudés à tort, comme و قابلت pour وقابلت. Les organisateurs de QALB citent les alifs à hamza et la confusion alif maqsoura/ya comme les plus fréquentes.

### La normalisation du texte arabe équivaut-elle à une correction orthographique ?

Non. La normalisation fusionne volontairement des variantes d’écriture, comme أ et ا, pour que la recherche et l’appariement les ignorent. La correction décide quelle variante est juste dans le contexte. Corrigez le texte original, et ne normalisez que la copie que vous indexez pour la recherche.

### Comment évaluer un correcteur grammatical arabe ?

Corrigez à la main 100 à 200 phrases réelles avec des modifications minimales. Extrayez les éditions au niveau du mot de la source vers la référence et de la source vers la sortie du modèle, puis comptez les éditions concordantes pour la précision, le rappel et le F0.5. Le M2 scorer utilisé par QALB fait cela avec un alignement plus fin des éditions.

### Existe-t-il une bibliothèque Python de correction grammaticale arabe ?

Pour l’orthographe seule, ar-corrector propose des mots du dictionnaire à une ou deux éditions près. Pour la grammaire, le CAMeL Lab publie des modèles et du code de recherche en GEC (arabic-gec). Une API LLM est la façon la plus rapide de démarrer ; un modèle affiné peut être plus constant à gros volume.

## À lire ensuite

-   [Normaliser le texte arabe pour la recherche et le RAG : quoi changer](https://broadrouter.com/fr/blog/arabic-text-normalization-search/)
-   [Vocaliser un texte arabe avec un LLM : prompt, contrôles, DER](https://broadrouter.com/fr/blog/arabic-diacritization-llm/)
-   [Prompt engineering en arabe : registre, RTL, chiffres et texte mixte](https://broadrouter.com/fr/blog/arabic-prompt-engineering/)
-   [Extraction d’entités nommées en arabe par LLM : JSON, dates, contrôles](https://broadrouter.com/fr/blog/arabic-named-entity-extraction-llm/)
-   [Choisir une API LLM pour l’arabe : ce qu’il faut tester](https://broadrouter.com/fr/blog/choosing-an-llm-for-arabic/)
-   [Comment évaluer un LLM avant de changer de fournisseur](https://broadrouter.com/fr/blog/evaluate-llm-before-switching/)
-   [Traitement par lots LLM sans Batch API : un exécuteur reprenable](https://broadrouter.com/fr/blog/llm-batch-processing-without-batch-api/)
-   [Comptes rendus de réunion en arabe depuis l’audio : un pipeline API](https://broadrouter.com/fr/blog/arabic-meeting-minutes-from-recordings/)
-   [Comparatif des API OCR pour l’arabe : Google, Azure, Textract, Mistral](https://broadrouter.com/fr/blog/arabic-ocr-api-comparison/)
-   [Guide : Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)
-   [Guide : Pourquoi un modèle de raisonnement renvoie une réponse vide](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/)

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

[Commencer](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-arabic-grammar-spelling-correction-llm&utm_content=page-cta) ·

**Sources**

-   [Mohit et al., The First QALB Shared Task on Automatic Text Correction for Arabic, atelier ANLP à EMNLP 2014 : données, M2 scorer, tableaux 3 et 7 (vérifié le 2026-11-15)](https://aclanthology.org/W14-3605/)
-   [Rozovskaya et al., The Second QALB Shared Task on Automatic Text Correction for Arabic, WANLP 2015 : pistes locuteurs natifs et L2, tableaux 4, 8 et 9 (vérifié le 2026-11-15)](https://aclanthology.org/W15-3204/)
-   [Kwon, Bhatia, Nagoudi et Abdul-Mageed, Beyond English: Evaluating LLMs for Arabic Grammatical Error Correction, ArabicNLP 2023, tableau 2 (vérifié le 2026-11-15)](https://aclanthology.org/2023.arabicnlp-1.9/)
-   [Alrehili et Alhothali, Tibyan Corpus: Balanced and Comprehensive Error Coverage Corpus Using ChatGPT for Arabic GEC, arXiv 2411.04588 (vérifié le 2026-11-15)](https://arxiv.org/abs/2411.04588)
-   [Belkebir et Habash, Automatic Error Type Annotation for Arabic (ARETA), CoNLL 2021 (vérifié le 2026-11-15)](https://aclanthology.org/2021.conll-1.47/)
-   [CAMeL Lab, ARETA sur GitHub (MIT) : étiquettes d’erreur fondées sur l’ALC, comme OH hamza, OT ha/taa marbouta, OA alif/ya, MG fusion, SP séparation (vérifié le 2026-11-15)](https://github.com/CAMeL-Lab/arabic_error_type_annotation)
-   [Alhafni, Inoue, Khairallah et Habash, Advancements in Arabic Grammatical Error Detection and Correction, EMNLP 2023 ; code et modèles dans CAMeL-Lab/arabic-gec (vérifié le 2026-11-15)](https://aclanthology.org/2023.emnlp-main.396/)
-   [NUS M2Scorer sur GitHub : précision, rappel et F-beta au niveau des éditions pour la GEC ; la version de développement exige Python 2 (vérifié le 2026-11-15)](https://github.com/nusnlp/m2scorer)
-   [ERRANT sur GitHub : extrait et classe les éditions au format M2 ; anglais uniquement (vérifié le 2026-11-15)](https://github.com/chrisjbryant/errant)
-   [ar-corrector sur PyPI : correcteur à dictionnaire, plus de 500 000 mots, candidats à 1 ou 2 éditions, version 1.1.6 d’avril 2021 (vérifié le 2026-11-15)](https://pypi.org/project/ar-corrector/)
-   [Référence de l’API de BroadNet Inference : identifiants de modèles, le raisonnement compte dans max\_tokens, reasoning\_effort (vérifiée le 2026-11-15) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-arabic-grammar-spelling-correction-llm&utm_content=sources)
