Komma igång med tal-till-text

En av huvudfunktionerna i taltjänsten är möjligheten att känna igen och transkribera mänskligt tal (kallas ofta tal till text). I den här snabbstarten lär du dig att använda Speech SDK i dina appar och produkter för att utföra högkvalitativ tal-till-text-konvertering.

Hoppa till exempel på GitHub

Om du vill hoppa direkt till exempelkoden kan du gå till C#-snabbstartsexempel på GitHub.

Förutsättningar

Den här artikeln förutsätter att du har ett Azure-konto och en speech-tjänstprenumeration. Om du inte har något konto och en prenumeration kan du prova Speech-tjänsten utan kostnad.

Installera Speech SDK

Om du bara vill att paketnamnet ska komma igång kör du Install-Package Microsoft.CognitiveServices.Speech i NuGet-konsolen.

Plattformsspecifika installationsanvisningar finns på följande länkar:

• .NET Framework
• .NET Core
• Enhet
• UWP
• Xamarin

Skapa en talkonfiguration

Om du vill anropa Speech-tjänsten med hjälp av Speech SDK måste du skapa en SpeechConfig . Den här klassen innehåller information om din prenumeration, till exempel din nyckel och associerad plats/region, slutpunkt, värd eller auktoriseringstoken. Skapa en SpeechConfig med hjälp av din nyckel och plats/region. Se sidan Hitta nycklar och plats/region för att hitta ditt nyckel-plats-/regionpar.

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("<paste-your-speech-key-here>", "<paste-your-speech-location/region-here>");
    }
}

Det finns några andra sätt att initiera en SpeechConfig :

• Med en slutpunkt: skicka in en speech-tjänstslutpunkt. En nyckel eller auktoriseringstoken är valfri.
• Med en värd: skicka in en värdadress. En nyckel eller auktoriseringstoken är valfri.
• Med en auktoriseringstoken: skicka in en auktoriseringstoken och den associerade regionen/platsen.

Identifiera från mikrofon

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

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 recognizer = new SpeechRecognizer(speechConfig, audioConfig);

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

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("<paste-your-speech-key-here>", "<paste-your-speech-location/region-here>");
        await FromMic(speechConfig);
    }
}

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

Identifiera från 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 . Men när du skapar , AudioConfig i stället för att anropa , FromDefaultMicrophoneInput() anropar du och skickar FromWavFileInput() 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 recognizer = new SpeechRecognizer(speechConfig, audioConfig);

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

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("<paste-your-speech-key-here>", "<paste-your-speech-location/region-here>");
        await FromFile(speechConfig);
    }
}

Identifiera från minnes minnesström

I många användningsfall är det troligt att dina ljuddata kommer från bloblagring, eller på annat sätt redan finns i minnet som en byte[] eller liknande rådatastruktur. I följande exempel används en PushAudioInputStream för att identifiera tal, vilket i princip är en abstraherad minnesström. Exempelkoden gör följande:

• Skriver rådata för ljud (PCM) PushAudioInputStream till med hjälp av funktionen , som accepterar en Write() byte[] .
• Läser en fil i demonstrationssyfte, men om du redan har ljuddata i en kan du hoppa direkt till att skriva innehållet till .wav FileReader byte[] indataströmmen.
• Standardformatet är 16-bitars 16khz mono PCM. Om du vill anpassa formatet kan du skicka ett AudioStreamFormat -objekt till med CreatePushStream() 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 audioInputStream = AudioInputStream.CreatePushStream();
        using var audioConfig = AudioConfig.FromStreamInput(audioInputStream);
        using var recognizer = new SpeechRecognizer(speechConfig, audioConfig);

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

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

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("<paste-your-speech-key-here>", "<paste-your-speech-location/region-here>");
        await FromStream(speechConfig);
    }
}

Användning av en push-dataström som indata förutsätter att ljuddata är en rå PCM, t.ex. att hoppa över alla huvuden. API:et fungerar fortfarande i vissa fall om huvudet inte har hoppats över, men för bästa resultat bör du överväga att implementera logik för att läsa av rubrikerna så att startar i början av byte[] ljuddata.

Felhantering

Föregående exempel hämtar helt enkelt den identifierade texten från , men för att hantera fel och andra svar måste du skriva kod result.text 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 du användaren: ResultReason.NoMatch
• Om ett fel uppstår skriver du 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 update the speech key and location/region info?");
        }
        break;
}

Kontinuerlig igenkänning

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

Däremot används kontinuerlig igenkänning när du vill styra när igenkänningen ska sluta kännas igen. Det kräver att du prenumererar på Recognizing händelserna , och för att få Recognized Canceled 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 ljudindatafil.

Börja med att definiera indata och initiera ett SpeechRecognizer :

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

Skapa sedan en TaskCompletionSource<int> för att hantera taligenkänningens tillstånd.

var stopRecognition = new TaskCompletionSource<int>();

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

• Recognizing: Signal för händelser som innehåller resultat från mellanliggande igenkänning.
• Recognized: Signal för händelser som innehåller resultat av slutlig igenkänning (som anger ett lyckat igenkänningsförsök).
• SessionStopped: Signal för händelser som anger slutet av en igenkänningssession (åtgärd).
• Canceled: Signal för händelser som innehåller annullerade igenkänningsresultat (som anger ett igenkänningsförsök som avbröts som ett resultat eller en begäran om direkt annullering eller, alternativt, ett transport- eller protokollfel).

recognizer.Recognizing += (s, e) =>
{
    Console.WriteLine($"RECOGNIZING: Text={e.Result.Text}");
};

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

recognizer.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 update the speech key and location/region info?");
    }

    stopRecognition.TrySetResult(0);
};

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

När allt har ställts in kan StartContinuousRecognitionAsync du anropa för att börja känna igen.

await recognizer.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 recognizer.StopContinuousRecognitionAsync();

Dikteringsläge

När du använder kontinuerlig igenkänning kan du aktivera dikteringsbearbetning med hjälp av motsvarande "aktivera diktering"-funktion. Det här läget gör att talkonfigurationsinstansen tolkar ordbeskrivningar av meningsstrukturer, till exempel skiljetecken. Till exempel skulle ta upp "Bor du i staden frågetecken" tolkas som texten "Bor du i staden?".

Om du vill aktivera dikteringsläge använder EnableDictation du metoden på din SpeechConfig .

speechConfig.EnableDictation();

Ändra källspråk

En vanlig uppgift för taligenkänning är att ange indataspråket (eller källan). Låt oss ta en titt på hur du skulle ändra indataspråket till italienska. Leta upp din i koden SpeechConfig och lägg sedan till den här raden direkt under den.

speechConfig.SpeechRecognitionLanguage = "it-IT";

Egenskapen SpeechRecognitionLanguage förväntar sig en formatsträng med språkspråk. Du kan ange ett värde i kolumnen Språk i listan över språk som stöds.

Förbättra igenkänningsprecisionen

Fraslistor används för att identifiera kända fraser i ljuddata, till exempel en persons namn eller en specifik plats. Genom att tillhandahålla en lista över fraser kan du förbättra noggrannheten för taligenkänning.

Om du till exempel har kommandot "Flytta till" och ett möjligt mål för "Ward" som kan sägas, kan du lägga till en post i "Flytta till Ward". Att lägga till en fras ökar sannolikheten att när ljudet känns igen att "Flytta till Ward" känns igen i stället för "Flytta mot"

Enkla ord eller fullständiga fraser kan läggas till i en fraslista. Under igenkänning används en post i en fraslista för att öka igenkänningen av orden och fraserna i listan även när posterna visas mitt i yttrandena.

Om du vill använda en fraslista skapar du PhraseListGrammar först ett -objekt och lägger sedan till specifika ord och fraser med AddPhrase .

Eventuella ändringar som PhraseListGrammar börjar gälla vid nästa igenkänning eller efter en återanslutning till Speech-tjänsten.

var phraseList = PhraseListGrammar.FromRecognizer(recognizer);
phraseList.AddPhrase("Supercalifragilisticexpialidocious");

Om du behöver rensa fraslistan:

phraseList.Clear();

Andra alternativ för att förbättra igenkänningsprecisionen

Fraslistor är bara ett alternativ för att förbättra igenkänningsprecisionen. Du kan även:

• Förbättra noggrannheten med anpassat tal
• Förbättra noggrannheten med klientmodeller

En av huvudfunktionerna i taltjänsten är möjligheten att känna igen och transkribera mänskligt tal (kallas ofta tal till text). I den här snabbstarten lär du dig att använda Speech SDK i dina appar och produkter för att utföra högkvalitativ tal-till-text-konvertering.

Hoppa till exempel på GitHub

Om du vill hoppa direkt till exempelkoden kan du gå till C++-snabbstartsexempel på GitHub.

Förutsättningar

Den här artikeln förutsätter att du har ett Azure-konto och en speech-tjänstprenumeration. Om du inte har något konto och en prenumeration kan du prova Speech-tjänsten utan kostnad.

Installera Speech SDK

Innan du kan göra något måste du installera Speech SDK. Följ anvisningarna nedan beroende på din plattform:

• Linux
• Macos
• Windows

Skapa en talkonfiguration

Om du vill anropa Speech-tjänsten med hjälp av Speech SDK måste du skapa en SpeechConfig . Den här klassen innehåller information om din prenumeration, till exempel din nyckel och associerad plats/region, slutpunkt, värd eller auktoriseringstoken. Skapa en SpeechConfig med hjälp av din nyckel och region. Se sidan Hitta nycklar och plats/region för att hitta ditt nyckel-plats-/regionpar.

using namespace std;
using namespace Microsoft::CognitiveServices::Speech;

auto config = SpeechConfig::FromSubscription("<paste-your-speech-key-here>", "<paste-your-speech-location/region-here>");

Det finns några andra sätt att initiera en SpeechConfig :

• Med en slutpunkt: skicka in en speech-tjänstslutpunkt. En nyckel eller auktoriseringstoken är valfri.
• Med en värd: skicka in en värdadress. En nyckel eller auktoriseringstoken är valfri.
• Med en auktoriseringstoken: skicka en auktoriseringstoken och den associerade regionen.

Identifiera från mikrofon

Om du vill känna igen tal med enhetens mikrofon skapar du en med AudioConfig hjälp av FromDefaultMicrophoneInput() . Initiera sedan en SpeechRecognizer , och skicka din och audioConfig config .

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

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

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

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

Identifiera från 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 . Men när du skapar , AudioConfig i stället för att anropa , FromDefaultMicrophoneInput() anropar du och skickar FromWavFileInput() filsökvägen.

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

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

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

Identifiera tal

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

Startigenkänning

Vid start identifierar igenkänningen asynkront ett enda uttryck. Slutet på ett enda uttryck bestäms genom att lyssna efter tystnad i slutet eller tills högst 15 sekunders ljud bearbetas. Här är ett exempel på asynkron startigenkänning med hjälp av RecognizeOnceAsync :

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

Du måste skriva kod för att hantera resultatet. I det här exemplet utvärderas result->Reason :

• Skriver ut igenkänningsresultatet: ResultReason::RecognizedSpeech
• Om det inte finns någon igenkänningsmatchning informerar du användaren: ResultReason::NoMatch
• Om ett fel uppstår skriver du 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 update the speech key and location/region info?" << std::endl;
            }
        }
        break;
    default:
        break;
}

Kontinuerlig igenkänning

Kontinuerlig igenkänning är lite mer inblandat än vid början av igenkänningen. Det kräver att du prenumererar på Recognizing händelserna , och för att få Recognized Canceled 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 ljudindatafil.

Vi börjar med att definiera indata och initiera ett SpeechRecognizer :

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

Nu ska vi skapa en variabel för att hantera taligenkänningens tillstånd. Till att börja med deklarerar vi en , eftersom vi i början av igenkänningen kan anta promise<void> att den inte är färdig.

promise<void> recognitionEnd;

Vi prenumererar på de händelser som skickas från SpeechRecognizer .

• Recognizing: Signal för händelser som innehåller resultat från mellanliggande igenkänning.
• Recognized: Signal för händelser som innehåller resultat av slutlig igenkänning (som anger ett lyckat igenkänningsförsök).
• SessionStopped: Signal för händelser som anger slutet av en igenkänningssession (åtgärd).
• Canceled: Signal för händelser som innehåller annullerade igenkänningsresultat (som anger ett igenkänningsförsök som avbröts som ett resultat eller en begäran om direkt annullering eller, alternativt, ett transport- eller protokollfel).

recognizer->Recognizing.Connect([](const SpeechRecognitionEventArgs& e)
    {
        cout << "Recognizing:" << e.Result->Text << std::endl;
    });

recognizer->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;
        }
    });

recognizer->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 update the speech key and location/region info?" << std::endl;

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

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

När allt har ställts in kan vi anropa StopContinuousRecognitionAsync .

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

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

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

Dikteringsläge

När du använder kontinuerlig igenkänning kan du aktivera dikteringsbearbetning med hjälp av motsvarande "aktivera diktering"-funktion. Det här läget gör att talkonfigurationsinstansen tolkar ordbeskrivningar av meningsstrukturer, till exempel skiljetecken. Till exempel skulle ta upp "Bor du i staden frågetecken" tolkas som texten "Bor du i staden?".

Om du vill aktivera dikteringsläge använder EnableDictation du metoden på din SpeechConfig .

config->EnableDictation();

Ändra källspråk

En vanlig uppgift för taligenkänning är att ange indataspråket (eller källan). Låt oss ta en titt på hur du skulle ändra indataspråket till tyska. Leta upp din i koden SpeechConfig och lägg sedan till den här raden direkt under den.

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

SetSpeechRecognitionLanguage är en parameter som tar en sträng som argument. Du kan ange ett värde i listan över språk som stöds.

Förbättra igenkänningsprecisionen

Fraslistor används för att identifiera kända fraser i ljuddata, till exempel en persons namn eller en specifik plats. Genom att tillhandahålla en lista över fraser kan du förbättra noggrannheten för taligenkänning.

Om du till exempel har kommandot "Flytta till" och ett möjligt mål för "Ward" som kan sägas, kan du lägga till en post i "Flytta till Ward". Att lägga till en fras ökar sannolikheten att när ljudet känns igen att "Flytta till Ward" känns igen i stället för "Flytta mot"

Enkla ord eller fullständiga fraser kan läggas till i en fraslista. Under igenkänning används en post i en fraslista för att öka igenkänningen av orden och fraserna i listan även när posterna visas mitt i yttrandena.

Om du vill använda en fraslista skapar du PhraseListGrammar först ett -objekt och lägger sedan till specifika ord och fraser med AddPhrase .

Eventuella ändringar som PhraseListGrammar börjar gälla vid nästa igenkänning eller efter en återanslutning till Speech-tjänsten.

auto phraseListGrammar = PhraseListGrammar::FromRecognizer(recognizer);
phraseListGrammar->AddPhrase("Supercalifragilisticexpialidocious");

Om du behöver rensa fraslistan:

phraseListGrammar->Clear();

Andra alternativ för att förbättra igenkänningsprecisionen

Fraslistor är bara ett alternativ för att förbättra igenkänningsprecisionen. Du kan även:

• Förbättra noggrannheten med anpassat tal
• Förbättra noggrannheten med klientmodeller

En av huvudfunktionerna i Speech Service är möjligheten att känna igen och transkribera mänskligt tal (kallas ofta tal till text). I den här snabbstarten lär du dig hur du använder Speech SDK i dina appar och produkter för att utföra tal-till-text-konvertering av hög kvalitet.

Gå vidare till exempel på GitHub

Om du vill hoppa direkt till exempelkoden kan du gå till Go-snabbstartsexempel på GitHub.

Förutsättningar

Den här artikeln förutsätter att du har ett Azure-konto och en prenumeration på Speech-tjänsten. Om du inte har ett konto och en prenumeration kan du prova Speech-tjänsten utan kostnad.

Installera Speech SDK

Innan du kan göra något måste du installera Speech SDK för Go.

Tal till text från mikrofon

Använd följande kodexempel för att köra taligenkänning från din standardenhets mikrofon. Ersätt variablerna subscription och med din region talnyckel och plats/region. På sidan Hitta nycklar och plats/region hittar du ditt nyckel-plats-/regionpar. Om du kör skriptet startas en igenkänningssession på din standardmi mikrofon och utdatatext.

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)
}

func main() {
    subscription :=  "<paste-your-speech-key-here>"
    region := "<paste-your-speech-location/region-here>"

    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

Se referensdokumenten för detaljerad information om SpeechConfig SpeechRecognizer klasserna och .

Tal till text från ljudfil

Använd följande exempel för att köra taligenkänning från en ljudfil. Ersätt variablerna subscription och med din region talnyckel och plats/region. På sidan Hitta nycklar och plats/region hittar du ditt nyckel-plats-/regionpar. Ersätt dessutom variabeln med file en sökväg till en WAV-fil. Om du kör skriptet kan du identifiera tal från filen och mata ut textresultatet.

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 :=  "<paste-your-speech-key-here>"
    region := "<paste-your-speech-location/region-here>"
    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

Se referensdokumenten för detaljerad information om SpeechConfig SpeechRecognizer klasserna och .

En av huvudfunktionerna i taltjänsten är möjligheten att känna igen och transkribera mänskligt tal (kallas ofta tal till text). I den här snabbstarten lär du dig att använda Speech SDK i dina appar och produkter för att utföra högkvalitativ tal-till-text-konvertering.

Hoppa till exempel på GitHub

Om du vill hoppa direkt till exempelkoden kan du gå till Snabbstartsexempel för Java på GitHub.

Förutsättningar

Den här artikeln förutsätter att du har ett Azure-konto och en speech-tjänstprenumeration. Om du inte har något konto och en prenumeration kan du prova Speech-tjänsten utan kostnad.

Installera Speech SDK

Innan du kan göra något måste du installera Speech SDK. Följ anvisningarna nedan beroende på din plattform:

• Java Runtime
• Android

Skapa en talkonfiguration

Om du vill anropa Speech-tjänsten med hjälp av Speech SDK måste du skapa en SpeechConfig . Den här klassen innehåller information om din prenumeration, till exempel din nyckel och associerad plats/region, slutpunkt, värd eller auktoriseringstoken. Skapa en SpeechConfig med hjälp av din nyckel och plats/region. Se sidan Hitta nycklar och plats/region för att hitta ditt nyckel-plats-/regionpar.

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>");
    }
}

Det finns några andra sätt att initiera en SpeechConfig :

• Med en slutpunkt: skicka in en speech-tjänstslutpunkt. En nyckel eller auktoriseringstoken är valfri.
• Med en värd: skicka in en värdadress. En nyckel eller auktoriseringstoken är valfri.
• Med en auktoriseringstoken: skicka en auktoriseringstoken och den associerade regionen.

Identifiera från mikrofon

Om du vill känna igen tal med enhetens mikrofon skapar du en med AudioConfig hjälp av fromDefaultMicrophoneInput() . Initiera sedan en SpeechRecognizer , och skicka din och audioConfig 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 recognizer = new SpeechRecognizer(speechConfig, audioConfig);

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

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

Identifiera från 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 . Men när du skapar anropar AudioConfig och skickar du fromDefaultMicrophoneInput() filsökvägen i fromWavFileInput() stället för att anropa .

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 recognizer = new SpeechRecognizer(speechConfig, audioConfig);
        
        Future<SpeechRecognitionResult> task = recognizer.recognizeOnceAsync();
        SpeechRecognitionResult result = task.get();
        System.out.println("RECOGNIZED: Text=" + result.getText());
    }
}

Felhantering

I föregående exempel hämtar du helt enkelt den identifierade texten med , men för att hantera fel och andra svar måste du skriva kod result.getText() 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 du användaren: ResultReason.NoMatch
• Om ett fel uppstår skriver du 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 update the subscription info?");
            }
        }
        break;
}

Kontinuerlig igenkänning

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

Däremot används kontinuerlig igenkänning när du vill styra när igenkänningen ska sluta kännas igen. Det kräver att du prenumererar på recognizing händelserna , och för att få recognized canceled 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 ljudindatafil.

Vi börjar med att definiera indata och initiera ett SpeechRecognizer :

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

Nu ska vi skapa en variabel för att hantera taligenkänningens tillstånd. Till att börja med deklarerar vi en Semaphore i klassomfånget.

private static Semaphore stopTranslationWithFileSemaphore;

Vi prenumererar på de händelser som skickas från SpeechRecognizer .

• recognizing: Signal för händelser som innehåller resultat från mellanliggande igenkänning.
• recognized: Signal för händelser som innehåller resultat av slutlig igenkänning (som anger ett lyckat igenkänningsförsök).
• sessionStopped: Signal för händelser som anger slutet av en igenkänningssession (åtgärd).
• canceled: Signal för händelser som innehåller annullerade igenkänningsresultat (som anger ett igenkänningsförsök som avbröts som ett resultat eller en begäran om direkt annullering eller, alternativt, ett transport- eller protokollfel).

// First initialize the semaphore.
stopTranslationWithFileSemaphore = new Semaphore(0);

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

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

recognizer.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 update the subscription info?");
    }

    stopTranslationWithFileSemaphore.release();
});

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

När allt har ställts in kan vi anropa startContinuousRecognitionAsync .

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

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

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

Dikteringsläge

När du använder kontinuerlig igenkänning kan du aktivera dikteringsbearbetning med hjälp av motsvarande "aktivera diktering"-funktion. Det här läget gör att talkonfigurationsinstansen tolkar ordbeskrivningar av meningsstrukturer, till exempel skiljetecken. Till exempel skulle ta upp "Bor du i staden frågetecken" tolkas som texten "Bor du i staden?".

Om du vill aktivera dikteringsläge använder enableDictation du metoden på din SpeechConfig .

config.enableDictation();

Ändra källspråk

En vanlig uppgift för taligenkänning är att ange indataspråket (eller källan). Låt oss ta en titt på hur du skulle ändra indataspråket till franska. Leta upp din i koden SpeechConfig och lägg sedan till den här raden direkt under den.

config.setSpeechRecognitionLanguage("fr-FR");

setSpeechRecognitionLanguage är en parameter som tar en sträng som argument. Du kan ange ett värde i listan över språk som stöds.

Förbättra igenkänningsprecisionen

Fraslistor används för att identifiera kända fraser i ljuddata, till exempel en persons namn eller en specifik plats. Genom att tillhandahålla en lista över fraser kan du förbättra noggrannheten för taligenkänning.

Om du till exempel har kommandot "Flytta till" och ett möjligt mål för "Ward" som kan sägas, kan du lägga till en post i "Flytta till Ward". Att lägga till en fras ökar sannolikheten att när ljudet känns igen att "Flytta till Ward" känns igen i stället för "Flytta mot"

Enkla ord eller fullständiga fraser kan läggas till i en fraslista. Under igenkänning används en post i en fraslista för att öka igenkänningen av orden och fraserna i listan även när posterna visas mitt i yttrandena.

Om du vill använda en fraslista skapar du PhraseListGrammar först ett -objekt och lägger sedan till specifika ord och fraser med AddPhrase .

Eventuella ändringar som PhraseListGrammar börjar gälla vid nästa igenkänning eller efter en återanslutning till Speech-tjänsten.

PhraseListGrammar phraseList = PhraseListGrammar.fromRecognizer(recognizer);
phraseList.addPhrase("Supercalifragilisticexpialidocious");

Om du behöver rensa fraslistan:

phraseList.clear();

Andra alternativ för att förbättra igenkänningsprecisionen

Fraslistor är bara ett alternativ för att förbättra igenkänningsprecisionen. Du kan även:

• Förbättra noggrannheten med anpassat tal
• Förbättra noggrannheten med klientmodeller

En av huvudfunktionerna i taltjänsten är möjligheten att känna igen och transkribera mänskligt tal (kallas ofta tal till text). I den här snabbstarten lär du dig att använda Speech SDK i dina appar och produkter för att utföra högkvalitativ tal-till-text-konvertering.

Hoppa till exempel på GitHub

Om du vill hoppa direkt till exempelkoden kan du gå till Snabbstartsexempel för JavaScript på GitHub.

Du kan också läsa React för att lära dig hur du använder Speech SDK i en webbläsarbaserad miljö.

Förutsättningar

Den här artikeln förutsätter att du har ett Azure-konto och en speech-tjänstprenumeration. Om du inte har något konto och en prenumeration kan du prova Speech-tjänsten utan kostnad.

Installera Speech SDK

Innan du kan göra något måste du installera Speech SDK för Node.js. Om du bara vill att paketnamnet ska installeras kör du npm install microsoft-cognitiveservices-speech-sdk . Guidade installationsanvisningar finns i artikeln Kom igång.

Använd följande instruktion require för att importera SDK:n.

const sdk = require("microsoft-cognitiveservices-speech-sdk");

Mer information om require finns i dokumentationen om att kräva.

Skapa en talkonfiguration

Om du vill anropa Speech-tjänsten med hjälp av Speech SDK måste du skapa en SpeechConfig . Den här klassen innehåller information om din prenumeration, till exempel din nyckel och associerad plats/region, slutpunkt, värd eller auktoriseringstoken. Skapa en SpeechConfig med hjälp av din nyckel och plats/region. Se sidan Hitta nycklar och plats/region för att hitta ditt nyckel-plats-/regionpar.

const speechConfig = sdk.SpeechConfig.fromSubscription("<paste-your-speech-key-here>", "<paste-your-speech-location/region-here>");

Det finns några andra sätt att initiera en SpeechConfig :

• Med en slutpunkt: skicka in en speech-tjänstslutpunkt. En nyckel eller auktoriseringstoken är valfri.
• Med en värd: skicka in en värdadress. En nyckel eller auktoriseringstoken är valfri.
• Med en auktoriseringstoken: skicka in en auktoriseringstoken och den associerade platsen/regionen.

Identifiera från mikrofon (endast webbläsare)

Igenkänning av tal från en mikrofon stöds inte i Node.js, och stöds endast i en webbläsarbaserad JavaScript-miljö. Se React på GitHub för att se tal till text från mikrofonimplementering.

Identifiera från fil

Om du vill känna igen tal från en ljudfil skapar du AudioConfig en med vilken ett fromWavFileInput() -objekt Buffer accepteras. Initiera sedan en SpeechRecognizer , och skicka din och audioConfig speechConfig .

const fs = require('fs');
const sdk = require("microsoft-cognitiveservices-speech-sdk");
const speechConfig = sdk.SpeechConfig.fromSubscription("<paste-your-speech-key-here>", "<paste-your-speech-location/region-here>");

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

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

Identifiera från minnes minnesström

I många användningsfall är det troligt att dina ljuddata kommer från bloblagring, eller på annat sätt redan finns i minnet som en ArrayBuffer eller liknande rådatastruktur. Följande kod:

• Skapar en push-dataström med hjälp av createPushStream() .
• Läser en fil i demonstrationssyfte, men om du redan har ljuddata i en kan du gå direkt till att skriva innehållet till .wav fs.createReadStream ArrayBuffer indataströmmen.
• Skapar en ljudkonfiguration med push-dataströmmen.

const fs = require('fs');
const sdk = require("microsoft-cognitiveservices-speech-sdk");
const speechConfig = sdk.SpeechConfig.fromSubscription("<paste-your-speech-key-here>", "<paste-your-speech-location/region-here>");

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 recognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);
    recognizer.recognizeOnceAsync(result => {
        console.log(`RECOGNIZED: Text=${result.text}`);
        recognizer.close();
    });
}
fromStream();

Användning av en push-dataström som indata förutsätter att ljuddata är en rå PCM, t.ex. att hoppa över alla huvuden. API:et fungerar fortfarande i vissa fall om huvudet inte har hoppats över, men för bästa resultat bör du överväga att implementera logik för att läsa av rubrikerna så att startar i början av fs ljuddata.

Felhantering

Föregående exempel hämtar helt enkelt den identifierade texten från , men för att hantera fel och andra svar måste du skriva kod result.text 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 du användaren: ResultReason.NoMatch
• Om ett fel uppstår skriver du 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 = 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 update the key and location/region info?");
        }
        break;
    }

Kontinuerlig igenkänning

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

Däremot används kontinuerlig igenkänning när du vill styra när igenkänningen ska sluta kännas igen. Det kräver att du prenumererar på Recognizing händelserna , och för att få Recognized Canceled 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 ljudindatafil.

Börja med att definiera indata och initiera ett SpeechRecognizer :

const recognizer = 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 resultat från mellanliggande igenkänning.
• recognized: Signal för händelser som innehåller resultat av slutlig igenkänning (som anger ett lyckat igenkänningsförsök).
• sessionStopped: Signal för händelser som anger slutet av en igenkänningssession (åtgärd).
• canceled: Signal för händelser som innehåller annullerade igenkänningsresultat (som anger ett igenkänningsförsök som avbröts som ett resultat eller en begäran om direkt annullering eller, alternativt, ett transport- eller protokollfel).

recognizer.recognizing = (s, e) => {
    console.log(`RECOGNIZING: Text=${e.result.text}`);
};

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

recognizer.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 update the key and location/region info?");
    }

    recognizer.stopContinuousRecognitionAsync();
};

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

När allt har ställts in kan startContinuousRecognitionAsync du anropa för att börja känna igen.

recognizer.startContinuousRecognitionAsync();

// make the following call at some point to stop recognition.
// recognizer.stopContinuousRecognitionAsync();

Dikteringsläge

När du använder kontinuerlig igenkänning kan du aktivera dikteringsbearbetning med hjälp av motsvarande "aktivera diktering"-funktion. Det här läget gör att talkonfigurationsinstansen tolkar ordbeskrivningar av meningsstrukturer, till exempel skiljetecken. Till exempel skulle ta upp "Bor du i staden frågetecken" tolkas som texten "Bor du i staden?".

Om du vill aktivera dikteringsläge använder enableDictation du metoden på din SpeechConfig .

speechConfig.enableDictation();

Ändra källspråk

En vanlig uppgift för taligenkänning är att ange indataspråket (eller källan). Låt oss ta en titt på hur du skulle ändra indataspråket till italienska. Leta upp din i koden SpeechConfig och lägg sedan till den här raden direkt under den.

speechConfig.speechRecognitionLanguage = "it-IT";

Egenskapen speechRecognitionLanguage förväntar sig en formatsträng med språkspråk. Du kan ange ett värde i kolumnen Språk i listan över språk som stöds.

Förbättra igenkänningsprecisionen

Fraslistor används för att identifiera kända fraser i ljuddata, till exempel en persons namn eller en specifik plats. Genom att tillhandahålla en lista över fraser kan du förbättra noggrannheten för taligenkänning.

Om du till exempel har kommandot "Flytta till" och ett möjligt mål för "Ward" som kan sägas, kan du lägga till en post i "Flytta till Ward". Att lägga till en fras ökar sannolikheten att när ljudet känns igen att "Flytta till Ward" känns igen i stället för "Flytta mot"

Enkla ord eller fullständiga fraser kan läggas till i en fraslista. Under igenkänning används en post i en fraslista för att öka igenkänningen av orden och fraserna i listan även när posterna visas mitt i yttrandena.

Om du vill använda en fraslista skapar du PhraseListGrammar först ett -objekt och lägger sedan till specifika ord och fraser med addPhrase .

Eventuella ändringar som PhraseListGrammar börjar gälla vid nästa igenkänning eller efter en återanslutning till Speech-tjänsten.

const phraseList = sdk.PhraseListGrammar.fromRecognizer(recognizer);
phraseList.addPhrase("Supercalifragilisticexpialidocious");

Om du behöver rensa fraslistan:

phraseList.clear();

Andra alternativ för att förbättra igenkänningsprecisionen

Fraslistor är bara ett alternativ för att förbättra igenkänningsprecisionen. Du kan även:

• Förbättra noggrannheten med anpassat tal
• Förbättra noggrannheten med klientmodeller

En av huvudfunktionerna i Taltjänsten är möjligheten att känna igen och transkribera mänskligt tal (kallas ofta tal till text). I det här exemplet får du lära dig hur du använder Speech SDK i dina appar och produkter för att utföra konvertering av tal till text av hög kvalitet.

React exempel på GitHub

Gå till React på GitHub för att lära dig hur du använder Speech SDK i en webbläsarbaserad JavaScript-miljö. Det här exemplet visar designmönsterexempel för utbyte och hantering av autentiseringstoken, samt avbildning av ljud från en mikrofon eller fil för tal-till-text-konvertering.

Dessutom kan de designmönster som används i Node.js snabbstart också användas i en webbläsarmiljö.

Du kan transkribera tal till text med hjälp av Speech SDK för Swift och Objective-C.

Förutsättningar

I följande exempel förutsätts att du har ett Azure-konto och en prenumeration på Speech-tjänsten. Om du inte har ett konto och en prenumeration kan du prova Speech-tjänsten utan kostnad.

Installera Speech SDK och exempel

Den Cognitive Services Speech SDK innehåller exempel skrivna i Swift och Objective-C för iOS och Mac. Klicka på en länk om du vill se installationsanvisningar för varje exempel:

• Identifiera tal från en mikrofon i Objective-C på macOS
• Identifiera tal i Swift på macOS
• Identifiera tal i Objective-C på iOS
• Identifiera tal i Swift på iOS
• Ytterligare exempel för Objective-C på iOS

Vi tillhandahåller också en Speech SDK online för Objective-C-referens.

En av huvudfunktionerna i taltjänsten är möjligheten att känna igen och transkribera mänskligt tal (kallas ofta tal till text). I den här snabbstarten lär du dig att använda Speech SDK i dina appar och produkter för att utföra högkvalitativ tal-till-text-konvertering.

Hoppa till exempel på GitHub

Om du vill hoppa direkt till exempelkoden kan du gå till Python-snabbstartsexempel på GitHub.

Förutsättningar

Den här artikeln förutsätter:

• Du har ett Azure-konto och en speech-tjänstprenumeration. Om du inte har kontot och prenumerationen – prova Speech-tjänsten utan kostnad.

Installera och importera Speech SDK

Innan du kan göra något måste du installera Speech SDK.

pip install azure-cognitiveservices-speech

Om du använder macOS och får installationsproblem kan du behöva köra det här kommandot först.

python3 -m pip install --upgrade pip

När Speech SDK har installerats importerar du det till Python-projektet.

import azure.cognitiveservices.speech as speechsdk

Skapa en talkonfiguration

Om du vill anropa Speech-tjänsten med hjälp av Speech SDK måste du skapa en SpeechConfig . Den här klassen innehåller information om din prenumeration, till exempel din nyckel och associerad plats/region, slutpunkt, värd eller auktoriseringstoken. Skapa en SpeechConfig med hjälp av din nyckel och plats/region. Se sidan Hitta nycklar och plats/region för att hitta ditt nyckel-plats-/regionpar.

speech_config = speechsdk.SpeechConfig(subscription="<paste-your-speech-key-here>", region="<paste-your-speech-location/region-here>")

Det finns några andra sätt att initiera en SpeechConfig :

• Med en slutpunkt: skicka in en speech-tjänstslutpunkt. En nyckel eller auktoriseringstoken är valfri.
• Med en värd: skicka in en värdadress. En nyckel eller auktoriseringstoken är valfri.
• Med en auktoriseringstoken: skicka en auktoriseringstoken och den associerade regionen.

Identifiera från mikrofon

Om du vill känna igen tal med enhetens mikrofon skapar du helt enkelt en utan att skicka en SpeechRecognizer AudioConfig och skickar speech_config .

import azure.cognitiveservices.speech as speechsdk

def from_mic():
    speech_config = speechsdk.SpeechConfig(subscription="<paste-your-speech-key-here>", region="<paste-your-speech-location/region-here>")
    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 enhet för ljudinspelning måste du ange enhets-ID:t i en och skicka det till AudioConfig SpeechRecognizer konstruktorns audio_config parameter. Lär dig hur du hämtar enhets-ID:t för din enhet för ljudinspelning.

Identifiera från fil

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

import azure.cognitiveservices.speech as speechsdk

def from_file():
    speech_config = speechsdk.SpeechConfig(subscription="<paste-your-speech-key-here>", region="<paste-your-speech-location/region-here>")
    audio_input = speechsdk.AudioConfig(filename="your_file_name.wav")
    speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_input)
    
    result = speech_recognizer.recognize_once_async().get()
    print(result.text)

from_file()

Felhantering

Föregående exempel hämtar helt enkelt den identifierade texten från , men för att hantera fel och andra svar måste du skriva kod result.text 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 du användaren: speechsdk.ResultReason.NoMatch
• Om ett fel uppstår skriver du 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))

Kontinuerlig igenkänning

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

Däremot används kontinuerlig igenkänning när du vill styra när igenkänningen ska sluta kännas igen. Det kräver att du ansluter till för att få igenkänningsresultatet och för att stoppa igenkänningen måste du EventSignal anropa stop_continuous_recognition() eller stop_continuous_recognition(). Här är ett exempel på hur kontinuerlig igenkänning utförs på en ljudindatafil.

Vi börjar med att definiera indata och initiera ett SpeechRecognizer :

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

Nu ska vi skapa en variabel för att hantera taligenkänningens tillstånd. Vi börjar med att ange det här till , eftersom vi i början av igenkänningen kan anta False att det inte är klart.

done = False

Nu ska vi skapa ett återanrop för att stoppa kontinuerlig igenkänning när en evt tas emot. Det finns några saker att tänka på.

• När evt ett tas emot evt skrivs meddelandet ut.
• När en 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

Det här kodexe exemplet visar hur du ansluter återanrop till händelser som skickas från SpeechRecognizer .

• recognizing: Signal för händelser som innehåller resultat från mellanliggande igenkänning.
• recognized: Signal för händelser som innehåller resultat av slutlig igenkänning (som anger ett lyckat igenkänningsförsök).
• session_started: Signal för händelser som anger starten av en igenkänningssession (åtgärd).
• session_stopped: Signal för händelser som anger slutet av en igenkänningssession (åtgärd).
• canceled: Signal för händelser som innehåller annullerade igenkänningsresultat (som anger ett igenkänningsförsök som avbröts som ett resultat eller en begäran om direkt annullering eller, alternativt, 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)

När allt har ställts in kan vi anropa start_continuous_recognition().

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

Dikteringsläge

När du använder kontinuerlig igenkänning kan du aktivera dikteringsbearbetning med hjälp av motsvarande "aktivera diktering"-funktion. Det här läget gör att talkonfigurationsinstansen tolkar ordbeskrivningar av meningsstrukturer, till exempel skiljetecken. Till exempel skulle ta upp "Bor du i staden frågetecken" tolkas som texten "Bor du i staden?".

Om du vill aktivera dikteringsläge använder enable_dictation() du metoden på din SpeechConfig .

SpeechConfig.enable_dictation()

Ändra källspråk

En vanlig uppgift för taligenkänning är att ange indataspråket (eller källan). Låt oss ta en titt på hur du skulle ändra indataspråket till tyska. Leta rätt på SpeechConfig i koden och lägg sedan 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. Du kan ange ett värde i listan över språk som stöds.

Förbättra igenkänningsprecisionen

Fraslistor används för att identifiera kända fraser i ljuddata, till exempel en persons namn eller en specifik plats. Genom att tillhandahålla en lista över fraser kan du förbättra noggrannheten för taligenkänning.

Om du till exempel har kommandot "Flytta till" och ett möjligt mål för "Ward" som kan sägas, kan du lägga till en post i "Flytta till Ward". Att lägga till en fras ökar sannolikheten att när ljudet känns igen att "Flytta till Ward" känns igen i stället för "Flytta mot"

Enkla ord eller fullständiga fraser kan läggas till i en fraslista. Under igenkänning används en post i en fraslista för att öka igenkänningen av orden och fraserna i listan även när posterna visas mitt i yttrandena.

Om du vill använda en fraslista skapar du PhraseListGrammar först ett -objekt och lägger sedan till specifika ord och fraser med addPhrase .

Eventuella ändringar som PhraseListGrammar börjar gälla vid nästa igenkänning eller efter en återanslutning till Speech-tjänsten.

phrase_list_grammar = speechsdk.PhraseListGrammar.from_recognizer(reco)
phrase_list_grammar.addPhrase("Supercalifragilisticexpialidocious")

Om du behöver rensa fraslistan:

phrase_list_grammar.clear()

Andra alternativ för att förbättra igenkänningsprecisionen

Fraslistor är bara ett alternativ för att förbättra igenkänningsprecisionen. Du kan även:

• Förbättra noggrannheten med anpassat tal
• Förbättra noggrannheten med klientmodeller

I den här snabbstarten lär du dig att konvertera tal till text med hjälp av Speech-tjänsten och cURL.

En översiktlig titt på tal till text-begrepp finns i översiktsartikeln.

Förutsättningar

Den här artikeln förutsätter att du har ett Azure-konto och en speech-tjänstprenumeration. Om du inte har något konto och en prenumeration kan du prova Speech-tjänsten utan kostnad.

Konvertera tal till text

Kör följande kommando i en kommandotolk. Du måste infoga följande värden i kommandot .

• Din prenumerationsnyckel för Speech-tjänsten.
• Taltjänstens region.
• Sökvägen till indataljudfilen. Du kan generera ljudfiler med hjälp av 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 som liknar följande.

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

Mer information finns i tal till text-REST API referens.

En av huvudfunktionerna i Taltjänsten är möjligheten att känna igen och transkribera mänskligt tal (kallas ofta tal till text). I den här snabbstarten får du lära dig hur du använder Speech CLI i dina appar och produkter för att utföra tal-till-text-konvertering av hög kvalitet.

Hämta och installera

mkdir ~/spx-data
cd ~/spx-data
pwd

docker run -it -v c:\spx-data:/data --rm msftspeech/spx

sudo docker run -it -v ABSOLUTE_PATH:/data --rm msftspeech/spx

docker run -it -v c:\spx-data:/data --rm msftspeech/spx config @key --set SUBSCRIPTION-KEY

docker run -it --entrypoint=/bin/bash -v c:\spx-data:/data --rm msftspeech/spx

Tal till text från mikrofon

Anslut och slå på datorns mikrofon och 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 identifiera tal från mikrofonen. Från kommandoraden ändrar du till den katalog som innehåller speech CLI-binärfilen och kör följande kommando.

spx recognize --microphone

Tala in i mikrofonen så ser du transkription av dina ord i text i realtid. Speech CLI stoppas efter en stunds tystnad eller när du trycker på Ctrl+C.

Tal till text från ljudfil

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

Nu är du redo att köra Speech CLI för att identifiera tal som finns i ljudfilen genom att köra följande kommando.

spx recognize --file whatstheweatherlike.wav

Tal-CLI visar en texttranskriskription av talet på skärmen.