# Comment préparer un jeu de données pour entraîner un modèle de langage à partir de zéro?

Date: 2026-03-17 · Author: Robert Scales · https://guidetoartificialintelligence.com/fr/apprendre/preparer-donnees-entrainer-modele-langage/

**Answer:** Choisissez un texte dont la licence convient à ce que vous prévoyez faire du modèle, puis nettoyez-le, retirez les doublons et les renseignements personnels, mélangez-le, réservez-en une partie pour la validation et rangez-le en fragments. La qualité de ce texte limite le modèle plus que la plupart des réglages d’entraînement, et la licence vous suit si vous publiez.

Un **jeu de données de préentraînement** est le texte brut qu’un modèle de langage lit pour apprendre comment la langue se comporte, avant qu’on lui enseigne à clavarder. Il diffère des quelques centaines de paires entrée-sortie utilisées pour l’ajustement fin : ici, il faut des milliards de caractères, et vous n’en lirez jamais la majeure partie. Le travail consiste donc à choisir une bonne source, puis à écrire des filtres fiables.

## Choisir une source

Ne commencez pas par moissonner le Web. Plusieurs groupes ont déjà fait le gros du filtrage, et leurs conditions de licence sont documentées.

| Jeu de données | Taille | Langue | Licence, selon sa fiche ou son article | Convient à |
|---|---|---|---|---|
| TinyStories GPT-4 Clean | 2,19 milliards de caractères, environ 673 Mo | Anglais | CDLA-Sharing 1.0 | Un premier projet sur du matériel modeste |
| FineWeb, échantillon 10B | 10 milliards de jetons, 27,6 Go | Anglais | ODC-By 1.0, plus les conditions de Common Crawl | Texte général du Web en anglais |
| FineWeb2 | Plus de 1 000 langues, avec un sous-ensemble français | Nombreuses | ODC-By 1.0 | Modèles non anglophones |
| Common Pile v0.1 | 8 To, 30 sources | Surtout l’anglais | Domaine public ou licence ouverte, source par source | Licences plus strictes |
| Common Corpus | 2,27 billions de jetons | Surtout anglais et français | Sans droit d’auteur ou sous licence libre, indiqué par document | Le français, et retracer chaque document |
| ClimbMix | 400 milliards de jetons | Anglais | CC BY-NC 4.0, « recherche et développement seulement » | La recherche |

Deux mises en garde se cachent dans ce tableau. ClimbMix est ce que nanochat télécharge par défaut depuis mars 2026, et sa licence interdit l’usage commercial. Un modèle entraîné pour le plaisir est une chose; un modèle que vous comptez vendre en est une autre. Et « ouvert » ne veut pas dire « libre des droits d’autrui ». Les données de FineWeb proviennent de pages Web moissonnées, et sa licence sur le jeu de données ne signifie pas que l’auteur de chaque page a consenti à l’entraînement de modèles. Les auteurs de la Common Pile ont pris le chemin inverse, ne gardant que le matériel dont ils pouvaient se fier à la licence, et ils ont écarté des sources comme YouTube Commons lorsqu’ils ne le pouvaient pas. Leurs modèles de 7 milliards de paramètres se comparent à des modèles Llama 1 et 2 de même budget : la voie stricte est donc praticable.

Pour le français, FineWeb lui-même n’aidera pas, puisqu’il filtre les documents qui ne sont pas clairement en anglais. Utilisez le sous-ensemble français de FineWeb2 ou Common Corpus.

## Ce que comporte le nettoyage

La fiche de FineWeb décrit une chaîne de traitement dont l’esprit mérite d’être copié : filtrer par adresse Web, détecter la langue, appliquer des règles de qualité (par exemple, rejeter les pages faites surtout de listes ou de lignes répétées), retirer les quasi-doublons et masquer les adresses de courriel et IP. Elle précise aussi franchement que des renseignements personnels s’y trouvent encore très probablement. Aucun filtre n’est parfait : si les détails d’une personne peuvent lui nuire, laissez carrément cette source de côté.

Les doublons méritent une attention particulière, parce qu’un modèle à qui on montre sans cesse le même texte a tendance à le mémoriser. Les copies identiques se repèrent facilement à l’aide d’un hachage, une courte empreinte du texte, comme ci-dessous. Les quasi-copies demandent une méthode comme MinHash, qu’utilise FineWeb; la bibliothèque gratuite `datatrove` la met en œuvre.

## Une petite chaîne de traitement à exécuter

Ce script lit un fichier JSONL dont chaque ligne a les champs `text`, `source` et `licence`. Il garde seulement les licences de votre liste, masque les courriels et numéros de téléphone évidents, écarte les documents très courts et les copies exactes, mélange, réserve 2 % pour la validation et écrit des fichiers Parquet, un format compact en colonnes que les outils d’entraînement lisent bien. Exécutez d’abord `pip install pyarrow`, et essayez-le sur un petit fichier d’échantillon.

```python
import hashlib, json, random, re, unicodedata
import pyarrow as pa, pyarrow.parquet as pq

EMAIL = re.compile(r"\b[\w.+-]+@[\w-]+\.[\w.-]+\b")
PHONE = re.compile(r"\b\d{3}[ .-]?\d{3}[ .-]?\d{4}\b")

def clean(text):
    text = unicodedata.normalize("NFC", text)
    text = EMAIL.sub("[email]", text)
    text = PHONE.sub("[phone]", text)
    return re.sub(r"[ \t]+", " ", text).strip()

seen, docs = set(), []
for line in open("raw.jsonl", encoding="utf-8"):
    row = json.loads(line)
    if row["licence"] not in {"cc0-1.0", "cc-by-4.0", "public-domain"}:
        continue
    text = clean(row["text"])
    if len(text) < 200:
        continue
    key = hashlib.sha256(text.lower().encode()).hexdigest()
    if key in seen:
        continue
    seen.add(key)
    docs.append({"text": text, "source": row["source"], "licence": row["licence"]})

random.Random(42).shuffle(docs)
n_val = max(1, len(docs) // 50)
splits = {"val": docs[:n_val], "train": docs[n_val:]}
for name, rows in splits.items():
    pq.write_table(pa.Table.from_pylist(rows), f"{name}.parquet", row_group_size=1024)
    print(name, len(rows), "documents", sum(len(r["text"]) for r in rows), "caractères")
```

La ligne `NFC` compte pour le français. Un « é » peut être stocké comme un seul caractère ou comme un « e » suivi d’un accent et, sans normalisation, votre découpeur en jetons (*tokenizer*) les traite comme deux choses différentes. Pour de vrais volumes, répartissez la sortie en de nombreux fichiers. nanochat utilise des fragments d’environ 250 millions de caractères, soit environ 100 Mo compressés chacun, ce qui permet à l’entraînement de télécharger les données au fur et à mesure.

Gardez les colonnes `source` et `licence`. Elles coûtent peu, et elles vous permettent de répondre à la question « sur quoi l’avez-vous entraîné? » au moment de publier.

> **À essayer :** chargez TinyStories avec `load_dataset("karpathy/tinystories-gpt4-clean", split="train")`, lisez 30 histoires au hasard et notez ce qui semble clocher. Tout projet devrait commencer par la lecture de ses données.

## Combien de texte faut-il pour un modèle d’une taille donnée?

Une façon approximative de comparer est le nombre de jetons par paramètre, un **paramètre** étant l’un des nombres que le modèle apprend. Les projets publiés varient beaucoup :

| Projet | Paramètres | Jetons d’entraînement | Jetons par paramètre |
|---|---|---|---|
| Comma v0.1-1T | 7 milliards | 1 billion | environ 140 |
| Base de référence DCLM | 7 milliards | 2,6 billions | environ 370 |
| SmolLM3 | 3 milliards | 11 billions | environ 3 700 |

nanochat compte autrement, en n’utilisant que les paramètres qu’il appelle *scaling parameters*. Ses documents situent le point le plus efficace pour ses petits modèles à environ 10 à 12 jetons par tel paramètre, et son *speedrun* de niveau GPT-2 en utilise 8. En pratique, ce *speedrun* demande environ 150 fragments, soit quelque 37 milliards de caractères et environ 15 Go compressés. Les très petits modèles en demandent bien moins : les auteurs de TinyStories ont obtenu des histoires pour enfants fluides avec moins de 10 millions de paramètres.

C’est donc le budget qui fixe généralement la quantité, et non une règle. Plus de jetons coûtent plus de temps de GPU, comme le montre le [détail des coûts](/fr/apprendre/combien-coute-entrainer-modele-langage-2026/). Commencez par ce que votre budget peut traiter, et gardez au moins quelques millions de jetons de validation, assez pour que le résultat cesse de sauter. De meilleures données peuvent aussi remplacer une plus grande quantité : les auteurs de DCLM disent égaler Llama 3 8B en moyenne sur leurs tâches avec 6,6 fois moins de calcul en améliorant le jeu de données.

## Sources

- FineWeb dataset card: https://huggingface.co/datasets/HuggingFaceFW/fineweb
- The Common Pile v0.1: An 8TB Dataset of Public Domain and Openly Licensed Text: https://arxiv.org/abs/2506.05209
- Nemotron-ClimbMix dataset card: https://huggingface.co/datasets/nvidia/Nemotron-ClimbMix

---

Tiré du Guide de l’intelligence artificielle, par Robert Scales, publié par Holistic Hybrid inc. Partage et adaptation permis selon la licence CC BY-NC-SA 4.0 (https://creativecommons.org/licenses/by-nc-sa/4.0/) : citez le guide, mettez un lien vers https://guidetoartificialintelligence.com/fr/apprendre/preparer-donnees-entrainer-modele-langage/, pas d’usage commercial sans permission, et gardez la même licence.
