Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Automatisch optimieren

Auto-Optimize ist ein Service, der Vektorindex-Optimierungen automatisiert und es Benutzern ermöglicht, ein ausgewogenes Verhältnis zwischen Suchqualität, Geschwindigkeit und Kosten zu finden, ohne dass wochenlanges manuelles Tuning durch Experten erforderlich ist. Er bewertet Indexkonfigurationen auf der Grundlage benutzerdefinierter Latenz- und Abrufanforderungen und generiert Optimierungsempfehlungen, sodass nur minimales Fachwissen erforderlich ist. Empfehlungen werden in der Regel innerhalb von 30 bis 60 Minuten übermittelt.

Die herkömmliche Konfiguration von Vektorindexen erfordert umfangreiche Fachkenntnisse und Experimente, um eine optimale Leistung zu erzielen. Parameter wie ef_construction (steuert die Qualität der Indexerstellung), m (bestimmt die Anzahl der Graphverbindungen), ef_search (steuert die HNSW-Suche) und Quantisierungsmethoden (Binäre Quantisierung (32x, 16x, 8x), Skalare Quantisierung (4x)) wirken sich sowohl auf die Suchgenauigkeit als auch auf die Ressourcennutzung erheblich aus. Die automatische Optimierung verwendet Algorithmen zur Hyperparameter-Optimierung, um Indexkonfigurationen zu ermitteln, die für Ihren Datensatz innerhalb Ihrer definierten Latenz- und Abrufanforderungen einzigartig optimal sind.

Vorteile

Die automatische Optimierung für OpenSearch bietet die folgenden Vorteile:

Die automatische Optimierung funktioniert zusammen mit anderen OpenSearch Funktionen, z. B. GPU-Beschleunigung für die Vektorindizierung zur umfassenden Leistungsoptimierung für Workloads bei der Vektorsuche.

Funktionsweise

Die automatische Optimierung basiert auf einer auftragsbasierten Architektur, die Ihre Vektordaten analysiert und Optimierungsempfehlungen gibt. Die wichtigsten Punkte:

Voraussetzungen

Anwendungsfälle für die automatische Optimierung

Die automatische Optimierung ist in den folgenden Szenarien besonders nützlich:

Optimierung der Erstkonfiguration

Bei der ersten Implementierung von Vektorsuchanwendungen erfordert die Bestimmung der optimalen HNSW-Parameter häufig umfangreiche Tests und Fachwissen. Durch die automatische Optimierung entfällt dieser trial-and-error Prozess, da Ihre Daten und Workload-Merkmale analysiert werden, um produktionsreife Konfigurationen zu empfehlen.

Dieser Anwendungsfall ist ideal für Teams, die mit der Vektorsuche noch nicht vertraut sind, oder für Teams, die von anderen Vektordatenbankplattformen migrieren und schnell Basiskonfigurationen einrichten müssen.

Skalierung und Optimierung

Wenn Ihr Vektordatensatz von Tausenden auf Millionen von Vektoren anwächst, können Parameter, die anfangs gut funktionierten, suboptimal werden. Die automatische Optimierung empfiehlt Anpassungen, um die Leistung im großen Maßstab aufrechtzuerhalten.

Senkung der Kosten

Vektorindizes können erhebliche Rechen- und Speicherressourcen beanspruchen, insbesondere bei hochdimensionalen Einbettungen. Die automatische Optimierung identifiziert Möglichkeiten zur Kostensenkung, indem effizientere Parameterkonfigurationen gefunden werden, die das erforderliche Leistungsniveau beibehalten und gleichzeitig weniger Ressourcen verbrauchen.

Bei der automatischen Optimierung könnte beispielsweise festgestellt werden, dass Ihr aktueller m Wert (Grafikverbundenheit) höher ist als für Ihre Genauigkeitsanforderungen erforderlich, sodass Sie die Indizierungszeit und den Speicherplatz reduzieren können, ohne die Suchqualität zu beeinträchtigen.

Fehlerbehebung bei der Leistung

Wenn bei Vektorsuchoperationen eine langsame Abfrageleistung oder eine hohe Latenz auftreten, kann die automatische Optimierung Ihren Datensatz analysieren und eine optimalere Konfiguration ermitteln. Der Service bietet spezifische Empfehlungen zur Behebung von Leistungsengpässen, z. B. zur Anpassung der Grafikkonnektivität oder der Suchparameter.

Einschränkungen

Fakturierung und Kosten

Auto-Optimize verwendet ein Preismodell pro Auftrag, bei dem Sie für jeden erfolgreichen Optimierungsjob zahlen, unabhängig von der Datensatzgröße und den Optimierungskonfigurationen. Fehlgeschlagene oder stornierte Jobs werden Ihnen nicht in Rechnung gestellt. Darüber hinaus wird die automatische Optimierung auf einer anderen Infrastruktur als auf verwalteten oder serverlosen OpenSearch Clustern ausgeführt, sodass die Ressourcennutzung bereits vorhandener Cluster nicht beeinträchtigt wird.

Preismodell

Die Kosten für die automatische Optimierung werden getrennt von den standardmäßigen Rechen- und Speicherkosten für OpenSearch serverlose oder OpenSearch verwaltete Domänen in Rechnung gestellt.

Preisinformationen finden Sie unter Amazon OpenSearch Service Pricing.

Unterstützte Datumsformate

Auto-Optimize unterstützt die folgenden Datenformate für in Amazon S3 gespeicherte Vektordatensätze:

Parkett-Format

Parquet ist ein spaltenförmiges Speicherformat, das für analytische Workloads optimiert ist. Jede Parquet-Datei sollte eine Spalte mit Float-Arrays enthalten, die Ihre Vektordaten darstellen.

Beispiel für eine Parquet-Dateistruktur (als Tabelle betrachtet):

| 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] |

JSONL-Format

JSONL (JSON Lines) ist ein Textformat, bei dem jede Zeile ein gültiges JSON-Objekt ist. Jede Zeile sollte ein Feld mit einem Float-Array enthalten, das Ihre Vektordaten darstellt.

Beispiel für eine JSONL-Datei:

{"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]}

Konvertierung zwischen Formaten

Wenn Ihre Daten in einem anderen Format vorliegen, können Sie sie mit den folgenden Python-Skripten konvertieren.

Konvertieren Sie JSON oder JSONL nach 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)

Konvertiere Parquet in 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)

Verwandte Funktionen

Die automatische Optimierung arbeitet mit anderen Funktionen von Amazon OpenSearch Service zusammen, um Sie bei der Erstellung und Optimierung von Vektorsuchanwendungen zu unterstützen: