API Ultralytics Explorer

Introduction

L'API Explorer est une API python permettant d'explorer vos ensembles de données. Elle prend en charge le filtrage et la recherche dans votre ensemble de données à l'aide de requêtes SQL, de la recherche de similarité vectorielle et de la recherche sémantique.

Regarder : Présentation de l'API Ultralytics Explorer

Installation

Explorer dépend de bibliothèques externes pour certaines de ses fonctionnalités. Celles-ci sont automatiquement installées lors de l'utilisation. Pour installer manuellement ces dépendances, utilisez la commande suivante :

pip install ultralytics[explorer]

Utilisation

from ultralytics import Explorer

# Create an Explorer object
explorer = Explorer(data="coco128.yaml", model="yolo11n.pt")

# Create embeddings for your dataset
explorer.create_embeddings_table()

# Search for similar images to a given image/images
dataframe = explorer.get_similar(img="path/to/image.jpg")

# Or search for similar images to a given index/indices
dataframe = explorer.get_similar(idx=0)

Si vous souhaitez forcer la mise à jour de la table des embeddings, vous pouvez passer force=True à create_embeddings_table méthode.

Vous pouvez accéder directement à l'objet de table LanceDB pour effectuer une analyse avancée. Pour en savoir plus, consultez la section Travailler avec la section Table d'intégrations.

1. Recherche de similarité

La recherche de similarité est une technique permettant de trouver des images similaires à une image donnée. Elle est basée sur l'idée que les images similaires auront des embeddings similaires. Une fois la table des embeddings créée, vous pouvez exécuter une recherche sémantique de l'une des manières suivantes :

• Sur un index ou une liste d'index donnés dans l'ensemble de données : exp.get_similar(idx=[1,10], limit=10)
• Sur n'importe quelle image ou liste d'images ne figurant pas dans l'ensemble de données : exp.get_similar(img=["path/to/img1", "path/to/img2"], limit=10)

En cas d'entrées multiples, l'agrégation de leurs embeddings est utilisée.

Vous obtenez un dataframe pandas avec le limit nombre de points de données les plus similaires à l'entrée, ainsi que leur distance dans l'espace d'intégration. Vous pouvez utiliser cet ensemble de données pour effectuer un filtrage plus approfondi.

from ultralytics import Explorer

# create an Explorer object
exp = Explorer(data="coco128.yaml", model="yolo11n.pt")
exp.create_embeddings_table()

similar = exp.get_similar(img="https://ultralytics.com/images/bus.jpg", limit=10)
print(similar.head())

# Search using multiple indices
similar = exp.get_similar(
    img=["https://ultralytics.com/images/bus.jpg", "https://ultralytics.com/images/bus.jpg"],
    limit=10,
)
print(similar.head())

from ultralytics import Explorer

# create an Explorer object
exp = Explorer(data="coco128.yaml", model="yolo11n.pt")
exp.create_embeddings_table()

similar = exp.get_similar(idx=1, limit=10)
print(similar.head())

# Search using multiple indices
similar = exp.get_similar(idx=[1, 10], limit=10)
print(similar.head())

Tracé d'images similaires

Vous pouvez également tracer les images similaires en utilisant le plot_similar méthode. Cette méthode prend les mêmes arguments que get_similar et trace les images similaires dans une grille.

from ultralytics import Explorer

# create an Explorer object
exp = Explorer(data="coco128.yaml", model="yolo11n.pt")
exp.create_embeddings_table()

plt = exp.plot_similar(img="https://ultralytics.com/images/bus.jpg", limit=10)
plt.show()

from ultralytics import Explorer

# create an Explorer object
exp = Explorer(data="coco128.yaml", model="yolo11n.pt")
exp.create_embeddings_table()

plt = exp.plot_similar(idx=1, limit=10)
plt.show()

2. Interroger l'IA (requêtes en langage naturel)

Cela vous permet d'écrire comment vous souhaitez filtrer votre ensemble de données en utilisant le langage naturel. Vous n'avez pas besoin de maîtriser l'écriture de requêtes SQL. Notre générateur de requêtes basé sur l'IA le fera automatiquement en coulisses. Par exemple, vous pouvez dire - "montre-moi 100 images avec exactement une personne et 2 chiens. Il peut aussi y avoir d'autres objets" et il générera en interne la requête et vous montrera ces résultats. Remarque : cela fonctionne avec des LLM en coulisses, de sorte que les résultats sont probabilistes et peuvent parfois se tromper.

from ultralytics import Explorer
from ultralytics.data.explorer import plot_query_result

# create an Explorer object
exp = Explorer(data="coco128.yaml", model="yolo11n.pt")
exp.create_embeddings_table()

df = exp.ask_ai("show me 100 images with exactly one person and 2 dogs. There can be other objects too")
print(df.head())

# plot the results
plt = plot_query_result(df)
plt.show()

3. Requêtes SQL

Vous pouvez exécuter des requêtes SQL sur votre ensemble de données en utilisant le sql_query méthode. Cette méthode prend une requête SQL en entrée et renvoie un dataframe pandas avec les résultats.

from ultralytics import Explorer

# create an Explorer object
exp = Explorer(data="coco128.yaml", model="yolo11n.pt")
exp.create_embeddings_table()

df = exp.sql_query("WHERE labels LIKE '%person%' AND labels LIKE '%dog%'")
print(df.head())

Tracé des résultats de requêtes SQL

Vous pouvez également tracer les résultats d'une requête SQL en utilisant le plot_sql_query méthode. Cette méthode prend les mêmes arguments que sql_query et trace les résultats dans une grille.

from ultralytics import Explorer

# create an Explorer object
exp = Explorer(data="coco128.yaml", model="yolo11n.pt")
exp.create_embeddings_table()

# plot the SQL Query
exp.plot_sql_query("WHERE labels LIKE '%person%' AND labels LIKE '%dog%' LIMIT 10")

4. Travailler avec le tableau d'Embeddings

Vous pouvez également travailler directement avec la table d'intégrations. Une fois la table d'intégrations créée, vous pouvez y accéder en utilisant le Explorer.table

from ultralytics import Explorer

exp = Explorer()
exp.create_embeddings_table()
table = exp.table

Voici quelques exemples de ce que vous pouvez faire avec le tableau :

Obtenir des Embeddings bruts

from ultralytics import Explorer

exp = Explorer()
exp.create_embeddings_table()
table = exp.table

embeddings = table.to_pandas()["vector"]
print(embeddings)

Requêtes avancées avec des filtres pré et post

from ultralytics import Explorer

exp = Explorer(model="yolo11n.pt")
exp.create_embeddings_table()
table = exp.table

# Dummy embedding
embedding = [i for i in range(256)]
rs = table.search(embedding).metric("cosine").where("").limit(10)

Créer un index vectoriel

Lorsque vous utilisez de grands ensembles de données, vous pouvez également créer un index vectoriel dédié pour des requêtes plus rapides. Ceci est fait en utilisant le create_index méthode sur la table LanceDB.

table.create_index(num_partitions=..., num_sub_vectors=...)

Vous trouverez plus de détails sur les types d'index vectoriels disponibles et les paramètres de configuration dans la documentation d'indexation LanceDB. À l'avenir, nous prévoyons de prendre en charge la création d'index vectoriels directement via l'API Explorer.

5. Applications des Embeddings

Vous pouvez utiliser le tableau d'intégrations pour effectuer diverses analyses exploratoires. Voici quelques exemples :

Indice de similarité

Explorer est livré avec un similarity_index opération :

• Il essaie d'estimer à quel point chaque point de données est similaire au reste de l'ensemble de données.
• Il le fait en comptant combien d'embeddings d'images se trouvent plus près que max_dist à l'image actuelle dans l'espace d'intégration généré, en tenant compte de top_k images similaires à la fois.

Il renvoie un dataframe pandas avec les colonnes suivantes :

• idx: Index de l'image dans l'ensemble de données
• im_file: Chemin d'accès au fichier image
• count: Nombre d'images dans l'ensemble de données qui sont plus proches que max_dist à l'image actuelle
• sim_im_files: Liste des chemins d'accès aux count images similaires

from ultralytics import Explorer

exp = Explorer()
exp.create_embeddings_table()

sim_idx = exp.similarity_index()

Vous pouvez utiliser l'index de similarité pour créer des conditions personnalisées afin de filtrer l'ensemble de données. Par exemple, vous pouvez filtrer les images qui ne sont similaires à aucune autre image de l'ensemble de données en utilisant le code suivant :

import numpy as np

sim_count = np.array(sim_idx["count"])
sim_idx["im_file"][sim_count > 30]

Visualiser l'espace d'intégration

Vous pouvez également visualiser l'espace d'intégration en utilisant l'outil de traçage de votre choix. Par exemple, voici un exemple simple utilisant matplotlib :

import matplotlib.pyplot as plt
from sklearn.decomposition import PCA

# Reduce dimensions using PCA to 3 components for visualization in 3D
pca = PCA(n_components=3)
reduced_data = pca.fit_transform(embeddings)

# Create a 3D scatter plot using Matplotlib Axes3D
fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111, projection="3d")

# Scatter plot
ax.scatter(reduced_data[:, 0], reduced_data[:, 1], reduced_data[:, 2], alpha=0.5)
ax.set_title("3D Scatter Plot of Reduced 256-Dimensional Data (PCA)")
ax.set_xlabel("Component 1")
ax.set_ylabel("Component 2")
ax.set_zlabel("Component 3")

plt.show()

Commencez à créer vos propres rapports d'exploration d'ensembles de données CV à l'aide de l'API Explorer. Pour vous inspirer, consultez l'Exemple d'exploration VOC.

Applications conçues à l'aide d'Ultralytics Explorer

Essayez notre démo GUI basée sur l'API Explorer

Bientôt disponible

• [ ] Fusionner des étiquettes spécifiques à partir d'ensembles de données. Exemple - Importer tout person étiquettes de COCO et car étiquettes de Cityscapes
• [ ] Supprimer les images qui ont un indice de similarité supérieur au seuil donné
• [ ] Persister automatiquement les nouveaux ensembles de données après la fusion/suppression d'entrées
• [ ] Visualisations avancées de l'ensemble de données

FAQ

À quoi sert l'API Ultralytics Explorer ?

L'API Ultralytics Explorer est conçue pour une exploration complète des ensembles de données. Elle permet aux utilisateurs de filtrer et de rechercher des ensembles de données à l'aide de requêtes SQL, de la recherche de similarité vectorielle et de la recherche sémantique. Cette puissante API python peut gérer de grands ensembles de données, ce qui la rend idéale pour diverses tâches de vision par ordinateur à l'aide de modèles Ultralytics.

Comment installer l’API Ultralytics Explorer ?

Pour installer l'API Ultralytics Explorer avec ses dépendances, utilisez la commande suivante :

pip install ultralytics[explorer]

Cela installera automatiquement toutes les bibliothèques externes nécessaires à la fonctionnalité de l'API Explorer. Pour plus de détails sur la configuration, consultez la section installation de notre documentation.

Comment puis-je utiliser l’API Ultralytics Explorer pour la recherche de similarités ?

Vous pouvez utiliser l'API Ultralytics Explorer pour effectuer des recherches de similarité en créant une table d'intégrations et en la consultant pour trouver des images similaires. Voici un exemple de base :

from ultralytics import Explorer

# Create an Explorer object
explorer = Explorer(data="coco128.yaml", model="yolo11n.pt")
explorer.create_embeddings_table()

# Search for similar images to a given image
similar_images_df = explorer.get_similar(img="path/to/image.jpg")
print(similar_images_df.head())

Pour plus de détails, veuillez consulter la section Recherche de similarités.

Quels sont les avantages de l'utilisation de LanceDB avec Ultralytics Explorer ?

LanceDB, utilisé en interne par Ultralytics Explorer, fournit des tables d'intégrations évolutives sur disque. Cela garantit que vous pouvez créer et réutiliser des intégrations pour de grands ensembles de données comme COCO sans manquer de mémoire. Ces tables ne sont créées qu'une seule fois et peuvent être réutilisées, ce qui améliore l'efficacité de la gestion des données.

Comment fonctionne la fonctionnalité Ask AI dans l'API Ultralytics Explorer ?

La fonctionnalité Ask AI permet aux utilisateurs de filtrer les ensembles de données à l'aide de requêtes en langage naturel. Cette fonctionnalité exploite les LLM pour convertir ces requêtes en requêtes SQL en arrière-plan. Voici un exemple :

from ultralytics import Explorer

# Create an Explorer object
explorer = Explorer(data="coco128.yaml", model="yolo11n.pt")
explorer.create_embeddings_table()

# Query with natural language
query_result = explorer.ask_ai("show me 100 images with exactly one person and 2 dogs. There can be other objects too")
print(query_result.head())

Pour plus d'exemples, consultez la section Demander à l'IA.

📅 Créé il y a 1 an ✏️ Mis à jour il y a 4 mois

Commentaires