Interface LLM d'Ultralytics#

LLM est une petite interface permettant d'appeler des modèles de langage et de vision via une API compatible avec OpenAI. Elle prépare les entrées textuelles ou image, transmet les arguments de la requête au SDK Python officiel d'OpenAI et renvoie l'objet de réponse natif du SDK. Cela te permet d'ajouter facilement un raisonnement linguistique ou visuel à côté d'un pipeline YOLO sans encapsuler des types de réponse spécifiques à chaque fournisseur.

L'API par défaut est responses ; utilise api="chat.completions" pour les fournisseurs qui implémentent uniquement Chat Completions.

Installation#

Installe Ultralytics avec la dépendance LLM facultative :

pip install "ultralytics[llm]"

Pour OpenAI, définis la clé API dans l'environnement :

export OPENAI_API_KEY="your-api-key"

Responses API#

Responses API est utilisée par défaut. Transmets un prompt et lis output_text :

from ultralytics import LLM

llm = LLM("gpt-5.6-luna")
response = llm("What is YOLO?")
print(response.output_text)

Entrée multimodale#

Transmets un chemin, une URL HTTP, une URI de données, un tableau NumPy ou une image PIL via image :

from ultralytics import LLM

llm = LLM("gpt-5.6-luna")
response = llm("What is happening in this image?", image="https://ultralytics.com/images/bus.jpg")
print(response.output_text)

Les fichiers locaux et les objets image sont encodés sous forme d'URI de données JPEG. Les tableaux NumPy utilisent l'ordre des canaux BGR d'OpenCV. Une chaîne transmise comme source, telle que llm("bus.jpg"), est traitée comme du texte ; utilise l'argument image pour envoyer une image.

Utilise prompt pour une instruction commune à chaque requête :

llm = LLM("gpt-5.6-luna", prompt="Answer in one sentence.")
response = llm("Describe this image.", image="bus.jpg")

Chat Completions#

Sélectionne Chat Completions lorsque le point de terminaison l'exige, puis lis le format de réponse natif :

from ultralytics import LLM

llm = LLM("gpt-5.6-luna", api="chat.completions")
response = llm("What is non-maximum suppression?")
print(response.choices[0].message.content)

La même interface accepte les entrées multimodales :

response = llm("Describe this image.", image="bus.jpg")
print(response.choices[0].message.content)

Transmets des objets de message natifs lorsque tu as besoin de l'historique de la conversation. Ils sont transmis sans modification.

Appels en streaming et asynchrones#

Les arguments de requête du SDK sont transmis sans modification, y compris stream=True :

llm = LLM("gpt-5.6-luna")
for event in llm("Explain object detection.", stream=True):
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

Utilise async_call pour les requêtes concurrentes :

import asyncio

from ultralytics import LLM

llm = LLM("gpt-5.6-luna")

async def main():
    response = await llm.async_call("What is YOLO?")
    print(response.output_text)

asyncio.run(main())

Fournisseurs compatibles avec OpenAI#

LLM fonctionne avec les fournisseurs qui exposent une API Responses ou Chat Completions compatible avec OpenAI, notamment DeepSeek, Kimi, Z.AI GLM et OpenRouter. Définis le base_url du fournisseur, le nom du modèle et la clé API :

from ultralytics import LLM

llm = LLM(
    "provider-model",
    api="chat.completions",
    base_url="https://provider.example/v1",
    api_key="your-api-key",
)
response = llm("What tasks does YOLO support?")
print(response.choices[0].message.content)

La même configuration fonctionne avec des serveurs locaux compatibles. Les noms de modèles, la prise en charge des images, les arguments de requête et les API prises en charge varient selon le fournisseur ; consulte donc sa documentation associée.

Assococier YOLO et un LLM#

Exécute d'abord YOLO, puis appelle le LLM uniquement lorsqu'une personne est détectée :

from ultralytics import LLM, YOLO

yolo = YOLO("yolo26n.pt")
llm = LLM("gpt-5.6-luna")
image = "https://ultralytics.com/images/bus.jpg"

result = yolo(image)[0]
# Call the LLM only when YOLO detects a person.
if any(result.names[int(cls)] == "person" for cls in result.boxes.cls):
    response = llm("Describe the scene.", image=image)
    print(response.output_text)

Référence de l'API#

source accepte du texte, une liste de messages native ou un objet image. image accepte une URL d'image, une URI de données, un chemin, un tableau NumPy ou une image PIL. Appeler model() avec un prompt configuré envoie uniquement le prompt.

LLM est réservé à l'inférence et n'est pas exposé via la CLI yolo. Il n'implémente pas train, val, export, track ni benchmark.

FAQ#