Schnellstart: Echtzeit-Besprechungstranskription

  • Artikel

Sie können Besprechungen transkribieren und haben die Möglichkeit, mehrere Teilnehmer hinzuzufügen, zu entfernen und zu bestimmen, indem Sie Audiodaten an den Speech-Dienst streamen. Sie erstellen zunächst mithilfe der REST-API Stimmsignaturen für jeden Teilnehmer und verwenden dann die Stimmsignaturen mit dem SDK, um Besprechungen zu transkribieren. Weitere Informationen finden Sie in der Übersicht zur Besprechungstranskription.

Begrenzungen

  • Nur in den folgenden Abonnementregionen verfügbar : centralus, eastasia, eastus, westeurope
  • Es ist ein kreisförmiges Mikrofonarray mit 7 Mikrofonen erforderlich. Das Mikrofonarray sollte unsere Spezifikation erfüllen.

Hinweis

Das Speech SDK für C++, Java, Objective-C und Swift unterstützt die Besprechungstranskription, wir haben hier jedoch noch keinen Leitfaden bereitgestellt.

Voraussetzungen

Einrichten der Umgebung

Zuallererst müssen Sie das Speech SDK für JavaScript installieren. Falls Sie lediglich den Paketnamen für die Installation benötigen, können Sie den folgenden Befehl ausführen: npm install microsoft-cognitiveservices-speech-sdk. Anweisungen zu einer geführten Installation finden Sie im SDK-Installationshandbuch.

Erstellen von Stimmsignaturen

Wenn Sie Benutzerprofile registrieren möchten, besteht der erste Schritt im Erstellen von Stimmsignaturen für die Teilnehmer der Besprechung, damit sie eindeutig als Sprecher erkannt werden können. Dieser Schritt ist nicht erforderlich, wenn Sie keine vorab registrierten Benutzerprofile für die Identifikation bestimmter Teilnehmer verwenden möchten.

Die .wav-Audioeingabedatei zum Erstellen von Stimmsignaturen muss in 16-Bit, mit einer Abtastrate von 16 kHz im Monoformat (einzelner Kanal) vorliegen. Die empfohlene Länge der einzelnen Audiobeispiele liegt zwischen 30 Sekunden und zwei Minuten. Ein zu kurzes Audiobeispiel kann bei der Sprechererkennung zu Ungenauigkeiten führen. Bei der Datei .wav muss es sich um ein Beispiel für die Stimme einer Person handeln, damit ein eindeutiges Sprachprofil erstellt wird.

Das folgende Beispiel zeigt das Erstellen einer Stimmsignatur mithilfe der REST-API in JavaScript. Sie müssen subscriptionKey, region und den Pfad in eine .wav-Beispieldatei einfügen.

const fs = require('fs');
const axios = require('axios');
const formData = require('form-data');
 
const subscriptionKey = 'your-subscription-key';
const region = 'your-region';
 
async function createProfile() {
    let form = new formData();
    form.append('file', fs.createReadStream('path-to-voice-sample.wav'));
    let headers = form.getHeaders();
    headers['Ocp-Apim-Subscription-Key'] = subscriptionKey;
 
    let url = `https://signature.${region}.cts.speech.microsoft.com/api/v1/Signature/GenerateVoiceSignatureFromFormData`;
    let response = await axios.post(url, form, { headers: headers });
    
    // get signature from response, serialize to json string
    return JSON.stringify(response.data.Signature);
}
 
async function main() {
    // use this voiceSignature string with meeting transcription calls below
    let voiceSignatureString = await createProfile();
    console.log(voiceSignatureString);
}
main();

Beim Ausführen dieses Skripts wird eine Stimmsignatur-Zeichenfolge in der Variable voiceSignatureString zurückgegeben. Führen Sie die Funktion zweimal aus, damit Sie über zwei Zeichenfolgen verfügen, die Sie unten als Eingabe für die Variablen voiceSignatureStringUser1 und voiceSignatureStringUser2 verwenden können.

Hinweis

Stimmsignaturen können nur mithilfe der REST-API erstellt werden.

Transkribieren von Besprechungen

Der folgende Beispielcode veranschaulicht das Transkribieren von Besprechungen in Echtzeit für zwei Sprecher. Dabei wird davon ausgegangen, dass Sie bereits für alle Sprecher Stimmsignatur-Zeichenfolgen erstellt haben, wie oben gezeigt. Ersetzen Sie subscriptionKey, region und den Pfad filepath für das zu transkribierende Audiomaterial durch echte Informationen.

Wenn Sie keine vorab registrierten Benutzerprofile verwenden, dauert es einige Sekunden, bis die erstmalige Erkennung eines unbekannten Benutzers als Speaker1, Speaker2 usw. abgeschlossen ist.

Hinweis

Stellen Sie sicher, dass derselbe subscriptionKey in Ihrer Anwendung für die Erstellung von Signaturen verwendet wird, da es sonst zu Fehlern kommen kann.

Der Beispielcode führt die folgenden Aufgaben aus:

  • Erstellt einen Pushstream, der für die Transkription verwendet werden soll, und schreibt die Beispieldatei .wav dafür.
  • Erstellt ein Meeting-Element mithilfe von createMeetingAsync().
  • Erstellt ein MeetingTranscriber-Element mit dem Konstruktor.
  • Fügt der Besprechung Teilnehmer hinzu. Die Zeichenfolgen voiceSignatureStringUser1 und voiceSignatureStringUser2 sollten sich als Ausgabe aus den oben dargestellten Schritten ergeben.
  • Führt eine Registrierung für Ereignisse durch und beginnt mit der Transkription.
  • Wenn Sie die Sprecher unterscheiden möchten, ohne Stimmbeispiele zur Verfügung zu stellen, aktivieren Sie das Feature DifferentiateGuestSpeakers wie in der Übersicht zur Besprechungstranskription.

Wenn die Sprecher*innenidentifikation oder -unterscheidung aktiviert ist, wertet der Dienst diese weiterhin anhand der gesammelten Audioinformationen aus, selbst wenn Sie bereits transcribed-Ergebnisse erhalten haben. Wenn der Dienst feststellt, dass einem vorherigen Ergebnis eine falsche speakerId zugewiesen wurde, wird erneut ein nahezu identisches Transcribed-Ergebnis gesendet, wobei nur die speakerId und UtteranceId unterschiedlich sind. Da das UtteranceId-Format {index}_{speakerId}_{Offset} ist, wenn Sie ein transcribed-Ergebnis erhalten, können Sie die UtteranceId verwenden, um zu bestimmen, ob das aktuelle transcribed-Ergebnis ein vorheriges Ergebnis korrigieren wird. Ihre Client- oder Benutzeroberflächenlogik kann über Verhaltensweisen entscheiden, wie das Überschreiben der vorherigen Ausgabe oder das Ignorieren des letzten Ergebnisses.

(function() {
    "use strict";
    var sdk = require("microsoft-cognitiveservices-speech-sdk");
    var fs = require("fs");
    
    var subscriptionKey = "your-subscription-key";
    var region = "your-region";
    var filepath = "audio-file-to-transcribe.wav"; // 8-channel audio
    
    var speechTranslationConfig = sdk.SpeechTranslationConfig.fromSubscription(subscriptionKey, region);
    var audioConfig = sdk.AudioConfig.fromWavFileInput(fs.readFileSync(filepath));
    speechTranslationConfig.setProperty("ConversationTranscriptionInRoomAndOnline", "true");

    // en-us by default. Adding this code to specify other languages, like zh-cn.
    speechTranslationConfig.speechRecognitionLanguage = "en-US";
    
    // create meeting and transcriber
    var meeting = sdk.Meeting.createMeetingAsync(speechTranslationConfig, "myMeeting");
    var transcriber = new sdk.MeetingTranscriber(audioConfig);
    
    // attach the transcriber to the meeting
    transcriber.joinMeetingAsync(meeting,
    function () {
        // add first participant using voiceSignature created in enrollment step
        var user1 = sdk.Participant.From("user1@example.com", "en-us", voiceSignatureStringUser1);
        meeting.addParticipantAsync(user1,
        function () {
            // add second participant using voiceSignature created in enrollment step
            var user2 = sdk.Participant.From("user2@example.com", "en-us", voiceSignatureStringUser2);
            meeting.addParticipantAsync(user2,
            function () {
                transcriber.sessionStarted = function(s, e) {
                console.log("(sessionStarted)");
                };
                transcriber.sessionStopped = function(s, e) {
                console.log("(sessionStopped)");
                };
                transcriber.canceled = function(s, e) {
                console.log("(canceled)");
                };
                transcriber.transcribed = function(s, e) {
                console.log("(transcribed) text: " + e.result.text);
                console.log("(transcribed) speakerId: " + e.result.speakerId);
                };
    
                // begin meeting transcription
                transcriber.startTranscribingAsync(
                function () { },
                function (err) {
                    console.trace("err - starting transcription: " + err);
                });
        },
        function (err) {
            console.trace("err - adding user1: " + err);
        });
    },
    function (err) {
        console.trace("err - adding user2: " + err);
    });
    },
    function (err) {
    console.trace("err - " + err);
    });
}());

Voraussetzungen

Einrichten der Umgebung

Das Speech SDK ist als NuGet-Paket verfügbar und implementiert .NET Standard 2.0. Im weiteren Verlauf dieses Leitfadens installieren Sie das Speech SDK. Überprüfen Sie jedoch zunächst in den plattformspezifischen Installationsanweisungen, ob weitere Anforderungen gelten.

Erstellen von Stimmsignaturen

Wenn Sie Benutzerprofile registrieren möchten, besteht der erste Schritt im Erstellen von Stimmsignaturen für die Teilnehmer der Besprechung, damit sie eindeutig als Sprecher erkannt werden können. Dieser Schritt ist nicht erforderlich, wenn Sie keine vorab registrierten Benutzerprofile für die Identifikation bestimmter Teilnehmer verwenden möchten.

Die .wav-Audioeingabedatei zum Erstellen von Stimmsignaturen muss in 16-Bit, mit einer Abtastrate von 16 kHz im Monoformat (einzelner Kanal) vorliegen. Die empfohlene Länge der einzelnen Audiobeispiele liegt zwischen 30 Sekunden und zwei Minuten. Ein zu kurzes Audiobeispiel kann bei der Sprechererkennung zu Ungenauigkeiten führen. Bei der Datei .wav muss es sich um ein Beispiel für die Stimme einer Person handeln, damit ein eindeutiges Sprachprofil erstellt wird.

Das folgende Beispiel zeigt das Erstellen einer Stimmsignatur mithilfe der REST-API in C#. Sie müssen subscriptionKey, region und den Pfad in eine .wav-Beispieldatei einfügen.

using System;
using System.IO;
using System.Net.Http;
using System.Runtime.Serialization;
using System.Threading.Tasks;
using Newtonsoft.Json;

[DataContract]
internal class VoiceSignature
{
    [DataMember]
    public string Status { get; private set; }

    [DataMember]
    public VoiceSignatureData Signature { get; private set; }

    [DataMember]
    public string Transcription { get; private set; }
}

[DataContract]
internal class VoiceSignatureData
{
    internal VoiceSignatureData()
    { }

    internal VoiceSignatureData(int version, string tag, string data)
    {
        this.Version = version;
        this.Tag = tag;
        this.Data = data;
    }

    [DataMember]
    public int Version { get; private set; }

    [DataMember]
    public string Tag { get; private set; }

    [DataMember]
    public string Data { get; private set; }
}

private static async Task<string> GetVoiceSignatureString()
{
    var subscriptionKey = "your-subscription-key";
    var region = "your-region";

    byte[] fileBytes = File.ReadAllBytes("path-to-voice-sample.wav");
    var content = new ByteArrayContent(fileBytes);
    var client = new HttpClient();
    client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", subscriptionKey);
    var response = await client.PostAsync($"https://signature.{region}.cts.speech.microsoft.com/api/v1/Signature/GenerateVoiceSignatureFromByteArray", content);
    
    var jsonData = await response.Content.ReadAsStringAsync();
    var result = JsonConvert.DeserializeObject<VoiceSignature>(jsonData);
    return JsonConvert.SerializeObject(result.Signature);
}

Beim Ausführen der Funktion GetVoiceSignatureString() wird eine Stimmsignatur-Zeichenfolge im richtigen Format zurückgegeben. Führen Sie die Funktion zweimal aus, damit Sie über zwei Zeichenfolgen verfügen, die Sie unten als Eingabe für die Variablen voiceSignatureStringUser1 und voiceSignatureStringUser2 verwenden können.

Hinweis

Stimmsignaturen können nur mithilfe der REST-API erstellt werden.

Transkribieren von Besprechungen

Der folgende Beispielcode veranschaulicht das Transkribieren von Besprechungen in Echtzeit für zwei Sprecher. Dabei wird davon ausgegangen, dass Sie bereits für alle Sprecher Stimmsignatur-Zeichenfolgen erstellt haben, wie oben gezeigt. Ersetzen Sie subscriptionKey, region und den Pfad filepath für das zu transkribierende Audiomaterial durch echte Informationen.

Wenn Sie keine vorab registrierten Benutzerprofile verwenden, dauert es einige Sekunden, bis die erstmalige Erkennung eines unbekannten Benutzers als Speaker1, Speaker2 usw. abgeschlossen ist.

Hinweis

Stellen Sie sicher, dass derselbe subscriptionKey in Ihrer Anwendung für die Erstellung von Signaturen verwendet wird, da es sonst zu Fehlern kommen kann.

Der Beispielcode führt die folgenden Aufgaben aus:

  • Erstellt einen AudioConfig aus der .wav-Beispieldatei für die Transkription.
  • Erstellt eine Meeting mithilfe von CreateMeetingAsync().
  • Erstellt einen MeetingTranscriber mit dem-Konstruktor und abonniert die erforderlichen Ereignisse.
  • Fügt der Besprechung Teilnehmer hinzu. Die Zeichenfolgen voiceSignatureStringUser1 und voiceSignatureStringUser2 sollten sich als Ausgabe aus den oben dargestellten Schritten aus der Funktion GetVoiceSignatureString() ergeben.
  • Tritt der Besprechung bei und beginnt mit der Transkription.
  • Wenn Sie die Sprecher unterscheiden möchten, ohne Stimmbeispiele zur Verfügung zu stellen, aktivieren Sie das Feature DifferentiateGuestSpeakers wie in der Übersicht zur Besprechungstranskription.

Hinweis

AudioStreamReader ist eine Hilfsklasse. Sie erhalten Sie auf GitHub.

Wenn die Sprecher*innenidentifikation oder -unterscheidung aktiviert ist, wertet der Dienst diese weiterhin anhand der gesammelten Audioinformationen aus, selbst wenn Sie bereits Transcribed-Ergebnisse erhalten haben. Wenn der Dienst feststellt, dass einem vorherigen Ergebnis eine falsche UserId zugewiesen wurde, wird erneut ein nahezu identisches Transcribed-Ergebnis gesendet, wobei nur die UserId und UtteranceId unterschiedlich sind. Da das UtteranceId-Format {index}_{UserId}_{Offset} ist, wenn Sie ein Transcribed-Ergebnis erhalten, können Sie die UtteranceId verwenden, um zu bestimmen, ob das aktuelle Transcribed-Ergebnis ein vorheriges Ergebnis korrigieren wird. Ihre Client- oder Benutzeroberflächenlogik kann über Verhaltensweisen entscheiden, wie das Überschreiben der vorherigen Ausgabe oder das Ignorieren des letzten Ergebnisses.

Ruft die TranscribeMeetingsAsync()-Funktion auf, um die Transkription der Besprechung zu starten.

using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;
using Microsoft.CognitiveServices.Speech.Transcription;

class TranscribeMeeting
{
    // all your other code

    public static async Task TranscribeMeetingsAsync(string voiceSignatureStringUser1, string voiceSignatureStringUser2)
    {
        var subscriptionKey = "your-subscription-key";
        var region = "your-region";
        var filepath = "audio-file-to-transcribe.wav";

        var config = SpeechConfig.FromSubscription(subscriptionKey, region);
        config.SetProperty("ConversationTranscriptionInRoomAndOnline", "true");

        // en-us by default. Adding this code to specify other languages, like zh-cn.
        // config.SpeechRecognitionLanguage = "zh-cn";
        var stopRecognition = new TaskCompletionSource<int>();

        using (var audioInput = AudioConfig.FromWavFileInput(filepath))
        {
            var meetingID = Guid.NewGuid().ToString();
            using (var meeting = await Meeting.CreateMeetingAsync(config, meetingID))
            {
                // create a meeting transcriber using audio stream input
                using (var meetingTranscriber = new MeetingTranscriber(audioInput))
                {
                    meetingTranscriber.Transcribing += (s, e) =>
                    {
                        Console.WriteLine($"TRANSCRIBING: Text={e.Result.Text} SpeakerId={e.Result.UserId}");
                    };

                    meetingTranscriber.Transcribed += (s, e) =>
                    {
                        if (e.Result.Reason == ResultReason.RecognizedSpeech)
                        {
                            Console.WriteLine($"TRANSCRIBED: Text={e.Result.Text} SpeakerId={e.Result.UserId}");
                        }
                        else if (e.Result.Reason == ResultReason.NoMatch)
                        {
                            Console.WriteLine($"NOMATCH: Speech could not be recognized.");
                        }
                    };

                    meetingTranscriber.Canceled += (s, e) =>
                    {
                        Console.WriteLine($"CANCELED: Reason={e.Reason}");

                        if (e.Reason == CancellationReason.Error)
                        {
                            Console.WriteLine($"CANCELED: ErrorCode={e.ErrorCode}");
                            Console.WriteLine($"CANCELED: ErrorDetails={e.ErrorDetails}");
                            Console.WriteLine($"CANCELED: Did you set the speech resource key and region values?");
                            stopRecognition.TrySetResult(0);
                        }
                    };

                    meetingTranscriber.SessionStarted += (s, e) =>
                    {
                        Console.WriteLine($"\nSession started event. SessionId={e.SessionId}");
                    };

                    meetingTranscriber.SessionStopped += (s, e) =>
                    {
                        Console.WriteLine($"\nSession stopped event. SessionId={e.SessionId}");
                        Console.WriteLine("\nStop recognition.");
                        stopRecognition.TrySetResult(0);
                    };

                    // Add participants to the meeting.
                    var speaker1 = Participant.From("User1", "en-US", voiceSignatureStringUser1);
                    var speaker2 = Participant.From("User2", "en-US", voiceSignatureStringUser2);
                    await meeting.AddParticipantAsync(speaker1);
                    await meeting.AddParticipantAsync(speaker2);

                    // Join to the meeting and start transcribing
                    await meetingTranscriber.JoinMeetingAsync(meeting);
                    await meetingTranscriber.StartTranscribingAsync().ConfigureAwait(false);

                    // waits for completion, then stop transcription
                    Task.WaitAny(new[] { stopRecognition.Task });
                    await meetingTranscriber.StopTranscribingAsync().ConfigureAwait(false);
                }
            }
        }
    }
}

Voraussetzungen

Einrichten der Umgebung

Bevor Sie anfangen können, müssen Sie das Speech SDK für Python installieren. Sie können das Speech SDK über PyPI installieren, indem Sie pip install azure-cognitiveservices-speech ausführen.

Erstellen von Stimmsignaturen

Wenn Sie Benutzerprofile registrieren möchten, besteht der erste Schritt im Erstellen von Stimmsignaturen für die Teilnehmer der Besprechung, damit sie eindeutig als Sprecher erkannt werden können. Dieser Schritt ist nicht erforderlich, wenn Sie keine vorab registrierten Benutzerprofile für die Identifikation bestimmter Teilnehmer verwenden möchten.

Die .wav-Audioeingabedatei zum Erstellen von Stimmsignaturen muss in 16-Bit, mit einer Abtastrate von 16 kHz im Monoformat (einzelner Kanal) vorliegen. Die empfohlene Länge der einzelnen Audiobeispiele liegt zwischen 30 Sekunden und zwei Minuten. Ein zu kurzes Audiobeispiel kann bei der Sprechererkennung zu Ungenauigkeiten führen. Bei der Datei .wav muss es sich um ein Beispiel für die Stimme einer Person handeln, damit ein eindeutiges Sprachprofil erstellt wird.

Das folgende Beispiel zeigt das Erstellen einer Stimmsignatur mithilfe der REST-API in Python. Sie müssen subscriptionKey, region und den Pfad in eine .wav-Beispieldatei einfügen.

import requests
from scipy.io.wavfile import read
import json

speech_key, service_region = "your-subscription-key", "your-region"
endpoint = f"https://signature.{service_region}.cts.speech.microsoft.com/api/v1/Signature/GenerateVoiceSignatureFromByteArray"

#Enrollment audio for each speaker. In this example, two speaker enrollment audio files are added.
enrollment_audio_speaker1 = "enrollment-audio-speaker1.wav"
enrollment_audio_speaker2 = "enrollment-audio-speaker2.wav"

def voice_data_converter(enrollment_audio):
  with open(enrollment_audio, "rb") as wav_file:
    input_wav = wav_file.read()
  return input_wav
  
def voice_signature_creator(endpoint, speech_key, enrollment_audio):
  data = voice_data_converter(enrollment_audio)
  headers = {"Ocp-Apim-Subscription-Key":speech_key}
  r = requests.post(url = endpoint,headers = headers, data = data)
  voice_signature_string = json.dumps(r.json()['Signature'])
  return voice_signature_string

voice_signature_user1 = voice_signature_creator(endpoint, speech_key, enrollment_audio_speaker1)
voice_signature_user2 = voice_signature_creator(endpoint, speech_key, enrollment_audio_speaker2)

Sie können diese zwei voice_signature_string als Eingabe für die Variablen voice_signature_user1 und voice_signature_user2 später im Beispielcode verwenden.

Hinweis

Stimmsignaturen können nur mithilfe der REST-API erstellt werden.

Transkribieren von Besprechungen

Der folgende Beispielcode veranschaulicht das Transkribieren von Besprechungen in Echtzeit für zwei Sprecher. Dabei wird davon ausgegangen, dass Sie bereits für alle Sprecher Stimmsignatur-Zeichenfolgen erstellt haben, wie zuvor gezeigt. Ersetzen Sie subscriptionKey, region und den Pfad filepath für das zu transkribierende Audiomaterial durch echte Informationen.

Wenn Sie keine vorab registrierten Benutzerprofile verwenden, dauert es einige Sekunden, bis die erstmalige Erkennung eines unbekannten Benutzers als Speaker1, Speaker2 usw. abgeschlossen ist.

Hinweis

Stellen Sie sicher, dass derselbe subscriptionKey in Ihrer Anwendung für die Erstellung von Signaturen verwendet wird, da es sonst zu Fehlern kommen kann.

Hier sehen Sie, was das Beispiel ausführt:

  • Erstellt eine Sprachkonfiguration mit Abonnementinformationen.
  • Erstellt eine Audiokonfiguration mithilfe des Pushstreams.
  • Erstellt einen MeetingTranscriber und abonniert die Ereignisse, die vom Transcriber der Besprechung ausgelöst werden.
  • Besprechungsbezeichner zum Erstellen einer Besprechung.
  • Fügt der Besprechung Teilnehmer hinzu. Die Zeichenfolgen voiceSignatureStringUser1 und voiceSignatureStringUser2 sollten sich als Ausgabe aus den vorherigen Schritten ergeben.
  • Liest die gesamten Wave-Dateien in einem Durchgang, streamt sie zum SDK und beginnt mit der Transkription.
  • Wenn Sie die Sprecher unterscheiden möchten, ohne Stimmbeispiele zur Verfügung zu stellen, aktivieren Sie das Feature DifferentiateGuestSpeakers wie in der Übersicht zur Besprechungstranskription.

Wenn die Sprecher*innenidentifikation oder -unterscheidung aktiviert ist, wertet der Dienst diese weiterhin anhand der gesammelten Audioinformationen aus, selbst wenn Sie bereits transcribed-Ergebnisse erhalten haben. Wenn der Dienst feststellt, dass einem vorherigen Ergebnis eine falsche speakerId zugewiesen wurde, wird erneut ein nahezu identisches Transcribed-Ergebnis gesendet, wobei nur die speakerId und UtteranceId unterschiedlich sind. Da das UtteranceId-Format {index}_{speakerId}_{Offset} ist, wenn Sie ein transcribed-Ergebnis erhalten, können Sie die UtteranceId verwenden, um zu bestimmen, ob das aktuelle transcribed-Ergebnis ein vorheriges Ergebnis korrigieren wird. Ihre Client- oder Benutzeroberflächenlogik kann über Verhaltensweisen entscheiden, wie das Überschreiben der vorherigen Ausgabe oder das Ignorieren des letzten Ergebnisses.

import azure.cognitiveservices.speech as speechsdk
import time
import uuid
from scipy.io import wavfile

speech_key, service_region="your-subscription-key","your-region"
meetingfilename= "audio-file-to-transcribe.wav" # 8 channel, 16 bits, 16kHz audio

def meeting_transcription():
    
    speech_config = speechsdk.SpeechConfig(subscription=speech_key, region=service_region)
    speech_config.set_property_by_name("ConversationTranscriptionInRoomAndOnline", "true")
    # If you want to differentiate speakers without providing voice samples, uncomment the following line.
    # speech_config.set_property_by_name("DifferentiateGuestSpeakers", "true")

    channels = 8
    bits_per_sample = 16
    samples_per_second = 16000
    
    wave_format = speechsdk.audio.AudioStreamFormat(samples_per_second, bits_per_sample, channels)
    stream = speechsdk.audio.PushAudioInputStream(stream_format=wave_format)
    audio_config = speechsdk.audio.AudioConfig(stream=stream)

    transcriber = speechsdk.transcription.MeetingTranscriber(audio_config)

    meeting_id = str(uuid.uuid4())
    meeting = speechsdk.transcription.Meeting(speech_config, meeting_id)
    done = False

    def stop_cb(evt: speechsdk.SessionEventArgs):
        """callback that signals to stop continuous transcription upon receiving an event `evt`"""
        print('CLOSING {}'.format(evt))
        nonlocal done
        done = True
        
    transcriber.transcribed.connect(lambda evt: print('TRANSCRIBED: {}'.format(evt)))
    transcriber.session_started.connect(lambda evt: print('SESSION STARTED: {}'.format(evt)))
    transcriber.session_stopped.connect(lambda evt: print('SESSION STOPPED {}'.format(evt)))
    transcriber.canceled.connect(lambda evt: print('CANCELED {}'.format(evt)))
    # stop continuous transcription on either session stopped or canceled events
    transcriber.session_stopped.connect(stop_cb)
    transcriber.canceled.connect(stop_cb)

    # Note user voice signatures are not required for speaker differentiation.
    # Use voice signatures when adding participants when more enhanced speaker identification is required.
    user1 = speechsdk.transcription.Participant("user1@example.com", "en-us", voice_signature_user1)
    user2 = speechsdk.transcription.Participant("user2@example.com", "en-us", voice_signature_user2)

    meeting.add_participant_async(user1).get()
    meeting.add_participant_async(user2).get()
    transcriber.join_meeting_async(meeting).get()
    transcriber.start_transcribing_async()
    
    sample_rate, wav_data = wavfile.read(meetingfilename)
    stream.write(wav_data.tobytes())
    stream.close()
    while not done:
        time.sleep(.5)

    transcriber.stop_transcribing_async()

Nächste Schritte

Asynchrone Besprechungstranskription