Go - Elasticsearch Labs

Usar búsqueda híbrida para la detección de errores con Elasticsearch y Go

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

En las partes anteriores de este serial, se demostró cómo usar el cliente Elasticsearch Go para la búsqueda tradicional por palabras clave y la búsqueda vectorial. Esta tercera parte trata sobre la búsqueda híbrida. Compartiremos ejemplos de cómo puedes combinar tanto búsqueda vectorial como búsqueda por palabras clave usando Elasticsearch y el cliente Elasticsearch Go.

Prerrequisitos

Al igual que en la primera parte de este serial, se requieren los siguientes requisitos previos para este ejemplo:

Instalación de Go versión 1.21 o posterior
Crea tu propio repositorio de Go usando la estructura recomendada y la gestión de paquetes que se menciona en la documentación de Go
Creando tu propio clúster de Elasticsearch, poblado con un conjunto de páginas basadas en roedores, incluyendo nuestro amigable Gopher, de Wikipedia:

Conexión con Elasticsearch

Como recordatorio, en nuestros ejemplos emplearemos la API tipada que ofrece el cliente Go. Establecer una conexión segura para cualquier consulta requiere configurar al cliente usando cualquiera de:

ID de la nube y clave API si se emplea Elastic Cloud
URL del clúster, nombre de usuario, contraseña y el certificado

Conectarse a nuestro clúster ubicado en Elastic Cloud sería así:

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 }

La conexión client puede entonces emplear para búsqueda, como se demuestra en las secciones posteriores.

Impulso manual para búsqueda híbrida

Al combinar cualquier conjunto de algoritmos de búsqueda, el enfoque tradicional fue configurar manualmente las constantes para potenciar cada tipo de consulta. Específicamente, se especifica un factor para cada consulta, y el conjunto de resultados combinados se compara con el conjunto esperado para determinar la recuperación de la consulta. Luego repetimos para varios conjuntos de factores y elegimos el que esté más cerca de nuestro estado deseado.

Por ejemplo, combinar una consulta de búsqueda de texto individual potenciada por un factor de 0.8 con una consulta knn de menor factor de 0.2 puede hacer especificando el campo Boost en ambos tipos de consulta, como se muestra en el siguiente ejemplo:

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

El factor especificado en la opción de Boost para cada consulta se suma al puntaje del documento. Al aumentar el puntaje de nuestra consulta de coincidencia en un factor mayor que la consulta knn, los resultados de la consulta por palabra clave tienen un peso más fuerte.

El reto del aumento manual, especialmente si no eres un experto en búsquedas, es que requiere ajuste para identificar los factores que manejarán al conjunto de resultados deseado. Simplemente se trata de probar valores aleatorios para ver qué te acerca más al conjunto de resultados deseado.

Fusión de rangos recíprocos en un cliente híbrido de búsqueda y Go

Reciprocal Rank Fusion, o RRF, se publicó en formato de vista previa técnica para búsqueda híbrida en Elasticsearch 8.9. Su objetivo es reducir la curva de aprendizaje asociada al ajuste y disminuir el tiempo dedicado a experimentar con factores para optimizar el conjunto de resultados.

Con RRF, el puntaje del documento se recalcula mezclando los puntajes mediante el siguiente algoritmo:

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

El beneficio de usar RRF es que podemos aprovechar los valores predeterminados sensatos dentro de Elasticsearch. La constante de clasificación k por defecto es 60. Para proporcionar un equilibrio entre la relevancia de los documentos devueltos y el rendimiento de la consulta al buscar sobre grandes conjuntos de datos, el tamaño del conjunto de resultados para cada consulta considerada se limita al valor de window_size, que por defecto es 100 según se indica en la documentación.

k y windows_size también pueden configurar dentro de la configuración Rrf dentro del método Rank en el cliente Go, como se muestra en el siguiente ejemplo:

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

Conclusión

Aquí hablamos de cómo combinar la búsqueda vectorial y la búsqueda por palabras clave en Elasticsearch usando el cliente Elasticsearch Go.

Echa un vistazo al repositorio de GitHub para ver todo el código de este serial. Si no lo hiciste ya, echa un vistazo a la parte 1 y la parte 2 para ver todo el código de este serial.

¡Feliz caza de topos!

Recursos

Realiza búsqueda vectorial en Elasticsearch con el cliente Elasticsearch Go

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

Desarrollar software en cualquier lenguaje de programación, incluido Go, es comprometer con una vida entera de aprendizaje. A lo largo de su carrera universitaria y profesional, Carly experimentó con muchos lenguajes de programación y tecnologías, incluyendo las últimas y mejores implementaciones de búsqueda vectorial. ¡Pero eso no fue suficiente! Así que recientemente Carly también empezó a jugar con Go.

Al igual que los animales, los lenguajes de programación y tu autor amable, la búsqueda experimentó una evolución de diferentes prácticas que pueden ser difíciles de elegir para tu propio caso de uso. En este blog, compartiremos una visión general de la búsqueda vectorial junto con ejemplos de cada enfoque usando Elasticsearch y el cliente Elasticsearch Go. Estos ejemplos te mostrarán cómo encontrar topos y determinar qué comen usando búsqueda vectorial en Elasticsearch y Go.

Prerrequisitos

Para seguir con este ejemplo, cerciorar de cumplir los siguientes requisitos:

Instalación de Go versión 1.21 o posterior
Creación de tu propio repositorio Go con el
Creación de tu propio clúster Elasticsearch, poblado con un conjunto de páginas basadas en roedores, incluyendo para nuestro amable Gopher, de Wikipedia:

Conexión con Elasticsearch

En nuestros ejemplos, emplearemos la API tipada que ofrece el cliente Go. Establecer una conexión segura para cualquier consulta requiere configurar al cliente usando cualquiera de:

Cloud ID y clave API si se emplea Elastic Cloud.
URL del clúster, nombre de usuario, contraseña y el certificado.

Conectarse a nuestro clúster ubicado en Elastic Cloud sería así:

La conexión client puede entonces emplear para búsqueda vectorial, como se muestra en secciones posteriores.

Búsqueda de vectores

La búsqueda vectorial intenta resolver este problema convirtiendo el problema de búsqueda en una comparación matemática usando vectores. El proceso de incrustación de documentos tiene una etapa adicional de convertir el documento usando un modelo en una representación vectorial densa, o simplemente en un flujo de números. El beneficio de este enfoque es que puedes buscar documentos no textuales, como imágenes y audio, traduciéndolos a un vector junto con una consulta.

En términos simples, la búsqueda vectorial es un conjunto de cálculos de distancia vectorial. En la ilustración siguiente, la representación vectorial de nuestro Go Gopherde consulta se compara con los documentos en el espacio vectorial, y se devuelven los resultados más cercanos (denotados por kconstantes):

Dependiendo del método que se emplee para generar los embeddings de tus documentos, hay dos formas diferentes de saber qué comen los topos.

Enfoque 1: Trae tu propio modelo

Con una licencia Platinum, es posible generar las incrustaciones dentro de Elasticsearch subiendo el modelo y usando la API de inferencia. Hay seis pasos implicados para establecer el modelo:

Selecciona un modelo de PyTorch para subirlo desde un repositorio de modelos. Para este ejemplo, estamos usando los transformadores de frase/msmarco-MiniLM-L-12-v3 de Hugging Face para generar los embeddings.
Carga el modelo en Elastic usando el cliente Eland Machine Learning para Python usando las credenciales de nuestro clúster Elasticsearch y tipo de tarea text_embeddings. Si no tienes Eland instalado, puedes ejecutar el paso de importación usando Docker, como se muestra a continuación:

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

Una vez cargado, prueba rápidamente el sentence-transformers__msmarco-minilm-l-12-v3 del modelo con un documento de muestra para cerciorarte de que las incrustaciones se generan como se espera:

Crear una tubería de ingesta que contenga un procesador de inferencia. Esto permitirá generar la representación vectorial usando el modelo subido:

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" } } } ] }

Crea un nuevo índice que contenga el text_embedding.predicted_value de campo de tipo dense_vector para almacenar las incrustaciones vectoriales generadas para cada documento:

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

Reindexa los documentos usando la nueva tubería de ingesta para generar las incrustaciones de texto como el campo adicional text_embedding.predicted_value en cada documento:

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

Ahora podemos usar la opción Knn en la misma API de búsqueda usando el nuevo índice vector-search-rodents, como se muestra en el siguiente ejemplo:

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

La conversión del objeto de resultado JSON mediante desmaravillamiento se realiza exactamente de la misma manera que en el ejemplo de búsqueda por palabra clave. Las constantes K y NumCandidates nos permiten configurar el número de documentos vecinos que devolver y el número de candidatos a considerar por fragmento. Ten en cuenta que aumentar el número de candidatos incrementa la precisión de los resultados pero conduce a una consulta de mayor duración a medida que se realizan más comparaciones.

Cuando el código se ejecuta usando la consulta What do Gophers eat?, los resultados devuelto se ven similares a los siguientes, destacando que el artículo de Gopher contiene la información aplicar, a diferencia de la búsqueda por palabra clave anterior:

[ {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 ]

Enfoque 2: API de inferencia de rostros de abrazo

Otra opción es generar estas mismas incrustaciones fuera de Elasticsearch e ingerirlas como parte de tu documento. Como esta opción no emplea un nodo de aprendizaje automático de Elasticsearch, puede hacer en la capa libre.

Hugging Face expone una API de inferencia gratis y limitada a la velocidad que, con una cuenta y un token de API, puede usar para generar manualmente las mismas incrustaciones para experimentación y prototipado que te ayude a empezar. No se recomienda para uso en producción. Invocar tus propios modelos localmente para generar embeddings o usar la API de pago también puede hacer con un enfoque similar.

En la función GetTextEmbeddingForQuery siguiente usamos la API de inferencia contra nuestra cadena de consulta para generar el vector devuelto de una petición POST al punto final:

// 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 }

El vector resultante, de tipo []float32 , se pasa entonces como QueryVector en lugar de usar la opción QueryVectorBuilder para aprovechar el modelo previamente subido a Elastic.

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

Cabe señalar que las opciones de K y NumCandidates siguen siendo las mismas independientemente de las dos opciones y que se generan los mismos resultados, ya que estamos usando el mismo modelo para generar las incrustaciones

Conclusión

Aquí discutimos cómo realizar búsqueda vectorial en Elasticsearch usando el cliente Elasticsearch Go. Echa un vistazo al repositorio de GitHub para ver todo el código de este serial. Sigue la parte 3 para obtener una visión general de cómo combinar la búsqueda vectorial con las capacidades de búsqueda por palabras clave que se tratan en la primera parte de Go.

Hasta entonces, ¡feliz caza de topos!

Recursos

Realiza consultas de texto con el cliente Elasticsearch Go

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

Desarrollar software en cualquier lenguaje de programación, incluido Go, es comprometer con una vida entera de aprendizaje. A lo largo de su carrera universitaria y profesional, Carly tuvo que adaptar a ser políglota y experimentar con muchos lenguajes de programación, incluyendo Python, C, JavaScript, TypeScript y Java. ¡Pero eso no fue suficiente! ¡Hace poco también empezó a jugar con Go!

Al igual que los animales, los lenguajes de programación y uno de tus autores amables, la búsqueda experimentó una evolución de diferentes prácticas que pueden ser difíciles de elegir para tu propio caso de uso. En este blog, compartiremos una visión general de la búsqueda tradicional por palabras clave junto con un ejemplo usando Elasticsearch y el cliente Elasticsearch Go.

Prerrequisitos

Para seguir con este ejemplo, cerciorar de cumplir los siguientes requisitos:

Instalación de Go versión 1.21 o posterior
Crea tu propio repositorio de Go usando la estructura recomendada y la gestión de paquetes que se menciona en la documentación de Go
Creación de tu propio clúster Elasticsearch, poblado con un conjunto de páginas basadas en roedores , incluyendo para nuestro amable Gopher, de Wikipedia:

Conexión con Elasticsearch

En nuestros ejemplos, emplearemos la API tipada que ofrece el cliente Go. Establecer una conexión segura para cualquier consulta requiere configurar el cliente usando cualquiera de:

Cloud ID y clave API si se emplea Elastic Cloud.
URL del clúster, nombre de usuario, contraseña y el certificado.

Conectarse a nuestro clúster ubicado en Elastic Cloud sería así:

La conexión client puede usar entonces para buscar, como se muestra más adelante.

Búsqueda por palabras clave

La búsqueda por palabras clave es el tipo de búsqueda fundamental con el que estamos familiarizados desde la creación de Archie, el primer motor de búsqueda documentado en Internet escrito en 1990.

Un componente central de la búsqueda por palabras clave es la traducción de documentos a un índice invertido. Exactamente como el índice que se encuentra al final de un libro de texto, un índice invertido contiene un mapeo entre una lista de tokens y su ubicación en cada documento. El siguiente diagrama muestra las etapas clave para generar el índice:

Como se muestra arriba, la generación de tokens en Elasticsearch comprende tres etapas clave:

Despojar personajes innecesarios mediante cero o más char_filters. En nuestro ejemplo, eliminamos elementos HTML dentro del campo body_content mediante el filtro html_strip .
Separar los tokens del contenido con el tokenizador standard, que se divide por espaciado y puntaje clave.
Eliminar tokens no deseados o transformar tokens del flujo de salida del tokenizador usando opciones de cero o más filter, como el filtro de token lowercaseo stemmers como el stemmer snowballpara transformar tokens de nuevo a su raíz de lenguaje.

Búsqueda en Elasticsearch con Go

Al consultar con el cliente Go, especificamos el índice que queremos buscar y pasar en la consulta y otras opciones, igual que en el siguiente ejemplo:

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

En el ejemplo anterior, realizamos una consulta estándar de matchpara encontrar cualquier documento en nuestro índice que contenga la cadena especificada que se pasó a nuestra función. Observar que pasamos un nuevo contexto vacío a la ejecución de búsqueda mediante Do(context.Background()). Además, cualquier error devuelto por Elasticsearch se envía al atributo err para el registro y el manejo de errores.

Los resultados se devuelven en res.Hits.Hits con el atributo _Source que contiene el documento en formato JSON. Para convertir esta fuente a un struct compatible con Go, necesitamos deshacer el marshal de la respuesta JSON usando el paquete de codificación/json de Go, como se muestra en el siguiente ejemplo:

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 }

Buscar y desorganizar la consulta gopher devolverá la página de Wikipedia de Gopher como se esperaba:

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

Sin embargo, si preguntamos What do Gophers eat? no obtenemos exactamente los resultados que queremos:

[]

Una búsqueda sencilla por palabra clave permite que los resultados devuelvan a tu aplicación Go de forma eficiente que funciona de una manera que conocemos por las aplicaciones que empleamos. También funciona muy bien para coincidencias de términos exactos relevantes para escenarios como buscar una compañía o término concreto.

Sin embargo, como vimos arriba, le cuesta identificar el contexto y la semántica debido al problema de la desadaptación del vocabulario. Además, el soporte para formatos de archivo no textuales, como imágenes y audio, resulta complicado.

Conclusión

Aquí hablamos de cómo realizar consultas de texto tradicionales en Elasticsearch usando el cliente Elasticsearch Go. Dado que Go se usa ampliamente para scripting de infraestructura y construcción de servidores sitio web, es útil saber cómo buscar en Go.

Echa un vistazo al repositorio de GitHub para ver todo el código de este serial. Continúa la parte 2 para obtener una visión general de la búsqueda vectorial y cómo realizar la búsqueda vectorial en Go. Hasta entonces, ¡feliz caza de topos!