Aller au contenu principal

F-06 Diarisation des locuteurs

Brique F de la plateforme Enterprise AI. Technologie : pyannote.audio (pipeline speaker-diarization) sur des workers GPU. Version anglaise : ../../en/bricks/F-06-speaker-diarization.md.

Rôle et responsabilités​

  • Répondre à qui a parlé quand : tours de parole, nombre de locuteurs, détection de chevauchements.
  • Fusionner les tours avec les mots du STT pour produire une transcription attribuée par locuteur.
  • POST /v1/multimodal/diarize accepte min_speakers et max_speakers (de 1 à 32, min_speakers au plus égal à max_speakers), transmis à pyannote ; un adaptateur qui ne les prend pas en charge, ou word_timestamps sur cette route, donne un refus 422 traduit parameter_unsupported.

Position et interactions​

  • Chemin d'exécution : job batch, enchaîné après ou avec le STT.
  • Appelée directement ou via POST /v1/multimodal/stt avec diarize=true.

Part open source et part développée​

  • Open source réutilisé : pyannote.audio, PyTorch.
  • Développé dans la plateforme : Alignement avec les mots du STT, correspondance des étiquettes, aucune empreinte vocale persistante par défaut.

Modèle de données​

Tables du Control Plane (schéma eai) : eai.media, eai.multimodal_jobs, eai.usage_events.

Chaque table de tenant a tenant_id uuid NOT NULL et une politique de sécurité au niveau des lignes sur current_setting('app.tenant_id', true)::uuid. ClickHouse usage_events est la réplique analytique de eai.usage_events (ReplacingMergeTree par event_id).

Contrat : contracts/v1/multimodal-contract.schema.json (schema_version 1.0). L'usage est toujours remonté avec contracts/v1/usage-event.schema.json, l'audit avec contracts/v1/audit-event.schema.json.

Endpoints d'API​

MéthodeChemin
POST/v1/multimodal/diarize
GET/v1/multimodal/jobs/{id}

POST /v1/multimodal/diarize​

Requête :

{
  "media_id": "med_AUD1",
  "language": "fr"
}

Réponse :

{
  "job_id": "mmj_D01",
  "status": "succeeded",
  "speakers": 2,
  "turns": [
    {
      "speaker": "SPEAKER_00",
      "start": 0.0,
      "end": 6.1
    },
    {
      "speaker": "SPEAKER_01",
      "start": 6.3,
      "end": 11.0
    }
  ],
  "usage": {
    "audio_seconds": 184.2,
    "gpu_seconds": 21.5
  }
}

GET /v1/multimodal/jobs/{id}​

Réponse :

{
  "job_id": "mmj_V01",
  "operation": "video_process",
  "status": "succeeded",
  "outputs": {
    "frames": 118,
    "audio_media_id": "med_AUD7"
  },
  "attempts": 1
}

Exemples SDK​

Python​

from enterprise_ai import EnterpriseAI

client = EnterpriseAI(base_url="<control-plane-url>", api_key="eai_live_xxx", tenant="acme", locale="fr")
client.multimodal.audio.diarize("med_AUD1", language="fr")
client.multimodal.job(job_id="mmj_V01")

TypeScript​

import { EnterpriseAI } from "@enterprise-ai/sdk";

const client = new EnterpriseAI({ baseUrl: "<control-plane-url>", apiKey: process.env.EAI_API_KEY, tenant: "acme", locale: "fr" });
await client.multimodal.diarize({ media_id: "med_AUD1", language: "fr" });
await client.multimodal.getJob("mmj_V01");

Java​

EnterpriseAIClient client = EnterpriseAIClient.builder()
    .baseUrl("<control-plane-url>")
    .apiKey(System.getenv("EAI_API_KEY"))
    .tenant("acme")
    .locale(Locale.FRENCH)
    .build();
client.multimodal().diarize(Map.of("media_id", "med_AUD1", "language", "fr"));
client.multimodal().job("mmj_V01");

Go​

client, err := eai.NewClient(eai.WithBaseURL("<control-plane-url>"), eai.WithAPIKey(os.Getenv("EAI_API_KEY")), eai.WithTenant("acme"), eai.WithLocale("fr"))
if err != nil { log.Fatal(err) }
ctx := context.Background()
_, err = client.Multimodal.Diarize(ctx, map[string]any{"media_id": "med_AUD1", "language": "fr"})
_, err = client.Multimodal.Job(ctx, "mmj_V01")

// worker package: run a media worker consuming multimodal jobs
w, err := worker.New(worker.Config{Source: jobs, Handler: handle, Client: client, Concurrency: 2})
if err != nil { log.Fatal(err) }
err = w.Run(ctx)

Configuration​

Variables d'environnement : EAI_PYANNOTE_MODEL.

Clés de valeurs Helm (deploy/helm/enterprise-ai/values.yaml) : workers.items[name=diarization].resources.

Sécurité​

  • Les embeddings de locuteurs sont des données biométriques : l'adaptateur pyannote (EAI_PYANNOTE_MODEL) ne renvoie que les tours de parole (start, end, speaker) et aucun embedding n'est stocké.
  • Tenant déduit de l'identifiant d'accès, jamais du corps ; sécurité au niveau des lignes PostgreSQL sur chaque table de tenant.
  • Chaque mutation et décision de politique écrit un événement d'audit chaîné par hachage (G-11).
  • Les erreurs utilisent l'enveloppe standard avec message_i18n en et fr.

Observabilité​

  • Taux d'erreur de diarisation suivi par les suites d'évaluation G-09 sur de l'audio annoté.
  • traceparent W3C propagé, X-Request-Id renvoyé, les spans portent eai.tenant_id, eai.project, eai.agent_id, eai.run_id.

Unités FinOps​

  • Enregistré sous usage_type stt avec labels.operation=diarize : audio_seconds et gpu_seconds.

Modes de défaillance et résilience​

  • Plus de locuteurs que le modèle ne peut en séparer -> certains tours sont regroupés sous un même locuteur ; vérifier turns avant de se fier au nombre de locuteurs.

Adoption autonome​

Des outils de réunion peuvent n'appeler que la diarisation sur des médias déposés via /v1/media.

Tests d'acceptation​

  1. Un enregistrement à 2 locuteurs renvoie 2 libellés dans speakers et des tours couvrant l'audio.
  2. Aucun embedding n'est persisté avec la configuration par défaut.

Feuille de route d'implémentation

Preuves vocales du kit L4​

Les poids pyannote sont à accès restreint sur Hugging Face : l'adaptateur n'est testé qu'avec une simulation (MULT-004 bloquée par les poids). Voir le guide du runtime vocal.