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 de texte ou d'image, transmet les arguments de requête au SDK Python officiel d'OpenAI et renvoie l'objet de réponse natif du SDK. Cela facilite l'ajout de raisonnement textuel ou visuel à côté d'un pipeline YOLO sans avoir à encapsuler les types de réponse spécifiques au fournisseur.

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

Installation#

Installe Ultralytics avec la dépendance LLM optionnelle :

pip install "ultralytics[llm]"

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

export OPENAI_API_KEY="your-api-key"

API Responses#

L'API Responses est celle 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, un 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 en tant qu'URI de données JPEG. Les tableaux NumPy utilisent l'ordre des canaux BGR d'OpenCV. Une chaîne passée en tant que 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 partagée par 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 l'endpoint l'exige, et lis sa structure de réponse native :

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 tels quels.

Appels en flux et asynchrones#

Les arguments de requête du SDK sont transmis tels quels, 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 des requêtes simultanées :

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 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 paramètre base_url du fournisseur, le nom du modèle et la clé d'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.

Combiner 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 natifs ou un objet image. image accepte une URL d'image, un URI de données, un chemin, un tableau NumPy ou une image PIL. Appeler model() avec un paramètre prompt configuré envoie le prompt seul.

LLM est destiné uniquement à l'inférence et n'est pas exposé via le CLI yolo. Il n'implémente pas train, val, export, track ou benchmark.

FAQ#