Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Diarisation : identifier qui parle

Õppetund 7 / 16 Värskendatud 3. november 2026 Arendajatele
Sellel lehel
  1. Qu’est-ce que la diarisation
  2. Activer la diarisation
  3. Utiliser les résultats
  4. Générer un rapport structuré
  5. Aller jusqu’à l’analyse complète
  6. Ce que la diarisation ne fait pas
  7. Nommer les locuteurs avec des clips de référence
  8. Peamised punktid

Cours mis à jour le 3 novembre 2026 pour Voxtral 3, sur la base du guide Mistral Migrate from Voxtral 2 : les modèles Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), dépréciés le 31 octobre 2026 et retirés le 30 avril 2027, sont remplacés dans les exemples par voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 et voxtral-mini-tts-3-0. Changements clés : les horodatages sont uniquement au niveau des segments (word renvoie une erreur 400), la diarisation est disponible en temps réel, les paramètres de session en temps réel sont verrouillés après le premier fragment audio, et les entrées context_bias sont en texte libre (phrases avec espaces). Sources : Migrate from Voxtral 2 · Speech to Text. Ajout basé sur le guide Diarize speakers : les étiquettes commencent à speaker_1 (et non speaker_0), le champ se nomme speaker_id, les clips de référence (speaker_references) permettent de nommer des locuteurs connus, et la diarisation fonctionne en temps réel, contrairement à ce qu’indiquait la version précédente. Sources : Diarize speakers · Speakers and diarization.

Qu’est-ce que la diarisation

La diarisation (ou diarisation des locuteurs) est la capacité à identifier et séparer les différents intervenants dans un enregistrement audio. Le modèle attribue automatiquement un identifiant à chaque voix distincte et segmente la transcription en conséquence.

L’écart de valeur est considérable. Une réunion à cinq personnes transcrite sans diarisation produit un bloc de texte où personne ne sait qui a pris quel engagement ; la même réunion, une fois diarisée, devient un compte-rendu attribuable. C’est pourquoi cette fonctionnalité est essentielle pour tout enregistrement multi-locuteurs : réunions, entretiens, appels téléphoniques, débats et tables rondes.

Activer la diarisation

Un seul paramètre suffit : diarize=True.

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

with open("reunion_equipe.mp3", "rb") as f:
    response = client.audio.transcriptions.complete(
        model="voxtral-mini-transcribe-3",
        file={"content": f, "file_name": "reunion_equipe.mp3"},
        diarize=True,
        timestamp_granularities=["segment"]
    )

La diarisation fonctionne de pair avec les horodatages au niveau des segments : le segment porte l’information. Chaque segment retourné inclut désormais un champ speaker_id identifiant le locuteur ; sans horodatages au niveau des segments, la requête échoue.

Utiliser les résultats

L’affichage le plus simple parcourt les segments et préfixe chaque énoncé par son auteur et son horodatage.

for seg in response.segments:
    temps = f"{seg.start:.1f}s"
    print(f"[{temps}] {seg.speaker_id} : {seg.text}")

Le résultat ressemble à ceci :

[0.0s] speaker_1 : Bonjour à tous, on commence la réunion hebdomadaire.
[3.2s] speaker_1 : Julien, tu veux commencer avec le point technique ?
[5.8s] speaker_2 : Oui, alors cette semaine on a finalisé la migration.
[12.4s] speaker_2 : Tout est déployé en production depuis mercredi.
[15.1s] speaker_3 : Super, et côté performances, on a vu une amélioration ?
[18.3s] speaker_2 : Oui, le temps de réponse a baissé de trente pour cent.

Les locuteurs sont identifiés comme speaker_1, speaker_2, etc. Ces étiquettes ne sont valables que pour une seule transcription : speaker_1 dans un fichier et speaker_1 dans le suivant ne désignent pas nécessairement la même personne. Sans références, le modèle ignore les noms : c’est à toi de mapper ces identifiants vers des individus réels, par exemple après avoir écouté les premières secondes, en utilisant un simple dictionnaire.

# Mapper les identifiants vers des noms réels
noms_locuteurs = {
    "speaker_1": "Marie (Manager)",
    "speaker_2": "Julien (Tech Lead)",
    "speaker_3": "Sarah (Product)",
}

for seg in response.segments:
    nom = noms_locuteurs.get(seg.speaker_id, seg.speaker_id)
    minutes = int(seg.start // 60)
    secondes = int(seg.start % 60)
    print(f"[{minutes:02d}:{secondes:02d}] {nom}")
    print(f"  {seg.text}\n")

Une fois le mappage en place, les durées des segments deviennent des métriques. La somme de seg.end - seg.start par locuteur te donne le temps de parole de chacun — une mesure sur laquelle s’appuient les animateurs de réunion et les responsables qualité des centres d’appels.

from collections import defaultdict

temps_parole = defaultdict(float)

for seg in response.segments:
    duree = seg.end - seg.start
    temps_parole[seg.speaker_id] += duree

print("=== Temps de parole ===")
total = sum(temps_parole.values())
for locuteur, duree in sorted(temps_parole.items()):
    nom = noms_locuteurs.get(locuteur, locuteur)
    pourcentage = (duree / total) * 100
    minutes = int(duree // 60)
    secondes = int(duree % 60)
    print(f"{nom} : {minutes}m{secondes:02d}s ({pourcentage:.1f}%)")
=== Temps de parole ===
Marie (Manager) : 8m23s (28.4%)
Julien (Tech Lead) : 12m45s (43.2%)
Sarah (Product) : 8m22s (28.4%)

Générer un rapport structuré

La diarisation combinée aux segments te permet de produire un rapport directement lisible. L’astuce dans le script suivant tient en une ligne : elle n’écrit un nouvel en-tête que lorsque le locuteur change, regroupant ainsi les tours de parole consécutifs d’une même personne au lieu de les fragmenter.

def generer_compte_rendu(segments, noms):
    """Générer un rapport Markdown à partir de segments diarisés."""
    lignes = ["# Compte-rendu de réunion\n"]
    locuteur_actuel = None

    for seg in segments:
        nom = noms.get(seg.speaker_id, seg.speaker_id)

        if seg.speaker_id != locuteur_actuel:
            locuteur_actuel = seg.speaker_id
            minutes = int(seg.start // 60)
            secondes = int(seg.start % 60)
            lignes.append(f"\n**{nom}** ({minutes:02d}:{secondes:02d}) :")

        lignes.append(f"  {seg.text}")

    return "\n".join(lignes)

compte_rendu = generer_compte_rendu(response.segments, noms_locuteurs)

with open("compte_rendu.md", "w", encoding="utf-8") as f:
    f.write(compte_rendu)

print("Compte-rendu généré")

Aller jusqu’à l’analyse complète

Voici le script qui rassemble le tout : transcription diarisée, statistiques par locuteur et sortie JSON, prête à alimenter un tableau de bord ou un LLM de résumé.

import os
import json
from collections import defaultdict
from mistralai.client import Mistral

def analyser_reunion(chemin_audio: str, noms: dict = None):
    """Transcrire et analyser une réunion complète."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

    # Transcrire avec diarisation
    with open(chemin_audio, "rb") as f:
        response = client.audio.transcriptions.complete(
            model="voxtral-mini-transcribe-3",
            file={"content": f, "file_name": chemin_audio},
            diarize=True,
            timestamp_granularities=["segment"]
        )

    noms = noms or {}

    # Statistiques
    stats = defaultdict(lambda: {"duree": 0.0, "segments": 0, "mots": 0})
    for seg in response.segments:
        stats[seg.speaker_id]["duree"] += seg.end - seg.start
        stats[seg.speaker_id]["segments"] += 1
        stats[seg.speaker_id]["mots"] += len(seg.text.split())

    # Résultat
    resultat = {
        "transcription": response.text,
        "nb_locuteurs": len(stats),
        "duree_totale": max(s.end for s in response.segments),
        "statistiques": {
            noms.get(loc, loc): {
                "duree_secondes": round(data["duree"], 1),
                "nb_segments": data["segments"],
                "nb_mots": data["mots"]
            }
            for loc, data in stats.items()
        }
    }

    return resultat

# Utilisation
resultat = analyser_reunion("reunion.mp3", {
    "speaker_1": "Marie",
    "speaker_2": "Julien",
    "speaker_3": "Sarah"
})

print(json.dumps(resultat["statistiques"], indent=2, ensure_ascii=False))

Ce que la diarisation ne fait pas

Garde quelques limites en tête avant de promettre un résultat à un client. Sans clips de référence, le modèle distingue les voix, pas les personnes, et le mappage reste ta responsabilité. Il détecte cependant seul le nombre de locuteurs : tu n’as pas besoin de le spécifier. Deux voix similaires peuvent être confondues, ce qui justifie la révision des passages critiques. La parole simultanée de deux locuteurs n’est pas prise en charge dans la version actuelle, selon Mistral. Enfin, la diarisation est aussi disponible en temps réel avec voxtral-mini-transcribe-realtime-3 (diarize dans session.update, étiquettes portées par les événements transcription.segment), mais une seule session ne peut pas combiner diarisation et détection de tours de parole.

Nommer les locuteurs avec des clips de référence

Lorsque tu sais à l’avance qui parle — par exemple, l’agent et le client dans un appel de support — tu peux envoyer un court extrait de chaque voix sous un nom : les segments provenant de cette voix porteront alors ce nom dans speaker_id, et le même nom désignera la même personne d’une transcription à l’autre.

import base64

def en_base64(chemin):
    with open(chemin, "rb") as f:
        return base64.b64encode(f.read()).decode()

with open("appel_support.wav", "rb") as f:
    response = client.audio.transcriptions.complete(
        model="voxtral-mini-transcribe-3",
        file={"content": f, "file_name": "appel_support.wav"},
        diarize=True,
        timestamp_granularities=["segment"],
        speaker_references={
            "conseiller": en_base64("ref_conseiller.wav"),
            "client": en_base64("ref_client.wav"),
        },
    )

Selon la documentation de Mistral, chaque clip doit durer entre 3 et 15 secondes et contenir au moins 85 % de parole ; tu peux en fournir jusqu’à 8, et le nombre total de locuteurs, référencés ou détectés, ne doit pas dépasser 10. Les formats WAV, Opus, MP3 et FLAC sont acceptés, les formats sans perte donnant les meilleurs résultats ; plus les conditions d’enregistrement du clip correspondent à celles de l’audio, meilleure est la correspondance. Un locuteur sans référence conserve une étiquette générique. Les références nécessitent diarize=True, fonctionnent aussi en temps réel (speaker_references dans session.update), et un modèle qui ne les accepte pas renvoie une erreur.

Peamised punktid

  • Active la diarisation avec diarize=True — un seul paramètre suffit
  • timestamp_granularities=["segment"] est requis avec la diarisation
  • Chaque segment inclut un champ speaker_id (speaker_1, speaker_2, etc.)
  • Mappe les identifiants vers des noms réels, ou nomme les voix connues avec speaker_references
  • Exploite les statistiques : temps de parole, nombre de tours, nombre de mots
  • La diarisation fonctionne hors ligne et en temps réel, mais pas avec la détection de tours de parole dans la même session