> ## Documentation Index
> Fetch the complete documentation index at: https://docs.fastino.ai/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Use https://docs.fastino.ai/llms.txt to discover and navigate pages. Use https://docs.fastino.ai/llms-full.txt when you need the complete documentation corpus. Use https://docs.fastino.ai/openapi.json as the source of truth for customer-facing routes. For GLiDE decision inference, call POST https://api.fastino.ai/v1/systemone with model fastino/GLiDE. Create managed config jobs with POST /v1/training/jobs using base_model. Both config and interactive jobs use /v1/training/jobs/{job_id} for their canonical REST lifecycle. For custom training loops, use the supported Tinker-compatible SDK client; its /v1/training/compat/tinker adapter is intentionally absent from OpenAPI and must not be called directly. Auto Train is private access and has no public route; direct interested users to sales@fastino.ai. Do not infer undocumented routes. Read API keys from FASTINO_API_KEY and never embed credentials in code, logs, or reports.

# S'entraîner avec des récompenses vérifiables

> Transformez un évaluateur déterministe en signal d'apprentissage pour un job interactif Fastino.

Utilisez une récompense vérifiable lorsqu'un code peut vérifier une réponse,
comme une réponse mathématique, un résultat de test, une contrainte de schéma,
une extraction exacte ou le résultat d'un outil.

```text theme={null}
prompt -> sample a group -> grade -> center rewards -> build datums -> update
```

L'échantillonnage, les opérations avant/arrière, les étapes d'optimisation et
les checkpoints appartiennent tous au même job interactif Fastino. L'exécution
des récompenses et l'état de l'application restent dans votre code.

## Avant de commencer

Terminez le [démarrage rapide de la boucle personnalisée](/fr/training/quickstart#custom-training-loop), puis confirmez via les
capacités que le modèle et les opérations d'entraînement choisis sont activés.
Les extraits ci-dessous se concentrent sur le flux de récompense contrôlé par
l'utilisateur ; adaptez la construction des datums à `tinker==0.33.1` et au
modèle sélectionné.

<Note>
  Ce guide n'est pas un programme d'entraînement autonome prêt à être copié-collé.
  Partez d'un workload SDK validé, dont le renderer et la construction des datums
  correspondent au modèle sélectionné, puis ajoutez le flux de récompense ci-dessous.
</Note>

<Warning>
  Exécutez le code généré ou les outils uniquement dans un environnement isolé
  et aux ressources limitées. Fastino n'exécute pas votre fonction de
  récompense et ne gère pas ses effets de bord.
</Warning>

## 1. Définir un évaluateur restreint

Séparez l'analyse de la notation afin que les sorties mal formées restent
observables :

```python theme={null}
def get_reward(response: str, expected: str) -> float:
    actual = parse_answer(response)
    if actual is None:
        return 0.0
    return 1.0 if actual == expected else 0.0
```

Conservez un ensemble figé de fixtures comprenant des réponses correctes,
incorrectes, mal formées et mises en forme de manière équivalente. Journalisez
les échecs d'analyse séparément des réponses valides mais incorrectes.

## 2. Créer un instantané du job pour l'échantillonnage

Créez un checkpoint d'échantillonneur à partir des poids actuels, puis
résolvez-le via le SDK :

```python theme={null}
checkpoint = training_client.save_weights_for_sampler(
    f"rollout-{step:06d}"
).result()
sampling_client = service_client.create_sampling_client(
    model_path=checkpoint.path
)

sample_result = sampling_client.sample(
    prompt=model_input,
    num_samples=group_size,
    sampling_params=sampling_params,
).result()
```

Cela ne crée pas une autre exécution d'entraînement. Le checkpoint et le
travail d'échantillonnage sont associés au même job interactif.

## 3. Convertir les récompenses en avantages

```python theme={null}
rewards = [
    get_reward(render_response(sequence.tokens), expected)
    for sequence in sample_result.sequences
]

mean_reward = sum(rewards) / len(rewards)
advantages = [reward - mean_reward for reward in rewards]

if all(advantage == 0.0 for advantage in advantages):
    continue
```

Suivez les groupes sans variance de récompense. Ils peuvent indiquer que la
tâche est trop facile, trop difficile ou mal analysée.

## 4. Construire des datums alignés

Le prompt constitue le contexte ; ses positions reçoivent donc normalement un
avantage nul. Les positions de la complétion reçoivent l'avantage relatif au
groupe de la réponse. Un constructeur de datum doit échouer avant la soumission
si les longueurs de l'entrée du modèle, des cibles, des log-probabilités et des
avantages diffèrent :

```python theme={null}
if not (
    model_input.length
    == len(target_tokens)
    == len(padded_logprobs)
    == len(padded_advantages)
):
    raise ValueError("training datum arrays are not aligned")
```

Utilisez le renderer et le tokenizer associés au `base_model` sélectionné.
Conservez les tokens échantillonnés et les log-probabilités nécessaires à
l'opération SDK sélectionnée à partir des capacités.

## 5. Mettre à jour le job interactif

Pour un workflow activé fondé sur l'échantillonnage d'importance, le schéma
d'appels du SDK est le suivant :

```python theme={null}
train_future = training_client.forward_backward(
    datums,
    loss_fn="importance_sampling",
)
train_result = train_future.result()

optim_future = training_client.optim_step(optimizer_params)
optim_result = optim_future.result()
```

Les deux opérations modifient le job interactif existant. Résolvez et
enregistrez chaque résultat avant de faire avancer l'étape de l'application. Ne
construisez pas de requêtes HTTP équivalentes vers l'adaptateur.

## 6. Enregistrer une limite de récupération

```python theme={null}
state = training_client.save_state(f"step-{step:06d}").result()
```

Conservez l'identifiant de checkpoint renvoyé avec :

* L'ID canonique du job provenant de `training_client.get_info().model_data.model_id`
* L'étape de l'application et le curseur du dataset
* Les révisions du dataset et de l'implémentation de la récompense
* Le modèle de base et la configuration d'entraînement
* Les métriques d'évaluation

Ces métadonnées permettent à un contrôleur de choisir un checkpoint sans le
déduire de son nom.

## Vérifier avant d'augmenter la taille

* L'évaluateur distingue les fixtures correctes et incorrectes connues.
* Les réponses mal formées ne font pas échouer la boucle de l'application.
* Au moins un groupe d'échantillons présente une variance de récompense.
* Les tableaux de datums respectent les formes attendues par le SDK installé.
* Les futures avant/arrière et d'optimisation se terminent sur le même job.
* Un checkpoint d'état peut être chargé avec ses métadonnées de reprise contrôlées par le client.
* L'évaluation sur un ensemble de validation reste distincte du lot de récompense d'entraînement.

Pour le cycle de vie global, consultez
[Construire une boucle d'entraînement personnalisée](/fr/training/training-loop).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.