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 Ultralytics Explorer ! Ce notebook sert de point de départ pour explorer les différentes ressources disponibles pour vous aider à démarrer avec l'utilisation d'Ultralytics pour explorer vos ensembles de données en utilisant la puissance de la recherche sémantique. Vous pouvez utiliser des utilitaires prêts à l'emploi qui vous permettent d'examiner des types spécifiques d'étiquettes en utilisant la recherche vectorielle ou même des requêtes SQL.

Essayer yolo explorer propulsé par l'API Explorer

Simplement pip install ultralytics et exécutez yolo explorer dans votre terminal pour exécuter des requêtes personnalisées et une recherche sémantique sur vos ensembles de données directement dans votre navigateur !

Configuration

Pip install ultralytics et dépendances et vérifier les logiciels et le matériel.

!uv pip install ultralytics[explorer] openai
yolo checks

Recherche de similarité

Utilisez la puissance de la recherche de similarité vectorielle pour trouver les points de données similaires dans votre ensemble de données, ainsi que leur distance dans l'espace d'intégration. Créez simplement une table d'intégrations pour la paire ensemble de données-modèle donnée. Cela n'est nécessaire qu'une seule fois et est réutilisé automatiquement.

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

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

• Sur un index / une liste d'index donnés dans l'ensemble de données, comme - exp.get_similar(idx=[1,10], limit=10)
• Sur n'importe quelle image / 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égat de leurs embeddings est utilisé.

Vous obtenez 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'intégration. Vous pouvez utiliser cet ensemble de données pour effectuer un filtrage plus poussé.

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

Vous pouvez également tracer les échantillons similaires directement en utilisant le plot_similar util

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 avec le langage naturel

Vous pouvez interroger l'objet Explorer avec le type de points de données que vous souhaitez voir, et il essaiera de renvoyer un dataframe avec ces points. Puisqu'il est alimenté par des LLM, il ne réussit pas toujours. 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, vous pouvez utiliser plot_query_result Exemple d'utilisation :

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 votre ensemble de données

Parfois, vous pouvez souhaiter examiner un certain type d'entrées dans votre ensemble de données. Pour cela, Explorer vous 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 abrégée
• Vous pouvez également écrire des requêtes complètes où vous pouvez spécifier les colonnes à sélectionner

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

• Disons que votre modèle a du mal avec les images qui contiennent des humains et des chiens. Vous pouvez écrire une requête comme celle-ci pour sélectionner les points qui ont au moins 2 humains ET au moins un chien.

Vous pouvez combiner une requête SQL et une recherche sémantique pour filtrer les résultats selon un type 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 la recherche de similarité, vous disposez également d'un utilitaire pour tracer directement les requêtes SQL en utilisant exp.plot_sql_query

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

Travailler avec le tableau des embeddings (Avancé)

Explorer fonctionne sur LanceDB des tables en interne. Vous pouvez accéder directement à cette table en utilisant Explorer.table objet et exécuter des requêtes brutes, appliquer 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 dans la base de données. Dans un système de recommandation ou un moteur de recherche, vous pouvez trouver des produits similaires à celui que vous avez recherché. Dans les LLM et autres applications d'IA, chaque point de données peut être présenté par les embeddings générés à partir de certains modèles, ce qui renvoie les caractéristiques les plus pertinentes.

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

Dans LanceDB, une métrique est une façon de décrire la distance entre une paire de vecteurs. Actuellement, il prend en charge les métriques suivantes :

• L2
• Cosinus
• La recherche de similarité de Dot Explorer utilise L2 par défaut. Vous pouvez 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 ensembles de données. 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

Vous pouvez accéder à l'embedding brut depuis la Table lancedb et l'analyser. Les embeddings d'image 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 la réduction de la 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'une opération alimentée par la table d'embeddings. 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 de l'image actuelle dans l'espace d'embedding généré, en considérant top_k images similaires à la fois.

Pour un ensemble de données donné, un modèle, max_dist & top_k l'indice de similarité une fois généré sera réutilisé. Si votre jeu de données a changé ou si vous avez simplement besoin de régénérer l'indice de similarité, vous pouvez passer force=True. Semblable à la recherche vectorielle et SQL, ceci est également livré avec un utilitaire pour le tracer directement. Regardons

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)

d'abord au niveau du tracé

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

Examinons 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 nombre de similarités supérieur à 30 et traçons des images similaires à celles-ci.

import numpy as np

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

Vous devriez voir quelque chose comme ceci

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

📅 Créé il y a 8 mois ✏️ Mis à jour il y a 9 jours

Commentaires