Tutorial: Uso de un centro de eventos como base de datos vectorial

Artículo
11/19/2024

En este tutorial, aprenderá a usar una instancia de Eventhouse como base de datos vectorial para almacenar y consultar datos vectoriales en Inteligencia en tiempo real. Para obtener información general sobre las bases de datos vectoriales, consulte Bases de datos vectoriales

El escenario dado implica el uso de búsquedas semánticas en páginas de Wikipedia para buscar páginas con temas comunes. Se usa un conjunto de datos de ejemplo disponible, que incluye vectores para decenas de miles de páginas de Wikipedia. Estas páginas se insertaron con un modelo de OpenAI para generar vectores para cada página. Los vectores, junto con algunos metadatos pertinentes relacionados con la página, se almacenan en Eventhouse. Puede usar este conjunto de datos para buscar páginas similares entre sí o para buscar páginas similares a algún tema que desee encontrar. Por ejemplo, supongamos que quiere buscar "mujeres científicas famosas del siglo XIX". Codifique esta frase con el mismo modelo de OpenAI y, a continuación, ejecute una búsqueda de similitud vectorial sobre los datos almacenados de la página de Wikipedia para encontrar las páginas con la similitud semántica más alta.

Específicamente, en este tutorial:

Preparará una tabla en Eventhouse con codificación Vector16 para las columnas vectoriales.
Almacenará datos vectoriales de un conjunto de datos insertado previamente a un Eventhouse.
Insertará para una consulta de lenguaje natural mediante el modelo de OpenAI.
Usará la función KQL series_cosine_similarity para calcular las similitudes entre el vector de inserción de consultas y los de las páginas de la wiki.
Verá las filas de la similitud más alta para obtener las páginas de la wiki más relevantes para la consulta de búsqueda.

Este flujo se puede visualizar de la siguiente manera:

Requisitos previos

Un área de trabajo con una capacidad habilitada para Microsoft Fabric
Una instancia de Eventhouse en el área de trabajo
Un recurso de Azure OpenAI con el modelo text-embedding-ada-002 (versión 2) implementado. Este modelo solo está disponible actualmente en determinadas regiones. Para más información, consulte Crear un recurso.
- Asegúrese de que la autenticación local está habilitada en el recurso de Azure OpenAI.
Descargue el cuaderno de ejemplo del repositorio de GitHub

Nota:

Aunque en este tutorial se usa Azure OpenAI, puede usar cualquier proveedor de modelos de inserción para generar vectores para datos de texto.

Preparación del entorno de Eventhouse

En este paso de configuración, creará una tabla en un centro de eventos con las columnas necesarias y directivas de codificación para almacenar los datos vectoriales.

Vaya a la página de inicio de su área de trabajo en Real-Time Intelligence.
Seleccione el Eventhouse que creó en la sección anterior.
Seleccione la base de datos de destino en la que desea almacenar los datos vectoriales. Si no tiene una base de datos, puede crear una seleccionando Añadir base de datos.

Seleccione Explorar mis datos. Copie o pegue la siguiente consulta KQL para crear una tabla con las columnas necesarias:

.create table Wiki (id:string,url:string,['title']:string,text:string,title_vector:dynamic,content_vector:dynamic,vector_id:long)

Copie o pegue los siguientes comandos para establecer la directiva de codificación de las columnas vectoriales. Ejecute estos comandos secuencialmente.
```
.alter column Wiki.title_vector policy encoding type='Vector16'

.alter column Wiki.content_vector policy encoding type='Vector16'
```

Escritura de datos vectoriales en un Eventhouse

Los pasos siguientes se usan para importar los datos insertados de Wikipedia y escribirlos en un Eventhouse:

Importar cuaderno

Descargue el cuaderno de ejemplo del repositorio de GitHub.
Vaya al entorno de Fabric. En el conmutador de experiencia, elija Desarrollar y, a continuación, el área de trabajo.
Seleccione Importar>Cuaderno>Desde este equipo>Cargar y, después, elija el cuaderno que descargó en un paso anterior.
Una vez completada la importación, abra el cuaderno importado desde el área de trabajo.

Escritura de datos en Eventhouse

Ejecute las celdas para configurar el entorno.

%%configure -f
{"conf":
    {
        "spark.rpc.message.maxSize": "1024"
    }
}

%pip install wget

%pip install openai

Ejecute las celdas para descargar las inserciones procesadas previamente.

import wget

embeddings_url = "https://cdn.openai.com/API/examples/data/vector_database_wikipedia_articles_embedded.zip"

# The file is ~700 MB so it might take some time
wget.download(embeddings_url)

import zipfile

with zipfile.ZipFile("vector_database_wikipedia_articles_embedded.zip","r") as zip_ref:
    zip_ref.extractall("/lakehouse/default/Files/data")

import pandas as pd

from ast import literal_eval

article_df = pd.read_csv('/lakehouse/default/Files/data/vector_database_wikipedia_articles_embedded.csv')
# Read vectors from strings back into a list
article_df["title_vector"] = article_df.title_vector.apply(literal_eval)
article_df["content_vector"] = article_df.content_vector.apply(literal_eval)
article_df.head()

Para escribir en el centro de eventos, escriba el URI del clúster, que se puede encontrar en la página de información general del sistema y el nombre de la base de datos. La tabla se crea en el cuaderno y se hace referencia a ella más adelante en la consulta.
```
# replace with your Eventhouse Cluster URI, Database name, and Table name
KUSTO_CLUSTER =  "Eventhouse Cluster URI"
KUSTO_DATABASE = "Database name"
KUSTO_TABLE = "Wiki"
```

Ejecute las celdas restantes para escribir los datos en Eventhouse. Esta operación puede tardar un poco en ejecutarse.

kustoOptions = {"kustoCluster": KUSTO_CLUSTER, "kustoDatabase" :KUSTO_DATABASE, "kustoTable" : KUSTO_TABLE }

access_token=mssparkutils.credentials.getToken(kustoOptions["kustoCluster"])

#Pandas data frame to spark dataframe
sparkDF=spark.createDataFrame(article_df)

# Write data to a table in Eventhouse
sparkDF.write. \
format("com.microsoft.kusto.spark.synapse.datasource"). \
option("kustoCluster",kustoOptions["kustoCluster"]). \
option("kustoDatabase",kustoOptions["kustoDatabase"]). \
option("kustoTable", kustoOptions["kustoTable"]). \
option("accessToken", access_token). \
option("tableCreateOptions", "CreateIfNotExist").\
mode("Append"). \
save()

Ver los datos en el Eventhouse

En este momento, puede comprobar que los datos se escribieron en el Eventhouse si navega a la página de detalles de la base de datos.

Vaya a la página de inicio de su área de trabajo en Real-Time Intelligence.
Seleccione el elemento de base de datos que se proporcionó en la sección anterior. Debería ver un resumen de los datos escritos en la tabla "Wiki".

Generación de inserción para el término de búsqueda

Ahora que almacenó los datos de la wiki insertados en el Eventhouse, puede usar estos datos como referencia para buscar páginas en un artículo determinado. Para realizar la comparación, inserte el término de búsqueda y, a continuación, realice una comparación entre el término de búsqueda y las páginas de Wikipedia.

Para realizar correctamente una llamada en Azure OpenAI, necesita un punto de conexión, una clave y el ID de implementación.

Nombre de la variable	Valor
endpoint	Este valor se puede encontrar en la sección Claves y punto de conexión al examinar el recurso en Azure Portal. Como alternativa, puede encontrar el valor en Azure OpenAI Studio> Área de juegos > vista Código. Punto de conexión de ejemplo: `https://docs-test-001.openai.azure.com/`.
Clave de API	Este valor se puede encontrar en la sección Claves y punto de conexión al examinar el recurso en Azure Portal. Puede usar KEY1 o KEY2.
Id. de implementación	Este valor se puede encontrar en la sección Implementaciones de Azure OpenAI Studio.

Use la información de la tabla al ejecutar las celdas de Azure OpenAI.

Importante

La autenticación local debe estar habilitada en el recurso de Azure Open AI para poder usar la clave de API.

import openai

openai.api_version = '2022-12-01'
openai.api_base = 'endpoint' # Add your endpoint here
openai.api_type = 'azure'
openai.api_key = 'api key'  # Add your api key here

def embed(query):
  # Creates embedding vector from user query
  embedded_query = openai.Embedding.create(
          input=query,
          deployment_id="deployment id", # Add your deployment id here
          chunk_size=1
  )["data"][0]["embedding"]
  return embedded_query

searchedEmbedding = embed("most difficult gymnastics moves in the olympics")
#print(searchedEmbedding)

Consulta de la similitud

La consulta se ejecuta directamente desde el cuaderno y usa la inserción devuelta del paso anterior en una comparación con las páginas insertadas de Wikipedia almacenadas en el centro de eventos. Esta consulta usa la función de similitud coseno y devuelve los 10 vectores más similares principales.

Ejecute las celdas del cuaderno para ver los resultados de la consulta. Puede cambiar el término de búsqueda y volver a ejecutar la consulta para ver resultados diferentes. También puede comparar una entrada existente en la base de datos de la Wiki para buscar entradas similares.

kustoQuery = "Wiki | extend similarity = series_cosine_similarity(dynamic("+str(searchedEmbedding)+"), content_vector) | top 10 by similarity desc" 
accessToken = mssparkutils.credentials.getToken(KUSTO_CLUSTER)
kustoDf  = spark.read\
    .format("com.microsoft.kusto.spark.synapse.datasource")\
    .option("accessToken", accessToken)\
    .option("kustoCluster", KUSTO_CLUSTER)\
    .option("kustoDatabase", KUSTO_DATABASE)\
    .option("kustoQuery", kustoQuery).load()

# Example that uses the result data frame.
kustoDf.show()

Limpieza de recursos

Cuando termine el tutorial, puede eliminar los recursos que creó para evitar incurrir en otros costos. Para eliminar los recursos, siga estos pasos:

Vaya a la página principal del área de trabajo.
Elimine el cuaderno que haya creado en este tutorial.
Elimine el Eventhouse o la base de datos usados en este tutorial.

Compartir a través de