Como analisar pôsteres de filmes no BigQuery com modelos remotos

Como analisar pôsteres de filmes no BigQuery com modelos remotos

Sobre este codelab

Último mar. 10, 2025 atualizado

Escrito por Alicia Williams

1. Introdução

Neste laboratório, você vai aprender a usar o BigQuery Machine Learning para inferência com modelos remotos ( modelos do Gemini) para analisar imagens de cartazes de filmes e gerar resumos dos filmes com base nos cartazes diretamente no seu data warehouse do BigQuery.

Imagem acima: uma amostra das imagens de pôsteres de filmes que você vai analisar.

O BigQuery é uma plataforma de análise de dados totalmente gerenciada e pronta para IA que ajuda a maximizar o valor dos seus dados, funcionando com vários mecanismos, formatos e nuvens. Um dos principais recursos dele é o BigQuery Machine Learning para inferência, que permite criar e executar modelos de machine learning (ML) usando consultas do GoogleSQL.

Gemini é uma família de modelos de IA generativa desenvolvida pelo Google para casos de uso multimodais.

Como executar modelos de ML usando consultas do GoogleSQL

Em geral, para executar ML ou inteligência artificial (IA) em grandes conjuntos de dados, é preciso utilizar programação detalhada e ter conhecimento de frameworks de ML. Isso limita o desenvolvimento de soluções a um pequeno grupo de especialistas em cada empresa. Com o BigQuery Machine Learning para inferência, os profissionais de SQL podem usar as habilidades e ferramentas de SQL atuais para criar modelos e gerar resultados com LLMs e APIs de IA do Cloud.

Pré-requisitos

• Conhecimentos básicos sobre o Console do Google Cloud
• Experiência com o BigQuery é um diferencial

O que você vai aprender

• Como configurar seu ambiente e sua conta para usar APIs
• Como criar uma conexão de recursos do Cloud no BigQuery
• Como criar um conjunto de dados e uma tabela de objetos no BigQuery para imagens de pôsteres de filmes
• Como criar os modelos remotos do Gemini no BigQuery
• Como solicitar que o modelo do Gemini forneça resumos de filmes para cada pôster
• Como gerar embeddings de texto para o filme representado em cada pôster
• Como usar a VECTOR_SEARCH do BigQuery para combinar imagens de pôsteres de filmes com filmes muito semelhantes no conjunto de dados

O que é necessário

• Uma conta e um projeto do Google Cloud com o faturamento ativado
• Um navegador da Web, como o Chrome

2. Configuração e requisitos

Configuração de ambiente autoguiada

1. Faça login no Console do Google Cloud e crie um novo projeto ou reutilize um existente. Crie uma conta do Gmail ou do Google Workspace, se ainda não tiver uma.

• O Nome do projeto é o nome de exibição para os participantes do projeto. É uma string de caracteres não usada pelas APIs do Google e pode ser atualizada quando você quiser.
• O ID do projeto precisa ser exclusivo em todos os projetos do Google Cloud e não pode ser mudado após a definição. O console do Cloud gera automaticamente uma string exclusiva. Em geral, não importa o que seja. Na maioria dos codelabs, é necessário fazer referência ao ID do projeto, normalmente identificado como PROJECT_ID. Se você não gostar do ID gerado, crie outro aleatório. Se preferir, teste o seu e confira se ele está disponível. Ele não pode ser mudado após essa etapa e permanece durante o projeto.
• Para sua informação, há um terceiro valor, um Número do projeto, que algumas APIs usam. Saiba mais sobre esses três valores na documentação.

Atenção: o ID do projeto é globalmente exclusivo e não pode ser usado por outras pessoas após a seleção. Você é o único usuário com esse ID. Mesmo que um projeto seja excluído, o ID não poderá ser usado novamente.

Observação: se você usa uma conta do Gmail, defina o local padrão como Sem organização. Se você usa uma conta do Google Workspace, escolha um local adequado para a organização.

2. Em seguida, ative o faturamento no console do Cloud para usar os recursos/APIs do Cloud. A execução deste codelab não vai ser muito cara, se tiver algum custo. Para encerrar os recursos e evitar cobranças além deste tutorial, exclua os recursos criados ou exclua o projeto. Novos usuários do Google Cloud estão qualificados para o programa de US$ 300 de avaliação sem custos.

Inicie o Cloud Shell

Embora o Google Cloud e o Spanner possam ser operados remotamente do seu laptop, neste codelab usaremos o Google Cloud Shell, um ambiente de linha de comando executado no Cloud.

No Console do Google Cloud, clique no ícone do Cloud Shell na barra de ferramentas superior à direita:

O provisionamento e a conexão com o ambiente levarão apenas alguns instantes para serem concluídos: Quando o processamento for concluído, você verá algo como:

Essa máquina virtual contém todas as ferramentas de desenvolvimento necessárias. Ela oferece um diretório principal persistente de 5 GB, além de ser executada no Google Cloud. Isso aprimora o desempenho e a autenticação da rede. Neste codelab, todo o trabalho pode ser feito com um navegador. Você não precisa instalar nada.

3. Antes de começar

Há algumas etapas de configuração para trabalhar com modelos do Gemini no BigQuery, incluindo ativar APIs, criar uma conexão de recursos do Cloud e conceder à conta de serviço para a conexão de recursos do Cloud determinadas permissões. Essas etapas são únicas por projeto e serão abordadas nas próximas seções.

Ativar APIs

Alguns recursos que você ativar vão gerar custos, incluindo o BigQuery, o BigQuery ML e a Vertex AI. Em circunstâncias normais, o custo de todos os recursos usados neste tutorial quando executado uma vez não vai exceder US $5. É recomendável conferir o faturamento e confirmar se o exercício é adequado para você.

No Cloud Shell, verifique se o ID do projeto está configurado:

gcloud config set project [YOUR-PROJECT-ID]

Defina a variável de ambiente PROJECT_ID:

PROJECT_ID=$(gcloud config get-value project)

Configure a região padrão a ser usada para os modelos da Vertex AI. Saiba mais sobre os locais disponíveis para a Vertex AI. No exemplo, estamos usando a região us-central1.

gcloud config set compute/region us-central1

Defina a variável de ambiente REGION:

REGION=$(gcloud config get-value compute/region)

Ative todos os serviços necessários:

gcloud services enable bigqueryconnection.googleapis.com \
                       aiplatform.googleapis.com

Saída esperada após a execução de todos os comandos acima:

student@cloudshell:~ (test-project-001-402417)$ gcloud config set project test-project-001-402417
Updated property [core/project].
student@cloudshell:~ (test-project-001-402417)$ PROJECT_ID=$(gcloud config get-value project)
Your active configuration is: [cloudshell-14650]
student@cloudshell:~ (test-project-001-402417)$ 
student@cloudshell:~ (test-project-001-402417)$ gcloud services enable bigqueryconnection.googleapis.com \
                       aiplatform.googleapis.com
Operation "operations/acat.p2-4470404856-1f44ebd8-894e-4356-bea7-b84165a57442" finished successfully.

4. criar uma conexão de recursos do Cloud

Nesta tarefa, você vai criar uma conexão de recursos do Cloud, que permite que o BigQuery acesse arquivos de imagem no Cloud Storage e faça chamadas para a Vertex AI.

1. No console do Google Cloud, acesse o Menu de navegação ( ) e clique em BigQuery.

2. Para criar uma conexão, clique em + ADICIONAR e selecione Conexões com fontes de dados externas.

3. Na lista Tipo de conexão, selecione Modelos remotos, funções remotas e BigLake (recurso do Cloud) da Vertex AI.
4. No campo ID da conexão, digite gemini_conn.
5. Em Tipo de local, selecione Multirregional e, no menu suspenso, selecione a opção multirregional EUA.
6. Mantenha os valores padrão nas outras configurações.

7. Clique em Criar conexão.
8. Clique em ACESSAR CONEXÃO.
9. No painel "Informações da conexão", copie o ID da conta de serviço para um arquivo de texto a fim de usá-lo na próxima tarefa. Observe também que a conexão foi adicionada à seção Conexões externas do projeto no BigQuery Explorer.

5. conceder permissões do IAM à conta de serviço da conexão

Nesta tarefa, você vai conceder permissões do IAM à conta de serviço da conexão de recursos do Cloud por meio de um papel para permitir que ela acesse os serviços da Vertex AI.

1. No console do Google Cloud, no menu de navegação, clique em IAM e administrador.
2. Clique em Permitir acesso.
3. No campo Novos principais, digite o ID da conta de serviço que você copiou anteriormente.
4. No campo Selecionar um papel, digite Vertex AI e selecione o papel Usuário da Vertex AI.

5. Clique em Salvar. Agora, o ID da conta de serviço tem o papel de usuário da Vertex AI.

Observação:esta demonstração analisa um conjunto de dados em um bucket público do Cloud Storage. Ao analisar um conjunto de dados em um bucket não público, a conta de serviço também precisa ter a função "Leitor de objetos do Storage" nesse bucket.

6. criar o conjunto de dados e a tabela de objetos no BigQuery para imagens de pôsteres de filmes

Nesta tarefa, você vai criar um conjunto de dados para o projeto e uma tabela de objetos nele para armazenar as imagens de pôsteres.

O conjunto de dados de imagens de cartazes de filmes usado neste tutorial está armazenado em um bucket público do Google Cloud Storage: gs://cloud-samples-data/vertex-ai/dataset-management/datasets/classic-movie-posters

crie um conjunto de dados

Você vai criar um conjunto de dados para armazenar objetos de banco de dados, incluindo tabelas e modelos, usados neste tutorial.

1. No console do Google Cloud, selecione o Menu de navegação ( ) e clique em BigQuery.
2. No painel Explorer, ao lado do nome do projeto, selecione Ver ações ( ) e Criar conjunto de dados.
3. No painel Criar conjunto de dados, digite as seguintes informações:

• ID do conjunto de dados: gemini_demo
• Tipo de local: selecione Multirregional.
• Multirregional: selecione EUA.

4. Deixe os demais campos com os valores padrão.

5. Clique em Criar conjunto de dados.

Como resultado, o conjunto de dados gemini_demo é criado e listado no projeto no BigQuery Explorer.

Criar a tabela de objetos

O BigQuery armazena dados estruturados, mas também pode acessar dados não estruturados (como imagens de cartazes) por meio de tabelas de objetos.

Para criar uma tabela de objetos, aponte para um bucket do Cloud Storage. A tabela resultante terá uma linha para cada objeto do bucket com o caminho de armazenamento e os metadados.

Para criar a tabela de objetos, você vai usar uma consulta SQL.

1. Clique em + para Criar uma consulta SQL.
2. No editor de consultas, cole a consulta abaixo.

CREATE OR REPLACE EXTERNAL TABLE
  `gemini_demo.movie_posters`
WITH CONNECTION `us.gemini_conn`
OPTIONS (
  object_metadata = 'SIMPLE',
  uris = ['gs://cloud-samples-data/vertex-ai/dataset-management/datasets/classic-movie-posters/*']
  );

3. Execute a consulta. O resultado é uma tabela de objetos movie_posters adicionada ao conjunto de dados gemini_demo e carregada com o URI (o local do Cloud Storage) de cada imagem de pôster de filme.
4. No Explorer, clique em movie_posters e analise o esquema e os detalhes. Você pode consultar a tabela para analisar registros específicos.

7. Criar o modelo remoto do Gemini no BigQuery

Agora que a tabela de objetos foi criada, você pode começar a trabalhar com ela. Nesta tarefa, você vai criar um modelo remoto para o Gemini 1.5 Flash e disponibilizá-lo no BigQuery.

Criar o modelo remoto do Gemini 1.5 Flash

1. Clique em + para Criar uma consulta SQL.
2. No editor de consultas, cole a consulta abaixo e a execute.

CREATE OR REPLACE MODEL `gemini_demo.gemini_1_5_flash`
REMOTE WITH CONNECTION `us.gemini_conn`
OPTIONS (endpoint = 'gemini-1.5-flash')

Como resultado, o modelo gemini_1_5_flash é criado e adicionado ao conjunto de dados gemini_demo na seção de modelos.

3. No Explorer, clique no modelo gemini_1_5_flash e analise os detalhes.

8. Solicitar que o modelo do Gemini forneça resumos de filmes para cada pôster

Nesta tarefa, você vai usar o modelo remoto do Gemini que acabou de criar para analisar as imagens dos postêres de filmes e gerar resumos para cada um deles.

É possível enviar solicitações ao modelo usando a função ML.GENERATE_TEXT, referenciando o modelo nos parâmetros.

Analisar as imagens com o modelo Flash do Gemini 1.5

1. Crie e execute uma nova consulta com a seguinte instrução SQL:

CREATE OR REPLACE TABLE
`gemini_demo.movie_posters_results` AS (
SELECT
    uri,
    ml_generate_text_llm_result
FROM
    ML.GENERATE_TEXT( MODEL `gemini_demo.gemini_1_5_flash`,
    TABLE `gemini_demo.movie_posters`,
    STRUCT( 0.2 AS temperature,
        'For the movie represented by this poster, what is the movie title and year of release? Answer in JSON format with two keys: title, year. title should be string, year should be integer. Do not use JSON decorators.' AS PROMPT,
        TRUE AS FLATTEN_JSON_OUTPUT)));

Quando a consulta é executada, o BigQuery solicita o modelo Gemini para cada linha da tabela de objetos, combinando a imagem com o comando estático especificado. Como resultado, a tabela movie_posters_results é criada.

Observação:a função ML.GENERATE_TEXT é usada para solicitar o modelo Gemini para cada linha da tabela de objetos. Essa função usa três argumentos:

• O primeiro argumento é o nome do MODEL a ser solicitado. Nesse caso, o modelo é chamado gemini_demo.gemini_1_5_flash.
• O segundo argumento aponta para o objeto TABLE que faz referência às imagens.
• O terceiro argumento é um STRUCT que especifica parâmetros. Nesse caso, o STRUCT contém o PROMPT, que será concatenado com a imagem de cada linha da tabela de objetos antes de ser enviado ao modelo Gemini. Ele também contém parâmetros opcionais, como temperature e flatten_json_output, definidos como TRUE para achatar a saída em um único objeto JSON.

2. Agora vamos conferir os resultados. Crie e execute uma nova consulta com a seguinte instrução SQL:

SELECT * FROM `gemini_demo.movie_posters_results`

O resultado são linhas para cada pôster de filme com o URI (o local do Cloud Storage da imagem do pôster) e um resultado JSON com o título do filme e o ano de lançamento dele fornecidos pelo modelo Gemini 1.5 Flash.

Você pode usar a próxima consulta para recuperar esses resultados de uma forma mais legível por humanos. Essa consulta usa SQL para extrair o título do filme e o ano de lançamento dessas respostas em novas colunas.

3. Crie e execute uma nova consulta com a seguinte instrução SQL:

CREATE OR REPLACE TABLE
  `gemini_demo.movie_posters_results_formatted` AS (
  SELECT
    uri,
    JSON_VALUE(ml_generate_text_llm_result, "$.title") AS title,
    JSON_VALUE(ml_generate_text_llm_result, "$.year") AS year
  FROM
    `gemini_demo.movie_posters_results` results )

Como resultado, a tabela movie_posters_result_formatted é criada.

4. Você pode usar a consulta abaixo para a tabela a fim de conferir as linhas criadas.

SELECT * FROM `gemini_demo.movie_posters_results_formatted`

Observe como os resultados da coluna URI permanecem os mesmos, mas o JSON agora foi convertido nas colunas title e year para cada linha.

Pedir ao modelo Gemini 1.5 Flash para fornecer resumos de filmes

E se você quisesse um pouco mais de informação sobre cada um desses filmes, digamos um resumo de cada um deles? Esse caso de uso de geração de conteúdo é perfeito para um modelo LLM, como o Gemini 1.5 Flash.

1. É possível usar o Gemini 1.5 Flash para fornecer resumos de filmes para cada pôster executando a consulta abaixo:

SELECT
  uri,
  title,
  year,
  prompt,
  ml_generate_text_llm_result
  FROM
 ML.GENERATE_TEXT( MODEL `gemini_demo.gemini_1_5_flash`,
   (
   SELECT
     CONCAT('Provide a short summary of movie titled ',title, ' from the year ',year,'.') AS prompt,
     uri,
     title,
     year
   FROM
     `gemini_demo.movie_posters_results_formatted`
   LIMIT
     20 ),
   STRUCT(0.2 AS temperature,
     TRUE AS FLATTEN_JSON_OUTPUT));     

Observe o campo ml_generate_text_llm_result dos resultados, que inclui um breve resumo do filme.

Observação:nesse uso da função ML.GENERATE_TEXT, você está enviando uma solicitação somente de texto para o modelo Gemini em cada linha da tabela movie_posters_results_formatted. A função ainda usa os mesmos três argumentos:

• o MODEL para solicitar
• o TABLE, que dessa vez é criado em tempo real com uma instrução SELECT
• o STRUCT, agora sem o PROMPT, mas com outros parâmetros opcionais

Observe como, neste cenário de solicitação somente de texto, o PROMPT passa a ser uma coluna no argumento TABLE e pode incorporar campos dos dados, como title e year. Esse formato é diferente da forma como você estruturou os comandos multimodais na última seção.

9. gerar embeddings de texto usando um modelo remoto

Agora você pode mesclar os dados estruturados que criou com outros dados estruturados no data warehouse. O conjunto de dados público do IMDB disponível no BigQuery contém muitas informações sobre filmes, incluindo classificações de espectadores e algumas avaliações de usuários em formato livre. Esses dados podem ajudar você a aprofundar a análise dos pôsteres de filmes e entender como eles foram percebidos.

Para mesclar dados, você vai precisar de uma chave. Nesse caso, os títulos dos filmes gerados pelo modelo Gemini podem não corresponder perfeitamente aos títulos no conjunto de dados IMDB.

Nesta tarefa, você vai gerar embeddings de texto dos títulos e anos dos filmes dos dois conjuntos de dados e usar a distância entre esses embeddings para mesclar o título do IMDB mais próximo com os títulos dos pôsteres de filmes do conjunto de dados recém-criado.

Criar o modelo remoto

Para gerar os embeddings de texto, crie um novo modelo remoto que aponte para o endpoint text-multilingual-embedding-002.

1. Crie e execute uma nova consulta com a seguinte instrução SQL:

CREATE OR REPLACE MODEL `gemini_demo.text_embedding`
REMOTE WITH CONNECTION `us.gemini_conn`
OPTIONS (endpoint = 'text-multilingual-embedding-002')

Como resultado, o modelo text_embedding é criado e aparece no Explorer abaixo do conjunto de dados gemini_demo.

Gerar embeddings de texto para o título e o ano associados aos pôsteres

Agora você vai usar esse modelo remoto com a função ML.GENERATE_EMBEDDING para criar um embedding para cada título e ano do pôster do filme.

1. Crie e execute uma nova consulta com a seguinte instrução SQL:

CREATE OR REPLACE TABLE
  `gemini_demo.movie_posters_results_embeddings` AS (
  SELECT
    *
  FROM
    ML.GENERATE_EMBEDDING(
    MODEL `gemini_demo.text_embedding`,
    (
    SELECT
      CONCAT('The movie titled ', title, ' from the year ', year,'.') AS content,
      title,
      year,
      uri
    FROM
      `gemini_demo.movie_posters_results_formatted` ),
    STRUCT(TRUE AS flatten_json_output)));

O resultado é a criação da tabela movie_poster_results_embeddings, que contém os embeddings do conteúdo de texto concatenado para cada linha da tabela gemini_demo.movie_posters_results_formatted.

Observação:a função ML.GENERATE_EMBEDDING é usada para gerar os embeddings. Assim como a ML.GENERATE_TEXT, essa função usa três argumentos:

• o MODEL a ser usado para gerar os embeddings, que é o modelo remoto que você acabou de criar, chamado gemini_demo.text_embedding.
• o TABLE, que contém o conteúdo de texto a ser incorporado, criado novamente em tempo real com uma instrução SELECT que define o conteúdo de texto como title e year de cada filme concatenado em uma única string.
• o STRUCT com os parâmetros opcionais.

2. É possível conferir os resultados da consulta usando a nova consulta abaixo:

SELECT * FROM `gemini_demo.movie_posters_results_embeddings`

É possível encontrar os embeddings (vetores representados por números) de cada filme gerado pelo modelo.

Gerar embeddings de texto para um subconjunto do conjunto de dados IMDB

Você vai criar uma nova visualização de dados de um conjunto de dados público do IMDB que contém apenas os filmes lançados antes de 1935 (o período conhecido dos filmes das imagens dos pôsteres).

1. Crie e execute uma nova consulta com a seguinte instrução SQL:

CREATE OR REPLACE VIEW
  `gemini_demo.imdb_movies` AS (
  WITH
    reviews AS (
      SELECT
        reviews.movie_id AS movie_id,
        title.primary_title AS title,
        title.start_year AS year,
        reviews.review AS review
      FROM
        `bigquery-public-data.imdb.reviews` reviews
      LEFT JOIN
        `bigquery-public-data.imdb.title_basics` title
      ON
        reviews.movie_id = title.tconst)
  SELECT
    DISTINCT(movie_id),
    title,
    year
  FROM
    reviews
  WHERE
    year < 1935)

O resultado é uma nova visualização com uma lista de IDs, títulos e anos de lançamento de filmes distintos da tabela bigquery-public-data.imdb.reviews para todos os filmes no conjunto de dados lançados antes de 1935.

2. Agora você vai criar embeddings para o subconjunto de filmes do IMDB usando um processo semelhante ao da seção anterior. Crie e execute uma nova consulta com a seguinte instrução SQL:

CREATE OR REPLACE TABLE
  `gemini_demo.imdb_movies_embeddings` AS (
  SELECT
    *
  FROM
    ML.GENERATE_EMBEDDING( MODEL `gemini_demo.text_embedding`,
      (
      SELECT
        CONCAT('The movie titled ', title, ' from the year ', year,'.') AS content,
        title,
        year,
        movie_id
      FROM
        `gemini_demo.imdb_movies` ),
      STRUCT(TRUE AS flatten_json_output) )
  WHERE
    ml_generate_embedding_status = '' );

O resultado da consulta é uma tabela que contém os embeddings do conteúdo de texto da tabela gemini_demo.imdb_movies.

Fazer a correspondência entre as imagens dos pôsteres de filmes e o movie_id do IMDB usando o BigQuery VECTOR_SEARCH

Agora, você pode unir as duas tabelas usando a função VECTOR_SEARCH.

1. Crie e execute uma nova consulta com a seguinte instrução SQL:

SELECT
  query.uri AS poster_uri,
  query.title AS poster_title,
  query.year AS poster_year,
  base.title AS imdb_title,
  base.year AS imdb_year,
  base.movie_id AS imdb_movie_id,
  distance
FROM
 VECTOR_SEARCH( TABLE `gemini_demo.imdb_movies_embeddings`,
   'ml_generate_embedding_result',
   TABLE `gemini_demo.movie_posters_results_embeddings`,
   'ml_generate_embedding_result',
   top_k => 1,
   distance_type => 'COSINE');

A consulta usa a função VECTOR_SEARCH para encontrar o vizinho mais próximo na tabela gemini_demo.imdb_movies_embeddings para cada linha na tabela gemini_demo.movie_posters_results_embeddings. O vizinho mais próximo é encontrado usando a métrica de distância de cosseno, que determina o quão semelhantes são dois embeddings.

Essa consulta pode ser usada para encontrar no conjunto de dados IMDB o filme mais semelhante a cada um dos filmes identificados pelo Gemini 1.5 Flash nos pôsteres de filmes. Por exemplo, é possível usar essa consulta para encontrar a correspondência mais próxima do filme "Au Secours!" no conjunto de dados público IMDB, que faz referência a esse filme pelo título em inglês, "Help!".

2. Crie e execute uma nova consulta para mesclar algumas informações adicionais sobre as classificações de filmes fornecidas no conjunto de dados público IMDB:

SELECT
  query.uri AS poster_uri,
  query.title AS poster_title,
  query.year AS poster_year,
  base.title AS imdb_title,
  base.year AS imdb_year,
  base.movie_id AS imdb_movie_id,
  distance,
  imdb.average_rating,
  imdb.num_votes
FROM
  VECTOR_SEARCH( TABLE `gemini_demo.imdb_movies_embeddings`,
    'ml_generate_embedding_result',
    TABLE `gemini_demo.movie_posters_results_embeddings`,
    'ml_generate_embedding_result',
    top_k => 1,
    distance_type => 'COSINE') DATA
LEFT JOIN
  `bigquery-public-data.imdb.title_ratings` imdb
ON
  base.movie_id = imdb.tconst
ORDER BY
  imdb.average_rating DESC

Essa consulta é semelhante à anterior. Ela ainda usa representações numéricas especiais chamadas de embeddings de vetor para encontrar filmes semelhantes a um determinado pôster de filme. No entanto, ela também mescla a classificação média e o número de votos de cada filme que é o vizinho mais próximo com base em uma tabela separada do conjunto de dados público IMDB.

10. Parabéns

Parabéns por concluir o codelab. Você criou uma tabela de objetos para suas imagens de pôsteres no BigQuery, criou um modelo Gemini remoto, usou o modelo para solicitar que o Gemini analisasse as imagens e forneceu resumos de filmes, gerou embeddings de texto para títulos de filmes e usou esses embeddings para combinar imagens de pôsteres com o título do filme relacionado no conjunto de dados do IMDB.

O que vimos

• Como configurar seu ambiente e sua conta para usar APIs
• Como criar uma conexão de recursos do Cloud no BigQuery
• Como criar um conjunto de dados e uma tabela de objetos no BigQuery para imagens de pôsteres de filmes
• Como criar os modelos remotos do Gemini no BigQuery
• Como solicitar que o modelo do Gemini forneça resumos de filmes para cada pôster
• Como gerar embeddings de texto para o filme representado em cada pôster
• Como usar a VECTOR_SEARCH do BigQuery para combinar imagens de pôsteres de filmes com filmes muito semelhantes no conjunto de dados

Próximas etapas / Saiba mais

• Introdução ao BigQuery ML
• Escalonamento do machine learning com o mecanismo de inferência do BigQuery ML – Blog

11. Pesquisa

Como você usará este tutorial?

Apenas leituraLeitura e exercícios