Beispiel zur VOC-Erkundung#

In diesem Beispiel wird die Explorer API anhand des VOC-Datensatzes vorgestellt: Es wird eine Embedding-Tabelle erstellt, es werden semantische Suchen und SQL-Abfragen ausgeführt und Fragen in natürlicher Sprache gestellt. Dieselben Schritte bilden die Grundlage für die yolo explorer GUI.

Einrichtung#

Installiere die festgelegte Version ultralytics mit den Explorer-Zusatzpaketen und überprüfe anschließend die Software und Hardware.

pip install "ultralytics[explorer]==8.3.11" openai
yolo checks

Suche nach ähnlichen Elementen#

Nutze die Suche nach Vektorähnlichkeit, um ähnliche Datenpunkte in deinem Datensatz sowie ihre Abstände im Embedding-Raum zu finden. Erstelle einfach eine Embedding-Tabelle für das jeweilige Dataset-Modell-Paar. Das ist nur einmal erforderlich; anschließend wird die Tabelle automatisch wiederverwendet.

from ultralytics import Explorer

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

Sobald die Embedding-Tabelle erstellt ist, kannst du auf eine der folgenden Arten eine semantische Suche ausführen:

• Anhand eines bestimmten Index oder einer Liste von Indizes im Datensatz, zum Beispiel exp.get_similar(idx=[1, 10], limit=10)
• Anhand eines beliebigen Bildes oder einer Liste von Bildern, die nicht im Datensatz enthalten sind, zum Beispiel exp.get_similar(img=["path/to/img1", "path/to/img2"], limit=10). Bei mehreren Eingaben wird ein Aggregat ihrer Embeddings verwendet.

Du erhältst einen pandas-DataFrame mit den ähnlichsten Datenpunkten für die Eingabe, bis zur festgelegten Höchstzahl, sowie ihren Abständen im Embedding-Raum. Mit diesem Datensatz kannst du weitere Filter anwenden.

# Datensatz anhand des Index durchsuchen
similar = exp.get_similar(idx=1, limit=10)
similar.head()

Du kannst ähnliche Beispiele auch direkt mit dem Hilfsprogramm plot_similar darstellen:

exp.plot_similar(idx=6500, limit=20)
exp.plot_similar(idx=[100, 101], limit=10)  # Du kannst auch eine Liste von Indizes oder Bildern übergeben

exp.plot_similar(img="https://ultralytics.com/images/bus.jpg", limit=10, labels=False)  # Du kannst auch externe Bilder übergeben

Ask AI: Suchen oder Filtern mit natürlicher Sprache#

Du kannst dem Explorer-Objekt beschreiben, welche Datenpunkte du sehen möchtest. Es versucht dann, einen DataFrame mit den entsprechenden Ergebnissen zurückzugeben. Da die Funktion von LLMs unterstützt wird, sind die Ergebnisse nicht immer korrekt. In diesem Fall wird None zurückgegeben.

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

Um diese Ergebnisse darzustellen, kannst du das Hilfsprogramm plot_query_result verwenden:

# 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)

SQL-Abfragen für deinen Datensatz ausführen#

Manchmal möchtest du bestimmte Einträge in deinem Datensatz untersuchen. Dafür kannst du mit Explorer SQL-Abfragen ausführen. Unterstützt werden die folgenden Formate:

• Bei Abfragen, die mit „WHERE“ beginnen, werden automatisch alle Spalten ausgewählt. Das ist eine verkürzte Schreibweise für eine Abfrage.
• Du kannst auch vollständige Abfragen schreiben und dabei festlegen, welche Spalten ausgewählt werden sollen.

Damit kannst du die Modellleistung und bestimmte Datenpunkte untersuchen. Zum Beispiel:

• Angenommen, dein Modell hat Schwierigkeiten mit Bildern, auf denen Menschen und Hunde zu sehen sind. Mit einer Abfrage wie dieser kannst du die Datenpunkte auswählen, die mindestens 2 Menschen UND mindestens einen Hund enthalten.

Du kannst SQL-Abfragen mit semantischer Suche kombinieren, um die Ergebnisse auf bestimmte Arten einzugrenzen.

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)

Wie bei der Ähnlichkeitssuche steht dir auch ein Hilfsprogramm zur Verfügung, mit dem du SQL-Abfragen direkt über exp.plot_sql_query darstellen kannst.

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

Mit Embedding-Tabellen arbeiten (Fortgeschritten)#

Explorer verwendet intern LanceDB-Tabellen. Du kannst mit dem Objekt Explorer.table direkt auf diese Tabelle zugreifen und unveränderte Abfragen ausführen, Vor- und Nachfilter nach unten weiterreichen usw.

table = exp.table
print(table.schema)

Unverarbeitete Abfragen ausführen#

Die Vektorsuche findet die nächstgelegenen Vektoren in der Datenbank. In einem Empfehlungssystem oder einer Suchmaschine kannst du ähnliche Produkte zu einem gesuchten Produkt finden. Bei LLM- und anderen KI-Anwendungen kann jeder Datenpunkt durch die von bestimmten Modellen erzeugten Embeddings dargestellt werden. Dabei werden die relevantesten Merkmale zurückgegeben.

Bei einer Suche in einem hochdimensionalen Vektorraum werden die K nächsten Nachbarn (KNN) des Abfragevektors ermittelt.

Metrik: In LanceDB beschreibt eine Metrik den Abstand zwischen zwei Vektoren. Derzeit werden die folgenden Metriken unterstützt:

• L2
• Kosinus
• Skalarprodukt

Die Ähnlichkeitssuche im Explorer verwendet standardmäßig L2. Du kannst Abfragen direkt auf Tabellen ausführen oder das lance-Format verwenden, um eigene Hilfsprogramme zur Verwaltung von Datensätzen zu erstellen. Weitere Informationen zu den verfügbaren Tabellenoperationen in LanceDB findest du in der LanceDB-Dokumentation.

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

Konvertierung in gängige Datenformate#

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

Mit Embeddings arbeiten#

Du kannst auf das rohe Embedding aus der lancedb-Tabelle zugreifen und es analysieren. Die Bild-Embeddings werden in der Spalte vector gespeichert.

import numpy as np

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

Streudiagramm#

Ein erster Schritt bei der Analyse von Embeddings besteht darin, sie mithilfe einer Dimensionsreduktion in einem zweidimensionalen Raum darzustellen. Sehen wir uns ein Beispiel an.

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

# Dimensionen mit PCA für die 3D-Visualisierung auf 3 Komponenten reduzieren
pca = PCA(n_components=3)
reduced_data = pca.fit_transform(embeddings)

# # Erstelle mit Matplotlibs Axes3D ein dreidimensionales Streudiagramm
fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111, projection="3d")

# Streudiagramm
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()

Ähnlichkeitsindex#

Hier ist ein einfaches Beispiel für eine Operation, die von der Embedding-Tabelle unterstützt wird. Explorer enthält eine similarity_index-Operation-

• Sie versucht zu schätzen, wie ähnlich die einzelnen Datenpunkte dem restlichen Datensatz sind.
• Dazu wird gezählt, wie viele Bild-Embeddings im generierten Embedding-Raum näher als max_dist am aktuellen Bild liegen; dabei werden jeweils top_k ähnliche Bilder berücksichtigt.

Für einen bestimmten Datensatz, ein bestimmtes Modell, max_dist und top_k wird der einmal generierte Ähnlichkeitsindex wiederverwendet. Falls sich dein Datensatz geändert hat oder du den Ähnlichkeitsindex einfach neu generieren musst, kannst du force=True übergeben. Wie bei der Vektor- und SQL-Suche gibt es auch hier ein Hilfsprogramm zur direkten Darstellung.

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)

Sehen wir uns zuerst das Diagramm an.

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

Sehen wir uns nun die Ausgabe der Operation an.

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

sim_idx

Erstellen wir eine Abfrage, um Datenpunkte mit einer Ähnlichkeitsanzahl von mehr als 30 zu finden und ähnliche Bilder darzustellen.

import numpy as np

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

Das Ergebnis sollte ungefähr so aussehen.

exp.plot_similar(idx=[7146, 14035])  # # Durchschnittliche Embeddings von 2 Bildern verwenden

Häufig gestellte Fragen#