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 a violação 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, dificultando a compreensão rápida da ideia principal. Isso pode levar os pesquisadores a perderem patentes importantes ou a perderem tempo com resultados irrelevantes.

O segredo dessa revolução está na pesquisa vetorial. Em vez de depender da correspondência de palavra-chave simples, a pesquisa vetorial transforma o texto em representações numéricas (embeddings). Isso nos permite pesquisar com base no significado da consulta, não apenas nas palavras específicas usadas. No mundo das pesquisas de literatura, isso é revolucionário. 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, aproveitando o AlloyDB, a extensão pgvector e o Gemini 1.5 Pro, Embeddings e Pesquisa vetorial.

O que você vai criar

Como parte deste 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 uma pesquisa de similaridade de cosseno 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 na nuvem. 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 o ID do seu projeto usando o comando a seguir:
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. Ativar as APIs necessárias É possível usar 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 é pelo console do Google Cloud, pesquisando cada produto ou usando 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 instância com o ID do cluster "patent-cluster", a senha "alloydb", o PostgreSQL 15 compatível 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 vetores. A extensão google_ml_integration fornece funções que você usa para acessar endpoints de previsão da Vertex AI para 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 IAM do Google Cloud, conceda à conta de serviço do AlloyDB (que se parece com esta: service-<<PROJECT_NUMBER>>@gcp-sa-alloydb.iam.gserviceaccount.com) acesso ao papel "Usuário da Vertex AI". PROJECT_NUMBER terá o número do seu projeto.

Como alternativa, também é possível 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"

Alterar a tabela para adicionar uma coluna de vetor para armazenar os embeddings

Execute o 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. É possível 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 embedding executando a seguinte consulta de amostra:

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

Isso deve retornar o vetor de embeddings, que se parece com uma matriz de flutuantes, para o texto de amostra na consulta. Assim:

25a1d7ef0e49e91e.png

Atualizar o campo de vetor abstract_embeddings

Execute o DML abaixo para atualizar os resumos de patentes na tabela com os embeddings correspondentes:

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

6. Realizar 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, 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 aprendizado de máquina relacionado ao processamento de linguagem natural".
  2. Estamos convertendo para 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 do texto de 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ê também fez login no mesmo projeto do 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, na caixa de diálogo Criar novo aplicativo, selecione Aplicativo do Cloud Functions:

a800ee1eb6cb8a5b.png

Na página 2/2 da caixa de diálogo Criar novo aplicativo, selecione Java: Hello World e insira o nome do seu projeto como "alloydb-pgvector" no local preferido e clique em OK:

5b09446ecf7d4f8d.png

  1. Na estrutura do projeto resultante, pesquise pom.xml e substitua-o 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 do repositório.

Substitua os valores abaixo pelos seus valores 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

Observe que a função espera o texto de pesquisa como parâmetro de entrada com a chave "search" e, nesta implementação, estamos retornando 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 que você acabou de criar, execute o comando a seguir no terminal do Cloud Shell. Lembre-se de navegar até a pasta do projeto correspondente primeiro 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 definir a implantação, você poderá ver as funções no console do Cloud Run Functions do Google Cloud. Pesquise a função recém-criada e abra-a, edite as configurações e altere 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 de VPC" e siga as instruções que aparecem na caixa de diálogo:

8126ec78c343f199.png

  1. Forneça um nome para o conector de 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á definida exatamente como a seguinte:

7baf980463a86a5c.png

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

8. Testar o aplicativo

Depois de implantado, o endpoint vai aparecer no seguinte formato:

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

É possível testar no terminal do Cloud Shell executando o seguinte comando:

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 do Cloud Functions. Selecione a função implantada e navegue até a guia "TESTE". Na caixa de texto da seção "Configurar evento de acionamento" 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 e você poderá ver o resultado no lado direito da página:

e21f806d661996ff.png

Pronto! É muito simples realizar a pesquisa vetorial de similaridade usando o modelo de embeddings nos dados do AlloyDB.

9. Liberar espaço

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 a página Gerenciar
  2. 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 Desligar para excluir o projeto.

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, avançamos muito para tornar as pesquisas de literatura acessíveis, eficientes e realmente orientadas por significado.