ms-ai-architect/skills/ms-ai-engineering/references/multi-modal/whisper-speech-recognition.md

# Whisper ASR and Advanced Speech Recognition

**Last updated:** 2026-02
**Status:** GA
**Category:** Multi-Modal AI
**Type:** reference

---

## Innhold

- [Introduksjon](#introduksjon)
- [Kjernekomponentar](#kjernekomponentar)
- [Whisper Model Selection](#whisper-model-selection)
- [Fleirspråkleg og norsk støtte](#fleirspråkleg-og-norsk-støtte)
- [Speaker Diarization og Identification](#speaker-diarization-og-identification)
- [Custom Vocabularies og Fine-Tuning](#custom-vocabularies-og-fine-tuning)
- [Batch Transcription for store filer](#batch-transcription-for-store-filer)
- [Implementeringsmønstre](#implementeringsmønstre)
- [Norsk offentleg sektor](#norsk-offentleg-sektor)
- [Beslutningsrammeverk](#beslutningsrammeverk)
- [For arkitekten](#for-arkitekten)

## Introduksjon

OpenAI Whisper er ein generell talegjenkjenningsmodell (Automatic Speech Recognition, ASR) som utmerkar seg på fleirspråkleg talegjenkjenning, taleoversetting og språkidentifisering. Modellen er trena på eit massivt datasett med variert audio, noko som gir robust handtering av ulike språk, aksentar og talevariantar. Whisper er tilgjengeleg både gjennom Azure OpenAI Service og som ein del av Azure AI Speech Service.

For norsk offentleg sektor er Whisper særleg interessant fordi modellen har god støtte for norsk (bokmål), og kan transkribere tale med høg nøyaktigheit sjølv i utfordrande lydforhold. Azure AI Speech Service tilbyr i tillegg Custom Speech-funksjonalitet for å finjustere modellen til spesifikke domene — som juridisk, medisinsk eller forvaltingsspråk — og Azure OpenAI sin Whisper-implementering gir enkel API-tilgang med integrert sikkerheit.

Valet mellom Azure OpenAI Whisper og Azure AI Speech avheng av bruksscenarioet: Azure OpenAI Whisper for enkel filbasert transkripsjon med fleirspråkleg støtte, og Azure AI Speech for sanntidstranskripsjon, custom models, batch-prosessering av store filer og talarergjenkjenning.

---

## Kjernekomponentar

| Komponent | Formål | Teknologi |
|-----------|--------|-----------|
| **Azure OpenAI Whisper** | Filbasert tale-til-tekst | Azure OpenAI API |
| **Azure AI Speech STT** | Sanntids tale-til-tekst | Azure AI Speech Service |
| **Whisper Batch API** | Transkripsjon av store filer (>25MB) | Azure AI Speech Batch |
| **Custom Speech** | Finjustering for spesifikke domene | Azure AI Speech Custom |
| **Speaker Diarization** | Talar-identifisering | Azure AI Speech |
| **Pronunciation Assessment** | Uttale-evaluering | Azure AI Speech |

---

## Whisper Model Selection

### Modellversjonar

| Modell | Parametrar | Relative VRAM | Relativ hastighet | Kvalitet |
|--------|-----------|---------------|-------------------|----------|
| `whisper-tiny` | 39M | ~1 GB | 32x | Låg |
| `whisper-base` | 74M | ~1 GB | 16x | Basis |
| `whisper-small` | 244M | ~2 GB | 6x | God |
| `whisper-medium` | 769M | ~5 GB | 2x | Høg |
| `whisper-large-v3` | 1550M | ~10 GB | 1x | Best |

### Azure OpenAI Whisper Deployment

Azure OpenAI tilbyr Whisper som ein managed service — ingen modellval nødvendig, berre deploy og bruk:

```python
from openai import AzureOpenAI

client = AzureOpenAI(
    azure_endpoint="https://<resource>.openai.azure.com/",
    api_key="<api-key>",
    api_version="2024-06-01"
)

# Transkriber ein lydfil
with open("møteopptak.wav", "rb") as audio_file:
    transcript = client.audio.transcriptions.create(
        model="whisper",  # Azure OpenAI deployment name
        file=audio_file,
        language="no",     # Norsk
        response_format="verbose_json",
        timestamp_granularities=["word", "segment"]
    )

print(f"Tekst: {transcript.text}")

# Segmentnivå tidsstempel
for segment in transcript.segments:
    print(f"  [{segment.start:.1f}s - {segment.end:.1f}s]: {segment.text}")

# Ordnivå tidsstempel
for word in transcript.words:
    print(f"  [{word.start:.2f}s]: {word.word}")
```

### C#-implementering

```csharp
using Azure;
using Azure.AI.OpenAI;

var client = new AzureOpenAIClient(
    new Uri("https://<resource>.openai.azure.com/"),
    new AzureKeyCredential("<api-key>")
);

var audioClient = client.GetAudioClient("whisper");

// Transkriber med tidsstempel
AudioTranscriptionOptions options = new()
{
    Language = "no",
    ResponseFormat = AudioTranscriptionFormat.Verbose,
    TimestampGranularities = AudioTimestampGranularities.Word
        | AudioTimestampGranularities.Segment
};

using FileStream audio = File.OpenRead("møteopptak.wav");
AudioTranscription result = await audioClient.TranscribeAudioAsync(audio, options);

Console.WriteLine($"Tekst: {result.Text}");

foreach (var segment in result.Segments)
{
    Console.WriteLine($"  [{segment.StartTime} - {segment.EndTime}]: {segment.Text}");
}
```

### Val mellom Azure OpenAI Whisper og Azure AI Speech

| Eigenskap | Azure OpenAI Whisper | Azure AI Speech |
|-----------|---------------------|-----------------|
| **Deployment** | Managed (global/standard) | Regional |
| **Filstorleik** | Max 25 MB | Ubegrensa (batch) |
| **Sanntid** | Nei | Ja |
| **Custom models** | Nei | Ja (Custom Speech) |
| **Speaker diarization** | Nei | Ja |
| **Batch API** | Via Speech Service | Ja, native |
| **Støtta format** | mp3, mp4, wav, etc. | wav, mp3, ogg, etc. |
| **Norsk kvalitet** | God | God (betre med custom) |
| **Kostnad** | Per token | Per audio-minutt |

---

## Fleirspråkleg og norsk støtte

### Språkstøtte

Whisper støttar transkribering i 100+ språk. For norsk er det viktig å spesifisere riktig språkkode:

```python
# Norsk bokmål
transcript_no = client.audio.transcriptions.create(
    model="whisper",
    file=audio_file,
    language="no"      # Norsk (generelt)
)

# Automatisk språkdeteksjon
transcript_auto = client.audio.transcriptions.create(
    model="whisper",
    file=audio_file
    # Utelat language for automatisk deteksjon
)
```

### Azure AI Speech for norsk

Azure AI Speech gir meir kontroll over norsk tale-til-tekst:

```python
import azure.cognitiveservices.speech as speechsdk

speech_config = speechsdk.SpeechConfig(
    subscription="<speech-key>",
    region="norwayeast"
)

# Norsk bokmål
speech_config.speech_recognition_language = "nb-NO"

# Kontinuerleg gjenkjenning
audio_config = speechsdk.AudioConfig(filename="møte.wav")
recognizer = speechsdk.SpeechRecognizer(
    speech_config=speech_config,
    audio_config=audio_config
)

results = []

def recognized_cb(evt):
    if evt.result.reason == speechsdk.ResultReason.RecognizedSpeech:
        results.append({
            "text": evt.result.text,
            "offset": evt.result.offset,
            "duration": evt.result.duration,
            "confidence": evt.result.best()  # Confidence scores
        })

recognizer.recognized.connect(recognized_cb)
recognizer.start_continuous_recognition()
```

### Taleoversetting

Whisper kan oversette frå andre språk til engelsk:

```python
# Oversett frå norsk til engelsk
translation = client.audio.translations.create(
    model="whisper",
    file=audio_file
)

print(f"Engelsk oversetting: {translation.text}")
```

---

## Speaker Diarization og Identification

### Azure AI Speech Diarization

Speaker diarization identifiserer kven som snakkar når i ein lydopptaking:

```python
import azure.cognitiveservices.speech as speechsdk

speech_config = speechsdk.SpeechConfig(
    subscription="<speech-key>",
    region="norwayeast"
)
speech_config.speech_recognition_language = "nb-NO"

# Aktiver diarisering
speech_config.set_property(
    speechsdk.PropertyId.SpeechServiceResponse_DiarizeIntermediateResults,
    "true"
)

audio_config = speechsdk.AudioConfig(filename="møte.wav")

# Bruk ConversationTranscriber for multi-talar gjenkjenning
transcriber = speechsdk.transcription.ConversationTranscriber(
    speech_config=speech_config,
    audio_config=audio_config
)

diarized_results = []

def transcribed_cb(evt):
    if evt.result.reason == speechsdk.ResultReason.RecognizedSpeech:
        diarized_results.append({
            "speaker_id": evt.result.speaker_id,
            "text": evt.result.text,
            "offset": evt.result.offset,
            "duration": evt.result.duration
        })
        print(f"Talar {evt.result.speaker_id}: {evt.result.text}")

transcriber.transcribed.connect(transcribed_cb)
transcriber.start_transcribing_async()
```

### Speaker Identification

For å identifisere kjende talarar (ikkje berre skilje mellom ukjende):

```python
# Steg 1: Registrer taleprofil
voice_profile_client = speechsdk.VoiceProfileClient(
    speech_config=speech_config
)

# Opprett profil for kvar kjend talar
profile = voice_profile_client.create_profile_async(
    speechsdk.VoiceProfileType.TextIndependentIdentification,
    "nb-NO"
).get()

# Tren profilen med taleprøve
audio_config = speechsdk.AudioConfig(filename="talar1_prøve.wav")
voice_profile_client.enroll_profile_async(profile, audio_config).get()

# Steg 2: Identifiser talar i ny opptak
speaker_recognizer = speechsdk.SpeakerRecognizer(
    speech_config=speech_config,
    audio_config=speechsdk.AudioConfig(filename="ukjent_tale.wav")
)

model = speechsdk.SpeakerIdentificationModel(profiles=[profile1, profile2, profile3])
result = speaker_recognizer.recognize_once_async(model).get()
print(f"Identifisert som: {result.profile_id}, Confidence: {result.score}")
```

---

## Custom Vocabularies og Fine-Tuning

### Custom Speech (Azure AI Speech)

For å forbetre gjenkjenning av domene-spesifikke termar:

```python
# Custom Speech trening via REST API
import requests

def create_custom_speech_model(subscription_key, region, training_data_url):
    """Opprett ein custom speech model for norsk forvaltingsspråk."""

    base_url = f"https://{region}.api.cognitive.microsoft.com/speechtotext/v3.2"

    # Steg 1: Last opp treningsdata
    dataset = requests.post(
        f"{base_url}/datasets",
        headers={
            "Ocp-Apim-Subscription-Key": subscription_key,
            "Content-Type": "application/json"
        },
        json={
            "kind": "Language",
            "displayName": "Norsk forvaltingsspråk",
            "description": "Custom language model for norsk offentleg sektor",
            "locale": "nb-NO",
            "contentUrl": training_data_url
        }
    )

    dataset_id = dataset.json()["self"].split("/")[-1]

    # Steg 2: Tren modell
    model = requests.post(
        f"{base_url}/models",
        headers={
            "Ocp-Apim-Subscription-Key": subscription_key,
            "Content-Type": "application/json"
        },
        json={
            "displayName": "Forvaltingsmodell-v1",
            "description": "Tilpassa for norsk forvaltingsterminologi",
            "locale": "nb-NO",
            "datasets": [{"self": f"{base_url}/datasets/{dataset_id}"}],
            "properties": {
                "wordErrorRate": True
            }
        }
    )

    return model.json()
```

### Phrase Lists for rask tilpassing

For enkel tilpassing utan full custom model:

```python
# Phrase list for å forbetre gjenkjenning av spesifikke termar
phrase_list = speechsdk.PhraseListGrammar.from_recognizer(recognizer)

# Norske forvaltingstermar
forvaltingstermar = [
    "Direktoratet for digital tjenesteutvikling", "Digitaliseringsdirektoratet",
    "forvaltingslova", "offentleglova", "personopplysningslova",
    "DPIA", "GDPR", "ROS-analyse", "Schrems II",
    "Microsoft Entra ID", "Microsoft Foundry",
    "Copilot Studio", "Power Platform"
]

for term in forvaltingstermar:
    phrase_list.addPhrase(term)
```

### Display Form for tekniske termar

```python
# Custom display forms for akronym og tekniske termar
speech_config.set_property_by_name(
    "DictationServiceCustomDisplayText",
    json.dumps({
        "displayForms": [
            {"spoken": "GDPR", "display": "GDPR"},
            {"spoken": "A I", "display": "AI"},
            {"spoken": "N A V", "display": "NAV"},
            {"spoken": "I K T", "display": "IKT"},
            {"spoken": "R O S", "display": "ROS"}
        ]
    })
)
```

---

## Batch Transcription for store filer

For filer over 25 MB eller for stor-skala prosessering:

```python
import requests

def batch_transcribe(subscription_key, region, audio_urls):
    """Batch-transkribering av store lydfiler."""

    base_url = f"https://{region}.api.cognitive.microsoft.com/speechtotext/v3.2"

    transcription = requests.post(
        f"{base_url}/transcriptions",
        headers={
            "Ocp-Apim-Subscription-Key": subscription_key,
            "Content-Type": "application/json"
        },
        json={
            "displayName": "Batch-transkripsjon møteopptak",
            "locale": "nb-NO",
            "contentUrls": audio_urls,
            "properties": {
                "diarizationEnabled": True,
                "wordLevelTimestampsEnabled": True,
                "punctuationMode": "DictatedAndAutomatic",
                "profanityFilterMode": "Masked",
                "timeToLive": "PT12H"
            },
            "model": {
                "self": f"{base_url}/models/base/nb-NO"
                # Eller bruk custom model:
                # "self": f"{base_url}/models/<custom-model-id>"
            }
        }
    )

    transcription_id = transcription.json()["self"].split("/")[-1]
    return transcription_id
```

---

## Implementeringsmønstre

### Mønster 1: Hybrid Whisper + Azure Speech

```
Audio Input
   |
   ├── < 25 MB → Azure OpenAI Whisper (enkel, rask)
   |
   └── > 25 MB → Azure AI Speech Batch API (skalerbar)
                     |
                     ├── Custom Speech model (domene-tilpassa)
                     ├── Speaker diarization
                     └── Ordnivå tidsstempel
```

### Mønster 2: Real-time + Post-processing

```
Live tale → Azure AI Speech (sanntid) → Rå transkripsjon
                                             |
                                             v
Post-processing med GPT-4o → Oppsummering, nøkkelord, handlingspostar
```

### Mønster 3: Edge + Cloud Cascade

```
Edge (Whisper-small) → Rask lokal transkripsjon → Filtrering
                                                       |
                                                       v
Cloud (Azure Speech Custom) → Presis transkripsjon med domene-modell
```

---

## Norsk offentleg sektor

### Bruksscenario

- **NAV**: Transkripsjon av telefonsamtalar for kvalitetssikring og opplæring
- **Domstolane**: Automatisk protokollføring av rettsmøte
- **Stortinget**: Sanntids underteksting av debattar og høyringar
- **Kommunar**: Transkripsjon av bystyremøte med talar-identifisering

### Regulatoriske omsyn

| Krav | Tiltak |
|------|--------|
| **GDPR** | Lydfiler med personopplysningar må behandlast med heimel |
| **Samtykke** | Informer om opptak og transkripsjon |
| **Lagring** | Timeboxed lagring med `timeToLive` parameter |
| **Nøyaktigheit** | Custom Speech for forvaltingsterminologi |
| **Innhaldsfiltrering** | Azure OpenAI Whisper har IKKJE innhaldsfiltrering |

### Viktig: Ingen innhaldsfiltrering for audio

Azure OpenAI sitt innhaldsfiltreringssystem gjeld **ikkje** for Whisper-modellen. Organisasjonen må implementere eigne mekanismar for å filtrere uønskt innhald frå transkripsjonsresultat.

---

## Beslutningsrammeverk

| Scenario | Anbefaling | Begrunnelse |
|----------|------------|-------------|
| Enkel filbasert transkripsjon | Azure OpenAI Whisper | Enkel API, god kvalitet |
| Sanntidstranskripsjon | Azure AI Speech STT | Streaming-støtte |
| Store filer (>25 MB) | Azure AI Speech Batch | Ingen filstorleikgrense |
| Domene-spesifikk terminologi | Custom Speech + Phrase lists | Betre nøyaktigheit |
| Talar-identifisering | Azure AI Speech Diarization | Native støtte |
| Fleirspråkleg innhald | Azure OpenAI Whisper | 100+ språk automatisk |
| Edge/offline bruk | Whisper-small lokalt | Ingen nettverkskrav |
| Norsk forvaltingsspråk | Custom Speech nb-NO + phrase lists | Tilpassa vokabular |

---

## For arkitekten

- **Azure OpenAI Whisper** er enklast for filbasert transkripsjon under 25 MB — bruk `language: "no"` for norsk og `response_format: "verbose_json"` for tidsstempel på ord- og segmentnivå
- **Azure AI Speech er meir kraftig** for produksjonsscenario — sanntidstranskripsjon, speaker diarization, batch-prosessering av store filer, og Custom Speech for domene-tilpassing
- **Custom Speech med Phrase Lists** er den raskaste vegen til betre norsk nøyaktigheit — legg til forvaltingstermar, stadnamn og akronym utan å trene ein full custom model
- **Speaker diarization via ConversationTranscriber** identifiserer talarar automatisk — kritisk for møtetranskribering i offentleg sektor (bystyremøte, rettsmøte, høyringar)
- **Innhaldsfiltrering gjeld IKKJE for Whisper** — organisasjonen må implementere eigne filter for transkripsjonsresultat, spesielt for sensitive bruksområde som helse og rettsvesen