# 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):**
```python
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:**
```python
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:**
```python
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:**
```python
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:**
```python
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:**
```yaml
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:**
```csharp
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:**
```python
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 (Cosmo)

### 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)