AWS: LLM HuggingFace RAG

Berikut adalah panduan umum dan langkah-langkah yang dapat Anda ambil untuk membangun pipeline Retrieval Augmented Generation (RAG) sederhana menggunakan LLM dari Hugging Face di lingkungan AWS. Pendekatan ini tidak satu-satunya, namun dapat menjadi starting point yang solid.

Konsep Dasar RAG:

RAG umumnya melibatkan dua bagian utama:

• Retrieval (Pengambilan Informasi): Mengambil dokumen atau informasi relevan dari suatu knowledge base (misalnya kumpulan dokumen yang telah diindeks dan diembedding ke dalam vector store).

• Augmented Generation (Pengayaan Prompt): Menggabungkan hasil retrieval tersebut ke dalam prompt yang diberikan ke model bahasa (LLM), sehingga model dapat memberikan jawaban yang kontekstual dan lebih akurat.

Lingkungan AWS yang Bisa Digunakan:

• Amazon EC2 atau Amazon SageMaker: Untuk men-deploy model LLM Hugging Face.
• Amazon S3: Untuk menyimpan data dokumen asli, model checkpoint, maupun embedding hasil proses.
• Layanan untuk Vector Store:
  • Amazon OpenSearch Service dengan plugin vector search: Anda dapat mengindeks embedding dokumen di sini.
  • Alternatifnya, Anda bisa menggunakan basis data terkelola lain yang mendukung vector search, atau bahkan menyimpan embedding di database sendiri (misalnya DynamoDB) dan memprosesnya dengan FAISS secara manual di dalam container.
• Amazon Lambda / AWS API Gateway (opsional): Untuk menyiapkan endpoint yang memproses query user, melakukan retrieval, lalu memanggil model.

Langkah-Langkah Detail:

• Persiapan Model LLM di AWS:
  • Anda dapat memulai dengan model open-source LLM dari Hugging Face Hub (misalnya Llama 2, Falcon, atau Dolly) yang telah tersedia di SageMaker JumpStart.
  • Jika Anda ingin menggunakan model custom dari Hugging Face, Anda dapat:
  • Unduh model dan simpan ke Amazon S3, lalu gunakan SageMaker untuk men-deploy container inference Hugging Face.
  • SageMaker menyediakan `HuggingFaceModel` yang memudahkan proses ini:

from sagemaker.huggingface import HuggingFaceModel

huggingface_model = HuggingFaceModel(
     model_data='s3://bucket-name/path/to/model.tar.gz',
     role='arn:aws:iam::111122223333:role/SageMakerRole',
     transformers_version='4.17',
     pytorch_version='1.10',
     py_version='py38'
 )

predictor = huggingface_model.deploy(
     initial_instance_count=1,
     instance_type='ml.g4dn.xlarge'
 )

• Pastikan Anda sudah menyesuaikan tipe instance dengan kebutuhan GPU/CPU.

• Membangun Vector Embedding untuk Dokumen:
  • Ambil kumpulan dokumen (misalnya teks, PDF yang sudah diekstrak isinya, dsb.) dan simpan di Amazon S3.
  • Gunakan model embedding (misalnya `sentence-transformers` atau `Instructor Embeddings`) untuk mengubah teks menjadi embedding vektor. Anda dapat melakukan ini secara offline di EC2 atau job SageMaker Processing:

from sentence_transformers import SentenceTransformer

model = SentenceTransformer('sentence-transformers/all-mpnet-base-v2')
documents = ["Teks dokumen 1", "Teks dokumen 2", "Teks dokumen N"]
embeddings = model.encode(documents)

• • Simpan hasil embedding ke S3 atau langsung indeks ke Amazon OpenSearch.

3. Membuat Index Vector Store di Amazon OpenSearch:

  - Buat domain Amazon OpenSearch dengan fitur vector search diaktifkan.
  - Buat index untuk dokumen:

h

    PUT my-index
    {
      "mappings": {
        "properties": {
          "text": {"type": "text"},
          "embedding": {"type": "knn_vector", "dimension": 768} 
        }
      }
    }

    (Dimension menyesuaikan dengan model embedding yang digunakan.)
  
  - Indeks dokumen beserta embedding-nya ke OpenSearch.

    POST my-index/_doc
    {
      "text": "Teks dokumen 1",
      "embedding": [0.123, 0.234, ...] // embedding vektor hasil encode
    }
    ```

4. Alur Query (RAG):

  - User mengirim pertanyaan (query).  
  - Sistem mengambil pertanyaan user, me-generate embedding query dengan model embedding yang sama.
  - Lakukan pencarian di OpenSearch dengan `knn` search:

    POST my-index/_search
    {
      "size": 3,
      "query": {
        "knn": {
          "embedding": {
            "vector": [0.321, 0.456, ...], // embedding query
            "k": 3
          }
        }
      }
    }
    ```
  - Dapatkan dokumen teratas yang paling relevan.
  - Buat prompt baru untuk LLM dengan format:  

    Context:
    [Dokumen 1]
    [Dokumen 2]
    [Dokumen 3]

    Pertanyaan: {pertanyaan user}
    Jawaban:

  - Kirim prompt tersebut ke endpoint model Hugging Face di SageMaker:

    response = predictor.predict({"inputs": prompt})
    print(response)

5. Orkestrasi Alur:

  - Untuk menyederhanakan pipeline, Anda bisa membungkus semua alur (embedding query, searching di OpenSearch, membangun prompt, memanggil LLM) dalam satu Lambda function.
  - Gunakan AWS API Gateway untuk menyediakan endpoint publik.  
  
  Alurnya menjadi:
  1. User mengirim query ke endpoint API Gateway.
  2. API Gateway memanggil Lambda.
  3. Lambda:
     - Menghitung embedding query.
     - Melakukan knn search ke OpenSearch.
     - Menggabungkan hasil dan membentuk prompt.
     - Memanggil endpoint SageMaker untuk inference LLM.
     - Mengembalikan jawaban ke user.

Tips:

• Optimasi Biaya & Performa: Pertimbangkan untuk menggunakan instance GPU yang sesuai ukuran beban. Untuk beban rendah, Anda dapat memanfaatkan endpoint serverless di SageMaker (jika tersedia untuk model Hugging Face tertentu) atau scaling policy auto-scaling.

• Keamanan & IAM: Pastikan peran IAM (misalnya peran SageMaker, peran Lambda) memiliki hak akses untuk membaca S3, query OpenSearch, dan memanggil endpoint inference.

• Penyesuaian Prompt: Kualitas jawaban sangat tergantung dari cara Anda menyusun prompt dengan konteks hasil retrieval. Eksperimen dengan panjang konteks, jumlah dokumen, serta format prompt.

• Monitoring & Logging: Gunakan CloudWatch untuk memonitor kinerja inference endpoint, Lambda, dan OpenSearch queries. Log detail query & response untuk memudahkan debugging.

Dengan langkah-langkah di atas, Anda akan memiliki pipeline RAG sederhana: dokumen disimpan, diencode menjadi embedding, diindeks, dan pada saat query masuk, sistem akan melakukan retrieval sebelum mengumpankan konteks ke LLM yang dijalankan di AWS.