Giving Examples (Few-Shot Prompting)

While clear instructions are essential for communicating with Large Language Models, sometimes just telling the model what to do isn't enough. Imagine trying to teach someone a new game just by describing the rules versus showing them a few rounds. Often, seeing examples makes the task much clearer. This is where few-shot prompting comes in.

Instead of relying solely on instructions (which is sometimes called zero-shot prompting), few-shot prompting involves including examples of the task you want the LLM to perform directly within your prompt. You show the model the pattern, the format, or the type of response you expect. Providing just one example is called one-shot prompting, while providing more than one (typically 2 to 5) is referred to as few-shot prompting.

Why Show Examples?

Providing examples in your prompt offers several advantages:

1. Clarity: Examples can resolve ambiguities in your instructions. What you mean by "summarize briefly" or "extract names" might be interpreted differently by the model than you intend. An example makes your expectation concrete.
2. Format Specification: If you need the output in a specific format (like a list, JSON, or a particular sentence structure), showing examples is often the most effective way to guide the model.
3. Task Demonstration: For tasks that are slightly unusual or require a specific style (like classifying text into custom categories or adopting a certain persona), examples demonstrate the desired behavior more effectively than descriptions alone.
4. Improved Accuracy: By seeing examples of correct input-output pairs, the model gets a better understanding of the task's nuances, often leading to more accurate and relevant responses.

Structuring Few-Shot Prompts

A typical few-shot prompt includes:

1. (Optional but Recommended) An instruction: Briefly describe the task.
2. Examples: Provide one or more pairs of input and desired output.
3. Your final input: The actual query or input you want the model to process.

It's important to format your examples consistently so the model can easily recognize the pattern. Common formats include using labels like Input: and Output:, or Q: and A:, or simply demonstrating the transformation.

Let's look at a simple example: classifying the sentiment of movie reviews.

Zero-Shot Prompt (Instruction Only):

Classify the sentiment of the following movie review as Positive, Negative, or Neutral.

Review: This movie was absolutely fantastic, a must-see!
Sentiment:

The model might correctly identify this as Positive. But for more detailed reviews, or if you have specific ideas about what counts as Neutral, examples help.

Few-Shot Prompt (Instruction and Examples):

Classify the sentiment of the following movie reviews as Positive, Negative, or Neutral.

Review: I loved the acting and the storyline was gripping.
Sentiment: Positive

Review: The plot was predictable and the pacing felt slow.
Sentiment: Negative

Review: It was an okay movie, neither great nor terrible.
Sentiment: Neutral

Review: This movie was absolutely fantastic, a must-see!
Sentiment:

By providing examples, you've given the model a clearer template for the task. It sees the input format (Review:), the desired output format (Sentiment:), and examples of how inputs map to outputs according to your definition.

Here's another example: extracting specific information and formatting it as JSON.

Task: Extract the fruit and color from a sentence.

Few-Shot Prompt:

Extract the fruit and its color from the sentence and provide the output in JSON format.

Sentence: I bought a bright red apple.
JSON: {"fruit": "apple", "color": "red"}

Sentence: The recipe calls for a green lime.
JSON: {"fruit": "lime", "color": "green"}

Sentence: He ate a yellow banana for breakfast.
JSON:

The examples clearly demonstrate both the extraction task and the exact JSON structure required ({"fruit": "...", "color": "..."}). This makes it much more likely the model will produce the correct output for the final sentence compared to just asking it to "Extract the fruit and color as JSON."

Tips for Effective Few-Shot Prompting

• Quality over Quantity: Use clear, accurate, and relevant examples. A few good examples are better than many poor or inconsistent ones.
• Consistency: Maintain the same format for all your examples and for the final input you want the model to process. If you use Input: and Output: for the examples, use Input: for your final query too.
• Relevance: Ensure the examples directly relate to the specific task you want the model to perform on your final input.
• Start Small: Often, 1 to 3 examples (one-shot or few-shot) are sufficient. Adding too many examples can sometimes confuse the model or use up too much of its allowed input length (context window). Experiment to find what works best.

Few-shot prompting is a fundamental technique for improving the reliability and specificity of LLM responses. By showing the model what you want, in addition to telling it, you provide valuable context that helps bridge the gap between your intention and the model's output. As you practice, you'll develop an intuition for when and how to use examples effectively.