🟦 Program-of-Thoughts Prompting

Last updated on September 4, 2024 by Bhuwan Bhatt

What is Program-of-Thoughts Prompting?

In Chain-of-Thoughts (CoT) prompting¹, Large Language Models (LLMs) perform both reasoning and computations. The LLM generates mathematical expressions as a reasoning step and then solves it to get the final answer. However, LLMs are not the ideal candidate for solving mathematical expressions for three reasons:

• LLMs are prone to computational errors
• LLMs are incapable of solving complex mathematical expressions involving polynomial equations, differential equations, etc.
• LLMs are highly inefficient at expressing iteration

Program-of-Thoughts (PoT) prompting² is a prompting technique that separates reasoning from computation. To be specific, PoT delegates computation steps to an external language interpreter. For instance, the LLM can express the reasoning steps as a Python program, which can be delegated to a Python interpreter to get an accurate response.

The example input and output pair generated by employing CoT prompting and PoT prompting below illustrate how PoT differs from CoT.

• A sample response generated using CoT prompting:

• A sample response generated using PoT prompting:

It is clear that while CoT prompting generates natural language output, PoT prompting yields a Python program, which is executed in the Python interpreter to get the final response.

How to Use Program-of-Thoughts Prompting?

We can use PoT in either zero-shot or few-shot settings. In zero-shot PoT, the prompt doesn't include any exemplar.

The prompt generates a Python program as the output, which the Python interpreter executes to get the final output, i.e., 260.

def solver():
    seattle_sheep = 20
    charleston_sheep = seattle_sheep * 4
    toulouse_sheep = charleston_sheep * 2
    
    total_sheep = seattle_sheep + charleston_sheep + toulouse_sheep
    
    return total_sheep

# Now let's call the solver function and print the result
print(solver())

### OUTPUT
----
>>> 260

As expected, a few-shots PoT prompt requires exemplars demonstrating how to solve the problem. Like zero-shot, the output is a program that we separately execute using an interpreter to get the final output.

cost_of_original_house = 80000
increase_rate = 150 / 100
value_of_house = (1 + increase_rate) * cost_of_original_house
cost_of_repair = 50000
ans = value_of_house - cost_of_repair - cost_of_original_house
print(ans)
### OUTPUT
----
>>> 70000.0

PoT as an Intermediate Step

For problems requiring additional reasoning, PoT can also be utilized as an intermediate step to tackle the computation part. The code generated by PoT can be executed to get the intermediate result, which is then substituted with the original question to get the final answer using CoT.

What Are Program-of-Thoughts Prompting Results?

• Zero-shot PoT outperforms zero-shot CoT across all Math Word Problems (MWP) datasets by a significant margin.

• On financial datasets, few-shot PoT + Self-Consistency(SC) decoding outperforms few-shot CoT + SC by roughly 20% on FinQA/ConvFinQA and 7% on TATQA. On MWP datasets, few-shot PoT + Self-Consistency(SC) decoding wins by a small margin of roughly 2-6%.

Model	GSM8K	AQuA	SVAMP	TabWMP	FinQA	ConvFin	TATQA
Codex CoT-SC	78.0	52.0	86.8	75.4	44.4	47.9	63.2
PoT-SC-Codex	80.0	58.6	89.1	81.8	68.1	67.3	70.2

Limitations of Program-of-Thoughts Prompting

There are two major limitations to PoT prompting:

• PoT requires the execution of generated code. If the code is malicious and contains snippets like import os; os.rmdir(), it could harm the machine running the snippets. Code snippets could also be exploited to run SQL injection, which could either delete data or leak confidential data.
• For datasets like AQuA, which contain a complex and wide variety of questions, PoT's performance suffers. The reason behind this could be that the exemplars cannot cover the diversity of questions in the dataset.

Conclusion

Program-of-Thought (PoT) separates computation from reasoning by having the LLM express reasoning as structured programs rather than natural language, improving accuracy for tasks that can be represented as code, like math or accounting. However, PoT is limited to such problems and carries the risk of executing malicious code from user prompts.

Footnotes

1. Jason Wei. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. ↩

2. Wenhu Chen. (2022). Program of Thoughts Prompting: Disentangling Computation from Reasoning for Numerical Reasoning Tasks. ↩ ↩² ↩³