Mengurangi Biaya LLM: Strategi Optimisasi Token

Potong biaya LLM sebesar 80% dengan optimisasi token yang cerdas

Konten Halaman

Optimasi token adalah keterampilan kritis yang membedakan aplikasi LLM yang hemat biaya dari eksperimen yang menghabiskan anggaran.

Dengan biaya API yang meningkat secara linear seiring penggunaan token, memahami dan menerapkan strategi optimasi dapat mengurangi biaya hingga 60-80% sambil mempertahankan kualitas.

arsitektur cerdas

Memahami Ekonomi Token

Sebelum mengoptimalkan, Anda perlu memahami bagaimana token dan harga bekerja di berbagai penyedia LLM.

Dasar Token

Token adalah unit dasar yang diproses oleh LLM - sekitar setara dengan 4 karakter atau 0,75 kata dalam bahasa Inggris. String “Hello, world!” mengandung sekitar 4 token. Model-model berbeda menggunakan tokenizer yang berbeda (GPT menggunakan tiktoken, Claude menggunakan tokenizer mereka sendiri), sehingga jumlah token bervariasi sedikit antar penyedia.

Perbandingan Model Harga

Harga OpenAI (per 2025):

  • GPT-4 Turbo: $0,01 input / $0,03 output per 1K token
  • GPT-3.5 Turbo: $0,0005 input / $0,0015 output per 1K token
  • GPT-4o: $0,005 input / $0,015 output per 1K token

Harga Anthropic:

  • Claude 3 Opus: $0,015 input / $0,075 output per 1K token
  • Claude 3 Sonnet: $0,003 input / $0,015 output per 1K token
  • Claude 3 Haiku: $0,00025 input / $0,00125 output per 1K token

Untuk perbandingan menyeluruh tentang Penyedia LLM Cloud termasuk harga, fitur, dan kasus penggunaan, lihat panduan kami yang dedikasikan.

Insight Penting: Token output biayanya 2-5x lebih mahal dibandingkan token input. Membatasi panjang output memiliki dampak besar terhadap biaya.

Rekayasa Prompt untuk Efisiensi

Rekayasa prompt yang efektif secara dramatis mengurangi konsumsi token tanpa mengorbankan kualitas.

1. Menghilangkan Redundansi

Contoh Buruk (127 token):

Anda adalah asisten yang ramah. Silakan bantu saya dengan tugas berikut.
Saya ingin Anda menganalisis teks berikut dan memberi saya ringkasan.
Berikut adalah teks yang ingin saya ringkas:
[text]
Silakan berikan ringkasan singkat dari poin utama.

Optimalkan (38 token):

Ringkaskan poin utama:
[text]

Penghematan: Pengurangan token sebesar 70%, kualitas output identik.

2. Gunakan Format Terstruktur

JSON dan output terstruktur mengurangi pemborosan token dari bahasa alami yang panjang.

Alih-alih:

Silakan ekstrak nama, usia, dan pekerjaan dari teks ini
dan format respons Anda secara jelas.

Gunakan:

Ekstrak ke JSON: {nama, usia, pekerjaan}
Teks: [input]

3. Optimasi Pembelajaran dengan Beberapa Contoh

Contoh beberapa contoh sangat kuat tetapi mahal. Optimalkan dengan:

  • Gunakan contoh minimum yang diperlukan (1-3 biasanya cukup)
  • Jaga contoh ringkas - hilangkan kata-kata yang tidak perlu
  • Bagikan awalan umum - kurangi instruksi yang diulang
# Prompt optimasi few-shot
prompt = """Klasifikasikan sentimen (pos/neg):
Teks: "Produk hebat!" -> pos
Teks: "Kecewa" -> neg
Teks: "{user_input}" ->"""

Untuk pola optimasi Python lainnya dan singkatan sintaks, lihat Kartu Panduan Python.

Strategi Penyimpanan Konteks

Penyimpanan konteks adalah strategi optimasi paling efektif untuk aplikasi dengan konten statis yang berulang.

Cara Penyimpanan Konteks Bekerja

Penyedia seperti OpenAI dan Anthropic menyimpan awalan prompt yang muncul di beberapa permintaan. Bagian yang disimpan biayanya 50-90% lebih murah dibandingkan token biasa.

Persyaratan:

  • Konten yang dapat disimpan minimum: 1024 token (OpenAI) atau 2048 token (Anthropic)
  • TTL cache: 5-60 menit tergantung penyedia
  • Konten harus identik dan muncul di awal prompt

Contoh Implementasi

from openai import OpenAI

client = OpenAI()

# Pesan sistem yang disimpan di seluruh permintaan
SYSTEM_PROMPT = """Anda adalah AI layanan pelanggan untuk TechCorp.
Kebijakan perusahaan:
[ Dokumen kebijakan besar - 2000 token]
"""

# Ini secara otomatis disimpan
response = client.chat.completions.create(
    model="gpt-4-turbo",
    messages=[
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": "Bagaimana cara mengembalikan barang?"}
    ]
)

# Panggilan berikutnya dalam TTL cache menggunakan prompt sistem yang disimpan
# Hanya membayar untuk pesan pengguna + output

Dampak Nyata: Aplikasi dengan basis pengetahuan atau instruksi panjang melihat pengurangan biaya sebesar 60-80%.

Strategi Pemilihan Model

Menggunakan model yang tepat untuk setiap tugas sangat penting untuk optimasi biaya.

Tangga Model

  1. GPT-4 / Claude Opus - Penalaran kompleks, tugas kreatif, akurasi kritis
  2. GPT-4o / Claude Sonnet - Keseimbangan kinerja/biaya, tujuan umum
  3. GPT-3.5 / Claude Haiku - Tugas sederhana, klasifikasi, ekstraksi
  4. Model kecil yang dilatih ulang - Tugas berulang khusus

Pola Pengarah

def route_request(task_complexity, user_query):
    """Pengarah ke model yang sesuai berdasarkan kompleksitas"""
    
    # Klasifikasi sederhana - gunakan Haiku
    if task_complexity == "simple":
        return call_llm("claude-3-haiku", user_query)
    
    # Menengah - gunakan Sonnet
    elif task_complexity == "moderate":
        return call_llm("claude-3-sonnet", user_query)
    
    # Penalaran kompleks - gunakan Opus
    else:
        return call_llm("claude-3-opus", user_query)

Studi Kasus: Chatbot layanan pelanggan yang mengarahkan 80% pertanyaan ke GPT-3.5 dan 20% ke GPT-4 mengurangi biaya sebesar 75% dibandingkan menggunakan GPT-4 untuk semuanya.

Pemrosesan Batch

Untuk beban kerja yang tidak mendesak, pemrosesan batch menawarkan diskon 50% dari sebagian besar penyedia.

API Batch OpenAI

from openai import OpenAI
client = OpenAI()

# Membuat file batch
batch_requests = [
    {"custom_id": f"request-{i}", 
     "method": "POST",
     "url": "/v1/chat/completions",
     "body": {
         "model": "gpt-3.5-turbo",
         "messages": [{"role": "user", "content": query}]
     }}
    for i, query in enumerate(queries)
]

# Kirim batch (diskon 50%, pemrosesan 24 jam)
batch = client.batches.create(
    input_file_id=upload_batch_file(batch_requests),
    endpoint="/v1/chat/completions",
    completion_window="24h"
)

Kasus Penggunaan:

  • Labeling dan anotasi data
  • Pembuatan konten untuk blog/SEO
  • Pembuatan laporan
  • Penerjemahan batch
  • Pembuatan dataset sintetis

Teknik Kontrol Output

Karena token output biayanya 2-5x lebih mahal, mengontrol panjang output sangat kritis.

1. Tetapkan Max Tokens

response = client.chat.completions.create(
    model="gpt-4",
    messages=messages,
    max_tokens=150  # Batas keras mencegah biaya yang tidak terkendali
)

2. Gunakan Stop Sequences

response = client.chat.completions.create(
    model="gpt-4",
    messages=messages,
    stop=["END", "\n\n\n"]  # Berhenti di marker
)

3. Minta Format yang Ringkas

Tambahkan instruksi seperti:

  • “Jawab dalam kurang dari 50 kata”
  • “Hanya berikan poin-poin saja”
  • “Kembalikan hanya JSON, tanpa penjelasan”

Streaming untuk UX yang Lebih Baik

Meskipun streaming tidak mengurangi biaya, hal ini meningkatkan performa yang dirasakan dan memungkinkan terminasi dini.

stream = client.chat.completions.create(
    model="gpt-4",
    messages=messages,
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        token = chunk.choices[0].delta.content
        print(token, end="")
        
        # Terminasi dini jika respons menyimpang
        if undesired_pattern(token):
            break

Optimasi RAG

Generasi Augmented Retrieval (RAG) menambah konteks, tetapi RAG yang tidak dioptimalkan membuang token.

Pola RAG Efisien

def optimized_rag(query, vector_db):
    # 1. Cari fragmen relevan
    chunks = vector_db.search(query, top_k=3)  # Tidak terlalu banyak
    
    # 2. Kompresi fragmen - hilangkan redundansi
    compressed = compress_chunks(chunks)  # Kompresi khusus
    
    # 3. Potong hingga batas token
    context = truncate_to_tokens(compressed, max_tokens=2000)
    
    # 4. Prompt terstruktur
    prompt = f"Konteks:\n{context}\n\nQ: {query}\nA:"
    
    return call_llm(prompt)

Teknik Optimasi:

  • Gunakan chunking semantik (bukan ukuran tetap)
  • Hilangkan format markdown dari fragmen yang diambil
  • Implementasikan re-ranking untuk mendapatkan konten paling relevan
  • Pertimbangkan ringkasan chunk untuk dokumen besar

Penyimpanan Respons

Simpan permintaan yang identik atau mirip untuk menghindari panggilan API sama sekali.

Implementasi dengan Redis

import redis
import hashlib
import json

redis_client = redis.Redis()

def cached_llm_call(prompt, model="gpt-4", ttl=3600):
    # Membuat cache key dari prompt + model
    cache_key = hashlib.md5(
        f"{model}:{prompt}".encode()
    ).hexdigest()
    
    # Periksa cache
    cached = redis_client.get(cache_key)
    if cached:
        return json.loads(cached)
    
    # Panggil LLM
    response = call_llm(model, prompt)
    
    # Simpan hasil
    redis_client.setex(
        cache_key, 
        ttl, 
        json.dumps(response)
    )
    
    return response

Penyimpanan Semantik: Untuk permintaan yang mirip (tidak identik), gunakan embedding vektor untuk menemukan respons yang disimpan.

Pemantauan dan Analitik

Lacak penggunaan token untuk mengidentifikasi peluang optimasi.

Metrik Penting

class TokenTracker:
    def __init__(self):
        self.metrics = {
            'total_tokens': 0,
            'input_tokens': 0,
            'output_tokens': 0,
            'cost': 0.0,
            'requests': 0
        }
    
    def track_request(self, response, model):
        usage = response.usage
        self.metrics['input_tokens'] += usage.prompt_tokens
        self.metrics['output_tokens'] += usage.completion_tokens
        self.metrics['total_tokens'] += usage.total_tokens
        self.metrics['cost'] += calculate_cost(usage, model)
        self.metrics['requests'] += 1
    
    def report(self):
        return {
            'avg_tokens_per_request': 
                self.metrics['total_tokens'] / self.metrics['requests'],
            'total_cost': self.metrics['cost'],
            'input_output_ratio': 
                self.metrics['input_tokens'] / self.metrics['output_tokens']
        }

Peringatan Biaya

Atur peringatan ketika penggunaan melebihi ambang batas:

def check_cost_threshold(daily_cost, threshold=100):
    if daily_cost > threshold:
        send_alert(f"Biaya harian ${daily_cost} melebihi ${threshold}")

Teknik Lanjutan

1. Model Kompresi Prompt

Gunakan model khusus untuk mengkompresi prompt:

  • LongLLMLingua
  • AutoCompressors
  • Token kompresi yang dipelajari

Ini dapat mencapai rasio kompresi 10x sambil mempertahankan kinerja tugas 90%+.

2. Decoding Spekulatif

Jalankan model kecil bersama model besar untuk memprediksi token, mengurangi panggilan model besar. Biasanya 2-3x percepatan dan pengurangan biaya untuk kualitas yang serupa.

3. Kuantisasi

Untuk model yang dihosting sendiri, kuantisasi (4-bit, 8-bit) mengurangi memori dan komputasi:

  • 4-bit: ~75% pengurangan memori, kehilangan kualitas minimal
  • 8-bit: ~50% pengurangan memori, kehilangan kualitas tidak signifikan

Jika Anda menjalankan LLM secara lokal, Ollama menyediakan platform yang sangat baik untuk mendeploy model yang dikuantisasi dengan konfigurasi minimal. Untuk pemilihan perangkat keras dan benchmark kinerja, Perbandingan NVIDIA DGX Spark vs Mac Studio vs RTX-4080 menunjukkan kinerja nyata di berbagai konfigurasi perangkat keras yang menjalankan model besar yang dikuantisasi.

Daftar Pemeriksaan Optimisasi Biaya

  • Profil penggunaan token saat ini dan biaya per endpoint
  • Audit prompt untuk redundansi - hilangkan kata-kata yang tidak perlu
  • Implementasikan penyimpanan konteks untuk konten statis > 1K token
  • Atur routing model (kecil untuk sederhana, besar untuk kompleks)
  • Tambahkan batas max_tokens ke semua permintaan
  • Implementasikan penyimpanan respons untuk permintaan yang identik
  • Gunakan API batch untuk beban kerja yang tidak mendesak
  • Aktifkan streaming untuk UX yang lebih baik
  • Optimalkan RAG: lebih sedikit chunk, ranking yang lebih baik
  • Pantau dengan pelacakan token dan peringatan biaya
  • Pertimbangkan pelatihan ulang untuk tugas berulang
  • Evaluasi model kecil (Haiku, GPT-3.5) untuk klasifikasi

Studi Kasus Nyata

Skenario: Chatbot layanan pelanggan, 100K permintaan/bulan

Sebelum Optimisasi:

  • Model: GPT-4 untuk semua permintaan
  • Rata-rata token input: 800
  • Rata-rata token output: 300
  • Biaya: 100K × (800 × 0,00003 + 300 × 0,00006) = $4.200/bulan

Setelah Optimisasi:

  • Routing model: 80% GPT-3.5, 20% GPT-4
  • Penyimpanan konteks: 70% dari prompt disimpan
  • Kompresi prompt: 40% pengurangan
  • Penyimpanan respons: 15% tingkat cache hit

Hasil:

  • 85% permintaan menghindari GPT-4
  • 70% mendapatkan diskon dari penyimpanan konteks
  • 40% token input lebih sedikit
  • Biaya efektif: $780/bulan
  • Penghematan: 81% ($3.420/bulan)

Tautan Berguna

Kesimpulan

Optimasi token mengubah ekonomi LLM dari sangat mahal menjadi skalabel secara berkelanjutan. Dengan menerapkan kompresi prompt, penyimpanan konteks, pemilihan model yang cerdas, dan penyimpanan respons, sebagian besar aplikasi mencapai pengurangan biaya sebesar 60-80% tanpa mengorbankan kualitas.

Mulailah dengan kemenangan cepat: audit prompt Anda, aktifkan penyimpanan konteks, dan arahkan tugas sederhana ke model kecil. Pantau penggunaan token Anda secara religius - apa yang diukur akan dioptimalkan. Perbedaan antara aplikasi LLM yang hemat biaya dan yang mahal bukanlah teknologi—ini adalah strategi optimisasi.

Artikel Terkait