Hướng dẫn Prompt Chaining: Prompt Chaining là gì và cách sử dụng?

Bạn đã bao giờ thử lắp một món đồ nội thất mà không đọc hướng dẫn chưa? Nếu may mắn, bạn có thể ghép được vài bộ phận, nhưng không có chỉ dẫn từng bước, kết quả thường khá lộn xộn. Điều này tương tự với thách thức mà các mô hình ngôn ngữ lớn (LLM) gặp phải khi xử lý các vấn đề phức tạp. Những mô hình này có tiềm năng đáng kinh ngạc, nhưng thường đi chệch hướng khi nhiệm vụ đòi hỏi lập luận chi tiết qua nhiều bước.

Khi chỉ nhận một prompt duy nhất, LLM có thể đưa ra câu trả lời quá chung chung, thiếu chiều sâu hoặc bỏ sót chi tiết quan trọng. Hạn chế này xuất phát từ việc khó bao quát đầy đủ ngữ cảnh cần thiết và cung cấp hướng dẫn phù hợp chỉ trong một prompt.

Giải pháp cho vấn đề này là prompt chaining.

Prompt chaining là việc chia nhỏ một nhiệm vụ phức tạp thành chuỗi các prompt nhỏ hơn, dễ xử lý hơn. Mỗi prompt giải quyết một phần cụ thể của nhiệm vụ, và đầu ra từ một prompt sẽ là đầu vào cho prompt tiếp theo. Cách làm này tạo ra một phương pháp có cấu trúc, dẫn dắt LLM qua chuỗi bước suy luận để đi đến câu trả lời chính xác và toàn diện hơn. Bằng việc sắp xếp các prompt theo trình tự logic, chúng ta có thể khai thác tối đa LLM để giải quyết hiệu quả các vấn đề phức tạp.

Hướng dẫn này nằm trong loạt bài “Kỹ thuật Prompt: Từ Zero đến Hero”:

1. Kỹ thuật Prompt cho mọi người
2. Zero-Shot Prompting
3. Few-Shot Prompting
4. Prompt Chaining

Prompt Chaining là gì?

Prompt chaining là phương pháp dùng đầu ra của một prompt LLM làm đầu vào cho prompt tiếp theo trong một chuỗi. Kỹ thuật này tạo ra loạt prompt liên kết với nhau, mỗi prompt tập trung vào một phần cụ thể của vấn đề tổng thể. Làm theo chuỗi này cho phép dẫn dắt LLM theo một quy trình suy luận có cấu trúc, giúp tạo ra phản hồi chính xác và chi tiết hơn.

Mục đích chính của prompt chaining là cải thiện hiệu năng, độ tin cậy và tính rõ ràng của ứng dụng LLM. Với các nhiệm vụ phức tạp, một prompt đơn lẻ thường không đủ chiều sâu và ngữ cảnh cho câu trả lời tốt. Prompt chaining giải quyết bằng cách chia nhiệm vụ thành các bước nhỏ, đảm bảo mỗi bước được xử lý cẩn thận. Cách làm này nâng cao chất lượng đầu ra của LLM và giúp dễ hiểu hơn cách đi đến kết quả cuối cùng.

Hãy cùng điểm qua một số lợi ích của prompt chaining:

Cách triển khai Prompt Chaining

Triển khai prompt chaining đòi hỏi một cách tiếp cận có hệ thống để chia nhỏ nhiệm vụ phức tạp và dẫn dắt LLM qua chuỗi các bước được xác định rõ. 

Hãy xem cách bạn có thể tạo và thực thi một chuỗi prompt hiệu quả.

Xác định các tiểu nhiệm vụ

Bước đầu tiên là phân rã nhiệm vụ phức tạp thành các tiểu nhiệm vụ nhỏ, dễ quản lý. Mỗi tiểu nhiệm vụ nên đại diện cho một khía cạnh riêng của vấn đề tổng thể. Như vậy, LLM có thể tập trung vào từng phần một.

Ví dụ, giả sử bạn muốn LLM viết một báo cáo toàn diện về biến đổi khí hậu. Các tiểu nhiệm vụ có thể gồm:

• Tìm hiểu dữ liệu khí hậu lịch sử
• Tóm tắt các phát hiện chính từ tài liệu khoa học
• Phân tích tác động của biến đổi khí hậu lên các hệ sinh thái khác nhau
• Đề xuất các giải pháp và chiến lược giảm thiểu tiềm năng

Thiết kế prompt

Tiếp theo, thiết kế các prompt rõ ràng, súc tích cho từng tiểu nhiệm vụ. Mỗi prompt cần cụ thể và trực diện để LLM hiểu nhiệm vụ và tạo đầu ra phù hợp. Quan trọng là đầu ra của một prompt phải phù hợp để làm đầu vào cho prompt tiếp theo, tạo nên dòng chảy thông tin.

Với các tiểu nhiệm vụ trên, ta có thể tạo các prompt sau:

• Prompt Tiểu nhiệm vụ 1: "Tóm tắt các xu hướng chính trong biến đổi nhiệt độ toàn cầu trong thế kỷ qua."
• Prompt Tiểu nhiệm vụ 2: "Dựa trên các xu hướng đã xác định, liệt kê các nghiên cứu khoa học chính bàn về nguyên nhân của những thay đổi này."
• Prompt Tiểu nhiệm vụ 3: "Tóm tắt các phát hiện của những nghiên cứu đã liệt kê, tập trung vào tác động của biến đổi khí hậu lên hệ sinh thái biển."
• Prompt Tiểu nhiệm vụ 4: "Đề xuất ba chiến lược giảm thiểu tác động của biến đổi khí hậu lên hệ sinh thái biển dựa trên các phát hiện đã tóm tắt."

Thực thi chuỗi

Giờ hãy thực thi các prompt theo thứ tự, truyền đầu ra của prompt trước làm đầu vào cho prompt sau. Cách thực thi từng bước đảm bảo LLM xây dựng dựa trên các đầu ra trước đó, tạo kết quả mạch lạc và toàn diện.

Trong ví dụ của chúng ta, các đầu ra cho tiểu nhiệm vụ có thể như sau:

• Đầu ra Tiểu nhiệm vụ 1: "Nhiệt độ toàn cầu đã tăng khoảng 1,2 độ C trong thế kỷ qua, với mức tăng đáng kể trong 20 năm gần đây."
• Đầu vào Tiểu nhiệm vụ 2: "Với việc nhiệt độ toàn cầu đã tăng 1,2 độ C trong thế kỷ qua, hãy liệt kê các nghiên cứu khoa học chính bàn về nguyên nhân của những thay đổi này."
• Đầu ra Tiểu nhiệm vụ 2: "Các nghiên cứu then chốt gồm: 'The Role of Greenhouse Gases in Global Warming' của Dr. Smith, 'Deforestation and Climate Change' của Dr. Jones, và 'Oceanic Changes and Climate Patterns' của Dr. Lee."
• Đầu vào Tiểu nhiệm vụ 3: "Tóm tắt các phát hiện của 'The Role of Greenhouse Gases in Global Warming' của Dr. Smith, 'Deforestation and Climate Change' của Dr. Jones, và 'Oceanic Changes and Climate Patterns' của Dr. Lee, tập trung vào tác động của biến đổi khí hậu lên hệ sinh thái biển."

Xử lý lỗi

Triển khai cơ chế xử lý lỗi là chìa khóa để giải quyết các vấn đề có thể phát sinh trong quá trình thực thi chuỗi prompt. Có thể thiết lập kiểm tra để xác minh chất lượng và mức độ liên quan của đầu ra trước khi chuyển sang prompt tiếp theo, và tạo các prompt dự phòng để đưa LLM trở lại đúng hướng nếu nó lệch khỏi quỹ đạo mong đợi. Ví dụ:

• Kiểm tra lỗi 1: Sau mỗi đầu ra, hãy xác minh thông tin có liên quan và đầy đủ không. Nếu bản tóm tắt xu hướng biến đổi nhiệt độ toàn cầu chưa đầy đủ, hãy nhắc LLM cung cấp chi tiết bổ sung.
• Prompt dự phòng: Nếu LLM không liệt kê được các nghiên cứu khoa học phù hợp, hãy dùng prompt cụ thể hơn như "Liệt kê năm nghiên cứu đã bình duyệt trong thập kỷ qua bàn về nguyên nhân gia tăng nhiệt độ toàn cầu."

Triển khai

Hãy xem cách triển khai bằng Python!

Bước 1: Thiết lập môi trường

Trước hết, chúng ta cần import các thư viện cần thiết. Ta sẽ dùng lớp OpenAI từ gói openai và os để xử lý biến môi trường.

import openai
import os

Lưu trữ an toàn thông tin nhạy cảm như API key là rất quan trọng. Một cách là đặt API key thành biến môi trường. Bạn có thể làm điều này bằng một OpenAI API key.

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

Hãy thay 'your-api-key-here' bằng OpenAI API key thực của bạn.

Với API key đã thiết lập, bạn có thể khởi tạo client OpenAI. Client này sẽ dùng để gọi API của OpenAI.

Client = OpenAI ()

Bước 2: Định nghĩa hàm tương tác với API chat completions của OpenAI.

Giờ chúng ta tạo một hàm Python để tương tác với API chat completions của OpenAI. Hàm này sẽ gửi prompt đến API và trả về phản hồi được tạo.

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

Phân tích hàm này—nó:

• Nhận một prompt và tham số model tùy chọn.
• Gọi API OpenAI qua endpoint chat completions.
• Thiết lập hội thoại với một system message và một user message (prompt).
• Đặt temperature = 0 để đầu ra có tính quyết định cao hơn (tăng temperature để sáng tạo hơn).
• Trả về nội dung phản hồi hoặc None nếu có lỗi.

Bước 3: Xâu chuỗi nhiều prompt

Giờ chúng ta tạo một hàm Python xâu chuỗi nhiều prompt, truyền đầu ra của prompt trước làm đầu vào cho prompt sau.

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

Hàm prompt_chain triển khai prompt chaining. Nó:

• Bắt đầu với prompt ban đầu và lấy completion.
• Lặp qua danh sách các prompt tiếp theo.
• Với mỗi prompt tiếp theo, kết hợp prompt với đầu ra trước đó, gọi completion cho prompt kết hợp và cập nhật kết quả.
• Nếu bước nào thất bại, trả về thông báo lỗi.
• In đầu ra của mỗi bước để dễ theo dõi.

Bước 4: Ví dụ sử dụng

Chúng ta sẽ minh họa cách dùng hàm prompt_chain để tạo chuỗi prompt xây dựng trên nhau. Ví dụ này tập trung tóm tắt các xu hướng nhiệt độ toàn cầu và khám phá nghiên cứu khoa học liên quan cùng chiến lược giảm thiểu, nhưng bạn có thể áp dụng cho trường hợp riêng của mình!

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)

Ở đây, ta định nghĩa prompt ban đầu về biến đổi nhiệt độ toàn cầu, sau đó thiết lập danh sách các prompt tiếp theo xây dựng trên nhau. Tiếp theo, gọi hàm prompt_chain với các prompt này và cuối cùng in ra kết quả cuối.

Cách các phần phối hợp với nhau

Tóm tắt quy trình:

1. Prompt ban đầu lấy bản tóm tắt xu hướng nhiệt độ.
2. Prompt theo sau đầu tiên dùng bản tóm tắt này để tìm nghiên cứu liên quan.
3. Prompt theo sau thứ hai tóm tắt phát hiện về hệ sinh thái biển.
4. Prompt cuối dùng toàn bộ thông tin để đề xuất chiến lược giảm thiểu.

Chuỗi này cho phép tiếp cận từng bước với truy vấn phức tạp, mỗi bước xây dựng trên thông tin từ các bước trước.

Các kỹ thuật Prompt Chaining

Prompt chaining có thể được triển khai theo nhiều cách để phù hợp với từng loại nhiệm vụ và yêu cầu. Dưới đây là ba kỹ thuật chính: Chuỗi tuần tự, Chuỗi có điều kiện và Chuỗi lặp.

Chuỗi tuần tự

Chuỗi tuần tự liên kết các prompt theo một trình tự tuyến tính, đơn giản. Mỗi prompt phụ thuộc vào đầu ra của prompt trước, tạo dòng chảy thông tin và nhiệm vụ theo từng bước. Kỹ thuật này phù hợp với các nhiệm vụ cần tiến trình logic từ giai đoạn này sang giai đoạn khác, như:

• Tóm tắt văn bản: Chia một tài liệu dài thành các phần tóm tắt, rồi ghép các bản tóm tắt thành bản tổng hợp mạch lạc.
• Sinh mã: Tạo đoạn mã theo từng bước, như viết định nghĩa hàm, rồi hiện thực hàm, cuối cùng viết test.

Đoạn mã ở phần trước là ví dụ về chuỗi tuần tự.

Chuỗi có điều kiện

Chuỗi có điều kiện đưa nhánh rẽ vào chuỗi prompt dựa trên đầu ra của LLM. Kỹ thuật này tạo quy trình linh hoạt, thích ứng, cho phép LLM đi theo các hướng khác nhau tùy phản hồi nó tạo ra.

Hãy xem cách triển khai chuỗi có điều kiện để phân tích cảm xúc.

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)

Đầu tiên, ta định nghĩa hàm analyze_sentiment() dùng mô hình ngôn ngữ để xác định cảm xúc của đoạn văn bản. Sau đó, trong hàm conditional_prompt_chain(), ta bắt đầu với prompt ban đầu về mức độ ứng dụng năng lượng tái tạo. Sau khi có phản hồi ban đầu, ta phân tích cảm xúc của nó. Dựa trên cảm xúc, ta chọn prompt tiếp theo khác nhau:

•  Nếu tích cực, hỏi về cơ hội.
•  Nếu tiêu cực, hỏi về giải pháp.
•  Nếu trung lập, hỏi về các trọng tâm chính.

Prompt tiếp theo được chọn sẽ được gửi tới mô hình kèm ngữ cảnh từ phản hồi ban đầu. Kết quả cuối là phản hồi cho prompt theo sau có điều kiện này.

Lưu ý lựa chọn prompt thứ hai không cố định trước mà phụ thuộc vào nội dung phản hồi đầu tiên. Luồng hội thoại cũng thích ứng dựa trên phân tích cảm xúc, thể hiện cách chuỗi có thể rẽ nhánh. Điều này cho phép tương tác năng động và nhận biết ngữ cảnh hơn với mô hình ngôn ngữ.

Khi chạy đoạn mã này, câu hỏi tiếp theo cụ thể sẽ phụ thuộc việc phân tích ban đầu về mức độ ứng dụng năng lượng tái tạo được xem là tích cực, tiêu cực hay trung lập. Điều này tạo nên chuỗi prompt thích ứng và linh hoạt hơn.

Chuỗi lặp

Chuỗi lặp tạo vòng lặp trong chuỗi prompt để lặp qua dữ liệu hoặc thực hiện tác vụ lặp lại. Kỹ thuật này hữu ích khi xử lý danh sách hay tập hợp mục cần các bước xử lý tương tự. Một số lợi ích và thách thức:

• Hiệu quả: Tự động hóa tác vụ lặp lại, tiết kiệm thời gian và công sức.
• Xử lý dữ liệu: Phù hợp cho các tác vụ như xử lý nhiều bản ghi, tóm tắt theo lô, hoặc cải thiện lặp.
• Thách thức: Cần xử lý cẩn thận để tránh vòng lặp vô hạn và đảm bảo mỗi vòng mang lại tiến triển có ý nghĩa.

Hãy xem cách triển khai chuỗi lặp cho tác vụ kiểm tra độ đầy đủ văn bản:

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)

Trước hết, ta định nghĩa hàm check_completeness() dùng mô hình ngôn ngữ để xác định một phản hồi đã đầy đủ hay cần thêm thông tin.

Sau đó, trong hàm looping_prompt_chain(), ta bắt đầu với prompt về quang hợp. Sau khi có phản hồi ban đầu, ta vào vòng lặp:

• Kiểm tra phản hồi hiện tại đã đầy đủ bằng check_completeness().
• Nếu đầy đủ, thoát vòng lặp và trả kết quả.
• Nếu chưa đủ, tạo prompt mới yêu cầu mở rộng phản hồi trước.
• Nhận phản hồi mới dựa trên prompt mở rộng này.

Quy trình tiếp tục cho đến khi có phản hồi được coi là đầy đủ hoặc đạt số vòng lặp tối đa (mặc định là 5).

Vòng lặp đảm bảo ta liên tục tinh chỉnh và mở rộng phản hồi cho đến khi đạt mức đầy đủ hoặc chạm giới hạn vòng lặp.

Khi chạy mã, chương trình sẽ cố gắng cung cấp giải thích toàn diện về quang hợp, có thể trải qua nhiều vòng mở rộng nếu phản hồi ban đầu chưa đầy đủ. Điều này tạo chuỗi prompt kỹ lưỡng và thích ứng hơn, hướng tới kết quả cuối cùng toàn diện.

Ứng dụng thực tiễn của Prompt Chaining

Prompt chaining có thể tăng cường đáng kể khả năng của LLM trên nhiều ứng dụng. Phần này khám phá một số cách sử dụng thực tế, minh họa cách áp dụng cho các tác vụ đời thực.

Trả lời câu hỏi dựa trên tài liệu

Prompt chaining có thể dùng để tóm tắt tài liệu dài rồi tạo câu trả lời cho câu hỏi cụ thể. Quy trình gồm chia tài liệu thành phần nhỏ, tóm tắt từng phần, rồi dùng các bản tóm tắt này để trả lời câu hỏi chi tiết.

Hãy xem cách triển khai:

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

Đoạn mã này minh họa cách dùng prompt chaining cho các tác vụ phức tạp như phân tích tài liệu và hỏi đáp. Nó chia một nhiệm vụ lớn (hiểu một tài liệu dài) thành các bước nhỏ (tóm tắt từng phần). Nó dùng đầu ra của bước này (các bản tóm tắt) làm đầu vào cho bước tiếp theo (trả lời câu hỏi). Cách này cho phép xử lý tài liệu quá dài để đưa vào một prompt duy nhất.

Khi chạy mã với tài liệu dài thực tế, chương trình sẽ chia tài liệu thành các phần, tóm tắt từng phần, và dùng những tóm tắt này để trả lời các câu hỏi về nguyên nhân, tác động và giải pháp liên quan đến biến đổi khí hậu.

Sinh văn bản kèm kiểm chứng sự thật

Sinh văn bản kèm kiểm chứng sự thật là tạo văn bản rồi lồng các bước kiểm tra tính xác thực vào chuỗi prompt. Điều này đảm bảo đầu ra không chỉ mạch lạc mà còn chính xác.

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)

Hàm text_generation_with_verification() quản lý toàn bộ quy trình. Nó bắt đầu bằng generate_text() để tạo đoạn văn ban đầu về chủ đề. Sau đó, extract_facts() trích xuất các khẳng định chính từ văn bản này. verify_facts() kiểm tra các khẳng định, gán nhãn True, False hoặc Uncertain. Cuối cùng, revise_text() viết lại văn bản gốc, sửa lỗi và ghi chú thông tin chưa chắc chắn. Quy trình giúp đảm bảo văn bản cuối cùng vừa giàu thông tin vừa chính xác.

Prompt chaining diễn ra qua nhiều bước: sinh văn bản ban đầu, trích xuất sự kiện từ văn bản đã sinh, kiểm chứng từng sự kiện, và chỉnh sửa văn bản dựa trên kết quả kiểm chứng.

Khi chạy mã với chủ đề như "tác động của biến đổi khí hậu lên gấu Bắc Cực", chương trình sẽ tạo văn bản ban đầu, trích xuất các khẳng định, kiểm chứng từng khẳng định và chỉnh sửa văn bản dựa trên các sự thật đã xác minh, đảm bảo đầu ra chính xác hơn. Bạn có thể dùng bất kỳ chủ đề nào mình chọn!

Sinh mã kèm gỡ lỗi

Dùng prompt chaining để viết mã rồi kiểm thử có thể tăng tốc phát triển. Cách này giúp đảm bảo mã hoạt động đúng và đạt mục đích, vượt xa việc chỉ chạy không lỗi.

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)

Hàm code_generation_with_debugging() quản lý toàn bộ quy trình. Cách hoạt động: Đầu tiên, generate_code() viết mã Python cho nhiệm vụ. Sau đó, generate_test_cases() tạo test cho mã. run_tests() kiểm tra mã có vượt qua các test không. Nếu có test thất bại, debug_code() cố gắng sửa lỗi.

Lưu ý mỗi bước xây dựng trên bước trước. Bắt đầu viết mã, rồi tạo test, chạy test và sửa vấn đề. Cách này chia nhỏ việc lập trình thành các bước dễ hơn. Nó cho thấy prompt chaining xử lý tốt nhiệm vụ phức tạp như viết mã, mô phỏng cách lập trình viên làm việc: viết, kiểm thử và sửa lỗi. Mỗi bước tận dụng kết quả trước đó, cho phép cải thiện mã dần dần.

Khi chạy mã với nhiệm vụ "tính giai thừa của một số", chương trình sẽ tạo mã Python ban đầu, tạo các test cho hàm này, mô phỏng chạy test và báo cáo kết quả. Nếu có test thất bại, chương trình sẽ cố gắng gỡ lỗi và sửa mã, rồi chạy lại test.

Nhiệm vụ suy luận nhiều bước

Prompt chaining có thể giải quyết các vấn đề phức tạp cần nhiều bước suy luận, như bài toán có lời văn hay câu đố logic. Mỗi bước xây dựng trên bước trước, đảm bảo cách tiếp cận có cấu trúc và kỹ lưỡng.

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)

Đầu tiên, solve_step_by_step() chia bài toán thành các phần nhỏ. Nó yêu cầu mô hình AI đưa ra từng bước, lần lượt, cho đến khi hoàn tất lời giải. Mỗi bước được lưu lại. Sau đó, combine_steps() lấy tất cả các bước này và yêu cầu AI ghép thành một lời giải mạch lạc. Hàm get_completion() xử lý việc gọi OpenAI API trong suốt quá trình.

Trong ví dụ này, bài toán là: "Một chiếc xe đi 60 dặm/giờ trong 2 giờ, rồi 40 dặm/giờ trong 3 giờ. Tổng quãng đường xe đi được là bao nhiêu?"

Khi chạy mã, chương trình sẽ chia bài toán thành các bước suy luận nhỏ, thu thập và in từng bước, rồi ghép các bước thành lời giải cuối cùng và in ra.

Thực hành tốt nhất cho Prompt Chaining

Cần tuân theo một số thực hành tốt để tối đa hóa hiệu quả của prompt chaining. Những thực hành này đảm bảo chuỗi của bạn vững chắc, chính xác và hiệu quả, dẫn đến kết quả tốt hơn và ứng dụng LLM đáng tin cậy hơn.

Thiết kế prompt

Sử dụng prompt rõ ràng và súc tích là điều cốt yếu để nhận được kết quả tốt từ LLM. Khi prompt thẳng thắn, mô hình dễ hiểu yêu cầu của bạn, giảm nhầm lẫn và nâng cao chất lượng phản hồi.

Một số mẹo:

• Dùng ngôn ngữ đơn giản: Tránh từ ngữ phức tạp và thuật ngữ kỹ thuật.
• Hãy trực diện: Nêu rõ điều bạn muốn, không thêm chi tiết không cần thiết.
• Tập trung vào một nhiệm vụ: Mỗi prompt nên giải quyết một nhiệm vụ hoặc câu hỏi duy nhất. 

Ví dụ:

• Thay vì: "Bạn có thể vui lòng tóm tắt các điểm chính của xu hướng nhiệt độ toàn cầu trong thế kỷ qua, tập trung vào những thay đổi đáng kể và nguyên nhân tiềm ẩn, cũng như các sự kiện nổi bật có thể ảnh hưởng tới các xu hướng này không?"
• Hãy dùng: "Tóm tắt các điểm chính của xu hướng nhiệt độ toàn cầu trong thế kỷ qua."

Sử dụng prompt có cấu trúc tốt cũng là chìa khóa để giúp LLM theo dõi dòng chảy logic của nhiệm vụ. Khi prompt được tổ chức mạch lạc, mô hình sẽ hiểu và phản hồi phù hợp hơn.

Một số mẹo:

• Chia nhỏ nhiệm vụ phức tạp: Phân chia thành các bước nhỏ, dễ quản lý.
• Đảm bảo dòng chảy logic: Mỗi prompt xây trên prompt trước và dẫn mạch lạc tới prompt sau.

Cấu trúc prompt như vậy sẽ dẫn dắt LLM thực hiện từng bước, mang lại phản hồi tốt và chính xác hơn. Ví dụ:

• Bước 1: "Liệt kê những thay đổi lớn trong nhiệt độ toàn cầu trong thế kỷ qua."
• Bước 2: "Xác định nguyên nhân tiềm năng cho mỗi thay đổi lớn về nhiệt độ toàn cầu."

Thử nghiệm

Các nhiệm vụ khác nhau cần cách xâu chuỗi prompt khác nhau. Chọn đúng phương pháp cho nhiệm vụ của bạn có thể tạo khác biệt lớn. Nên thử nhiều cách tiếp cận và xem cách nào hiệu quả nhất với mục tiêu của bạn. Kiểm thử và so sánh giúp bạn tìm được phương pháp tối ưu.

Cần thường xuyên đánh giá hiệu quả chuỗi prompt của bạn. Xem xét độ chính xác, đầy đủ và mức độ liên quan của đầu ra. Điều này giúp bạn biết phần nào đang hoạt động tốt và phần nào cần cải thiện. Bằng cách làm thường xuyên, bạn có thể điều chỉnh và tối ưu để đạt kết quả tốt nhất.

Tinh chỉnh lặp

Tinh chỉnh lặp dựa trên phản hồi và kết quả sẽ dẫn đến các prompt chính xác và hiệu quả hơn. Bạn có thể liên tục cải thiện hiệu năng LLM bằng cách thu thập phản hồi từ đầu ra, xác định điểm yếu và điều chỉnh prompt tương ứng. Quy trình liên tục này đảm bảo prompt của bạn ngày càng chính xác và phù hợp theo thời gian. Ví dụ:

• Prompt ban đầu: "Mô tả tác động của biến đổi khí hậu."
• Prompt đã tinh chỉnh: "Mô tả tác động của biến đổi khí hậu lên hệ sinh thái ven biển trong thập kỷ qua."

Tinh chỉnh cấu trúc chuỗi

Cách bạn sắp xếp chuỗi prompt có thể ảnh hưởng mạnh đến kết quả. Việc thay đổi thứ tự và logic của prompt dựa trên những gì hiệu quả là hữu ích. Điều này đảm bảo mỗi bước hợp lý sau bước trước đó. Khi làm vậy, bạn sẽ nhận được câu trả lời tốt hơn và logic hơn từ AI.

Xử lý lỗi

Xử lý lỗi vững chắc đảm bảo chuỗi prompt vẫn hoạt động ngay cả khi một số prompt thất bại. Bằng cách thiết lập kiểm tra tính hợp lệ của đầu ra và dùng prompt dự phòng, bạn có thể đưa LLM trở lại đúng hướng khi lỗi xảy ra. Cách tiếp cận này duy trì luồng và độ tin cậy của chuỗi prompt, đảm bảo hiệu năng ổn định.

Giám sát và ghi log

Việc theo dõi hiệu quả chuỗi prompt là quan trọng. Điều này giúp bạn hiểu điều gì hiệu quả và phát hiện vấn đề. Hãy dùng công cụ để ghi lại thông tin quan trọng như đầu vào, đầu ra và thời gian xử lý. Chẳng hạn, ghi lại từng bước trong chuỗi, những gì được tạo ra và bất kỳ lỗi nào xảy ra. Làm vậy giúp bạn phân tích quy trình và cải thiện, dẫn đến kết quả tốt hơn.

Việc lưu trữ hồ sơ chi tiết giúp bạn khắc phục sự cố và cải tiến chuỗi prompt. Hãy lưu trữ một cách có tổ chức để dễ phân tích và rút kinh nghiệm. Điều này giúp phát hiện vấn đề và tinh chỉnh chuỗi prompt, nhờ đó hoạt động hiệu quả hơn và đưa ra câu trả lời chính xác hơn

Tuân thủ các thực hành tốt này sẽ giúp bạn tạo ra các chuỗi prompt hiệu quả và đáng tin cậy, nâng cao năng lực của LLM, đảm bảo hiệu năng tốt hơn và kết quả có ý nghĩa hơn trên nhiều ứng dụng.

Kết luận

Trong bài viết này, chúng ta đã tìm hiểu prompt chaining, một kỹ thuật tăng cường hiệu năng của LLM trên các nhiệm vụ phức tạp bằng cách chia chúng thành các prompt nhỏ, dễ quản lý. Chúng ta đã đề cập các phương pháp xâu chuỗi, ứng dụng và thực hành tốt nhất để bạn tận dụng LLM hiệu quả cho nhiều trường hợp sử dụng.

Nếu bạn muốn tìm hiểu thêm về kỹ thuật prompt, tôi khuyến nghị các bài viết sau:

• Prompt Compression: Hướng dẫn kèm ví dụ Python
• Buffer of Thoughts (BoT)
• DSPy là gì? Cách hoạt động, trường hợp sử dụng và tài nguyên
• Tìm hiểu Prompt Tuning