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

# Téléverser un dataset

> Créez un dataset à partir d’un fichier JSONL existant en le téléversant via la Management API.

Si vos exemples d’entraînement existent déjà en dehors du projet, téléversez-les sous forme de fichier JSONL plutôt que d’enregistrer le trafic via le [proxy d’inférence](/fr/model-distillation/proxy/overview). Model Distillation valide le fichier, attribue les répartitions d’entraînement et de validation, puis crée un dataset qui, comme tout autre dataset, peut servir au réétiquetage, au fine-tuning et aux évaluations.

Le téléversement n’est possible que via la Management API. L’interface affiche le dataset obtenu ainsi qu’un panneau **Uploaded source** dans les paramètres du dataset, mais ne propose pas de sélecteur de fichiers.

Cette page explique comment se déroule un téléversement, comment préparer le fichier, comment le téléverser en plusieurs parties et comment lire les résultats de validation.

<h2 id="prerequisites">
  Prérequis
</h2>

Avant de commencer, assurez-vous de disposer des éléments suivants :

* Une clé API W\&B associée à une équipe ayant accès à Model Distillation. Les exemples la lisent depuis la variable d’environnement `WANDB_API_KEY`, la transmettent dans l’en-tête `Authorization` et indiquent l’entity dans l’en-tête `Wandb-Entity`.
* Un projet au sein de cette équipe. L’alias du projet figure dans chaque chemin de requête. Pour créer un projet, consultez le [Démarrage rapide](/fr/model-distillation/quickstart).
* Les outils correspondant à l’onglet que vous comptez utiliser dans [Téléverser le fichier](#upload-the-file). Un seul des ensembles suivants suffit :
  * `curl`, accompagné de `jq` et `split`.
  * Python 3.9 ou version ultérieure avec le package `requests`.
  * Node.js 18 ou version ultérieure, sans package supplémentaire.

<h2 id="how-an-upload-works">
  Fonctionnement d’un téléversement
</h2>

Un téléversement est une *session d’importation* limitée à un projet. Une session contient exactement un fichier JSONL, que vous envoyez directement vers le stockage d’objets en plusieurs parties. La session passe par les états suivants :

| État | Signification |
| - | - |
| `uploading` | La session accepte le téléversement de parties. |
| `queued`, `validating`, `auditing`, `committing` | Le téléversement est terminé. Model Distillation analyse les lignes, vérifie les répartitions et les doublons, puis écrit le dataset. |
| `ready` | Le dataset existe. Son ID figure dans `dataset_id`. |
| `failed` | La validation ou la création du dataset a échoué. `error` en indique la raison, et `validation.errors` répertorie les problèmes au niveau des lignes. |
| `cancelled` | Vous avez supprimé la session avant qu’elle n’atteigne l’état `ready`. |
| `expired` | La session est restée à l’état `uploading` pendant 7 jours sans être finalisée. |

Une session encore à l’état `uploading` 7 jours après sa création expire. Les requêtes de téléversement de parties et de finalisation qui lui sont adressées renvoient `410 Gone`, puis une tâche exécutée toutes les heures la fait passer à l’état `expired` et supprime ses parties. Les objets téléversés et les téléversements multipart incomplets sont supprimés 8 jours après leur écriture, que la session ait été finalisée ou non.

Une entity désigne le compte d’équipe ou personnel indiqué dans l’en-tête `Wandb-Entity`. Chaque entity peut avoir deux sessions en cours simultanément, pour une taille de fichier déclarée totale de 2 Gio au maximum. Une session est prise en compte dans ces deux limites dès sa création et jusqu’à ce qu’elle atteigne l’état `ready`, `failed`, `cancelled` ou `expired`. Toute requête qui dépasserait l’une de ces limites renvoie `429 Too Many Requests`. Pour libérer de la capacité, annulez une session dont vous n’avez plus besoin ou attendez qu’une session en cours se termine.

<h2 id="prepare-the-file">
  Préparer le fichier
</h2>

Avant de créer une session d’importation, assurez-vous que le fichier respecte le format de ligne et les limites décrites dans cette section. La validation ne s’exécute qu’une fois le téléversement terminé, et une session en échec ne peut pas être rouverte. Pour corriger un problème de format, créez une nouvelle session et téléversez de nouveau le fichier.

Le fichier doit être au format JSONL encodé en UTF-8 : un objet JSON par ligne, sans clé en double au sein d’un même objet.

<h3 id="row-format">
  Format des lignes
</h3>

Chaque ligne est une requête OpenAI Chat Completions dont le dernier message correspond à la réponse de l’assistant vers laquelle orienter l’entraînement. Model Distillation enregistre les messages précédents, ainsi que les éventuels `tools`, `tool_choice` et `response_format`, en tant qu’entrée, et le dernier message de l’assistant en tant que sortie.

```json theme={"system"}
{"messages":[{"role":"system","content":"Classify the ticket."},{"role":"user","content":"My invoice is wrong."},{"role":"assistant","content":"billing"}],"row_id":"ticket-1042"}
```

Une ligne doit contenir au moins deux messages et peut en comporter jusqu'à 1 000. `tools` accepte jusqu'à 128 outils de type fonction et 1 Mio de JSON. Si le dernier message d'une ligne ne provient pas de l'assistant, la ligne échoue avec l'erreur `missing_assistant_target`.

<h3 id="optional-fields">
  Champs facultatifs
</h3>

Les lignes peuvent comporter les champs facultatifs suivants :

| Champ | Rôle |
| - | - |
| `row_id` | Identifiant stable, jusqu’à 512 caractères. Doit être unique dans le fichier. En son absence, la ligne est identifiée par son numéro de ligne. |
| `group_id` | Regroupe les lignes associées dans la même répartition, jusqu’à 512 caractères. Correspond par défaut à l’identité de la ligne. |
| `split` | `train` ou `val`. Requis sur chaque ligne lorsque `split_policy.mode` vaut `preserve`, et ignoré lorsque le mode vaut `automatic`. |
| `metadata` | JSON arbitraire, jusqu’à 64 Kio et 10 niveaux d’imbrication. |
| `provenance` | JSON arbitraire indiquant l’origine de la ligne, avec les mêmes limites que `metadata`. |

Les lignes ne doivent contenir aucun autre champ de premier niveau.

<h3 id="limits">
  Limites
</h3>

Les fichiers et les sessions d’importation doivent respecter les limites suivantes :

| Limite | Valeur |
| - | - |
| Taille de fichier | 1 Gio |
| Lignes par fichier | 100 000 |
| Taille d’une ligne | 10 Mio |
| Imbrication JSON | 64 niveaux |
| Taille des parties | 32 Mio, fixée par le serveur |
| Sessions en cours par entity | 2 |
| `size_bytes` total des sessions en cours, par entity | 2 Gio |

<h2 id="upload-the-file">
  Téléverser le fichier
</h2>

Le téléversement se déroule en plusieurs étapes : créer la session, téléverser le fichier par parties, finaliser le téléversement, puis interroger l’état jusqu’à ce que le dataset soit prêt. Les onglets suivants présentent l’ensemble du processus sous la forme d’un script unique en `curl`, Python et JavaScript. Des commentaires numérotés signalent les étapes, et la section [Fonctionnement du script](#how-the-script-works) détaille chacune d’elles.

Les scripts utilisent l’alias de projet `ticket-classifier` et un fichier nommé `tickets.jsonl`. Avant d’exécuter un script, remplacez l’entity, l’alias et le nom de fichier par les vôtres, puis définissez `WANDB_API_KEY` dans votre environnement. Utilisez une nouvelle `idempotency_key` pour chaque téléversement distinct.

<Tabs>
  <Tab title="curl">
    ```bash theme={"system"}
    #!/usr/bin/env bash
    # Nécessite curl, jq et split.
    set -euo pipefail

    API="https://distillation.training.wandb.ai/v1/tasks/ticket-classifier"
    ENTITY="your-team"
    FILE="tickets.jsonl"
    auth=(--header "Authorization: Bearer $WANDB_API_KEY" --header "Wandb-Entity: $ENTITY")

    # 1. Créer la session d'importation.
    size=$(wc -c < "$FILE" | tr -d ' ')
    curl --silent --fail --request POST --url "$API/dataset-imports" "${auth[@]}" \
      --header "Content-Type: application/json" \
      --data "$(jq -n --arg name "$FILE" --argjson size "$size" '{
        idempotency_key: "support-tickets-v1",
        name: "Support tickets (uploaded)",
        file: { name: $name, size_bytes: $size },
        split_policy: { mode: "automatic", val_fraction: 0.1 },
        duplicate_policy: { split_overlap: "drop_train" }
      }')" --output session.json
    import_id=$(jq -r '.id' session.json)
    part_size=$(jq -r '.file.part_size_bytes' session.json)
    part_count=$(jq -r '.file.part_count' session.json)

    # 2. Demander une URL de téléversement signée pour chaque partie.
    curl --silent --fail --request POST --url "$API/dataset-imports/$import_id/parts" "${auth[@]}" \
      --header "Content-Type: application/json" \
      --data "$(jq -n --argjson count "$part_count" '{ part_numbers: [range(1; $count + 1)] }')" \
      --output urls.json

    # 3. Téléverser les parties. La numérotation des parties commence à 1. Les URL signées contiennent leur propre autorisation.
    split -b "$part_size" -d -a 4 "$FILE" part-
    n=1
    for chunk in part-*; do
      url=$(jq -r --argjson n "$n" '.parts[] | select(.part_number == $n) | .url' urls.json)
      curl --silent --fail --request PUT --upload-file "$chunk" "$url"
      n=$((n + 1))
    done
    rm part-*

    # 4. Facultatif : lire la session pour vérifier quelles parties ont été reçues.
    curl --silent --fail --url "$API/dataset-imports/$import_id" "${auth[@]}" | jq '.file | {uploaded_bytes, parts}'

    # 5. Finaliser le téléversement. La validation et la création du dataset sont alors placées en file d'attente.
    curl --silent --fail --request POST --url "$API/dataset-imports/$import_id/complete" "${auth[@]}" --output /dev/null

    # 6. Interroger la session jusqu'à ce qu'elle soit prête ou en échec.
    while true; do
      curl --silent --fail --url "$API/dataset-imports/$import_id" "${auth[@]}" --output status.json
      case "$(jq -r '.state' status.json)" in
        ready|failed) break ;;
      esac
      sleep 10
    done
    jq '{state, dataset_id, error}' status.json
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={"system"}
    # Nécessite Python 3.9 ou version ultérieure, ainsi que le package requests.
    import os
    import time

    import requests

    API = "https://distillation.training.wandb.ai/v1/tasks/ticket-classifier"
    HEADERS = {
        "Authorization": f"Bearer {os.environ['WANDB_API_KEY']}",
        "Wandb-Entity": "your-team",
    }
    FILE = "tickets.jsonl"

    # 1. Créer la session d'importation.
    response = requests.post(
        f"{API}/dataset-imports",
        headers=HEADERS,
        json={
            "idempotency_key": "support-tickets-v1",
            "name": "Support tickets (uploaded)",
            "file": {"name": FILE, "size_bytes": os.path.getsize(FILE)},
            "split_policy": {"mode": "automatic", "val_fraction": 0.1},
            "duplicate_policy": {"split_overlap": "drop_train"},
        },
    )
    response.raise_for_status()
    session = response.json()
    import_id = session["id"]
    part_size = session["file"]["part_size_bytes"]
    part_count = session["file"]["part_count"]

    # 2. Demander une URL de téléversement signée pour chaque partie.
    response = requests.post(
        f"{API}/dataset-imports/{import_id}/parts",
        headers=HEADERS,
        json={"part_numbers": list(range(1, part_count + 1))},
    )
    response.raise_for_status()
    url_by_part = {part["part_number"]: part["url"] for part in response.json()["parts"]}

    # 3. Téléverser les parties. La numérotation des parties commence à 1. Les URL signées contiennent leur propre autorisation.
    with open(FILE, "rb") as handle:
        for part_number in range(1, part_count + 1):
            chunk = handle.read(part_size)
            requests.put(url_by_part[part_number], data=chunk).raise_for_status()

    # 4. Facultatif : lire la session pour vérifier quelles parties ont été reçues.
    progress = requests.get(f"{API}/dataset-imports/{import_id}", headers=HEADERS).json()
    uploaded = {part["part_number"] for part in progress["file"]["parts"]}
    missing = [n for n in range(1, part_count + 1) if n not in uploaded]

    # 5. Finaliser le téléversement. La validation et la création du jeu de données sont alors placées en file d'attente.
    requests.post(f"{API}/dataset-imports/{import_id}/complete", headers=HEADERS).raise_for_status()

    # 6. Interroger l'API jusqu'à ce que la session soit prête ou en échec.
    while True:
        status = requests.get(f"{API}/dataset-imports/{import_id}", headers=HEADERS).json()
        if status["state"] in ("ready", "failed"):
            break
        time.sleep(10)

    print(status["state"], status["dataset_id"], status["error"])
    ```
  </Tab>

  <Tab title="JavaScript">
    ```javascript theme={"system"}
    // Nécessite Node.js 18 ou version ultérieure. Aucun package à installer.
    import { open, stat } from "node:fs/promises";

    const API = "https://distillation.training.wandb.ai/v1/tasks/ticket-classifier";
    const HEADERS = {
      Authorization: `Bearer ${process.env.WANDB_API_KEY}`,
      "Wandb-Entity": "your-team",
    };
    const FILE = "tickets.jsonl";

    async function call(path, init = {}) {
      const response = await fetch(`${API}${path}`, { ...init, headers: { ...HEADERS, ...init.headers } });
      if (!response.ok) throw new Error(`${init.method ?? "GET"} ${path} failed: ${await response.text()}`);
      return response.status === 204 ? null : response.json();
    }

    // 1. Créer la session d'importation.
    const { size } = await stat(FILE);
    const session = await call("/dataset-imports", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        idempotency_key: "support-tickets-v1",
        name: "Support tickets (uploaded)",
        file: { name: FILE, size_bytes: size },
        split_policy: { mode: "automatic", val_fraction: 0.1 },
        duplicate_policy: { split_overlap: "drop_train" },
      }),
    });
    const importId = session.id;
    const partSize = session.file.part_size_bytes;
    const partCount = session.file.part_count;

    // 2. Demander une URL de téléversement signée pour chaque partie.
    const urls = await call(`/dataset-imports/${importId}/parts`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ part_numbers: Array.from({ length: partCount }, (_, i) => i + 1) }),
    });
    const urlByPart = new Map(urls.parts.map((part) => [part.part_number, part.url]));

    // 3. Téléverser les parties. La numérotation des parties commence à 1. Les URL signées contiennent leur propre autorisation.
    const handle = await open(FILE, "r");
    try {
      for (let partNumber = 1; partNumber <= partCount; partNumber++) {
        const offset = (partNumber - 1) * partSize;
        const chunk = Buffer.alloc(Math.min(partSize, size - offset));
        await handle.read(chunk, 0, chunk.length, offset);
        const put = await fetch(urlByPart.get(partNumber), { method: "PUT", body: chunk });
        if (!put.ok) throw new Error(`Part ${partNumber} failed with ${put.status}`);
      }
    } finally {
      await handle.close();
    }

    // 4. Facultatif : lire la session pour vérifier quelles parties ont été reçues.
    const progress = await call(`/dataset-imports/${importId}`);
    const uploaded = new Set(progress.file.parts.map((part) => part.part_number));
    const missing = Array.from({ length: partCount }, (_, i) => i + 1).filter((n) => !uploaded.has(n));

    // 5. Finaliser le téléversement. La validation et la création du dataset sont alors placées en file d'attente.
    await call(`/dataset-imports/${importId}/complete`, { method: "POST" });

    // 6. Interroger l'API jusqu'à ce que la session soit prête ou en échec.
    let status;
    while (true) {
      status = await call(`/dataset-imports/${importId}`);
      if (status.state === "ready" || status.state === "failed") break;
      await new Promise((resolve) => setTimeout(resolve, 10_000));
    }
    console.log(status.state, status.dataset_id, status.error);
    ```
  </Tab>
</Tabs>

<h3 id="how-the-script-works">
  Fonctionnement du script
</h3>

Les commentaires numérotés de chaque script correspondent aux étapes suivantes.

<Steps>
  <Step title="Créer la session d’importation">
    Le script envoie le nom du fichier et sa taille exacte en octets, la politique de répartition et, éventuellement, une politique de doublons. Pour en savoir plus sur le rôle de chaque politique, consultez [Répartitions et doublons](#splits-and-duplicates). La requête exige également une `idempotency_key` unique, afin qu’une requête relancée renvoie la session existante au lieu d’en créer une seconde.

    La réponse est `201 Created` et contient la session. Le script en conserve les champs `id`, `file.part_size_bytes` et `file.part_count`. L’extrait suivant présente ces champs :

    ```json theme={"system"}
    {
      "id": "3f9c2d1e-7b4a-4c58-9e21-0d6f8a1b2c3d",
      "state": "uploading",
      "dataset_id": null,
      "total_bytes": 73400320,
      "expires_at": "2026-09-24T18:02:11.000Z",
      "file": {
        "name": "tickets.jsonl",
        "size_bytes": 73400320,
        "part_size_bytes": 33554432,
        "part_count": 3,
        "state": "pending",
        "uploaded_bytes": 0,
        "parts": []
      }
    }
    ```
  </Step>

  <Step title="Demander les URL de téléversement">
    Le script demande une URL signée pour chaque numéro de partie, de 1 à `file.part_count`. La réponse liste chaque `part_number` avec son `url`, ainsi que `expires_in_seconds`. Chaque URL est valide pendant 15 minutes. Si les URL expirent avant que vous ne les utilisiez, demandez-en de nouvelles.
  </Step>

  <Step title="Téléverser les parties">
    Le script lit le fichier par blocs de `file.part_size_bytes` et envoie chaque bloc via une requête `PUT` à l’URL correspondant à son numéro de partie. Les numéros de partie commencent à 1 : le premier bloc est donc la partie 1. Chaque partie, à l’exception de la dernière, doit mesurer exactement `file.part_size_bytes`, la dernière contenant le reste. Vous pouvez envoyer les parties dans n’importe quel ordre, et en parallèle.

    Les URL signées intègrent leur propre autorisation : le script n’ajoute donc pas les en-têtes `Authorization` ou `Wandb-Entity` à ces requêtes.
  </Step>

  <Step title="Facultatif : vérifier les parties reçues">
    Pour reprendre après un transfert interrompu, lisez la session. `file.parts` liste chaque partie téléversée avec sa taille, et `file.uploaded_bytes` en indique le total. Demandez de nouvelles URL pour les parties manquantes, puis renvoyez-les. Les scripts Python et JavaScript calculent les numéros des parties manquantes, et le script `curl` affiche la liste des parties téléversées. Aucun des scripts ne renvoie les parties manquantes, car une exécution unique et sans interruption n’en laisse aucune.
  </Step>

  <Step title="Finaliser le téléversement">
    Lorsque toutes les parties sont présentes, le script finalise le téléversement. Model Distillation vérifie que les parties correspondent à la taille déclarée, calcule une empreinte, puis met en file d’attente la validation et la création du dataset.

    La réponse est `202 Accepted`. Si une partie est manquante, la réponse est `409 Conflict` avec le type `upload_incomplete`. Si une partie n’a pas la bonne taille, le type est `upload_manifest_mismatch`. Dans les deux cas, la session reste à l’état `uploading` : vous pouvez donc corriger les parties et relancer la finalisation. Si vous finalisez un téléversement déjà terminé, la requête renvoie la session actuelle sans erreur.
  </Step>

  <Step title="Interroger jusqu’à ce que le dataset soit prêt">
    Le script lit la session toutes les 10 secondes jusqu’à ce que `state` vaille `ready` ou `failed`. Pendant la validation, `validation.validated_rows` compte les lignes analysées, et `counters` indique `staged_rows`, `rejected_rows` et `rows_by_split`.

    Lorsque `state` vaut `ready`, `dataset_id` identifie le nouveau dataset. Utilisez-le pour le réétiquetage, le fine-tuning et les évaluations, ou ouvrez-le dans l’interface utilisateur. Si `state` vaut `failed`, consultez [Lire les résultats de validation](#read-validation-results).
  </Step>
</Steps>

<h2 id="splits-and-duplicates">
  Répartitions et doublons
</h2>

`split_policy` détermine la façon dont les lignes sont réparties entre l’entraînement et la validation :

* **`preserve`** conserve la valeur `split` de chaque ligne. Une ligne sans `split` échoue à la validation avec l’erreur `missing_split`.
* **`automatic`** ignore toute valeur `split` définie sur les lignes. Cette option calcule le hachage du `group_id` de chaque ligne (ou de l’identité de la ligne en l’absence de `group_id`) et attribue la fraction définie par `val_fraction` à la répartition de validation. La fraction par défaut est de 0,2. Les lignes qui partagent le même `group_id` sont toujours attribuées à la même répartition.

`duplicate_policy.split_overlap` détermine le comportement adopté lorsqu’une entrée identique figure dans les deux répartitions après l’attribution :

* **`reject`** (valeur par défaut) enregistre une erreur de validation pour chaque ligne en double entre les deux ensembles, et l’importation échoue.
* **`drop_train`** supprime les copies présentes dans l’ensemble d’entraînement et conserve celles de l’ensemble de validation.

Un `row_id` qui apparaît plusieurs fois dans le fichier échoue à la validation avec l’erreur `duplicate_row_id`, quelle que soit la politique choisie.

<h2 id="read-validation-results">
  Lire les résultats de validation
</h2>

Une session `failed` renvoie dans `error` une synthèse succincte, et `validation` fournit les détails :

* `error_count` indique le nombre total de problèmes détectés.
* `errors` répertorie jusqu’à 100 problèmes, triés par ligne, chacun avec `physical_line`, `code` et `message`.
* `errors_truncated` vaut `true` lorsque la liste n’affiche pas tous les problèmes détectés.

Les codes les plus fréquents sont `invalid_json`, `invalid_utf8`, `duplicate_json_key`, `row_too_large`, `missing_assistant_target`, `tools_too_large`, `missing_split` et `duplicate_row_id`. Corrigez le fichier, puis créez une nouvelle session. Une session en échec ne peut pas être rouverte.

<h2 id="cancel-an-upload">
  Annuler un téléversement
</h2>

Pour abandonner une session, supprimez-la. L’annulation est possible dans tous les états sauf `ready`. Vous pouvez donc aussi abandonner une session en cours de validation ou en échec. La réponse est `204 No Content`, l’état passe à `cancelled`, les parties déjà téléversées sont supprimées et tout dataset partiellement créé est retiré. Si vous renvoyez la requête sur une session annulée, vous obtenez de nouveau `204 No Content`.

```bash theme={"system"}
curl --request DELETE \
  --url "https://distillation.training.wandb.ai/v1/tasks/ticket-classifier/dataset-imports/$IMPORT_ID" \
  --header "Authorization: Bearer $WANDB_API_KEY" \
  --header "Wandb-Entity: your-team"
```

Une session ayant déjà atteint l’état `ready` renvoie `409 Conflict` avec le type `dataset_import_ready`. Pour retirer le dataset qu’elle a créé, supprimez directement ce dataset. Voir [Supprimer un dataset](/fr/model-distillation/studio/datasets#delete-a-dataset).

<h2 id="errors">
  Erreurs
</h2>

Les requêtes de session d’importation peuvent renvoyer les erreurs suivantes.

| Statut | Type | Cause |
| - | - | - |
| `403 Forbidden` | `dataset_uploads_disabled` | Les téléversements ne sont pas activés pour l’entity. |
| `409 Conflict` | `idempotency_conflict` | L’`idempotency_key` a déjà été utilisée avec un corps de requête différent. |
| `409 Conflict` | `dataset_import_not_uploading` | La session a quitté l’état `uploading` et n’accepte donc plus de nouvelles parties. |
| `409 Conflict` | `upload_incomplete` | Vous avez tenté de finaliser le téléversement avant la réception de toutes les parties. |
| `409 Conflict` | `upload_manifest_mismatch` | Une partie téléversée, ou le fichier assemblé, ne correspond pas à la taille déclarée. |
| `409 Conflict` | `dataset_import_ready` | Vous avez tenté d’annuler une session qui a déjà créé son dataset. |
| `409 Conflict` | `dataset_import_state_changed` | La session a changé d’état pendant votre requête. Récupérez-la de nouveau, puis réessayez. |
| `410 Gone` | `dataset_import_expired` | La session date de plus de 7 jours. Créez-en une nouvelle. |
| `422 Unprocessable Entity` | `validation_error` | Un numéro de partie est supérieur à `file.part_count`. |
| `429 Too Many Requests` | `dataset_import_concurrency_limit` | L’entity a déjà 2 sessions en cours. |
| `429 Too Many Requests` | `dataset_import_byte_quota` | Avec le nouveau fichier, la taille déclarée de l’ensemble des sessions en cours de l’entity dépasserait 2 Gio. |
| `502 Bad Gateway` | `object_storage_error` | Le stockage de téléversement a rejeté la requête. Réessayez plus tard. |
| `503 Service Unavailable` | `uploads_unavailable`, `temporal_unavailable` | Le stockage de téléversement ou la file d’attente de validation est injoignable. Réessayez plus tard. |

Pour les schémas de requête et de réponse, consultez les pages suivantes de la référence de la Management API :

* [Créer une session d’importation de dataset](/fr/model-distillation/reference/management/datasets/create-a-dataset-import-session)
* [Créer des URL de téléversement pour les parties de fichier](/fr/model-distillation/reference/management/datasets/create-upload-urls-for-file-parts)
* [Obtenir une session d’importation de dataset](/fr/model-distillation/reference/management/datasets/get-a-dataset-import-session)
* [Finaliser et valider une importation de dataset](/fr/model-distillation/reference/management/datasets/complete-and-validate-a-dataset-import)
* [Annuler une importation de dataset](/fr/model-distillation/reference/management/datasets/cancel-a-dataset-import)

<h2 id="next-steps">
  Étapes suivantes
</h2>

<CardGroup cols={2}>
  <Card title="Réétiquetage" icon="pen-to-square" href="/fr/model-distillation/studio/relabeling">
    Demandez à un modèle plus performant de réécrire les réponses de l’assistant dans le dataset téléversé, sans modifier les lignes d’origine.
  </Card>

  <Card title="Fine-tuning" icon="graduation-cap" href="/fr/model-distillation/studio/fine-tuning">
    Entraînez un modèle de base pris en charge sur le dataset téléversé, à partir des sorties d’origine ou d’un ensemble de sorties réétiquetées.
  </Card>
</CardGroup>


## Related topics

- [Datasets](/fr/model-distillation/studio/datasets.md)