Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Optimisation automatique

Auto-Optimize est un service qui automatise les optimisations des index vectoriels, permettant aux utilisateurs d'équilibrer la qualité, la vitesse et le coût de la recherche sans avoir besoin de plusieurs semaines de réglage manuel par des experts. Il évalue les configurations d'index en fonction des exigences de latence et de rappel définies par l'utilisateur et génère des recommandations d'optimisation, de sorte qu'une expertise minimale est requise. Les recommandations sont généralement fournies dans un délai de 30 à 60 minutes.

La configuration d'index vectoriels traditionnelle nécessite une expertise et des expérimentations importantes pour obtenir des performances optimales. Des paramètres tels que ef_construction (qui contrôle la qualité de la création de l'index), m (qui détermine le nombre de connexions graphiques), ef_search (qui contrôle la recherche HNSW) et les méthodes de quantification (quantification binaire (32x, 16x, 8x), quantification scalaire (4x)) ont un impact significatif à la fois sur la précision de la recherche et sur l'utilisation des ressources. L'optimisation automatique utilise des algorithmes d'optimisation des hyperparamètres pour découvrir des configurations d'index particulièrement optimales pour votre ensemble de données, dans le respect des exigences de latence et de rappel définies.

Avantages

L'optimisation automatique pour OpenSearch offre les avantages suivants :

L'optimisation automatique fonctionne parallèlement à d'autres OpenSearch fonctionnalités, telles que Accélération par GPU pour l'indexation vectorielle l'optimisation complète des performances pour les charges de travail de recherche vectorielle.

Comment ça marche

L'optimisation automatique fonctionne grâce à une architecture basée sur les tâches qui analyse vos données vectorielles et fournit des recommandations d'optimisation. Points clés :

Conditions préalables

Cas d'utilisation de l'optimisation automatique

L'optimisation automatique est particulièrement utile dans les scénarios suivants :

Optimisation de la configuration initiale

Lors du premier déploiement d'applications de recherche vectorielle, la détermination des paramètres HNSW optimaux nécessite souvent des tests approfondis et une expertise du domaine. L'optimisation automatique élimine ce trial-and-error processus en analysant les caractéristiques de vos données et de votre charge de travail afin de recommander des configurations prêtes pour la production.

Ce cas d'utilisation est idéal pour les équipes qui découvrent la recherche vectorielle ou celles qui migrent depuis d'autres plateformes de base de données vectorielles et qui ont besoin d'établir rapidement des configurations de base de données vectorielles.

Optimisation de l'échelle

Au fur et à mesure que votre jeu de données vectorielles passe de milliers à des millions de vecteurs, les paramètres qui fonctionnaient bien au départ peuvent devenir sous-optimaux. L'optimisation automatique recommande des ajustements pour maintenir les performances à grande échelle.

Réduction des coûts

Les index vectoriels peuvent consommer d'importantes ressources de calcul et de stockage, en particulier dans le cas d'intégrations de grande dimension. L'optimisation automatique identifie les opportunités de réduction des coûts en trouvant des configurations de paramètres plus efficaces qui maintiennent les niveaux de performance requis tout en utilisant moins de ressources.

Par exemple, l'optimisation automatique peut détecter que votre m valeur actuelle (connectivité graphique) est supérieure à ce qui est nécessaire pour répondre à vos exigences de précision, ce qui vous permet de réduire le temps d'indexation et le stockage sans affecter la qualité de la recherche.

Dépannage des performances

Lorsque les performances des requêtes sont lentes ou que la latence est élevée dans les opérations de recherche vectorielle, l'optimisation automatique peut analyser votre ensemble de données et identifier une configuration plus optimale. Le service fournit des recommandations spécifiques pour remédier aux problèmes de performances, tels que le réglage de la connectivité graphique ou des paramètres de recherche.

Limitations

Facturation et coûts

L'optimisation automatique utilise un modèle de tarification par tâche dans lequel vous payez pour chaque tâche d'optimisation réussie, indépendamment de la taille du jeu de données et des configurations d'optimisation. Aucun frais ne vous sera facturé en cas d'échec ou d'annulation de tâches. En outre, l'optimisation automatique s'exécute sur une infrastructure distincte de celle des OpenSearch clusters gérés ou sans serveur, de sorte qu'elle n'affecte pas l'utilisation des ressources des clusters préexistants.

Modèle de tarification

Les coûts d'optimisation automatique sont facturés séparément des coûts de calcul et de OpenSearch stockage standard pour les domaines OpenSearch gérés ou sans serveur.

Pour plus d'informations sur les tarifs, consultez Amazon OpenSearch Service Pricing.

Convertir JSONL en Parquet

Si vos données sont au format JSONL, vous pouvez utiliser le script Python suivant pour les convertir au format Parquet afin de les utiliser avec l'optimisation automatique :

#!/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}")


def print_parquet_rows(parquet_path: str, limit: int = 5):
    """Print first N rows from the parquet file."""
    table = pq.read_table(parquet_path)
    df = table.to_pandas()

    print(f"\n=== Showing first {min(limit, len(df))} rows from {parquet_path} ===")
    print(df.head(limit).to_string())
    print("===========================================================\n")


if __name__ == "__main__":
    INPUT_JSON = "movies_10k.json"
    OUTPUT_PARQUET = "movies.parquet"

    # Convert JSON → Parquet
    json_to_parquet(INPUT_JSON, OUTPUT_PARQUET)

    # Print some rows from Parquet
    print_parquet_rows(OUTPUT_PARQUET, limit=3)

Fonctionnalités associées

Auto-optimize fonctionne avec d'autres fonctionnalités d'Amazon OpenSearch Service pour vous aider à créer et à optimiser des applications de recherche vectorielle :