Zero-Shot and Few-Shot Learning with Reasoning LLMs

As large language models have already become essential components of so many real-world applications, understanding how they reason and learn from prompts is critical. From answering questions to solving complex problems, the way we structure inputs can have a significant impact the quality of their outputs.

This article briefly introduces reasoning language models and analyzes two common learning approaches they use to address complex tasks: zero-shot learning and few-shot learning, outlining the key benefits, limitations, and key differences between each learning approach.

What are Reasoning LLMs?

Large language models (LLMs) are massive artificial intelligence (AI) solutions capable of understanding complex text inputs and generating responses to a variety of natural language questions or requests, like providing an answer, translating a text, summarizing it, and so on.

But do all LLMs behave similarly in the process that leads them to generate natural language responses to user prompts? Not quite: reasoning-capable LLMs specialize in breaking down complex user queries into simpler subproblems and solving them logically before generating a coherent and accurate response. This enhanced internal process enables a more profound understanding and more structured answers compared to standard LLMs that focus more on surface-level next-word prediction.

The differences between reasoning-capable and conventional LLMs based on the transformer architecture, from a procedural viewpoint, are depicted below:

Difference between classic and reasoning LLMs

Some key characteristics of reasoning-capable LLMs include their instruction tuning and prompting strategies that guide them to use logical inference and draw conclusions from information, employing the so-called Chain of Thought (CoT) prompting mechanism which divides the problem into a set of intermediate steps before generating the final answer, and their applicability in complex domains like education, engineering, and finance, where accurate reasoning is vital.

Here’s a simple example of a CoT prompt for solving a math problem:

Question: If a dozen eggs cost $4, how much does one egg cost?

Answer: A dozen eggs means 12 eggs. If 12 eggs cost $4, then each egg costs $4 ÷ 12 = $0.33. So the answer is 33 cents.

This kind of step-by-step prompt encourages the model to reason through intermediate steps before arriving at the final answer, leading to more reliable and interpretable outputs.

Zero-Shot vs. Few-Shot Learning in Reasoning LLMs

Reasoning LLMs can adopt several learning approaches for solving tasks without requiring extensive task-specific retraining. Two of the most common are zero-shot learning and few-shot learning. Both zero-shot and few-shot prompting are forms of in-context learning — a term used to describe how language models use examples and instructions provided in the same prompt (or “context”) to infer how to perform a task, without any changes to the underlying model weights.

In zero-shot learning, the LLM attempts to complete a task based solely on its general pre-training, without seeing any examples in the prompt about the target task to address. This process is particularly frequent for problems like answering straightforward factual questions, summarizing text, or classifying, to name a few representative use cases.

For instance, suppose a user requests the LLM to “summarize this lengthy article in three sentences.” Under a zero-shot learning approach, the model will put its efforts in directly generating (word by word) a summary of the text passed as input alongside the prompt, without having been exposed to any specific examples of article summaries during the interaction.

You may have guessed it already, but zero-shot behavior is basically having an LLM immediately try to answer a user’s question without guidance from examples. While modern reasoning-capable LLMs can still apply structured thinking in zero-shot mode depending on how the prompt is written, the process involves relying entirely on general pretraining.

It is, however, with few-shot learning where reasoning LLMs truly shine. By applying few-shot learning, an LLM can go several steps beyond simple pattern matching by being exposed to several example input-output pairs, thereby giving the model the necessary guidelines and nuances to approach the task in a more structured and contextually appropriate fashion. In other words, through examples, we tell the model how we want its generated response to look.

Returning to our earlier example of summarizing a text, an example user prompt for the same task based on few-shot learning could be as follows (assuming the articles to summarize are provided as attachments, for instance):

Summarize the following articles in no more than three sentences. Here are two examples of how I want the summary to be structured:

Example 1:
Article: “The Industrial Revolution marked a major turning point in history. It began in the late 18th century in Britain and led to major technological, socioeconomic, and cultural changes across the world.”
Summary: “The Industrial Revolution began in 18th-century Britain, triggering widespread technological and societal transformation.”

Example 2:
Article: “Climate change is causing a steady rise in global temperatures, leading to more extreme weather events, sea level rise, and biodiversity loss. Scientists are urging governments to implement urgent emission reduction strategies.”
Summary: “Climate change is accelerating global warming and ecological disruption, prompting urgent calls for emissions cuts.”

Now, summarize the following article:

Article: [insert user’s text here]
Summary:

To illustrate how different prompting strategies affect output, here’s a quick comparison of model behavior for the same task: summarizing a short article.

Task: Summarize the sentence “The moon influences Earth’s tides due to gravitational pull.”

• Zero-Shot: “The moon causes Earth’s tides.”
• Few-Shot: “Earth’s tides are caused by the moon’s gravity. See examples above for similar summaries.”
• Chain of Thought: “The moon’s gravity pulls on Earth’s oceans, creating bulges that result in tides. Therefore, the moon influences Earth’s tides.”

Each technique offers a different balance of brevity, context sensitivity, and logical structure.

Wrapping Up

To conclude, in few-shot learning, the purpose of examples is to teach the model the expected pattern to follow in the reasoning process that will lead to the generated response. It’s not just about showing the input content the model needs to understand, but also examples of how it should generate the output. Despite its advantages, few-shot prompting comes with trade-offs. One major limitation is token length constraints: since every example must be packed into the same prompt as the task input, long examples or large numbers of them can easily exceed model limits. Additionally, few-shot performance can be highly sensitive to formatting, as even minor inconsistencies in prompt structure can lead to inconsistent results.

We cannot finalize without mentioning other examples of reasoning processes where few-shot learning via user prompts can go the extra mile: mathematical problem solving like arithmetic operations or simple equations, legal document summarization, reasoning over medical diagnosing reports, code generation, scientific question-answering, multi-step logical puzzles, and contractual document analysis, among many others.