🔍🤖 Vision Agent

Vision Agent est une bibliothèque qui vous aide à utiliser des cadres d’agents pour générer du code afin de résoudre votre tâche de vision. De nombreux problèmes de vision actuels peuvent facilement prendre des heures ou des jours à résoudre, vous devez trouver le bon modèle, comprendre comment l’utiliser et le programmer pour accomplir la tâche que vous souhaitez. Vision Agent vise à offrir une expérience en quelques secondes en permettant aux utilisateurs de décrire leur problème par texte et d’avoir le cadre de l’agent générer du code pour résoudre la tâche pour eux. Consultez notre discord pour les mises à jour et les feuilles de route!

Application Web

Essayez Vision Agent en direct sur

Documentation

Pour commencer

Pour commencer, vous pouvez installer la bibliothèque en utilisant pip:

pip install vision-agent

Assurez-vous d’avoir une clé API OpenAI et définissez-la en tant que variable d’environnement (si vous utilisez Azure OpenAI, veuillez consulter la section de configuration Azure):

export OPENAI_API_KEY="votre-clé-api"

Note importante sur l’utilisation de l’API

Veuillez noter que l’utilisation de l’API dans ce projet nécessite que vous ayez des crédits API (minimum de cinq dollars américains). Cela diffère de l’abonnement OpenAI utilisé dans ce chatbot. Si vous n’avez pas de crédit, vous pouvez trouver plus d’informations

Vision Agent

Utilisation de base

Vous pouvez interagir avec l’agent comme vous le feriez avec n’importe quel modèle LLM ou LMM:

from vision_agent.agent import VisionAgent
agent = VisionAgent()
code = agent("Quel pourcentage de la surface du pot est rempli de grains de café?", media="jar.jpg")

Ce qui produit le code suivant:

from vision_agent.tools import load_image, grounding_sam
def calculate_filled_percentage(image_path: str) -> float:
    # Étape 1: Charger l'image
    image = load_image(image_path)
    # Étape 2: Segmenter le pot
    jar_segments = grounding_sam(prompt="jar", image=image)
    # Étape 3: Segmenter les grains de café
    coffee_beans_segments = grounding_sam(prompt="grains de café", image=image)
    # Étape 4: Calculer la surface du pot segmentée
    jar_area = 0
    for segment in jar_segments:
        jar_area += segment['mask'].sum()
    # Étape 5: Calculer la surface des grains de café segmentés
    coffee_beans_area = 0
    for segment in coffee_beans_segments:
        coffee_beans_area += segment['mask'].sum()
    # Étape 6: Calculer le pourcentage de la surface du pot rempli de grains de café
    if jar_area == 0:
        return 0.0  # Pour éviter la division par zéro
    filled_percentage = (coffee_beans_area / jar_area) * 100
    # Étape 7: Renvoyer le pourcentage calculé
    return filled_percentage

Pour mieux comprendre comment le modèle a trouvé sa réponse, vous pouvez l’exécuter en mode débogage en passant l’argument verbose:

agent = VisionAgent(verbose=2)

Utilisation détaillée

Vous pouvez également lui faire retourner plus d’informations en appelant . Le format de l’entrée est une liste de dictionnaires avec les clés , , et :

results = agent.chat_with_workflow([{"role": "user", "content": "Quel pourcentage de la surface du pot est rempli de grains de café?", "media": ["jar.jpg"]}])
print(results){"code": "from vision_agent.tools import ...", "test": "calculate_filled_percentage('jar.jpg')", "test_result": "...", "plan": [{"code": "...", "test": "...", "plan": "..."}, ...], "working_memory": ...,}

Avec cela, vous pouvez examiner des informations plus détaillées telles que le code de test, les résultats du test, le plan ou la mémoire de travail qu’il a utilisé pour accomplir la tâche.

Conversations multi-tours

Vous pouvez avoir des conversations multi-tours avec vision-agent également, lui donnant des retours sur le code et le faisant mettre à jour. Il vous suffit d’ajouter le code en tant que réponse de l’assistant:

agent = va.agent.VisionAgent(verbosity=2)
conv = [{"role": "user","content": "Ces travailleurs portent-ils un équipement de sécurité? Renvoyez uniquement une valeur True ou False.","media": ["workers.png"],}]
result = agent.chat_with_workflow(conv)
code = result["code"]
conv.append({"role": "assistant","content": code})
conv.append({"role": "user","content": "Pouvez-vous également renvoyer le nombre de travailleurs portant un équipement de sécurité?",})
result = agent.chat_with_workflow(conv)

Outils

Il existe une variété d’outils pour le modèle ou l’utilisateur à utiliser. Certains sont exécutés localement tandis que d’autres sont hébergés pour vous. Vous pouvez également demander directement à un LMM de construire un outil pour vous. Par exemple:

import vision_agent as va
lmm = va.lmm.OpenAILMM()
detector = lmm.generate_detector("Pouvez-vous construire un détecteur de pot pour moi?")
detector(va.tools.load_image("jar.jpg"))

Vous pouvez également ajouter des outils personnalisés à l’agent:

import vision_agent as va
import numpy as np
@va.tools.register_tool(imports=["import numpy as np"])
def custom_tool(image_path: str) -> str:
    """My custom tool documentation.

    Parameters:
    image_path (str): The path to the image.

    Returns:
    str: The result of the tool.

    Example
    -------
    >>> custom_tool("image.jpg")
    """
    return np.zeros((10, 10))

Vous devez vous assurer d’appeler avec toutes les importations qu’il pourrait utiliser et de vous assurer que la documentation est dans le même format ci-dessus avec description, , , et . Vous pouvez trouver un cas d’utilisation d’exemple .

Configuration Azure

Si vous souhaitez utiliser les modèles Azure OpenAI, vous devez avoir deux déploiements de modèles OpenAI:

1. Modèle OpenAI GPT-4o
2. Modèle d’incorporation de texte OpenAI

Ensuite, vous pouvez définir les variables d’environnement suivantes:

export AZURE_OPENAI_API_KEY="votre-clé-api"
export AZURE_OPENAI_ENDPOINT="votre-endpoint"
# Le nom du déploiement de votre modèle de chat Azure OpenAI
export AZURE_OPENAI_CHAT_MODEL_DEPLOYMENT_NAME="votre_nom_de_déploiement_gpt4o"
# Le nom du déploiement de votre modèle d'incorporation de texte Azure OpenAI
export AZURE_OPENAI_EMBEDDING_MODEL_DEPLOYMENT_NAME="votre_nom_de_déploiement_d'incorporation"

Q&R

Comment commencer avec les crédits API OpenAI

1. Visitez le pour vous inscrire pour une clé API.
2. Suivez les instructions pour acheter et gérer vos crédits API.
3. Assurez-vous que votre clé API est correctement configurée dans les paramètres de votre projet.

L’absence de crédits API suffisants peut entraîner une fonctionnalité limitée ou nulle pour les fonctionnalités qui dépendent de l’API OpenAI.

Pour plus de détails sur la gestion de votre utilisation de l’API et de vos crédits, veuillez vous référer à la documentation de l’API OpenAI.

Source de l’article