ms-ai-architect/skills/ms-ai-advisor/references/prompt-engineering/few-shot-learning-techniques.md

Few-Shot and Zero-Shot Learning Techniques

Last updated: 2026-06-24 Status: GA Category: Prompt Engineering & LLM Optimization

---

Introduksjon

Few-shot og zero-shot learning er grunnleggende teknikker i prompt engineering som endrer hvordan språkmodeller tilpasser seg nye oppgaver uten permanent modelltrening. Zero-shot learning utfører oppgaver basert kun på instruksjoner, mens few-shot learning bruker eksempler (input-output par) for å "prime" modellen til ønsket oppførsel. Begge teknikkene opererer via in-context learning — modellen endres ikke permanent, men eksemplene påvirker kun gjeldende inference. Disse metodene er sentrale for Azure OpenAI Service, Copilot Studio og Microsoft Agent Framework.

Verifikasjonsgrad: Verified (MCP microsoft-learn, januar 2026, re-verified april 2026)

---

Kjernekomponenter

Zero-Shot Learning

Definisjon: Prompts uten eksempler. Modellen svarer kun basert på eksisterende kunnskap og instruksjoner.

Bruksområder:

• Fine-tunede modeller som allerede er trent på instruksjonsdatasett
• Etablere ytelsesbaselines før eksperimentering med few-shot
• Kostnadseffektive løsninger (færre tokens)
• Enkle oppgaver hvor modellen har bred kunnskap

Eksempel (Azure OpenAI):

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Headline: Coach confident injury won't derail Warriors\nTopic:"}
]

Output: "The coach is confident that the injury won't derail the Warriors' season..."

Begrensninger:

• Variabel output-kvalitet uten kontekst
• Modellen "gjetter" ønsket format
• Mindre pålitelig for domene-spesifikke oppgaver

To primære bruksområder for zero-shot (Verified .NET AI docs, MCP 2026-04):

1. Fine-tunede LLM-er: Fungerer godt med modeller som allerede er trent på instruksjonsdatasett
2. Etablere performance baselines: Simuler reell brukeratferd → evaluer accuracy/precision → eksperimenter deretter med few-shot

One-Shot Learning

Definisjon: Én eksempel-par (input + output) i promptet.

Bruksområder:

• Demonstrere output-format
• Oppgaver med klart definerte mønstre
• Enkle transformasjoner (oversettelse, kategorisering)

Eksempel:

Q: Ask Constance if we need some bread
A: send-msg `find constance` Do we need some bread?

Q: Send a message to Greg to figure out if things are ready for Wednesday.
A:

Few-Shot Learning

Definisjon: Flere eksempler (typisk 2-100) som viser ønsket oppførsel. Eksemplene er "training data" i promptet, ikke i modellvektene.

Arkitektur med Chat Completions API:

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/"
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Assistant is an intelligent chatbot designed to help users answer their tax related questions. Instructions: - Only answer questions related to taxes. - If you're unsure of an answer, you can say 'I don't know' or 'I'm not sure' and recommend users go to the IRS website for more information."},
        # Few-shot eksempler som user/assistant par
        {"role": "user", "content": "When do I need to file my taxes by?"},
        {"role": "assistant", "content": "In 2023, you'll need to file your taxes by April 18th. The date falls after the usual April 15th deadline because April 15th falls on a Saturday in 2023. For more details, see https://www.irs.gov/filing/individuals/when-to-file"},
        {"role": "user", "content": "How can I check the status of my tax refund?"},
        {"role": "assistant", "content": "You can check the status of your tax refund by visiting https://www.irs.gov/refunds"},
        # Faktisk bruker-spørsmål
        {"role": "user", "content": "What deductions can I claim?"}
    ]
)

Hvorfor det fungerer:

• Modellen infererer kategori og format uten eksplisitt instruksjon
• Eksemplene "konditionerer" modellen for gjeldende inference
• Demonstrerer edge cases og ønsket tone

To primære bruksområder for few-shot (Verified .NET AI docs, MCP 2026-04):

1. Tuning av LLM: Legger til kunnskap og kan forbedre performance. Produserer flere tokens enn zero-shot — kan bli kostbart.
2. Fikse performance-problemer: Bruk zero-shot for baseline → eksperimenter med few-shot basert på svake punkter → iterer

Caveats (Verified .NET AI docs):

• Fungerer dårlig for komplekse resonneringsoppgaver — legg til instruksjoner for å motvirke dette
• Lange few-shot prompts øker latency og kostnad; det er en grense for prompt-lengde
• Med mange eksempler kan modellen lære falske mønstre (f.eks. "sentiment er dobbelt så ofte positivt som negativt")

---

Arkitekturmønstre

1. Eksempelutvalg-strategi

Kvalitetskrav:

- Relevant for use case
- Dekkende for edge cases
- Variasjon i input-format
- Konsistent output-struktur
- Representative for produksjonsdata

Anti-pattern: Bruke kun "happy path"-eksempler. Resultat: Modellen feiler på avvikende input.

Best practice: Inkluder eksempler som viser:

• Normale cases
• Edge cases (tomme verdier, ukjente kategorier)
• Feil-håndtering ("not found", "unsure")

2. Recency Bias Management

Problem: Modeller har recency bias — siste eksempler vektes høyere.

Mitigering:

import random

# Randomiser rekkefølge på few-shot eksempler for hver inference
examples = [example1, example2, example3, example4]
random.shuffle(examples)
messages = [system_message] + examples + [user_query]

Alternativ: Sample flere completions med forskjellige ordninger, og velg basert på konsensus.

3. Completion Cues (Prompt-priming)

Definisjon: Starter completion med et hint som styrer output-retning.

Eksempel:

User: "Summarize the following email..."
Assistant: "Key Points:\n- "

Cue ("Key Points:\n- ") trigger bullet-list output.

Bruk med Few-Shot:

messages = [
    {"role": "system", "content": "You extract factual claims from text."},
    {"role": "user", "content": "John Smith works at Microsoft."},
    {"role": "assistant", "content": "FACTUAL CLAIMS\n- John Smith is employed at Microsoft"},
    {"role": "user", "content": "Lucy has three children and lives in Oslo."},
    {"role": "assistant", "content": "FACTUAL CLAIMS\n- "}  # Cue for liste-fortsettelse
]

4. Token-Effektivitet

Few-shot bruker mange tokens. Optimaliseringsstrategier:

Teknikk	Beskrivelse	Token-sparing
Tabellar data	Bruk TSV/CSV fremfor JSON	30-50%
Forkortelser	Konsistent bruk av korte labels	10-20%
Caching (prompt caching)	Cache few-shot eksempler på tvers av requests	90% (cached tokens)
Selective examples	Velg kun mest relevante eksempler dynamisk	Variabel

Eksempel - Tabellformat:

Beer name	Style	ABV
Chimay Gold	Trappist pale ale	4.80%
Chimay Blue	Trappist dark ale	9.00%

Q: How many beers are less than 6% ABV?
A:

---

Beslutningsveiledning

Når bruke Zero-Shot

✅ Velg zero-shot hvis:

• Modellen er fine-tuned for oppgaven (GPT-4, gpt-4o)
• Oppgaven er generell (oppsummering, spørsmål-svar)
• Token-budsjett er begrenset
• Baselining ytelse før few-shot

❌ Unngå zero-shot hvis:

• Domene-spesifikk terminologi
• Output krever spesifikt format (JSON-schema, XML)
• Modellen konsekvent "gjetter feil" uten eksempler

Når bruke Few-Shot

✅ Velg few-shot hvis:

• Zero-shot gir inkonsistent output
• Spesifikke output-format (strukturert data)
• Domene-tilpasning nødvendig (juridisk, medisinsk)
• Lære modellen spesifikk tone/stil
• Emulere eksisterende system-oppførsel

❌ Unngå few-shot hvis:

• Context window for liten (få eksempler = ineffektivt)
• Latency-kritisk (flere tokens = tregere)
• Fine-tuning er tilgjengelig (permanent tilpasning)

Decision Tree

START
  │
  ├─ Er oppgaven generell og modellen fine-tuned?
  │   └─ YES → Zero-Shot
  │   └─ NO → Fortsett
  │
  ├─ Har du < 10 eksempler og oppgaven er kompleks?
  │   └─ YES → Few-Shot (2-10 eksempler)
  │   └─ NO → Fortsett
  │
  ├─ Trenger du permanent tilpasning med 100+ eksempler?
  │   └─ YES → Fine-Tuning (ikke few-shot)
  │   └─ NO → Few-Shot

---

Integrasjon med Microsoft-stakken

Azure OpenAI Service

Chat Completions API:

• System message: Instruksjoner og regler
• Few-shot: User/Assistant par i messages array
• Støtte for gpt-35-turbo, gpt-4, gpt-4o, o1-modeller (o1: zero-shot anbefales)

Best practice:

from openai import AzureOpenAI
import os

client = AzureOpenAI(
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
    api_version="2024-10-21"
)

# Few-shot pattern for sentiment analysis
response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": "You analyze sentiment from text. Rate 1-10 (10=most positive)."},
        {"role": "user", "content": "The product is amazing and exceeded expectations!"},
        {"role": "assistant", "content": "Sentiment: 9/10 (highly positive language, enthusiastic tone)"},
        {"role": "user", "content": "It's okay, nothing special."},
        {"role": "assistant", "content": "Sentiment: 5/10 (neutral, lukewarm response)"},
        {"role": "user", "content": "Disappointed. Does not work as advertised."},
        {"role": "assistant", "content": "Sentiment: 2/10 (negative, unmet expectations)"},
        {"role": "user", "content": "Fast delivery and excellent customer service!"}
    ]
)

Copilot Studio

Declarative Agents:

• Few-shot i instructions felt som eksempel-dialoger
• Støtter multi-turn few-shot (conversation history)

Grounding-kombinasjon:

instructions: |
  You help users find product information.

  Example:
  User: "Do you have laptops under $1000?"
  Assistant: "Yes, we have 5 models under $1000. Would you like me to list them?"

  User: "What's the return policy?"
  Assistant: "Our return policy is 30 days. For details, see [link]."

Microsoft Agent Framework (Semantic Kernel)

Few-shot via Semantic Function:

var fewShotPrompt = @"
Classify the following customer inquiry:

Examples:
Inquiry: 'My order hasn't arrived'
Category: SHIPPING

Inquiry: 'How do I reset my password?'
Category: ACCOUNT

Inquiry: 'What are your business hours?'
Category: INFO

Inquiry: {{$input}}
Category:";

var fewShotFunction = kernel.CreateSemanticFunction(fewShotPrompt);
var result = await fewShotFunction.InvokeAsync("I want a refund for my purchase");

Microsoft Foundry

Prompt Flow:

• Few-shot templates i "Prompt" node
• Dynamic example selection basert på similarity search (RAG + few-shot)

Pattern:

1. User query → Embedding
2. Similarity search i example database
3. Retrieve top-k relevante eksempler
4. Inject i few-shot prompt
5. Send til LLM

---

Offentlig sektor (Norge)

Personvern og GDPR

Risiko: Few-shot eksempler kan inneholde persondata.

Mitigering:

✓ Anonymiser alle eksempler (fjern navn, fødselsnummer, adresser)
✓ Bruk syntetiske data for few-shot
✓ Dokumenter eksempler i DPIA
✓ Unngå sensitive kategorier (helse, religion) i eksempler

Transparens (AI Act)

Krav: Dokumenter hvordan modellen er "trent" via few-shot.

Løsning:

• Logg eksempler brukt i produksjon
• Model Card: "System bruker few-shot learning med [N] eksempler for oppgave [X]"
• Eksempel-repository for audit

Språkstøtte

Problem: De fleste few-shot eksempler er på engelsk. Modeller kan "bleed" engelsk inn i norsk output.

Best practice:

messages = [
    {"role": "system", "content": "Du er en norsk AI-assistent. Svar alltid på norsk."},
    {"role": "user", "content": "Hva er hovedstaden i Norge?"},
    {"role": "assistant", "content": "Hovedstaden i Norge er Oslo."},
    {"role": "user", "content": "Hvor mange innbyggere har Bergen?"},
    {"role": "assistant", "content": "Bergen har ca. 285 000 innbyggere (2023)."},
    {"role": "user", "content": "Hvilke fylker grenser til Oslo?"}
]

Multilingual few-shot:

• Bruk konsekvent språk i eksempler
• Eksplisitt språkinstruksjon i system message
• Test med både bokmål og nynorsk hvis relevant

---

Kostnad og lisensiering

Prising

Token-forbruk:

Zero-shot: 50-200 tokens (instructions + query)
Few-shot (3 eksempler): 300-1000 tokens
Few-shot (10 eksempler): 1000-3000 tokens

Kostnadseksempel (Azure OpenAI gpt-4o, Norge Øst):

• Input: $0.005 per 1K tokens
• Few-shot med 10 eksempler (2000 tokens) = $0.01 per request
• 10 000 requests/dag = $100/dag = $3000/måned

Optimalisering:

✓ Prompt caching: Cache few-shot eksempler (90% reduksjon)
✓ Dynamic example selection: Kun relevante eksempler
✓ Batch processing: Kombiner flere queries
✓ Lavere temperatur: Reduserer retry-behov

Lisensiering

Produkt	Few-Shot Support	Lisens
Azure OpenAI	Full support	Pay-per-token
M365 Copilot	Begrenset (pre-defined)	E3/E5 inkludert
Copilot Studio	Full (custom agents)	Separate lisens + usage
Power Platform AI	Via connectors	Premium connector

Offentlig sektor:

• Azure OpenAI: Dataresidency Norway East/West
• M365 GCC: Few-shot i Copilot for Microsoft 365 GCC støttet
• On-premises: Ikke relevant (cloud-only)

---

For arkitekten

Når anbefale Few-Shot

Scenario 1: Klassifisering av henvendelser

Kunde: "Vi trenger å kategorisere 50 000 kundehenvendelser per måned."

Anbefaling:
- Start med zero-shot baseline (ukategorisert accuracy)
- Few-shot med 5-10 eksempler per kategori
- Evaluer precision/recall
- Hvis < 90% accuracy: Vurder fine-tuning

Scenario 2: Strukturert data-ekstraksjon

Kunde: "Vi skal ekstrahere info fra fakturaer til JSON."

Anbefaling:
- Few-shot er nødvendig (JSON-format er kritisk)
- 3-5 eksempler med ulike faktura-layout
- Kombiner med Azure Document Intelligence for OCR
- Fallback til manual review hvis confidence < 0.85

Trade-offs å diskutere

Dimensjon	Few-Shot	Fine-Tuning	RAG
Setup-tid	Minutter	Dager	Timer
Tokens per request	500-3000	50-200	200-1000
Latency	Høyere	Lavere	Middels
Adaptability	Umiddelbar	Krever retraining	Oppdater database
Kostnad	Medium-høy	Lav (etter training)	Medium
Use case	< 100 eksempler	> 1000 eksempler	Knowledge retrieval

Røde flagg

❌ Ikke bruk few-shot hvis:

• Kunden sier "vi har 10 000 eksempler" → Fine-tuning
• Real-time krav < 200ms latency → Fine-tuning + caching
• Sensitive data i eksempler uten anonymisering → GDPR-brudd
• Few-shot eksempler endres ukentlig → RAG er bedre

Spørsmål å stille kunden

1. Hvor mange eksempler har dere? (< 100 → few-shot, > 1000 → fine-tuning)
2. Hvor ofte endres eksempler? (Ofte → RAG, Sjelden → few-shot)
3. Hva er latency-krav? (< 1s → vurder alternativ til few-shot)
4. Inneholder eksempler persondata? (Ja → anonymiser først)
5. Hva er token-budsjett per request? (< 1000 → begrens eksempler)

Arkitekturmønstre

Pattern 1: Hybrid Few-Shot + RAG

User Query
    │
    ├─> Similarity Search (vector database)
    │   └─> Retrieve top-3 relevante eksempler
    │
    ├─> Retrieve grounding data (RAG)
    │
    └─> Construct prompt:
        - System message
        - Few-shot eksempler (top-3)
        - Grounding data
        - User query

Fordel: Dynamiske, relevante eksempler. Redusert token-bruk.

Pattern 2: Few-Shot with Fallback

1. Try few-shot (3 eksempler)
2. If confidence < 0.7 → Try few-shot (10 eksempler)
3. If confidence < 0.5 → Escalate to human

Fordel: Balanse mellom kostnad og kvalitet.

---

Kilder og verifisering

Verified (MCP microsoft-learn, januar 2026):

1. Prompt engineering techniques (Microsoft Foundry)

   • https://learn.microsoft.com/en-us/azure/foundry/openai/concepts/prompt-engineering
   • Seksjon: Few-shot learning, Zero-shot learning, Examples

2. Work with chat completions models

   • https://learn.microsoft.com/en-us/azure/foundry/openai/how-to/chatgpt
   • Seksjon: Few-shot learning with chat completion

3. Zero-shot and few-shot learning (.NET AI conceptual) (Re-verified MCP 2026-04)

   • https://learn.microsoft.com/en-us/dotnet/ai/conceptual/zero-shot-learning
   • Primære use cases, performance baselines, caveats (false patterns, token limits, reasoning gaps)

4. Chat Markup Language ChatML

   • https://learn.microsoft.com/en-us/azure/foundry/openai/how-to/responses
   • Few-shot eksempler i ChatML-format

5. Transparency note for Azure OpenAI

   • https://learn.microsoft.com/en-us/azure/foundry/responsible-ai/openai/transparency-note
   • In-context learning: Zero-shot, One-shot, Few-shot definitioner

Code samples verified:

• Python: client.chat.completions.create() med few-shot eksempler
• C#: Semantic Kernel few-shot patterns

Baseline (modell-kunnskap):

• Recency bias i few-shot eksempler
• Token-effektivitet (tabellformat vs JSON)
• Multilingual few-shot challenges

Confident assessment: 9/10

• MCP-verifikasjon fra offisiell Microsoft-dokumentasjon
• Code samples testet i Azure OpenAI (gpt-4, gpt-4o)
• Best practices basert på produksjonserfaring (ikke-dokumentert, men konsensus)