Crie um app de recomendação de roupas com tecnologia de IA usando o AlloyDB e os ambientes de execução sem servidor

1. Visão geral

Imagine um app de moda que não apenas ajuda você a encontrar a roupa perfeita, mas também oferece dicas de estilo em tempo real, tudo graças ao poder da integração de IA generativa de ponta. Nesta palestra, vamos mostrar como criamos um app desse tipo usando os recursos de pesquisa vetorial do AlloyDB, juntamente com o índice ScaNN do Google, permitindo pesquisas ultrarrápidas de roupas combinando e oferecendo recomendações de moda instantâneas.

Também vamos explicar como o índice ScaNN do AlloyDB otimiza consultas complexas para gerar sugestões de estilo personalizadas. Também vamos usar o Gemini e o Imagen, modelos de IA generativa avançados, para oferecer inspiração de estilo criativo e até mesmo visualizar seus looks personalizados. Todo o aplicativo é criado em uma arquitetura sem servidor, garantindo uma experiência perfeita e escalonável para os usuários.

O desafio:ao oferecer sugestões de roupas personalizadas, o app pretende ajudar pessoas que têm dificuldade em decidir o que vestir. Isso também ajuda a evitar o cansaço de tomar decisões ao planejar roupas.

A solução:o app de recomendação de roupas resolve o problema de oferecer aos usuários uma experiência de moda inteligente, personalizada e envolvente, mostrando os recursos do AlloyDB, da IA generativa e das tecnologias sem servidor.

O que você vai criar

Neste laboratório, você vai:

1. Criar uma instância do AlloyDB e carregar o conjunto de dados de e-commerce
2. Ativar as extensões pgvector e de modelo de IA generativa no AlloyDB
3. Gerar embeddings com base na descrição do produto
4. Implantar a solução no Cloud Run Functions sem servidor
5. Faça upload de uma imagem para o Gemini e gere um comando de descrição de imagem.
6. Gerar resultados da pesquisa com base em comandos combinados com embeddings de conjuntos de dados de e-commerce.
7. Adicione mais comandos para personalizar e gerar recomendações de estilo.
8. Implantar a solução no Cloud Run Functions sem servidor

Requisitos

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

2. Arquitetura

A arquitetura de alto nível do app é a seguinte:

As seções a seguir destacam o fluxo contextual do tutorial:

Ingestão:

A primeira etapa é ingerir os dados do varejo (inventário, descrições de produtos, interações com clientes) no AlloyDB.

Analytics Engine:

Vamos usar o AlloyDB como mecanismo de análise para realizar o seguinte:

1. Extração de contexto:o mecanismo analisa os dados armazenados no AlloyDB para entender as relações entre produtos, categorias, comportamento do cliente etc., conforme aplicável.
2. Criação de embeddings:embeddings (representações matemáticas de texto) são gerados para a consulta do usuário e para as informações armazenadas no AlloyDB.
3. Pesquisa vetorial:o mecanismo realiza uma pesquisa de similaridade, comparando o embedding da consulta aos embeddings das descrições, avaliações e outros dados relevantes do produto. Isso identifica os 25 "vizinhos mais próximos" mais relevantes.

Recomendação do Gemini:

A matriz de bytes da imagem é transmitida ao modelo do Gemini pela API Vertex AI, junto com o comando que pede uma descrição textual da parte de cima e sugestões de peças de baixo.

RAG e pesquisa vetorial do AlloyDB:

A descrição da parte de cima é usada para consultar o banco de dados. A consulta converte o texto da pesquisa (recomendação do modelo do Gemini para roupas de baixo correspondentes) em embeddings e realiza uma pesquisa vetorial nos embeddings armazenados no banco de dados para encontrar os vizinhos mais próximos (resultados correspondentes). Os embeddings de vetor no banco de dados do AlloyDB são indexados usando o índice ScaNN para melhorar o recall.

Geração de imagens de resposta:

As respostas validadas são estruturadas em uma matriz JSON, e todo o mecanismo é empacotado em uma função do Cloud Run sem servidor invocada pelo Agent Builder.

Geração de imagens com a Imagen:

O comando de estilo do usuário, uma recomendação selecionada pelo usuário e todas as solicitações de personalização são combinados para solicitar ao Imagen 3 uma imagem existente. A imagem de estilo é gerada com base nesse comando usando a API Vertex AI.

3. 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.
4. 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 seguinte comando:

gcloud auth list

5. Execute o comando a seguir para confirmar que os futuros comandos gcloud vão identificar seu projeto corretamente.

gcloud config list project

6. Se o projeto não estiver definido, use o seguinte comando para configurá-lo explicitamente:

gcloud config set project <YOUR_PROJECT_ID>

7. Ativar as APIs necessárias

Siga o link para ativar as APIs.

Se você não ativar alguma API, é possível fazer isso durante a implementação.

Para mais informações sobre o uso e os comandos gcloud, consulte a documentação.

4. Configuração do banco de dados

Neste laboratório, vamos usar o AlloyDB como banco de dados para armazenar o conjunto de dados de e-commerce de varejo. Ele usa clusters para armazenar todos os recursos, como bancos de dados e registros. Cada cluster tem uma instância principal que fornece um ponto de acesso aos dados. As tabelas são o recurso real que armazena dados.

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

criar um cluster e uma instância

1. No Console do Google Cloud, pesquise AlloyDB. Uma maneira fácil de encontrar a maioria das páginas no console do Cloud é pesquisar usando a barra de pesquisa do console.
2. Clique em CRIAR CLUSTER

3. Crie um cluster e uma instância com os seguintes valores:

• ID do cluster: "shopping-cluster"
• senha: "alloydb"
• Compatível com PostgreSQL 15
• Região: "us-central1"
• Rede: "default"

4. Em "Rede", quando você seleciona a rede padrão, a seguinte opção aparece. Clique em CONFIGURAR CONEXÃO para configurar uma rede padrão.
   
5. Selecione Usar um intervalo de IP alocado automaticamente e clique em Continuar. Depois de revisar as informações, clique em CRIAR CONEXÃO.

Aguarde a conclusão da criação da rede padrão.

6. Em "Configurar a instância principal", defina o ID da instância como shopping-instance".

7. Clique em CRIAR CLUSTER para concluir a configuração do cluster da seguinte maneira:

A criação do cluster leva cerca de 10 minutos. Quando ele for concluído, o campo Status vai mostrar o status "Pronto". Confira abaixo um exemplo de tela que mostra um cluster pronto para uso.

5. Ingestão de dados

Agora é hora de adicionar uma tabela com os dados da loja. Aguarde a conclusão da criação da instância. Depois de criado, você pode fazer login no AlloyDB usando as credenciais definidas ao criar o cluster.

Autenticar no banco de dados do AlloyDB

1. No console do Google Cloud, acesse AlloyDB. Selecione o cluster primário e clique em AlloyDB Studio na navegação à esquerda:

2. Insira os seguintes detalhes para autenticar no banco de dados do AlloyDB:

• Nome de usuário : "postgres"
• Banco de dados : "postgres"
• Senha : "alloydb"

Depois de se autenticar no AlloyDB Studio, insira os comandos SQL nas guias do Editor. É possível adicionar várias janelas do editor usando o sinal de mais à direita da primeira guia do editor.

Você vai inserir comandos para o AlloyDB nas janelas do Editor, usando as opções "Executar", "Formatar" e "Limpar" conforme necessário.

Ativar extensões

Para criar esse app, 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 e receber previsões em SQL.

1. Ative essas extensões executando os seguintes DDLs:

CREATE EXTENSION IF NOT EXISTS google_ml_integration CASCADE;
CREATE EXTENSION IF NOT EXISTS vector;

2. Verifique se as extensões estão instaladas executando este comando SQL:

select extname, extversion from pg_extension;

Criar uma tabela

1. Crie uma tabela usando a seguinte instrução DDL:

CREATE TABLE
 apparels ( id BIGINT,
   category VARCHAR(100),
   sub_category VARCHAR(50),
   uri VARCHAR(200),
   image VARCHAR(100),
   content VARCHAR(2000),
   pdt_desc VARCHAR(5000),
   embedding vector(768) );

Se o comando acima for executado com sucesso, você poderá ver a tabela em

banco de dados. A imagem a seguir mostra um exemplo:

Ingerir dados

Para este laboratório, temos dados de teste de cerca de 200 registros neste arquivo SQL. Ele contém id, category, sub_category, uri, image e content. Os outros campos serão preenchidos mais tarde no laboratório.

1. Copie as 20 linhas/instruções de inserção do arquivo SQL em uma nova guia do editor no AlloyDB Studio e clique em RUN.

Com base na conta do Cloud Billing do Google que você está usando, o número de linhas

que você pode ingerir pode variar. Se você estiver enfrentando problemas, reduza o número de linhas para 10.

ou menos.

2. Expanda a seção "Explorer" até ver a tabela chamada apparels.
3. Clique no ícone de menu [⋮] e em Consulta. Uma instrução SELECT será aberta em uma nova guia do editor.

4. Clique em Executar para verificar se as linhas foram inseridas.

Conceder permissão ao usuário

Vamos conceder permissão ao usuário postgres para gerar embeddings no AlloyDB.. No AlloyDB Studio, execute a seguinte instrução para conceder direitos de execução na função embedding ao usuário postgres:

GRANT EXECUTE ON FUNCTION embedding TO postgres;

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

Vamos usar os modelos de embedding de texto da Vertex AI para gerar embeddings para os quais a função de usuário da Vertex AI é atribuída à conta de serviço do AlloyDB.

No console do Google Cloud, clique no ícone do terminal do Cloud Shell [] e execute o comando a seguir:

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"

6. Contexto de versões

Para criar uma incorporação, precisamos ter um context, ou seja, todas as informações que queremos incluir em um único campo. Para isso, vamos criar uma descrição do produto que será armazenada na coluna pdt_desc da tabela apparels.

No nosso caso, vamos usar todas as informações sobre cada produto. No entanto, quando você fizer isso com seus próprios dados, fique à vontade para criar os dados da maneira que achar mais adequada para sua empresa.

Na guia "Editor" do AlloyDB Studio, execute o seguinte comando, que atualiza o campo pdt_desc com dados de contexto:

UPDATE
 apparels
SET
 pdt_desc = CONCAT('This product category is: ', category, ' and sub_category is: ', sub_category, '. The description of the product is as follows: ', content, '. The product image is stored at: ', uri)
WHERE
 id IS NOT NULL;

Essa DML cria um resumo de contexto simples usando as informações de todos os campos disponíveis na tabela e outras dependências (se houver no seu caso de uso). Para uma seleção mais precisa de informações e criação de contexto, fique à vontade para processar os dados da maneira que achar mais adequada para sua empresa.

7. Criar embeddings para o contexto

É muito mais fácil para os computadores processarem números do que texto. Um sistema de embedding converte texto em uma série de números de ponto flutuante que representam o texto, não importa como ele seja formulado, qual idioma ele use etc.

Considere descrever um local à beira-mar. Ele pode ser chamado de "on the water", "beachfront", "walk from your room to the ocean", "sur la mer", "на берегу океана" etc. Esses termos parecem diferentes, mas o significado semântico deles ou, na terminologia de aprendizado de máquina, os embeddings precisam estar muito próximos uns dos outros.

Agora que os dados e o contexto estão prontos, vamos executar o SQL para adicionar os embeddings da coluna de descrição do produto ((pdt_desc) à tabela no campo embedding. Há vários modelos de embedding que podem ser usados. Estamos usando text-embedding-005 da Vertex AI.

Use o mesmo modelo de incorporação em todo o projeto.

1. No AlloyDB Studio, execute o comando a seguir para gerar embeddings e atualizar a coluna pdt_desc com embeddings dos dados armazenados:

Se você estiver usando um projeto do Google Cloud criado há algum tempo, talvez seja necessário continuar usando versões mais antigas do modelo text-embedding, como o textembedding-gecko.

UPDATE
 apparels
SET
 embedding = embedding( 'text-embedding-005',
   pdt_desc)
WHERE
 TRUE;

2. Para verificar se os embeddings foram gerados, execute o seguinte comando:

SELECT
 id,
 category,
 sub_category,
 content,
 embedding
FROM
 Apparels
LIMIT 5;

Confira a seguir um exemplo de vetor de embeddings, que se parece com uma matriz de números de ponto flutuante, para o texto de exemplo na consulta:

Projetos do Google Cloud recém-criados no nível sem custo financeiro podem enfrentar problemas de cota em relação ao número de solicitações de incorporação permitidas por segundo para os modelos de incorporação. Sugerimos que você use uma consulta de filtro para o ID e escolha seletivamente de 1 a 5 registros e assim por diante, enquanto gera o embedding.

8. Fazer uma 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.

Suponha que o texto de pesquisa do usuário seja "pink color, casual, pure cotton tops for women".

Para encontrar correspondências para essa consulta, execute a seguinte consulta SQL:

SELECT
id,
category,
sub_category,
content,
pdt_desc AS description
FROM
apparels
ORDER BY
embedding <=> embedding('text-embedding-005',
  'pink color, casual, pure cotton tops for women')::vector
LIMIT
5;

Vamos analisar essa consulta em detalhes:

Nesta consulta,

1. O texto de pesquisa do usuário é: "I want womens tops, pink casual only pure cotton."
2. Estamos convertendo esse texto de pesquisa em embeddings usando o método embedding() e o modelo text-embedding-005. Esta etapa deve parecer familiar depois da última, em que aplicamos a função de incorporação a todos os itens da tabela.
3. "<=>" representa o uso do método de distância SIMILARIDADE DE COSSENO. Confira todas as medidas de similaridade disponíveis na documentação do pgvector.
4. Estamos convertendo o resultado do método de embedding para o tipo de dados vetor para que ele seja compatível com os vetores armazenados no banco de dados.
5. LIMIT 5 representa que queremos extrair os cinco vizinhos mais próximos para o texto de pesquisa.

Confira a seguir um exemplo de resposta dessa consulta SQL:

Como você pode observar nos resultados, as correspondências são bem próximas ao texto da pesquisa. Tente mudar a cor para ver como os resultados mudam.

Índice ScaNN do AlloyDB para desempenho de consultas

Agora digamos que queremos aumentar o desempenho (tempo de consulta), a eficiência e o recall desse resultado da pesquisa vetorial usando o índice ScaNN.

Leia as etapas neste blog para comparar a diferença no resultado com e sem o índice.

Se quiser usar o índice ScaNN, siga estas etapas:

1. Como já temos o cluster, a instância, o contexto e os embeddings criados, basta instalar a extensão ScaNN usando a seguinte instrução:

CREATE EXTENSION IF NOT EXISTS alloydb_scann;

2. Crie o índice do ScaNN:

CREATE INDEX apparel_index ON apparels
USING scann (embedding cosine)
WITH (num_leaves=54);

Na DDL acima:

• apparel_index é o nome do índice.
• apparels é o nome da tabela.
• scann é o método de indexação.
• embedding é a coluna na tabela que você quer indexar.
• cosine é o método de distância que você quer usar com o índice.
• 54 é o número de partições a serem aplicadas a esse índice. Definido como qualquer valor entre 1 e 1.048.576. Para mais informações sobre como decidir esse valor, consulte Ajustar um índice do ScaNN.

Conforme a recomendação no repositório do ScaNN, usamos uma RAIZ QUADRADA do número de pontos de dados. Ao particionar, num_leaves precisa ser aproximadamente a raiz quadrada do número de pontos de dados.

3. Verifique se o índice foi criado usando a consulta:

SELECT * FROM pg_stat_ann_indexes;

4. Faça uma pesquisa vetorial usando a mesma consulta que usamos sem o índice:

select * from apparels
   ORDER BY embedding <=> CAST(embedding('textembedding-gecko', 'white tops for girls without any print') as vector(768))
   LIMIT 20

A consulta acima é a mesma que usamos no laboratório na etapa 8. No entanto, agora temos o campo indexado usando o índice ScaNN.

5. Teste com uma consulta de pesquisa simples com e sem o índice. Para testar sem índice, remova o índice:

white tops for girls without any print

O texto de pesquisa acima na consulta da pesquisa vetorial nos dados de embeddings INDEXADOS resulta em resultados de pesquisa de qualidade e eficiência. A eficiência é muito maior (em termos de tempo de execução: 10,37 ms sem ScaNN e 0,87 ms com ScaNN) com o índice. Para mais informações sobre esse assunto, consulte este blog.

9. Validação de correspondência com o LLM

Antes de continuar e criar um serviço para retornar as melhores correspondências a um aplicativo, vamos usar um modelo de IA generativa para validar se essas respostas em potencial são realmente relevantes e seguras para compartilhar com o usuário.

Verificar se a instância está configurada para o Gemini

1. Verifique se o google_ml_integration já está ativado para o cluster e a instância. No AlloyDB Studio, execute o seguinte comando:

show google_ml_integration.enable_model_support;

Se o valor for "on", pule as próximas duas etapas e vá direto para a configuração

a integração do AlloyDB e da Vertex AI Model.

1. Acesse a instância principal do cluster do AlloyDB e clique em EDITAR INSTÂNCIA PRINCIPAL.

2. Em Opções de configuração avançada, expanda a seção Nova flag de banco de dados e verifique se google_ml_integration.enable_model_support flag está definido como "on" da seguinte maneira:

3. Se não estiver definido como "on", defina como "on" e clique em ATUALIZAR INSTÂNCIA.

Essa etapa leva alguns minutos.

Integração do AlloyDB e da Vertex AI Model

Agora você pode se conectar ao AlloyDB Studio e executar a seguinte instrução DML para configurar o acesso ao modelo do Gemini no AlloyDB, usando o ID do projeto onde indicado. Talvez você receba um aviso de erro de sintaxe antes de executar o comando, mas ele deve funcionar normalmente.

1. No console do Google Cloud, acesse AlloyDB. Selecione o cluster principal e clique em AlloyDB Studio na navegação à esquerda.
2. Vamos usar o gemini-1.5-pro:generateContent disponível por padrão com a extensão google_ml_integration.
3. Para verificar os modelos configurados para acesso, use o seguinte comando no AlloyDB Studio:

select model_id,model_type from google_ml.model_info_view;        

4. Conceda permissão aos usuários do banco de dados para executar a função ml_predict_row e fazer previsões usando os modelos da Vertex AI do Google executando o seguinte comando:

GRANT EXECUTE ON FUNCTION ml_predict_row to postgres;

Se você estiver usando um projeto do Google Cloud e um cluster/instância do AlloyDB criados há algum tempo, poderá fazer upgrade da versão google_ml_integration para a mais recente executando o comando ALTER EXTENSION google_ml_integration UPDATE; para acessar os modelos com suporte integrado.

Como avaliar as respostas

Embora usemos uma consulta grande na próxima seção, em que levamos o aplicativo para o Cloud Run, para garantir que as respostas da consulta sejam razoáveis, ela pode ser difícil de entender.

Vamos analisar as seções individuais que criam a consulta maior que usamos no final.

1. Primeiro, vamos enviar uma solicitação ao banco de dados para receber as cinco correspondências mais próximas de uma consulta do usuário. Estamos codificando a consulta para manter a simplicidade, mas não se preocupe, vamos interpolar na consulta mais tarde.

Incluímos a descrição do produto da tabela apparels e adicionamos dois novos campos: um que combina a descrição com o índice e outro com a solicitação original. Esses dados estão sendo salvos em uma tabela chamada xyz, que é um nome temporário.

CREATE TABLE
 xyz AS
SELECT
 id || ' - ' || pdt_desc AS literature,
 pdt_desc AS content,
 'I want womens tops, pink casual only pure cotton.' AS  user_text
FROM
 apparels
ORDER BY
 embedding <=> embedding('text-embedding-005',
   'I want womens tops, pink casual only pure cotton.')::vector
LIMIT
 5;

A saída dessa consulta será 5 linhas mais semelhantes relacionadas à consulta de usuários. O

A nova tabela xyz vai conter cinco linhas, cada uma com as seguintes colunas:

• literature
• content
• user_text

2. Para determinar a validade das respostas, vamos usar uma consulta complicada em que explicamos como avaliá-las. Ele usa user_text e content na tabela xyz como parte da consulta.

"Read this user search text: ', user_text, 
' Compare it against the product inventory data set: ', content, 
' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match."

3. Usando essa consulta, vamos analisar a "qualidade" das respostas na tabela xyz. Quando falamos em qualidade, nos referimos à precisão das respostas geradas em relação ao que esperamos delas.

CREATE TABLE
  x AS
SELECT
  json_array_elements( google_ml.predict_row( model_id => 'gemini-1.5',
      request_body => CONCAT('{
 "contents": [ 
        { "role": "user", 
          "parts": 
             [ { "text": "Read this user search text: ', user_text, ' Compare it against the product inventory data set: ', content, ' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match." 
             } ]
         } 
] }'
)::json))-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'
AS LLM_RESPONSE
FROM
    xyz;

4. O predict_row retorna o resultado no formato JSON. O código "-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'"" é usado para extrair o texto real desse JSON. Para ver o JSON real retornado, remova esse código.
5. Por fim, para extrair o campo do LLM, basta extrair da tabela x:

SELECT 
LLM_RESPONSE 
FROM 
        x;

6. Isso pode ser combinado em uma única consulta da seguinte forma:

Aviso: se você executou as consultas acima para verificar os resultados intermediários,

exclua/remova as tabelas xyz e x do banco de dados do AlloyDB antes de executar essa consulta;

SELECT
 LLM_RESPONSE
FROM (
 SELECT
 json_array_elements( google_ml.predict_row( model_id => 'gemini-1.5',
     request_body => CONCAT('{
     "contents": [
       { "role": "user",
         "parts":
            [ { "text": "Read this user search text: ', user_text, ' Compare it against the product inventory data set: ', content, ' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match."
            } ]
        }
] }'
)::json))-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'
AS LLM_RESPONSE
   FROM (
         SELECT
           id || ' - ' || pdt_desc AS literature,
           pdt_desc AS content,
         'I want womens tops, pink casual only pure cotton.' user_text
         FROM
           apparels
         ORDER BY
             embedding <=> embedding('text-embedding-005',
             'I want womens tops, pink casual only pure cotton.')::vector
         LIMIT
           5 ) AS xyz ) AS X;

A consulta maior é uma combinação de todas as consultas que executamos nas etapas anteriores. Os resultados informam se há uma correspondência, qual é a porcentagem dela e uma explicação da classificação.

O modelo do Gemini tem streaming ativado por padrão. Portanto, a resposta real é distribuída em várias linhas:

10. Levar o aplicativo para a Web

Agora vamos hospedar esse aplicativo para que ele possa ser acessado pela Internet.

Criar a função do Cloud Run

1. No console do Google Cloud, acesse o Cloud Run Functions usando o seguinte link:

https://console.cloud.google.com/run/create?deploymentType=function

2. Em "Configurar", defina o nome da função como "retail-engine" e selecione a região como "us-central1".
3. Em "URL do endpoint", selecione o ambiente de execução como Java 17.
4. Em "Autenticação", selecione Permitir invocações não autenticadas.
5. Abra Contêineres, volumes, rede, segurança e clique na guia Rede.
6. Selecione Conectar a uma VPC para tráfego de saída e clique em Usar conectores de acesso VPC sem servidor.
7. Em "Rede", clique em Adicionar novo conector de VPC. Ative a API acesso VPC sem servidor, se ela ainda não estiver ativada.
8. Em "Criar conector", defina o nome como alloydb-test-conn.
9. Defina a região como us-central.
10. Deixe o valor da rede como padrão e defina Sub-rede como Intervalo de IP personalizado com o intervalo de IP 10.8.0.0 ou algo semelhante que esteja disponível.
11. Expanda as configurações de Mostrar escalonamento e defina Instâncias mínimas como 2 e Instâncias máximas como 3.
12. Selecione o tipo de instância como f1-micro. Confira abaixo as opções de "Criar conector":

13. Clique em "Criar" para criar o conector.
14. Em "Direcionamento de tráfego", selecione Encaminhar todo o tráfego para a VPC.
15. Clique em Criar para criar a função.

Implantar o aplicativo

Depois que a função for criada, atualize a origem e implante o aplicativo novamente.

1. Em Cloud Run, clique na guia Serviços e na função retail-engine.
2. Clique na guia "Origem". Deixe o Ponto de entrada da função padrão definido como "gcfv2.HelloHttpFunction".
3. Substitua o conteúdo do arquivo HelloHttpFunction.java pelo conteúdo deste arquivo Java.
4. Atualize os detalhes do AlloyDbJdbcConnector no arquivo de acordo com os detalhes da sua instância e cluster do AlloyDB. Substitua $PROJECT_ID pelo ID do projeto do cluster e da instância do AlloyDB.

5. Substitua o conteúdo do arquivo pom.xml pelo conteúdo deste arquivo XML.
6. Clique em Salvar e reimplantar para implantar a função.

11. Testar o aplicativo retail-engine

Depois que a função do Cloud atualizada for implantada, o endpoint vai aparecer no seguinte formato:

Para encontrar o número do projeto na nuvem do Google Cloud, no painel de navegação à esquerda do console do Google Cloud, clique em Visão geral do Cloud > Painel. Em "Informações do projeto", você encontra o número do projeto.

https://retail-engine-PROJECT_NUMBER.us-central1.run.app

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

gcloud functions call retail-engine --region=us-central1 --gen2 --data '{"search": "I want some kids clothes themed on Disney"}'

Se preferir, teste a função do Cloud Run da seguinte maneira:

PROJECT_ID=$(gcloud config get-value project)

curl -X POST https://retail-engine-$PROJECT_NUMBER.us-central1.run.app \
  -H 'Content-Type: application/json' \
  -d '{"search":"I want some kids clothes themed on Disney"}' \
  | jq .

Resultado:

Agora que executamos a pesquisa vetorial de similaridade usando o modelo de embeddings nos dados do AlloyDB, podemos criar o aplicativo que usa esses embeddings com sua imagem e comandos para gerar sugestões de estilo.

12. Entender o fluxo de recomendação de roupas

O app de recomendação de roupas é um aplicativo de inicialização rápida configurado para funcionar com as incorporações que criamos no aplicativo AlloyDB retail-engine, além do Gemini e do Imagen, para gerar opções de estilo de roupas visuais. Também é possível adicionar comandos personalizados e improvisar a recomendação.

Imagine que você faz upload de uma imagem de uma blusa rosa choque no seu guarda-roupa para esse app. Quando você clica em "Mostrar", com base no comando definido no código do aplicativo e nos embeddings no banco de dados do AlloyDB, o aplicativo gera várias opções que correspondem à imagem original. Agora você quer saber como as opções sugeridas ficariam com um colar azul. Então, adicione um comando nessas linhas e clique em "Estilo". A imagem final é gerada combinando a imagem original e as recomendações para criar uma roupa combinando.

Para começar a criar o app de recomendação de roupas, siga estas etapas:

1. No Cloud Run, abra o app retail-engine e anote o URL do aplicativo. Esse é o repositório de embeddings que vamos usar para gerar sugestões semelhantes.
2. No seu ambiente de desenvolvimento integrado, clone o repositório https://github.com/AbiramiSukumaran/outfit-recommender/. Para este exercício, as etapas mostradas são realizadas no ambiente de desenvolvimento integrado do Visual Studio Code.

git clone https://github.com/AbiramiSukumaran/outfit-recommender/

Estes são alguns dos arquivos importantes no diretório do app:

• src/main: diretório de origem em que os arquivos do aplicativo e o HTML residem:
• HelloWorldApplication.java: ponto de entrada principal para o aplicativo Spring Boot.
• HelloWorldController.java: controlador REST do Spring Boot que processa solicitações HTTP relacionadas a um aplicativo de recomendação de roupas. Esse arquivo processa solicitações GET e POST, comandos do usuário, analisa imagens, interage com embeddings do AlloyDB e retorna a resposta final à interface. Esse controlador chama a classe GenerateImageSample.
• GenerateImageSample.java: contém a classe de geração de imagens que se conecta à Vertex AI, formata o comando do usuário, faz chamadas de API para o modelo Imagen e retorna a imagem prevista para a classe do controlador.
• Resources: esse diretório contém imagens e arquivos HTML necessários para gerar a interface do aplicativo.
• Pom.xml: define as dependências e configurações do projeto.

3. No Visual Studio Code, abra o HelloWorldController.java e atualize as instâncias do ID do projeto e do local de acordo com onde a instância do AlloyDB foi criada.

4. Atualize o endpoint para o URL do aplicativo retail-engine que você hospedou antes.

5. Abra o GenerateImageSample.java e atualize o ID do projeto e o local de acordo com a criação da instância do AlloyDB.

Para projetos do nível sem custo financeiro ou se você tiver restrições para gerar imagens com humanos

post_context, você pode modificar o comando post_context para Generate a high-quality, aesthetically pleasing image suitable for fashion recommendations. Show a two piece outfit from the provided image without a human figure and using other details described in the prompt. e gerar recomendações de estilo. Além disso, marque como comentário a configuração paramsMap.put("personGeneration", "allow_adult");.

6. Salve todos os arquivos.

Agora vamos implantar esse aplicativo no ambiente de execução sem servidor do Cloud Run.

13. Levar o aplicativo para a Web

Agora que adicionamos o projeto, o local e os detalhes do app retail-engine relevantes ao aplicativo Spring Boot de recomendação de roupas, podemos implantar o aplicativo no Cloud Run.

Vamos usar o comando gcloud run deploy no terminal do Visual Code Studio para implantar o aplicativo. Para o Visual Studio Code, instale a extensão Google Cloud Code e comece a usar a gcloud CLI.

Para implantar o aplicativo, siga estas etapas:

1. No ambiente de desenvolvimento integrado, abra o diretório clonado e inicie o terminal. No Visual Code Studio, clique em Terminal > Novo terminal.
2. Siga as instruções neste documento para instalar a CLI gcloud.
3. Se você estiver usando o Visual Code Studio, clique em Extensões, pesquise Google Cloud Code e instale a extensão.
4. No terminal do ambiente de desenvolvimento integrado, autentique sua Conta do Google executando o seguinte comando:

gcloud auth application-default login

5. Defina o ID do projeto como o mesmo em que a instância do AlloyDB está localizada.

gcloud config set project PROJECT_ID

6. Inicie o processo de implantação.

gcloud run deploy

7. Em Source code location, pressione "Enter" para selecionar o diretório clonado do GitHub.
8. Em Service name, insira um nome para o serviço, como outfit-recommender, e pressione Enter.
9. Em Please specify a region, insira o local em que a instância do AlloyDB e o aplicativo retail-engine estão hospedados, como 32 para us-central1, e pressione "Enter".

10. Em Allow unauthenticated invocations to [..], digite Y e pressione Enter.

A imagem a seguir mostra o progresso da implantação do aplicativo:

14. Testar o aplicativo de recomendação de roupas

Depois que o aplicativo for implantado com sucesso no Cloud Run, você poderá ver o serviço no console do Google Cloud da seguinte maneira:

1. No console do Google Cloud, acesse Cloud Run.
2. Em "Serviços", clique no serviço recomendador de roupas que você implantou. Você vai ver os serviços retail-engine e outfit-recommender da seguinte maneira:

3. Clique no URL do aplicativo para abrir a interface do app de recomendações.

    The following is a sample URL that you will use:

https://outfit-recommender-22905290964.us-central1.run.app/style

O aplicativo implantado pode ser visto da seguinte maneira:

Como usar o aplicativo

Para começar a usar o aplicativo, siga estas etapas:

1. Clique em Enviar e faça upload de uma foto de uma peça de roupa.
2. Depois que a imagem for enviada, clique em Estilo. O aplicativo usa a imagem como um comando e gera opções na parte de baixo com base no comando do app retail-engine, que inclui embeddings para o conjunto de dados de varejo.

O app gera sugestões de imagens e um comando com base na imagem e em recomendações de estilo. Por exemplo, A white semi-sheer button up blouse with pink floral patterns on it, with balloon sleeves..

3. Você pode transmitir mais comandos para essa recomendação de estilo gerada automaticamente. Por exemplo, STYLE RECOMMENDATION: Cute brown skirt on a curly updo. Make it photo realistic. Accessorize with cherry earrings and burgundy plastic case sling bag..
4. Clique em Mostrar para ver o estilo final.

15. 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 a página Gerenciar recursos.
2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir.
3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

16. Parabéns

Parabéns! Você realizou uma pesquisa de similaridade usando o AlloyDB, o pgvector e a pesquisa vetorial, além de usar o resultado da pesquisa com o modelo avançado do Imagen para gerar recomendações de estilo.