As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Otimização automática

A otimização automática é um serviço que automatiza as otimizações do índice vetorial, permitindo que os usuários equilibrem a qualidade, a velocidade e o custo da pesquisa sem exigir semanas de ajustes manuais especializados. Ele avalia as configurações do índice com base nos requisitos de latência e recall definidos pelo usuário e gera recomendações de otimização, portanto, é necessária uma experiência mínima. Normalmente, as recomendações são entregues em 30 a 60 minutos.

A configuração tradicional do índice vetorial requer experiência e experimentação significativas para alcançar o desempenho ideal. Parâmetros como ef_construction (que controla a qualidade de construção do índice), m (que determina o número de conexões gráficas), ef_search (que controla a pesquisa HNSW) e métodos de quantização (quantização binária (32x, 16x, 8x), quantização escalar (4x)) afetam significativamente a precisão da pesquisa e a utilização de recursos. A otimização automática usa algoritmos de otimização de hiperparâmetros para descobrir configurações de índice que são exclusivamente ideais para seu conjunto de dados dentro dos requisitos definidos de latência e recuperação.

Benefícios

A otimização automática para OpenSearch fornece os seguintes benefícios:

A otimização automática funciona junto com outros OpenSearch recursos, como Aceleração por GPU para indexação vetorial fornecer uma otimização abrangente do desempenho para cargas de trabalho de pesquisa vetorial.

Como funciona

A otimização automática opera por meio de uma arquitetura baseada em tarefas que analisa seus dados vetoriais e fornece recomendações de otimização. Principais pontos:

Pré-requisitos

Casos de uso para otimização automática

A otimização automática é particularmente valiosa nos seguintes cenários:

Otimização da configuração inicial

Ao implantar pela primeira vez aplicativos de pesquisa vetorial, determinar os parâmetros ideais de HNSW geralmente requer testes extensivos e experiência no domínio. A otimização automática elimina esse trial-and-error processo analisando seus dados e as características da carga de trabalho para recomendar configurações prontas para produção.

Esse caso de uso é ideal para equipes iniciantes na pesquisa vetorial ou para aquelas que estão migrando de outras plataformas de banco de dados vetoriais e que precisam estabelecer configurações básicas rapidamente.

Otimização de escalabilidade

À medida que seu conjunto de dados vetoriais cresce de milhares para milhões de vetores, os parâmetros que funcionaram bem inicialmente podem ficar abaixo do ideal. A otimização automática recomenda ajustes para manter o desempenho em grande escala.

Redução de custos

Os índices vetoriais podem consumir recursos significativos de computação e armazenamento, especialmente com incorporações de alta dimensão. A otimização automática identifica oportunidades de reduzir custos encontrando configurações de parâmetros mais eficientes que mantêm os níveis de desempenho necessários enquanto usam menos recursos.

Por exemplo, a otimização automática pode descobrir que seu m valor atual (conexão gráfica) é maior do que o necessário para seus requisitos de precisão, permitindo que você reduza o tempo de indexação e o armazenamento sem afetar a qualidade da pesquisa.

Solução de problemas de performance

Ao experimentar um desempenho de consulta lento ou alta latência nas operações de pesquisa vetorial, a otimização automática pode analisar seu conjunto de dados e identificar uma configuração mais ideal. O serviço fornece recomendações específicas para lidar com gargalos de desempenho, como ajustar a conectividade gráfica ou os parâmetros de pesquisa.

Limitações

Faturamento e custos

A otimização automática usa um modelo de precificação por trabalho em que você paga por cada trabalho de otimização bem-sucedido, independentemente do tamanho do conjunto de dados e das configurações de otimização. Você não será cobrado por trabalhos fracassados ou cancelados. Além disso, a otimização automática é executada em uma infraestrutura diferente da dos OpenSearch clusters gerenciados ou sem servidor, portanto, não afeta a utilização de recursos dos clusters preexistentes.

Modelo de definição de preços

Os custos de otimização automática são cobrados separadamente dos custos padrão de computação e armazenamento em domínio OpenSearch gerenciado ou OpenSearch sem servidor.

Para obter informações sobre preços, consulte Amazon OpenSearch Service Pricing.

Formatos de dados compatíveis

A otimização automática oferece suporte aos seguintes formatos de dados para conjuntos de dados vetoriais armazenados no Amazon S3:

Formato Parquet

O Parquet é um formato de armazenamento em colunas otimizado para cargas de trabalho analíticas. Cada arquivo Parquet deve conter uma coluna de matrizes flutuantes representando seus dados vetoriais.

Exemplo de estrutura de arquivo Parquet (vista como uma tabela):

| id  | train_data                     |
|-----|--------------------------------|
| 1   | [0.12, 0.45, 0.78, ..., 0.33] |
| 2   | [0.56, 0.89, 0.12, ..., 0.67] |
| 3   | [0.34, 0.67, 0.90, ..., 0.11] |

Formato JSONL

JSONL (Linhas JSON) é um formato de texto em que cada linha é um objeto JSON válido. Cada linha deve conter um campo com uma matriz flutuante representando seus dados vetoriais.

Exemplo de arquivo JSONL:

{"id": 1, "train_data": [0.12, 0.45, 0.78, 0.33]}
{"id": 2, "train_data": [0.56, 0.89, 0.12, 0.67]}
{"id": 3, "train_data": [0.34, 0.67, 0.90, 0.11]}

Conversão entre formatos

Se seus dados estiverem em um formato diferente, você poderá usar os seguintes scripts Python para convertê-los.

Converter JSON ou JSONL em Parquet

#!/usr/bin/env python3
import json
import pyarrow as pa
import pyarrow.parquet as pq
from pathlib import Path
from typing import Any, Dict, List


def load_json_any(path: Path) -> List[Dict[str, Any]]:
    """
    Load JSON that can be:
      - a list of objects
      - a single object
      - JSON Lines (one object per line)
    Returns list[dict].
    """
    text = path.read_text().strip()

    # Try full JSON file
    try:
        obj = json.loads(text)
        if isinstance(obj, list):
            return obj
        if isinstance(obj, dict):
            return [obj]
    except json.JSONDecodeError:
        pass

    # Fallback → JSON Lines
    records = []
    for i, line in enumerate(text.splitlines(), start=1):
        line = line.strip()
        if not line:
            continue
        try:
            rec = json.loads(line)
        except json.JSONDecodeError as e:
            raise ValueError(f"Invalid JSON on line {i}: {e}")
        if not isinstance(rec, dict):
            raise ValueError(f"Line {i} must contain a JSON object")
        records.append(rec)

    return records


def json_to_parquet(json_path: str, parquet_path: str, compression: str = "snappy"):
    """Convert ANY JSON to Parquet (schema inferred)."""
    records = load_json_any(Path(json_path))
    table = pa.Table.from_pylist(records)
    pq.write_table(table, parquet_path, compression=compression)
    print(f"Wrote {len(records)} rows to {parquet_path}")


if __name__ == "__main__":
    INPUT_JSON = "vectors.jsonl"
    OUTPUT_PARQUET = "vectors.parquet"
    json_to_parquet(INPUT_JSON, OUTPUT_PARQUET)

Conversão de Parquet para JSONL

#!/usr/bin/env python3
import json
import pyarrow.parquet as pq


def parquet_to_jsonl(parquet_path: str, jsonl_path: str):
    """Convert a Parquet file to JSONL format."""
    table = pq.read_table(parquet_path)
    rows = table.to_pylist()
    with open(jsonl_path, "w") as f:
        for row in rows:
            f.write(json.dumps(row) + "\n")
    print(f"Wrote {len(rows)} rows to {jsonl_path}")


if __name__ == "__main__":
    INPUT_PARQUET = "vectors.parquet"
    OUTPUT_JSONL = "vectors.jsonl"
    parquet_to_jsonl(INPUT_PARQUET, OUTPUT_JSONL)

Características relacionadas

A otimização automática funciona em conjunto com outros recursos do Amazon OpenSearch Service para ajudar você a criar e otimizar aplicativos de pesquisa vetorial: