Exemple d'exploration VOC#

中文 | 한국어 | 日本語 | Русский | Deutsch | Français | Español | Português | Türkçe | Tiếng Việt | العربية

Bienvenue dans le notebook de l'API Explorer d'Ultralytics. Ce notebook présente les ressources disponibles pour explorer des datasets avec la recherche sémantique, la recherche vectorielle et les requêtes SQL.

Essaie yolo explorer (propulsé par l'API Explorer)

Installe ultralytics et exécute yolo explorer dans ton terminal pour lancer des requêtes personnalisées et une recherche sémantique dans ton navigateur.

Configuration#

Installe ultralytics et les dépendances requises, puis vérifie le logiciel et le matériel.

!uv pip install ultralytics[explorer] openai
yolo checks

Recherche de similarité#

Utilise la puissance de la recherche par similarité vectorielle pour trouver les points de données similaires dans ton dataset ainsi que leur distance dans l'espace d'embedding. Crée simplement une table d'embeddings pour la paire dataset-modèle donnée. Elle n'est nécessaire qu'une seule fois et est réutilisée automatiquement.

exp = Explorer("VOC.yaml", model="yolo11n.pt")
exp.create_embeddings_table()

Une fois la table d'embeddings construite, tu peux exécuter une recherche sémantique de l'une des manières suivantes :

• Sur un index donné ou une liste d'indices dans le dataset, par ex., exp.get_similar(idx=[1, 10], limit=10)
• Sur n'importe quelle image ou liste d'images ne figurant pas dans le dataset - exp.get_similar(img=["path/to/img1", "path/to/img2"], limit=10). En cas d'entrées multiples, l'agrégat de leurs embeddings est utilisé.

Tu obtiens un DataFrame pandas avec le nombre limite de points de données les plus similaires à l'entrée, ainsi que leur distance dans l'espace d'embedding. Tu peux utiliser ce dataset pour effectuer un filtrage supplémentaire.

# Search dataset by index
similar = exp.get_similar(idx=1, limit=10)
similar.head()

Tu peux aussi tracer les échantillons similaires directement à l'aide de l'utilitaire plot_similar

exp.plot_similar(idx=6500, limit=20)
exp.plot_similar(idx=[100, 101], limit=10)  # Can also pass list of idxs or imgs

exp.plot_similar(img="https://ultralytics.com/images/bus.jpg", limit=10, labels=False)  # Can also pass external images

Demander à l'IA : Rechercher ou filtrer en langage naturel#

Tu peux inviter l'objet Explorer avec le type de points de données que tu souhaites voir, et il essaiera de renvoyer un DataFrame avec ces résultats. Comme il est propulsé par des LLMs, il ne tape pas toujours dans le mille. Dans ce cas, il renverra None.

df = exp.ask_ai("show me images containing more than 10 objects with at least 2 persons")
df.head(5)

Pour tracer ces résultats, tu peux utiliser l'utilitaire plot_query_result. Exemple :

plt = plot_query_result(exp.ask_ai("show me 10 images containing exactly 2 persons"))
Image.fromarray(plt)

# plot
from PIL import Image
from ultralytics.data.explorer import plot_query_result

plt = plot_query_result(exp.ask_ai("show me 10 images containing exactly 2 persons"))
Image.fromarray(plt)

Exécuter des requêtes SQL sur ton dataset#

Parfois, tu peux vouloir enquêter sur certaines entrées de ton dataset. Pour cela, Explorer te permet d'exécuter des requêtes SQL. Il accepte l'un des formats suivants :

• Les requêtes commençant par "WHERE" sélectionneront automatiquement toutes les colonnes. Cela peut être considéré comme une requête raccourcie.
• Tu peux aussi écrire des requêtes complètes où tu peux spécifier quelles colonnes sélectionner.

Cela peut être utilisé pour enquêter sur les performances du modèle et des points de données spécifiques. Par exemple :

• disons que ton modèle peine sur les images qui contiennent des humains et des chiens. Tu peux écrire une requête comme celle-ci pour sélectionner les points qui ont au moins 2 humains ET au moins un chien.

Tu peux combiner une requête SQL et une recherche sémantique pour filtrer vers un type de résultats spécifique

table = exp.sql_query("WHERE labels LIKE '%person, person%' AND labels LIKE '%dog%' LIMIT 10")
exp.plot_sql_query("WHERE labels LIKE '%person, person%' AND labels LIKE '%dog%' LIMIT 10", labels=True)

table = exp.sql_query("WHERE labels LIKE '%person, person%' AND labels LIKE '%dog%' LIMIT 10")
print(table)

Tout comme pour la recherche de similarité, tu disposes également d'un utilitaire pour tracer directement les requêtes SQL à l'aide de exp.plot_sql_query

exp.plot_sql_query("WHERE labels LIKE '%person, person%' AND labels LIKE '%dog%' LIMIT 10", labels=True)

Travailler avec la table d'embeddings (Avancé)#

Explorer fonctionne en interne sur des tables LanceDB. Tu peux accéder directement à cette table en utilisant l'objet Explorer.table et exécuter des requêtes brutes, pousser des pré- et post-filtres, etc.

table = exp.table
print(table.schema)

Exécuter des requêtes brutes¶#

La recherche vectorielle trouve les vecteurs les plus proches de la base de données. Dans un système de recommandation ou un moteur de recherche, tu peux trouver des produits similaires à celui que tu as cherché. Dans les LLM et autres applications d'IA, chaque point de données peut être représenté par les embeddings générés par certains modèles, et cela renvoie les caractéristiques les plus pertinentes.

Une recherche dans un espace vectoriel de grande dimension consiste à trouver les K plus proches voisins (KNN) du vecteur de requête.

Métrique Dans LanceDB, une métrique est la manière de décrire la distance entre une paire de vecteurs. Actuellement, elle prend en charge les métriques suivantes :

• L2
• Cosinus
• Dot La recherche de similarité d'Explorer utilise L2 par défaut. Tu peux exécuter des requêtes directement sur les tables ou utiliser le format lance pour créer des utilitaires personnalisés afin de gérer les datasets. Plus de détails sur les opérations de table LanceDB disponibles dans la documentation

dummy_img_embedding = [i for i in range(256)]
table.search(dummy_img_embedding).limit(5).to_pandas()

Interconversion vers des formats de données populaires#

df = table.to_pandas()
pa_table = table.to_arrow()

Travailler avec des embeddings#

Tu peux accéder à l'embedding brut de la table lancedb et l'analyser. Les embeddings d'images sont stockés dans la colonne vector

import numpy as np

embeddings = table.to_pandas()["vector"].tolist()
embeddings = np.array(embeddings)

Nuage de points#

L'une des étapes préliminaires de l'analyse des embeddings consiste à les tracer dans un espace 2D via une réduction de dimensionnalité. Essayons un exemple

import matplotlib.pyplot as plt
from sklearn.decomposition import PCA  # pip install scikit-learn

# 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's 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()

Indice de similarité#

Voici un exemple simple d'opération propulsée par la table d'embeddings. Explorer est fourni avec une opération similarity_index -

• Elle essaie d'estimer à quel point chaque point de données est similaire au reste du dataset.
• Elle procède en comptant combien d'embeddings d'images se trouvent plus près que max_dist de l'image actuelle dans l'espace d'embedding généré, en considérant top_k images similaires à la fois.

Pour un dataset, un modèle, max_dist et top_k donnés, l'indice de similarité, une fois généré, sera réutilisé. Si ton dataset a changé ou si tu as simplement besoin de régénérer l'indice de similarité, tu peux passer force=True. Tout comme pour la recherche vectorielle et SQL, cela s'accompagne d'un utilitaire pour le tracer directement.

sim_idx = exp.similarity_index(max_dist=0.2, top_k=0.01)
exp.plot_similarity_index(max_dist=0.2, top_k=0.01)

Regardons d'abord le graphique

exp.plot_similarity_index(max_dist=0.2, top_k=0.01)

Regardons maintenant la sortie de l'opération

sim_idx = exp.similarity_index(max_dist=0.2, top_k=0.01, force=False)

sim_idx

Créons une requête pour voir quels points de données ont un compte de similarité supérieur à 30 et traçons des images similaires à ceux-ci.

import numpy as np

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

Tu devrais voir quelque chose comme ceci

exp.plot_similar(idx=[7146, 14035])  # Using avg embeddings of 2 images