Menguasai Zero-shot dan Few-shot Prompting untuk LLM

Pendahuluan

Halo teman-teman developer! Senang sekali bisa kembali lagi di seri pengembangan Chatbot berbasis LLM. Pada artikel sebelumnya, kita sudah membahas tentang dasar-dasar Prompt Engineering dan bagaimana instruksi yang presisi dapat mengubah hasil dari sebuah model bahasa besar (LLM) secara drastis.

Namun, ada kalanya instruksi teks saja tidak cukup. Terkadang, kita menghadapi tugas yang sangat spesifik, seperti mengubah format teks yang berantakan menjadi JSON yang rapi, atau mengklasifikasikan sentimen dengan gaya bahasa gaul khas Indonesia yang sangat unik. Jika kita hanya memberikan instruksi (instruksi murni), LLM mungkin akan bingung atau memberikan jawaban yang tidak sesuai format yang kita harus.

Di artikel ke-5 ini, kita akan mempelajari dua teknik tingkat lanjut yang sangat krusial namun tetap ramah bagi pemula: Zero-shot Prompting dan Few-shot Prompting. Kita akan melihat bagaimana teknik ini bekerja dengan memberikan “contoh” kepada model, sehingga kita tidak perlu melakukan retraining atau fine-tuning yang mahal hanya untuk mengajarkan pola baru kepada chatbot kita. Di akhir tutorial, kita akan mengimplementasikan teknik ini ke dalam proyek Chatbot Sederhana yang sedang kita bangun.

Zero-shot Prompting: Langsung ke Inti

Zero-shot prompting adalah teknik yang paling sederhana. Sesuai namanya, “zero-shot” berarti kita memberikan tugas kepada LLM tanpa memberikan satu pun contoh sebelumnya. Kita hanya memberikan instruksi (prompt) dan mengharapkan model untuk memahami tugas tersebut berdasarkan pengetahuan yang sudah ia miliki selama masa pelatihan (pre-training).

Teknik ini sangat bergantung pada seberapa pintar model tersebut dalam memahami bahasa alami. Jika tugasnya bersifat umum, seperti “Ringkaslah teks berikut”, maka zero-shot biasanya sudah sangat mumpuni.

Mari kita lihat contoh implementasi zero-shot menggunakan Python untuk melakukan analisis sentimen pada ulasan belanja di sebuah marketplace lokal seperti Tokopedia.

import openai

# Inisialisasi client (asumsi menggunakan OpenAI API)
client = openai.OpenAI(api_key="SK-ANDA-DI-SINI")

def analyze_sentiment_zero_shot(review_text):
    # Prompt zero-shot: Hanya instruksi tanpa contoh
    prompt = f"""
    Tugas: Klasifikasikan sentimen dari ulasan pembeli berikut ke dalam kategori: Positif, Negatif, atau Netral.
    
    Ulasan: "{review_text}"
    Sentimen:
    """
    
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}]
    )
    
    return response.choices[0].message.content.strip()

# Contoh penggunaan dengan konteks lokal
review_1 = "Barangnya sampai dengan cepat, packing aman banget. Terima kasih seller!"
review_2 = "Kecewa banget, barang yang dikirim tidak sesuai pesanan. Harusnya warna biru, malah merah."
reviewly_3 = "Barang sudah diterima, standar saja sesuai harga."

print(f"Review 1: {analyze_sentiment_zero_shot(review_1)}")
print(f"Review 2: {analyze_sentiment_zero_shot(review_2)}")
print(f"Review 3: {analyze_sentiment_zero_shot(review_3)}")

Pada kode di atas, Anda bisa melihat bahwa kita tidak memberikan contoh ulasan sebelumnya. Kita langsung memberikan instruksi: “Klasifikasikan sentimen…”. LLM sudah cukup pintar untuk mengenali kata “cepat” dan “aman” sebagai sentimen positif tanpa perlu kita beri contoh.

Few-shot Prompting: Memberikan Contoh Pola

Lalu, bagaimana jika tugasnya sangat spesifik? Misalnya, kita ingin chatbot kita mengekstrak data dari chat WhatsApp yang berantakan menjadi format JSON yang sangat kaku. Jika kita hanya menggunakan zero-shot, LLM mungkin akan memberikan teks tambahan seperti “Berikut adalah data yang Anda minta: …”, yang mana akan merusak proses parsing di aplikasi kita.

Di sinilah Few-lag-shot Prompting berperan. Kita memberikan beberapa pasang “Input” dan “Output” (disebut sebagai shots) sebelum memberikan input utama yang ingin kita proses. Dengan memberikan 2-5 contoh, kita sebenarnya sedang menunjukkan “pola” yang kita inginkan kepada LLM.

Mari kita coba kasus ekstraksi data transaksi belanja menggunakan few-shot prompting.

import openai

client = openai.OpenAI(api_key="SK-ANDA-DI-SINI")

def extract_transaction_few_shot(user_input):
    # Prompt few-shot: Memberikan 3 contoh (3-shot prompting)
    prompt = f"""
    Tugas: Ekstrak informasi transaksi dari pesan berikut ke dalam format JSON.
    Format JSON harus berisi: 'nama_pembeli', 'item', 'jumlah', 'total_harga'.

    Contoh 1:
    Input: "Halo, saya Budi mau beli kopi susu 2 cup harganya Rp40000"
    Output: {{"nama_pembali": "Budi", "item": "kopi susu", "jumlah": 2, "total_harga": 40000}}

    Contoh 2:
    Input: "Siti pesan martabak manis satu porsi, total bayar Rp55000 ya"
    Output: {{"nama_pembali": "Siti", "item": "martabak manis", "jumlah": 1, "total_harga": 55000}}

    Contoh 3:
    Input: "Andi, order nasi goreng 3 porsi, totalnya Rp75000"
    Output: {{"nama_pembali": "Andi", "item": "nasi goreng", "jumlah": 3, "total_harga": 75000}}

    Contoh Baru:
    Input: "{user_input}"
    Output:
    """

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        temperature=0 # Gunakan temperature 0 agar output konsisten/deterministik
    )
    
    return response.choices[0].message.content.strip()

# Contoh penggunaan
chat_user = "Dewi mau beli sate ayam 5 tusuk, totalnya Rp25000"
print(extract_transaction_few_shot(chat_user))

Perhatikan bagaimana pada Contoh 1, Contoh 2, dan Contoh 3, kita secara konsisten menunjukkan format JSON yang kita inginkan. Dengan melakukan ini, LLM belajar bahwa tugasnya bukan sekadar menjawab, melapaikan pola key-value yang seragam. Penggunaan temperature=0 juga sangat penting dalam few-shot untuk menjaga agar model tidak “berimajinasi” di luar pola yang sudah kita berikan.

Perbedaan Utama dan Kapan Harus Menggunakannya

Sebagai developer, Anda tidak boleh menggunakan few-shot untuk semua hal karena ada biaya (token) yang harus dibayar. Berikut adalah panduan singkatnya:

Gunakan Zero-shot jika: Anda hanya perlu meringkas artikel, menerjemahkan bahasa, atau menjawab pertanyaan umum yang jawabannya sudah ada di dalam basis pengetahuan model.

Gunakan Few-shot jika: Anda ingin output dalam format JSON tertentu, ingin mengklasifikasikan sentimen dengan label khusus (misal: [Sangat_Marah, Marah, Biasa, Senang]), atau ingin mengubah gaya bahasa (misal: mengubah bahasa formal menjadi bahasa gaul Jakarta).

Implementasi pada Proyek Chatbot Kita

Sekarang, mari kita terapkan konsep ini ke dalam struktur utama chatbot yang sedang kita bangun. Kita akan membuat sebuah fungsi handler yang bisa menentukan kapan menggunakan teknik few-shot berdasarkan jenis permintaan pengguna.

class ChatbotEngine:
    def __init__(self):
        self.system_prompt = "Anda adalah asisten toko online yang ramah."

    def process_request(self, user_input):
        # Logika sederhana: Jika input mengandung kata 'format' atau 'data', 
        # kita gunakan teknik few-shot untuk memastikan output JSON.
        
        if "simpan data" in user_input.lower():
            return self._handle_data_extraction(user_input)
        else:
            return self._handle_general_chat(user_input)

    def _handle_general_chat(self, user_input):
        # Menggunakan Zero-shot untuk chat biasa
        print(f"[Zero-Shot Mode] Memproses: {user_input}")
        # (Logika pemanggilan API OpenAI di sini)
        return "Halo! Ada yang bisa saya bantu?"

    def _handle_data_extraction(self, user_input):
        # Menggunakan Few-shot untuk ekstraksi data ke JSON
        print(f"[Few-Shot Mode] Memproses ekstraksi: {user_input}")
        few_shot_prompt = """
        Ekstrak informasi pesanan menjadi JSON.
        Input: Saya beli baju harga 50rb
        Output: {"item": "baju", "harga": 50000}
        Input: Pesan sepatu 150000
        Output: {"item": "sepatu", "harga": 150000}
        Input: """
        # (Logika pemanggilan API OpenAI dengan prompt di atas)
        return '{"item": "...", "harga": ...}'

# Testing
bot = ChatbotEngine()
print(bot.process_request("Halo, apa kabar?"))
print(bot.process_request("Tolong simpan data: Saya beli tas harga 200000"))

Dengan pendekatan ini, chatbot Anda akan menjadi sangat cerdas: ia bisa mengobrol secara natural (hemat token) namun tetap sangat presisi saat diminta melakukan tugas teknis (menggunakan few-shot).

Kesimpulan

Memahami perbedaan antara Zero-shot dan Few-shot adalah kunci untuk membangun aplikasi AI yang efisien secara biaya dan akurat secara fungsional. Jangan ragu untuk menggunakan few-shot pada tugas-tugas kritis yang membutuhkan struktur data yang ketat, namun tetaplah gunakan zero-shot untuk percakapan umum agar aplikasi Anda tetap ringan dan ekonomis.