Compartilhar via

Tutorial: usar um Eventhouse como banco de dados de vetores

  • Artigo

Neste tutorial, você aprende a usar um Eventhouse como banco de dados de vetores para armazenar e consultar dados de vetores em Inteligência em Tempo Real. Para obter informações gerais sobre bancos de dados de vetores, consulte Bancos de dados de vetores

O cenário fornecido envolve o uso de pesquisas semânticas nas páginas da Wikipédia para encontrar páginas com temas comuns. Você usa um conjunto de dados de exemplo disponível, que inclui vetores para dezenas de milhares de páginas da Wikipédia. Essas páginas foram inseridas a um modelo OpenAI a fim de produzir vetores para cada página. Os vetores, juntamente com alguns metadados pertinentes relacionados à página, são então armazenados em um Eventhouse. Você pode usar esse conjunto de dados para encontrar páginas semelhantes entre si ou para encontrar páginas semelhantes a algum tema que deseja encontrar. Por exemplo, digamos que você queira procurar "cientistas famosas do século XIX". Você codifica essa frase usando o mesmo modelo OpenAI e executa uma pesquisa de similaridade de vetores nos dados armazenados da página da Wikipédia para encontrar as páginas com a mais alta semelhança semântica.

Especificamente, neste tutorial você vai:

  • Preparar uma tabela no Eventhouse com codificação Vector16 para as colunas de vetores.
  • Armazenar dados de vetores de um conjunto de dados pré-inserido em um Eventhouse.
  • Inserir uma consulta em linguagem natural usando o modelo Open AI.
  • Usar a função KQL series_cosine_similarity para calcular as semelhanças entre o vetor de inserção de consulta e as páginas do wiki.
  • Exibir as linhas de maior similaridade para obter as páginas do wiki mais relevantes para sua consulta de pesquisa.

Esse fluxo pode ser visualizado da seguinte maneira:

Esquema do Eventhouse como fluxo de trabalho de banco de dados de vetores.

Pré-requisitos

  • Um espaço de trabalho com uma capacidade habilitada para o Microsoft Fabric
  • Uma eventhouse no seu espaço de trabalho
  • Um recurso do Azure OpenAI com o modelo text-embedding-ada-002 (Versão 2) implantado. Este modelo está atualmente disponível apenas em determinadas regiões. Para obter mais informações, consulte Criar um recurso.
    • Verifique se a autenticação local está habilitada em seu recurso OpenAI do Azure.
  • Baixe o notebook de exemplo do repositório GitHub

Observação

Embora este tutorial use o OpenAI do Azure, você pode usar qualquer fornecedor de modelo de inserção a fim de gerar vetores para dados de texto.

Preparar o ambiente do Eventhouse

Nesta etapa de configuração, você cria uma tabela em um Eventhouse com as colunas e as políticas de codificação necessárias para armazenar os dados de vetores.

  1. Navegue até a home page do espaço de trabalho na Inteligência em tempo Real.

  2. Selecione o Eventhouse que você criou nos pré-requisitos.

  3. Selecione o banco de dados de destino em que deseja armazenar os dados de vetores. Se não tiver um banco de dados, você poderá criar um selecionando Adicionar banco de dados.

  4. Selecione Explorar meus dados. Copie/cole a seguinte consulta KQL para criar uma tabela com as colunas necessárias:

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

  5. Copie/cole os comandos a seguir para definir a política de codificação das colunas de vetores. Execute esses comandos sequencialmente.

    .alter column Wiki.title_vector policy encoding type='Vector16'

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

Gravar dados de vetores em um Eventhouse

As seguintes etapas são usadas para importar os dados inseridos da Wikipédia e gravá-los em um Eventhouse:

Importar notebook

  1. Baixe o notebook de exemplo do repositório GitHub.
  2. Navegue até seu ambiente do Fabric. No seletor de experiências, escolha Desenvolver e, em seguida, selecione seu workspace.
  3. Selecione Importar>Notebook>Deste computador>Carregar e escolha o notebook que você baixou em uma etapa anterior.
  4. Depois que a importação for concluída, abra o notebook importado do seu workspace.

Gravar dados no Eventhouse

  1. Execute as células para configurar seu ambiente.

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

    %pip install wget

    %pip install openai

  2. Execute as células para baixar as inserções pré-computadas.

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

  3. Para gravar no eventhouse, insira o URI do Cluster, que pode ser encontrado na página de visão geral do sistema, e o nome do banco de dados. A tabela é criada no notebook e, posteriormente, referenciada na consulta.

    # replace with your Eventhouse Cluster URI, Database name, and Table name
KUSTO_CLUSTER =  "Eventhouse Cluster URI"
KUSTO_DATABASE = "Database name"
KUSTO_TABLE = "Wiki"

  4. Execute as células restantes para gravar os dados no Eventhouse. Essa operação pode levar algum tempo para ser executada.

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

Exibir os dados no Eventhouse

Nesse ponto, você pode verificar se os dados foram gravados no Eventhouse navegando até a página de detalhes do banco de dados.

  1. Navegue até a home page do espaço de trabalho na Inteligência em tempo Real.
  2. Selecione o item do banco de dados fornecido na seção anterior. Você deverá ver um resumo dos dados que foram gravados na tabela "Wiki".

Gerar inserção para o termo de pesquisa

Agora que armazenou os dados do wiki inseridos em seu Eventhouse, você pode usar esses dados como referência para localizar páginas de um artigo específico. Para fazer a comparação, você insere o termo de pesquisa e faz uma comparação entre o termo de pesquisa e as páginas da Wikipédia.

Para fazer uma chamada com êxito no OpenAI do Azure, você precisa de um ponto de extremidade, uma chave e uma ID de implantação.

Nome da variável Valor
endpoint Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no Portal do Azure. Como alternativa, você pode encontrar o valor no Estúdio OpenAI do Azure> Playground > Exibição de Código. Um ponto de extremidade de exemplo é: https://docs-test-001.openai.azure.com/.
Chave de API Esse valor pode ser encontrado na seção Chaves e Ponto de Extremidade ao examinar seu recurso no Portal do Azure. Você pode usar KEY1 ou KEY2.
ID de Implantação Esse valor pode ser encontrado na seção Implantações no Estúdio OpenAI do Azure.

Use as informações da tabela ao executar as células do OpenAI do Azure.

Importante

A autenticação local deve ser habilitada no recurso Open AI do Azure para usar a chave 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)

Consultar a semelhança

A consulta é executada diretamente por meio do notebook e usa a inserção retornada da etapa anterior em uma comparação com as páginas inseridas da Wikipédia armazenadas em seu Eventhouse. Essa consulta usa a função de similaridade de cosseno e retorna os 10 vetores mais semelhantes.

Execute as células do notebook para ver os resultados da consulta. Você pode alterar o termo de pesquisa e executar novamente a consulta para ver resultados diferentes. Você também pode comparar uma entrada existente no banco de dados Wiki para encontrar entradas semelhantes.

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

Captura de tela da célula em execução de resultados de similaridade.

Limpar os recursos

Ao concluir o tutorial, você poderá excluir os recursos criados para evitar incorrer em outros custos. Para excluir os recursos, siga estas etapas:

  1. Navegue até a home page do espaço de trabalho.
  2. Exclua o notebook criado neste tutorial.
  3. Exclua o Eventhouse ou o banco de dados usado neste tutorial.