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

# Ingestion des défaillances

> Envoyez rollouts et défaillances à Avala, et découvrez comment Avala les transforme en taxonomie des défaillances et en rapport d'écarts

La boucle commence par ce que vos robots font réellement. Vous envoyez des rollouts, y compris les défaillances et les interventions. Avala les lit, trouve les motifs récurrents et vous indique quelles données manquent.

## Formats

| Format | Mode d'arrivée |
| - | - |
| MCAP | Téléversement d'enregistrement de flotte, ou `avala import folder --data-type mcap` |
| ROS bags (`.bag`, `.db3`) | `avala import rosbag`, ou conversion en MCAP puis téléversement comme enregistrement de flotte |
| Jeux de données LeRobot | `avala import lerobot` depuis le Hugging Face Hub ou un répertoire local |
| Vidéo avec journaux | Vidéo via `avala import folder --data-type video`. Avala aligne les journaux sur la vidéo dans le cadre du programme. |
| Journaux d'évaluation Inspect Robots | `avala import inspect-robots`. Consultez la section Importer des journaux d'évaluation. |

MCAP conserve chaque topic et donne donc l'image la plus complète. L'importateur de ROS bags convertit les topics caméra (`sensor_msgs/Image` et `sensor_msgs/CompressedImage`) et conserve les états articulaires et les autres topics numériques ou textuels. Les nuages de points et les autres charges binaires sont ignorés. Envoyez du MCAP lorsque vous avez besoin de conserver tous les topics.

## Envoyer des rollouts comme enregistrements de flotte

Chaque téléversement va dans un enregistrement de flotte existant. Avala provisionne des enregistrements pour vos appareils enregistrés au démarrage du programme. Listez-les pour trouver l'UID de l'enregistrement.

```python Python theme={null}
from avala import Client

client = Client()  # reads AVALA_API_KEY

page = client.fleet.recordings.list(device_id="<device-uid>", limit=20)
for recording in page:
    print(recording.uid, recording.status, recording.started_at)

# Upload a local directory of rollout files into one recording.
session = client.fleet.uploads.upload_recording(
    "<recording-uid>",
    "./rollouts/2026-09-29",
)
print(session.uid, session.status)
```

```bash CLI theme={null}
# Preview what will be uploaded
avala fleet recordings upload \
  --source ./rollouts/2026-09-29 \
  --recording <recording-uid> \
  --dry-run

# Upload and wait for server-side processing
avala fleet recordings upload \
  --source ./rollouts/2026-09-29 \
  --recording <recording-uid> \
  --wait
```

`upload_recording` reprend un téléversement interrompu de la même source. Un appel terminé signifie que le traitement est en file d'attente. Vérifiez `client.fleet.recordings.get(uid).status` jusqu'à ce qu'il indique `ready`.

## Marquer les défaillances et les interventions comme événements

Les événements de flotte posent une étiquette sur un moment d'un enregistrement. Marquez chaque défaillance et chaque intervention pour qu'Avala les retrouve rapidement. Utilisez `type` pour la classe d'événement et `metadata` pour tout ce que votre stack journalise, comme la version du modèle et la tâche.

```python Python theme={null}
from avala import Client

client = Client()

event = client.fleet.events.create(
    recording="<recording-uid>",
    device="<device-uid>",
    type="anomaly",
    label="Plate slipped during placement",
    timestamp="2026-09-29T14:03:12Z",
    severity="warning",
    duration_ms=1800,
    tags=["failure", "regrasp"],
    metadata={"model_version": "your-policy@2026-09-20", "task": "load_dishwasher"},
)
print(event.uid)

# Many events at once
created = client.fleet.events.create_batch(
    events=[
        {
            "recording": "<recording-uid>",
            "device": "<device-uid>",
            "type": "state_change",
            "label": "Operator took over",
            "timestamp": "2026-09-29T14:03:15Z",
            "tags": ["intervention"],
        },
    ]
)
print(created)
```

```typescript TypeScript theme={null}
import Avala from "@avala-ai/sdk";

const avala = new Avala(); // reads AVALA_API_KEY

const event = await avala.fleet.events.create({
  recording: "<recording-uid>",
  device: "<device-uid>",
  type: "anomaly",
  label: "Plate slipped during placement",
  timestamp: "2026-09-29T14:03:12Z",
  severity: "warning",
  durationMs: 1800,
  tags: ["failure", "regrasp"],
  metadata: { model_version: "your-policy@2026-09-20", task: "load_dishwasher" },
});
console.log(event.uid);
```

```bash CLI theme={null}
avala fleet events create \
  --recording <recording-uid> \
  --device <device-uid> \
  --type anomaly \
  --label "Plate slipped during placement" \
  --timestamp 2026-09-29T14:03:12Z \
  --severity warning
```

Le `type` d'événement est l'un de `error`, `warning`, `info`, `state_change`, `anomaly` ou `custom`. `severity` est l'un de `info`, `warning`, `error` ou `critical`. Vous pouvez aussi créer des événements automatiquement avec des [règles d'enregistrement](/docs/visualization/fleet/recording-rules.md).

## Importer des ROS bags et des jeux de données LeRobot

Lorsque les rollouts se trouvent hors de la flotte, importez-les comme jeu de données. Installez d'abord l'extra correspondant au format.

```bash theme={null}
pip install "avala[rosbag]"
avala import rosbag ./rollout_0412.bag --name "Rollouts 0412" --slug rollouts-0412 --wait

pip install "avala[lerobot]"
avala import lerobot --repo-id your-hf-user/your-rollouts --name "Rollouts" --slug rollouts --wait
```

L'importateur LeRobot est décrit en détail dans [Exports](/docs/fr/fleet-learning/exports.md).

## Importer des journaux d'évaluation

Si vous évaluez votre politique avec [Inspect Robots](https://github.com/robocurve/inspect-robots), un outil d'évaluation open source, importez son journal d'évaluation JSON. Chaque essai, soit une scène dans une epoch, étiquette une séquence avec une [étiquette de résultat](/docs/fr/fleet-learning/sequence-metadata.md). Les essais en échec deviennent des séquences que vous pouvez filtrer, réviser et transformer en travail de collecte.

```bash theme={null}
pip install "avala[inspect]"

# Preview the trial-to-outcome mapping. Reads the log only.
avala import inspect-robots logs/load-dishwasher_1a2b3c4d.json --dataset your-org/dishwasher-eval --dry-run

# Label the sequences that already exist in the dataset, one per trial
avala import inspect-robots logs/load-dishwasher_1a2b3c4d.json --dataset your-org/dishwasher-eval

# Or create the dataset from each trial's recorded actions, plus camera frames if the run stored them
avala import inspect-robots logs/load-dishwasher_1a2b3c4d.json --dataset your-org/dishwasher-eval --create
```

| Essai Inspect Robots | Résultat |
| - | - |
| Score de réussite supérieur ou égal à `--success-threshold`, score de notation supérieur ou égal à `--expert-threshold` | `expert_success` |
| Score de réussite supérieur ou égal à `--success-threshold`, score de notation inférieur à `--expert-threshold` | `partial_success` |
| Score de réussite inférieur à `--success-threshold` | `failure` |
| L'essai a échoué sur une erreur ou a été annulé | `aborted` |
| Le scoreur de réussite n'a produit aucune valeur | Non étiqueté |

Chaque étiquette importée a `source` à `imported`, `evaluation_membership` à `held_out_eval` et `autonomy_level` à `autonomous`. `model_version` est la politique de l'exécution. La tâche de l'exécution devient une sous-tâche qui couvre tout l'essai. Les étiquettes écrites par une personne ou par un modèle sont conservées, sauf si vous passez `--overwrite`. La liste complète des options se trouve dans la [référence de la CLI](/docs/sdks/cli.md#inspect-robots-evaluation-logs).

## Inspecter les enregistrements et les événements avec le serveur MCP

Le serveur MCP lit les données de flotte. Interrogez votre assistant sur les défaillances récentes, ou appelez directement les outils :

* `fleet_list_recordings` et `fleet_get_recording` pour les enregistrements
* `fleet_list_events` filtré par `recording`, `device`, `type` ou `severity`
* `get_fleet_health` pour une synthèse à l'échelle de la flotte

Les téléversements et la création d'événements passent par le SDK ou la CLI. Consultez [Utiliser Avala avec l'IA](/docs/fr/getting-started/mcp.md) pour vous connecter.

## Ce qu'Avala fait des rollouts

Les étapes ci-dessous sont un service qu'Avala réalise dans le cadre du programme. Aucune API n'est à appeler pour elles.

1. **Segmentation.** Avala découpe chaque rollout en séquences et en sous-tâches aux changements d'état. Vos événements ancrent les moments de défaillance.
2. **Étiquetage.** Chaque séquence reçoit les deux axes de ses [métadonnées de séquence](/docs/fr/fleet-learning/sequence-metadata.md) : une vérification de validité technique et une étiquette de résultat.
3. **Regroupement.** Avala regroupe les défaillances selon ce qui a mal tourné et dans quelles conditions. Les groupes correspondent à une taxonomie des défaillances versionnée pour votre programme. Les nouveaux groupes étendent la taxonomie.
4. **Analyse des écarts.** Avala compare les groupes de défaillances avec la couverture de vos données d'entraînement existantes et avec les cohortes d'évaluation.

## Le rapport d'écarts

Avala livre un rapport d'écarts pour chaque lot de rollouts.

| Section | Contenu |
| - | - |
| Périmètre | Enregistrements, plage temporelle, versions du modèle et version de la taxonomie. |
| Taxonomie des défaillances | Chaque mode de défaillance, sa définition et des exemples de séquences. |
| Distribution | Nombres et taux de défaillances par mode, par version du modèle et par cellule de couverture. |
| Couverture manquante | Les [cellules de couverture](/docs/fr/fleet-learning/coverage.md) derrière chaque mode de défaillance qui manquent dans vos données d'entraînement ou y sont trop peu représentées. |
| Expériences proposées | Un brouillon d'[expérience de capacité](/docs/fr/fleet-learning/capability-experiments.md) par condition de défaillance prioritaire, avec une hypothèse et des cellules cibles. |

Vous examinez le rapport d'écarts et choisissez les priorités. Les expériences approuvées deviennent le prochain brief de collecte.
