update prompt techniques

ntk148v · ntk148v · commit 585c5c19f218 · 2025-05-20T15:39:44.000+07:00
diff --git a/ai/prompt-engineering-guide/techniques.md b/ai/prompt-engineering-guide/techniques.md
@@ -11,12 +11,16 @@ Table of contents:
     - [2.2.2. Zero-shot CoT](#222-zero-shot-cot)
     - [2.2.3. Automatic CoT (Auto-CoT)](#223-automatic-cot-auto-cot)
     - [2.2.4. Self-Consistency](#224-self-consistency)
-  - [2.3. Tree of thoughts (ToT)](#23-tree-of-thoughts-tot)
-  - [2.4. Knowledge-enhanced techniques](#24-knowledge-enhanced-techniques)
-    - [2.4.1. Generated knowledge prompting](#241-generated-knowledge-prompting)
-    - [2.4.2. Retrieval augmented generation (RAG)](#242-retrieval-augmented-generation-rag)
+    - [2.2.5. Tree of thoughts (ToT)](#225-tree-of-thoughts-tot)
+  - [2.3. Knowledge-enhanced techniques](#23-knowledge-enhanced-techniques)
+    - [2.3.1. Generated knowledge prompting](#231-generated-knowledge-prompting)
+    - [2.3.2. Retrieval augmented generation (RAG)](#232-retrieval-augmented-generation-rag)
   - [2.4. Action-oriented techniques](#24-action-oriented-techniques)
     - [2.4.1. ReAct Prompting](#241-react-prompting)
+    - [2.4.2. Program-Aided language models (PAL)](#242-program-aided-language-models-pal)
+    - [2.4.3. Prompt Chaining](#243-prompt-chaining)
+  - [2.5. Automated techniques](#25-automated-techniques)
+    - [2.5.1. Automatic prompt engineering (APE)](#251-automatic-prompt-engineering-ape)
 
 ```mermaid
 graph TD
@@ -30,7 +34,8 @@ graph TD
     C --> C1[Chain-of-Thought]
     C --> C2[Zero-Shot CoT]
     C --> C3[Self-Consistency]
-    C --> C4[Tree of Thoughts]
+    C --> C4[Auto-CoT]
+    C --> C5[Tree of Thoughts]
 
     A --> D[Knowledge-Enhanced Techniques]
     D --> D1[Generated Knowledge]
@@ -217,7 +222,7 @@ Donny
 Classify the above email as IMPORTANT or NOT IMPORTANT as it relates to a software company. Let's think step by step.
 ```
 
-## 2.3. Tree of thoughts (ToT)
+### 2.2.5. Tree of thoughts (ToT)
 
 The Tree of Thoughts (ToT) is an advanced prompting framework that extends beyond the Chain-of-Thought (CoT) prompting technique. ToT enables language models to perform complex tasks that require exploration or strategic lookahead by leveraging a tree-based approach to generate and evaluate multiple reasoning paths.
 
@@ -318,11 +323,11 @@ Final Plan:
 - **Total:** $1,500 ✔️
 ```
 
-## 2.4. Knowledge-enhanced techniques
+## 2.3. Knowledge-enhanced techniques
 
 Knowledge-enhanced techniques augment the model's reasoning with additional information, either generated by the model itself or retrieved from external sources.
 
-### 2.4.1. Generated knowledge prompting
+### 2.3.1. Generated knowledge prompting
 
 Generated knowledge prompting involves having the model generate relevant knowledge or information before answering a question. This technique helps the model access its own knowledge in a structured way before attempting to solve a problem.
 
@@ -357,7 +362,7 @@ Generate 4 facts about the Kermode bear:
 Then, we feed that information into another prompt to write the blog post:
 ```
 
-### 2.4.2. Retrieval augmented generation (RAG)
+### 2.3.2. Retrieval augmented generation (RAG)
 
 Retrieval Augmented Generation enhances language models by incorporating information from external knowledge sources. This technique retrieves relevant documents or data from a knowledge base and provides them as context for the model to generate a response.
 
@@ -389,5 +394,93 @@ graph LR
 
 ### 2.4.1. ReAct Prompting
 
-> [!WARNING]
-> WIP
+ReAct (Reasoning and Acting) is a framework where language models generate both reasoning traces and task-specific actions in an interleaved manner. This allows the model to reason about its actions and use external tools to gather information.
+
+ReAct prompting works by combining reasoning and acting into a thought-action loop. The
+LLM first reasons about the problem and generates a plan of action. It then performs the
+actions in the plan and observes the results. The LLM then uses the observations to update
+its reasoning and generate a new plan of action. This process continues until the LLM
+reaches a solution to the problem.
+
+To see this action, you need to write some [code](https://github.com/ntk148v/testing/blob/7516cfe2265ac974b9f2bf10305411bf02a69e6c/python/react_agent/main.py).
+
+```mermaid
+flowchart TD
+    A[Question] --> B[Thought: Reasoning about question]
+    B --> C[Action: Using external tool]
+    C --> D[Observation: Result from tool]
+    D --> E[Thought: Reasoning with new info]
+    E --> F[Action: Using tool again]
+    F --> G[Observation: New result]
+    G --> H[Thought: Final reasoning]
+    H --> I[Final Answer]
+```
+
+Below is an example from [HotPotQA2](https://hotpotqa.github.io), a question-answering dataset requiring complex reasoning. ReAct allows the LLM to reason about the question (Thought 1), take actions (e.g., querying Google) (Act 1). It then receives an observation (Obs 1) and continues the thought-action loop until reaching a conclusion (Act 3).
+
+![](https://www.promptingguide.ai/_next/image?url=%2F_next%2Fstatic%2Fmedia%2Freact.8e7c93ae.png&w=828&q=75)
+
+**Key characteristics:**
+
+- Alternates between reasoning (Thought) and actions
+- Can interact with external tools like search engines
+- Combines internal knowledge with external information
+- Improves performance on knowledge-intensive tasks
+- Enhanced interpretability through reasoning traces
+
+### 2.4.2. Program-Aided language models (PAL)
+
+Program-Aided Language Models use code as an intermediate step for solving complex problems. Instead of generating the answer directly, PAL generates a program (typically in Python) that computes the answer.
+
+![](https://www.promptingguide.ai/_next/image?url=%2F_next%2Fstatic%2Fmedia%2Fpal.dfc96526.png&w=828&q=75)
+
+**Key characteristics**:
+
+- Uses code generation as an intermediate reasoning step
+- Leverages programming language semantics for precise computation
+- Offloads calculation and logical reasoning to code execution
+- Particularly effective for mathematical and algorithmic tasks
+
+Check out [a simple Python application](https://github.com/ntk148v/testing/blob/master/python/pal/main.py) that's able to interpret the question being asked and provide an answer by leveraging the Python interpret.
+
+### 2.4.3. Prompt Chaining
+
+Prompt chaining involves breaking down complex tasks into subtasks and using the output of one prompt as input to another. This technique creates a chain of prompts, each handling a specific part of the overall task.
+
+Prompt chaining is useful to accomplish complex tasks which an LLM might struggle to address if prompted with a very detailed prompt.
+
+```mermaid
+flowchart TD
+    A[Document] --> B[Prompt 1: Extract Quotes]
+    A --> D[Prompt 2: Answer Question]
+    B --> C[Relevant Quotes]
+    C --> D
+    E[User Question] --> B
+    E --> D
+    D --> F[Final Answer]
+```
+
+**Key characteristics:**
+
+- Decomposes complex tasks into manageable subtasks
+- Uses outputs from earlier prompts as inputs to later ones
+- Increases reliability and controllability
+- Allows for more transparent debugging and analysis
+- Especially useful for complex multi-stage tasks
+
+## 2.5. Automated techniques
+
+### 2.5.1. Automatic prompt engineering (APE)
+
+At this point you might realize that writing a prompt can be complex. Wouldn't it be nice to automate this (write prompt to write prompt)? Well, there's a method: Automatic Prompt Engineering (APE). This method not only alleviate the need for human input but also enhances the model's performance in various tasks.
+
+![](https://www.promptingguide.ai/_next/image?url=%2F_next%2Fstatic%2Fmedia%2FAPE.3f0e01c2.png&w=828&q=75)
+
+**How APE Works**
+
+- Define a task to optimize
+- Use an inference LLM to generate instruction candidates based on output demonstrations
+- Execute these instructions using a target model
+- Evaluate performance to find the best instruction
+
+APE has discovered more effective zero-shot CoT prompts than human-engineered ones. For example, APE found that "Let's work this out in a step by step way to be sure we have the right answer" elicits better chain-of-thought reasoning than the human-designed "Let's think step by step" prompt.
