Inférence

Plateforme Ultralytics fournit une API d'inférence pour tester les modèles entraînés. Utilisez le navigateur basé sur Predict onglet pour une validation rapide ou le REST API pour un accès programmatique.

Onglet Prédire

Chaque modèle comprend un Predict onglet pour l'inférence basée sur le navigateur :

1. Accédez à votre modèle
2. Cliquez sur l'onglet « Prédire ».
3. Téléchargez une image, utilisez un exemple ou ouvrez votre webcam.
4. Affichez instantanément les prédictions avec des superpositions de cadres de sélection.

Méthodes de saisie

Le panneau de prédiction prend en charge plusieurs méthodes de saisie :

graph LR
    A[Upload Image] --> D[Auto-Inference]
    B[Example Image] --> D
    C[Webcam Capture] --> D
    D --> E[Results + Overlays]

    style D fill:#2196F3,color:#fff
    style E fill:#4CAF50,color:#fff

Télécharger une image

Glissez-déposez ou cliquez pour télécharger :

• Formats pris en charge: JPEG, PNG, WebP, AVIF, HEIC, JP2, TIFF, BMP, DNG, MPO
• Taille maximale : 10 Mo
• Auto-inférence: les résultats s'affichent automatiquement après le téléchargement.

Exemples d'images

Le panneau de prédiction affiche des exemples d'images provenant de l'ensemble de données lié à votre modèle. Si aucun ensemble de données n'est lié, des exemples par défaut sont utilisés :

Pour les modèles OBB, des images aériennes de bateaux et d'aéroports sont affichées à la place.

Webcam

Cliquez sur la carte webcam pour démarrer la diffusion en direct :

1. Accorder l'autorisation d'accès à la caméra lorsque vous y êtes invité.
2. Cliquez sur l'aperçu vidéo pour capturer une image.
3. L'inférence s'exécute automatiquement sur l'image capturée.
4. Cliquez à nouveau pour redémarrer la webcam.

Afficher les résultats

Affichage des résultats d'inférence :

• Boîtes englobantes avec étiquettes de classe sous forme de superpositions SVG
• Scores de confiance pour chaque détection
• Couleurs de classe issues de la palette de couleurs de votre ensemble de données (ou de la palette Ultralytics )
• Répartition de la vitesse: prétraitement, inférence, post-traitement et temps réseau

Le panneau des résultats affiche :

Paramètres d'inférence

Ajustez le comportement de détection à l'aide des paramètres dans la section Paramètres repliable :

Seuil de confiance

Filtrer les prédictions par confiance :

• Plus élevé (0.5+) : Moins de prédictions, plus certaines
• Plus faible (0.1-0.25) : Plus de prédictions, avec un certain bruit
• Par défaut (0.25) : Équilibré pour la plupart des cas d'utilisation

Seuil d'IoU

Contrôler la NMS :

• Supérieur (0,7+): autoriser davantage de chevauchement entre les cases
• Inférieur (0,3-0,5): fusionner les détections proches de manière plus agressive
• Par défaut (0,70): NMS équilibré pour la plupart des cas d'utilisation

Prévision du déploiement

Chaque course terminal dédié comprend un Predict onglet directement sur sa carte de déploiement. Cela utilise le service d'inférence propre au déploiement plutôt que le service de prédiction partagé, ce qui vous permet de tester votre point de terminaison déployé à partir du navigateur.

REST API

Accéder à l'inférence par programmation :

Authentification

Inclure votre clé API dans les requêtes :

Authorization: Bearer YOUR_API_KEY

Point de terminaison

POST https://platform.ultralytics.com/api/models/{modelId}/predict

Requête

import requests

url = "https://platform.ultralytics.com/api/models/MODEL_ID/predict"
headers = {"Authorization": "Bearer YOUR_API_KEY"}
files = {"file": open("image.jpg", "rb")}
data = {"conf": 0.25, "iou": 0.7, "imgsz": 640}

response = requests.post(url, headers=headers, files=files, data=data)
print(response.json())

curl -X POST \
  "https://platform.ultralytics.com/api/models/MODEL_ID/predict" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "file=@image.jpg" \
  -F "conf=0.25" \
  -F "iou=0.7" \
  -F "imgsz=640"

const formData = new FormData();
formData.append("file", fileInput.files[0]);
formData.append("conf", "0.25");
formData.append("iou", "0.7");
formData.append("imgsz", "640");

const response = await fetch(
  "https://platform.ultralytics.com/api/models/MODEL_ID/predict",
  {
    method: "POST",
    headers: { Authorization: "Bearer YOUR_API_KEY" },
    body: formData,
  }
);

const result = await response.json();
console.log(result);

Réponse

{
    "images": [
        {
            "shape": [1080, 1920],
            "results": [
                {
                    "class": 0,
                    "name": "person",
                    "confidence": 0.92,
                    "box": { "x1": 100, "y1": 50, "x2": 300, "y2": 400 }
                },
                {
                    "class": 2,
                    "name": "car",
                    "confidence": 0.87,
                    "box": { "x1": 400, "y1": 200, "x2": 600, "y2": 350 }
                }
            ],
            "speed": {
                "preprocess": 1.2,
                "inference": 12.5,
                "postprocess": 2.3
            }
        }
    ],
    "metadata": {
        "imageCount": 1,
        "functionTimeCall": 0.018,
        "model": "model.pt",
        "version": {
            "ultralytics": "8.4.14",
            "torch": "2.6.0",
            "torchvision": "0.21.0",
            "python": "3.13.0"
        }
    }
}

Champs de réponse

Réponses spécifiques à la tâche

Le format de réponse varie selon la tâche :

{
  "class": 0,
  "name": "person",
  "confidence": 0.92,
  "box": {"x1": 100, "y1": 50, "x2": 300, "y2": 400}
}

{
  "class": 0,
  "name": "person",
  "confidence": 0.92,
  "box": {"x1": 100, "y1": 50, "x2": 300, "y2": 400},
  "segments": [[100, 50], [150, 60], ...]
}

{
  "class": 0,
  "name": "person",
  "confidence": 0.92,
  "box": {"x1": 100, "y1": 50, "x2": 300, "y2": 400},
  "keypoints": [
    {"x": 200, "y": 75, "conf": 0.95},
    ...
  ]
}

{
  "results": [
    {"class": 0, "name": "cat", "confidence": 0.95},
    {"class": 1, "name": "dog", "confidence": 0.03}
  ]
}

{
  "class": 0,
  "name": "ship",
  "confidence": 0.89,
  "box": {"x1": 100, "y1": 50, "x2": 300, "y2": 400},
  "obb": {"x1": 105, "y1": 48, "x2": 295, "y2": 55, "x3": 290, "y3": 395, "x4": 110, "y4": 402}
}

Limites de débit

L'inférence partagée est limitée en débit à 20 requêtes/min par clé API. En cas de limitation, l'API renvoie 429 avec un Retry-After en-tête. Voir l'intégralité référence de limite de débit pour toutes les catégories de points finaux.

Gestion des erreurs

Réponses d'erreur courantes :

FAQ

Puis-je exécuter l'inférence sur des vidéos ?

L'API accepte les images individuelles. Pour la vidéo :

1. Extrayez les images localement
2. Envoyer chaque image à l'API
3. Agréger les résultats

Pour la vidéo en temps réel, envisagez de déployer un point de terminaison dédié.

Comment puis-je obtenir l'image annotée ?

L'API renvoie des prédictions JSON. Pour visualiser :

1. Utiliser les prédictions pour tracer les cadres localement
2. Utiliser Ultralytics plot() méthode :

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
results = model("image.jpg")
results[0].save("annotated.jpg")

Consultez la documentation sur le mode Predict pour connaître toutes les options disponibles en matière d'API de résultats et de visualisation.

Quelle est la taille maximale de l'image ?

• Limite de téléversement : 10 Mo
• Recommended: <5MB for fast inference
• Redimensionnement automatique: Les images sont redimensionnées selon la sélection choisie. Image Size paramètre

Les images de grande taille sont automatiquement redimensionnées tout en préservant leur rapport d'aspect.

Puis-je exécuter l'inférence par lots ?

L'API actuelle traite une image par requête. Pour le traitement par lots :

1. Envoyer des requêtes concurrentes
2. Utiliser un point de terminaison dédié pour un débit plus élevé
3. Privilégier l'inférence locale pour les grands lots

import concurrent.futures

import requests

url = "https://predict-abc123.run.app/predict"
headers = {"Authorization": "Bearer YOUR_API_KEY"}
images = ["img1.jpg", "img2.jpg", "img3.jpg"]


def predict(image_path):
    with open(image_path, "rb") as f:
        return requests.post(url, headers=headers, files={"file": f}).json()


with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    results = list(executor.map(predict, images))

📅 Créé il y a 1 mois ✏️ Mis à jour il y a 5 jours

Commentaires