Carly Richmond - Elasticsearch Labs

So verbinden Sie zwei Indizes in Elasticsearch

Carly Richmond — Wed, 07 May 2025 00:00:00 GMT

In Elasticsearch ist das Verbinden zweier Indizes nicht so einfach wie in herkömmlichen relationalen SQL-Datenbanken. Mit bestimmten Techniken und Funktionen von Elasticsearch können jedoch ähnliche Ergebnisse erzielt werden.

In der Vergangenheit haben viele Leute den Feldtyp nestedals Mechanismus verwendet, um verschiedene Indizes miteinander zu verbinden. Allerdings war dies aufgrund teurer Abfragen und unvollständiger Unterstützung in Kibana, insbesondere bei Lens-Visualisierungen, eingeschränkt.

Dieser Artikel befasst sich eingehend mit dem Zusammenführen zweier Indizes in Elasticsearch und konzentriert sich dabei auf die folgenden Ansätze:

Verwenden der terms -Abfrage
Verwenden des enrich -Prozessors in Aufnahmepipelines
Logstash elasticsearch Filter-Plugin
ES|QL ENRICH
ES|QL LOOKUP JOIN

Verwenden der Begriffsabfrage

Die Termabfrage ist eine der effektivsten Möglichkeiten, zwei Indizes in Elasticsearch zu verbinden. Mit dieser Abfrage können Sie Dokumente abrufen, die einen oder mehrere genaue Begriffe in einem bestimmten Feld enthalten. Hier besprechen wir, wie man es zum Verbinden zweier Indizes verwendet.

Zuerst müssen Sie die erforderlichen Daten aus dem ersten Index abrufen. Dies kann mithilfe einer einfachen GET-Anfrage und dem Abrufen der Werte aus dem Attribut _source erfolgen.

# Simple GET request GET first_index/_search

Sobald Sie die Daten aus dem ersten Index haben, können Sie diese zum Abfragen des zweiten Index verwenden. Dies geschieht mithilfe der terms -Abfrage, bei der Sie das Feld und die Werte angeben, die Sie abgleichen möchten.

Hier ist ein Beispiel:

GET second_index/_search { "query": { "terms": { "field_in_second_index": ["value1_from_first_index", "value2_from_first_index"] } } }

In diesem Beispiel ist field_in_second_index das Feld im zweiten Index, das Sie mit den Werten aus dem ersten Index abgleichen möchten. value1_from_first_index und value2_from_first_index sind die Werte aus dem ersten Index, die im zweiten Index abgeglichen werden sollen.

Die Begriffsabfrage bietet außerdem Unterstützung bei der Ausführung der beiden oben genannten Schritte in einem Durchgang mithilfe einer Technik namens „Begriffssuche“. Elasticsearch kümmert sich um das transparente Abrufen der abzugleichenden Werte aus einem anderen Index. Wenn Sie beispielsweise einen Teamindex mit einer Spielerliste haben:

PUT teams/_doc/team1 { "players": ["john", "bill", "michael"] } PUT teams/_doc/team2 { "players": ["aaron", "joe", "donald"] }

Es ist möglich, einen Personenindex für alle Personen abzufragen, die in Team1 spielen, wie unten gezeigt:

GET people/_search?pretty { "query": { "terms": { "name" : { "index" : "teams", "id" : "team1", "path" : "players" } } } }

Im obigen Beispiel ruft Elasticsearch die Spielernamen transparent aus dem Dokument mit der ID team1 im Teamindex ab (d. h. „John“, „Bill“ und „Michael“) und suchen Sie alle Dokumente im Personenindex, die einen dieser Werte in ihrem Namensfeld enthalten.

Für alle, die es interessiert: Die entsprechende SQL-Abfrage wäre:

Verwenden des Anreicherungsprozessors

Der enrich -Prozessor ist ein weiteres leistungsstarkes Tool, mit dem zwei Indizes in Elasticsearch verbunden werden können. Dieser Prozessor bereichert die Daten eingehender Dokumente, indem er Daten aus einem vordefinierten Anreicherungsindex hinzufügt.

So können Sie den Anreicherungsprozessor verwenden, um zwei Indizes zu verknüpfen:

1. Zuerst müssen Sie eine Anreicherungsrichtlinie erstellen. Diese Richtlinie definiert, welcher Index für die Anreicherung verwendet werden soll, welches Feld abgeglichen werden soll und welche Felder für die Anreicherung eingehender Dokumente verwendet werden sollen.

Hier ist ein Beispiel:

PUT _enrich/policy/my_enrich_policy { "match": { "indices": "first_index", "match_field": "field_in_first_index", "enrich_fields": ["field_to_enrich"] } }

2. Sobald die Richtlinie erstellt ist, müssen Sie sie ausführen, um den angereicherten Index aus Ihrer neu erstellten Richtlinie zu erstellen:

PUT _enrich/policy/my_enrich_policy/_execute

Dadurch wird ein neuer versteckter angereicherter Index erstellt, der während der Anreicherung verwendet wird. Abhängig von der Größe des Quellindex kann dieser Vorgang einige Zeit dauern. Stellen Sie sicher, dass die Anreicherungsrichtlinie vollständig erstellt ist, bevor Sie mit dem nächsten Schritt fortfahren.

3. Nachdem die Anreicherungsrichtlinie erstellt wurde, können Sie den Anreicherungsprozessor in einer Aufnahmepipeline verwenden, um die Daten eingehender Dokumente anzureichern:

PUT _ingest/pipeline/my_pipeline { "processors": [ { "enrich": { "policy_name": "my_enrich_policy", "field": "field_in_second_index", "target_field": "enriched_field" } } ] }

In diesem Beispiel ist field_in_second_index das Feld im zweiten Index, das mit match_field aus dem ersten Index übereinstimmen muss. enriched_field ist das neue Feld im zweiten Index, das die angereicherten Daten aus enrich_fields im ersten Index enthalten wird.

Ein Nachteil dieses Ansatzes besteht darin, dass die Anreicherungsrichtlinie erneut ausgeführt werden muss, wenn sich die Daten in first_index ändern. Der angereicherte Index wird nicht automatisch mit dem Quellindex aktualisiert oder synchronisiert, aus dem er erstellt wurde. Wenn first_index jedoch relativ stabil ist, funktioniert dieser Ansatz gut.

Logstash Elasticsearch-Filter-Plugin

Wenn Sie Logstash verwenden, besteht eine weitere Option, die dem oben beschriebenen enrich -Prozessor ähnelt, darin, das elasticsearch -Filter-Plugin zu verwenden, um dem Ereignis basierend auf einer angegebenen Abfrage relevante Felder hinzuzufügen. Die Konfiguration für unsere Logstash-Pipeline würde sich in einer .conf -Datei befinden, beispielsweise my-pipeline.conf.

Stellen wir uns vor, unsere Pipeline zieht Protokolle aus Elasticsearch mithilfe des elasticsearch -Eingabe-Plugins und verwendet eine Abfrage, um die Auswahl einzugrenzen:

input { # Read all documents from Elasticsearch matching the given query elasticsearch { hosts => "localhost" query => '{ "query": { "match": { "statuscode": 200 } }, "sort": [ "_doc" ] }' } }

Wenn wir diese Nachrichten mit Informationen aus einem bestimmten Index anreichern möchten, können wir das Filter-Plugin elasticsearchim Abschnitt filter verwenden, um unsere Protokolle anzureichern:

filter { elasticsearch { hosts => ["localhost"] index => "index_name" query => "type:start AND operation:%{[opid]}" fields => { "@timestamp" => "started" } } }

Der obige Code findet die Dokumente ab Index index_name , wobei type der Start ist und das Operationsfeld mit dem angegebenen opid übereinstimmt, und kopiert dann den Wert des Felds @timestamp in ein neues Feld mit dem Namen started.

Die angereicherten Dokumente würden dann an die entsprechende Ausgabequelle gesendet, in diesem Fall an Elasticsearch unter Verwendung des elasticsearch -Ausgabe-Plugins:

output { elasticsearch { hosts => "localhost" data_stream => "true" } }

Wenn Sie Logstash bereits verwenden, kann diese Option nützlich sein, um Ihre Anreicherungslogik an einem einzigen Ort zu konsolidieren und bei eingehenden neuen Ereignissen zu verarbeiten. Wenn dies jedoch nicht der Fall ist, wird Ihre Lösung komplexer und Sie müssen eine weitere Komponente ausführen und warten.

ES|QL ENRICH

Die Einführung von ES|QL, das in Version 8.14 allgemein verfügbar wurde, ist eine von Elasticsearch unterstützte Piped-Abfragesprache, die das Filtern, Transformieren und Analysieren von Daten ermöglicht. Mithilfe des Verarbeitungsbefehls ENRICH können wir mithilfe einer Anreicherungsrichtlinie Daten aus vorhandenen Indizes hinzufügen.

Wenn man dieselbe Richtlinie my_enrich_policy aus dem ursprünglichen Beispiel des Anreicherungsprozessors verwendet, würde das ES|QL-Beispiel folgendermaßen aussehen:

Es ist auch möglich, die Übereinstimmungs- und Anreicherungsfelder zu überschreiben, die in unserem Beispiel field_in_first_index bzw. field_to_enrich sind:

Die offensichtliche Einschränkung besteht darin, dass Sie zuerst eine Anreicherungsrichtlinie angeben müssen, ES|QL bietet jedoch die Flexibilität, die Felder nach Bedarf anzupassen.

ES|QL LOOKUP JOIN

Elasticsearch 8.18 führt eine neue Möglichkeit zum Verbinden von Indizes in Elasticsearch ein, nämlich den Befehl LOOKUP JOIN . Dieser Befehl funktioniert als LEFT OUTER JOIN im SQL-Stil und verwendet den neuen Lookup-Indexmodus auf der rechten Seite des Joins.

Wenn wir unser vorheriges Beispiel noch einmal betrachten, lautet die neue Abfrage wie folgt, wobei match_field sowohl in first_index als auch in second_index vorhanden sein muss:

Der Vorteil von LOOKUP JOIN gegenüber den anderen Ansätzen besteht darin, dass keine enrich -Richtlinie erforderlich ist und daher auch keine zusätzliche Verarbeitung im Zusammenhang mit der Einrichtung der Richtlinie erforderlich ist. Im Gegensatz zu den anderen in diesem Artikel besprochenen Ansätzen ist es nützlich, wenn mit sich häufig ändernden Anreicherungsdaten gearbeitet wird.

Fazit

Zusammenfassend lässt sich sagen, dass Elasticsearch zwar keine herkömmlichen Join-Operationen unterstützt, aber verschiedene Funktionen bietet, mit denen ähnliche Ergebnisse erzielt werden können. Insbesondere haben wir erläutert, wie Sie Join-Operationen mithilfe der folgenden Methoden durchführen können:

Die terms -Abfrage
Der enrich -Prozessor in Ingest-Pipelines
Logstash elasticsearch Filter-Plugin
ES|QL ENRICH
ES|QL LOOKUP JOIN

Es ist wichtig zu beachten, dass diese Methoden ihre Grenzen haben und je nach den spezifischen Anforderungen und der Art der Daten mit Bedacht eingesetzt werden sollten.

Verwendung der hybriden Suche für die Gopher-Jagd mit Elasticsearch und Go

Carly Richmond,Laurent Saint-Félix — Thu, 02 Nov 2023 00:00:00 GMT

In den vorherigen Teilen dieser Serie wurde gezeigt, wie man den Elasticsearch Go-Client für die traditionelle Stichwortsuche und die Vektorsuche verwendet. Dieser dritte Teil behandelt die hybride Suche. Wir zeigen Ihnen Beispiele , wie Sie Vektorsuche und Stichwortsuche mit Elasticsearch und dem Elasticsearch Go-Client kombinieren können.

Voraussetzungen

Genau wie im ersten Teil dieser Reihe gelten auch für dieses Beispiel folgende Voraussetzungen:

Installation von Go Version 1.21 oder höher
Erstellen Sie Ihr eigenes Go-Repository gemäß der in der Go-Dokumentationbeschriebenen empfohlenen Struktur und Paketverwaltung.
Erstellen eines eigenen Elasticsearch-Clusters, gefüllt mit einer Reihe von Seiten über Nagetiere, darunter auch für unseren freundlichen Gopher, aus Wikipedia:

Verbindung zu Elasticsearch herstellen

Zur Erinnerung: In unseren Beispielen werden wir die vom Go-Client angebotene Typed API verwenden. Um eine sichere Verbindung für jede Anfrage herzustellen, muss der Client auf folgende Weise konfiguriert werden:

Cloud-ID und API-Schlüssel bei Verwendung von Elastic Cloud
Cluster-URL, Benutzername, Passwort und Zertifikat

Die Verbindung zu unserem Cluster in der Elastic Cloud würde folgendermaßen aussehen:

func GetElasticsearchClient() (*elasticsearch.TypedClient, error) { var cloudID = os.Getenv("ELASTIC_CLOUD_ID") var apiKey = os.Getenv("ELASTIC_API_KEY") var es, err = elasticsearch.NewTypedClient(elasticsearch.Config{ CloudID: cloudID, APIKey: apiKey, Logger: &elastictransport.ColorLogger{os.Stdout, true, true}, }) if err != nil { return nil, fmt.Errorf("unable to connect: %w", err) } return es, nil }

Die client -Verbindung kann dann für Suchvorgänge verwendet werden, wie in den nachfolgenden Abschnitten gezeigt wird.

Manuelles Boosting für Hybridsuche

Bei der Kombination beliebiger Suchalgorithmen bestand der traditionelle Ansatz darin, Konstanten manuell zu konfigurieren, um jeden Abfragetyp zu verstärken. Genauer gesagt wird für jede Anfrage ein Faktor festgelegt, und das kombinierte Ergebnisset wird mit dem erwarteten Set verglichen, um die Trefferquote der Anfrage zu bestimmen. Dann wiederholen wir den Vorgang für mehrere Faktorensätze und wählen denjenigen aus, der unserem gewünschten Zustand am nächsten kommt.

Beispielsweise kann die Kombination einer einzelnen Textsuchanfrage mit einem Gewichtungsfaktor von 0.8 mit einer kNN-Abfrage mit einem niedrigeren Gewichtungsfaktor von 0.2 durch Angabe des Feldes Boost in beiden Abfragetypen erfolgen, wie im folgenden Beispiel gezeigt:

func HybridSearchWithBoost(client *elasticsearch.TypedClient, term string) ([]Rodent, error) { var k = 10 var numCandidates = 10 var knnBoost float32 = 0.2 var queryBoost float32 = 0.8 res, err := client.Search(). Index("vector-search-rodents"). Knn(types.KnnSearch{ Field: "text_embedding.predicted_value", Boost: &knnBoost, K: &k, NumCandidates: &numCandidates, QueryVectorBuilder: &types.QueryVectorBuilder{ TextEmbedding: &types.TextEmbedding{ ModelId: "sentence-transformers__msmarco-minilm-l-12-v3", ModelText: term, }, }}). Query(&types.Query{ Match: map[string]types.MatchQuery{ "title": { Query: term, Boost: &queryBoost, }, }, }). Do(context.Background()) if err != nil { return nil, err } return getRodents(res.Hits.Hits) }

Der in der Option Boost für jede Abfrage angegebene Faktor wird zur Dokumentbewertung addiert. Indem wir den Score unserer Match-Abfrage um einen größeren Faktor erhöhen als den der KNN-Abfrage, werden die Ergebnisse der Keyword-Abfrage stärker gewichtet.

Die Herausforderung beim manuellen Boosting, insbesondere wenn man kein Suchmaschinenexperte ist, besteht darin, dass es eine Feinabstimmung erfordert, um die Faktoren herauszufinden, die zum gewünschten Ergebnis führen. Es geht einfach darum, verschiedene Werte auszuprobieren, um zu sehen, welcher Wert Sie dem gewünschten Ergebnis näherbringt.

Reciprocal Rank Fusion in hybrid search & Go client

Reciprocal Rank Fusion, oder RRF, wurde in Elasticsearch 8.9 als technische Vorschau für die hybride Suche veröffentlicht. Ziel ist es, den Lernaufwand für die Feinabstimmung zu reduzieren und den Zeitaufwand für das Experimentieren mit Faktoren zur Optimierung des Ergebnissatzes zu verringern.

Bei RRF wird die Dokumentenbewertung durch Mischen der Bewertungen mithilfe des folgenden Algorithmus neu berechnet:

score := 0.0 // q is a query in the set of queries (vector and keyword search) for _, q := range queries { // result(q) is the results if document in result(q) { // k is a ranking constant (default 60) // rank(result(q), d) is the document's rank within result(q) // range from 1 to the window_size (default 100) score += 1.0 / (k + rank(result(q), d)) } } return score

Der Vorteil der Verwendung von RRF besteht darin, dass wir die sinnvollen Standardwerte in Elasticsearch nutzen können. Die Rangkonstante k ist standardmäßig auf 60 gesetzt. Um einen Kompromiss zwischen der Relevanz der zurückgegebenen Dokumente und der Abfrageleistung bei der Suche in großen Datensätzen zu erzielen, ist die Größe des Ergebnissatzes für jede betrachtete Abfrage auf den Wert window_size begrenzt, der standardmäßig auf 100 eingestellt ist, wie in der Dokumentation beschrieben.

k und windows_size kann auch innerhalb der Rrf -Konfiguration innerhalb der Rank -Methode im Go-Client konfiguriert werden, wie im folgenden Beispiel gezeigt:

func HybridSearchWithRRF(client *elasticsearch.TypedClient, term string) ([]Rodent, error) { var k = 10 var numCandidates = 10 // Minimum required window size for the default result size of 10 var windowSize int64 = 10 var rankConstant int64 = 42 res, err := client.Search(). Index("vector-search-rodents"). Knn(types.KnnSearch{ Field: "text_embedding.predicted_value", K: &k, NumCandidates: &numCandidates, QueryVectorBuilder: &types.QueryVectorBuilder{ TextEmbedding: &types.TextEmbedding{ ModelId: "sentence-transformers__msmarco-minilm-l-12-v3", ModelText: term, }, }}). Query(&types.Query{ Match: map[string]types.MatchQuery{ "title": {Query: term}, }, }). Rank(&types.RankContainer{ Rrf: &types.RrfRank{ WindowSize: &windowSize, RankConstant: &rankConstant, }, }). Do(context.Background()) if err != nil { return nil, err } return getRodents(res.Hits.Hits) }

Fazit

Hier haben wir besprochen, wie man Vektor- und Stichwortsuche in Elasticsearch mithilfe des Elasticsearch Go-Clients kombiniert.

Im GitHub-Repository findet ihr den gesamten Code dieser Serie. Falls Sie es noch nicht getan haben, schauen Sie sich Teil 1 und Teil 2 an, um den gesamten Code dieser Serie zu finden.

Viel Spaß bei der Gopherjagd!

Ressourcen

Führen Sie eine Vektorsuche in Elasticsearch mit dem Elasticsearch Go-Client durch.

Carly Richmond,Laurent Saint-Félix — Wed, 01 Nov 2023 00:00:00 GMT

Softwareentwicklung in jeder Programmiersprache, einschließlich Go, bedeutet die Verpflichtung zu lebenslangem Lernen. Während ihrer Universitäts- und Berufslaufbahn hat Carly mit vielen Programmiersprachen und Technologien experimentiert, darunter auch mit den neuesten und besten Implementierungen der Vektorsuche. Aber das reichte nicht! Seit Kurzem spielt auch Carly Go.

Genau wie Tiere, Programmiersprachen und Ihr freundlicher Autor hat sich auch die Suche im Laufe der Zeit weiterentwickelt und verschiedene Praktiken hervorgebracht, bei denen es schwierig sein kann, die richtige für Ihren individuellen Anwendungsfall zu finden. In diesem Blog geben wir einen Überblick über die Vektorsuche und zeigen Beispiele für die einzelnen Ansätze mit Elasticsearch und dem Elasticsearch Go-Client. Anhand dieser Beispiele wird Ihnen gezeigt, wie Sie mit Hilfe der Vektorsuche in Elasticsearch und Go Taschenratten finden und deren Nahrung bestimmen können.

Voraussetzungen

Um diesem Beispiel folgen zu können, stellen Sie sicher, dass die folgenden Voraussetzungen erfüllt sind:

Installation von Go Version 1.21 oder höher
Erstellung eines eigenen Go-Repositorys mit dem
Erstellung eines eigenen Elasticsearch-Clusters, gefüllt mit einer Reihe von Seiten über Nagetiere, darunter auch für unseren freundlichen Gopher, aus Wikipedia:

Verbindung zu Elasticsearch herstellen

In unseren Beispielen werden wir die vom Go-Client angebotene Typed API verwenden. Um eine sichere Verbindung für jede Anfrage herzustellen, muss der Client auf folgende Weise konfiguriert werden:

Cloud-ID und API-Schlüssel bei Verwendung von Elastic Cloud.
Cluster-URL, Benutzername, Passwort und Zertifikat.

Die Verbindung zu unserem Cluster in der Elastic Cloud würde folgendermaßen aussehen:

Die client -Verbindung kann dann für die Vektorsuche verwendet werden, wie in den nachfolgenden Abschnitten gezeigt wird.

Vektorsuche

Die Vektorsuche versucht, dieses Problem zu lösen, indem sie das Suchproblem in einen mathematischen Vergleich mithilfe von Vektoren umwandelt. Der Dokumenteneinbettungsprozess beinhaltet einen zusätzlichen Schritt, bei dem das Dokument mithilfe eines Modells in eine dichte Vektordarstellung oder einfach in einen Zahlenstrom umgewandelt wird. Der Vorteil dieses Ansatzes besteht darin, dass man auch nicht-textuelle Dokumente wie Bilder und Audiodateien durchsuchen kann, indem man sie zusammen mit einer Suchanfrage in einen Vektor übersetzt.

Vereinfacht ausgedrückt ist die Vektorsuche eine Reihe von Vektordistanzberechnungen. In der folgenden Abbildung wird die Vektordarstellung unserer Anfrage Go Gophermit den Dokumenten im Vektorraum verglichen, und die nächstliegenden Ergebnisse (gekennzeichnet durch die Konstante k) werden zurückgegeben:

Je nachdem, welcher Ansatz zur Generierung der Einbettungen für Ihre Dokumente verwendet wird, gibt es zwei verschiedene Wege, um herauszufinden, was Taschenratten fressen.

Ansatz 1: Bringen Sie Ihr eigenes Modell mit

Mit einer Platinum-Lizenz ist es möglich, die Einbettungen innerhalb von Elasticsearch zu generieren, indem das Modell hochgeladen und die Inferenz-API verwendet wird. Die Einrichtung des Modells umfasst sechs Schritte:

Wählen Sie ein PyTorch-Modell aus einem Modell-Repository zum Hochladen aus. Für dieses Beispiel verwenden wir den sentence-transformers/msmarco-MiniLM-L-12-v3 von Hugging Face, um die Einbettungen zu generieren.
Laden Sie das Modell in Elastic mit dem Eland Machine Learning Client für Python unter Verwendung der Anmeldeinformationen für unseren Elasticsearch-Cluster und dem Aufgabentyp text_embeddings. Falls Eland nicht installiert ist, können Sie den Import-Schritt mit Docker ausführen, wie unten gezeigt:

docker run -it --rm --network host \ docker.elastic.co/eland/eland \ eland_import_hub_model \ --cloud-id $ELASTIC_CLOUD_ID \ --es-api-key $ELASTIC_API_KEY \ --hub-model-id sentence-transformers/msmarco-MiniLM-L-12-v3 \ --task-type text_embedding

Nach dem Hochladen sollte das Modell sentence-transformers__msmarco-minilm-l-12-v3 schnell mit einem Beispieldokument getestet werden, um sicherzustellen, dass die Einbettungen wie erwartet generiert werden:

Erstellen Sie eine Ingest-Pipeline, die einen Inferenzprozessor enthält. Dadurch kann die Vektordarstellung mithilfe des hochgeladenen Modells generiert werden:

PUT _ingest/pipeline/search-rodents-vector-embedding-pipeline { "processors": [ { "inference": { "model_id": "sentence-transformers__msmarco-minilm-l-12-v3", "target_field": "text_embedding", "field_map": { "body_content": "text_field" } } } ] }

Erstellen Sie einen neuen Index, der das Feld text_embedding.predicted_value vom Typ dense_vector enthält, um die für jedes Dokument generierten Vektoreinbettungen zu speichern:

PUT vector-search-rodents { "mappings": { "properties": { "text_embedding.predicted_value": { "type": "dense_vector", "dims": 384, "index": true, "similarity": "cosine" }, "text": { "type": "text" } } } }

Die Dokumente werden mithilfe der neu erstellten Ingest-Pipeline neu indiziert, um die Text-Embeddings als zusätzliches Feld text_embedding.predicted_value in jedem Dokument zu generieren:

POST _reindex { "source": { "index": "search-rodents" }, "dest": { "index": "vector-search-rodents", "pipeline": "search-rodents-vector-embedding-pipeline" } }

Nun können wir die Option Knn in derselben Such-API mit dem neuen Index vector-search-rodents verwenden, wie im folgenden Beispiel gezeigt:

func VectorSearch(client *elasticsearch.TypedClient, term string) ([]Rodent, error) { var k = 10 var numCandidates = 10 res, err := client.Search(). Index("vector-search-rodents"). Knn(types.KnnSearch{ # Field in document containing vector Field: "text_embedding.predicted_value", # Number of neighbors to return K: &k, # Number of candidates to evaluate in comparison NumCandidates: &numCandidates, # Generate query vector using the same model used in the inference processor QueryVectorBuilder: &types.QueryVectorBuilder{ TextEmbedding: &types.TextEmbedding{ ModelId: "sentence-transformers__msmarco-minilm-l-12-v3", ModelText: term, }, }}).Do(context.Background()) if err != nil { return nil, fmt.Errorf("error in rodents vector search: %w", err) } return getRodents(res.Hits.Hits) }

Die Konvertierung des JSON-Ergebnisobjekts mittels Unmarshalling erfolgt auf genau die gleiche Weise wie im Beispiel der Stichwortsuche. Mithilfe der Konstanten K und NumCandidates können wir die Anzahl der zurückzugebenden Nachbardokumente und die Anzahl der pro Shard zu berücksichtigenden Kandidaten konfigurieren. Beachten Sie, dass eine Erhöhung der Anzahl der Kandidaten zwar die Genauigkeit der Ergebnisse erhöht, aber zu einer längeren Abfragedauer führt, da mehr Vergleiche durchgeführt werden.

Wird der Code mit der Abfrage What do Gophers eat? ausgeführt, sehen die zurückgegebenen Ergebnisse ähnlich wie unten dargestellt aus, was verdeutlicht, dass der Gopher-Artikel im Gegensatz zur vorherigen Stichwortsuche die angeforderten Informationen enthält:

[ {ID:64f74ecd4acb3df024d91112 Title:Gopher - Wikipedia Url:https://en.wikipedia.org/wiki/Gopher} {ID:64f74ed34acb3d71aed91fcd Title:Squirrel - Wikipedia Url:https://en.wikipedia.org/wiki/Squirrel} //Other results omitted ]

Ansatz 2: Hugging Face Inference API

Eine weitere Möglichkeit besteht darin, diese Einbettungen außerhalb von Elasticsearch zu generieren und sie als Teil Ihres Dokuments einzubinden. Da diese Option keinen Elasticsearch Machine Learning-Knoten verwendet, kann sie im kostenlosen Tarif durchgeführt werden.

Hugging Face stellt eine kostenlose, ratenbegrenzte Inferenz-API zur Verfügung, mit der Sie mithilfe eines Kontos und eines API-Tokens dieselben Einbettungen manuell für Experimente und Prototyping generieren können, um Ihnen den Einstieg zu erleichtern. Für den Einsatz in der Produktion wird es nicht empfohlen. Das lokale Aufrufen eigener Modelle zur Generierung von Einbettungen oder die Nutzung der kostenpflichtigen API kann ebenfalls mit einem ähnlichen Ansatz erfolgen.

In der folgenden Funktion GetTextEmbeddingForQuery verwenden wir die Inferenz-API anhand unserer Abfragezeichenfolge, um den Vektor zu generieren, der von einer POST Anfrage an den Endpunkt zurückgegeben wird:

// HuggingFace text embedding helper func GetTextEmbeddingForQuery(term string) []float32 { // HTTP endpoint model := "sentence-transformers/msmarco-minilm-l-12-v3" posturl := fmt.Sprintf("https://api-inference.huggingface.co/pipeline/feature-extraction/%s", model) // JSON body body := []byte(fmt.Sprintf(`{ "inputs": "%s", "options": {"wait_for_model":True} }`, term)) // Create a HTTP post request r, err := http.NewRequest("POST", posturl, bytes.NewBuffer(body)) if err != nil { log.Fatal(err) return nil } token := os.Getenv("HUGGING_FACE_TOKEN") r.Header.Add("Authorization", fmt.Sprintf("Bearer %s", token)) client := &http.Client{} res, err := client.Do(r) if err != nil { panic(err) } defer res.Body.Close() var post []float32 derr := json.NewDecoder(res.Body).Decode(&post) if derr != nil { log.Fatal(derr) return nil } return post }

Der resultierende Vektor vom Typ []float32 wird dann als QueryVector übergeben, anstatt die Option QueryVectorBuilder zu verwenden, um das zuvor in Elastic hochgeladene Modell zu nutzen.

func VectorSearchWithGeneratedQueryVector(client *elasticsearch.TypedClient, term string) ([]Rodent, error) { vector, err := GetTextEmbeddingForQuery(term) if err != nil { return nil, err } if vector == nil { return nil, fmt.Errorf("unable to generate vector: %w", err) } var k = 10 var numCandidates = 10 res, err := client.Search(). Index("vector-search-rodents"). Knn(types.KnnSearch{ # Field in document containing vector Field: "text_embedding.predicted_value", # Number of neighbors to return K: &k, # Number of candidates to evaluate in comparison NumCandidates: &numCandidates, # Query vector returned from Hugging Face inference API QueryVector: vector, }). Do(context.Background()) if err != nil { return nil, err } return getRodents(res.Hits.Hits) }

Beachten Sie, dass die Optionen K und NumCandidates unabhängig von den beiden Optionen gleich bleiben und dass die gleichen Ergebnisse generiert werden, da wir dasselbe Modell zur Generierung der Einbettungen verwenden.

Fazit

Hier haben wir besprochen, wie man eine Vektorsuche in Elasticsearch mit dem Elasticsearch Go-Client durchführt. Im GitHub-Repository findet ihr den gesamten Code dieser Serie. Im Anschluss daran lesen Sie Teil 3, um einen Überblick über die Kombination der Vektorsuche mit den in Teil eins behandelten Schlüsselwortsuchfunktionen in Go zu erhalten.

Bis dahin, viel Erfolg bei der Gopherjagd!

Ressourcen

Führen Sie Textabfragen mit dem Elasticsearch Go-Client durch.

Carly Richmond,Laurent Saint-Félix — Tue, 31 Oct 2023 00:00:00 GMT

Softwareentwicklung in jeder Programmiersprache, einschließlich Go, bedeutet die Verpflichtung zu lebenslangem Lernen. Während ihrer gesamten Universitäts- und Berufslaufbahn musste sich Carly an die Polyglotte anpassen und sich mit vielen Programmiersprachen auseinandersetzen, darunter Python, C, JavaScript, TypeScript und Java. Aber das reichte nicht! Seit Kurzem spielt sie auch Go!

Genau wie Tiere, Programmiersprachen und auch einige Ihrer Lieblingsautoren hat sich die Suche im Laufe der Zeit weiterentwickelt und verschiedene Vorgehensweisen hervorgebracht, bei denen es schwierig sein kann, die richtige für Ihren individuellen Anwendungsfall zu finden. In diesem Blog geben wir einen Überblick über die traditionelle Stichwortsuche und stellen ein Beispiel mit Elasticsearch und dem Elasticsearch Go-Client vor.

Voraussetzungen

Um diesem Beispiel folgen zu können, stellen Sie sicher, dass die folgenden Voraussetzungen erfüllt sind:

Installation von Go Version 1.21 oder höher
Erstellen Sie Ihr eigenes Go-Repository gemäß der in der Go-Dokumentationbeschriebenen empfohlenen Struktur und Paketverwaltung.
Erstellung eines eigenen Elasticsearch-Clusters, gefüllt mit einer Reihe von Seiten über Nagetiere, darunter auch für unseren freundlichen Gopher, aus Wikipedia:

Verbindung zu Elasticsearch herstellen

In unseren Beispielen werden wir die vom Go-Client angebotene Typed API verwenden. Um eine sichere Verbindung für jede Anfrage herzustellen, muss der Client auf folgende Weise konfiguriert werden:

Cloud-ID und API-Schlüssel bei Verwendung von Elastic Cloud.
Cluster-URL, Benutzername, Passwort und Zertifikat.

Die Verbindung zu unserem Cluster in der Elastic Cloud würde folgendermaßen aussehen:

Die client -Verbindung kann dann, wie später gezeigt wird, für die Suche verwendet werden.

Stichwortsuche

Die Stichwortsuche ist die grundlegende Suchart, mit der wir seit der Entwicklung von Archie, der ersten dokumentierten Internet-Suchmaschine aus dem Jahr 1990, vertraut sind.

Ein zentraler Bestandteil der Stichwortsuche ist die Übersetzung von Dokumenten in einen invertierten Index. Genau wie das Register am Ende eines Lehrbuchs enthält ein invertiertes Register eine Zuordnung zwischen einer Liste von Tokens und deren Position in jedem Dokument. Das folgende Diagramm zeigt die wichtigsten Schritte der Indexerstellung:

Wie oben dargestellt, umfasst die Token-Generierung in Elasticsearch drei Hauptphasen:

Entfernen unnötiger Zeichen durch Null oder mehr char_filters. In unserem Beispiel entfernen wir HTML-Elemente innerhalb des Feldes body_content mithilfe des Filters html_strip .
Die Tokens werden mithilfe des standard Tokenizers vom Inhalt getrennt, wobei die Trennung anhand von Leerzeichen und Satzzeichen erfolgt.
Unerwünschte Tokens werden aus dem Ausgabestream des Tokenizers entfernt oder Tokens mithilfe von null oder mehr filter -Optionen transformiert, z. B. durch den lowercase -Tokenfilter oder Stemmer wie den snowball -Stemmer , um Tokens wieder in ihre Sprachwurzel umzuwandeln.

Suche in Elasticsearch mit Go

Bei Abfragen mit dem Go-Client geben wir den zu durchsuchenden Index an und übergeben die Abfrage sowie weitere Optionen, wie im folgenden Beispiel:

func KeywordSearch(client *elasticsearch.TypedClient, term string) ([]Rodent, error) { res, err := client.Search(). Index("search-rodents"). Query(&types.Query{ Match: map[string]types.MatchQuery{ "title": {Query: term}, }, }). From(0). Size(10). Do(context.Background()) if err != nil { return nil, fmt.Errorf("could not search for rodents: %w", err) } return getRodents(res.Hits.Hits) }

Im obigen Beispiel führen wir eine Standardabfrage matchdurch, um alle Dokumente in unserem Index zu finden, die die an unsere Funktion übergebene Zeichenkette enthalten. Beachten Sie, dass wir über Do(context.Background()) einen neuen leeren Kontext an die Suchausführung übergeben. Darüber hinaus werden alle von Elasticsearch zurückgegebenen Fehler zur Protokollierung und Fehlerbehandlung an das Attribut err ausgegeben.

Die Ergebnisse werden in res.Hits.Hits zurückgegeben, wobei das Attribut _Source das Dokument selbst im JSON-Format enthält. Um diese Quelle in eine Go-kompatible Struktur umzuwandeln, müssen wir die JSON-Antwort mithilfe des Go -Pakets encoding/json deserialisieren, wie im folgenden Beispiel gezeigt:

func getRodents(hits []types.Hit) ([]Rodent, error) { var rodents []Rodent for _, hit := range hits { var currentRodent Rodent err := json.Unmarshal(hit.Source_, ¤tRodent) if err != nil { return nil, fmt.Errorf("an error occurred while unmarshaling rodent %s: %w", hit.Id_, err) } currentRodent.ID = hit.Id_ rodents = append(rodents, currentRodent) } return rodents, nil }

Die Suche und das Unmarshalling der Anfrage gopher liefert wie erwartet die Wikipedia-Seite für Gopher zurück:

[ {ID:64f74ecd4acb3df024d91112 Title:Gopher - Wikipedia Url:https://en.wikipedia.org/wiki/Gopher} ]

Wenn wir jedoch What do Gophers eat? fragen, erhalten wir nicht ganz die gewünschten Ergebnisse:

[]

Eine einfache Stichwortsuche ermöglicht es, Ergebnisse performant an Ihre Go-Anwendung zurückzugeben, und zwar auf eine Weise, die wir von den Anwendungen, die wir verwenden, gewohnt sind. Es eignet sich auch hervorragend für exakte Suchbegriffübereinstimmungen, die für Szenarien wie die Suche nach einem bestimmten Unternehmen oder Begriff relevant sind.

Wie wir oben sehen, hat es jedoch aufgrund des Vokabular-Diskrepanzen Probleme, Kontext und Semantik zu identifizieren. Darüber hinaus stellt die Unterstützung von Nicht-Text-Dateiformaten wie Bildern und Audiodateien eine Herausforderung dar.

Fazit

Hier haben wir besprochen, wie man mit dem Elasticsearch Go-Client herkömmliche Textabfragen in Elasticsearch durchführt. Da Go häufig für die Skripterstellung im Infrastrukturbereich und den Aufbau von Webservern verwendet wird, ist es nützlich zu wissen, wie man in Go sucht.

Im GitHub-Repository findet ihr den gesamten Code dieser Serie. Im Anschluss daran folgt Teil 2, um einen Überblick über die Vektorsuche und deren Durchführung in Go zu erhalten. Bis dahin, viel Erfolg bei der Gopherjagd!