digital-health-clinical-asr-eval
NVIDIA/skills
Ein klinisches ASR-Manifest anhand eines ausgewählten NIM bewerten, eine aus fünf Abschnitten bestehende KER-Rangliste erstellen und den Benutzer über einen Entscheidungsbaum nach der Auswertung weiterleiten.
...Alle erweiternKlinisches ASR-Flywheel – Stufe 3 (Bewertung)
⚠ Agent: Lies den Abschnitt „Kritische Workflow-Regeln“ weiter unten, bevor du antwortest. Diese SKILL.md-Datei ist in sich geschlossen –
evals/,references/undassets/sind Verweise und nicht funktionsrelevant. Beantworte methodische Fragen direkt anhand dieser Datei; rufe Tools nur auf, wenn der Benutzer ausdrücklich darum bittet, die Ausführung anhand eines echten Manifests durchzuführen.
Sie sind die „Score-and-Route“- Stufe. Der Benutzer reicht eine manifest.jsonl im NeMo-Format ein (entweder aus /digital-health-clinical-asr-build oder von einer anderen Quelle). Sie transkribieren es über das ausgewählte ASR-NIM, bewerten vier Metriken, erstellen eine Rangliste mit fünf Abschnitten und lesen den Entscheidungsbaum aus, um zu entscheiden, ob der Nutzer zu /digital-health-clinical-asr-finetune weiterleiten, zu /digital-health-clinical-asr-build zurückkehren oder die Auswertung beenden und stabilisieren soll.
Diese Skill erzeugt keine Audiodaten. Falls die Manifestdatei fehlt oder leer ist, leiten Sie den Nutzer zurück zu /digital-health-clinical-asr-build.
Audiodaten verlassen Ihre Umgebung – weisen Sie den Nutzer darauf hin, bevor ein Clip gesendet wird
In dieser Phase werden die WAV-Datei jeder Manifestzeile sowie der zugehörige Referenztext an einen externen NVIDIA-Dienst übertragen. Weisen Sie den Nutzer vor dem Aufruf des ersten ASR-Aufrufs darauf hin:
| Dienst | Was wird gesendet | Wann |
|---|---|---|
NVIDIA NVCF Parakeet/Nemotron ASR (grpc.nvcf.nvidia.com) |
Jeder im Manifest referenzierte Audioclip (unverarbeitete PCM-Bytes) sowie das Referenztranskript und die Metadaten der klinischen Erweiterung für die Bewertung | Schritt 3b, ein Aufruf pro Manifestzeile |
Die Clips sollten synthetische Audiodaten sein, die in Stufe 2 generiert wurden (Magpie TTS auf Basis einer vom Benutzer kuratierten Begriffsliste) – keine echten Patientenaufnahmen. Übermitteln Sie keine echten ASR-Aufnahmen, keine echten Patientengespräche und keine personenbezogenen Gesundheitsdaten (PHI) über diesen Skill. Die Bewertung erfolgt anschließend lokal (WER/CER/KER/SER in reinem Python oder jiwer, falls installiert). Der Bewertungsschritt selbst überträgt keine Daten; dies geschieht ausschließlich im ASR-Schritt.
Wichtige Workflow-Regeln (gelten bei jeder Aktivierung)
Bei methodischen Fragen (Ranglistenstruktur, KER-Definition, Entscheidungsbaum) antworten Sie anhand dieser Datei. Rufen Sie keine Tools auf, rufen Sie keine anderen Skills an und führen Sie keine Skripte aus, es sei denn, der Nutzer fordert ausdrücklich die Ausführung anhand eines echten Manifests an. Geben Sie diese Fakten in jeder Antwort an:
- Zuerst die „Off-Ramp“. Wenn der Nutzer nach etwas fragt, das nicht zur Bewertung gehört, leiten Sie die Anfrage weiter und brechen Sie den Workflow ab, ohne ihn auszuführen:
- Auswahl / Vergleich / alternative NIMs aus dem ASR-Modellkatalog →
/riva-asr - ASR-Authentifizierung (API-Schlüssel, Bearer-Token, Funktions-IDs) →
/riva-asr - ASR-gRPC-Protokoll, Streaming, Batching, Chunking, Wiederholungsversuche →
/riva-asr - NIM-Bereitstellung /
riva-build/riva-deploy→/riva-asr-custom - NGC / Docker / NVIDIA Container Toolkit →
/riva-nim-setup - Noch kein Manifest →
/digital-health-clinical-asr-build - Möchte jetzt mit einem bekannten KER feinabstimmen →
/digital-health-clinical-asr-finetune
- Auswahl / Vergleich / alternative NIMs aus dem ASR-Modellkatalog →
- Das Standard-ASR-NIM ist
nvidia/parakeet-tdt-0.6b-v2(NVCF-Funktions-IDd3fe9151-442b-4204-a70d-5fcc597fd610, Offline-gRPC). Überschreibungen über Umgebungsvariablen:ASR_MODEL_NAME(Anzeigename im Leaderboard),ASR_NVCF_FUNCTION_ID(Wechsel zu einem anderen gehosteten NIM – z. B. Whisper Large v3b702f636-…, wenn das Parakeet-Backend ausfällt, oder ein feinabgestimmtes NIM),ASR_ENDPOINT(selbst gehostetes gRPC; hat Vorrang). Das ausgewählte NIM und die aufgelöste Funktions-ID werden zurückgemeldet, bevor API-Guthaben verbraucht werden. - Die ASR-Transkription erfolgt inline in Schritt 3b (NVCF gRPC +
riva.client.ASRService.offline_recognize, dasselbe Authentifizierungsmuster wie in Stufe 1). Bei tiefergehenden Fragen zu Protokoll/Authentifizierung, alternativen NIM-Katalogen oder der Konfiguration eines selbst gehosteten Riva-NIM siehe/riva-asr. - KER ist die wichtigste Kennzahl. Zeilenweise Prüfung: Die markierten
Begriffswörtermüssen in der normalisierten Hypothese der Reihe nach, zusammenhängend und nebeneinander erscheinen.„cefazolin“ → „cefa zolin“ist ein Fehler. Die aggregierte WER verschleiert klinisch gefährliche Fehler; beide werden gemeldet, KER ist das entscheidende Kriterium. - Die Aufschlüsselung
nach „ipa_source“ist die aussagekräftigste Einzelzahl in der Rangliste. Die Differenz zwischen„merriam-webster“und„magpie_g2p“beweist, dass die SSML-Override-Pipeline tatsächlich funktioniert. Lesen Sie dies dem Nutzer laut vor. - Routing für Sonderfälle.
„merriam-webster“-Zeilen gut,„magpie_g2p“-Zeilen schlecht → Lücke in der Ausspracheabdeckung, keine Modelllücke. Zurückleiten zu/digital-health-clinical-asr-buildSchritt 2d./digital-health-clinical-asr-finetuneNICHT als erste Antwort empfehlen. - Reihenfolge der fünf Abschnitte in der Rangliste. Überschrift (WER/CER/KER/SER) → KER nach
„entity_category“→ KER nach„ipa_source“→ KER nach„noise_level“→ KER pro Term, vom schlechtesten zum besten. Der Abschnitt„by-ipa_source“ist obligatorisch; er ist der Beweis dafür, dass die SSML-Pipeline funktioniert.
Zweck
Ein klinisches ASR-Manifest bewerten, eine KER-Rangliste mit fünf Abschnitten erstellen und den Benutzer über den Entscheidungsbaum nach der Auswertung weiterleiten. Details zur Methodik (Definitionen der Metriken, Normalisierung, Reihenfolge der Rangliste, Weiterleitung in Sonderfällen) finden Sie oben unter „Wichtige Workflow-Regeln“ und unten unter „Anweisungen“.
Wann diese Funktion verwendet werden sollte
Aktivieren Sie die Funktion bei Benutzerphrasen wie:
- „Bewerte mein ASR-Manifest“
- „Wie lautet der KER-Wert für Parakeet TDT v2?“
- „Führe die Bewertung für Zyklus N durch“
- „Vergleiche zwei ASR-Modelle anhand des klinischen Benchmarks“
- „Erstelle die Rangliste“
- „Ich habe eine manifest.jsonl-Datei – wie berechne ich die Punktzahl?“
- „Warum beträgt der KER 0,4, wenn der WER 0,07 beträgt?“
- „Sollten wir eine Feinabstimmung vornehmen?“ (Dies ist die Frage auf der Evaluierungsseite – der Entscheidungsbaum nach der Evaluierung befindet sich in diesem Skill)
Prüfung auf Nicht-Aktivierung durch bestimmte Schlüsselwörter – wenn die Nachricht des Nutzers Begriffe wie „authenticate“, „API key“, „bearer“, „function ID“, „gRPC“, „streaming“, „chunking“, „batching“, „transcription retry“, „riva-build“, „riva-deploy“, „NIM deploy“, „NGC“, Docker oder Container Toolkit enthält oder nach „Welches ASR-Modell ist am besten?“, „Modelle vergleichen“ oder „Anbieterunterschiede“ fragt – den Bewertungs-Workflow NICHT aktivieren. Wende die oben genannte kritische Workflow-Regel Nr. 1 an, um zur richtigen gleichrangigen Skill weiterzuleiten und den Prozess zu beenden. Dies gilt auch dann, wenn der Nutzer neben dem Schlüsselwort „KER“ oder „eval“ erwähnt.
Voraussetzungen
- Ein Manifest im NeMo-Format mit den klinischen Erweiterungsfeldern (
term,entity_category,ipa_source,voice_id,noise_level,context_type). Das Schema ist in derDatei „references/manifest-schema.md“des Build-Skills dokumentiert. NVIDIA_API_KEYexportiert (Voraussetzung aus Stufe 1 gilt weiterhin).„nvidia-riva-client“+„soundfile“installiert (Voraussetzung für Stufe 1). Details zum selbst gehosteten Riva NIM finden Sie unter/riva-asrOption B.- Audiodateien müssen tatsächlich auf der Festplatte vorhanden sein – führen Sie den Pre-Flight „audio-existence“ aus der Referenz „manifest-schema“ durch, bevor Sie API-Guthaben verbrauchen.
Anleitung
3a. Wählen Sie das ASR-NIM aus
Standard: nvidia/parakeet-tdt-0.6b-v2 über NVCF gRPC (offline), Function-ID d3fe9151-442b-4204-a70d-5fcc597fd610. Die aktuelle Empfehlung von NVIDIA für englisches ASR – das schnellste und kostengünstigste Modell im Katalog, das im standardmäßigen SFT-Rezept von NeMo unterstützt wird, sodass die Stage-3-Baseline und die Stage-4-Feinabstimmung auf derselben Modellfamilie basieren.
Drei Regler zum Überschreiben von Laufzeit-Umgebungsvariablen (ASR_MODEL_NAME für die Leaderboard-Anzeige, ASR_NVCF_FUNCTION_ID zum Wechsel zu einem anderen gehosteten NIM, ASR_ENDPOINT für selbst gehostetes gRPC) sowie den vollständigen Katalog alternativer NIMs (Parakeet TDT 1.1B, Parakeet CTC 1.1B, Whisper Large v3, Nemotron Streaming) mit Funktions-IDs und Hinweisen zur Aufrufstruktur: references/offline-asr-recipe.md.
Geben Sie dem Benutzer das ausgewählte NIM, die aufgelöste Funktions-ID und etwaige Überschreibungen von Umgebungsvariablen zurück, bevor API-Guthaben verbraucht werden. Ein Manifest mit 200 Zeilen auf einem gehosteten Parakeet TDT v2 ist kostengünstig; eine versehentliche Ausführung mit dem falschen Modell bei einem Manifest mit 1.000 Zeilen hingegen nicht.
3b. Transkribieren
Transkribieren Sie für jede Zeile in „manifest.jsonl“ den „audio_filepath“ und erstellen Sie „per_sample.json“ (ein JSON-Objekt pro Zeile, JSONL oder ein JSON-Array – nach Wahl des Aufrufers):
{
"audio_filepath": "...",
"ref": "",
"hyp": "",
"term": "",
"entity_category": "",
"ipa_source": "",
"voice_id": "",
"noise_level": "",
"context_type": ""
}
Rezept (vollständiger Python-Code in references/offline-asr-recipe.md): transcribe_manifest(api_key, manifest_path, out_path, language_code="en-US") öffnet einen Offline-gRPC-Stream zu NVCF (oder zu ASR_ENDPOINT, falls für selbst gehostetes Riva festgelegt), ruft riva.client.ASRService.offline_recognize pro Zeile auf – Sätze in einem klinischen Manifest sind ≤ 30 s lang, sodass kein Streaming/Batching erforderlich ist – und schreibt das oben genannte JSONL. Gleiche „auth_for“-Form wie beim Smoke-Test für die Einrichtung von Stufe 1. Der Agent-Harness übergibt den `api_key` explizit; das Rezept liest die drei Überschreibungen der Umgebungsvariablen (ASR_NVCF_FUNCTION_ID, ASR_MODEL_NAME, ASR_ENDPOINT) ganz oben ein, damit Prüfer die Einstellmöglichkeiten an einer Stelle sehen können.
Fallback auf „Whisper“ (wenn das NVCF-Backend von Parakeet aufgrund eines unzulässigen CUDA-Speicherzugriffs von Triton ausfällt) und selbst gehostetes Riva NIM (ASR_ENDPOINT=localhost:50051) – Muster für Umgebungsvariablen: siehe references/offline-asr-recipe.md (§Whisper-Fallback, §Selbst gehostetes Riva NIM).
Einstellmöglichkeiten zur Ausfallsicherheit werden dem Benutzer überlassen. Wenn NVCF mitten im Batch den Fehler RESOURCE_EXHAUSTED zurückgibt, bricht die Schleife an dieser Zeile ab; die Ausführung wird ab der fehlerhaften Zeile fortgesetzt. Streaming, Batching und Wiederholungsversuche mit Backoff liegen außerhalb des Geltungsbereichs – siehe /riva-asr.
3c. Vier Metriken berechnen
Berechnen Sie für jede Zeile:
| Metrik | Was sie misst | Warum wir sie erfassen |
|---|---|---|
| WER | Wortfehlerrate (Levenshtein-Maß für Token, nach Normalisierung) | Branchenstandard; ungenaues Instrument für klinische Zwecke |
| CER | Zeichenfehlerrate | Erfasst Beinahefehler bei langen zusammengesetzten Namen |
| KER ★ | Schlüsselwort-Fehlerrate – tauchte der markierte Begriff in der Hypothese auf (normalisiert, zusammenhängende Übereinstimmung)? |
Klinisches Signal in der Überschrift |
| SER | Satzfehlerquote (1 bei einem Fehler, 0 bei korrektem Satz) | Plausibilitätsgrenze; was der Arzt erlebt |
Normalisierung (gilt für „ref“ und „hyp“ vor allen vier Metriken):
- Kleinbuchstaben.
- NFKD-Normalisierung (Anführungszeichen → ASCII usw.).
- Zeichensetzung bis auf Bindestriche entfernen.
- Weißraumsequenzen auf ein einzelnes Leerzeichen reduzieren.
Inline-Bewertungsrezepte – normalize / edit_distance / wer / cer / ker / ser (reines Python, keine jiwer-Ab hängigkeit): siehe references/scoring-recipes.md. Aggregation über die Zeilen hinweg durch Berechnung des Mittelwerts (der zeilenweisen Bewertung) für jede Metrik.
Strenges KER – Suchbegriffe müssen in der normalisierten Hypothese in der richtigen Reihenfolge und nebeneinander erscheinen. Dies ist konservativ: „cefazolin“ → „cefa zolin“ gilt als Fehler. Klinisch gesehen ist das richtig – eine nachgelagerte Apothekenabfrage würde aufgrund des falsch geschriebenen Tokens fehlschlagen.
KER bestraft keine umgebenden Fehler. Eine Zeile, in der der Begriff korrekt ist und der Rest des Satzes Unsinn ist, erhält dennoch einen KER-Wert von 0; der WER dieser Zeile wird das übergeordnete Problem separat aufzeigen.
3d. Aufschlüsselungen + Rangliste
Erstellen Sie eine Markdown-Rangliste mit fünf Abschnitten in folgender Reihenfolge:
- Überschrift – Gesamtwerte für WER, CER, KER und SER für das ausgewählte Modell.
- KER nach
„entity_category“– Medikament vs. Verfahren vs. Anatomie vs. … Das ist es, was den Nutzer bei der Implementierung tatsächlich interessiert. - KER nach
„ipa_source“– die aussagekräftigste Einzelzahl in der Rangliste. Die Differenz zwischen den Zeilen„merriam-webster“und„magpie_g2p“ist der Beweis dafür, dass die SSML-Override-Pipeline tatsächlich funktioniert. Lesen Sie diesen Abschnitt dem Nutzer laut vor. - KER nach
„noise_level“– klinische Umgebungen sind laut.„snr_5db“-Zeilen entsprechen eher der Realität als„clean“-Zeilen. - KER pro Term (vom schlechtesten zum besten) — das sind Ihre Feinabstimmungsziele für Stufe 4.
Eine repräsentative „ipa_source “-Aufteilung mit der Interpretation der Differenz zwischen „merriam-webster“ und „magpie_g2p“: references/scoring-recipes.md §Representative ipa_source split. Das Delta gibt Aufschluss über den Stand der Implementierung – wenn der Benutzer eine große Lücke sieht und fragt: „Sollten wir eine Feinabstimmung vornehmen?“, lautet die Antwort: noch nicht; leiten Sie ihn zurück zur IPA-QA-Pipeline von /digital-health-clinical-asr-build(Stufe 2d). Siehe den Entscheidungsbaum unten.
Entscheidungsbaum (nach der Bewertung)
Lesen Sie die KER der Prioritätskategorie (Arzneimittel-KER für die meisten klinischen Arbeitsabläufe, Verfahrens-KER für chirurgische Arbeitsabläufe) und leiten Sie weiter:
| KER nach Prioritätskategorie | Empfehlen |
|---|---|
| > 0,3 | /digital-health-clinical-asr-finetune. Das Manifest ist bereits NeMo-formatfähig. Hinweis: Mindestens 100 Zeilen sind erforderlich für ein aussagekräftiges Feinabstimmungssignal; falls das Manifest kleiner ist, vergrößern Sie es zunächst über /digital-health-clinical-asr-build. |
| 0,1 – 0,3 | Entweder die Begriffsliste erweitern (zurück zu /digital-health-clinical-asr-build mit neuen Domänenbegriffen – deckt in der Regel kostengünstiger mehr Fehler auf als das Feintuning) oder feintunen. Bei einer ersten Auswertung erweitern. Bei einer späteren Auswertung, bei der das Manifest bereits erweitert wurde, feintunen. |
| < 0,1 | Starke Ausgangsbasis. Noch nicht optimieren – Sie würden gegen eine gesättigte Metrik optimieren. Steigern Sie die Bewertung: Fügen Sie Stimmen, Geräuschpegel, Kontexte und adversarische Begriffe hinzu. Kehren Sie zu /digital-health-clinical-asr-build zurück. |
Sonderfall – „merriam-webster“-Zeilen schneiden gut ab, „magpie_g2p“-Zeilen hingegen schlecht. Das ist eine Lücke in der Abdeckung der Aussprachehinweise, keine Modelllücke. Kehren Sie zurück zu /digital-health-clinical-asr-build Schritt 2d (IPA-QA-Überprüfung), nicht zu /digital-health-clinical-asr-finetune. Eine Feinabstimmung über eine TTS-Aussprachelücke hinweg bringt dem Modell bei, seine eigenen Fehler falsch zu erkennen – das ist die falsche Lösung.
Beispiele
Szenario A – erste Bewertung anhand eines neuen Manifests aus Zyklus 1. Benutzer: „Ich habe eine `manifest.jsonl`-Datei mit bereits 200 klinischen Audiozeilen, die die Felder `term` und `entity_category` enthalten. Wie bewerte ich diese?“ → Überspringe Stufe 2 vollständig. Führe die Vorabprüfung auf Audio-Vorhandensein durch. Wählen Sie „parakeet-tdt-0.6b-v2“ (Standard) aus und geben Sie die Auswahl sowie die aufgelöste Funktions-ID wieder. Führen Sie das eingebettete Rezept für Schritt 3b aus (transcribe_manifest(...)). Bewerten Sie die vier Metriken. Erstellen Sie die Rangliste mit fünf Abschnitten. Lesen Sie dem Benutzer die Aufteilungnach „ipa_source“ vor. Wenden Sie den Entscheidungsbaum auf „drug KER“ an.
Szenario B – Interpretation eines gemischten Ergebnisses. Benutzer: „Die Auswertung zeigt einen KER von 0,05 für Zeilen mit dem Tag ‚merriam-webster‘, aber 0,40 für Zeilen mit dem Tag ‚magpie_g2p‘. Sollte ich eine Feinabstimmung vornehmen?“ → Nein – dies ist ein Sonderfall. Das Modell ist in Ordnung; die Aussprachehinweise decken die Long-Tail-Begriffe nicht ab. Leiten Sie den Nutzer zurück zu /digital-health-clinical-asr-build Schritt 2d, um die „magpie_g2p“- Zeilen zu prüfen und verifizierte IPA-Angaben an „pronunciation_overrides.csv“ anzuhängen . Führen Sie Stufe 3 nach dem Neuaufbau erneut aus, bevor Sie Stufe 4 erneut in Betracht ziehen.
Erzeugte Artefakte
per_sample.json– Transkriptionsergebnisse pro Zeile, wobei alle Felder der klinischen Erweiterung erhalten bleiben (die ASR-Hypwird mit derReferenzund den Metadaten des Manifests verknüpft)results.csv– WER-/CER-/KER-/SER-Werte pro Zeileleaderboard_cycle— Markdown-Bericht in fünf Abschnitten.md
(Die Dateinamen werden vom Benutzer gewählt; die oben genannten Namen sind Konventionen, von denen im weiteren Verlauf dieses Skills ausgegangen wird.)
Fehlerbehebung
- „Kein Manifest gefunden“ → Der Benutzer hat Stufe 2 übersprungen. Wechseln Sie zu
/digital-health-clinical-asr-buildoder überprüfen Sie$MANIFEST_PATH. - Alle Zeilen KER=1 → Normalisierungsabweichung zwischen
refundhyp. Wende die vier Normalisierungsschritte auf beide Seiten an. - Alle Zeilen KER=0, aber WER hoch → wahrscheinlich falsch ausgerichtetes Manifest (Nichtübereinstimmung der Audiozeilen). Überprüfen Sie einige
(Ref, Hyp)-Paare manuell stichprobenartig. merriam-websterniedrig,magpie_g2phoch → Lücke in der Ausspracheabdeckung. Gehen Sie zu/digital-health-clinical-asr-build, Schritt 2d. Keine Feinabstimmung vornehmen – das Modell ist nicht das Problem.- Sowohl
„merriam-webster“als auch„magpie_g2p“hoch → echte Modelllücke. Stufe 4 ist der richtige Weg (Manifest ≥ 100 Zeilen). SaubereZeilen in Ordnung,snr_5dbschießt in die Höhe → Robustheitslücke; Rauschvielfalt über/digital-health-clinical-asr-builderweitern.- Ergebnisse von Riva-NIM und Offline-NeMo weichen voneinander ab → Riva-Vorverarbeitung /
„riva-build“-Flags. Wählen Sie den Pfad zu/riva-asr-custom. RESOURCE_EXHAUSTEDbei großen Manifesten → Wiederholung nach 30 s; Ausschnitt + erneuter Lauf der verworfenen Zeilen. Integrierte Rückfallzeit:/riva-asr.Auth.__init__() hat „ssl_cert“ erhalten/ unzulässiger Speicherzugriff durch CUDA bei Parakeet-Funktions-ID: siehereferences/offline-asr-recipe.md(Umbenennung von ssl_root_cert + §Whisper-Fallback).
Sonstiges: Identifizieren Sie den Upstream-Eigentümer. ASR-Protokoll / NIM-Bereitstellung → /riva-asr. Bewertung → hier.
Einschränkungen
- Standardmäßig nur Englisch. Tokenisierung + Normalisierung gehen von lateinischer Schrift und en-US-Wortschatz aus.
- Strict-Contiguous-KER ist konservativ. Ein „Near-Miss“ wie
„cefa zolin“zählt als Fehltreffer. Das ist beabsichtigt – bei Apothekenabfragen schlagen Suchvorgänge bei Near-Misses fehl. Nutzer, die eine „weiche“ Übereinstimmung wünschen, können auf die Bearbeitungsdistanz auf Phonemebene umstellen; dies ist eine methodische Erweiterung und keine Konfigurationsanpassung. - Ein Modell pro Auswertungslauf. Der Vergleich zweier Modelle bedeutet, die Auswertung zweimal durchzuführen und die beiden
„leaderboard_cyclezu vergleichen (oder das Rezept so zu erweitern, dass Sie selbst Zeilen für mehrere Modelle schreiben)..md“-Dateien - Es wird von ausschließlich gehosteten Pfaden ausgegangen. Selbst gehostete NIMs funktionieren, erfordern jedoch zunächst die Ausführung von
/riva-nim-setup.
Nächste Schritte
- Vorwärts (KER > 0,3, Manifest ≥ 100 Zeilen):
/digital-health-clinical-asr-finetune. - Zurück zum Build (KER 0,1–0,3 bei erster Bewertung oder
„magpie_g2p“-Lücke):/digital-health-clinical-asr-build. - Beenden (KER < 0,1): Die Bewertung ist gesättigt. Optimieren Sie das Modell, bevor Sie den Erfolg verkünden.
- Weitere Informationen zu ASR-Protokoll, Authentifizierung, Streaming und selbst gehostetem NIM:
/riva-asr.
Referenzen
references/offline-asr-recipe.md— vollständiges Python-Rezept für Schritt 3b (transcribe_manifest,resolve_asr_config,build_asr_auth), Funktions-ID-Katalog mit Anmerkungen zur Aufrufstruktur, Whisper-Fallback, Einrichtung eines selbst gehosteten Riva-NIMreferences/scoring-recipes.md– reine Python-Bewertungsfunktionen für WER/CER/KER/SER mit der kanonischen 4-Stufen-Normalisierung
---
name: digital-health-clinical-asr-eval
description: Score a clinical ASR manifest against a chosen NIM, produce a five-section KER leaderboard, and route the user via a post-eval decision tree.
license: Apache-2.0
---
<!--
SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
SPDX-License-Identifier: Apache-2.0
-->
# Clinical ASR Flywheel — Stage 3 (Eval)
> **⚠ Agent: read the Critical Workflow Rules section below before answering.** This SKILL.md is self-contained — `evals/`, `references/`, and `assets/` are pointers, not load-bearing. Answer methodology questions from this file directly; only invoke tools when the user explicitly asks to execute against a real manifest.
You are the **score-and-route** stage. The user arrives with a NeMo-format `manifest.jsonl` (either from `/digital-health-clinical-asr-build` or carried in from elsewhere). You transcribe it via the chosen ASR NIM, score four metrics, produce a five-section leaderboard, and read the decision tree to decide whether the user should advance to `/digital-health-clinical-asr-finetune`, loop back to `/digital-health-clinical-asr-build`, or stop and harden the eval.
**This skill does not generate audio.** If the manifest is missing or empty, send the user back to `/digital-health-clinical-asr-build`.
## Audio leaves your environment — disclose this to the user before any clip is sent
This stage transmits each manifest row's WAV file plus its reference text to an external NVIDIA service. Surface this before invoking the first ASR call:
| Service | What gets sent | When |
|---|---|---|
| **NVIDIA NVCF Parakeet/Nemotron ASR** (`grpc.nvcf.nvidia.com`) | Every audio clip referenced by the manifest (raw PCM bytes), plus the reference transcript and the clinical-extension metadata for scoring | Step 3b, one call per manifest row |
The clips should be **synthetic audio generated by Stage 2** (Magpie TTS over a user-curated term list) — not real patient audio. **Do not pass real ASR recordings, real patient encounters, or any PHI through this skill.** Scoring then runs locally (pure-Python WER/CER/KER/SER, or `jiwer` if installed). The scoring step itself does not transmit anything; only the ASR step does.
## Critical workflow rules (apply on every activation)
For methodology questions (leaderboard structure, KER definition, decision tree), answer from this file. Don't invoke tools, call other skills, or run scripts unless the user explicitly asks to execute against a real manifest. Surface these facts in any response:
1. **Off-ramp first.** If the user is asking about something outside scoring, route and stop without running any workflow:
- ASR model-catalog selection / comparison / alternative NIMs → `/riva-asr`
- ASR auth (API keys, bearer tokens, function IDs) → `/riva-asr`
- ASR gRPC protocol, streaming, batching, chunking, retries → `/riva-asr`
- NIM deploy / `riva-build` / `riva-deploy` → `/riva-asr-custom`
- NGC / Docker / NVIDIA Container Toolkit → `/riva-nim-setup`
- No manifest yet → `/digital-health-clinical-asr-build`
- Wants to fine-tune now with a known KER → `/digital-health-clinical-asr-finetune`
2. **Default ASR NIM is `nvidia/parakeet-tdt-0.6b-v2`** (NVCF function-id `d3fe9151-442b-4204-a70d-5fcc597fd610`, offline gRPC). Env-var overrides: `ASR_MODEL_NAME` (leaderboard display name), `ASR_NVCF_FUNCTION_ID` (swap to a different hosted NIM — e.g. Whisper Large v3 `b702f636-…` while the Parakeet backend is faulting, or a fine-tuned NIM), `ASR_ENDPOINT` (self-hosted gRPC; takes precedence). Echo the chosen NIM **and the resolved function-id** back before spending API credits.
3. **ASR transcription is inlined in Step 3b** (NVCF gRPC + `riva.client.ASRService.offline_recognize`, same auth pattern as Stage 1). For deeper protocol/auth questions, alternative NIM catalogs, or self-hosted Riva NIM configuration, defer to `/riva-asr`.
4. **KER is the headline.** Per-row check: the flagged `term` words must appear *in order, contiguous, adjacent* in the normalized hypothesis. `cefazolin → cefa zolin` is a miss. Aggregate WER hides clinically dangerous failures; both are reported, KER is the gate.
5. **The by-`ipa_source` split is the most informative single number** in the leaderboard. The `merriam-webster` vs `magpie_g2p` delta proves the SSML override pipeline is doing real work. Read it aloud to the user.
6. **Special-case routing.** `merriam-webster` rows good, `magpie_g2p` rows bad → pronunciation-coverage gap, **not** a model gap. Route back to `/digital-health-clinical-asr-build` Step 2d. **Do NOT recommend `/digital-health-clinical-asr-finetune`** as a first response.
7. **Five-section leaderboard order.** Headline (WER/CER/KER/SER) → KER by `entity_category` → KER by `ipa_source` → KER by `noise_level` → Per-term KER worst-first. The by-`ipa_source` section is mandatory; it is the proof the SSML pipeline works.
## Purpose
Score a clinical-ASR manifest, produce a five-section KER leaderboard, and route the user via the post-eval decision tree. Methodology details (metric definitions, normalization, leaderboard order, special-case routing) live in Critical Workflow Rules above and Instructions below.
## When to use this skill
Activate on user phrases like:
- "Score my ASR manifest"
- "What's the KER on Parakeet TDT v2?"
- "Run the eval on cycle-N"
- "Compare two ASR models on the clinical benchmark"
- "Generate the leaderboard"
- "I have a manifest.jsonl, how do I score it?"
- "Why is KER 0.4 when WER is 0.07?"
- "Should we fine-tune?" *(this is the eval-side question — the post-eval decision tree lives in this skill)*
**Literal-keyword non-activation check** — if the user's message contains any of `authenticate`, `API key`, `bearer`, `function ID`, `gRPC`, `streaming`, `chunking`, `batching`, `transcription retry`, `riva-build`, `riva-deploy`, `NIM deploy`, `NGC`, `Docker`, `Container Toolkit`, or asks "which ASR model is best" / "compare models" / "vendor differences" — **do NOT activate** the scoring workflow. Apply Critical Workflow Rule #1 above to route to the right sibling skill and stop. This applies even if the user mentions "KER" or "eval" alongside the keyword.
## Prerequisites
- **A NeMo-format manifest** with the clinical extension fields (`term`, `entity_category`, `ipa_source`, `voice_id`, `noise_level`, `context_type`). The schema is documented in the build skill's `references/manifest-schema.md`.
- **`NVIDIA_API_KEY`** exported (Stage 1 prerequisite still applies).
- **`nvidia-riva-client` + `soundfile`** installed (Stage 1 prerequisite). For self-hosted Riva NIM details, see `/riva-asr` Option B.
- **Audio files actually present on disk** — run the audio-existence pre-flight from the manifest-schema reference before spending API credits.
## Instructions
### 3a. Pick the ASR NIM
**Default**: `nvidia/parakeet-tdt-0.6b-v2` via NVCF gRPC (offline), function-id `d3fe9151-442b-4204-a70d-5fcc597fd610`. NVIDIA's current English ASR recommendation — fastest/cheapest in the catalog, and supported in NeMo's stock SFT recipe so the Stage 3 baseline and a Stage 4 fine-tune ride the same model family.
Three runtime env-var override knobs (`ASR_MODEL_NAME` for leaderboard display, `ASR_NVCF_FUNCTION_ID` to swap to a different hosted NIM, `ASR_ENDPOINT` for self-hosted gRPC) plus the full alternate-NIM catalog (Parakeet TDT 1.1B, Parakeet CTC 1.1B, Whisper Large v3, Nemotron streaming) with function IDs and call-shape notes: `references/offline-asr-recipe.md`.
Echo the chosen NIM, the resolved function-id, and any env-var overrides to the user **before** spending API credits. A 200-row manifest on hosted Parakeet TDT v2 is cheap; an accidental run against the wrong model on a 1,000-row manifest is not.
### 3b. Transcribe
For each row in `manifest.jsonl`, transcribe `audio_filepath` and write `per_sample.json` (one JSON object per row, JSONL or a JSON array — caller's choice):
```json
{
"audio_filepath": "...",
"ref": "<row.text>",
"hyp": "<asr output>",
"term": "<row.term>",
"entity_category": "<row.entity_category>",
"ipa_source": "<row.ipa_source>",
"voice_id": "<row.voice_id>",
"noise_level": "<row.noise_level>",
"context_type": "<row.context_type>"
}
```
**Recipe** (full Python in `references/offline-asr-recipe.md`): `transcribe_manifest(api_key, manifest_path, out_path, language_code="en-US")` opens an offline gRPC stream to NVCF (or to `ASR_ENDPOINT` if set for self-hosted Riva), calls `riva.client.ASRService.offline_recognize` per row — sentences in a clinical manifest are ≤ 30 s so no streaming/batching needed — and writes the JSONL above. Same `auth_for` shape as the Stage 1 setup smoke test. The agent harness passes `api_key` explicitly; the recipe reads the three env-var overrides (`ASR_NVCF_FUNCTION_ID`, `ASR_MODEL_NAME`, `ASR_ENDPOINT`) at the top so auditors see the knobs in one place.
**Whisper fallback** (when Parakeet's NVCF backend faults with `CUDA illegal-memory-access` from Triton) and **self-hosted Riva NIM** (`ASR_ENDPOINT=localhost:50051`) env-var patterns: see `references/offline-asr-recipe.md` (§Whisper fallback, §Self-hosted Riva NIM).
**Resilience knobs deferred to the user.** If NVCF returns `RESOURCE_EXHAUSTED` mid-batch, the loop raises on that row; re-run from the failing row. Streaming/batching/retry-with-backoff are out of scope — see `/riva-asr`.
### 3c. Score four metrics
For every row, compute:
| Metric | What it measures | Why we keep it |
|---|---|---|
| **WER** | Word error rate (Levenshtein on tokens, after normalization) | Industry standard; blunt instrument for clinical |
| **CER** | Character error rate | Catches near-misses on long compound names |
| **KER** ★ | Keyword error rate — did the flagged `term` appear in the hypothesis (normalized, **contiguous** match)? | **Headline clinical signal** |
| **SER** | Sentence error rate (1 if any wrong, 0 if perfect) | Sanity bound; what the doctor experiences |
**Normalization (apply to both `ref` and `hyp` before all four metrics):**
1. Lowercase.
2. NFKD-normalize (smart quotes → ASCII, etc.).
3. Strip punctuation **except hyphen**.
4. Collapse whitespace runs to a single space.
**Inline scoring recipes** — `normalize` / `edit_distance` / `wer` / `cer` / `ker` / `ser` (pure-Python, no `jiwer` dependency): see `references/scoring-recipes.md`. Aggregate across rows by taking `mean(per-row score)` for each metric.
**Strict KER** — term words must appear *in order, adjacent* in the normalized hypothesis. This is conservative: `cefazolin → cefa zolin` counts as a miss. That's the right call clinically — a downstream pharmacy lookup will fail on the misspelled token.
KER does **not** punish surrounding errors. A row where the term is correct and the rest of the sentence is garbage still scores KER=0; the WER on that row will surface the broader problem separately.
### 3d. Breakdowns + leaderboard
Write a five-section markdown leaderboard, **in this order**:
1. **Headline** — overall WER, CER, KER, SER for the chosen model.
2. **KER by `entity_category`** — drug vs procedure vs anatomy vs ... This is what the user actually cares about for deployment.
3. **KER by `ipa_source`** — **the most informative single number in the leaderboard.** The delta between `merriam-webster` and `magpie_g2p` rows is the proof the SSML override pipeline is doing real work. *Read this section aloud to the user.*
4. **KER by `noise_level`** — clinical environments are loud. `snr_5db` rows are closer to reality than `clean`.
5. **Per-term KER** (worst first) — these are your Stage 4 fine-tune targets.
A representative `ipa_source` split with the merriam-webster vs magpie_g2p delta interpretation: `references/scoring-recipes.md` §Representative ipa_source split. The delta tells the deployment story — if the user sees a wide gap and asks "should we fine-tune?", the answer is *not yet*; route them back to `/digital-health-clinical-asr-build`'s IPA QA pipeline (Stage 2d). See the decision tree below.
## Decision tree (after eval)
Read the **priority-category KER** (drug KER for most clinical workflows, procedure KER for surgical workflows) and route:
| KER on priority category | Recommend |
|---|---|
| **> 0.3** | `/digital-health-clinical-asr-finetune`. Manifest is already NeMo-format-ready. Note: rows ≥ 100 is the minimum for a believable fine-tune signal; if the manifest is smaller, grow it first via `/digital-health-clinical-asr-build`. |
| **0.1 – 0.3** | Either expand the term list (back to `/digital-health-clinical-asr-build` with new domain terms — usually surfaces more failures cheaper than tuning) **or** fine-tune. On a *first* eval, expand. On a *later* eval where you've already grown the manifest, tune. |
| **< 0.1** | Strong baseline. Don't tune yet — you'd be optimizing against a saturated metric. Push the eval harder: add voices, noise levels, contexts, adversarial terms. Loop back to `/digital-health-clinical-asr-build`. |
**Special case — `merriam-webster` rows score well but `magpie_g2p` rows are bad.** That's a pronunciation-hint coverage gap, **not a model gap**. Route back to `/digital-health-clinical-asr-build` Step 2d (IPA QA review), not to `/digital-health-clinical-asr-finetune`. Fine-tuning over a TTS-pronunciation gap teaches the model to mis-recognize the model's own mistakes — the wrong fix.
## Examples
**Scenario A — first eval on a fresh cycle-1 manifest.** User: *"I have `manifest.jsonl` with 200 clinical audio rows already, with `term` and `entity_category` fields. How do I score it?"* → Skip Stage 2 entirely. Run the audio-existence pre-flight. Pick `parakeet-tdt-0.6b-v2` (default) and echo the choice + resolved function-id. Run the inlined Step 3b recipe (`transcribe_manifest(...)`). Score the four metrics. Produce the five-section leaderboard. Read the by-`ipa_source` split to the user. Apply the decision tree against drug KER.
**Scenario B — interpreting a mixed result.** User: *"Eval shows KER 0.05 on rows tagged `merriam-webster` but 0.40 on rows tagged `magpie_g2p`. Should I fine-tune?"* → No — this is the special case. The model is fine; the pronunciation hints aren't covering the long-tail terms. Route the user back to `/digital-health-clinical-asr-build` Step 2d to audition the `magpie_g2p` rows and append verified IPA to `pronunciation_overrides.csv`. Re-run Stage 3 after the rebuild before reconsidering Stage 4.
## Artifacts produced
- `per_sample.json` — per-row transcription results with all clinical-extension fields preserved (the ASR `hyp` joined to the manifest's `ref` and metadata)
- `results.csv` — per-row WER/CER/KER/SER scores
- `leaderboard_cycle<N>.md` — five-section markdown report
(File names are user-chosen; the names above are conventions the rest of this skill assumes.)
## Troubleshooting
- **"No manifest found"** → user skipped Stage 2. Route to `/digital-health-clinical-asr-build` or confirm `$MANIFEST_PATH`.
- **All rows KER=1** → normalization mismatch between `ref` and `hyp`. Apply the four normalization steps to both sides.
- **All rows KER=0 but WER high** → likely misaligned manifest (audio row mismatch). Spot-check a few `(ref, hyp)` pairs by hand.
- **`merriam-webster` low, `magpie_g2p` high** → pronunciation-coverage gap. Route to `/digital-health-clinical-asr-build` Step 2d. **Don't fine-tune** — model isn't the problem.
- **Both `merriam-webster` and `magpie_g2p` high** → real model gap. Stage 4 is the right route (manifest ≥ 100 rows).
- **`clean` rows fine, `snr_5db` balloons** → robustness gap; expand noise diversity via `/digital-health-clinical-asr-build`.
- **Riva-NIM and offline NeMo results diverge** → Riva preprocessing / `riva-build` flags. Route to `/riva-asr-custom`.
- **`RESOURCE_EXHAUSTED` on large manifests** → retry after 30 s; slice + re-run dropped rows. Built-in backoff: `/riva-asr`.
- **`Auth.__init__() got 'ssl_cert'`** / **CUDA illegal-memory-access on Parakeet function ID**: see `references/offline-asr-recipe.md` (ssl_root_cert rename + §Whisper fallback).
Anything else: identify the upstream owner. ASR protocol / NIM deploy → `/riva-asr`. Scoring → here.
## Limitations
- **English-only by default.** Tokenization + normalization assume Latin script and en-US lexicon.
- **Strict-contiguous KER is conservative.** A near-miss like `cefa zolin` counts as a miss. That's intentional — pharmacy lookups fail on near-misses. Users wanting "soft" matching can switch to phoneme-level edit distance, which is a methodology extension, not a config tweak.
- **One model per eval run.** Comparing two models means running the eval twice and diffing the two `leaderboard_cycle<N>.md` files (or extending the recipe to write multi-model rows yourself).
- **Hosted-only paths assumed.** Self-hosted NIMs work but require `/riva-nim-setup` first.
## Next steps
- **Forward (KER > 0.3, manifest ≥ 100 rows):** `/digital-health-clinical-asr-finetune`.
- **Back to build (KER 0.1–0.3 on first eval, or `magpie_g2p` gap):** `/digital-health-clinical-asr-build`.
- **Stop (KER < 0.1):** the eval is saturated. Harden it before declaring victory.
- **Lateral** for ASR protocol / auth / streaming / self-hosted NIM details: `/riva-asr`.
## References
- [`references/offline-asr-recipe.md`](references/offline-asr-recipe.md) — full Step 3b Python recipe (`transcribe_manifest`, `resolve_asr_config`, `build_asr_auth`), function-ID catalog with call-shape notes, Whisper fallback, self-hosted Riva NIM setup
- [`references/scoring-recipes.md`](references/scoring-recipes.md) — pure-Python WER/CER/KER/SER scoring functions with the canonical 4-step normalization
Alle Dateien
7 Dateiendigital-health-clinical-asr-eval installieren
Laden Sie die Skill-Dateien herunter und entpacken Sie sie in Ihr Verzeichnis „.claude/skills/“.
ZIP herunterladenKlonen Sie das Repository und kopieren Sie die Skill-Dateien in Ihr Projekt.
git clone https://github.com/NVIDIA/skills/tree/main/skills/digital-health-clinical-asr-eval # Copy SKILL.md to your .claude/skills/ directory
Kopieren





Heim
