Référence de l'API REST#

Ultralytics Platform fournit une API REST pour l'accès programmatique aux jeux de données, images, projets, modèles, entraînements, exportations et déploiements.

# List the datasets owned by a workspace
curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://platform.ultralytics.com/api/datasets/YOUR_USERNAME

Aperçu de l'API#

L'API est organisée autour des ressources principales de la Platform :

graph LR
    A[API Key]:::start --> B[Datasets]:::proc
    A --> C[Projects]:::proc
    B -->|images| G[Images]:::proc
    C -->|contains| D[Models]:::proc
    B -->|train on| D
    D -->|deploy| E[Deployments]:::proc
    D -->|export| F[Exports]:::proc

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff

Authentification#

La plupart des points de terminaison nécessitent une clé API. Les points de terminaison qui exposent du contenu public — lire un jeu de données, un projet ou un modèle public, lister des images de jeux de données publics, exécuter une inférence sur un modèle public ou effectuer une recherche dans Explore — acceptent également les demandes anonymes et renvoient simplement plus de résultats lorsqu'une clé est fournie.

Obtenir une clé API#

1. Va sur Settings > API Keys
2. Clique sur Create Key
3. Copie la clé générée

Consulte les clés API pour des instructions détaillées.

En-tête d'autorisation#

Inclue ta clé API en tant que jeton du porteur (bearer token) :

Authorization: Bearer YOUR_API_KEY

Exemple#

curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://platform.ultralytics.com/api/account/summary

URL de base#

Tous les points de terminaison de l'API utilisent :

https://platform.ultralytics.com/api

Chemins des ressources#

Les ressources sont désignées par les mêmes noms explicites qui apparaissent dans les URL de la Platform, et non par des identifiants de base de données :

• {owner} est un nom d'utilisateur personnel ou un identifiant d'espace de travail d'équipe : de 4 à 32 caractères, alphanumériques minuscules avec un seul tiret entre les segments.
• {dataset}, {project}, {model} et {deployment} suivent le même modèle en minuscules avec des tirets, jusqu'à 128 caractères.
• {imageId} et {exportId} sont des identifiants hexadécimaux de 24 caractères renvoyés par l'API.
• Renommer une ressource via PATCH modifie conjointement le nom d'affichage name et le nom de l'URL, et la réponse renvoie le nom d'URL actuel afin que tu puisses continuer à le suivre.

Limites de taux#

L'API applique des limites de type fenêtre glissante par clé API. Chaque route appartient à une catégorie, et chaque catégorie dispose d'un compteur indépendant, de sorte que 20 requêtes de prédiction ne consomment pas ton allocation par défaut.

Les routes de la Platform réservées au navigateur, telles que le paiement de facturation et la gestion d'équipe, ont leurs propres limites qui ne s'appliquent pas au trafic des clés API.

En cas de limitation, l'API renvoie 429 avec à la fois les en-têtes et un corps JSON :

Retry-After: 12
X-RateLimit-Reset: 2026-02-21T12:34:56.000Z

{
    "error": "Rate limit exceeded",
    "retryAfter": 12,
    "resetAt": "2026-02-21T12:34:56.000Z"
}

Points de terminaison dédiés (illimité)#

Les points de terminaison dédiés ne sont pas soumis aux limites de taux de la clé API de la Platform lorsque tu appelles directement le serviceUrl du déploiement (par exemple, https://predict-abc123.run.app/predict). Le débit dépend alors de la configuration du service déployé.

Format de réponse#

Réponses de succès#

Les réponses sont des objets JSON avec des champs spécifiques à la ressource. Il n'y a pas d'enveloppe générique : les points de terminaison de liste renvoient une collection nommée accompagnée de comptes, et les mutations renvoient les identifiants modifiés.

{
    "datasets": [{ "id": "65f1c0a2b3d4e5f601234567", "owner": "acme-vision", "dataset": "warehouse" }],
    "total": 1,
    "region": "us"
}

Les réponses contenant des données incluent également region (us, eu ou ap), la région de stockage pour cet espace de travail.

Réponses d'erreur#

Chaque réponse d'erreur est un objet JSON avec un message error :

{
    "error": "Dataset not found"
}

Pagination#

Le style de pagination dépend de la collection :

API Datasets#

Créer, parcourir et gérer des jeux de données d'images étiquetées pour l'entraînement de modèles YOLO. Voir la documentation des jeux de données.

Lister les Datasets#

GET /api/datasets/{owner}

Python SDK : client.datasets.list(owner)

Renvoie les jeux de données publics du propriétaire, ainsi que les jeux de données privés lorsque ta clé peut voir cet espace de travail.

Param'tres de requ'te :

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://platform.ultralytics.com/api/datasets/acme-vision?limit=10&includeSamples=false"

R'ponse :

{
    "datasets": [
        {
            "id": "65f1c0a2b3d4e5f601234567",
            "owner": "acme-vision",
            "dataset": "warehouse",
            "name": "Warehouse",
            "task": "detect",
            "visibility": "private",
            "imageCount": 1000,
            "classCount": 2,
            "classNames": ["person", "forklift"],
            "splits": { "train": 800, "val": 200, "test": 0, "labeled": 1000 },
            "annotationCount": 5400,
            "starCount": 3,
            "isStarred": false,
            "status": "ready",
            "createdAt": "2026-01-15T10:00:00Z",
            "updatedAt": "2026-01-16T08:30:00Z"
        }
    ],
    "total": 1,
    "region": "us"
}

Obtenir un Dataset#

GET /api/datasets/{owner}/{dataset}

Python SDK : client.datasets.retrieve(owner, dataset)

Renvoie l'objet de jeu de données complet sous une clé dataset, incluant classNames, splits, versions, source et l' objet metadata défini par l'utilisateur.

Cr'er un Dataset#

POST /api/datasets

Python SDK : client.datasets.create(dataset=..., name=...)

Corps :

{
    "dataset": "warehouse",
    "name": "Warehouse",
    "task": "detect",
    "description": "Forklift and pedestrian safety dataset",
    "classNames": ["person", "forklift"],
    "visibility": "private",
    "metadata": { "location": "factory-1", "reviewed": true },
    "owner": "acme-vision"
}

Réponse (201) :

{
    "id": "65f1c0a2b3d4e5f601234567",
    "owner": "acme-vision",
    "dataset": "warehouse",
    "region": "us"
}

Mettre ' jour le Dataset#

PATCH /api/datasets/{owner}/{dataset}

Python SDK : client.datasets.update(owner, dataset)

Corps (mise ' jour partielle) :

{
    "name": "Warehouse Safety",
    "description": "New description",
    "visibility": "public",
    "metadata": { "location": "factory-2", "reviewed": true }
}

Champs acceptés : name, description, visibility, metadata, tags, classNames, classColors, format, task, license, iconColor, iconLetter et starred. Envoie un objet metadata vide ({}) pour effacer les métadonnées personnalisées. Les clés de métadonnées sont limitées à 128 caractères et l'objet sérialisé à 500 000 caractères.

R'ponse :

{
    "success": true,
    "dataset": "warehouse-safety"
}

Le renommage modifie le nom dans l'URL, utilise donc la valeur dataset renvoyée pour les requêtes ultérieures.

Supprimer le Dataset#

DELETE /api/datasets/{owner}/{dataset}

Python SDK : client.datasets.delete(owner, dataset)

Déplace le jeu de données vers la corbeille, où il peut être récupéré pendant 30 jours.

Cloner un dataset#

POST /api/datasets/{owner}/{dataset}/clone

Python SDK : client.datasets.clone(owner, dataset)

Copie un jeu de données accessible, avec ses images et ses étiquettes, dans ton espace de travail personnel ou un espace de travail d'équipe.

Corps optionnel (tous les champs sont optionnels) :

{
    "dataset": "warehouse-copy",
    "name": "Warehouse Copy",
    "description": "Cloned for experimentation",
    "visibility": "private",
    "license": "CC-BY-4.0",
    "owner": "acme-vision"
}

Réponse (201) : id, owner, dataset, name, imageCount, classCount et region. Les jeux de données s'appuyant sur une source de stockage connectée renvoient 409 car leurs fichiers ne sont pas copiés.

Télécharger l'exportation d'un jeu de données#

GET /api/datasets/{owner}/{dataset}/export

Python SDK : client.datasets.export(owner, dataset)

Renvoie une URL de téléchargement NDJSON signée. Omets v pour exporter l'état actuel du jeu de données, en réutilisant l'exportation mise en cache rien n'a changé depuis sa génération.

Param'tres de requ'te :

R'ponse :

{
    "downloadUrl": "https://storage.googleapis.com/...&signature=...",
    "cached": true
}

Demander une version spécifique renvoie downloadUrl et version au lieu de cached.

Cr'er une version de Dataset#

POST /api/datasets/{owner}/{dataset}/export

Python SDK : client.datasets.create_export(owner, dataset)

Crée un instantané numéroté immuable du jeu de données et stocke son exportation NDJSON. Nécessite un accès éditeur.

Corps (optionnel) :

{
    "description": "Added 500 training images"
}

R'ponse :

{
    "version": 3,
    "downloadUrl": "https://storage.googleapis.com/...&signature=...",
    "reused": false
}

reused vaut true lorsque le jeu de données n'a pas changé depuis la version précédente et que cet instantané a été renvoyé à la place.

Mettre ' jour la description de la version#

PATCH /api/datasets/{owner}/{dataset}/export

Python SDK : client.datasets.update_export(owner, dataset, version=..., description=...)

Corps :

{
    "version": 2,
    "description": "Fixed mislabeled classes"
}

Réponse : {"ok": true}

Restaurer la version du jeu de données#

POST /api/datasets/{owner}/{dataset}/restore

Python SDK : client.datasets.restore(owner, dataset, version=...)

Reconstruit les images, les annotations et les classes à partir d'une version enregistrée sans copier les octets des images.

Corps :

{
    "version": 2
}

Réponse : {"version": 2, "imageCount": 1000}

Obtenir les statistiques du jeu de données#

GET /api/datasets/{owner}/{dataset}/class-stats

Python SDK : client.datasets.class_stats(owner, dataset)

Renvoie les comptes d'annotations par classe, les histogrammes d'images et d'annotations, ainsi que les cartes thermiques. Les grands jeux de données sont échantillonnés, auquel cas sampleSize indique combien d'images ont contribué.

Réponse (abrégée) :

{
    "classes": [{ "classId": 0, "count": 1500, "imageCount": 450 }],
    "imageStats": {
        "widthHistogram": [{ "bin": 640, "count": 120, "size": 1 }],
        "heightHistogram": [{ "bin": 480, "count": 95, "size": 1 }],
        "pointsHistogram": [{ "bin": 4, "count": 200, "size": 1 }],
        "formatDistribution": { "jpg": 900, "png": 100 },
        "fileSizeHistogram": [{ "bin": 250000, "count": 300, "size": 50000 }],
        "objectsPerImageHistogram": [{ "bin": 5, "count": 210, "size": 1 }],
        "bboxWidthHistogram": [{ "bin": 120, "count": 340, "size": 20 }],
        "bboxHeightHistogram": [{ "bin": 90, "count": 300, "size": 20 }]
    },
    "locationHeatmap": {
        "bins": [
            [5, 10],
            [8, 3]
        ],
        "maxCount": 50
    },
    "dimensionHeatmap": {
        "bins": [
            [2, 5],
            [3, 1]
        ],
        "maxCount": 12,
        "minWidth": 10,
        "maxWidth": 1920,
        "minHeight": 10,
        "maxHeight": 1080
    },
    "classNames": ["person", "forklift"],
    "cached": true,
    "sampleSize": null
}

Gérer les classes#

Fusionner des classes (réassigner les annotations à une classe cible, puis supprimer les sources) :

POST /api/datasets/{owner}/{dataset}/classes/merge

Python SDK : client.datasets.merge_classes(owner, dataset, source_class_ids=..., target_class_id=...)

{
    "sourceClassIds": [2, 4],
    "targetClassId": 1
}

Supprimer des classes (leurs annotations sont supprimées et les ID de classe restants sont décalés vers le bas) :

POST /api/datasets/{owner}/{dataset}/classes/delete

Python SDK : client.datasets.delete_classes(owner, dataset, class_ids=...)

{
    "classIds": [2, 4]
}

Les deux opérations renvoient success, les éléments mis à jour classNames et classColors, ainsi qu'un résumé des modifications (mergedClassIds et targetClassId, ou deletedClassIds et deletedAnnotations).

Redistribuer les splits#

POST /api/datasets/{owner}/{dataset}/splits/redistribute

Python SDK : client.datasets.redistribute_splits(owner, dataset, train=..., val=..., test=...)

Réassigne aléatoirement les images entre les divisions. Les trois pourcentages doivent totaliser 100.

{
    "train": 80,
    "val": 20,
    "test": 0
}

Réponse : success, les comptes résultants splits et modified (nombre d'images déplacées).

Plongements de jeu de données#

GET /api/datasets/{owner}/{dataset}/embeddings
POST /api/datasets/{owner}/{dataset}/embeddings
DELETE /api/datasets/{owner}/{dataset}/embeddings

SDK Python : client.datasets.embeddings(owner, dataset), client.datasets.create_embeddings(owner, dataset), client.datasets.delete_embeddings(owner, dataset)

GET renvoie le résumé de l'analyse (analyzedAt, embeddingsCount, latestImageAt, activeJob). POST met en file d'attente une analyse d'embeddings et renvoie 202 avec un jobId. DELETE annule la tâche active et renvoie l'ID de la tâche annulée ou null.

Clustering d'images#

GET /api/datasets/{owner}/{dataset}/images/clustering

Python SDK : client.datasets.clustering(owner, dataset)

Renvoie la disposition 2D UMAP d'une analyse terminée, paginée avec offset et limit (par défaut et max 50 000). Chaque entrée possède id, umapX, umapY, split, classIds, width, height, bytes, labelCount et missing.

Lister les modèles entraînés sur un jeu de données#

GET /api/datasets/{owner}/{dataset}/models

Python SDK : client.datasets.models(owner, dataset)

R'ponse :

{
    "models": [
        {
            "id": "65f1c0a2b3d4e5f601234599",
            "owner": "acme-vision",
            "project": "inspection",
            "model": "v3",
            "name": "v3",
            "status": "completed",
            "task": "detect",
            "epochs": 100,
            "bestEpoch": 87,
            "metrics": { "mAP50": 0.85, "mAP50-95": 0.72, "precision": 0.88, "recall": 0.81 },
            "startedAt": "2026-01-14T22:00:00Z",
            "completedAt": "2026-01-15T10:00:00Z",
            "createdAt": "2026-01-14T21:55:00Z"
        }
    ],
    "count": 1
}

Lister les images du jeu de données#

GET /api/datasets/{owner}/{dataset}/images

Python SDK : client.datasets.images(owner, dataset)

Param'tres de requ'te :

R'ponse :

{
    "images": [
        {
            "id": "65f1c0a2b3d4e5f601234567",
            "hash": "9f2c1d4b6a8e0f3c5d7b9a1e2f4c6d8b",
            "ext": "jpg",
            "name": "aisle-04.jpg",
            "thumbnailUrl": "https://storage.googleapis.com/...&signature=...",
            "width": 1920,
            "height": 1080,
            "split": "train",
            "labelCount": 6,
            "bytes": 284213,
            "error": null
        }
    ],
    "total": 1000,
    "hasMore": true,
    "classes": ["person", "forklift"],
    "errorCount": 0,
    "nextCursor": "65f1c0a2b3d4e5f601234567"
}

Obtenir les images sélectionnées#

POST /api/datasets/{owner}/{dataset}/images

Python SDK : client.datasets.selected_images(owner, dataset, image_ids=...)

Renvoie la même forme d'image pour un maximum de 1 000 ID d'images fournis, et accepte les mêmes paramètres de filtre et de requête URL que l'opération de liste.

{
    "imageIds": ["65f1c0a2b3d4e5f601234567", "65f1c0a2b3d4e5f601234568"]
}

Ingérer des données dans le jeu de données#

POST /api/datasets/{owner}/{dataset}/ingest

Python SDK : client.datasets.ingest(owner, dataset, body=...)

Traite un téléversement terminé, une archive distante ou une source de stockage connectée dans un jeu de données existant. Fournis exactement une source :

Les sessions de téléversement sont liées à un jeu de données par le assetId passé à POST /api/upload/signed-url, et l'ingestion rejette une session qui appartient à un jeu de données différent.

Corps (archive téléchargée) :

{
    "sessionId": "session_abc123",
    "targetSplit": "train"
}

Corps (archive distante ou NDJSON) :

{
    "sourceUrl": "https://example.com/my-dataset.zip"
}

Corps (importation d'étiquettes lors d'une ingestion ultérieure) :

{
    "sessionId": "session_abc123",
    "classMapping": { "person": 0, "automobile": "forklift", "background": null }
}

Corps (attachement de métadonnées par image) :

{
    "sessionId": "session_abc123",
    "imageMetadata": {
        "airbus-wing.jpg": { "aircraft": { "family": "A350" }, "inspectionStatus": "reviewed" },
        "images/tail.jpg": { "aircraft": { "family": "A320" }, "inspectionSeverity": 2 }
    }
}

Les clés de métadonnées doivent correspondre au chemin normalisé à l'intérieur de l'archive, y compris les dossiers. Pour les importations NDJSON, chaque enregistrement peut porter son propre objet metadata, qui prime sur une entrée correspondante imageMetadata. Les chemins d'archive sont limités à 1 024 caractères, les clés de métadonnées de haut niveau à 128 caractères, et chaque objet de métadonnées — ainsi que l'ensemble de la table de correspondances imageMetadata — à 500 000 caractères sérialisés.

Réponse (201) :

{
    "jobId": "65f1c0a2b3d4e5f6012345aa",
    "status": "queued"
}

graph LR
    A[POST /api/datasets]:::start --> B[POST /api/upload/signed-url]:::proc
    B --> C[PUT archive to signed URL]:::proc
    C --> D[POST /api/upload/complete]:::proc
    D --> E["POST /api/datasets/{owner}/{dataset}/ingest"]:::proc
    E --> F[Process archive]:::proc
    F --> G[Dataset ready]:::out

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef out fill:#9C27B0,color:#fff

import io
import zipfile
from pathlib import Path

import requests

api = "https://platform.ultralytics.com/api"
headers = {"Authorization": "Bearer YOUR_API_KEY"}
owner, dataset = "acme-vision", "warehouse"
dataset_id = "65f1c0a2b3d4e5f601234567"  # id returned by POST /api/datasets
image_path = Path("airbus-wing.jpg")

archive = io.BytesIO()
with zipfile.ZipFile(archive, "w", zipfile.ZIP_DEFLATED) as zf:
    zf.write(image_path, image_path.name)
data = archive.getvalue()

signed = requests.post(
    f"{api}/upload/signed-url",
    headers=headers,
    json={
        "assetType": "datasets",
        "assetId": dataset_id,
        "filename": "images.zip",
        "contentType": "application/zip",
        "totalBytes": len(data),
    },
)
signed.raise_for_status()
upload = signed.json()

requests.put(upload["uploadUrl"], headers={"Content-Type": "application/zip"}, data=data).raise_for_status()
requests.post(
    f"{api}/upload/complete",
    headers=headers,
    json={"sessionId": upload["sessionId"]},
).raise_for_status()

ingest = requests.post(
    f"{api}/datasets/{owner}/{dataset}/ingest",
    headers=headers,
    json={
        "sessionId": upload["sessionId"],
        "imageMetadata": {
            "airbus-wing.jpg": {
                "aircraft": {"family": "A350", "section": "wing"},
                "inspectionStatus": "reviewed",
            }
        },
    },
)
ingest.raise_for_status()
print(ingest.json())

API des images#

Inspecte, commente, déplace et supprime des images de jeu de données par leur ID d'image de 24 caractères. Voir la documentation sur les annotations.

Obtenir l'image#

GET /api/images/{imageId}

Python SDK : client.images.retrieve(image_id)

Renvoie metadata (personnalisé, défini par l'utilisateur), properties (nom de fichier, hachage, dimensions, division, comptes, horodatages), labels et le classNames du jeu de données.

Mettre à jour l'image#

PATCH /api/images/{imageId}

Python SDK : client.images.update(image_id, body=...)

Remplace soit les annotations, soit les métadonnées personnalisées — envoie l'une des deux structures, pas les deux.

Corps (annotations) :

{
    "labels": [
        { "classId": 0, "bbox": [0.5, 0.5, 0.2, 0.3] },
        { "classId": 1, "segments": [0.1, 0.2, 0.3, 0.2, 0.2, 0.4] }
    ]
}

Corps (métadonnées) :

{
    "metadata": { "location": "strasbourg", "reviewed": true }
}

Supprimer l'image#

DELETE /api/images/{imageId}

Python SDK : client.images.delete(image_id)

Supprime définitivement une image et ses annotations.

Annoter automatiquement l'image#

POST /api/images/{imageId}/predict

Python SDK : client.images.predict(image_id, model_id=...)

Exécute l'inférence YOLO sur l'image et renvoie les annotations prédites. Elle ne les enregistre pas — réécris les résultats avec PATCH /api/images/{imageId} lorsque tu en es satisfait.

Réponse : success, predictions (objets d'annotation), modelUsed et inferenceTime. Un modèle dont les classes ne correspondent pas au jeu de données renvoie 422.

Déplacer des images en masse#

PATCH /api/images/bulk

Python SDK : client.images.update_bulk(image_ids=..., split=...)

Déplace jusqu'à 1 000 images d'un jeu de données vers une division différente.

{
    "imageIds": ["65f1c0a2b3d4e5f601234567"],
    "split": "val",
    "conflictPolicy": "skip"
}

Les conflits de noms de fichiers ou de contenu renvoient 409 jusqu'à ce que tu choisis un choix global conflictPolicy parmi skip, keep_both ou replace. La réponse indique modifiedCount, skippedCount et targetSplit.

Supprimer des images en masse#

DELETE /api/images/bulk

Python SDK : client.images.delete_bulk(image_ids=...)

{
    "imageIds": ["65f1c0a2b3d4e5f601234567", "65f1c0a2b3d4e5f601234568"]
}

Supprime jusqu'à 1 000 images d'un seul jeu de données et renvoie deletedCount et deletedImageIds.

Obtenir les URLs d'images sign'es#

POST /api/images/urls

Python SDK : client.images.urls(image_ids=...)

Renvoie des URL signées temporaires pour un maximum de 100 ID d'images provenant d'un jeu de données.

{
    "imageIds": ["65f1c0a2b3d4e5f601234567"]
}

Réponse : urls et thumbnails, tous deux indexés par ID d'image.

API Projets#

Organise tes modèles en projets. Chaque modèle appartient à un seul projet. Voir la documentation sur les projets.

Lister les projets#

GET /api/projects/{owner}

Python SDK : client.projects.list(owner)

Param'tres de requ'te :

Obtenir un projet#

GET /api/projects/{owner}/{project}

Python SDK : client.projects.retrieve(owner, project)

Renvoie l'objet project, un tableau models de résumés par modèle (statut, métriques, époques, poids, arguments d'entraînement) et isOwner.

Cr'er un projet#

POST /api/projects

Python SDK : client.projects.create(project=..., name=...)

curl -X POST \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "project": "inspection",
    "name": "Inspection",
    "description": "Detection experiments",
    "metadata": {"department": "manufacturing", "cost_center": "cv-01"}
  }' \
  https://platform.ultralytics.com/api/projects

Réponse (201) : id, owner, project, region.

Mettre ' jour un projet#

PATCH /api/projects/{owner}/{project}

Python SDK : client.projects.update(owner, project)

Champs acceptés : name, description, visibility, metadata, tags, license, archived, iconColor, iconLetter, viewPreferences et starred.

{
    "metadata": { "department": "research", "program": "inspection" }
}

Envoie un objet vide metadata ({}) pour l'effacer. Les métadonnées du projet utilisent les mêmes limites de clé de 128 caractères et d'objet sérialisé de 500 000 caractères que les métadonnées de jeu de données.

Supprimer un projet#

DELETE /api/projects/{owner}/{project}

Python SDK : client.projects.delete(owner, project)

Déplace le projet et ses modèles vers la corbeille, en renvoyant cascadedModels.

Cloner un projet#

POST /api/projects/{owner}/{project}/clone

Python SDK : client.projects.clone(owner, project)

Clone un projet accessible et ses modèles terminés. Le corps optionnel accepte project, name, description, visibility, license et une destination owner.

API Modèles#

Gère les modèles YOLO entraînés — affiche les métriques, télécharge les poids, exécute l'inférence et surveille l'entraînement. Voir la documentation sur les modèles.

Lister les modèles d'un projet#

GET /api/models/{owner}/{project}

Python SDK : client.models.list(owner, project)

Param'tres de requ'te :

Obtenir un modèle#

GET /api/models/{owner}/{project}/{model}

Python SDK : client.models.retrieve(owner, project, model)

Param'tres de requ'te :

La réponse par défaut contient l'objet model — statut, tâche, métriques, trainArgs, trainResults, classNames, computeCost, metadata, et plus encore — ainsi que isOwner.

Créer un modèle#

POST /api/models

Python SDK : client.models.create(body=...)

Crée un enregistrement de modèle non entraîné auquel tu peux attacher des poids ou lancer un entraînement.

Réponse (201) : id, owner, project, model, region.

Mettre à jour un modèle#

PATCH /api/models/{owner}/{project}/{model}

Python SDK : client.models.update(owner, project, model)

Les champs acceptés incluent name, description, color, metadata, status, license, datasetSlug, trainArgs, trainResults, epochs, bestEpoch, bestFitness, version, trainingError et starred.

{
    "metadata": { "release": "candidate-3", "reviewed": true }
}

Le paramètre personnalisé metadata est distinct des champs gérés par l'entraînement tels que trainArgs, environment et trainResults, et utilise les mêmes limites de taille que les métadonnées de jeu de données.

Supprimer un modèle#

DELETE /api/models/{owner}/{project}/{model}

Python SDK : client.models.delete(owner, project, model)

Déplace le modèle vers la corbeille pendant 30 jours.

Télécharger les fichiers du modèle#

GET /api/models/{owner}/{project}/{model}/files

Python SDK : client.models.files(owner, project, model)

Renvoie des URL signées à courte durée de vie pour les poids du modèle.

{
    "files": [
        {
            "name": "best.pt",
            "size": 6534127,
            "downloadUrl": "https://storage.googleapis.com/...&signature=..."
        }
    ]
}

Cloner un modèle#

POST /api/models/{owner}/{project}/{model}/clone

Python SDK : client.models.clone(owner, project, model, project_body=...)

Copie un modèle accessible dans un projet existant.

{
    "owner": "acme-vision",
    "project": "inspection",
    "model": "v3-copy",
    "name": "V3 Copy",
    "description": "Cloned from a public model"
}

Exécute l'inférence#

POST /api/models/{owner}/{project}/{model}/predict

Python SDK : client.models.predict(owner, project, model, body=...)

Les modèles publics peuvent être prédits sans authentification. Les modèles privés et partagés nécessitent une clé API ayant accès au projet parent.

Formulaire Multipart :

Fournis soit file, soit source. Les modèles de profondeur acceptent également bits (8, 12 ou 16) pour sélectionner la quantification PNG de la carte de profondeur. Les requêtes qui dépassent les limites d'entrée du service renvoient 413.

curl -X POST \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "file=@image.jpg" \
  -F "conf=0.5" \
  https://platform.ultralytics.com/api/models/acme-vision/inspection/v3/predict

R'ponse :

Chaque entrée dans images contient shape, speed, results et, pour les tâches de prédiction dense, une charge utile PNG semantic_mask ou depth (les valeurs de profondeur sont pixel × max / divisor, avec un diviseur de 255 pour la carte 8 bits par défaut et de 65535 lorsque bits vaut 12 ou 16). L'objet metadata indique le nombre d'images, les durées d'exécution, la tâche et les versions du service. Les chemins de modèles internes ne sont jamais renvoyés.

{
    "images": [
        {
            "shape": [1080, 1920],
            "speed": { "preprocess": 2.1, "inference": 12.4, "postprocess": 1.3 },
            "results": [
                {
                    "class": 0,
                    "name": "person",
                    "confidence": 0.92,
                    "box": { "x1": 100, "y1": 50, "x2": 300, "y2": 400 }
                }
            ]
        }
    ],
    "metadata": {
        "imageCount": 1,
        "functionTimeAlive": 184.2,
        "functionTimeCall": 0.31,
        "task": "detect",
        "version": { "ultralytics": "8.4.120" }
    }
}

Vérifier la progression de l'entraînement#

GET /api/models/{owner}/{project}/{model}/training

Python SDK : client.models.training(owner, project, model)

Renvoie job, contenant le statut, la progression des époques, le temps, les détails de calcul, les arguments d'entraînement, les métriques des époques et les détails d'erreur sécurisés, ou null si le modèle n'a jamais été entraîné. Les modèles des projets publics sont lisibles sans authentification.

Annuler l'entraînement#

DELETE /api/models/{owner}/{project}/{model}/training

Python SDK : client.models.delete_training(owner, project, model)

Met fin à l'instance de calcul en cours d'exécution et marque la tâche comme annulée. Renvoie 409 lorsque l'entraînement n'est plus actif.

API d'entraînement#

Lance l'entraînement YOLO sur des GPU cloud et surveille la progression en temps réel. Voir la documentation sur l'entraînement cloud.

graph LR
    A[POST /api/training/start]:::start --> B[Job Created]:::proc
    B --> C{Training}:::decide
    C -->|progress| D[GET .../training]:::proc
    C -->|cancel| E[DELETE .../training]:::error
    C -->|complete| F[Model Ready]:::out
    F --> G[Deploy or Export]:::proc

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef decide fill:#FF9800,color:#fff
    classDef out fill:#9C27B0,color:#fff
    classDef error fill:#F44336,color:#fff

Obtenir la disponibilité GPU#

GET /api/training/gpu-availability

Python SDK : client.training.gpu_availability()

Renvoie le statut actuel du stock par ID de GPU. Public et sans authentification ; passe managed=true pour inclure la capacité d'entraînement gérée, qui nécessite une clé API.

Démarrer l'entraînement#

POST /api/training/start

Python SDK : client.training.start(model_id=..., train_args=...)

curl -X POST \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "modelId": "65f1c0a2b3d4e5f601234599",
    "gpuType": "rtx-4090",
    "trainArgs": {
      "model": "yolo26n.pt",
      "data": "ul://acme-vision/datasets/warehouse",
      "epochs": 100,
      "imgsz": 640,
      "batch": 16
    }
  }' \
  https://platform.ultralytics.com/api/training/start

R'ponse :

{
    "modelId": "65f1c0a2b3d4e5f601234599",
    "status": "starting",
    "gpuType": "rtx-4090",
    "estimatedCost": { "pricePerHour": 0.69, "gpuMemoryGb": 24 },
    "billing": {
        "estimatedCostCents": 138,
        "estimatedCostDisplay": "$1.38",
        "balanceCents": 2500
    }
}

L'entraînement renvoie 402 lorsque ton solde de crédits est trop bas et 503 lorsqu'aucune capacité n'est disponible pour le GPU demandé.

API d'exportations#

Convertis des modèles en formats optimisés tels que ONNX, TensorRT, CoreML et LiteRT pour le déploiement en périphérie (edge). Consulte la documentation sur le déploiement.

Lister les exportations#

GET /api/models/{owner}/{project}/{model}/exports

Python SDK : client.exports.list(owner, project, model)

Param'tres de requ'te :

Créer une exportation#

POST /api/models/{owner}/{project}/{model}/exports

Python SDK : client.exports.create(owner, project, model, format=...)

curl -X POST \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"format": "onnx", "args": {"imgsz": 640, "quantize": 16}}' \
  https://platform.ultralytics.com/api/models/acme-vision/inspection/v3/exports

Réponse (201) : id, format, status (queued ou running), gpuType, region. Une exportation équivalente déjà en cours renvoie 409.

Formats pris en charge :

Utilise l'argument format du tableau d'exportation partagé ci-dessous. PyTorch est le format source et ne constitue pas une cible d'exportation de l'API.

Obtenir le statut d'exportation#

GET /api/models/{owner}/{project}/{model}/exports/{exportId}

Python SDK : client.exports.retrieve(owner, project, model, export_id)

Renvoie l'objet export avec status, format, args, gpuType, les horodatages et — une fois terminé — un objet file contenant size, downloadUrl et downloadFilename.

Annuler ou supprimer une exportation#

DELETE /api/models/{owner}/{project}/{model}/exports/{exportId}

Python SDK : client.exports.delete(owner, project, model, export_id)

Annule une exportation active ou supprime une exportation terminée ainsi que son fichier. La réponse indique l'action qui a eu lieu :

{
    "success": true,
    "action": "cancelled"
}

API de déploiements#

Déploie des modèles sur des points de terminaison d'inférence dédiés avec des vérifications de santé et de la surveillance. Consulte la documentation sur les points de terminaison.

graph LR
    A[Create]:::start --> B[Deploying]:::proc
    B --> C[Ready]:::out
    C -->|action stop| D[Stopped]:::extern
    C -->|action replace| B
    D -->|action start| C
    C -->|delete| E[Deleted]:::error
    D -->|delete| E
    C -->|predict| F[Inference Results]:::out

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef out fill:#9C27B0,color:#fff
    classDef error fill:#F44336,color:#fff
    classDef extern fill:#607D8B,color:#fff

Lister les déploiements#

GET /api/deployments/{owner}

Python SDK : client.deployments.list(owner)

Param'tres de requ'te :

Les appelants anonymes doivent filtrer par un seul modèle public ; lister un espace de travail entier nécessite une authentification.

Créer un déploiement#

POST /api/deployments/{owner}

Python SDK : client.deployments.create(owner, project=..., model=..., deployment=..., name=..., region=...)

Corps :

{
    "project": "inspection",
    "model": "v3",
    "deployment": "edge-1",
    "name": "Edge 1",
    "region": "us-central1"
}

Réponse (201) : id, deployment, status (creating), message et region.

Obtenir un déploiement#

GET /api/deployments/{owner}/{deployment}

Python SDK : client.deployments.retrieve(owner, deployment)

Renvoie l'objet deployment avec status, statusMessage, region, serviceUrl et resources.

Démarrer, arrêter ou remplacer un déploiement#

PATCH /api/deployments/{owner}/{deployment}

Python SDK : client.deployments.update(owner, deployment, body=...)

Un seul champ action sélectionne l'opération :

{ "action": "start" }

Le remplacement déploie une nouvelle révision tout en préservant l'ID de déploiement, la région et l'URL du point de terminaison ; la révision existante reste active si le déploiement échoue. Le modèle de remplacement doit être un modèle achevé dont les poids sont accessibles par ta clé. Les opérations terminées renvoient 200 avec status ready ou stopped ; les opérations encore en cours de déploiement renvoient 202 avec deploying ou stopping.

Supprimer un déploiement#

DELETE /api/deployments/{owner}/{deployment}

Python SDK : client.deployments.delete(owner, deployment)

Supprime définitivement le point de terminaison d'inférence.

Vérification de santé#

GET /api/deployments/{owner}/{deployment}/health

Python SDK : client.deployments.health(owner, deployment)

Envoie une requête ping et réchauffe le point de terminaison, en renvoyant healthy, latencyMs et le code amont status.

Exécuter une inférence sur un déploiement#

POST /api/deployments/{owner}/{deployment}/predict

Python SDK : client.deployments.predict(owner, deployment, body=...)

Achemine une image ou une vidéo à travers le point de terminaison dédié. Les contrats de requête et de réponse correspondent à l'inférence de modèle.

Formulaire Multipart :

Obtenir les métriques#

GET /api/deployments/{owner}/{deployment}/metrics

Python SDK : client.deployments.metrics(owner, deployment)

Param'tres de requ'te :

La réponse complète contient summary (totaux des requêtes, taux d'erreur, latence moyenne et p50/p95/p99) et timeSeries (requêtes, erreurs, latence, processeur, mémoire, nombre d'instances). La réponse en graphique lointain (sparkline) renvoie requests24h, totalRequests, errorRate et avgLatencyMs.

Obtenir les logs#

GET /api/deployments/{owner}/{deployment}/logs

Python SDK : client.deployments.logs(owner, deployment)

Param'tres de requ'te :

API de corbeille#

Afficher, restaurer et supprimer définitivement les projets, jeux de données et modèles supprimés de manière logique (soft-delete). Les éléments sont purgés automatiquement après 30 jours. Consulte la documentation sur la corbeille.

Lister la corbeille#

GET /api/trash

Python SDK : client.lifecycle.trash()

Param'tres de requ'te :

La réponse inclut items (chacun avec daysRemaining), total, page, limit, totalPages et un objet summary avec les totaux par type.

Restaurer l'élément#

POST /api/trash

Python SDK : client.lifecycle.restore(id=..., type=...)

{
    "id": "65f1c0a2b3d4e5f601234567",
    "type": "dataset"
}

Restaurer un projet restaure également les modèles qui ont été mis à la corbeille avec lui, signalés sous le nom de restoredModels.

Suppression définitive#

DELETE /api/trash

Python SDK : client.lifecycle.delete_trash(body=...)

Supprimer un élément :

{
    "id": "65f1c0a2b3d4e5f601234567",
    "type": "dataset"
}

Ou vider toute la corbeille :

{
    "all": true
}

La réponse indique deletedCount, ainsi que cascadedModels et survivingDeployments le cas échéant.

API de téléchargement#

Télécharge des fichiers directement vers le stockage cloud en utilisant des URL signées. Terminer le téléversement d'un modèle y associe ses poids ; terminer le téléversement d'une archive de jeu de données enregistre la session, que tu transmettras ensuite à l'ingestion de jeux de données. Consulte la documentation sur les données.

Obtenir une URL de téléchargement signée#

POST /api/upload/signed-url

Python SDK : client.upload.signed_url(body=...)

Corps :

{
    "assetType": "datasets",
    "assetId": "65f1c0a2b3d4e5f601234567",
    "filename": "warehouse.zip",
    "contentType": "application/zip",
    "totalBytes": 52428800
}

R'ponse :

{
    "sessionId": "session_abc123",
    "uploadUrl": "https://storage.googleapis.com/...&signature=...",
    "expiresAt": "2026-02-22T12:00:00Z"
}

Téléverse le fichier avec une requête PUT vers uploadUrl, en utilisant le même Content-Type que tu as déclaré.

Terminer le téléchargement#

POST /api/upload/complete

Python SDK : client.upload.complete(session_id=...)

{
    "sessionId": "session_abc123",
    "checksum": "<optional sha-256 hex>"
}

Réponse : success et un objet file avec size et contentType. Pour les modèles, cela attache les poids ; pour les archives de jeux de données, appelle ensuite ingest pour lancer le traitement.

API d'intégrations de stockage#

Connecte des comptes Google Cloud Storage, Amazon S3 ou Azure Blob Storage en lecture seule et parcours-les en tant que sources de jeux de données. Consulte la documentation sur les intégrations.

Lister les intégrations#

GET /api/integrations/buckets

Python SDK : client.storage_integrations.list()

Renvoie integrations, chacun avec id, provider, credentialIdentity, targets et createdAt. Les informations d'identification ne sont jamais renvoyées.

Découvrir les emplacements#

POST /api/integrations/buckets/discover

Python SDK : client.storage_integrations.discover(body=...)

Liste les compartiments (buckets) ou conteneurs lisibles avec les identifiants fournis, sans les enregistrer.

{
    "provider": "gcs",
    "credentials": {
        "client_email": "svc@project.iam.gserviceaccount.com",
        "private_key": "-----BEGIN PRIVATE KEY-----\n...",
        "project_id": "my-project"
    }
}

Réponse : {"targets": ["my-bucket", "another-bucket"]}

Connecter le stockage#

POST /api/integrations/buckets

Python SDK : client.storage_integrations.create(body=...)

Mêmes formats d'identifiants que pour la découverte, plus un tableau requis targets de 1 à 50 noms de compartiments ou conteneurs. Renvoie 201 avec l'intégration enregistrée. Les identifiants S3 temporaires (clés d'accès ASIA) sont rejetés.

Parcourir les objets#

GET /api/integrations/buckets/{id}/objects

Python SDK : client.storage_integrations.objects(id, target=...)

Param'tres de requ'te :

Renvoie entries (chaque kind est folder ou file) et un objet optionnel cursor pour la page suivante.

Déconnecter le stockage#

DELETE /api/integrations/buckets/{id}

Python SDK : client.storage_integrations.delete(id)

Supprime les identifiants enregistrés sans supprimer les données du fournisseur. Les jeux de données connectés restent visibles, mais leurs fichiers demeurent indisponibles tant que le même compte de stockage n'est pas reconnecté. Nécessite un accès administrateur à l'espace de travail.

API d'importation de jeux de données#

Importe des jeux de données depuis des services tiers. Consulte l'intégration Roboflow.

Prévisualiser un import Roboflow#

POST /api/integrations/roboflow/preview

Python SDK : client.datasets.preview_roboflow(api_key=...)

Convertit une clé API Roboflow en plan d'import : détails de l'espace de travail, newDatasets qui serait importé, décompte des projets ignorés, non pris en charge et non résolus, bytesTotal, ainsi que ta marge storage. La clé API Roboflow est lue depuis le corps et n'est pas persistée.

{
    "apiKey": "ROBOFLOW_API_KEY"
}

Importer depuis Roboflow#

POST /api/integrations/roboflow/import

Python SDK : client.datasets.import_roboflow(api_key=..., items=...)

Met en file d'attente des tâches d'ingestion pour un maximum de 500 versions de projets Roboflow sélectionnées, en utilisant les éléments renvoyés par la prévisualisation.

{
    "apiKey": "ROBOFLOW_API_KEY",
    "items": [
        {
            "workspace": "my-workspace",
            "projectId": "warehouse-safety",
            "projectName": "Warehouse Safety",
            "projectType": "object-detection",
            "latestVersion": 4
        }
    ]
}

Réponse (201) : Tableaux imported, failed et skipped. Les imports nécessitent de l'espace de stockage, et chaque jeu de données doit respecter la limite de taille par import de ton plan.

API de compte#

Inspecte ton compte Platform, tes clés, ton stockage et tes profils publics. Consulte la documentation des paramètres.

Résumé du compte#

GET /api/account/summary

Python SDK : client.account.summary()

Renvoie le plan, le solde des crédits et le décompte des ressources pour l'espace de travail qui a émis la clé.

{
    "username": "acme-vision",
    "name": "Acme Vision",
    "accountType": "team",
    "plan": "pro",
    "creditsCents": 2500,
    "counts": { "projects": 4, "datasets": 7, "models": 21 },
    "teams": []
}

Lister les clés API#

GET /api/api-keys

Python SDK : client.account.api_keys()

Renvoie keys avec keyId, name, keyPrefix et createdAt pour l'espace de travail de la clé. Les requêtes authentifiées par clé API ne reçoivent que des métadonnées ; les valeurs complètes des clés sont affichées au propriétaire de l'espace de travail dans Paramètres > Clés API dans l'interface utilisateur de Platform, qui est également l'endroit où les clés sont créées et révoquées.

Vérifier l'utilisation du stockage#

GET /api/storage

Python SDK : client.account.storage()

Param'tres de requ'te :

R'ponse :

{
    "tier": "pro",
    "usage": {
        "storage": { "current": 1073741824, "limit": 107374182400, "percent": 1.0 },
        "datasets": { "current": 536870912, "limit": 107374182400, "percent": 0.5 }
    },
    "breakdown": {
        "byCategory": {
            "datasets": { "bytes": 536870912, "count": 2 },
            "models": { "bytes": 268435456, "count": 4 },
            "exports": { "bytes": 268435456, "count": 3 }
        },
        "topItems": [
            {
                "_id": "65f1c0a2b3d4e5f601234567",
                "name": "Warehouse",
                "slug": "warehouse",
                "sizeBytes": 536870912,
                "type": "dataset"
            }
        ]
    },
    "region": "us",
    "username": "acme-vision",
    "updatedAt": "2026-01-15T10:00:00Z"
}

Obtenir un profil utilisateur public#

GET /api/users

Python SDK : client.account.profile(username=...)

Param'tres de requ'te :

Renvoie le profil public user avec followerCount et, pour les appelants authentifiés, isFollowed.

Suivre ou ne plus suivre un utilisateur#

PATCH /api/users

Python SDK : client.account.follow(username=..., followed=...)

{
    "username": "target-user",
    "followed": true
}

Réponse : followed et l'élément followerCount mis à jour.

API de facturation#

Vérifie l'utilisation de ton plan et ton registre de crédits. Consulte la documentation de facturation.

Afficher le plan et l'utilisation#

GET /api/billing/usage-summary

Python SDK : client.billing.usage_summary()

Renvoie plan (ID, statut, cycle de facturation, fin de période), metrics (limite de stockage et utilisation), trainingCredit, features, creditsCents et le nombre de sièges.

Afficher les transactions#

GET /api/billing/transactions

Python SDK : client.billing.transactions()

Param'tres de requ'te :

Chaque transaction inclut id, type (tels que purchase, training, monthly_grant ou refund), amountCents, balanceAfter, createdAt, un paramètre optionnel receiptUrl, ainsi que le contexte du modèle pour les frais d'entraînement. Les détails de facturation internes ne sont jamais renvoyés.

Explorer l'API#

Recherche parmi les projets publics et les jeux de données partagés par la communauté. Consulte la documentation Explorer.

Rechercher du contenu public#

GET /api/explore/search

Python SDK : client.explore.search()

Param'tres de requ'te :

Réponse : projects, datasets et hasMore.

curl "https://platform.ultralytics.com/api/explore/search?type=datasets&task=detect&sort=stars&limit=20"

SDK Python#

ultralytics-platform est un client Python typé généré à partir du contrat OpenAPI, avec une méthode par point de terminaison (client.datasets.list, client.models.predict, client.exports.create, ...). Chaque méthode accepte les paramètres de chemin par position, les autres entrées en tant qu'arguments nommés, ainsi que des paramètres optionnels timeout et extra_headers par requête.

pip install "ultralytics-platform>=0.1.5" # Python 3.11+

from ultralytics_platform import Platform

with Platform() as client:  # reads ULTRALYTICS_API_KEY
    dataset = client.datasets.retrieve("acme-vision", "warehouse")
    images = client.datasets.images("acme-vision", "warehouse", limit=10)
    export = client.exports.create("acme-vision", "inspection", "v3", format="onnx")

AsyncPlatform expose la même arborescence de ressources pour le code async/await, les réponses infructueuses lèvent APIError avec status_code, body et json analysés, et les échecs de connexion lèvent APIConnectionError. Consulte le dépôt du SDK pour le README complet.

Intégration Python#

Pour les flux de travail d'entraînement et d'inférence, utilise le package Python Ultralytics, qui gère automatiquement l'authentification, les transferts et la diffusion en continu des métriques en temps réel.

Installation et configuration#

pip install "ultralytics>=8.4.120"

Vérifie l'installation :

yolo check

Authentification#

yolo login YOUR_API_KEY

Utilisation des datasets de la plateforme#

Référence les jeux de données avec les URI ul:// :

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Train on your Platform dataset
model.train(
    data="ul://your-username/datasets/your-dataset",
    epochs=100,
    imgsz=640,
)

Format d'URI :

Envoi vers la plateforme#

Envoie les résultats vers un projet de la plateforme :

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Results automatically sync to Platform
model.train(
    data="coco8.yaml",
    epochs=100,
    project="your-username/my-project",
    name="experiment-1",
)

Ce qui est synchronisé :

• Métriques d'entraînement (temps réel)
• Poids finaux du modèle
• Graphiques de validation
• La sortie console
• Métriques système

Exemples d'API#

Charge un modèle depuis la plateforme :

# Your own model
model = YOLO("ul://username/project/model-name")

# Official model
model = YOLO("ul://ultralytics/yolo26/yolo26n")

Exécute une inférence :

results = model("image.jpg")

# Access results
for r in results:
    boxes = r.boxes  # Detection boxes
    masks = r.masks  # Segmentation masks
    keypoints = r.keypoints  # Pose keypoints
    probs = r.probs  # Classification probabilities

Exporte un modèle :

# Export to ONNX
model.export(format="onnx", imgsz=640, quantize=16)

# Export to TensorRT
model.export(format="engine", imgsz=640, quantize=16)

# Export to CoreML
model.export(format="coreml", imgsz=640)  # use imgsz=224 for classification

Validation :

metrics = model.val(data="ul://username/datasets/my-dataset")

print(f"mAP50: {metrics.box.map50}")
print(f"mAP50-95: {metrics.box.map}")

FAQ#