Suche nach Vektorähnlichkeiten in Spanner durchführen, indem die K-nächsten Nachbarn ermittelt werden

Auf dieser Seite wird beschrieben, wie Sie in Spanner eine Vektorähnlichkeitssuche durchführen. Dazu verwenden Sie die Vektorfunktionen für Kosinusdistanz, euklidische Distanz und Skalarprodukt, um die K-nächsten Nachbarn zu finden. Diese Informationen gelten sowohl für Datenbanken im GoogleSQL-Dialekt als auch für Datenbanken im PostgreSQL-Dialekt. Bevor Sie diese Seite lesen, sollten Sie sich mit den folgenden Konzepten vertraut machen:

  • Euklidische Distanz: Misst die kürzeste Distanz zwischen zwei Vektoren.
  • Kosinus-Distanz: Misst den Kosinus des Winkels zwischen zwei Vektoren.
  • Skalarprodukt: Berechnet den Kosinus des Winkels multipliziert mit dem Produkt der entsprechenden Vektorgrößen. Wenn Sie wissen, dass alle Vektoreinbettungen in Ihrem Dataset normalisiert sind, können Sie DOT_PRODUCT() als Distanzfunktion verwenden.
  • K-Nearest Neighbors (KNN): Ein Algorithmus für überwachtes maschinelles Lernen, der zur Lösung von Klassifizierungs- oder Regressionsproblemen verwendet wird.

Sie können Vektordistanzfunktionen verwenden, um eine KNN-Vektorsuche (K-Nearest Neighbors) für Anwendungsfälle wie die Ähnlichkeitssuche oder die Retrieval-Augmented Generation durchzuführen. Spanner unterstützt die Funktionen COSINE_DISTANCE(), EUCLIDEAN_DISTANCE() und DOT_PRODUCT(), die auf Vektoreinbettungen angewendet werden, sodass Sie die KNN der Eingabeeinbettung finden können.

Nachdem Sie beispielsweise Ihre operativen Spanner-Daten als Vektoreinbettungen generiert und gespeichert haben, können Sie diese Vektoreinbettungen als Eingabeparameter in Ihrer Abfrage angeben, um die nächstgelegenen Vektoren im N-dimensionalen Raum zu finden und nach semantisch ähnlichen oder verwandten Elementen zu suchen.

Alle drei Distanzfunktionen verwenden die Argumente vector1 und vector2, die vom Typ array<> sind und dieselben Dimensionen und dieselbe Länge haben müssen. Weitere Informationen zu diesen Funktionen finden Sie hier:

Beispiele

Die folgenden Beispiele zeigen die KNN-Suche, die KNN-Suche über partitionierte Daten und die Verwendung eines sekundären Index mit KNN.

In den Beispielen wird immer EUCLIDEAN_DISTANCE() verwendet. Sie können aber auch COSINE_DISTANCE() verwenden. Wenn alle Vektoreinbettungen in Ihrem Dataset normalisiert sind, können Sie außerdem DOT_PRODUCT() als Distanzfunktion verwenden.

Angenommen, Sie haben eine Documents-Tabelle mit einer Spalte (DocEmbedding) mit vorkalkulierten Texteinbettungen aus der DocContents-Bytespalte. Die Angabe der Vektorlänge für DocEmbedding ist für KNN-Abfragen nicht erforderlich, wird aber empfohlen, um die Scanleistung zu optimieren und später einen Vektorindex erstellen zu können. Lassen Sie die Vektorlänge weg, wenn in der Spalte Vektoren mit unterschiedlichen Dimensionen gespeichert werden.

GoogleSQL

CREATE TABLE Documents (
UserId       INT64 NOT NULL,
DocId        INT64 NOT NULL,
Author       STRING(1024),
DocContents  BYTES(MAX),
DocEmbedding ARRAY<FLOAT32>(vector_length=>4)
) PRIMARY KEY (UserId, DocId);

PostgreSQL

CREATE TABLE Documents (
UserId       bigint NOT NULL,
DocId        bigint NOT NULL,
Author       varchar(1024),
DocContents  bytea,
DocEmbedding float4[] VECTOR LENGTH 4,
PRIMARY KEY  (UserId, DocId)
);

Angenommen, eine Eingabeeinbettung für „Baseball, aber nicht professioneller Baseball“ ist das Array [0.3, 0.3, 0.7, 0.7]. Mit der folgenden Abfrage können Sie die fünf am besten übereinstimmenden Dokumente finden:

GoogleSQL

SELECT DocId, DocEmbedding FROM Documents
ORDER BY EUCLIDEAN_DISTANCE(DocEmbedding,
ARRAY<FLOAT32>[0.3, 0.3, 0.7, 0.8])
LIMIT 5;

PostgreSQL

SELECT DocId, DocEmbedding FROM Documents
ORDER BY spanner.euclidean_distance(DocEmbedding,
'{0.3, 0.3, 0.7, 0.8}'::float4[])
LIMIT 5;

Die erwarteten Ergebnisse dieses Beispiels:

Documents
+---------------------------+-----------------+
| DocId                     | DocEmbedding    |
+---------------------------+-----------------+
| 24                        | [8, ...]        |
+---------------------------+-----------------+
| 25                        | [6, ...]        |
+---------------------------+-----------------+
| 26                        | [3.2, ...]      |
+---------------------------+-----------------+
| 27                        | [38, ...]       |
+---------------------------+-----------------+
| 14229                     | [1.6, ...]      |
+---------------------------+-----------------+

Beispiel 2: KNN-Suche über partitionierte Daten

Die Abfrage im vorherigen Beispiel kann geändert werden, indem Sie der WHERE-Klausel Bedingungen hinzufügen, um die Vektorsuche auf eine Teilmenge Ihrer Daten zu beschränken. Eine gängige Anwendung hierfür ist die Suche in partitionierten Daten, z. B. in Zeilen, die zu einem bestimmten UserId gehören.

GoogleSQL

SELECT UserId, DocId, DocEmbedding FROM Documents
WHERE UserId=18
ORDER BY EUCLIDEAN_DISTANCE(DocEmbedding,
ARRAY<FLOAT32>[0.3, 0.3, 0.7, 0.8])
LIMIT 5;

PostgreSQL

SELECT UserId, DocId, DocEmbedding FROM Documents
WHERE UserId=18
ORDER BY spanner.euclidean_distance(DocEmbedding,
'{0.3, 0.3, 0.7, 0.8}'::float4[])
LIMIT 5;

Die erwarteten Ergebnisse dieses Beispiels:

Documents
+-----------+-----------------+-----------------+
| UserId    | DocId           | DocEmbedding    |
+-----------+-----------------+-----------------+
| 18        | 234             | [12, ...]       |
+-----------+-----------------+-----------------+
| 18        | 12              | [1.6, ...]      |
+-----------+-----------------+-----------------+
| 18        | 321             | [22, ...]       |
+-----------+-----------------+-----------------+
| 18        | 432             | [3, ...]        |
+-----------+-----------------+-----------------+

Beispiel 3: KNN-Suche über sekundäre Indexbereiche

Wenn der von Ihnen verwendete WHERE-Klauselfilter nicht Teil des Primärschlüssels der Tabelle ist, können Sie einen sekundären Index erstellen, um den Vorgang mit einem Nur-Index-Scan zu beschleunigen.

GoogleSQL

CREATE INDEX DocsByAuthor
ON Documents(Author)
STORING (DocEmbedding);

SELECT Author, DocId, DocEmbedding FROM Documents
WHERE Author="Mark Twain"
ORDER BY EUCLIDEAN_DISTANCE(DocEmbedding,
   <embeddings for "book about the time traveling American">)
LIMIT 5;

PostgreSQL

CREATE INDEX DocsByAuthor
ON Documents(Author)
INCLUDE (DocEmbedding);

SELECT Author, DocId, DocEmbedding FROM Documents
WHERE Author="Mark Twain"
ORDER BY spanner.euclidean_distance(DocEmbedding,
   <embeddings for "that book about the time traveling American">)
LIMIT 5;

Die erwarteten Ergebnisse dieses Beispiels:

Documents
+------------+-----------------+-----------------+
| Author     | DocId           | DocEmbedding    |
+------------+-----------------+-----------------+
| Mark Twain | 234             | [12, ...]       |
+------------+-----------------+-----------------+
| Mark Twain | 12              | [1.6, ...]      |
+------------+-----------------+-----------------+
| Mark Twain | 321             | [22, ...]       |
+------------+-----------------+-----------------+
| Mark Twain | 432             | [3, ...]        |
+------------+-----------------+-----------------+
| Mark Twain | 375             | [9, ...]        |
+------------+-----------------+-----------------+

Nächste Schritte