Tutorial Prompt Chaining: Apa Itu Prompt Chaining dan Cara Menggunakannya?

Pernahkah Anda mencoba merakit furnitur tanpa membaca petunjuk? Kalau beruntung, beberapa bagian mungkin bisa terpasang, tetapi tanpa panduan langkah demi langkah, hasilnya bisa berantakan. Ini mirip dengan tantangan yang dihadapi model bahasa besar (LLM) saat menyelesaikan masalah kompleks. Model-model ini punya potensi luar biasa, tetapi sering meleset ketika suatu tugas memerlukan penalaran mendetail dan bertahap.

Saat diberi satu prompt, LLM mungkin memberikan jawaban yang terlalu umum, kurang mendalam, atau melewatkan detail penting. Keterbatasan ini muncul karena sulitnya menangkap semua konteks yang diperlukan dan memberikan arahan yang memadai dalam satu prompt saja.

Solusinya adalah prompt chaining.

Prompt chaining melibatkan pemecahan tugas kompleks menjadi serangkaian prompt yang lebih kecil dan mudah dikelola. Setiap prompt menangani bagian spesifik dari tugas, dan keluaran dari satu prompt menjadi masukan untuk berikutnya. Metode ini memungkinkan pendekatan yang lebih terstruktur, membimbing LLM melalui rantai langkah penalaran yang menghasilkan jawaban yang lebih akurat dan komprehensif. Dengan urutan prompt yang logis, kita dapat memaksimalkan LLM untuk secara efektif menyelesaikan masalah kompleks.

Tutorial ini adalah bagian dari rangkaian artikel blog saya “Prompt Engineering: From Zero to Hero”:

1. Prompt Engineering untuk Semua Orang
2. Zero-Shot Prompting
3. Few-Shot Prompting
4. Prompt Chaining

Apa Itu Prompt Chaining?

Prompt chaining adalah metode di mana keluaran dari satu prompt LLM digunakan sebagai masukan untuk prompt berikutnya dalam suatu urutan. Teknik ini melibatkan pembuatan serangkaian prompt yang saling terhubung, masing-masing berfokus pada bagian spesifik dari masalah keseluruhan. Mengikuti urutan ini memungkinkan LLM dibimbing melalui proses penalaran terstruktur, membantunya menghasilkan respons yang lebih akurat dan mendetail.

Tujuan utama prompt chaining adalah meningkatkan kinerja, keandalan, dan kejelasan aplikasi LLM. Untuk tugas yang kompleks, satu prompt sering kali tidak memberikan kedalaman dan konteks yang cukup untuk jawaban yang baik. Prompt chaining mengatasinya dengan memecah tugas menjadi langkah-langkah yang lebih kecil, memastikan setiap langkah ditangani dengan cermat. Metode ini meningkatkan kualitas keluaran LLM dan memudahkan pemahaman bagaimana hasil akhir dicapai.

Mari kita lihat beberapa manfaat prompt chaining:

Cara Menerapkan Prompt Chaining

Menerapkan prompt chaining melibatkan pendekatan sistematis untuk memecah tugas kompleks dan membimbing LLM melalui serangkaian langkah yang terdefinisi dengan baik. 

Mari lihat bagaimana Anda dapat membuat dan mengeksekusi rantai prompt secara efektif.

Identifikasi sub-tugas

Langkah pertama dalam prompt chaining adalah menguraikan tugas kompleks menjadi sub-tugas yang lebih kecil dan dapat dikelola. Setiap sub-tugas harus merepresentasikan aspek yang berbeda dari masalah keseluruhan. Dengan cara ini, LLM dapat fokus pada satu bagian pada satu waktu.

Misalnya, Anda ingin LLM menulis laporan komprehensif tentang perubahan iklim. Sub-tugasnya bisa mencakup:

• Meneliti data iklim historis
• Merangkum temuan kunci dari literatur ilmiah
• Menganalisis dampak perubahan iklim pada berbagai ekosistem
• Mengusulkan solusi dan strategi mitigasi potensial

Rancang prompt

Berikutnya, rancang prompt yang jelas dan ringkas untuk setiap sub-tugas. Setiap prompt harus spesifik dan langsung, memastikan LLM memahami tugas dan dapat menghasilkan keluaran yang relevan. Yang penting, keluaran dari satu prompt harus cocok sebagai masukan untuk berikutnya, menciptakan aliran informasi.

Untuk sub-tugas di atas, kita bisa membuat prompt berikut:

• Prompt Sub-tugas 1: "Ringkas tren utama perubahan suhu global selama abad terakhir."
• Prompt Sub-tugas 2: "Berdasarkan tren yang diidentifikasi, daftarkan studi ilmiah utama yang membahas penyebab perubahan tersebut."
• Prompt Sub-tugas 3: "Ringkas temuan dari studi yang terdaftar, dengan fokus pada dampak perubahan iklim terhadap ekosistem laut."
• Prompt Sub-tugas 4: "Usulkan tiga strategi untuk memitigasi dampak perubahan iklim terhadap ekosistem laut berdasarkan temuan yang dirangkum."

Eksekusi rantai

Sekarang, kita perlu mengeksekusi prompt secara berurutan, meneruskan keluaran dari satu prompt sebagai masukan untuk berikutnya. Eksekusi bertahap ini memastikan LLM membangun atas keluarannya sebelumnya, menghasilkan hasil yang koheren dan komprehensif.

Untuk contoh kita, keluaran untuk sub-tugas akan tampak seperti ini:

• Keluaran Sub-tugas 1: "Suhu global meningkat sekitar 1,2 derajat Celsius selama abad terakhir, dengan peningkatan signifikan dalam 20 tahun terakhir."
• Masukan untuk Sub-tugas 2: "Mengingat suhu global meningkat 1,2 derajat Celsius selama abad terakhir, daftarkan studi ilmiah utama yang membahas penyebab perubahan ini."
• Keluaran Sub-tugas 2: "Studi kunci mencakup: 'The Role of Greenhouse Gases in Global Warming' oleh Dr. Smith, 'Deforestation and Climate Change' oleh Dr. Jones, dan 'Oceanic Changes and Climate Patterns' oleh Dr. Lee."
• Masukan untuk Sub-tugas 3: "Ringkas temuan dari 'The Role of Greenhouse Gases in Global Warming' oleh Dr. Smith, 'Deforestation and Climate Change' oleh Dr. Jones, dan 'Oceanic Changes and Climate Patterns' oleh Dr. Lee, dengan fokus pada dampak perubahan iklim terhadap ekosistem laut."

Penanganan galat

Menerapkan mekanisme penanganan galat penting untuk mengatasi potensi masalah selama eksekusi prompt. Ini dapat mencakup menyiapkan pemeriksaan untuk memverifikasi kualitas dan relevansi keluaran sebelum melanjutkan ke prompt berikutnya, serta membuat prompt cadangan untuk mengarahkan LLM kembali ke jalur yang benar jika menyimpang dari harapan. Misalnya:

• Pemeriksaan Galat 1: Setelah setiap keluaran, verifikasi bahwa informasi relevan dan lengkap. Jika ringkasan tren perubahan suhu global tidak lengkap, minta LLM memberikan detail tambahan.
• Prompt Cadangan: Jika LLM gagal mencantumkan studi ilmiah yang relevan, gunakan prompt yang lebih spesifik seperti "Daftarkan lima studi peer-reviewed dari dekade terakhir yang membahas penyebab kenaikan suhu global."

Implementasi

Mari lihat cara mengimplementasikannya di Python!

Langkah 1: Menyiapkan lingkungan

Pertama, kita perlu mengimpor pustaka yang diperlukan. Kita akan menggunakan kelas OpenAI dari paket openai dan os untuk menangani variabel lingkungan.

import openai
import os

Menyimpan informasi sensitif seperti kunci API secara aman sangat krusial. Salah satu caranya adalah dengan menetapkan kunci API sebagai variabel lingkungan. Anda dapat melakukannya menggunakan kunci OpenAI API.

os.environ['OPENAI_API_KEY'] = 'your-api-key-here'

Pastikan untuk mengganti 'your-api-key-here' dengan kunci OpenAI API Anda yang sebenarnya.

Dengan kunci API yang sudah diatur, kini Anda dapat menginisialisasi klien OpenAI. Klien ini akan digunakan untuk melakukan panggilan API ke layanan OpenAI.

Client = OpenAI ()

Langkah 2: Mendefinisikan fungsi untuk berinteraksi dengan chat completions API OpenAI.

Sekarang, kita akan membuat fungsi Python untuk berinteraksi dengan chat completions API OpenAI. Fungsi ini akan mengirim prompt ke API dan mengembalikan respons yang dihasilkan.

def get_completion(prompt, model="gpt-3.5-turbo"):
    try:
        response = client.chat.completions.create(
            model=model,
            messages=[
                {"role": "system", "content": "You are a helpful assistant."},
                {"role": "user", "content": prompt}
            ],
            temperature=0,
        )
        return response.choices[0].message.content
    except Exception as e:
        print(f"An error occurred: {e}")
        return None

Mari uraikan fungsi ini—fungsi ini:

• Menerima prompt dan parameter model opsional.
• Melakukan panggilan API ke OpenAI menggunakan endpoint chat completions.
• Mengatur percakapan dengan pesan sistem dan pesan pengguna (prompt)
• Menetapkan temperature ke 0 untuk keluaran yang lebih deterministik (tingkatkan temperature untuk keluaran yang lebih kreatif).
• Mengembalikan konten respons atau None jika terjadi galat.

Langkah 3: Merangkai beberapa prompt

Sekarang, kita akan membuat fungsi Python yang merangkai beberapa prompt, memberi makan keluaran dari satu prompt sebagai masukan untuk prompt berikutnya.

def prompt_chain(initial_prompt, follow_up_prompts):
    result = get_completion(initial_prompt)
    if result is None:
        return "Initial prompt failed."
    print(f"Initial output: {result}\n")
    for i, prompt in enumerate(follow_up_prompts, 1):
        full_prompt = f"{prompt}\n\nPrevious output: {result}"
        result = get_completion(full_prompt)
        if result is None:
            return f"Prompt {i} failed."
        print(f"Step {i} output: {result}\n")
    return result

Fungsi prompt_chain mengimplementasikan prompt chaining. Fungsi ini:

• Memulai dengan prompt awal dan mengambil completion-nya.
• Melakukan iterasi melalui daftar prompt lanjutan.
• Untuk setiap prompt lanjutan, menggabungkan prompt dengan keluaran sebelumnya, mengambil completion untuk prompt gabungan ini, dan memperbarui hasil.
• Jika ada langkah yang gagal, mengembalikan pesan galat.
• Keluaran setiap langkah dicetak agar terlihat.

Langkah 4: Contoh penggunaan

Sekarang kita akan mendemonstrasikan cara menggunakan fungsi prompt_chain untuk membuat rangkaian prompt yang saling membangun. Contoh ini berfokus pada merangkum tren utama perubahan suhu global dan mengeksplorasi studi ilmiah terkait dan strategi mitigasi, tetapi Anda dapat menerapkannya pada kasus penggunaan Anda sendiri!

initial_prompt = "Summarize the key trends in global temperature changes over the past century."
follow_up_prompts = [
    "Based on the trends identified, list the major scientific studies that discuss the causes of these changes.",
    "Summarize the findings of the listed studies, focusing on the impact of climate change on marine ecosystems.",
    "Propose three strategies to mitigate the impact of climate change on marine ecosystems based on the summarized findings."
]
final_result = prompt_chain(initial_prompt, follow_up_prompts)
print("Final result:", final_result)

Di sini, kita mendefinisikan prompt awal tentang perubahan suhu global, lalu menyiapkan daftar prompt lanjutan yang saling membangun. Selanjutnya, kita memanggil fungsi prompt_chain dengan prompt tersebut dan akhirnya mencetak hasil akhirnya.

Cara kerjanya secara keseluruhan

Mari kita rangkum prosesnya:

1. Prompt awal mendapatkan ringkasan tren suhu.
2. Prompt lanjutan pertama menggunakan ringkasan ini untuk menemukan studi yang relevan.
3. Prompt lanjutan kedua merangkum temuan studi tersebut tentang ekosistem laut.
4. Prompt terakhir menggunakan semua informasi ini untuk mengusulkan strategi mitigasi.

Perangkaian ini memungkinkan pendekatan bertahap untuk kueri kompleks, di mana setiap langkah dibangun dari informasi langkah sebelumnya.

Teknik Prompt Chaining

Prompt chaining dapat diterapkan dengan berbagai cara untuk memenuhi jenis tugas dan kebutuhan yang berbeda. Di sini, kita membahas tiga teknik utama: Sequential Chaining, Conditional Chaining, dan Looping Chaining.

Sequential chaining

Sequential chaining melibatkan pengaitan prompt dalam urutan linier yang lugas. Setiap prompt bergantung pada keluaran dari prompt sebelumnya, menciptakan aliran informasi dan tugas selangkah demi selangkah. Teknik ini ideal untuk tugas yang memerlukan progresi logis dari satu tahap ke tahap berikutnya, seperti:

• Perangkum teks: Memecah dokumen panjang menjadi bagian-bagian ringkasan, kemudian menggabungkan ringkasan tersebut menjadi ringkasan keseluruhan yang koheren.
• Pembuatan kode: Menghasilkan potongan kode selangkah demi selangkah, seperti membuat definisi fungsi terlebih dahulu, kemudian mengimplementasikan fungsi tersebut, dan akhirnya menulis test case.

Cuplikan kode pada bagian sebelumnya adalah contoh sequential chaining.

Conditional chaining

Conditional chaining memperkenalkan percabangan dalam rantai prompt berdasarkan keluaran LLM. Teknik ini memungkinkan alur kerja yang lebih fleksibel dan adaptif, memungkinkan LLM menempuh jalur berbeda tergantung pada respons yang dihasilkannya.

Mari lihat bagaimana kita dapat menerapkan conditional chaining untuk melakukan analisis sentimen.

def analyze_sentiment(text):
    prompt = f"Analyze the sentiment of the following text and respond with only one word - 'positive', 'negative', or 'neutral': {text}"
    sentiment = get_completion(prompt)
    return sentiment.strip().lower()

def conditional_prompt_chain(initial_prompt):
    result = get_completion(initial_prompt)
    if result is None:
        return "Initial prompt failed."
    print(f"Initial output: {result}\n")
    sentiment = analyze_sentiment(result)
    print(f"Sentiment: {sentiment}\n")
    if sentiment == 'positive':
        follow_up = "Given this positive outlook, what are three potential opportunities we can explore?"
    elif sentiment == 'negative':
        follow_up = "Considering these challenges, what are three possible solutions we can implement?"
    else:  # neutral
        follow_up = "Based on this balanced view, what are three key areas we should focus on for a comprehensive approach?"
    final_result = get_completion(f"{follow_up}\n\nContext: {result}")
    return final_result

# Example usage
initial_prompt = "Analyze the current state of renewable energy adoption globally."
final_result = conditional_prompt_chain(initial_prompt)
print("Final result:", final_result)

Pertama, kita mendefinisikan fungsi baru, analyze_sentiment(), yang menggunakan model bahasa untuk menentukan sentimen dari teks tertentu. Lalu, dalam fungsi conditional_prompt_chain(), kita mulai dengan prompt awal tentang adopsi energi terbarukan. Setelah mendapatkan respons awal, kita analisis sentimennya. Berdasarkan sentimen, kita memilih prompt lanjutan yang berbeda:

• Untuk sentimen positif, kita menanyakan peluang.
• Untuk sentimen negatif, kita menanyakan solusi.
• Untuk sentimen netral, kita menanyakan area fokus utama.

Prompt lanjutan yang dipilih kemudian dikirim ke model bahasa bersama konteks dari respons awal. Hasil akhirnya adalah respons terhadap prompt lanjutan bersyarat ini.

Perhatikan bahwa pemilihan prompt kedua tidak ditentukan sebelumnya melainkan bergantung pada konten respons pertama. Selain itu, alur percakapan beradaptasi berdasarkan analisis sentimen, menunjukkan bagaimana rantai dapat bercabang ke jalur yang berbeda. Ini memungkinkan interaksi yang lebih dinamis dan kontekstual dengan model bahasa.

Saat Anda menjalankan kode ini, pertanyaan lanjutan spesifik akan bergantung pada apakah analisis awal adopsi energi terbarukan dipandang positif, negatif, atau netral. Ini menciptakan rantai prompt yang lebih adaptif dan responsif.

Looping chaining

Looping chaining melibatkan pembuatan loop dalam rantai prompt untuk mengiterasi data atau melakukan tugas berulang. Teknik ini berguna saat menangani daftar atau kumpulan item yang memerlukan langkah pemrosesan serupa. Beberapa manfaat dan tantangannya adalah:

• Efisiensi: Mengotomatiskan tugas berulang, menghemat waktu dan upaya.
• Pemrosesan data: Cocok untuk tugas seperti memproses banyak rekaman, ringkasan batch, atau perbaikan iteratif.
• Tantangan: Memerlukan penanganan hati-hati untuk menghindari loop tak berujung dan memastikan setiap iterasi menghasilkan kemajuan yang bermakna.

Mari lihat bagaimana looping chaining diimplementasikan untuk tugas kelengkapan teks:

def check_completeness(text):
    prompt = f"Analyze the following text and respond with only 'complete' if it covers all necessary aspects, or 'incomplete' if more information is needed:\n\n{text}"
    response = get_completion(prompt)
    return response.strip().lower() == 'complete'

def looping_prompt_chain(initial_prompt, max_iterations=5):
    current_response = get_completion(initial_prompt)
    if current_response is None:
        return "Initial prompt failed."
    print(f"Initial output: {current_response}\n")
    iteration = 0
    while iteration < max_iterations:
        if check_completeness(current_response):
            print(f"Complete response achieved after {iteration + 1} iterations.")
            return current_response
        print(f"Iteration {iteration + 1}: Response incomplete. Expanding...")
        expand_prompt = f"The following response is incomplete. Please expand on it to make it more comprehensive:\n\n{current_response}"
        new_response = get_completion(expand_prompt)
        if new_response is None:
            return f"Expansion failed at iteration {iteration + 1}."
        current_response = new_response
        print(f"Expanded response: {current_response}\n")
        iteration += 1
    print(f"Maximum iterations ({max_iterations}) reached without achieving completeness.")
    return current_response

# Example usage
initial_prompt = "Explain the process of photosynthesis."
final_result = looping_prompt_chain(initial_prompt)
print("Final result:", final_result)

Pertama, kita mendefinisikan fungsi baru, check_completeness(), yang menggunakan model bahasa untuk menentukan apakah suatu respons sudah lengkap atau memerlukan informasi tambahan.

Lalu, dalam fungsi looping_prompt_chain(), kita mulai dengan prompt awal tentang fotosintesis. Setelah mendapatkan respons awal, kita masuk ke sebuah loop:

• Kita memeriksa apakah respons saat ini lengkap menggunakan check_completeness().
• Jika lengkap, kita keluar dari loop dan mengembalikan hasil.
• Jika belum lengkap, kita menghasilkan prompt baru yang meminta perluasan atas respons sebelumnya.
• Kemudian kita mendapatkan respons baru berdasarkan prompt perluasan ini.

Proses ini berlanjut hingga kita mendapatkan respons yang dinilai lengkap atau mencapai jumlah iterasi maksimum (bawaan 5).

Loop memastikan kita terus menyempurnakan dan memperluas respons sampai dianggap lengkap atau batas iterasi tercapai.

Saat Anda menjalankan kode ini, ia akan berupaya memberikan penjelasan fotosintesis yang komprehensif, berpotensi melalui beberapa iterasi perluasan jika respons awal dinilai belum lengkap. Ini menciptakan rantai prompt yang lebih menyeluruh dan adaptif, dengan tujuan menghasilkan hasil akhir yang komprehensif.

Aplikasi Praktis Prompt Chaining

Prompt chaining dapat secara signifikan meningkatkan kemampuan LLM di berbagai aplikasi. Pada bagian ini, kita membahas beberapa penggunaan praktis prompt chaining, menunjukkan bagaimana teknik ini dapat diterapkan pada tugas dunia nyata.

Menjawab pertanyaan atas dokumen

Prompt chaining dapat digunakan untuk merangkum dokumen panjang dan kemudian menghasilkan jawaban untuk pertanyaan spesifik. Ini melibatkan terlebih dahulu memecah dokumen menjadi bagian yang mudah dikelola, merangkum setiap bagian, lalu menggunakan ringkasan tersebut untuk menjawab pertanyaan mendetail.

Mari lihat cara mengimplementasikannya:

def split_document(document, max_length=1000):
    """Split the document into sections of approximately max_length characters."""
    words = document.split()
    sections = []
    current_section = []
    current_length = 0
    for word in words:
        if current_length + len(word) + 1 > max_length and current_section:
            sections.append(' '.join(current_section))
            current_section = []
            current_length = 0
        current_section.append(word)
        current_length += len(word) + 1
    if current_section:
        sections.append(' '.join(current_section))
    return sections

def summarize_section(section):
    prompt = f"Summarize the following text in a concise manner:\n\n{section}"
    return get_completion(prompt)

def answer_question(summaries, question):
    context = "\n\n".join(summaries)
    prompt = f"Given the following context, answer the question:\n\nContext:\n{context}\n\nQuestion: {question}"
    return get_completion(prompt)

def document_qa(document, questions):
    # Step 1: Split the document
    sections = split_document(document)
    print(f"Document split into {len(sections)} sections.")
    # Step 2: Summarize each section
    summaries = []
    for i, section in enumerate(sections):
        summary = summarize_section(section)
        summaries.append(summary)
        print(f"Section {i+1} summarized.")
    # Step 3: Answer questions
    answers = []
    for question in questions:
        answer = answer_question(summaries, question)
        answers.append((question, answer))
    return answers

# Example usage
long_document = """
[Insert a long document here. For brevity, we are using a placeholder. 
In a real scenario, this would be a much longer text, maybe several 
paragraphs or pages about a specific topic.]
This is a long document about climate change. It discusses various aspects 
including causes, effects, and potential solutions. The document covers 
topics such as greenhouse gas emissions, rising global temperatures, 
melting ice caps, sea level rise, extreme weather events, impact on 
biodiversity, and strategies for mitigation and adaptation.
The document also explores the economic implications of climate change, 
international agreements like the Paris Agreement, renewable energy 
technologies, and the role of individual actions in combating climate change.
[Continue with more detailed information about climate change...]
"""
questions = [
    "What are the main causes of climate change mentioned in the document?",
    "What are some of the effects of climate change discussed?",
    "What solutions or strategies are proposed to address climate change?"
]
results = document_qa(long_document, questions)
for question, answer in results:
    print(f"\nQ: {question}")
    print(f"A: {answer}")

Cuplikan kode ini menunjukkan bagaimana prompt chaining dapat digunakan untuk tugas kompleks seperti analisis dokumen dan menjawab pertanyaan. Ia memecah tugas besar (memahami dokumen panjang) menjadi langkah yang lebih kecil dan mudah dikelola (merangkum bagian). Ia menggunakan keluaran dari satu langkah (ringkasan) sebagai masukan untuk langkah berikutnya (menjawab pertanyaan). Ini memungkinkan penanganan dokumen yang mungkin terlalu panjang untuk diproses dalam satu prompt.

Saat Anda menjalankan kode ini dengan dokumen panjang yang nyata, kode akan membagi dokumen menjadi bagian yang mudah dikelola, merangkum setiap bagian, dan menggunakan ringkasan tersebut untuk menjawab pertanyaan yang disediakan tentang penyebab, dampak, dan solusi perubahan iklim.

Pembuatan teks dengan verifikasi fakta

Pembuatan teks dengan verifikasi fakta melibatkan pembuatan teks dan memasukkan langkah pemeriksaan fakta dalam rantai prompt. Ini memastikan keluaran tidak hanya koheren tetapi juga akurat.

def generate_text(topic):
    prompt = f"Write a short paragraph about {topic}."
    return get_completion(prompt)

def extract_facts(text):
    prompt = f"Extract the key factual claims from the following text, listing each claim on a new line:\n\n{text}"
    return get_completion(prompt)

def verify_facts(facts):
    verified_facts = []
    for fact in facts.split('\n'):
        if fact.strip():
            prompt = f"Verify the following statement and respond with 'True' if it's factually correct, 'False' if it's incorrect, or 'Uncertain' if it can't be verified without additional research: '{fact}'"
            verification = get_completion(prompt)
            verified_facts.append((fact, verification.strip()))
    return verified_facts

def revise_text(original_text, verified_facts):
    context = "Original text:\n" + original_text + "\n\nVerified facts:\n"
    for fact, verification in verified_facts:
        context += f"- {fact}: {verification}\n"
    
    prompt = f"{context}\n\nRewrite the original text, keeping the verified facts, removing or correcting any false information, and indicating any uncertain claims as 'It is claimed that...' or similar phrasing."
    return get_completion(prompt)

def text_generation_with_verification(topic):
    print(f"Generating text about: {topic}")
    # Step 1: Generate initial text
    initial_text = generate_text(topic)
    print("\nInitial Text:")
    print(initial_text)
    # Step 2: Extract facts
    extracted_facts = extract_facts(initial_text)
    print("\nExtracted Facts:")
    print(extracted_facts)
    # Step 3: Verify facts
    verified_facts = verify_facts(extracted_facts)
    print("\nVerified Facts:")
    for fact, verification in verified_facts:
        print(f"- {fact}: {verification}")
    # Step 4: Revise text
    revised_text = revise_text(initial_text, verified_facts)
    print("\nRevised Text:")
    print(revised_text)
    return revised_text

# Example usage
topic = "the effects of climate change on polar bears"
final_text = text_generation_with_verification(topic)

Fungsi text_generation_with_verification() mengelola seluruh proses. Ia dimulai dengan menggunakan generate_text() untuk membuat paragraf awal tentang topik. Lalu, extract_facts() mengekstrak klaim utama dari teks ini. verify_facts() memeriksa klaim tersebut, memberi label True, False, atau Uncertain. Terakhir, revise_text() menulis ulang teks asli, memperbaiki kesalahan dan menandai informasi yang tidak pasti. Proses ini membantu memastikan teks akhir informatif dan akurat.

Prompt chaining terjadi dalam beberapa langkah: pembuatan teks awal, ekstraksi fakta dari teks yang dihasilkan, verifikasi setiap fakta yang diekstrak, dan revisi teks berdasarkan fakta yang telah diverifikasi.

Saat Anda menjalankan kode ini dengan topik seperti "the effects of climate change on polar bears", kode akan menghasilkan teks awal tentang topik tersebut, mengekstrak klaim faktual dari teks ini, memverifikasi setiap klaim, dan merevisi teks berdasarkan fakta yang terverifikasi, memastikan keluaran akhir yang lebih akurat. Ingat bahwa Anda dapat menggunakan topik pilihan Anda sendiri!

Pembuatan kode dengan debugging

Menggunakan prompt chaining untuk menulis kode lalu mengujinya dapat mempercepat pengembangan. Metode ini membantu memastikan kode berfungsi dengan baik dan melakukan apa yang seharusnya dilakukan. Ini melampaui sekadar memastikan kode berjalan tanpa galat.

def generate_code(task):
    prompt = f"Write a Python function to {task}. Include comments explaining the code."
    return get_completion(prompt)

def generate_test_cases(code):
    prompt = f"Given the following Python code, generate 3 test cases to verify its functionality. Include both input and expected output for each test case:\n\n{code}"
    return get_completion(prompt)

def run_tests(code, test_cases):
    prompt = f"""
    Given the following Python code and test cases, run the tests and report the results. 
    If any tests fail, explain why and suggest fixes.
    Code:
    {code}
    Test Cases:
    {test_cases}
    For each test case, respond with:
    1. "PASS" if the test passes
    2. "FAIL" if the test fails, along with an explanation of why it failed and a suggested fix
    """
    return get_completion(prompt)

def debug_code(code, test_results):
    prompt = f"""
    Given the following Python code and test results, debug the code to fix any issues.
    Provide the corrected code along with explanations of the changes made.
    Original Code:
    {code}
    Test Results:
    {test_results}
    """
    return get_completion(prompt)

def code_generation_with_debugging(task):
    print(f"Generating code for task: {task}")
    # Step 1: Generate initial code
    initial_code = generate_code(task)
    print("\nInitial Code:")
    print(initial_code)
    # Step 2: Generate test cases
    test_cases = generate_test_cases(initial_code)
    print("\nGenerated Test Cases:")
    print(test_cases)
    # Step 3: Run tests
    test_results = run_tests(initial_code, test_cases)
    print("\nTest Results:")
    print(test_results)
    # Step 4: Debug code if necessary
    if "FAIL" in test_results:
        print("\nDebugging code...")
        debugged_code = debug_code(initial_code, test_results)
        print("\nDebugged Code:")
        print(debugged_code)    
        # Optionally, you can run tests again on the debugged code
        print("\nRe-running tests on debugged code...")
        final_test_results = run_tests(debugged_code, test_cases)
        print("\nFinal Test Results:")
        print(final_test_results)    
        return debugged_code
    else:
        print("\nAll tests passed. No debugging necessary.")
        return initial_code

# Example usage
task = "calculate the factorial of a number"
final_code = code_generation_with_debugging(task)

Fungsi code_generation_with_debugging() mengelola seluruh proses. Alurnya seperti ini: Pertama, generate_code() menulis kode Python untuk tugasnya. Lalu, generate_test_cases() membuat pengujian untuk kode tersebut. run_tests() memeriksa apakah kode lulus pengujian. Jika ada yang gagal, debug_code() mencoba memperbaiki masalahnya.

Perhatikan bahwa setiap langkah dibangun dari langkah sebelumnya. Dimulai dengan menulis kode, lalu membuat pengujian, menjalankannya, dan memperbaiki masalah. Ini memecah pengembangan kode menjadi langkah-langkah yang lebih kecil dan mudah. Metode ini menunjukkan bagaimana prompt chaining dapat menangani tugas kompleks seperti pengodean. Polanya meniru cara kerja pengembang: menulis kode, menguji, dan memperbaiki masalah. Setiap langkah memanfaatkan hasil sebelumnya, memungkinkan peningkatan kode secara bertahap.

Saat Anda menjalankan kode ini dengan tugas seperti "calculate the factorial of a number", kode akan menghasilkan kode Python awal untuk menghitung faktorial, membuat test case untuk fungsi tersebut, mensimulasikan menjalankan pengujian, dan melaporkan hasilnya. Jika ada pengujian yang gagal, kode akan mencoba melakukan debug dan memperbaikinya, lalu menjalankan ulang pengujian.

Tugas penalaran multi-langkah

Prompt chaining dapat menyelesaikan masalah kompleks yang memerlukan beberapa langkah penalaran, seperti soal cerita matematika atau teka-teki logika. Setiap langkah dibangun dari langkah sebelumnya, memastikan pendekatan yang terstruktur dan menyeluruh.

def solve_step_by_step(problem):
    steps = []
    current_problem = problem
    while True:
        prompt = f"Solve the following problem step by step. Provide the next step only and explain it clearly:\n\n{current_problem}"
        step = get_completion(prompt)
        if step is None or "solution" in step.lower():
            break
        steps.append(step)
        current_problem = f"{current_problem}\n\n{step}"
        print(f"Step {len(steps)}: {step}\n")
    return steps

def combine_steps(steps):
    combined_steps = "\n".join(steps)
    prompt = f"Combine the following steps into a coherent solution for the problem:\n\n{combined_steps}"
    return get_completion(prompt)

def multi_step_reasoning(problem):
    print(f"Solving problem: {problem}")    
    # Step 1: Solve step by step
    steps = solve_step_by_step(problem)    
    # Step 2: Combine steps into a final solution
    final_solution = combine_steps(steps)
    print("\nFinal Solution:")
    print(final_solution)
    return final_solution

# Example usage
problem = "A car travels 60 miles per hour for 2 hours, then 40 miles per hour for 3 hours. What is the total distance traveled by the car?"
final_solution = multi_step_reasoning(problem)

Pertama, solve_step_by_step() memecah masalah menjadi bagian-bagian kecil. Fungsi ini meminta model AI untuk setiap langkah, satu per satu, hingga solusi lengkap. Setiap langkah disimpan. Lalu, combine_steps() mengambil semua langkah ini dan meminta AI untuk menggabungkannya menjadi satu penjelasan yang jelas. Fungsi get_completion() menangani komunikasi dengan OpenAI API sepanjang proses ini.

Untuk contoh ini, ia akan menyelesaikan masalah: "Sebuah mobil melaju 60 mil per jam selama 2 jam, lalu 40 mil per jam selama 3 jam. Berapa jarak total yang ditempuh mobil?"

Saat Anda menjalankan kode ini, ia akan memecah masalah menjadi langkah penalaran yang lebih kecil, mengumpulkan dan mencetak setiap langkah, lalu menggabungkannya menjadi solusi akhir dan mencetaknya.

Praktik Terbaik untuk Prompt Chaining

Penting untuk mengikuti praktik terbaik tertentu guna memaksimalkan efektivitas prompt chaining. Praktik ini memastikan rantai Anda tangguh, akurat, dan efisien, sehingga menghasilkan keluaran yang lebih baik dan aplikasi LLM yang lebih andal.

Perancangan prompt

Prompt yang jelas dan ringkas sangat penting untuk mendapatkan hasil terbaik dari LLM. Saat prompt Anda lugas, model lebih mudah memahami kebutuhan Anda, yang mengurangi kebingungan dan meningkatkan kualitas respons.

Berikut beberapa tips:

• Gunakan bahasa sederhana: Hindari kata-kata rumit dan jargon teknis.
• Bersikap langsung: Nyatakan dengan jelas apa yang Anda inginkan tanpa menambahkan detail yang tidak perlu.
• Fokus pada satu tugas: Setiap prompt harus membahas satu tugas atau pertanyaan saja. 

Contohnya:

• Alih-alih: "Dapatkah Anda merangkum poin-poin kunci dari tren historis suhu global selama abad terakhir, dengan fokus pada perubahan signifikan dan potensi penyebabnya, serta peristiwa penting yang mungkin memengaruhi tren ini?"
• Gunakan: "Ringkas poin-poin kunci tren suhu global historis selama abad terakhir."

Prompt yang terstruktur dengan baik juga kunci untuk membantu LLM mengikuti alur logis suatu tugas. Saat prompt Anda terorganisasi dan koheren, model dapat lebih memahami dan merespons dengan tepat.

Berikut beberapa tips:

• Pecah tugas kompleks: Bagi tugas menjadi langkah-langkah yang lebih kecil dan dapat dikelola.
• Pastikan alur logis: Pastikan setiap prompt dibangun dari prompt sebelumnya dan secara logis mengarah ke langkah berikutnya.

Menyusun prompt dengan cara ini membimbing LLM melalui tugas selangkah demi selangkah, menghasilkan respons yang lebih baik dan akurat. Misalnya:

• Langkah 1: "Daftarkan perubahan besar pada suhu global selama abad terakhir."
• Langkah 2: "Identifikasi potensi penyebab untuk setiap perubahan besar pada suhu global."

Eksperimentasi

Tugas yang berbeda memerlukan cara merangkai prompt yang berbeda. Memilih metode yang tepat untuk tugas Anda dapat membuat perbedaan besar. Sebaiknya coba berbagai pendekatan dan lihat apa yang paling cocok dengan tujuan Anda. Pengujian dan perbandingan dapat membantu Anda menemukan cara terbaik untuk mendapatkan hasil yang baik.

Penting untuk sering memeriksa seberapa baik rantai prompt Anda bekerja. Lihat akurasi, kelengkapan, dan relevansi keluarannya. Ini membantu Anda melihat apa yang berhasil dan apa yang perlu diperbaiki. Dengan melakukan ini secara berkala, Anda dapat melakukan penyesuaian dan perbaikan sesuai kebutuhan dan memastikan Anda mendapatkan hasil terbaik.

Penyempurnaan iteratif

Penyempurnaan iteratif berdasarkan umpan balik dan hasil menghasilkan prompt yang lebih tepat dan efektif. Anda dapat terus meningkatkan kinerja LLM dengan mengumpulkan umpan balik dari keluaran, mengidentifikasi kekurangan, dan menyesuaikan prompt sesuai kebutuhan. Proses berkelanjutan ini memastikan prompt Anda semakin akurat dan relevan dari waktu ke waktu. Contohnya:

• Prompt awal: "Jelaskan dampak perubahan iklim."
• Prompt yang disempurnakan: "Jelaskan dampak perubahan iklim pada ekosistem pesisir selama dekade terakhir."

Sempurnakan struktur rantai

Cara Anda menyusun rantai prompt sangat memengaruhi hasil akhirnya. Mengubah urutan dan logika prompt bermanfaat berdasarkan apa yang terbukti efektif. Ini memastikan setiap langkah masuk akal setelah langkah sebelumnya. Dengan demikian, Anda bisa mendapatkan jawaban AI yang lebih baik dan lebih logis.

Penanganan galat

Penanganan galat yang tangguh memastikan rantai prompt tetap dapat berfungsi meski prompt individual gagal. Dengan menyiapkan pemeriksaan validitas keluaran dan menggunakan prompt cadangan, Anda dapat mengarahkan LLM kembali ke jalur saat terjadi kesalahan. Pendekatan ini menjaga alur dan keandalan rantai prompt, memastikan kinerja yang konsisten.

Pemantauan dan pencatatan

Penting untuk memantau seberapa baik rantai prompt Anda bekerja. Ini membantu Anda memahami apa yang efektif dan mengidentifikasi masalah. Gunakan alat untuk merekam informasi penting seperti masukan prompt, keluaran, dan waktu pemrosesan. Misalnya, catat setiap langkah rantai, apa yang dihasilkan, dan galat yang terjadi. Dengan melakukan ini, Anda dapat mempelajari prosesnya dan meningkatkannya, sehingga hasil menjadi lebih baik.

Menyimpan catatan terperinci membantu Anda memperbaiki masalah dan meningkatkan rantai prompt. Simpan catatan ini secara rapi agar lebih mudah dipelajari dan diambil pelajarannya. Ini membantu Anda menemukan masalah dan menyetel rantai prompt. Hasilnya, Anda dapat membuatnya bekerja lebih baik dan memberikan jawaban yang lebih akurat

Mengikuti praktik terbaik ini akan memungkinkan Anda membuat rantai prompt yang efektif dan andal yang meningkatkan kemampuan LLM, memastikan Anda mendapatkan kinerja yang lebih baik dan hasil yang lebih bermakna di berbagai aplikasi.

Kesimpulan

Dalam artikel ini, kita membahas prompt chaining, teknik untuk meningkatkan kinerja LLM pada tugas kompleks dengan memecahnya menjadi prompt yang lebih kecil dan mudah dikelola. Kita meninjau berbagai metode perangkaian, penerapannya, dan praktik terbaik untuk membantu Anda memanfaatkan LLM secara efektif untuk berbagai kasus penggunaan.

Jika Anda ingin mempelajari lebih lanjut tentang prompt engineering, saya merekomendasikan artikel berikut:

• Prompt Compression: Panduan dengan Contoh Python
• Buffer of Thoughts (BoT)
• Apa Itu DSPy? Cara Kerja, Use Case, dan Sumber Daya
• Memahami Prompt Tuning