Hologres: Análise de imagens de alto desempenho para direção autônoma

Capacidades principais

Esta prática recomendada para processamento de imagens, pesquisa e análise multimodal envolve as seguintes capacidades principais:

• Modelos gerenciados do Hologres: O Hologres oferece recursos de implantação e invocação de modelos gerenciados por meio de nós de IA. Implante modelos diretamente nos nós de IA do Hologres e invoque-os via SQL padrão usando AI Functions, sem configurar serviços externos de inferência. Nesta solução, o Hologres chama os modelos gerenciados implantados diretamente.

• Object Table: Leia dados não estruturados, como PDFs, imagens e PPTs, do Object Storage Service (OSS) em formato de tabela.

• AI Function: No Hologres, use SQL padrão para chamar funções que invocam automaticamente grandes modelos integrados e criam serviços de IA.

  • Processamento de dados: Fornece operadores Embed e Chunk para transformar dados não estruturados em dados estruturados para armazenamento. Gere embeddings automaticamente sem algoritmos externos.

  • Pesquisa e análise de dados: Disponibiliza operadores como ai_gen e ai_summarize para executar inferência, resumo e tradução de dados usando apenas SQL.

• Dynamic Table: Suporta modo de atualização incremental para processar dados não estruturados automaticamente. Esse modo processa apenas dados incrementais, o que reduz computações redundantes e o uso de recursos.

• Índice HGraph (Recomendado): Permite pesquisa vetorial usando SQL padrão para buscas de similaridade e reconhecimento de cenas em dados não estruturados. Combine livremente pesquisas vetoriais e escalares na mesma consulta.

• Índice invertido de texto completo: Possibilita pesquisa eficiente de dados não estruturados por meio de mecanismos como indexação invertida e tokenização. Oferece suporte a métodos avançados de pesquisa, como correspondência de palavras-chave e busca por frases, para uma recuperação mais flexível.

Benefícios

Com essas capacidades principais, o Hologres oferece as seguintes vantagens essenciais para pesquisa de imagens:

• Processamento de dados de IA de ponta a ponta: Cobre todo o fluxo de trabalho, desde embedding e fragmentação de dados até processamento incremental, pesquisa e análise. Construir aplicações de IA torna-se tão simples quanto trabalhar com sistemas de big data.

• Processe dados de imagem com SQL padrão: Não é necessária nenhuma linguagem de programação especializada. Use SQL puro para extrair e processar dados de imagem.

• Uma única plataforma para pesquisa cross-modal: Suporta tanto pesquisa de texto para imagem quanto de imagem para imagem. A compreensão semântica vai além dos limites de palavras-chave e habilita pesquisa cross-modal dentro do Hologres.

• Pesquisa mais precisa, flexível e inteligente: Construa facilmente pipelines de pesquisa híbrida que combinam palavras-chave, semântica e pesquisa multimodal para atender desde buscas exatas até descobertas baseadas em intenção. Utilize também AI Function para compreensão profunda da intenção do usuário, correlação semântica e raciocínio contextual, permitindo pesquisas mais inteligentes.

• Maior segurança com processamento no banco de dados: Não é necessário exportar dados para sistemas externos. Esta solução integra-se perfeitamente aos diversos recursos de segurança do Hologres para proteger seus dados com eficiência.

Como funciona

O fluxo de trabalho desta solução é o seguinte:

1. Prepare o conjunto de dados.

   Faça upload dos dados de imagem para o Object Storage Service (OSS).

2. Processe as imagens.

   Use uma Object Table para ler os metadados da imagem e crie uma Dynamic Table com atualização incremental para gerar embeddings. Crie um índice vetorial para a Dynamic Table a fim de acelerar as pesquisas subsequentes.

3. Utilize o operador ai_embed para criar embeddings de consultas em linguagem natural e use a pesquisa vetorial para recuperar os N principais resultados.

Pré-requisitos

• Preparação de dados

  Este tópico utiliza o arquivo val.zip do conjunto de dados de imagens de direção autônoma BDD100K, disponível publicamente no ModelScope, para simular dados reais de direção de múltiplos veículos.

• Preparação do ambiente

  • Adquira recursos de nó de IA do Hologres. No console do Hologres, acesse a página de detalhes da instância e vá para a seção AI Nodes (GPU) para comprar recursos de nó de IA. Para obter mais informações sobre AI Functions e modelos gerenciados, consulte Introdução a Recursos e Funções de IA.

  • É necessária uma instância do Hologres versão 4.0.40 ou posterior, 4.1.26 ou posterior, 4.2.5 ou posterior, ou 5.0 ou posterior. Regiões suportadas atualmente: China (Pequim), China (Xangai), China (Hangzhou), China (Shenzhen) e Singapura.

  • Implante um modelo gerenciado. No console do Hologres, acesse a página de detalhes da instância, clique em AI Model e depois clique em Deploy Model. Selecione Hologres AI Node como provedor do modelo e implante o modelo qwen3-vl-embedding. Para mais detalhes, consulte Implantar modelos gerenciados.

Procedimento

1. Baixe os dados de imagem e faça upload para o OSS.

   1. Baixe o arquivo val.zip do conjunto de dados de imagens de direção autônoma BDD100K.

   2. Faça login no console do OSS, crie um bucket e faça upload do arquivo val.zip baixado para o bucket. Para mais informações sobre upload de arquivos, consulte Upload simples.

      Nota

      Use letras minúsculas para nomes de pastas.

2. Conceda permissões.

   1. Faça login no console do Resource Access Management (RAM). Crie uma função RAM do Alibaba Cloud e conceda a ela permissões de OSS.

      Recomendamos conceder a permissão AliyunOSSReadOnlyAccess.

   2. Conceda permissões de login e acesso ao Hologres para a função RAM.

      • Conta Alibaba Cloud (conta raiz)

        Atualize a política de confiança da função RAM. Atualize estes parâmetros:

        • Action: Defina como sts:AssumeRole.

        • Service: Defina como hologres.aliyuncs.com.

        {
          "Statement": [
            {
              "Action": "sts:AssumeRole",
              "Effect": "Allow",
              "Principal": {
                "RAM": [
                  "acs:ram::1866xxxx:root"
                ],
                "Service": [
                  "hologres.aliyuncs.com"
                ]
              }
            }
          ],
          "Version": "1"
        }

      • Usuário RAM (subconta)

        1. Conceda permissões ao usuário RAM.

           1. Na página Access Control, clique em Create Policy e selecione o modo Script Editor para criar uma política. Para mais informações, consulte Criar uma política personalizada.

              O Hologres usa esta política para verificar se o usuário RAM tem permissão para criar a função RAM. Conteúdo da política:

              {
                "Version": "1",
                "Statement": [
                  {
                    "Effect": "Allow",
                    "Action": "hologram:GrantAssumeRole",
                    "Resource": "<RoleARN>"
                  }
                ]
              }

           2. Na página Identity Management > User, clique em Add Permissions na coluna Actions.

        2. Conceda permissões à função RAM.

           Atualize a política de confiança da função RAM. Atualize estes parâmetros:

           • Action: Defina como sts:AssumeRole.

           • Service: Defina como hologres.aliyuncs.com.

           {
             "Statement": [
               {
                 "Action": "sts:AssumeRole",
                 "Effect": "Allow",
                 "Principal": {
                   "RAM": [
                     "acs:ram::1866xxxx:root"
                   ],
                   "Service": [
                     "hologres.aliyuncs.com"
                   ]
                 }
               }
             ],
             "Version": "1"
           }

3. Gere embeddings para as imagens.

   Crie uma Object Table e uma Dynamic Table para ler metadados de imagem e gerar embeddings. O Hologres fornece esse processo extenso como um procedimento armazenado. Este procedimento armazenado inclui as seguintes capacidades:

   • Cria uma Object Table para ler metadados de imagem.

   • Cria uma Dynamic Table com atualização incremental como tabela de resultados para armazenar os dados processados e cria um índice vetorial. A atualização automática está desativada para esta Dynamic Table; portanto, atualize-a manualmente.

   • Durante o processo de atualização, esta Dynamic Table usa a função ai_embed para gerar embeddings de imagem.

   Para usar este procedimento armazenado, execute a seguinte instrução:

   -- Stored procedure to create an Object Table and a Dynamic Table, and use the Dynamic Table to embed images.
   CALL create_image_table_from_oss(
       oss_path => 'oss://xxxx/bdd100k/val/images',
       oss_endpoint => 'oss-cn-hangzhou-internal.aliyuncs.com',
       oss_role_arn => 'acs:ram::1xxxx:role/xxxx',
       image_table => 'public.dt_image_bdd100k',
       embedding_model =>'qwen3_vl_embedding'
   );

4. Atualize a tabela de resultados.

   Atualize manualmente a Object Table e a Dynamic Table da etapa anterior para concluir o processamento de dados. Esta etapa também está encapsulada em um procedimento armazenado. Este procedimento armazenado oferece as seguintes capacidades:

   • Atualiza a Object Table uma vez para obter metadados de imagem.

   • Atualiza a Dynamic Table uma vez para gerar embeddings para as imagens.

   Para usar este procedimento armazenado, execute a seguinte instrução:

   -- Refresh the Dynamic Table to generate embeddings for the images.
   CALL refresh_image_table(
       image_table => 'public.dt_image_bdd100k'
   );
   

5. Pesquise as imagens.

   Após o processamento dos dados de imagem, pesquise usando pesquisa vetorial e AI Function.

   Pesquisa de texto para imagem

   A seguinte instrução SQL é um exemplo de pesquisa de texto para imagem:

   -- Text-to-image search
   SELECT
       object_uri,
       approx_cosine_distance (embedding_vector, ai_embed ('qwen3_vl_embedding', 'a red car in the rain')) AS score
   FROM
       public.dt_image_bdd100k
   ORDER BY
       score DESC
   LIMIT 1;
                               object_uri                         |  score
   ---------------------------------------------------------------+-------
    oss://****/bdd100k/val/images/c11a0015-fc7c****.jpg| 0.559552908
   (5 rows)

   Na página de detalhes do objeto OSS, o resultado da pesquisa mostra uma cena de rua chuvosa capturada através da janela de um carro. É possível ver gotas de chuva, semáforos, veículos em movimento e uma faixa de pedestres. A cena apresenta forte correspondência semântica com o texto da consulta a red car in the rain. Os metadados do objeto indicam tempo de expiração de 300 segundos.

   Pesquisa de imagem para imagem

   A seguinte instrução SQL é um exemplo de pesquisa de imagem para imagem:

   -- Image-to-image search
   SELECT
       object_uri,
       approx_cosine_distance (embedding_vector, ai_embed ('qwen3_vl_embedding', to_file ('oss://xxxx/val/images/b9b53753-91a5d5f8.jpg', 'oss-cn-hangzhou-internal.aliyuncs.com', 'acs:ram::18xxx:role/xxx'))) AS score
   FROM
       public.dt_image_bdd100k
   WHERE
       object_uri <> 'oss://****-hangzhou/bdd100k/val/images/b9b53753-91a5****.jpg' -- Exclude the image itself.
   ORDER BY
       score DESC
   LIMIT 1;
                             object_uri                           |  score
   ---------------------------------------------------------------+------
    oss://****/bdd100k/val/images/c0e9b7c4-cd8b****.jpg | 0.811107099
   

   Uma comparação mostra que a imagem de consulta (uma cena de condução urbana chuvosa) e a imagem recuperada (uma cena de rua urbana com um sedã branco, um ônibus e um táxi) possuem alta similaridade visual. Isso valida a precisão do resultado da pesquisa de imagem para imagem.

Apêndice: Procedimentos armazenados

• Criar uma Object Table e uma Dynamic Table

  -- By default, a query returns a maximum of 200 rows. To return more data, modify the LIMIT clause. The maximum is 10,000 rows or 20 MB.
  CREATE OR REPLACE PROCEDURE create_image_table_from_oss(
      oss_path TEXT,
      oss_endpoint TEXT,
      oss_role_arn TEXT,
      image_table TEXT,
      embedding_model TEXT DEFAULT NULL,
      overwrite BOOLEAN DEFAULT FALSE
  )
  AS $$
  DECLARE
      image_schema_name TEXT;
      image_table_name TEXT;
      obj_table_name TEXT;
      full_image_table_ident TEXT;
      full_obj_ident TEXT;
      embed_expr TEXT;
      create_sql TEXT;
      embedding_dims INT;
  BEGIN
      -- 1. Split the schema name and table name.
      IF position('.' in image_table) > 0 THEN
          image_schema_name := split_part(image_table, '.', 1);
          image_table_name  := split_part(image_table, '.', 2);
      ELSE
          image_schema_name := 'public';
          image_table_name  := image_table;
      END IF;
      obj_table_name := image_table_name || '_obj_table';
      full_image_table_ident := format('%I.%I', image_schema_name, image_table_name);
      full_obj_ident    := format('%I.%I', image_schema_name, obj_table_name);
      -- 2. If overwrite is true, drop the tables and indexes first.
      IF overwrite THEN
          DECLARE
              dyn_table_exists BOOLEAN;
              rec RECORD;
          BEGIN
              -- Check whether the dynamic table exists.
              SELECT EXISTS (
                  SELECT 1
                  FROM pg_class c
                  JOIN pg_namespace n ON n.oid = c.relnamespace
                  WHERE c.relname = image_table_name
                  AND n.nspname = image_schema_name
              )
              INTO dyn_table_exists;
              IF dyn_table_exists THEN
                  -- 2.1 Disable auto-refresh for the dynamic table.
                  -- RAISE NOTICE 'Disabling auto refresh for %', full_image_table_ident;
                  -- EXECUTE format('ALTER TABLE IF EXISTS %s SET (auto_refresh_enable=false)', full_image_table_ident);
                  -- 2.2 Find and cancel the RUNNING refresh job.
                  FOR rec IN
                      EXECUTE format(
                          $f$
                          SELECT query_job_id
                              FROM hologres.hg_dynamic_table_refresh_log(%L)
                              WHERE status = 'RUNNING';
                          $f$,
                          image_table
                      )
                  LOOP
                      RAISE NOTICE 'Found running refresh job: %', rec.query_job_id;
                      IF hologres.hg_internal_cancel_query_job(rec.query_job_id::bigint) THEN
                          RAISE NOTICE 'Cancel job % succeeded.', rec.query_job_id;
                      ELSE
                          RAISE WARNING 'Cancel job % failed.', rec.query_job_id;
                      END IF;
                  END LOOP;
                  -- 2.3 Drop the Dynamic Table.
                  EXECUTE format('DROP TABLE IF EXISTS %s;', full_image_table_ident);
              ELSE
                  RAISE NOTICE 'Dynamic table % does not exist, skip cancel job and drop.', full_image_table_ident;
              END IF;
              -- 2.4 Drop the Object Table.
              EXECUTE format('DROP OBJECT TABLE IF EXISTS %s;', full_obj_ident);
          END;
      END IF;
      -- 3. Create the Object Table.
      RAISE NOTICE 'Create object table: %', obj_table_name;
      EXECUTE format(
          $f$
          CREATE OBJECT TABLE %s
          WITH (
              path = %L,
              oss_endpoint = %L,
              role_arn = %L
          );
          $f$,
          full_obj_ident,
          oss_path,
          oss_endpoint,
          oss_role_arn
      );
      COMMIT;
      -- 4. Refresh the Object Table.
      RAISE NOTICE 'Refresh object table: %', obj_table_name;
      EXECUTE format('REFRESH OBJECT TABLE %s;', full_obj_ident);
      COMMIT;
      -- 5. Select an embedding model.
      IF embedding_model IS NULL OR length(trim(embedding_model)) = 0 THEN
          embed_expr := 'ai_embed(file)';
          EXECUTE 'SELECT array_length(ai_embed(''dummy''), 1)'
          INTO embedding_dims;
      ELSE
          embed_expr := format('ai_embed(%L, file)', embedding_model);
          EXECUTE format(
              'SELECT array_length(ai_embed(%L, ''dummy''), 1)',
              embedding_model
          )
          INTO embedding_dims;
      END IF;
      RAISE NOTICE 'embedding dimension is: %', embedding_dims;
      -- 6. Create the Dynamic Table for RAG output.
      RAISE NOTICE 'create dynamic table: %', image_table_name;
      EXECUTE format(
          $f$
          CREATE DYNAMIC TABLE %s(
              CHECK(array_ndims(embedding_vector) = 1 AND array_length(embedding_vector, 1) = %s)
          )
          WITH (
              vectors = '{
                  "embedding_vector": {
                      "algorithm": "HGraph",
                      "distance_method": "Cosine",
                      "builder_params": {
                      "base_quantization_type": "sq8_uniform",
                      "max_degree": 64,
                      "ef_construction": 400,
                      "precise_quantization_type": "fp32",
                      "use_reorder": true
                      }
                  }
              }',
              auto_refresh_mode = 'incremental',
              freshness = '5 minutes',
              auto_refresh_enable = 'false'
          ) AS
          SELECT
              object_uri,
              etag,
              %s AS embedding_vector
          FROM %s;
          $f$,
          full_image_table_ident,
          embedding_dims,
          embed_expr,
          obj_table_name
      );
      COMMIT;
      RAISE NOTICE '';
      RAISE NOTICE 'Create image table success: %', image_table;
      RAISE NOTICE '    Vector index is: %.embedding_vector', image_table;
  END;
  $$ LANGUAGE plpgsql;
  

• Atualizar a Object Table e a Dynamic Table

  CREATE OR REPLACE PROCEDURE refresh_image_table(
      image_table TEXT
  )
  AS $$
  DECLARE
      image_schema_name TEXT;
      image_table_name   TEXT;
      obj_table_name TEXT;
      full_image_table_ident TEXT;
      full_obj_ident    TEXT;
  BEGIN
      -- 1. Parse the schema and table name.
      IF position('.' in image_table) > 0 THEN
          image_schema_name := split_part(image_table, '.', 1);
          image_table_name  := split_part(image_table, '.', 2);
      ELSE
          image_schema_name := 'public';
          image_table_name  := image_table;
      END IF;
      obj_table_name := image_table_name || '_obj_table';
      full_image_table_ident := format('%I.%I', image_schema_name, image_table_name);
      full_obj_ident    := format('%I.%I', image_schema_name, obj_table_name);
      -- 2. Refresh the Object Table.
      RAISE NOTICE 'Refreshing Object Table: %', obj_table_name;
      EXECUTE format('REFRESH OBJECT TABLE %s;', full_obj_ident);
      -- 3. Refresh the Dynamic Table.
      RAISE NOTICE 'Refreshing Dynamic Table: %', image_table_name;
      EXECUTE format('REFRESH TABLE %s;', full_image_table_ident);
      RAISE NOTICE 'Refresh image table complete: %', image_table;
  END;
  $$ LANGUAGE plpgsql;

• Procedimento para excluir tabelas

  CREATE OR REPLACE PROCEDURE drop_image_table(
      image_table TEXT
  )
  AS $$
  DECLARE
      image_schema_name TEXT;
      image_table_name   TEXT;
      obj_table_name TEXT;
      full_image_table_ident TEXT;
      full_obj_ident    TEXT;
      rec RECORD;
  BEGIN
      -- 1. Parse the schema and table name.
      IF position('.' in image_table) > 0 THEN
          image_schema_name := split_part(image_table, '.', 1);
          image_table_name   := split_part(image_table, '.', 2);
      ELSE
          image_schema_name := 'public';
          image_table_name   := image_table;
      END IF;
      obj_table_name := image_table_name || '_obj_table';
      full_image_table_ident := format('%I.%I', image_schema_name, image_table_name);
      full_obj_ident    := format('%I.%I', image_schema_name, obj_table_name);
      -- 2. Delete the table.
      -- 2.1 Disable auto-refresh for the dynamic table.
      -- RAISE NOTICE 'Disabling auto refresh for %', full_image_table_ident;
      -- EXECUTE format('ALTER TABLE IF EXISTS %s SET (auto_refresh_enable=false)', full_image_table_ident);
      -- 2.2 Find and cancel the RUNNING refresh job.
      FOR rec IN
          EXECUTE format(
              $f$
              SELECT query_job_id
                  FROM hologres.hg_dynamic_table_refresh_log(%L)
                  WHERE status = 'RUNNING';
              $f$,
              image_table
          )
      LOOP
          RAISE NOTICE 'Found running refresh job: %', rec.query_job_id;
          IF hologres.hg_internal_cancel_query_job(rec.query_job_id::bigint) THEN
              RAISE NOTICE 'Cancel job % succeeded.', rec.query_job_id;
          ELSE
              RAISE WARNING 'Cancel job % failed.', rec.query_job_id;
          END IF;
      END LOOP;
      -- 2.3 Drop the Dynamic Table.
      RAISE NOTICE 'Dropping Dynamic Table: %', image_table_name;
      EXECUTE format('DROP TABLE IF EXISTS %s;', full_image_table_ident);
      -- 2.4 Drop the Object Table.
      RAISE NOTICE 'Dropping Object Table: %', obj_table_name;
      EXECUTE format('DROP OBJECT TABLE IF EXISTS %s;', full_obj_ident);
      RAISE NOTICE 'Drop image table complete: %', image_table;
  END;
  $$ LANGUAGE plpgsql;