Crie um app de pesquisa de patentes com o AlloyDB, a pesquisa vetorial e a Vertex AI.

1. Visão geral

Em diferentes setores, a pesquisa de patentes é uma ferramenta essencial para entender o cenário competitivo, identificar possíveis oportunidades de licenciamento ou aquisição e evitar violações de patentes existentes.

A pesquisa de patentes é vasta e complexa. Analisar inúmeros resumos técnicos para encontrar inovações relevantes é uma tarefa difícil. As pesquisas tradicionais baseadas em palavras-chave costumam ser imprecisas e demoradas. Os resumos são longos e técnicos, o que dificulta a compreensão rápida da ideia principal. Isso pode fazer com que os pesquisadores percam patentes importantes ou desperdicem tempo com resultados irrelevantes.

O tempero secreto por trás dessa revolução é a pesquisa vetorial. Em vez de depender da correspondência simples de palavras-chave, a pesquisa vetorial transforma o texto em representações numéricas (embeddings). Isso permite pesquisar com base no significado da consulta, não apenas nas palavras específicas usadas. No mundo das pesquisas bibliográficas, isso é uma revolução. Imagine encontrar uma patente para um "monitor de frequência cardíaca vestível" mesmo que a frase exata não seja usada no documento.

Objetivo

Neste codelab, vamos trabalhar para tornar o processo de pesquisa de patentes mais rápido, intuitivo e incrivelmente preciso usando o AlloyDB, a extensão pgvector e o Gemini 1.5 Pro, Embeddings e Vector Search.

O que você vai criar

Neste laboratório, você vai:

  1. Criar uma instância do AlloyDB e carregar dados do conjunto de dados públicos de patentes
  2. Ativar extensões de modelo de IA generativa e pgvector no AlloyDB
  3. Gerar embeddings com base nos insights
  4. Realizar pesquisa de similaridade de cossenos em tempo real para o texto de pesquisa do usuário
  5. Implantar a solução no Cloud Functions sem servidor

O diagrama a seguir representa o fluxo de dados e as etapas envolvidas na implementação.

8b73c40a0d12e194.png

 High level diagram representing the flow of the Patent Search Application with AlloyDB

Requisitos

  • Use um navegador, como o Chrome ou o Firefox.
  • Ter um projeto do Google Cloud com o faturamento ativado.

2. Antes de começar

Criar um projeto

  1. No console do Google Cloud, na página de seletor de projetos, selecione ou crie um projeto do Google Cloud.
  2. Verifique se o faturamento está ativado para seu projeto do Cloud. Saiba como verificar se o faturamento está ativado em um projeto .
  3. Você vai usar o Cloud Shell, um ambiente de linha de comando executado no Google Cloud que vem pré-carregado com bq. Clique em "Ativar o Cloud Shell" na parte de cima do console do Google Cloud.

Imagem do botão "Ativar o Cloud Shell"

  1. Depois de se conectar ao Cloud Shell, verifique se sua conta já está autenticada e se o projeto está configurado com seu ID do projeto usando o seguinte comando:
gcloud auth list
  1. Execute o comando a seguir no Cloud Shell para confirmar se o comando gcloud sabe sobre seu projeto.
gcloud config list project
  1. Se o projeto não estiver definido, use este comando:
gcloud config set project <YOUR_PROJECT_ID>
  1. Ative as APIs necessárias. Use um comando gcloud no terminal do Cloud Shell:
gcloud services enable alloydb.googleapis.com \ 
                       compute.googleapis.com \
                       cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       run.googleapis.com \
                       cloudbuild.googleapis.com \
                       cloudfunctions.googleapis.com \
                       aiplatform.googleapis.com

A alternativa ao comando gcloud é pesquisar cada produto no console ou usar este link.

Consulte a documentação para ver o uso e os comandos gcloud.

3. Preparar o banco de dados do AlloyDB

Vamos criar um cluster, uma instância e uma tabela do AlloyDB em que o conjunto de dados de patentes será carregado.

Criar objetos do AlloyDB

Crie um cluster e uma instância com o ID do cluster "patent-cluster", a senha "alloydb", compatível com o PostgreSQL 15 e a região como "us-central1", a rede definida como "default". Defina o ID da instância como "patent-instance". Clique em "CRIAR CLUSTER". Os detalhes para criar um cluster estão neste link: https://cloud.google.com/alloydb/docs/cluster-create.

Criar uma tabela

É possível criar uma tabela usando a instrução DDL abaixo no AlloyDB Studio:

CREATE TABLE patents_data ( id VARCHAR(25), type VARCHAR(25), number VARCHAR(20), country VARCHAR(2), date VARCHAR(20), abstract VARCHAR(300000), title VARCHAR(100000), kind VARCHAR(5), num_claims BIGINT, filename VARCHAR(100), withdrawn BIGINT) ;

Ativar extensões

Para criar o app de pesquisa de patentes, vamos usar as extensões pgvector e google_ml_integration. A extensão pgvector permite armazenar e pesquisar embeddings de vetor. A extensão google_ml_integration oferece funções que você usa para acessar endpoints de previsão da Vertex AI e receber previsões em SQL. Ative essas extensões executando os seguintes DDLs:

CREATE EXTENSION vector;
CREATE EXTENSION google_ml_integration;

Conceder permissão

Execute a instrução abaixo para conceder a execução na função "embedding":

GRANT EXECUTE ON FUNCTION embedding TO postgres;

Conceder o papel de usuário da Vertex AI à conta de serviço do AlloyDB

No console do Cloud IAM, conceda à conta de serviço do AlloyDB (que se parece com isto: service-<<PROJECT_NUMBER>>@gcp-sa-alloydb.iam.gserviceaccount.com) acesso à função "Usuário da Vertex AI". PROJECT_NUMBER vai ter o número do seu projeto.

Como alternativa, você também pode conceder o acesso usando o comando gcloud:

PROJECT_ID=$(gcloud config get-value project)


gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:service-$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")@gcp-sa-alloydb.iam.gserviceaccount.com" \
--role="roles/aiplatform.user"

Altere a tabela para adicionar uma coluna de vetor para armazenar os embeddings.

Execute a DDL abaixo para adicionar o campo "abstract_embeddings" à tabela que acabamos de criar. Essa coluna vai permitir o armazenamento dos valores vetoriais do texto:

ALTER TABLE patents_data ADD column abstract_embeddings vector(3072);

4. Carregar dados de patentes no banco de dados

Os conjuntos de dados públicos do Google Patentes no BigQuery serão usados como nosso conjunto de dados. Vamos usar o AlloyDB Studio para executar nossas consultas. O repositório alloydb-pgvector inclui o script insert_into_patents_data.sql que vamos executar para carregar os dados de patentes.

  1. No console do Google Cloud, abra a página AlloyDB.
  2. Selecione o cluster recém-criado e clique na instância.
  3. No menu de navegação do AlloyDB, clique em AlloyDB Studio. Faça login com suas credenciais.
  4. Abra uma nova guia clicando no ícone Nova guia à direita.
  5. Copie a instrução de consulta insert do script insert_into_patents_data.sql mencionado acima para o editor. Você pode copiar de 50 a 100 instruções de inserção para uma demonstração rápida desse caso de uso.
  6. Clique em Executar. Os resultados da consulta aparecem na tabela Resultados.

5. Criar embeddings para dados de patentes

Primeiro, vamos testar a função de incorporação executando a seguinte consulta de exemplo:

SELECT embedding( 'gemini-embedding-001', 'AlloyDB is a managed, cloud-hosted SQL database service.');

Isso vai retornar o vetor de embeddings, que parece uma matriz de números de ponto flutuante, para o texto de exemplo na consulta. Ela tem esta aparência:

25a1d7ef0e49e91e.png

Atualizar o campo de vetor abstract_embeddings

Execute o DML abaixo para atualizar os resumos de patentes na tabela com os incorporações correspondentes:

UPDATE patents_data set abstract_embeddings = embedding( 'gemini-embedding-001', abstract);

6. Fazer pesquisa vetorial

Agora que a tabela, os dados e os embeddings estão prontos, vamos realizar a pesquisa vetorial em tempo real para o texto de pesquisa do usuário. Para testar isso, execute a consulta abaixo:

SELECT id || ' - ' || title as literature FROM patents_data ORDER BY abstract_embeddings <=> embedding('gemini-embedding-001', 'A new Natural Language Processing related Machine Learning Model')::vector LIMIT 10;

Nesta consulta,

  1. O texto de pesquisa do usuário é: "Um novo modelo de machine learning relacionado ao processamento de linguagem natural".
  2. Estamos convertendo em embeddings no método embedding() usando o modelo: gemini-embedding-001.
  3. "<=>" representa o uso do método de distância de similaridade de cosseno.
  4. Estamos convertendo o resultado do método de embedding para o tipo de vetor para torná-lo compatível com os vetores armazenados no banco de dados.
  5. "LIMIT 10" representa que estamos selecionando as 10 correspondências mais próximas do texto de pesquisa.

Confira o resultado:

8e77af965fc787ae.png

Como você pode observar nos resultados, as correspondências são bem próximas ao texto da pesquisa.

7. Levar o aplicativo para a Web

Tudo pronto para levar esse app para a Web? Siga as etapas abaixo:

  1. Acesse o editor do Cloud Shell e clique no ícone "Cloud Code — Fazer login" no canto inferior esquerdo (barra de status) do editor. Selecione seu projeto atual do Google Cloud com o faturamento ativado e verifique se você fez login no mesmo projeto no Gemini (no canto direito da barra de status).
  2. Clique no ícone do Cloud Code e aguarde até que a caixa de diálogo do Cloud Code apareça. Selecione "Novo aplicativo" e, no pop-up "Criar novo aplicativo", selecione "Aplicativo do Cloud Functions":

a800ee1eb6cb8a5b.png

Na página 2/2 do pop-up "Criar novo aplicativo", selecione "Java: Hello World", insira o nome do projeto como "alloydb-pgvector" no local de sua preferência e clique em "OK":

5b09446ecf7d4f8d.png

  1. Na estrutura do projeto resultante, procure pom.xml e substitua pelo conteúdo do arquivo do repositório. Ele precisa ter essas dependências, além de mais algumas:

2b3a3cdd75a57711.png

  1. Substitua o arquivo HelloWorld.java pelo conteúdo do arquivo repo.

Substitua os valores abaixo pelos seus reais:

String ALLOYDB_DB = "postgres";
String ALLOYDB_USER = "postgres";
String ALLOYDB_PASS = "*****";
String ALLOYDB_INSTANCE_NAME = "projects/<<YOUR_PROJECT_ID>>/locations/us-central1/clusters/<<YOUR_CLUSTER>>/instances/<<YOUR_INSTANCE>>";
//Replace YOUR_PROJECT_ID, YOUR_CLUSTER, YOUR_INSTANCE with your actual values

A função espera o texto de pesquisa como parâmetro de entrada com a chave "search". Nesta implementação, retornamos apenas uma correspondência mais próxima do banco de dados:

// Get the request body as a JSON object.
JsonObject requestJson = new Gson().fromJson(request.getReader(), JsonObject.class);
String searchText = requestJson.get("search").getAsString();

//Sample searchText: "A new Natural Language Processing related Machine Learning Model";
BufferedWriter writer = response.getWriter();
String result = "";
HikariDataSource dataSource = AlloyDbJdbcConnector();

try (Connection connection = dataSource.getConnection()) {
   //Retrieve Vector Search by text (converted to embeddings) using "Cosine Similarity" method
   try (PreparedStatement statement = connection.prepareStatement("SELECT id || ' - ' || title as literature FROM patents_data ORDER BY abstract_embeddings <=> embedding('tgemini-embedding-001', '" + searchText + "' )::vector LIMIT 1")) {
     ResultSet resultSet = statement.executeQuery();
     resultSet.next();
     String lit = resultSet.getString("literature");
     result = result + lit + "\n";
     System.out.println("Matching Literature: " + lit);
 }
writer.write("Here is the closest match: " + result);
}
  1. Para implantar a função do Cloud Functions que você acabou de criar, execute o seguinte comando no terminal do Cloud Shell. Não se esqueça de navegar até a pasta do projeto correspondente usando o comando:
cd alloydb-pgvector

Em seguida, execute o comando:

gcloud functions deploy patent-search --gen2 --region=us-central1 --runtime=java11 --source=. --entry-point=cloudcode.helloworld.HelloWorld --trigger-http

ETAPA IMPORTANTE:

Depois de iniciar a implantação, você poderá ver as funções no console do Cloud Run Functions do Google. Pesquise e abra a função recém-criada, edite as configurações e mude o seguinte:

  1. Acesse "Configurações de ambiente de execução, build, conexões e segurança"
  2. Aumente o tempo limite para 180 segundos
  3. Acesse a guia CONEXÕES:

4e83ec8a339cda08.png

  1. Em "Configurações de entrada", verifique se a opção "Permitir todo o tráfego" está selecionada.
  2. Em "Configurações de saída", clique no menu suspenso "Rede" e selecione a opção "Adicionar novo conector VPC". Siga as instruções na caixa de diálogo que aparece:

8126ec78c343f199.png

  1. Forneça um nome para o conector da VPC e verifique se a região é a mesma da sua instância. Deixe o valor da rede como padrão e defina a sub-rede como "Intervalo de IP personalizado" com o intervalo de IP 10.8.0.0 ou algo semelhante que esteja disponível.
  2. Expanda MOSTRAR CONFIGURAÇÕES DE ESCALONAMENTO e verifique se a configuração está exatamente assim:

7baf980463a86a5c.png

  1. Clique em "CRIAR". O conector vai aparecer nas configurações de saída.
  2. Selecione o conector recém-criado.
  3. Opte por todo o tráfego ser roteado por esse conector de VPC.

8. Testar o aplicativo

Depois da implantação, o endpoint vai aparecer no seguinte formato:

https://us-central1-YOUR_PROJECT_ID.cloudfunctions.net/patent-search

Para testar, execute o seguinte comando no terminal do Cloud Shell:

gcloud functions call patent-search --region=us-central1 --gen2 --data '{"search": "A new Natural Language Processing related Machine Learning Model"}'

Resultado:

da3dcfac7d024031.png

Também é possível testar na lista Cloud Functions. Selecione a função implantada e navegue até a guia "TESTING". Na caixa de texto da seção "Configurar evento acionador" para o JSON de solicitação, insira o seguinte:

{"search": "A new Natural Language Processing related Machine Learning Model"}

Clique no botão TESTAR A FUNÇÃO para ver o resultado no lado direito da página:

e21f806d661996ff.png

Pronto! É simples assim realizar uma pesquisa de vetor de similaridade usando o modelo de embeddings em dados do AlloyDB.

9. Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados nesta postagem, siga estas etapas:

  1. No console do Google Cloud, acesse Gerenciar
  2. página recursos.
  3. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir.
  4. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

10. Parabéns

Parabéns! Você realizou uma pesquisa de similaridade usando o AlloyDB, o pgvector e a pesquisa vetorial. Ao combinar os recursos do AlloyDB, da Vertex AI e da Pesquisa vetorial, demos um grande passo para tornar as pesquisas de literatura acessíveis, eficientes e realmente orientadas por significado.