Optimalkan otomatis

Optimalkan otomatis adalah layanan yang mengotomatiskan pengoptimalan indeks vektor, memungkinkan pengguna menyeimbangkan kualitas pencarian, kecepatan, dan biaya tanpa memerlukan penyetelan ahli manual selama berminggu-minggu. Ini mengevaluasi konfigurasi indeks berdasarkan latensi yang ditentukan pengguna dan persyaratan penarikan dan menghasilkan rekomendasi pengoptimalan, sehingga diperlukan keahlian minimal. Rekomendasi biasanya disampaikan dalam 30-60 menit.

Konfigurasi indeks vektor tradisional membutuhkan keahlian dan eksperimen yang signifikan untuk mencapai kinerja yang optimal. Parameter seperti ef_construction (yang mengontrol kualitas pembuatan indeks), m (yang menentukan jumlah koneksi grafik), (yang mengontrol pencarian HNSW), dan metode kuantisasi ef_search (Kuantisasi Biner (32x, 16x, 8x), kuantisasi skalar (4x)) berdampak signifikan pada akurasi pencarian dan pemanfaatan sumber daya. Optimalkan otomatis menggunakan algoritme pengoptimalan hiperparameter untuk menemukan konfigurasi indeks yang optimal secara unik untuk kumpulan data Anda dalam persyaratan latensi dan penarikan yang ditentukan.

Manfaat

Optimalkan otomatis untuk OpenSearch memberikan manfaat berikut:

• Penyetelan parameter otomatis - Menghilangkan eksperimen manual dengan algoritma (HNSW), kuantisasi, rescoring dan parameter mesin, menghemat waktu dan mengurangi kurva pembelajaran untuk optimasi pencarian vektor.

• Optimalkan kecepatan pencarian - Secara default, OpenSearch dikonfigurasi untuk kinerja dalam memori. Optimalkan otomatis menemukan trade-off yang menguntungkan yang meningkatkan kualitas pencarian dan penghematan biaya sambil mempertahankan kecepatan pencarian yang dapat diterima.

• Pengoptimalan biaya - Mengurangi biaya dengan menemukan opsi untuk mengurangi persyaratan memori indeks Anda sambil meminimalkan kualitas pencarian dan pertukaran kecepatan.

• Optimalkan kualitas pencarian - Berpotensi memberikan penarikan yang lebih tinggi daripada pengaturan default, atau temukan trade-off yang menguntungkan yang memberikan penghematan biaya yang signifikan dengan kerugian penarikan minimal.

Optimalkan otomatis bekerja bersama OpenSearch fitur lain seperti GPU-percepatan untuk pengindeksan vektor untuk memberikan pengoptimalan kinerja yang komprehensif untuk beban kerja pencarian vektor.

Cara kerjanya

Optimalkan otomatis beroperasi melalui arsitektur berbasis pekerjaan yang menganalisis data vektor Anda dan memberikan rekomendasi pengoptimalan. Poin kunci:

• Pengguna membagikan kumpulan data mereka sebagai dokumen OpenSearch JSON dalam format parket dalam ember Amazon S3.

• Mereka mengonfigurasi pekerjaan optimasi otomatis tanpa server dengan mengonfigurasi ambang penarikan dan latensi yang dapat diterima. Ambang batas yang lebih santai memungkinkan layanan menemukan pengoptimalan biaya yang lebih signifikan.

• Pekerjaan yang dioptimalkan secara otomatis dijalankan pada infrastruktur yang dikelola sepenuhnya oleh Amazon Service. OpenSearch Pekerjaan tidak menggunakan sumber daya di domain atau koleksi Anda. Pekerja berjalan secara paralel untuk mengevaluasi konfigurasi indeks, dan menggunakan pengambilan sampel pada kumpulan data besar untuk memberikan hasil biasanya dalam waktu 30-60 menit.

• Setiap pekerjaan ditagih dengan tarif tetap yang dapat diprediksi. Untuk informasi harga, lihat Harga OpenSearch Layanan Amazon.

Prasyarat

• Format dan izin set data - Anda harus memiliki kumpulan data yang tersedia sebagai satu set (satu atau banyak) file parket di folder bucket Amazon S3. Misalnya, jika dataset dibagi menjadi dua file yang disebut s3://dataset-bucket-us-east-1/dataset_folder/first_half.parquet dans3://dataset-bucket-us-east-1/dataset_folder/second_half.parquet, maka Anda harus menempatkan s3://dataset-bucket-us-east-1/dataset_folder/ di sini. Dataset ini akan digunakan untuk menghasilkan rekomendasi. Pastikan peran federasi Anda memiliki izin Amazon S3 berikut pada sumber daya tersebut:. "s3:Get*", "s3:List*", "s3:Describe*"

• Tentukan metadata kumpulan data yang benar - Dataset parket yang disediakan harus berisi baris nilai float. Nama setiap kolom dan dimensi setiap vektor harus sesuai dengan opsi yang disediakan di konsol. Misalnya, jika kumpulan data berisi vektor yang diberi nama train_data yang masing-masing 768 dimensi, nilai ini harus cocok dengan konsol optimasi otomatis.

• (Jika menggunakan fitur konsumsi vektor) - Jika Anda berencana untuk menggunakan fitur konsumsi (mengambil rekomendasi optimasi otomatis untuk secara otomatis membuat indeks dan menelan data), Anda harus mengonfigurasi cluster Anda untuk memberikan izin optimasi otomatis untuk menyerap kumpulan data parket Anda ke dalam OpenSearch cluster. OpenSearch Untuk OpenSearch domain dengan kebijakan akses domain, berikan akses peran yang baru dibuat melalui kebijakan tersebut. Untuk OpenSearch domain dengan kontrol akses berbutir halus, tambahkan peran pipeline sebagai peran backend. Untuk koleksi OpenSearch Tanpa Server, tambahkan peran pipeline ke kebijakan akses data.

• Izin IAM - Anda memerlukan izin IAM berikut untuk menggunakan optimasi otomatis:

  • opensearch:SubmitAutoOptimizeJob

  • opensearch:GetAutoOptimizeJob

  • opensearch:DeleteAutoOptimizeJob

  • opensearch:CancelAutoOptimizeJob

  • opensearch:ListAutoOptimizeJobs

  catatan

  Ini adalah kebijakan berbasis identitas. Optimalkan otomatis tidak mendukung kebijakan berbasis sumber daya.

• Credential expiry - Konfigurasikan sesi pengguna federasi Anda untuk memiliki masa berlaku kredensi minimum minimal 1 jam. Untuk kumpulan data yang sangat besar atau dimensi tinggi, pertimbangkan untuk meningkatkan durasi kedaluwarsa hingga 3 jam.

Kasus penggunaan untuk optimasi otomatis

Optimalkan otomatis sangat berharga dalam skenario berikut:

Optimalisasi konfigurasi awal

Saat pertama kali menerapkan aplikasi pencarian vektor, menentukan parameter HNSW yang optimal seringkali membutuhkan pengujian ekstensif dan keahlian domain. Optimalkan otomatis menghilangkan trial-and-error proses ini dengan menganalisis data dan karakteristik beban kerja Anda untuk merekomendasikan konfigurasi siap produksi.

Kasus penggunaan ini ideal untuk tim yang baru mengenal pencarian vektor atau mereka yang bermigrasi dari platform basis data vektor lain yang perlu membuat konfigurasi dasar dengan cepat.

Optimalisasi penskalaan

Saat kumpulan data vektor Anda tumbuh dari ribuan menjadi jutaan vektor, parameter yang bekerja dengan baik pada awalnya mungkin menjadi kurang optimal. Optimalkan otomatis merekomendasikan penyesuaian untuk mempertahankan kinerja dalam skala besar.

Pengurangan biaya

Indeks vektor dapat mengkonsumsi sumber daya komputasi dan penyimpanan yang signifikan, terutama dengan penyematan dimensi tinggi. Optimalkan otomatis mengidentifikasi peluang untuk mengurangi biaya dengan menemukan konfigurasi parameter yang lebih efisien yang mempertahankan tingkat kinerja yang diperlukan sambil menggunakan lebih sedikit sumber daya.

Misalnya, optimasi otomatis mungkin menemukan bahwa m nilai Anda saat ini (keterhubungan grafik) lebih tinggi dari yang diperlukan untuk persyaratan akurasi Anda, memungkinkan Anda mengurangi waktu pengindeksan dan penyimpanan tanpa memengaruhi kualitas pencarian.

Penyelesaian masalah kinerja

Saat mengalami kinerja kueri yang lambat atau latensi tinggi dalam operasi pencarian vektor, optimasi otomatis dapat menganalisis kumpulan data Anda dan mengidentifikasi konfigurasi yang lebih optimal. Layanan ini memberikan rekomendasi khusus untuk mengatasi kemacetan kinerja, seperti menyesuaikan konektivitas grafik atau parameter pencarian.

Batasan

• Ketersediaan regional - Optimalkan otomatis hanya tersedia di AWS Wilayah berikut:

  • ap-south-1

  • eu-west-1

  • us-west-2

  • us-east-2

  • us-east-1

  • eu-central-1

  • ap-southeast-2

  • ap-northeast-1

  • ap-southeast-1

• Jenis koleksi - Optimalkan otomatis hanya didukung untuk Koleksi dan OpenSearch Domain Pencarian Vektor (2.19, 3.1, dan 3.3).

• Dukungan mesin

  Dukungan mesin berdasarkan jenis penyebaran

  Engine	Nirserver	OpenSearch Dikelola
  Lucene	Tidak	Ya
  Faiss	Ya	Ya
  Nmslib	Tidak	Tidak

• Dukungan algoritma - Optimalkan otomatis hanya mendukung indeks vektor berbasis HNSWW.

• Pekerjaan bersamaan - Anda dapat menjalankan hingga 10 pekerjaan pengoptimalan bersamaan per akun per Wilayah. Tidak ada pekerjaan baru yang dapat diterima jika batas tercapai.

• Durasi pekerjaan - Pekerjaan pengoptimalan dapat berlangsung dari 15 menit hingga beberapa jam tergantung pada ukuran set data, dimensi, dan metrik kinerja yang diperlukan.

• Rekomendasi - Optimalkan otomatis hanya menyarankan hingga 3 rekomendasi.

• Dataset

  • Format yang didukung: parket

  • Toko data: Amazon S3

Penagihan dan biaya

Optimalkan otomatis menggunakan model penetapan harga per pekerjaan tempat Anda membayar untuk setiap pekerjaan pengoptimalan yang berhasil terlepas dari ukuran kumpulan data dan konfigurasi pengoptimalan. Anda tidak akan dikenakan biaya untuk pekerjaan yang gagal atau dibatalkan. Selain itu, optimasi otomatis berjalan pada infrastruktur terpisah daripada OpenSearch cluster yang dikelola atau tanpa server, sehingga tidak mempengaruhi pemanfaatan sumber daya dari cluster yang sudah ada sebelumnya.

Model penentuan harga

Biaya optimasi otomatis ditagih secara terpisah dari biaya komputasi dan penyimpanan domain OpenSearch Tanpa Server atau OpenSearch Terkelola standar.

Untuk informasi harga, lihat Harga OpenSearch Layanan Amazon.

Konversikan JSONL ke Parket

Jika data Anda dalam format JSONL, Anda dapat menggunakan skrip Python berikut untuk mengubahnya menjadi format Parket untuk digunakan dengan optimasi otomatis:

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

Fitur terkait

Optimalkan otomatis bekerja sama dengan fitur OpenSearch Layanan Amazon lainnya untuk membantu Anda membangun dan mengoptimalkan aplikasi pencarian vektor:

• GPU-percepatan untuk pengindeksan vektor- Mempercepat pembuatan indeks vektor menggunakan akselerasi GPU untuk mengurangi waktu dan biaya pengindeksan.

• Konsumsi vektor- Cepat menelan dan mengindeks data vektor dari Amazon S3 ke dalam domain atau koleksi Anda.