Så identifierar du tal

  • Artikel

Referensdokumentation Paket (NuGet) | Ytterligare exempel på GitHub |

I den här guiden lär du dig att känna igen och transkribera tal till text i realtid.

Skapa en talkonfiguration

Om du vill anropa Speech-tjänsten med hjälp av Speech SDK måste du skapa en SpeechConfig instans. Den här klassen innehåller information om din prenumeration, till exempel din nyckel och tillhörande plats/region, slutpunkt, värd eller auktoriseringstoken.

  1. Skapa en SpeechConfig instans med hjälp av din nyckel och plats/region.
  2. Skapa en Speech-resurs på Azure-portalen. Mer information finns i Skapa en resurs med flera tjänster.
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

class Program 
{
    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("YourSpeechKey", "YourSpeechRegion");
    }
}

Du kan initiera SpeechConfig på några andra sätt:

  • Använd en slutpunkt och skicka in en Slutpunkt för Speech-tjänsten. En nyckel eller auktoriseringstoken är valfri.
  • Använd en värd och skicka in en värdadress. En nyckel eller auktoriseringstoken är valfri.
  • Använd en auktoriseringstoken med den associerade regionen/platsen.

Kommentar

Oavsett om du utför taligenkänning, talsyntes, översättning eller avsiktsigenkänning skapar du alltid en konfiguration.

Identifiera tal från en mikrofon

Om du vill känna igen tal med hjälp av enhetens mikrofon skapar du en AudioConfig instans med hjälp FromDefaultMicrophoneInput() av metoden . Initiera sedan objektet SpeechRecognizer genom att skicka speechConfig och audioConfig.

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

class Program 
{
    async static Task FromMic(SpeechConfig speechConfig)
    {
        using var audioConfig = AudioConfig.FromDefaultMicrophoneInput();
        using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        Console.WriteLine("Speak into your microphone.");
        var result = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("YourSpeechKey", "YourSpeechRegion");
        await FromMic(speechConfig);
    }
}

Om du vill använda en specifik ljudinmatningsenhet måste du ange enhets-ID:t i AudioConfig. Lär dig hur du hämtar enhets-ID :t för din ljudinmatningsenhet.

Identifiera tal från en fil

Om du vill känna igen tal från en ljudfil i stället för en mikrofon måste du fortfarande skapa en AudioConfig instans. Men i det här fallet ringer FromDefaultMicrophoneInput()du inte . Du anropar FromWavFileInput() och skickar filsökvägen:

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

class Program 
{
    async static Task FromFile(SpeechConfig speechConfig)
    {
        using var audioConfig = AudioConfig.FromWavFileInput("PathToFile.wav");
        using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        var result = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("YourSpeechKey", "YourSpeechRegion");
        await FromFile(speechConfig);
    }
}

Identifiera tal från en minnesintern ström

I många användningsfall är det troligt att dina ljuddata kommer från Azure Blob Storage, eller att de annars redan finns i minnet som en byte[] instans eller en liknande rådatastruktur. I följande exempel används PushAudioInputStream för att identifiera tal, som i huvudsak är en abstrakt minnesström. Exempelkoden utför följande åtgärder:

  • Skriver rådata (PCM) till PushAudioInputStream med hjälp Write() av funktionen, som accepterar en byte[] instans.
  • Läser en .wav fil med hjälp FileReader av i demonstrationssyfte. Om du redan har ljuddata i en byte[] instans kan du hoppa direkt till att skriva innehållet till indataströmmen.
  • Standardformatet är pcm-data (16-bitars, 16 KHz mono pulse-code modulation). Om du vill anpassa formatet kan du skicka ett AudioStreamFormat objekt till CreatePushStream() med hjälp av den statiska funktionen AudioStreamFormat.GetWaveFormatPCM(sampleRate, (byte)bitRate, (byte)channels).
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

class Program 
{
    async static Task FromStream(SpeechConfig speechConfig)
    {
        var reader = new BinaryReader(File.OpenRead("PathToFile.wav"));
        using var audioConfigStream = AudioInputStream.CreatePushStream();
        using var audioConfig = AudioConfig.FromStreamInput(audioConfigStream);
        using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        byte[] readBytes;
        do
        {
            readBytes = reader.ReadBytes(1024);
            audioConfigStream.Write(readBytes, readBytes.Length);
        } while (readBytes.Length > 0);

        var result = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("YourSpeechKey", "YourSpeechRegion");
        await FromStream(speechConfig);
    }
}

Att använda en push-ström som indata förutsätter att ljuddata är en rå PCM och hoppar över alla rubriker. API:et fungerar fortfarande i vissa fall om huvudet inte har hoppats över. För bästa resultat bör du överväga att implementera logik för att läsa av rubrikerna så att den byte[]börjar i början av ljuddata.

Hantera fel

I föregående exempel hämtas endast den identifierade texten från egenskapen result.Text . Om du vill hantera fel och andra svar måste du skriva kod för att hantera resultatet. Följande kod utvärderar egenskapen result.Reason och:

  • Skriver ut igenkänningsresultatet: ResultReason.RecognizedSpeech.
  • Om det inte finns någon igenkänningsmatchning informerar den användaren: ResultReason.NoMatch.
  • Om ett fel påträffas skriver det ut felmeddelandet: ResultReason.Canceled.
switch (result.Reason)
{
    case ResultReason.RecognizedSpeech:
        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
        break;
    case ResultReason.NoMatch:
        Console.WriteLine($"NOMATCH: Speech could not be recognized.");
        break;
    case ResultReason.Canceled:
        var cancellation = CancellationDetails.FromResult(result);
        Console.WriteLine($"CANCELED: Reason={cancellation.Reason}");

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

Använda kontinuerlig igenkänning

I föregående exempel används enkel igenkänning, som identifierar ett enda yttrande. Slutet på ett enskilt yttrande bestäms genom att lyssna efter tystnad i slutet eller tills högst 15 sekunders ljud bearbetas.

Däremot använder du kontinuerlig igenkänning när du vill styra när du ska sluta känna igen. Det kräver att du prenumererar på Recognizinghändelserna , Recognizedoch Canceled för att få igenkänningsresultatet. Om du vill stoppa igenkänningen måste du anropa StopContinuousRecognitionAsync. Här är ett exempel på hur kontinuerlig igenkänning utförs på en ljudinmatningsfil.

Börja med att definiera indata och initiera SpeechRecognizer:

using var audioConfig = AudioConfig.FromWavFileInput("YourAudioFile.wav");
using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

Skapa sedan en TaskCompletionSource<int> instans för att hantera tillståndet för taligenkänning:

var stopRecognition = new TaskCompletionSource<int>();

Prenumerera sedan på de händelser som SpeechRecognizer skickar:

  • Recognizing: Signal för händelser som innehåller mellanliggande igenkänningsresultat.
  • Recognized: Signal för händelser som innehåller slutigenkänningsresultat, vilket indikerar ett lyckat igenkänningsförsök.
  • SessionStopped: Signal för händelser som anger slutet på en igenkänningssession (åtgärd).
  • Canceled: Signal för händelser som innehåller avbrutna igenkänningsresultat. Dessa resultat indikerar ett igenkänningsförsök som avbröts till följd av en direkt avbokningsbegäran. Alternativt anger de ett transport- eller protokollfel.
speechRecognizer.Recognizing += (s, e) =>
{
    Console.WriteLine($"RECOGNIZING: Text={e.Result.Text}");
};

speechRecognizer.Recognized += (s, e) =>
{
    if (e.Result.Reason == ResultReason.RecognizedSpeech)
    {
        Console.WriteLine($"RECOGNIZED: Text={e.Result.Text}");
    }
    else if (e.Result.Reason == ResultReason.NoMatch)
    {
        Console.WriteLine($"NOMATCH: Speech could not be recognized.");
    }
};

speechRecognizer.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);
};

speechRecognizer.SessionStopped += (s, e) =>
{
    Console.WriteLine("\n    Session stopped event.");
    stopRecognition.TrySetResult(0);
};

När allt har konfigurerats anropar du StartContinuousRecognitionAsync för att börja känna igen:

await speechRecognizer.StartContinuousRecognitionAsync();

// Waits for completion. Use Task.WaitAny to keep the task rooted.
Task.WaitAny(new[] { stopRecognition.Task });

// Make the following call at some point to stop recognition:
// await speechRecognizer.StopContinuousRecognitionAsync();

Ändra källspråket

En vanlig uppgift för taligenkänning är att ange indataspråket (eller källspråket). I följande exempel visas hur du ändrar indataspråket till italienska. Leta upp din SpeechConfig instans i koden och lägg till den här raden direkt under den:

speechConfig.SpeechRecognitionLanguage = "it-IT";

Egenskapen SpeechRecognitionLanguage förväntar sig en språkspråksformatsträng. Mer information finns i listan över tal till textspråk som stöds.

Språkidentifiering

Du kan använda språkidentifiering med tal till textigenkänning när du behöver identifiera språket i en ljudkälla och sedan transkribera det till text.

Ett fullständigt kodexempel finns i Språkidentifiering.

Använda en anpassad slutpunkt

Med anpassat tal kan du ladda upp dina egna data, testa och träna en anpassad modell, jämföra noggrannhet mellan modeller och distribuera en modell till en anpassad slutpunkt. I följande exempel visas hur du anger en anpassad slutpunkt.

var speechConfig = SpeechConfig.FromSubscription("YourSubscriptionKey", "YourServiceRegion");
speechConfig.EndpointId = "YourEndpointId";
var speechRecognizer = new SpeechRecognizer(speechConfig);

Köra och använda en container

Talcontainrar tillhandahåller websocketbaserade frågeslutpunkts-API:er som nås via Speech SDK och Speech CLI. Som standard använder Speech SDK och Speech CLI den offentliga Speech-tjänsten. Om du vill använda containern måste du ändra initieringsmetoden. Använd en containervärd-URL i stället för nyckel och region.

Mer information om containrar finns i Värd-URL:er i Installera och köra Speech-containrar med Docker.

Ändra hur tystnad hanteras

Om en användare förväntas tala snabbare eller långsammare än vanligt kanske standardbeteendena för icke-texttystnad i indataljud inte resulterar i det du förväntar dig. Vanliga problem med tystnadshantering är:

  • Snabbtal som sammanlänkar många meningar till ett enda igenkänningsresultat, i stället för att dela meningar i enskilda resultat.
  • Långsamt tal som skiljer delar av en enda mening till flera resultat.
  • En enskottsigenkänning slutar för snabbt i väntan på att talet ska börja.

Dessa problem kan åtgärdas genom att ange en av två timeout-egenskaper på den SpeechConfig instans som används för att skapa en SpeechRecognizer:

  • Tidsgränsen för segmenteringstystnad justerar hur mycket icke-ljud som tillåts inom en fras som för närvarande talas innan den frasen anses vara "klar".
    • Högre värden ger vanligtvis längre resultat och tillåter längre pauser från talaren i en fras, men gör att resultatet tar längre tid att komma fram. De kan också få separata fraser att kombineras till ett enda resultat när de anges för högt.
    • Lägre värden gör vanligtvis resultaten kortare och säkerställer mer snabba och frekventa brytningar mellan fraser, men kan också leda till att enskilda fraser separeras i flera resultat när de anges för lågt.
    • Den här tidsgränsen kan anges till heltalsvärden mellan 100 och 5 000, i millisekunder, med 500 som standard.
  • Den inledande tidsgränsen för tystnad justerar hur mycket ljud utan ljud som tillåts innan en fras innan igenkänningsförsöket slutar med ett resultat av typen "ingen matchning".
    • Högre värden ger talarna mer tid att reagera och börja tala, men kan också leda till långsam svarstid när ingenting talas.
    • Lägre värden säkerställer en uppmaning om "ingen matchning" för snabbare användarupplevelse och mer kontrollerad ljudhantering, men kan stänga av en högtalare för snabbt när den är för låg.
    • Eftersom kontinuerlig igenkänning genererar många resultat avgör det här värdet hur ofta "ingen matchning"-resultat anländer, men påverkar annars inte innehållet i igenkänningsresultatet.
    • Den här tidsgränsen kan ställas in på valfritt icke-negativt heltalsvärde, i millisekunder eller inställt på 0 för att inaktivera det helt. 5000 är en typisk standard för enkel igenkänning medan 15000 är en typisk standard för kontinuerlig igenkänning.

Eftersom det finns kompromisser när du ändrar dessa tidsgränser bör du bara ändra inställningarna när du har problem med tyst hantering. Standardvärden hanterar optimalt de flesta talade ljud och endast ovanliga scenarier bör stöta på problem.

Exempel: Användare som talar ett serienummer som "ABC-123-4567" kan pausa mellan teckengrupper tillräckligt länge för att serienumret ska delas upp i flera resultat. I det här fallet kan du prova ett högre värde som 2 000 ms för tidsgränsen för segmenteringstystnad:

speechConfig.SetProperty(PropertyId.Speech_SegmentationSilenceTimeoutMs, "2000");

Exempel: En inspelad presentatörs tal kan vara tillräckligt snabbt för att flera meningar i rad ska kombineras, med stora igenkänningsresultat som bara kommer en eller två gånger per minut. I det här fallet anger du tidsgränsen för segmenteringstystnad till ett lägre värde som 300 ms:

speechConfig.SetProperty(PropertyId.Speech_SegmentationSilenceTimeoutMs, "300");

Exempel: En enstaka igenkänning som ber en talare att hitta och läsa ett serienummer slutar för snabbt medan talet hittas. I det här fallet kan du prova en längre tidsgräns för inledande tystnad som 10 000 ms:

speechConfig.SetProperty(PropertyId.SpeechServiceConnection_InitialSilenceTimeoutMs, "10000");

Referensdokumentation Paket (NuGet) | Ytterligare exempel på GitHub |

I den här guiden lär du dig att känna igen och transkribera tal till text i realtid.

Skapa en talkonfiguration

Om du vill anropa Speech-tjänsten med hjälp av Speech SDK måste du skapa en SpeechConfig instans. Den här klassen innehåller information om din prenumeration, till exempel din nyckel och tillhörande plats/region, slutpunkt, värd eller auktoriseringstoken.

  1. Skapa en SpeechConfig instans med hjälp av din nyckel och region.
  2. Skapa en Speech-resurs på Azure-portalen. Mer information finns i Skapa en resurs med flera tjänster.
using namespace std;
using namespace Microsoft::CognitiveServices::Speech;

auto speechConfig = SpeechConfig::FromSubscription("YourSpeechKey", "YourSpeechRegion");

Du kan initiera SpeechConfig på några andra sätt:

  • Använd en slutpunkt och skicka in en Slutpunkt för Speech-tjänsten. En nyckel eller auktoriseringstoken är valfri.
  • Använd en värd och skicka in en värdadress. En nyckel eller auktoriseringstoken är valfri.
  • Använd en auktoriseringstoken med den associerade regionen/platsen.

Kommentar

Oavsett om du utför taligenkänning, talsyntes, översättning eller avsiktsigenkänning skapar du alltid en konfiguration.

Identifiera tal från en mikrofon

Om du vill känna igen tal med hjälp av enhetens mikrofon skapar du en AudioConfig instans med hjälp FromDefaultMicrophoneInput() av medlemsfunktionen. Initiera sedan objektetSpeechRecognizer genom att skicka audioConfig och config.

using namespace Microsoft::CognitiveServices::Speech::Audio;

auto audioConfig = AudioConfig::FromDefaultMicrophoneInput();
auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);

cout << "Speak into your microphone." << std::endl;
auto result = speechRecognizer->RecognizeOnceAsync().get();
cout << "RECOGNIZED: Text=" << result->Text << std::endl;

Om du vill använda en specifik ljudinmatningsenhet måste du ange enhets-ID:t i AudioConfig. Mer information om hur du hämtar enhets-ID för din ljudinmatningsenhet finns i Välj en ljudinmatningsenhet med Speech SDK

Identifiera tal från en fil

Om du vill känna igen tal från en ljudfil i stället för att använda en mikrofon måste du fortfarande skapa en AudioConfig instans. Men i det här fallet ringer FromDefaultMicrophoneInput()du inte . Du anropar FromWavFileInput() och skickar filsökvägen:

using namespace Microsoft::CognitiveServices::Speech::Audio;

auto audioConfig = AudioConfig::FromWavFileInput("YourAudioFile.wav");
auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);

auto result = speechRecognizer->RecognizeOnceAsync().get();
cout << "RECOGNIZED: Text=" << result->Text << std::endl;

Identifiera tal med hjälp av klassen Recognizer

Klassen Recognizer för Speech SDK för C++ visar några metoder som du kan använda för taligenkänning.

Enkel igenkänning

Enstaka igenkänning känner asynkront igen ett enda yttrande. Slutet på ett enskilt yttrande bestäms genom att lyssna efter tystnad i slutet eller tills högst 15 sekunders ljud bearbetas. Här är ett exempel på asynkron enkel igenkänning via RecognizeOnceAsync:

auto result = speechRecognizer->RecognizeOnceAsync().get();

Du måste skriva kod för att hantera resultatet. Det här exemplet utvärderar result->Reason och:

  • Skriver ut igenkänningsresultatet: ResultReason::RecognizedSpeech.
  • Om det inte finns någon igenkänningsmatchning informerar den användaren: ResultReason::NoMatch.
  • Om ett fel påträffas skriver det ut felmeddelandet: ResultReason::Canceled.
switch (result->Reason)
{
    case ResultReason::RecognizedSpeech:
        cout << "We recognized: " << result->Text << std::endl;
        break;
    case ResultReason::NoMatch:
        cout << "NOMATCH: Speech could not be recognized." << std::endl;
        break;
    case ResultReason::Canceled:
        {
            auto cancellation = CancellationDetails::FromResult(result);
            cout << "CANCELED: Reason=" << (int)cancellation->Reason << std::endl;
    
            if (cancellation->Reason == CancellationReason::Error) {
                cout << "CANCELED: ErrorCode= " << (int)cancellation->ErrorCode << std::endl;
                cout << "CANCELED: ErrorDetails=" << cancellation->ErrorDetails << std::endl;
                cout << "CANCELED: Did you set the speech resource key and region values?" << std::endl;
            }
        }
        break;
    default:
        break;
}

Kontinuerlig igenkänning

Kontinuerlig igenkänning är lite mer involverat än enkel igenkänning. Det kräver att du prenumererar på Recognizinghändelserna , Recognizedoch Canceled för att få igenkänningsresultatet. Om du vill stoppa igenkänningen måste du anropa StopContinuousRecognitionAsync. Här är ett exempel på hur kontinuerlig igenkänning utförs på en ljudinmatningsfil.

Börja med att definiera indata och initiera SpeechRecognizer:

auto audioConfig = AudioConfig::FromWavFileInput("YourAudioFile.wav");
auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);

Skapa sedan en variabel för att hantera taligenkänningens tillstånd. Deklarera promise<void> eftersom du i början av igenkänningen säkert kan anta att den inte är klar:

promise<void> recognitionEnd;

Prenumerera sedan på de händelser som SpeechRecognizer skickar:

  • Recognizing: Signal för händelser som innehåller mellanliggande igenkänningsresultat.
  • Recognized: Signal för händelser som innehåller slutigenkänningsresultat, vilket indikerar ett lyckat igenkänningsförsök.
  • SessionStopped: Signal för händelser som anger slutet på en igenkänningssession (åtgärd).
  • Canceled: Signal för händelser som innehåller avbrutna igenkänningsresultat. Dessa resultat indikerar ett igenkänningsförsök som avbröts till följd av en direkt annulleringsbegäran. Alternativt anger de ett transport- eller protokollfel.
speechRecognizer->Recognizing.Connect([](const SpeechRecognitionEventArgs& e)
    {
        cout << "Recognizing:" << e.Result->Text << std::endl;
    });

speechRecognizer->Recognized.Connect([](const SpeechRecognitionEventArgs& e)
    {
        if (e.Result->Reason == ResultReason::RecognizedSpeech)
        {
            cout << "RECOGNIZED: Text=" << e.Result->Text 
                 << " (text could not be translated)" << std::endl;
        }
        else if (e.Result->Reason == ResultReason::NoMatch)
        {
            cout << "NOMATCH: Speech could not be recognized." << std::endl;
        }
    });

speechRecognizer->Canceled.Connect([&recognitionEnd](const SpeechRecognitionCanceledEventArgs& e)
    {
        cout << "CANCELED: Reason=" << (int)e.Reason << std::endl;
        if (e.Reason == CancellationReason::Error)
        {
            cout << "CANCELED: ErrorCode=" << (int)e.ErrorCode << "\n"
                 << "CANCELED: ErrorDetails=" << e.ErrorDetails << "\n"
                 << "CANCELED: Did you set the speech resource key and region values?" << std::endl;

            recognitionEnd.set_value(); // Notify to stop recognition.
        }
    });

speechRecognizer->SessionStopped.Connect([&recognitionEnd](const SessionEventArgs& e)
    {
        cout << "Session stopped.";
        recognitionEnd.set_value(); // Notify to stop recognition.
    });

När allt har konfigurerats anropar du StartContinuousRecognitionAsync för att börja känna igen:

// Starts continuous recognition. Uses StopContinuousRecognitionAsync() to stop recognition.
speechRecognizer->StartContinuousRecognitionAsync().get();

// Waits for recognition end.
recognitionEnd.get_future().get();

// Stops recognition.
speechRecognizer->StopContinuousRecognitionAsync().get();

Ändra källspråket

En vanlig uppgift för taligenkänning är att ange indataspråket (eller källspråket). I följande exempel visas hur du ändrar indataspråket till tyska. Leta upp din SpeechConfig instans i koden och lägg till den här raden direkt under den:

speechConfig->SetSpeechRecognitionLanguage("de-DE");

SetSpeechRecognitionLanguage är en parameter som tar en sträng som argument. Mer information finns i listan över tal till textspråk som stöds.

Språkidentifiering

Du kan använda språkidentifiering med tal till textigenkänning när du behöver identifiera språket i en ljudkälla och sedan transkribera det till text.

Ett fullständigt kodexempel finns i Språkidentifiering.

Använda en anpassad slutpunkt

Med anpassat tal kan du ladda upp dina egna data, testa och träna en anpassad modell, jämföra noggrannhet mellan modeller och distribuera en modell till en anpassad slutpunkt. I följande exempel visas hur du anger en anpassad slutpunkt.

auto speechConfig = SpeechConfig::FromSubscription("YourSubscriptionKey", "YourServiceRegion");
speechConfig->SetEndpointId("YourEndpointId");
auto speechRecognizer = SpeechRecognizer::FromConfig(speechConfig);

Köra och använda en container

Talcontainrar tillhandahåller websocketbaserade frågeslutpunkts-API:er som nås via Speech SDK och Speech CLI. Som standard använder Speech SDK och Speech CLI den offentliga Speech-tjänsten. Om du vill använda containern måste du ändra initieringsmetoden. Använd en containervärd-URL i stället för nyckel och region.

Mer information om containrar finns i Värd-URL:er i Installera och köra Speech-containrar med Docker.

Referensdokumentation Paket (Go) | Ytterligare exempel på GitHub |

I den här guiden lär du dig att känna igen och transkribera tal till text i realtid.

Identifiera tal till text från en mikrofon

Använd följande kodexempel för att köra taligenkänning från standardenhetens mikrofon. Ersätt variablerna subscription och region med din talnyckel respektive plats/region. Skapa en Speech-resurs på Azure-portalen. Mer information finns i Skapa en resurs med flera tjänster. När du kör skriptet startas en igenkänningssession på standardmikrofonen och utdatatexten:

package main

import (
	"bufio"
	"fmt"
	"os"

	"github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
	"github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
)

func sessionStartedHandler(event speech.SessionEventArgs) {
	defer event.Close()
	fmt.Println("Session Started (ID=", event.SessionID, ")")
}

func sessionStoppedHandler(event speech.SessionEventArgs) {
	defer event.Close()
	fmt.Println("Session Stopped (ID=", event.SessionID, ")")
}

func recognizingHandler(event speech.SpeechRecognitionEventArgs) {
	defer event.Close()
	fmt.Println("Recognizing:", event.Result.Text)
}

func recognizedHandler(event speech.SpeechRecognitionEventArgs) {
	defer event.Close()
	fmt.Println("Recognized:", event.Result.Text)
}

func cancelledHandler(event speech.SpeechRecognitionCanceledEventArgs) {
	defer event.Close()
	fmt.Println("Received a cancellation: ", event.ErrorDetails)
	fmt.Println("Did you set the speech resource key and region values?")
}

func main() {
    subscription :=  "YourSpeechKey"
    region := "YourSpeechRegion"

	audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer audioConfig.Close()
	config, err := speech.NewSpeechConfigFromSubscription(subscription, region)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer config.Close()
	speechRecognizer, err := speech.NewSpeechRecognizerFromConfig(config, audioConfig)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer speechRecognizer.Close()
	speechRecognizer.SessionStarted(sessionStartedHandler)
	speechRecognizer.SessionStopped(sessionStoppedHandler)
	speechRecognizer.Recognizing(recognizingHandler)
	speechRecognizer.Recognized(recognizedHandler)
	speechRecognizer.Canceled(cancelledHandler)
	speechRecognizer.StartContinuousRecognitionAsync()
	defer speechRecognizer.StopContinuousRecognitionAsync()
	bufio.NewReader(os.Stdin).ReadBytes('\n')
}

Kör följande kommandon för att skapa en go.mod-fil som länkar till komponenter som finns på GitHub:

go mod init quickstart
go get github.com/Microsoft/cognitive-services-speech-sdk-go

Skapa och kör nu koden:

go build
go run quickstart

Detaljerad information finns i referensinnehållet SpeechConfig för klassen och referensinnehållet SpeechRecognizer för klassen.

Identifiera tal till text från en ljudfil

Använd följande exempel för att köra taligenkänning från en ljudfil. Ersätt variablerna subscription och region med din talnyckel respektive plats/region. Skapa en Speech-resurs på Azure-portalen. Mer information finns i Skapa en resurs med flera tjänster. Ersätt dessutom variabeln file med en sökväg till en .wav fil. När du kör skriptet identifieras tal från filen och textresultatet matas ut:

package main

import (
	"fmt"
	"time"

	"github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
	"github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
)

func main() {
    subscription :=  "YourSpeechKey"
    region := "YourSpeechRegion"
    file := "path/to/file.wav"

	audioConfig, err := audio.NewAudioConfigFromWavFileInput(file)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer audioConfig.Close()
	config, err := speech.NewSpeechConfigFromSubscription(subscription, region)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer config.Close()
	speechRecognizer, err := speech.NewSpeechRecognizerFromConfig(config, audioConfig)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer speechRecognizer.Close()
	speechRecognizer.SessionStarted(func(event speech.SessionEventArgs) {
		defer event.Close()
		fmt.Println("Session Started (ID=", event.SessionID, ")")
	})
	speechRecognizer.SessionStopped(func(event speech.SessionEventArgs) {
		defer event.Close()
		fmt.Println("Session Stopped (ID=", event.SessionID, ")")
	})

	task := speechRecognizer.RecognizeOnceAsync()
	var outcome speech.SpeechRecognitionOutcome
	select {
	case outcome = <-task:
	case <-time.After(5 * time.Second):
		fmt.Println("Timed out")
		return
	}
	defer outcome.Close()
	if outcome.Error != nil {
		fmt.Println("Got an error: ", outcome.Error)
	}
	fmt.Println("Got a recognition!")
	fmt.Println(outcome.Result.Text)
}

Kör följande kommandon för att skapa en go.mod-fil som länkar till komponenter som finns på GitHub:

go mod init quickstart
go get github.com/Microsoft/cognitive-services-speech-sdk-go

Skapa och kör nu koden:

go build
go run quickstart

Detaljerad information finns i referensinnehållet SpeechConfig för klassen och referensinnehållet SpeechRecognizer för klassen.

Köra och använda en container

Talcontainrar tillhandahåller websocketbaserade frågeslutpunkts-API:er som nås via Speech SDK och Speech CLI. Som standard använder Speech SDK och Speech CLI den offentliga Speech-tjänsten. Om du vill använda containern måste du ändra initieringsmetoden. Använd en containervärd-URL i stället för nyckel och region.

Mer information om containrar finns i Värd-URL:er i Installera och köra Speech-containrar med Docker.

Referensdokumentation | Ytterligare exempel på GitHub

I den här guiden lär du dig att känna igen och transkribera tal till text i realtid.

Skapa en talkonfiguration

Om du vill anropa Speech-tjänsten med hjälp av Speech SDK måste du skapa en SpeechConfig-instans . Den här klassen innehåller information om din prenumeration, till exempel din nyckel och tillhörande plats/region, slutpunkt, värd eller auktoriseringstoken.

  1. Skapa en SpeechConfig instans med hjälp av din nyckel och plats/region.
  2. Skapa en Speech-resurs på Azure-portalen. Mer information finns i Skapa en resurs med flera tjänster.
import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class Program {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        SpeechConfig speechConfig = SpeechConfig.fromSubscription("<paste-your-subscription-key>", "<paste-your-region>");
    }
}

Du kan initiera SpeechConfig på några andra sätt:

  • Använd en slutpunkt och skicka in en Slutpunkt för Speech-tjänsten. En nyckel eller auktoriseringstoken är valfri.
  • Använd en värd och skicka in en värdadress. En nyckel eller auktoriseringstoken är valfri.
  • Använd en auktoriseringstoken med den associerade regionen/platsen.

Kommentar

Oavsett om du utför taligenkänning, talsyntes, översättning eller avsiktsigenkänning skapar du alltid en konfiguration.

Identifiera tal från en mikrofon

Om du vill känna igen tal med hjälp av enhetens mikrofon skapar du en AudioConfig instans med hjälp fromDefaultMicrophoneInput() av metoden . Initiera sedan objektet SpeechRecognizer genom att skicka audioConfig och config.

import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class Program {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        SpeechConfig speechConfig = SpeechConfig.fromSubscription("<paste-your-subscription-key>", "<paste-your-region>");
        fromMic(speechConfig);
    }

    public static void fromMic(SpeechConfig speechConfig) throws InterruptedException, ExecutionException {
        AudioConfig audioConfig = AudioConfig.fromDefaultMicrophoneInput();
        SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        System.out.println("Speak into your microphone.");
        Future<SpeechRecognitionResult> task = speechRecognizer.recognizeOnceAsync();
        SpeechRecognitionResult result = task.get();
        System.out.println("RECOGNIZED: Text=" + result.getText());
    }
}

Om du vill använda en specifik ljudinmatningsenhet måste du ange enhets-ID:t i AudioConfig. Mer information om hur du hämtar enhets-ID för din ljudinmatningsenhet finns i Välj en ljudinmatningsenhet med Speech SDK.

Identifiera tal från en fil

Om du vill känna igen tal från en ljudfil i stället för att använda en mikrofon måste du fortfarande skapa en AudioConfig instans. Men i det här fallet ringer FromDefaultMicrophoneInput()du inte . Du anropar fromWavFileInput() och skickar filsökvägen:

import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class Program {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        SpeechConfig speechConfig = SpeechConfig.fromSubscription("<paste-your-subscription-key>", "<paste-your-region>");
        fromFile(speechConfig);
    }

    public static void fromFile(SpeechConfig speechConfig) throws InterruptedException, ExecutionException {
        AudioConfig audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
        SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);
        
        Future<SpeechRecognitionResult> task = speechRecognizer.recognizeOnceAsync();
        SpeechRecognitionResult result = task.get();
        System.out.println("RECOGNIZED: Text=" + result.getText());
    }
}

Hantera fel

I föregående exempel hämtas endast den identifierade texten med hjälp result.getText()av . Om du vill hantera fel och andra svar måste du skriva kod för att hantera resultatet. I följande exempel utvärderas result.getReason() och:

  • Skriver ut igenkänningsresultatet: ResultReason.RecognizedSpeech.
  • Om det inte finns någon igenkänningsmatchning informerar den användaren: ResultReason.NoMatch.
  • Om ett fel påträffas skriver det ut felmeddelandet: ResultReason.Canceled.
switch (result.getReason()) {
    case ResultReason.RecognizedSpeech:
        System.out.println("We recognized: " + result.getText());
        exitCode = 0;
        break;
    case ResultReason.NoMatch:
        System.out.println("NOMATCH: Speech could not be recognized.");
        break;
    case ResultReason.Canceled: {
            CancellationDetails cancellation = CancellationDetails.fromResult(result);
            System.out.println("CANCELED: Reason=" + cancellation.getReason());

            if (cancellation.getReason() == CancellationReason.Error) {
                System.out.println("CANCELED: ErrorCode=" + cancellation.getErrorCode());
                System.out.println("CANCELED: ErrorDetails=" + cancellation.getErrorDetails());
                System.out.println("CANCELED: Did you set the speech resource key and region values?");
            }
        }
        break;
}

Använda kontinuerlig igenkänning

I föregående exempel används enkel igenkänning, som identifierar ett enda yttrande. Slutet på ett enskilt yttrande bestäms genom att lyssna efter tystnad i slutet eller tills högst 15 sekunders ljud bearbetas.

Däremot använder du kontinuerlig igenkänning när du vill styra när du ska sluta känna igen. Det kräver att du prenumererar på recognizinghändelserna , recognizedoch canceled för att få igenkänningsresultatet. Om du vill stoppa igenkänningen måste du anropa stopContinuousRecognitionAsync. Här är ett exempel på hur du kan utföra kontinuerlig igenkänning på en ljudindatafil.

Börja med att definiera indata och initiera SpeechRecognizer:

AudioConfig audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
SpeechRecognizer speechRecognizer = new SpeechRecognizer(config, audioConfig);

Skapa sedan en variabel för att hantera taligenkänningens tillstånd. Deklarera en Semaphore instans i klassomfånget:

private static Semaphore stopTranslationWithFileSemaphore;

Prenumerera sedan på de händelser som SpeechRecognizer skickar:

  • recognizing: Signal för händelser som innehåller mellanliggande igenkänningsresultat.
  • recognized: Signal för händelser som innehåller slutigenkänningsresultat, vilket indikerar ett lyckat igenkänningsförsök.
  • sessionStopped: Signal för händelser som anger slutet på en igenkänningssession (åtgärd).
  • canceled: Signal för händelser som innehåller avbrutna igenkänningsresultat. Dessa resultat indikerar ett igenkänningsförsök som avbröts till följd av en direkt avbokningsbegäran. Alternativt anger de ett transport- eller protokollfel.
// First initialize the semaphore.
stopTranslationWithFileSemaphore = new Semaphore(0);

speechRecognizer.recognizing.addEventListener((s, e) -> {
    System.out.println("RECOGNIZING: Text=" + e.getResult().getText());
});

speechRecognizer.recognized.addEventListener((s, e) -> {
    if (e.getResult().getReason() == ResultReason.RecognizedSpeech) {
        System.out.println("RECOGNIZED: Text=" + e.getResult().getText());
    }
    else if (e.getResult().getReason() == ResultReason.NoMatch) {
        System.out.println("NOMATCH: Speech could not be recognized.");
    }
});

speechRecognizer.canceled.addEventListener((s, e) -> {
    System.out.println("CANCELED: Reason=" + e.getReason());

    if (e.getReason() == CancellationReason.Error) {
        System.out.println("CANCELED: ErrorCode=" + e.getErrorCode());
        System.out.println("CANCELED: ErrorDetails=" + e.getErrorDetails());
        System.out.println("CANCELED: Did you set the speech resource key and region values?");
    }

    stopTranslationWithFileSemaphore.release();
});

speechRecognizer.sessionStopped.addEventListener((s, e) -> {
    System.out.println("\n    Session stopped event.");
    stopTranslationWithFileSemaphore.release();
});

När allt har konfigurerats anropar du startContinuousRecognitionAsync för att börja känna igen:

// Starts continuous recognition. Uses StopContinuousRecognitionAsync() to stop recognition.
speechRecognizer.startContinuousRecognitionAsync().get();

// Waits for completion.
stopTranslationWithFileSemaphore.acquire();

// Stops recognition.
speechRecognizer.stopContinuousRecognitionAsync().get();

Ändra källspråket

En vanlig uppgift för taligenkänning är att ange indataspråket (eller källspråket). I följande exempel visas hur du ändrar indataspråket till franska. Leta reda på din SpeechConfig instans i koden och lägg till den här raden direkt under den:

config.setSpeechRecognitionLanguage("fr-FR");

setSpeechRecognitionLanguage är en parameter som tar en sträng som argument. Se listan över tal som stöds för textspråk.

Språkidentifiering

Du kan använda språkidentifiering med tal till textigenkänning när du behöver identifiera språket i en ljudkälla och sedan transkribera det till text.

Ett fullständigt kodexempel finns i Språkidentifiering.

Använda en anpassad slutpunkt

Med anpassat tal kan du ladda upp dina egna data, testa och träna en anpassad modell, jämföra noggrannhet mellan modeller och distribuera en modell till en anpassad slutpunkt. I följande exempel visas hur du anger en anpassad slutpunkt:

SpeechConfig speechConfig = SpeechConfig.FromSubscription("YourSubscriptionKey", "YourServiceRegion");
speechConfig.setEndpointId("YourEndpointId");
SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig);

Köra och använda en container

Talcontainrar tillhandahåller websocketbaserade frågeslutpunkts-API:er som nås via Speech SDK och Speech CLI. Som standard använder Speech SDK och Speech CLI den offentliga Speech-tjänsten. Om du vill använda containern måste du ändra initieringsmetoden. Använd en containervärd-URL i stället för nyckel och region.

Mer information om containrar finns i Värd-URL:er i Installera och köra Speech-containrar med Docker.

Referensdokumentation Paket (npm) | Ytterligare exempel på GitHub-bibliotekets källkod | |

I den här guiden lär du dig att känna igen och transkribera tal till text i realtid.

Skapa en talkonfiguration

Om du vill anropa Speech-tjänsten med hjälp av Speech SDK måste du skapa en SpeechConfig instans. Den här klassen innehåller information om din prenumeration, till exempel din nyckel och tillhörande plats/region, slutpunkt, värd eller auktoriseringstoken.

  1. Skapa en SpeechConfig instans med hjälp av din nyckel och plats/region.
  2. Skapa en Speech-resurs på Azure-portalen. Mer information finns i Skapa en resurs med flera tjänster.
const speechConfig = sdk.SpeechConfig.fromSubscription("YourSpeechKey", "YourSpeechRegion");

Du kan initiera SpeechConfig på några andra sätt:

  • Använd en slutpunkt och skicka in en Slutpunkt för Speech-tjänsten. En nyckel eller auktoriseringstoken är valfri.
  • Använd en värd och skicka in en värdadress. En nyckel eller auktoriseringstoken är valfri.
  • Använd en auktoriseringstoken med den associerade regionen/platsen.

Kommentar

Oavsett om du utför taligenkänning, talsyntes, översättning eller avsiktsigenkänning skapar du alltid en konfiguration.

Identifiera tal från en mikrofon

Det går inte att känna igen tal från en mikrofon i Node.js. Det stöds endast i en webbläsarbaserad JavaScript-miljö. Mer information finns i React-exemplet och implementeringen av tal till text från en mikrofon på GitHub. React-exemplet visar designmönster för utbyte och hantering av autentiseringstoken. Den visar också inspelning av ljud från en mikrofon eller fil för tal till textkonverteringar.

Kommentar

Om du vill använda en specifik ljudinmatningsenhet måste du ange enhets-ID:t i AudioConfig objektet. Mer information finns i Välj en ljudinmatningsenhet med Speech SDK.

Identifiera tal från en fil

Om du vill känna igen tal från en ljudfil skapar du en AudioConfig instans med hjälp fromWavFileInput() av metoden som accepterar ett Buffer objekt. SpeechRecognizer Initiera sedan genom att skicka audioConfig och speechConfig.

const fs = require('fs');
const sdk = require("microsoft-cognitiveservices-speech-sdk");
const speechConfig = sdk.SpeechConfig.fromSubscription("YourSpeechKey", "YourSpeechRegion");

function fromFile() {
    let audioConfig = sdk.AudioConfig.fromWavFileInput(fs.readFileSync("YourAudioFile.wav"));
    let speechRecognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);

    speechRecognizer.recognizeOnceAsync(result => {
        console.log(`RECOGNIZED: Text=${result.text}`);
        speechRecognizer.close();
    });
}
fromFile();

Identifiera tal från en minnesintern ström

I många användningsfall kommer dina ljuddata troligen från Azure Blob Storage. Eller så finns det redan i minnet som en ArrayBuffer eller liknande rådatastruktur. Följande kod:

  • Skapar en push-ström med hjälp createPushStream()av .
  • Läser en .wav fil med hjälp fs.createReadStream av i demonstrationssyfte. Om du redan har ljuddata i ArrayBufferkan du hoppa direkt till att skriva innehållet till indataströmmen.
  • Skapar en ljudkonfiguration med hjälp av push-strömmen.
const fs = require('fs');
const sdk = require("microsoft-cognitiveservices-speech-sdk");
const speechConfig = sdk.SpeechConfig.fromSubscription("YourSpeechKey", "YourSpeechRegion");

function fromStream() {
    let pushStream = sdk.AudioInputStream.createPushStream();

    fs.createReadStream("YourAudioFile.wav").on('data', function(arrayBuffer) {
        pushStream.write(arrayBuffer.slice());
    }).on('end', function() {
        pushStream.close();
    });
 
    let audioConfig = sdk.AudioConfig.fromStreamInput(pushStream);
    let speechRecognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);
    speechRecognizer.recognizeOnceAsync(result => {
        console.log(`RECOGNIZED: Text=${result.text}`);
        speechRecognizer.close();
    });
}
fromStream();

Att använda en push-ström som indata förutsätter att ljuddata är en rå PCM-data (pulse-code modulation) som hoppar över alla rubriker. API:et fungerar fortfarande i vissa fall om huvudet inte hoppades över. För bästa resultat bör du överväga att implementera logik för att läsa av rubrikerna så att den fsbörjar i början av ljuddata.

Hantera fel

I föregående exempel hämtas endast den identifierade texten från egenskapen result.text . Om du vill hantera fel och andra svar måste du skriva kod för att hantera resultatet. Följande kod utvärderar egenskapen result.reason och:

  • Skriver ut igenkänningsresultatet: ResultReason.RecognizedSpeech.
  • Om det inte finns någon igenkänningsmatchning informerar den användaren: ResultReason.NoMatch.
  • Om ett fel påträffas skriver det ut felmeddelandet: ResultReason.Canceled.
switch (result.reason) {
    case sdk.ResultReason.RecognizedSpeech:
        console.log(`RECOGNIZED: Text=${result.text}`);
        break;
    case sdk.ResultReason.NoMatch:
        console.log("NOMATCH: Speech could not be recognized.");
        break;
    case sdk.ResultReason.Canceled:
        const cancellation = sdk.CancellationDetails.fromResult(result);
        console.log(`CANCELED: Reason=${cancellation.reason}`);

        if (cancellation.reason == sdk.CancellationReason.Error) {
            console.log(`CANCELED: ErrorCode=${cancellation.ErrorCode}`);
            console.log(`CANCELED: ErrorDetails=${cancellation.errorDetails}`);
            console.log("CANCELED: Did you set the speech resource key and region values?");
        }
        break;
    }

Använda kontinuerlig igenkänning

I föregående exempel används enkel igenkänning, som identifierar ett enda yttrande. Slutet på ett enskilt yttrande bestäms genom att lyssna efter tystnad i slutet eller tills högst 15 sekunders ljud bearbetas.

Däremot kan du använda kontinuerlig igenkänning när du vill styra när du ska sluta känna igen. Det kräver att du prenumererar på Recognizinghändelserna , Recognizedoch Canceled för att få igenkänningsresultatet. Om du vill stoppa igenkänningen måste du anropa stopContinuousRecognitionAsync. Här är ett exempel på hur kontinuerlig igenkänning utförs på en ljudinmatningsfil.

Börja med att definiera indata och initiera SpeechRecognizer:

const speechRecognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);

Prenumerera sedan på de händelser som skickas från SpeechRecognizer:

  • recognizing: Signal för händelser som innehåller mellanliggande igenkänningsresultat.
  • recognized: Signal för händelser som innehåller slutigenkänningsresultat, vilket indikerar ett lyckat igenkänningsförsök.
  • sessionStopped: Signal för händelser som anger slutet på en igenkänningssession (åtgärd).
  • canceled: Signal för händelser som innehåller avbrutna igenkänningsresultat. Dessa resultat indikerar ett igenkänningsförsök som avbröts till följd av en direkt avbokningsbegäran. Alternativt anger de ett transport- eller protokollfel.
speechRecognizer.recognizing = (s, e) => {
    console.log(`RECOGNIZING: Text=${e.result.text}`);
};

speechRecognizer.recognized = (s, e) => {
    if (e.result.reason == sdk.ResultReason.RecognizedSpeech) {
        console.log(`RECOGNIZED: Text=${e.result.text}`);
    }
    else if (e.result.reason == sdk.ResultReason.NoMatch) {
        console.log("NOMATCH: Speech could not be recognized.");
    }
};

speechRecognizer.canceled = (s, e) => {
    console.log(`CANCELED: Reason=${e.reason}`);

    if (e.reason == sdk.CancellationReason.Error) {
        console.log(`"CANCELED: ErrorCode=${e.errorCode}`);
        console.log(`"CANCELED: ErrorDetails=${e.errorDetails}`);
        console.log("CANCELED: Did you set the speech resource key and region values?");
    }

    speechRecognizer.stopContinuousRecognitionAsync();
};

speechRecognizer.sessionStopped = (s, e) => {
    console.log("\n    Session stopped event.");
    speechRecognizer.stopContinuousRecognitionAsync();
};

När allt har konfigurerats anropar du startContinuousRecognitionAsync för att börja känna igen:

speechRecognizer.startContinuousRecognitionAsync();

// Make the following call at some point to stop recognition:
// speechRecognizer.stopContinuousRecognitionAsync();

Ändra källspråket

En vanlig uppgift för taligenkänning är att ange indataspråket (eller källspråket). I följande exempel visas hur du ändrar indataspråket till italienska. Leta upp din SpeechConfig instans i koden och lägg till den här raden direkt under den:

speechConfig.speechRecognitionLanguage = "it-IT";

Egenskapen speechRecognitionLanguage förväntar sig en språkspråksformatsträng. Mer information finns i listan över tal till textspråk som stöds.

Språkidentifiering

Du kan använda språkidentifiering med tal till textigenkänning när du behöver identifiera språket i en ljudkälla och sedan transkribera det till text.

Ett fullständigt kodexempel finns i Språkidentifiering.

Använda en anpassad slutpunkt

Med anpassat tal kan du ladda upp dina egna data, testa och träna en anpassad modell, jämföra noggrannhet mellan modeller och distribuera en modell till en anpassad slutpunkt. I följande exempel visas hur du anger en anpassad slutpunkt.

var speechConfig = SpeechSDK.SpeechConfig.fromSubscription("YourSubscriptionKey", "YourServiceRegion");
speechConfig.endpointId = "YourEndpointId";
var speechRecognizer = new SpeechSDK.SpeechRecognizer(speechConfig);

Köra och använda en container

Talcontainrar tillhandahåller websocketbaserade frågeslutpunkts-API:er som nås via Speech SDK och Speech CLI. Som standard använder Speech SDK och Speech CLI den offentliga Speech-tjänsten. Om du vill använda containern måste du ändra initieringsmetoden. Använd en containervärd-URL i stället för nyckel och region.

Mer information om containrar finns i Värd-URL:er i Installera och köra Speech-containrar med Docker.

Referensdokumentationspaket (ladda ned) | Ytterligare exempel på GitHub |

I den här guiden lär du dig att känna igen och transkribera tal till text i realtid.

Installera Speech SDK och exempel

Lagringsplatsen Azure-Samples/cognitive-services-speech-sdk innehåller exempel skrivna i Objective-C för iOS och Mac. Välj en länk för att se installationsinstruktioner för varje exempel:

Mer information finns i Speech SDK för Objective-C-referensen.

Använda en anpassad slutpunkt

Med anpassat tal kan du ladda upp dina egna data, testa och träna en anpassad modell, jämföra noggrannhet mellan modeller och distribuera en modell till en anpassad slutpunkt. I följande exempel visas hur du anger en anpassad slutpunkt:

SPXSpeechConfiguration *speechConfig = [[SPXSpeechConfiguration alloc] initWithSubscription:"YourSubscriptionKey" region:"YourServiceRegion"];
speechConfig.endpointId = "YourEndpointId";
SPXSpeechRecognizer* speechRecognizer = [[SPXSpeechRecognizer alloc] init:speechConfig];

Köra och använda en container

Talcontainrar tillhandahåller websocketbaserade frågeslutpunkts-API:er som nås via Speech SDK och Speech CLI. Som standard använder Speech SDK och Speech CLI den offentliga Speech-tjänsten. Om du vill använda containern måste du ändra initieringsmetoden. Använd en containervärd-URL i stället för nyckel och region.

Mer information om containrar finns i Värd-URL:er i Installera och köra Speech-containrar med Docker.

Referensdokumentationspaket (ladda ned) | Ytterligare exempel på GitHub |

I den här guiden lär du dig att känna igen och transkribera tal till text i realtid.

Installera Speech SDK och exempel

Lagringsplatsen Azure-Samples/cognitive-services-speech-sdk innehåller exempel skrivna i Swift för iOS och Mac. Välj en länk för att se installationsinstruktioner för varje exempel:

Mer information finns i Speech SDK för Swift-referensen.

Använda en anpassad slutpunkt

Med anpassat tal kan du ladda upp dina egna data, testa och träna en anpassad modell, jämföra noggrannhet mellan modeller och distribuera en modell till en anpassad slutpunkt. I följande exempel visas hur du anger en anpassad slutpunkt:

let speechConfig = SPXSpeechConfiguration(subscription: "YourSubscriptionKey", region: "YourServiceRegion");
speechConfig.endpointId = "YourEndpointId";
let speechRecognizer = SPXSpeechRecognizer(speechConfiguration: speechConfig);

Köra och använda en container

Talcontainrar tillhandahåller websocketbaserade frågeslutpunkts-API:er som nås via Speech SDK och Speech CLI. Som standard använder Speech SDK och Speech CLI den offentliga Speech-tjänsten. Om du vill använda containern måste du ändra initieringsmetoden. Använd en containervärd-URL i stället för nyckel och region.

Mer information om containrar finns i Värd-URL:er i Installera och köra Speech-containrar med Docker.

Referensdokumentation Paket (PyPi) | Ytterligare exempel på GitHub |

I den här guiden lär du dig att känna igen och transkribera tal till text i realtid.

Skapa en talkonfiguration

Om du vill anropa Speech-tjänsten med hjälp av Speech SDK måste du skapa en SpeechConfig instans. Den här klassen innehåller information om din prenumeration, till exempel din talnyckel och tillhörande plats/region, slutpunkt, värd eller auktoriseringstoken.

  1. Skapa en SpeechConfig instans med hjälp av din talnyckel och plats/region.
  2. Skapa en Speech-resurs på Azure-portalen. Mer information finns i Skapa en resurs med flera tjänster.
speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion")

Du kan initiera SpeechConfig på några andra sätt:

  • Använd en slutpunkt och skicka in en Slutpunkt för Speech-tjänsten. En talnyckel eller auktoriseringstoken är valfri.
  • Använd en värd och skicka in en värdadress. En talnyckel eller auktoriseringstoken är valfri.
  • Använd en auktoriseringstoken med den associerade regionen/platsen.

Kommentar

Oavsett om du utför taligenkänning, talsyntes, översättning eller avsiktsigenkänning skapar du alltid en konfiguration.

Identifiera tal från en mikrofon

Om du vill känna igen tal med hjälp av enhetens mikrofon skapar du en SpeechRecognizer instans utan att skicka AudioConfigoch skickar speech_configsedan :

import azure.cognitiveservices.speech as speechsdk

def from_mic():
    speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion")
    speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config)

    print("Speak into your microphone.")
    result = speech_recognizer.recognize_once_async().get()
    print(result.text)

from_mic()

Om du vill använda en specifik ljudinmatningsenhet måste du ange enhets-ID:t i AudioConfigoch skicka det till SpeechRecognizer konstruktorns audio_config parameter. Mer information om hur du hämtar enhets-ID för din ljudinmatningsenhet finns i Välj en ljudinmatningsenhet med Speech SDK

Identifiera tal från en fil

Om du vill känna igen tal från en ljudfil i stället för att använda en mikrofon skapar du en AudioConfig instans och använder parametern filename :

import azure.cognitiveservices.speech as speechsdk

def from_file():
    speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion")
    audio_config = speechsdk.AudioConfig(filename="your_file_name.wav")
    speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_config)

    result = speech_recognizer.recognize_once_async().get()
    print(result.text)

from_file()

Hantera fel

I föregående exempel hämtas endast den identifierade texten från egenskapen result.text . Om du vill hantera fel och andra svar måste du skriva kod för att hantera resultatet. Följande kod utvärderar egenskapen result.reason och:

  • Skriver ut igenkänningsresultatet: speechsdk.ResultReason.RecognizedSpeech.
  • Om det inte finns någon igenkänningsmatchning informerar den användaren: speechsdk.ResultReason.NoMatch.
  • Om ett fel påträffas skriver det ut felmeddelandet: speechsdk.ResultReason.Canceled.
if result.reason == speechsdk.ResultReason.RecognizedSpeech:
    print("Recognized: {}".format(result.text))
elif result.reason == speechsdk.ResultReason.NoMatch:
    print("No speech could be recognized: {}".format(result.no_match_details))
elif result.reason == speechsdk.ResultReason.Canceled:
    cancellation_details = result.cancellation_details
    print("Speech Recognition canceled: {}".format(cancellation_details.reason))
    if cancellation_details.reason == speechsdk.CancellationReason.Error:
        print("Error details: {}".format(cancellation_details.error_details))
        print("Did you set the speech resource key and region values?")

Använda kontinuerlig igenkänning

I föregående exempel används enkel igenkänning, som identifierar ett enda yttrande. Slutet på ett enskilt yttrande bestäms genom att lyssna efter tystnad i slutet eller tills högst 15 sekunders ljud bearbetas.

Däremot använder du kontinuerlig igenkänning när du vill styra när du ska sluta känna igen. Du måste ansluta till EventSignal för att få igenkänningsresultatet. Om du vill stoppa igenkänningen måste du anropa stop_continuous_recognition() eller stop_continuous_recognition(). Här är ett exempel på hur kontinuerlig igenkänning utförs på en ljudinmatningsfil.

Börja med att definiera indata och initiera SpeechRecognizer:

audio_config = speechsdk.audio.AudioConfig(filename=weatherfilename)
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_config)

Skapa sedan en variabel för att hantera taligenkänningens tillstånd. Ange variabeln till False eftersom du i början av igenkänningen säkert kan anta att den inte är klar:

done = False

Skapa nu ett återanrop för att stoppa kontinuerlig igenkänning när evt tas emot. Ha dessa punkter i åtanke:

  • När evt tas emot skrivs meddelandet evt ut.
  • När evt har tagits emot anropas stop_continuous_recognition() för att stoppa igenkänningen.
  • Igenkänningstillståndet ändras till True.
def stop_cb(evt):
    print('CLOSING on {}'.format(evt))
    speech_recognizer.stop_continuous_recognition()
    nonlocal done
    done = True

Följande kodexempel visar hur du ansluter återanrop till händelser som skickas från SpeechRecognizer. Händelserna är:

  • recognizing: Signal för händelser som innehåller mellanliggande igenkänningsresultat.
  • recognized: Signal för händelser som innehåller slutigenkänningsresultat, vilket indikerar ett lyckat igenkänningsförsök.
  • session_started: Signal för händelser som indikerar starten av en igenkänningssession (åtgärd).
  • session_stopped: Signal för händelser som anger slutet på en igenkänningssession (åtgärd).
  • canceled: Signal för händelser som innehåller avbrutna igenkänningsresultat. Dessa resultat indikerar ett igenkänningsförsök som avbröts till följd av en direkt avbokningsbegäran. Alternativt anger de ett transport- eller protokollfel.
speech_recognizer.recognizing.connect(lambda evt: print('RECOGNIZING: {}'.format(evt)))
speech_recognizer.recognized.connect(lambda evt: print('RECOGNIZED: {}'.format(evt)))
speech_recognizer.session_started.connect(lambda evt: print('SESSION STARTED: {}'.format(evt)))
speech_recognizer.session_stopped.connect(lambda evt: print('SESSION STOPPED {}'.format(evt)))
speech_recognizer.canceled.connect(lambda evt: print('CANCELED {}'.format(evt)))

speech_recognizer.session_stopped.connect(stop_cb)
speech_recognizer.canceled.connect(stop_cb)

Med allt konfigurerat kan du anropa start_continuous_recognition():

speech_recognizer.start_continuous_recognition()
while not done:
    time.sleep(.5)

Ändra källspråket

En vanlig uppgift för taligenkänning är att ange indataspråket (eller källspråket). I följande exempel visas hur du ändrar indataspråket till tyska. Leta upp din SpeechConfig instans i koden och lägg till den här raden direkt under den:

speech_config.speech_recognition_language="de-DE"

speech_recognition_language är en parameter som tar en sträng som argument. Mer information finns i listan över tal till textspråk som stöds.

Språkidentifiering

Du kan använda språkidentifiering med tal till textigenkänning när du behöver identifiera språket i en ljudkälla och sedan transkribera det till text.

Ett fullständigt kodexempel finns i Språkidentifiering.

Använda en anpassad slutpunkt

Med anpassat tal kan du ladda upp dina egna data, testa och träna en anpassad modell, jämföra noggrannhet mellan modeller och distribuera en modell till en anpassad slutpunkt. I följande exempel visas hur du anger en anpassad slutpunkt.

speech_config = speechsdk.SpeechConfig(subscription="YourSubscriptionKey", region="YourServiceRegion")
speech_config.endpoint_id = "YourEndpointId"
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config)

Köra och använda en container

Talcontainrar tillhandahåller websocketbaserade frågeslutpunkts-API:er som nås via Speech SDK och Speech CLI. Som standard använder Speech SDK och Speech CLI den offentliga Speech-tjänsten. Om du vill använda containern måste du ändra initieringsmetoden. Använd en containervärd-URL i stället för nyckel och region.

Mer information om containrar finns i Värd-URL:er i Installera och köra Speech-containrar med Docker.

REST API för tal till text refererar | till REST API för tal till text för kort ljudreferens | Ytterligare exempel på GitHub

I den här guiden lär du dig att känna igen och transkribera tal till text i realtid.

Konvertera tal till text

Kör följande kommando i en kommandotolk. Infoga följande värden i kommandot:

  • Din prenumerationsnyckel för Speech-tjänsten.
  • Din Speech-tjänstregion.
  • Sökvägen för indataljudfiler. Du kan generera ljudfiler med text till tal.
curl --location --request POST 'https://INSERT_REGION_HERE.stt.speech.microsoft.com/speech/recognition/conversation/cognitiveservices/v1?language=en-US' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_AUDIO_FILE_PATH_HERE'

Du bör få ett svar med en JSON-brödtext som i följande exempel:

{
    "RecognitionStatus": "Success",
    "DisplayText": "My voice is my passport, verify me.",
    "Offset": 6600000,
    "Duration": 32100000
}

Mer information finns i rest-API-referensen för tal till text.

I den här guiden lär du dig att känna igen och transkribera tal till text i realtid.

Identifiera tal från en mikrofon

Anslut och slå på datorns mikrofon. Inaktivera alla appar som också kan använda mikrofonen. Vissa datorer har en inbyggd mikrofon, medan andra kräver konfiguration av en Bluetooth-enhet.

Nu är du redo att köra Speech CLI för att känna igen tal från mikrofonen. Från kommandoraden ändrar du till katalogen som innehåller den binära Speech CLI-filen. Kör följande kommando:

spx recognize --microphone

Kommentar

Speech CLI är som standard engelska. Du kan välja ett annat språk än tal till texttabell. Lägg --source de-DE till till för att känna igen tyskt tal.

Tala in i mikrofonen och du kan se transkription av dina ord i text i realtid. Speech CLI stoppas efter en tyst period eller när du väljer Ctrl+C.

Identifiera tal från en fil

Speech CLI kan känna igen tal i många filformat och naturliga språk. I det här exemplet kan du använda valfri .wav fil (16 KHz eller 8 KHz, 16-bitars och mono PCM) som innehåller engelskt tal. Eller om du vill ha ett snabbexempel laddar du ned filen whatstheweatherlike.wav och kopierar den till samma katalog som den binära Speech CLI-filen.

Använd följande kommando för att köra Speech CLI för att identifiera tal som finns i ljudfilen:

spx recognize --file whatstheweatherlike.wav

Kommentar

Speech CLI är som standard engelska. Du kan välja ett annat språk än tal till texttabell. Lägg --source de-DE till till för att känna igen tyskt tal.

Speech CLI visar en textavskrift av talet på skärmen.

Köra och använda en container

Talcontainrar tillhandahåller websocketbaserade frågeslutpunkts-API:er som nås via Speech SDK och Speech CLI. Som standard använder Speech SDK och Speech CLI den offentliga Speech-tjänsten. Om du vill använda containern måste du ändra initieringsmetoden. Använd en containervärd-URL i stället för nyckel och region.

Mer information om containrar finns i Värd-URL:er i Installera och köra Speech-containrar med Docker.

Nästa steg