Exemple d'exploration des COV

Aucune description n'a été fournie pour cette image

Bienvenue dans le carnet de l'API Ultralytics Explorer ! Ce carnet sert de point de départ à l'exploration des différentes ressources disponibles pour t'aider à commencer à utiliser Ultralytics pour explorer tes ensembles de données en utilisant la puissance de la recherche sémantique. Tu peux utiliser des utilitaires prêts à l'emploi qui te permettent d'examiner des types spécifiques d'étiquettes en utilisant la recherche vectorielle ou même des requêtes SQL.

Nous espérons que les ressources de ce carnet t'aideront à tirer le meilleur parti de Ultralytics. N'hésite pas à parcourir les Explorer Docs pour plus de détails, à soulever un problème sur GitHub pour obtenir de l'aide, et à rejoindre notre communauté Discord pour poser des questions et discuter !

Essaie yolo explorer alimenté par Exlorer API

Simplement pip install ultralytics et exécute yolo explorer dans ton terminal pour exécuter des requêtes personnalisées et des recherches sémantiques sur tes ensembles de données directement dans ton navigateur !

Mise en place

Pip installer ultralytics et dépendances et vérifie les logiciels et le matériel.

Dans [ ] :

Copié !

%pip installer ultralytics[explorateur] openai
importer ultralytics
ultralytics.vérifications()
%pip install ultralytics[explorer] openai
import ultralytics
ultralytics .checks()

Dans [ ] :

Copié !

de ultralytics l'importation Explorer
from ultralytics import Explorer

Recherche de similitude¶

Utilise la puissance de la recherche de similarité vectorielle pour trouver les points de données similaires dans ton ensemble de données ainsi que leur distance dans l'espace d'intégration. Il suffit de créer une table d'intégration pour la paire donnée ensemble de données-modèle. Elle n'est nécessaire qu'une seule fois et est réutilisée automatiquement.

Dans [ ] :

Copié !

exp = Explorateur("VOC.yaml", modèle="yolov8n.pt")
exp.create_embeddings_table()
exp = Explorer("VOC.yaml", model="yolov8n.pt")
exp.create_embeddings_table()

Une fois que la table d'intégration est construite, tu peux lancer une recherche sémantique de l'une des façons suivantes :

Sur un index donné / une liste d'index dans le jeu de données comme - exp.get_similar(idx=[1,10], limit=10)
Sur toute 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, c'est l'agrégat de leur intégration qui est utilisé.

Tu obtiens un cadre de données pandas avec l'attribut limit le nombre de points de données les plus similaires à l'entrée, ainsi que leur distance dans l'espace d'intégration. Tu peux utiliser cet ensemble de données pour effectuer d'autres filtrages Capture d'écran 2024-01-06 à 9 45 42 PM

Dans [ ] :

Copié !

similaires = exp.get_similar(idx=1, limite=10)
similaire.tête()
similar = exp.get_similar(idx=1, limit=10)
similar.head()

Tu peux aussi tracer les échantillons similaires directement à l'aide de la fonction plot_similar util

Aucune description n'a été fournie pour cette image

Dans [ ] :

Copié !

exp.plot_similar(idx=6500, limit=20)
#exp.plot_similar(idx=[100,101], limit=10) # Peut aussi passer une liste d'idxs ou d'imgs
exp.plot_similar(idx=6500, limit=20)
#exp.plot_similar(idx=[100,101], limit=10) # Peut aussi passer une liste d'idxs ou d'imgs

Dans [ ] :

Copié !

exp.plot_similar(img="https://ultralytics.com/images/bus.jpg", limite=10, étiquettes=Faux) # Peut aussi passer des images externes
exp.plot_similar(img="https://ultralytics.com/images/bus.jpg", limit=10, labels=False) # Peut aussi passer des images externes

Aucune description n'a été fournie pour cette image

2. Ask AI : Rechercher ou filtrer avec le langage naturel¶

Tu peux demander à l'objet Explorateur le type de points de données que tu veux voir et il essaiera de renvoyer un cadre de données avec ces points. Comme il est alimenté par des LLM, il n'y parvient pas toujours. Dans ce cas, il renverra None.

Capture d'écran 2024-01-07 à 2 34 53 PM

Dans [ ] :

Copié !

df = exp.ask_ai("montre-moi des images contenant plus de 10 objets avec au moins 2 personnes")
df.head(5)
df = exp.ask_ai("montre-moi des images contenant plus de 10 objets avec au moins 2 personnes")
df.head(5)

Pour tracer ces résultats, tu peux utiliser plot_query_result util Exemple :

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

Aucune description n'a été fournie pour cette image

Dans [ ] :

Copié !





# tracé
à partir de ultralytics.data.explorer import résultat_de_la_requête_de_l'intrigue
de PIL import Image

plt = résultat_de_la_requête_de_l'intrigue(exp.ask_ai("montre-moi 10 images contenant exactement 2 personnes"))
Image.fromarray(plt)
# tracer
from ultralytics.data.explorer import plot_query_result
from PIL import Image

plt = plot_query_result(exp.ask_ai("montre-moi 10 images contenant exactement 2 personnes"))
Image.fromarray(plt)

3. Exécute des requêtes SQL sur ton jeu de données!¶

Il peut arriver que tu veuilles enquêter sur un certain type d'entrées dans ton ensemble de données. Pour cela, Explorer te permet d'exécuter des requêtes SQL. Il accepte l'un ou l'autre des formats :

Les requêtes commençant par "WHERE" sélectionneront automatiquement toutes les colonnes. On peut considérer qu'il s'agit d'une requête abrégée
Tu peux aussi écrire des requêtes complètes dans lesquelles tu peux 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 ton modèle se bat sur des images où il y a 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 les résultats d'un type spécifique. Capture d'écran 2024-01-06 à 9 47 30 PM

Dans [ ] :

Copié !

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

Tout comme la recherche par similarité, tu disposes également d'un util pour tracer directement les requêtes SQL à l'aide de exp.plot_sql_query Aucune description n'a été fournie pour cette image

Dans [ ] :

Copié !

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

3. Travailler avec des enchâssements Tableau (Avancé)¶

Explorer fonctionne sur LanceDB en interne. Tu peux accéder à cette table directement, en utilisant Explorer.table et d'exécuter des requêtes brutes, d'appliquer des filtres avant et après, etc.

Dans [ ] :

Copié !

table = exp.table
table.schéma
table = exp.table
table.schema

Exécute les requêtes brutes¶

La recherche de vecteurs trouve les vecteurs les plus proches dans 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 recherché. Dans le LLM et d'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, il renvoie les caractéristiques les plus pertinentes.

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

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

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

Dans [ ] :

Copié !

image fictive_embedding = [i pour i dans plage(256)]
table.recherche(dummy_img_embedding).limite(5).to_pandas()
dummy_img_embedding = [i for i in range(256)]
table.search(dummy_img_embedding).limit(5).to_pandas()

Interconversion vers les formats de données les plus courants¶

Dans [ ] :

Copié !

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

Travailler avec Embeddings¶

Tu peux accéder à l'intégration brute à partir de la table lancedb et l'analyser. Les incrustations d'images sont stockées dans la colonne vector

Dans [ ] :

Copié !

importer numpy comme np

enchâssements = table.to_pandas()["vecteur"].tolist()
encastrements = np.array(enchâssements)
importer numpy en tant que np

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

Diagramme de dispersion¶

L'une des étapes préliminaires de l'analyse des embeddings consiste à les représenter dans l'espace 2D par le biais de la réduction de la dimensionnalité. Prenons un exemple

Dans [ ] :

Copié !

!pip installe scikit-apprendre --q
!pip install scikit-learn --q

Dans [ ] :

Copié !





%matplotlib en ligne
importer numpy comme np
à partir de sklearn.decomposition importer PCA
import matplotlib.pyplot en tant que plt
à partir de mpl_toolkits.mplot3d importer Axes3D

# Réduit les dimensions à l'aide de l'ACP à 3 composantes pour la visualisation en 3D
pca = PCA(n_composantes=3)
données_réduites = pca.fit_transform(enchâssements)

# Crée un nuage de points en 3D à l'aide de Axes3D de Matplotlib
fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111, projection='3d')

# Diagramme de dispersion
ax.scatter(données_réduites[ :, 0], données_réduites[ :, 1], données_réduites[ :, 2], alpha=0.5)
ax.set_title('Diagramme de dispersion 3D des données réduites à 256 dimensions (ACP)')
ax.set_xlabel('Composant 1')
ax.set_ylabel('Composant 2')
ax.set_zlabel('Composant 3')

plt.montrer()
%matplotlib inline
import numpy as np
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Réduire les dimensions à l'aide de l'ACP à 3 composantes pour la visualisation en 3D
pca = PCA(n_composantes=3)
reduced_data = pca.fit_transform(embeddings)

# Crée un diagramme de dispersion en 3D à l'aide d'Axes3D de Matplotlib
fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111, projection='3d')

# Diagramme de dispersion
ax.scatter(reduced_data[ :, 0], reduced_data[ :, 1], reduced_data[ :, 2], alpha=0.5)
ax.set_title('Diagramme de dispersion 3D des données réduites à 256 dimensions (ACP)')
ax.set_xlabel('Composant 1')
ax.set_ylabel('Composant 2')
ax.set_zlabel('Composant 3')

plt.show()

4. Indice de similitude

Voici un exemple simple d'une opération alimentée par le tableau des incorporations. Explorer est livré avec un similarity_index fonctionnement-

Il tente d'estimer le degré de similitude de chaque point de données avec le reste de l'ensemble de données.
Pour ce faire, il compte le nombre d'images intégrées qui sont plus proches que max_dist à l'image actuelle dans l'espace d'intégration généré, en considérant que top_k des images similaires à la fois.

Pour un ensemble de données donné, le modèle, max_dist & top_k l'index de similarité une fois généré sera réutilisé. Si ton jeu de données a changé, ou si tu as simplement besoin de régénérer l'indice de similarité, tu peux passer le paramètre force=True. Tout comme la recherche vectorielle et la recherche SQL, cette recherche est également accompagnée d'un util permettant de la tracer directement. Examinons d'abord le tracé Capture d'écran 2024-01-06 à 9 49 36 PM

Dans [ ] :

Copié !

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

Regardons maintenant le résultat de l'opération.

Dans [ ] :

Copié !

importer numpy comme np

sim_idx = exp.indice_de_similitude(max_dist=0.2, top_k=0.01, force=Faux)
importer numpy en tant que np

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

Dans [ ] :

Copié !

sim_idx
sim_idx

Créons une requête pour voir quels sont les points de données dont le nombre de similitudes est supérieur à 30 et traçons les images qui leur sont similaires.

Dans [ ] :

Copié !

importer numpy comme np

sim_count = np.array(sim_idx["count"])
sim_idx['im_file'][sim_count > 30]
importer numpy en tant que np

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

Tu devrais voir quelque chose comme ceci Aucune description n'a été fournie pour cette image

Dans [ ] :

Copié !

exp.plot_similar(idx=[7146, 14035]) # Utilisation de l'intégration moyenne de 2 images
exp.plot_similar(idx=[7146, 14035]) # Utilisation de l'intégration moyenne de 2 images

Créé le 2024-01-07, Mis à jour le 2024-01-25
Auteurs : RizwanMunawar (1), AyushExel (2), glenn-jocher (1)