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

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.

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.

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.

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 :

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. 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.