---
title: "Corpus d'entraînement"
description: "Comment les documents sont exportés sous forme d'ensemble de formation prêt pour LoRA et comment le régénérer."
---

Chaque page de cette documentation est également un **point de données d'entraînement**. Nibiru embarque un script qui extrait un corpus JSONL propre et adapté au fine-tuning LoRA d'un modèle à poids ouvert — Llama, Mistral, Qwen, Gemma — sur des connaissances spécifiques à Nibiru.

## Exécutez-le
```bash
cd docs
npm run build:corpus
```
Ceci écrit :
```
docs/dist/corpus/
├── instructions.jsonl     # instruction → response pairs
├── chat.jsonl             # OpenAI/Anthropic chat-message format
├── completion.jsonl       # plain prompt → completion (legacy)
└── chunks.jsonl           # raw Markdown chunks (one per H2/H3 section)
```
## Formats

### `instructions.jsonl`

Instruction tuning compatible avec LoRA :
```json
{
  "instruction": "How do I scaffold a new module in Nibiru?",
  "input": "",
  "output": "Run `./nibiru -m <name>`, optionally with `-g` for Graylog hooks. This creates `application/module/<name>/` with traits/, plugins/, interfaces/, settings/<name>.ini and the main `<name>.php` class implementing `IModule`."
}
```
Chaque entrée est générée à partir d'une section de la documentation avec une question claire (dérivée du titre H2/H3) et le corps de la section comme réponse.

### `chat.jsonl`

Format des messages d'OpenAI / Anthropic :
```json
{
  "messages": [
    {"role": "system", "content": "You are an expert on the Nibiru PHP framework."},
    {"role": "user", "content": "How do I scaffold a new module?"},
    {"role": "assistant", "content": "Run `./nibiru -m <name>`. …"}
  ]
}
```
Compatible avec les ajustements d'OpenAI, l'API d'Anthropic pour l'évaluation et la plupart des outils LoRA attendant des entrées au format de chat (le modèle `sharegpt` d'Axolotl, Unsloth, LLaMA-Factory).

### `chunks.jsonl`

Blocs bruts à utiliser comme données de récupération RAG :
```json
{
  "id": "core/modules#observer-pattern",
  "title": "The observer pattern",
  "url": "/core/modules/#the-observer-pattern",
  "section": "core/modules",
  "language": "en",
  "tokens": 412,
  "content": "Modules implementing `SplSubject` can broadcast events…"
}
```
Ceci est exactement le fichier que l'[Oracle](/ai/oracle/) utilise en interne.

## Comment les morceaux sont dérivés

Le constructeur de corpus parcourt chaque fichier `.md` / `.mdx` sous `src/content/docs/`, le parse en un AST et le découpe aux frontières H2/H3. Il impose :

- Un bloc par section H2 (ou H3 si l'H2 est vide).
- ~200–800 jetons par bloc (diviser s'il est plus long, fusionner s'il est plus court).
- Les barres de code sont conservées intactes — ne jamais les diviser au milieu d'un bloc.
- Chaque bloc porte son chemin source, son URL ancre et le code langue.

Le script se trouve dans `scripts/build-corpus.mjs` et est entièrement configurable.

## Recette suggérée pour LoRA

Une ligne directrice pragmatique pour un modèle de base à 8 milliards de paramètres sur une seule A100 / 4090 :
```yaml
# axolotl.yaml
base_model: meta-llama/Llama-3.1-8B-Instruct
adapter: lora
lora_r: 16
lora_alpha: 32
lora_dropout: 0.05
lora_target_modules: [q_proj, k_proj, v_proj, o_proj]

datasets:
  - path: docs/dist/corpus/chat.jsonl
    type: sharegpt

sequence_len: 4096
sample_packing: true
gradient_accumulation_steps: 4
micro_batch_size: 2
num_epochs: 3
optimizer: adamw_bnb_8bit
learning_rate: 0.0002
warmup_ratio: 0.05
bf16: true
```
Entraînez, puis fusionnez les poids LoRA et servez-les via Ollama, vLLM ou text-generation-inference. Remplacez le `MODEL` de l'Oracle par votre point de terminaison local et vous avez une expérience utilisateur de conversation entièrement native Nibiru.

## Réexécuter à chaque modification du document

Connectez-le à votre CI :
```yaml
- name: Build corpus
  run: cd docs && npm run build:corpus
- name: Upload corpus artifact
  uses: actions/upload-artifact@v4
  with:
    name: nibiru-corpus
    path: docs/dist/corpus/
```
Lorsque les documents changent, le corpus se reconstruit ; les consommateurs (pipelines d'entraînement, index RAG) ont toujours les données les plus récentes.

## Langues

Le corpus respecte la localisation. Les pages sous `en/` sont étiquetées `language: en`, les pages allemandes `language: de`, et ainsi de suite. Entraînez des LoRAs monolingues ou multilingues en filtrant le JSONL sur le champ `language`.

## Licencia

Les documents sont sous licence BSD-4-Clause, comme le cadre lui-même. Le corpus exporté hérite de cette licence — vous êtes libre de fine-tuner les modèles dessus à des fins commerciales, avec obligation d'attribution.
