Prompt Zincirleme Eğitimi: Prompt Chaining Nedir ve Nasıl Kullanılır?

Hiç talimatları okumadan bir mobilyayı monte etmeye çalıştınız mı? Şanslıysanız bazı parçaları bir araya getirebilirsiniz, ancak adım adım yönlendirme olmadan sonuç epey dağınık olabilir. Bu durum, büyük dil modellerinin (LLM'ler) karmaşık problemlerle karşılaştığında yaşadığı zorluğa benzer. Bu modellerin inanılmaz bir potansiyeli var, ancak bir görev ayrıntılı, çok adımlı akıl yürütme gerektirdiğinde çoğu zaman hedefi ıskalıyorlar.

Tek bir istem verildiğinde, LLM'ler çok geniş, derinlikten yoksun ya da kritik ayrıntıları kaçıran yanıtlar verebilir. Bu sınırlama, gerekli tüm bağlamı tek bir istemde yakalamanın ve yeterli yönlendirme sağlamanın zorluğundan kaynaklanır.

Bunun çözümü prompt zincirleme.

Prompt zincirleme, karmaşık bir görevi daha küçük, daha yönetilebilir istemlere bölmeyi içerir. Her istem, görevin belirli bir kısmını ele alır ve bir istemden elde edilen çıktı, bir sonrakinin girdisi olur. Bu yöntem, daha yapılandırılmış bir yaklaşım sunarak LLM'i daha doğru ve kapsamlı bir yanıta götüren akıl yürütme adımları zinciri boyunca yönlendirir. Mantıksal bir istem dizisi kullanarak LLM'lerden tam verim alabilir ve karmaşık problemleri etkili biçimde çözebiliriz.

Bu eğitim, “Prompt Mühendisliği: Sıfırdan Uzmanlığa” blog serimin bir parçasıdır:

1. Herkes İçin Prompt Mühendisliği
2. Zero-Shot Prompting
3. Few-Shot Prompting
4. Prompt Zincirleme

Prompt Zincirleme Nedir?

Prompt zincirleme, bir LLM isteminin çıktısının, dizideki bir sonraki istem için girdi olarak kullanıldığı bir yöntemdir. Bu teknik, her biri genel problemin belirli bir bölümüne odaklanan bağlantılı istemlerin bir serisini oluşturmaya dayanır. Bu diziyi takip etmek, LLM'in yapılandırılmış bir akıl yürütme sürecinde yönlendirilmesini sağlar ve daha doğru ve ayrıntılı yanıtlar üretmesine yardımcı olur.

Prompt zincirlemenin temel amacı, LLM uygulamalarının performansını, güvenilirliğini ve açıklığını artırmaktır. Karmaşık görevlerde tek bir istem çoğu zaman iyi bir yanıt için yeterli derinlik ve bağlam sağlamaz. Prompt zincirleme, görevi daha küçük adımlara bölerek her adımın özenle ele alınmasını sağlar. Bu yöntem, LLM çıktısının kalitesini artırır ve nihai sonuca nasıl ulaşıldığını anlamayı kolaylaştırır.

Prompt zincirlemenin bazı faydalarına göz atalım:

Prompt Zincirleme Nasıl Uygulanır

Prompt zincirleme, karmaşık bir görevi sistematik biçimde parçalamayı ve bir LLM'i iyi tanımlanmış adımlar dizisi boyunca yönlendirmeyi gerektirir. 

Etkili bir prompt zincirini nasıl oluşturup çalıştırabileceğinize bakalım.

Alt görevleri belirleyin

Prompt zincirlemenin ilk adımı, karmaşık görevi daha küçük ve yönetilebilir alt görevlere ayırmaktır. Her alt görev, genel problemin ayrı bir yönünü temsil etmelidir. Böylece LLM her seferinde bir parçaya odaklanabilir.

Örneğin, LLM'in iklim değişikliği üzerine kapsamlı bir rapor yazmasını istiyorsunuz. Alt görevler şunları içerebilir:

• Tarihsel iklim verilerinin araştırılması
• Bilimsel literatürden temel bulguların özetlenmesi
• İklim değişikliğinin farklı ekosistemler üzerindeki etkisinin analiz edilmesi
• Olası çözümler ve azaltım stratejilerinin önerilmesi

İstemleri tasarlayın

Sonraki adımda, her alt görev için net ve öz istemler tasarlayın. Her istem, LLM'in görevi anlayıp ilgili çıktı üretebilmesini sağlayacak kadar spesifik ve doğrudan olmalıdır. Önemli olan, bir istemin çıktısının bir sonrakine girdi olmaya uygun olmasıdır; böylece bilgi akışı oluşur.

Yukarıdaki alt görevlerimiz için şu istemleri oluşturabiliriz:

• Alt Görev 1 İstemi: "Geçtiğimiz yüzyılda küresel sıcaklık değişimlerindeki temel eğilimleri özetleyin."
• Alt Görev 2 İstemi: "Belirlenen eğilimlere dayanarak, bu değişimlerin nedenlerini ele alan başlıca bilimsel çalışmaları listeleyin."
• Alt Görev 3 İstemi: "Listelenen çalışmaların bulgularını, iklim değişikliğinin deniz ekosistemleri üzerindeki etkisine odaklanarak özetleyin."
• Alt Görev 4 İstemi: "Özetlenen bulgulara dayanarak, iklim değişikliğinin deniz ekosistemleri üzerindeki etkisini azaltmaya yönelik üç strateji önerin."

Zinciri yürütme

Şimdi, istemleri art arda çalıştırıp birinin çıktısını bir sonrakine girdi olarak aktarmamız gerekiyor. Bu adım adım yürütme, LLM'in önceki çıktıları üzerine inşa etmesini sağlayarak tutarlı ve kapsamlı bir sonuç üretir.

Örneğimiz için alt görevlerin çıktıları kabaca şöyle görünebilir:

• Alt Görev 1 Çıktısı: "Küresel sıcaklıklar geçtiğimiz yüzyılda yaklaşık 1,2 santigrat derece arttı ve son 20 yılda belirgin artışlar gözlendi."
• Alt Görev 2 İçin Girdi: "Küresel sıcaklıkların geçtiğimiz yüzyılda 1,2 santigrat derece arttığı bilgisine dayanarak, bu değişimlerin nedenlerini ele alan başlıca bilimsel çalışmaları listeleyin."
• Alt Görev 2 Çıktısı: "Önemli çalışmalar arasında Dr. Smith'in 'Küresel Isınmada Sera Gazlarının Rolü', Dr. Jones'un 'Ormansızlaşma ve İklim Değişikliği' ve Dr. Lee'nin 'Okyanuslardaki Değişimler ve İklim Örüntüleri' yer alır."
• Alt Görev 3 İçin Girdi: "Dr. Smith'in 'Küresel Isınmada Sera Gazlarının Rolü', Dr. Jones'un 'Ormansızlaşma ve İklim Değişikliği' ve Dr. Lee'nin 'Okyanuslardaki Değişimler ve İklim Örüntüleri' çalışmalarının bulgularını, iklim değişikliğinin deniz ekosistemleri üzerindeki etkisine odaklanarak özetleyin."

Hata yönetimi

İstem yürütme sırasında ortaya çıkabilecek sorunları ele almak için hata yönetimi mekanizmaları uygulamak kritik önemdedir. Buna, bir sonraki adıma geçmeden önce çıktının kalitesini ve uygunluğunu doğrulayan kontroller kurmak ve LLM beklentiden saptığında onu tekrar raya sokacak yedek istemler oluşturmak dahildir. Örneğin:

• Hata Kontrolü 1: Her çıktının ardından bilginin ilgili ve eksiksiz olduğunu doğrulayın. Küresel sıcaklık değişimlerine ilişkin eğilim özeti eksikse, LLM'den ek ayrıntılar vermesini isteyin.
• Yedek İstem: LLM ilgili bilimsel çalışmaları listeleyemezse, "Küresel sıcaklık artışının nedenlerini ele alan, son on yılda yayımlanmış beş hakemli çalışmayı listeleyin." gibi daha spesifik bir istem kullanın.

Uygulama

Bunu Python'da nasıl uygulayacağımıza bakalım!

Adım 1: Ortamın hazırlanması

Önce gerekli kütüphaneleri içe aktarmalıyız. openai paketinden OpenAI sınıfını ve ortam değişkenlerini yönetmek için os'u kullanacağız.

import openai
import os

API anahtarları gibi hassas bilgilerin güvenle saklanması çok önemlidir. Bunu sağlamanın bir yolu, API anahtarını bir ortam değişkeni olarak ayarlamaktır. Bunu bir OpenAI API anahtarı kullanarak yapabilirsiniz.

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

'your-api-key-here' ifadesini gerçek OpenAI API anahtarınızla değiştirdiğinizden emin olun.

API anahtarı ayarlandıktan sonra OpenAI istemcisini başlatabilirsiniz. Bu istemci, OpenAI hizmetlerine API çağrıları yapmak için kullanılacaktır.

Client = OpenAI ()

Adım 2: OpenAI'nin chat completions API'ı ile etkileşim için bir fonksiyon tanımlama

Şimdi, OpenAI'nin chat completions API'ı ile etkileşim kuracak bir Python fonksiyonu oluşturacağız. Bu fonksiyon, API'yi istemleyecek ve üretilen yanıtı döndürecek.

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

Bu fonksiyonu parçalara ayıralım—şunları yapar:

• Bir istem ve isteğe bağlı bir model parametresi alır.
• OpenAI'ye chat completions uç noktası üzerinden bir API çağrısı yapar.
• Sisteme bir sistem mesajı ve bir kullanıcı mesajı (istem) ile konuşma kurulumu yapar.
• Daha belirleyici çıktılar için sıcaklığı 0'a ayarlar (daha yaratıcı çıktılar için sıcaklığı artırın).
• Bir hata oluşursa yanıtın içeriğini veya None döndürür.

Adım 3: Birden çok istemi zincirlemek

Şimdi, bir istemin çıktısını bir sonrakine girdi olarak vererek birden çok istemi birbirine zincirleyen bir Python fonksiyonu oluşturacağız.

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

prompt_chain fonksiyonu prompt zincirlemeyi uygular. Şunları yapar:

• Başlangıç istemiyle başlar ve tamamlamayı alır.
• Takip istemleri listesini yinelemeli olarak dolaşır.
• Her takip istemi için, istemi önceki çıktı ile birleştirir, bu birleşik istem için bir tamamlanma alır ve sonucu günceller.
• Herhangi bir adım başarısız olursa bir hata mesajı döndürür.
• Her adımın çıktısı görünürlük için yazdırılır.

Adım 4: Örnek kullanım

Şimdi prompt_chain fonksiyonunun, birbirini üzerine inşa eden bir istem dizisi oluşturmak için nasıl kullanılacağını göstereceğiz. Bu örnek, küresel sıcaklık değişimlerindeki temel eğilimleri özetlemeye ve ilgili bilimsel çalışmalar ile azaltım stratejilerini incelemeye odaklanacak; ancak siz bunu kendi kullanım senaryonuza uygulayabilirsiniz!

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)

Burada, küresel sıcaklık değişimleriyle ilgili bir başlangıç istemi tanımlıyor ve ardından birbirini tamamlayan takip istemlerinden oluşan bir liste hazırlıyoruz. Sonra bu istemlerle prompt_chain fonksiyonunu çağırıyor ve sonunda nihai sonucu yazdırıyoruz.

Birlikte nasıl çalışır

Süreci özetleyelim:

1. Başlangıç istemi, sıcaklık eğilimlerinin bir özetini alır.
2. İlk takip istemi bu özeti kullanarak ilgili çalışmaları bulur.
3. İkinci takip istemi, bu çalışmaların deniz ekosistemlerine dair bulgularını özetler.
4. Son istem, tüm bu bilgileri kullanarak azaltım stratejileri önerir.

Bu zincirleme, her adımın önceki adımlardaki bilgilere dayandığı karmaşık sorgular için adım adım bir yaklaşım sağlar.

Prompt Zincirleme Teknikleri

Prompt zincirleme, farklı görev türleri ve gereksinimlere uyacak çeşitli şekillerde uygulanabilir. Burada üç temel tekniği inceliyoruz: Sıralı Zincirleme, Koşullu Zincirleme ve Döngüsel Zincirleme.

Sıralı zincirleme

Sıralı zincirleme, istemleri düz, doğrusal bir dizide bağlamayı içerir. Her istem, bir öncekinden gelen çıktıya bağlıdır; böylece bilgi ve görevlerin adım adım akışı oluşur. Bu teknik, bir aşamadan diğerine mantıksal bir ilerleme gerektiren görevler için idealdir, örneğin:

• Metin özetleme: Uzun bir belgeyi bölümlere ayırıp her bölümü özetlemek, ardından bu özetleri birleştirerek tutarlı bir genel özet oluşturmak.
• Kod üretimi: Önce fonksiyon tanımlarını oluşturmak, sonra bu fonksiyonları uygulamak ve en sonunda test senaryolarını yazmak gibi adım adım kod parçacıkları üretmek.

Önceki bölümdeki kod parçası, sıralı zincirlemeye bir örnektir.

Koşullu zincirleme

Koşullu zincirleme, LLM'in çıktısına bağlı olarak prompt zincirine dallanma ekler. Bu teknik, LLM'in ürettiği yanıtlara göre farklı yollar izlemesini sağlayarak daha esnek ve uyarlanabilir iş akışları sunar.

Duygu analizi yapmak için koşullu zincirlemeyi nasıl uygulayabileceğimize bakalım.

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)

Önce, verilen bir metnin duygusunu belirlemek için dil modelini kullanan analyze_sentiment() adlı yeni bir fonksiyon tanımlıyoruz. Ardından, conditional_prompt_chain() fonksiyonunda, yenilenebilir enerjinin benimsenmesiyle ilgili başlangıç istemiyle başlıyoruz. İlk yanıtı aldıktan sonra duygusunu analiz ediyoruz. Duyguya bağlı olarak farklı bir takip istemi seçiyoruz:

•  Olumlu duygu için fırsatları soruyoruz.
•  Olumsuz duygu için çözümleri soruyoruz.
•  Nötr duygu için odaklanılması gereken temel alanları soruyoruz.

Seçilen takip istemi, başlangıç yanıtından alınan bağlamla birlikte dil modeline gönderilir. Nihai sonuç, bu koşullu takip istemine verilen yanıttır.

Dikkat ederseniz, ikinci istemin seçimi önceden belirlenmemiştir; ilk yanıta bağlıdır. Ayrıca, akış duygu analizine göre uyarlanır ve zincirin farklı yollara dallanabildiğini gösterir. Bu, dil modeliyle daha dinamik ve bağlam farkındalığı yüksek etkileşimler sağlar.

Bu kodu çalıştırdığınızda, belirli takip sorusu, yenilenebilir enerjinin benimsenmesine dair ilk analizin olumlu, olumsuz ya da nötr olarak algılanmasına bağlı olacaktır. Bu da daha uyarlanabilir ve tepkisel bir istem zinciri oluşturur.

Döngüsel zincirleme

Döngüsel zincirleme, veriler üzerinde yineleme yapmak veya tekrarlayan görevleri yürütmek için bir prompt zinciri içinde döngüler oluşturmayı içerir. Bu teknik, benzer işlem adımları gerektiren öğe listeleri veya koleksiyonlarıyla çalışırken faydalıdır. Bu yaklaşımın bazı faydaları ve zorlukları şunlardır:

• Verimlilik: Tekrarlayan görevleri otomatikleştirir, zaman ve emek tasarrufu sağlar.
• Veri işleme: Birden fazla kaydın işlenmesi, toplu özetleme veya yinelemeli iyileştirmeler gibi görevler için uygundur.
• Zorluklar: Sonsuz döngülerden kaçınmak ve her yinelemenin anlamlı bir ilerleme sağlamasını güvenceye almak için dikkatli ele alma gerektirir.

Metin bütünlüğü görevi için döngüsel zincirleme nasıl uygulanır görelim:

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)

Önce, verilen bir yanıtın eksiksiz mi yoksa daha fazla bilgiye mi ihtiyaç duyduğunu belirlemek için dil modelini kullanan check_completeness() adlı bir fonksiyon tanımlıyoruz.

Ardından, looping_prompt_chain() fonksiyonunda fotosentezle ilgili başlangıç istemiyle başlıyoruz. İlk yanıtı aldıktan sonra bir döngüye giriyoruz:

• Geçerli yanıtın check_completeness() ile eksiksiz olup olmadığını kontrol ederiz.
• Eksiksizse, döngüden çıkar ve sonucu döndürürüz.
• Eksikse, önceki yanıtın genişletilmesini isteyen yeni bir istem üretiriz.
• Daha sonra bu genişletme istemine dayalı yeni bir yanıt alırız.

Bu süreç, eksiksiz kabul edilen bir yanıt elde edene kadar veya maksimum yineleme sayısına (varsayılan 5) ulaşana kadar devam eder.

Döngü, yanıtı eksiksiz olana kadar rafine edip genişletmeye devam etmemizi sağlar ya da yineleme sınırına ulaşırız.

Bu kodu çalıştırdığınızda, fotosentez sürecine dair kapsamlı bir açıklama sağlamaya çalışacak; ilk yanıtlar eksik görülürse birden çok genişletme yinelemesinden geçebilir. Böylece daha ayrıntılı ve uyarlanabilir bir istem zinciri oluşur ve kapsamlı bir nihai sonuca hedeflenir.

Prompt Zincirlemenin Pratik Kullanımları

Prompt zincirleme, çeşitli uygulamalarda LLM'lerin yeteneklerini önemli ölçüde artırabilir. Bu bölümde, gerçek dünya görevlerine nasıl uygulanabileceğini gösteren bazı pratik kullanım alanlarını inceliyoruz.

Belgeler üzerinde soru yanıtlama

Prompt zincirleme, uzun belgeleri özetlemek ve ardından belirli sorulara yanıtlar üretmek için kullanılabilir. Bu, önce belgeyi yönetilebilir bölümlere ayırmayı, her bölümü özetlemeyi ve ardından bu özetleri ayrıntılı soruları yanıtlamak için kullanmayı içerir.

Bunu nasıl uygulayacağımıza bakalım:

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}")

Bu kod parçası, prompt zincirlemenin belge analizi ve soru yanıtlama gibi karmaşık görevlerde nasıl kullanılabileceğini gösterir. Büyük bir görevi (uzun bir belgeyi anlamak) daha küçük, yönetilebilir adımlara (bölümlerin özetlenmesi) böler. Bir adımın çıktısını (özetler) bir sonraki adımın girdisi (soruları yanıtlamak) olarak kullanır. Tek bir istemde işlemek için fazla uzun olabilecek belgeleri ele almayı sağlar.

Bu kodu gerçek, uzun bir belgeyle çalıştırdığınızda belgeyi yönetilebilir bölümlere ayıracak, her bölümü özetleyecek ve bu özetleri kullanarak iklim değişikliğinin nedenleri, etkileri ve çözümleri hakkında verilen soruları yanıtlayacaktır.

Gerçek denetimiyle metin üretimi

Gerçek denetimiyle metin üretimi, metin üretip prompt zinciri içinde gerçek kontrol adımlarını dahil etmeyi içerir. Bu, çıktının yalnızca tutarlı değil, aynı zamanda doğru olmasını da sağlar.

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)

text_generation_with_verification() fonksiyonu tüm süreci yönetir. Önce generate_text() ile konu hakkında bir paragraf üretir. Sonra extract_facts() bu metinden temel iddiaları çıkarır. verify_facts() bu iddiaları kontrol ederek Doğru, Yanlış veya Belirsiz olarak etiketler. Son olarak revise_text() özgün metni yeniden yazar, hataları düzeltir ve belirsiz bilgileri not eder. Bu süreç, nihai metnin hem bilgilendirici hem de doğru olmasını sağlar.

Prompt zincirleme, birkaç adımda gerçekleşir: ilk metnin üretilmesi, bu metinden gerçeklerin çıkarılması, her gerçeğin doğrulanması ve doğrulanmış gerçeklere göre metnin revize edilmesi.

Bu kodu "iklim değişikliğinin kutup ayıları üzerindeki etkileri" gibi bir konuyla çalıştırdığınızda, konu hakkında ilk metni üretir, bu metinden olgusal iddiaları çıkarır, her birini doğrular ve doğrulanmış gerçeklere göre metni revize eder; böylece daha doğru bir nihai çıktı elde edilir. Kendi seçtiğiniz bir konuyu da kullanabileceğinizi unutmayın!

Hata ayıklama ile kod üretimi

Kod yazmak ve sonra test etmek için prompt zincirleme kullanmak geliştirmeyi hızlandırabilir. Bu yöntem, kodun düzgün çalıştığından ve amacını yerine getirdiğinden emin olmanıza yardımcı olur. Yalnızca hatasız çalıştığını kontrol etmenin ötesine geçer.

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)

code_generation_with_debugging() fonksiyonu tüm süreci yönetir. Şöyle çalışır: Önce generate_code() verilen görev için Python kodu yazar. Ardından generate_test_cases() bu kod için testler oluşturur. run_tests() kodun bu testleri geçip geçmediğini kontrol eder. Herhangi bir test başarısız olursa debug_code() sorunları düzeltmeye çalışır.

Dikkat edin, her adım bir öncekine dayanır. Kod yazmayla başlar, ardından testler oluşturur, çalıştırır ve sorunları düzeltir. Bu, kodlamayı daha küçük ve kolay adımlara böler. Yöntem, kodlama gibi karmaşık görevleri yönetmek için prompt zincirlemenin nasıl kullanılabileceğini gösterir. Gerçek programcıların çalışma şeklini taklit eder: kod yaz, test et ve sorunları düzelt. Her adım, bir öncekinden yararlanarak kodun kademeli olarak iyileştirilmesini sağlar.

Bu kodu "bir sayının faktöriyelini hesapla" gibi bir görevle çalıştırdığınızda, faktöriyel hesaplayan ilk Python kodunu üretir, bu fonksiyon için test senaryoları oluşturur, bu testleri çalıştırmayı simüle eder ve sonuçları raporlar. Testler başarısız olursa, kodu hata ayıklamaya ve düzeltmeye çalışır, ardından testleri yeniden çalıştırır.

Çok adımlı akıl yürütme görevleri

Prompt zincirleme, matematiksel sözel problemler veya mantık bulmacaları gibi birden çok akıl yürütme adımı gerektiren karmaşık problemleri çözebilir. Her adım bir öncekine dayanır ve yapılandırılmış, titiz bir yaklaşım sağlar.

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)

Önce solve_step_by_step() problemi daha küçük parçalara böler. Çözüm tamamlanana kadar modelden her adımı tek tek ister. Her adımı kaydeder. Ardından combine_steps() tüm bu adımları alır ve tek bir net açıklamada birleştirmesini ister. Süreç boyunca OpenAI API ile iletişimi get_completion() fonksiyonu yürütür.

Bu örnekte şu problemi çözecektir: "Bir araba 2 saat boyunca saatte 60 mil, ardından 3 saat boyunca saatte 40 mil hızla gidiyor. Toplamda ne kadar mesafe kat eder?"

Bu kodu çalıştırdığınızda, problemi daha küçük akıl yürütme adımlarına böler, her adımı toplayıp yazdırır ve adımları bir nihai çözümde birleştirip yazdırır.

Prompt Zincirleme için En İyi Uygulamalar

Prompt zincirlemenin etkinliğini en üst düzeye çıkarmak için belirli en iyi uygulamaları takip etmek gerekir. Bu uygulamalar, zincirlerinizin sağlam, doğru ve verimli olmasını sağlayarak daha iyi sonuçlar ve daha güvenilir LLM uygulamaları elde etmenize yardımcı olur.

İstem tasarımı

Açık ve öz istemler kullanmak, bir LLM'den en iyi sonuçları almak için esastır. İstemleriniz net olduğunda model neye ihtiyaç duyduğunuzu kolayca anlar; bu da kafa karışıklığını azaltır ve yanıt kalitesini artırır.

İşte bazı ipuçları:

• Basit dil kullanın: Karmaşık kelimeler ve teknik jargonlardan kaçının.
• Doğrudan olun: Gereksiz ayrıntılar eklemeden ne istediğinizi açıkça belirtin.
• Tek bir göreve odaklanın: Her istem tek bir görevi veya soruyu ele almalıdır. 

Örneğin:

• Bunun yerine: "Geçtiğimiz yüzyıl boyunca küresel sıcaklıklardaki tarihsel eğilimlerin temel noktalarını, önemli değişimlere ve bunların olası nedenlerine odaklanarak, ayrıca bu eğilimleri etkilemiş olabilecek kayda değer olaylarla birlikte özetleyebilir misiniz?"
• Şunu kullanın: "Geçtiğimiz yüzyıldaki tarihsel küresel sıcaklık eğilimlerinin temel noktalarını özetleyin."

İyi yapılandırılmış istemler kullanmak da LLM'in bir görevin mantıksal akışını takip etmesine yardımcı olmak için kritik önem taşır. İstemleriniz düzenli ve tutarlı olduğunda, model daha iyi anlar ve uygun şekilde yanıt verir.

Bazı ipuçları şunlardır:

• Karmaşık görevleri parçalayın: Görevi daha küçük ve yönetilebilir adımlara bölün.
• Mantıksal akışı sağlayın: Her istemin bir öncekine dayandığından ve mantıksal olarak bir sonrakine yol açtığından emin olun.

İstemlerinizi bu şekilde yapılandırmak, LLM'i görevin içinde adım adım yönlendirir ve daha iyi, daha doğru yanıtlar üretir. Örneğin:

• Adım 1: "Geçtiğimiz yüzyılda küresel sıcaklıklardaki başlıca değişimleri listeleyin."
• Adım 2: "Küresel sıcaklıklardaki her büyük değişimin olası nedenlerini belirleyin."

Deney yapma

Farklı görevler, istemlerin farklı şekillerde zincirlenmesini gerektirir. Göreviniz için doğru yöntemi seçmek büyük fark yaratabilir. Farklı yaklaşımları denemek ve neyin işe yaradığını görmek iyi bir fikirdir. Test etmek ve karşılaştırmak, iyi sonuçlar için en uygun yolu bulmanıza yardımcı olur.

İstem zincirlerinizin ne kadar iyi çalıştığını sık sık kontrol etmek önemlidir. Çıktıların doğruluğuna, bütünlüğüne ve ilgililiğine bakın. Bu, neyin işe yaradığını ve neyin iyileştirilmesi gerektiğini görmenize yardımcı olur. Bunu düzenli olarak yaparak gerekli değişiklikleri ve iyileştirmeleri yapabilir ve en iyi sonuçları aldığınızdan emin olabilirsiniz.

Yinelemeli iyileştirme

Geri bildirim ve sonuçlara dayalı yinelemeli iyileştirme, daha kesin ve etkili istemlere yol açar. Çıktılardan geri bildirim toplayıp eksiklikleri belirleyerek ve istemleri buna göre ayarlayarak LLM performansını sürekli artırabilirsiniz. Bu sürekli süreç, zaman içinde istemlerinizin giderek daha doğru ve ilgili hale gelmesini sağlar. Örneğin:

• İlk istem: "İklim değişikliğinin etkilerini açıklayın."
• İyileştirilmiş istem: "Son on yılda iklim değişikliğinin kıyı ekosistemleri üzerindeki etkilerini açıklayın."

Zincir yapısını iyileştirin

Prompt zincirinizin düzeni, nihai sonucu gerçekten etkileyebilir. Çalıştığını gördüklerinize göre istemlerin sırasını ve mantığını değiştirmek faydalıdır. Bu, her adımın bir öncekinden sonra anlamlı olmasını sağlar. Böyle yaptığınızda, yapay zekâdan daha iyi ve mantıklı yanıtlar alabilirsiniz.

Hata yönetimi

Sağlam hata yönetimi, bireysel istemler başarısız olsa bile prompt zincirinin çalışmaya devam etmesini sağlar. Çıktı geçerliliği için kontroller kurarak ve yedek istemler kullanarak, hatalar meydana geldiğinde LLM'i yeniden doğru yola yönlendirebilirsiniz. Bu yaklaşım, zincirin akışını ve güvenilirliğini korur ve tutarlı performans sağlar.

İzleme ve günlükleme

İstem zincirlerinizin ne kadar iyi çalıştığını takip etmek önemlidir. Bu, neyin etkili olduğunu anlamanıza ve sorunları fark etmenize yardımcı olur. İstemlere giren ve çıkan bilgiler ile geçen süre gibi önemli bilgileri kaydetmek için araçlar kullanın. Örneğin, zincirin her adımını, ürettiği çıktıyı ve meydana gelen hataları not edin. Bunu yaparsanız süreci inceleyebilir ve geliştirebilir, böylece daha iyi sonuçlara ulaşabilirsiniz.

Ayrıntılı kayıtlar tutmak, sorunları çözmenize ve istem zincirlerinizi iyileştirmenize yardımcı olur. Bu kayıtları düzenli biçimde saklayın ki incelemesi ve ders çıkarılması kolay olsun. Bu, sorunları tespit etmenize ve istem zincirlerini ince ayar yapmanıza yardımcı olur. Sonuç olarak, daha iyi çalışır ve daha doğru yanıtlar verir hâle getirebilirsiniz

Bu en iyi uygulamaları takip etmek, LLM'lerin yeteneklerini geliştiren, etkili ve güvenilir prompt zincirleri oluşturmanızı sağlar ve çeşitli uygulamalarda daha iyi performans ve daha anlamlı sonuçlar elde etmenize yardımcı olur.

Sonuç

Bu yazıda, LLM'lerin karmaşık görevlerdeki performansını, bu görevleri daha küçük ve yönetilebilir istemlere bölerek artıran bir teknik olan prompt zincirlemeyi inceledik. Farklı zincirleme yöntemlerini, uygulamalarını ve LLM'lerden geniş bir kullanım yelpazesinde etkili şekilde yararlanmanıza yardımcı olacak en iyi uygulamaları ele aldık.

Prompt mühendisliği hakkında daha fazlasını öğrenmek isterseniz şu yazıları öneririm:

• Prompt Sıkıştırma: Python Örnekleriyle Bir Rehber
• Buffer of Thoughts (BoT)
• DSPy Nedir? Nasıl Çalışır, Kullanım Alanları ve Kaynaklar
• Prompt Tuning'i Anlamak