Rozpoznávání řeči pomocí služby Azure Speech Service

  • Článek
  • 7 min ke čtení

Ukázka stažení Stažení ukázky

Služba Azure Speech Service je cloudové rozhraní API, které nabízí následující funkce:

  • Transcribes zvukové soubory nebo streamy na text.
  • Převod textu na řeč převede vstupní text na syntetizované řeč podobné člověku.
  • Překlad řeči umožňuje překlady ve více jazycích pro převod řeči na text i pro převod řeči na řeč v reálném čase.
  • Asistenti hlasu mohou pro aplikace vytvořit podobná rozhraní konverzace.

Tento článek vysvětluje, jak se převod řeči na text implementuje v ukázkové Xamarin.Forms aplikaci pomocí služby Azure Speech Service. Následující snímky obrazovky ukazují ukázkovou aplikaci v iOS a Androidu:

ukázkové aplikace v iOS a Androidu

Vytvoření prostředku Azure Speech Service

služba azure Speech Service je součástí služby azure Cognitive Services, která poskytuje cloudová rozhraní api pro úlohy, jako je rozpoznávání obrázků, rozpoznávání řeči a překlad, a hledání Bing. Další informace najdete v tématu co je Azure Cognitive Services?.

Vzorový projekt vyžaduje, aby se v Azure Portal vytvořil prostředek služby Azure Cognitive Services. Prostředek Cognitive Services lze vytvořit pro jednu službu, jako je například služba rozpoznávání řeči nebo jako prostředek s více službami. Prostředkem pro vytvoření prostředku služby řeči jsou tyto kroky:

  1. Přihlaste se k Azure Portal.
  2. Vytvořte prostředek s více službami nebo s jednou službou.
  3. Získejte informace o klíči a oblasti rozhraní API pro váš prostředek.
  4. Aktualizujte ukázkový soubor konstant. cs .

Podrobný průvodce vytvořením prostředku najdete v tématu vytvoření prostředku Cognitive Services.

Poznámka

Pokud ještě nemáte předplatné Azure, vytvořte si bezplatný účet před tím, než začnete. Jakmile budete mít účet, můžete na bezplatné úrovni vytvořit prostředek s jednou službou, abyste mohli službu vyzkoušet.

Konfigurace aplikace pomocí služby Speech

Po vytvoření prostředku Cognitive Services můžete soubor konstanty. cs aktualizovat pomocí oblasti a klíče rozhraní API z prostředku Azure:

public static class Constants
{
    public static string CognitiveServicesApiKey = "YOUR_KEY_GOES_HERE";
    public static string CognitiveServicesRegion = "westus";
}

nainstalovat balíček služby NuGet Speech

ukázková aplikace používá balíček Microsoft. cognitiveservices account. Speech NuGet pro připojení ke službě Azure Speech Service. tento balíček NuGet nainstalujte do sdíleného projektu a každého projektu platformy.

Vytvoření rozhraní IMicrophoneService

Každá platforma vyžaduje oprávnění pro přístup k mikrofonu. Vzorový projekt poskytuje IMicrophoneService rozhraní ve sdíleném projektu a používá Xamarin.FormsDependencyService k získání implementací platformy rozhraní.

public interface IMicrophoneService
{
    Task<bool> GetPermissionAsync();
    void OnRequestPermissionResult(bool isGranted);
}

Vytvoření rozložení stránky

Vzorový projekt definuje základní rozložení stránky v souboru MainPage. XAML . Klíčové prvky rozložení jsou Button tím, že spustí přepisný proces, který bude Label obsahovat text přepisu a který se ActivityIndicator má zobrazit, když probíhá přepis:

<ContentPage ...>
    <StackLayout>
        <Frame ...>
            <ScrollView x:Name="scroll"
                        ...>
                <Label x:Name="transcribedText"
                       ... />
            </ScrollView>
        </Frame>

        <ActivityIndicator x:Name="transcribingIndicator"
                           IsRunning="False" />
        <Button x:Name="transcribeButton"
                ...
                Clicked="TranscribeClicked"/>
    </StackLayout>
</ContentPage>

Implementace služby pro rozpoznávání řeči

Soubor s kódem na pozadí MainPage. XAML. cs obsahuje veškerou logiku pro odesílání zvuku a příjem přepisu textu ze služby Azure Speech Service.

MainPageKonstruktor získá instanci IMicrophoneService rozhraní z DependencyService :

public partial class MainPage : ContentPage
{
    SpeechRecognizer recognizer;
    IMicrophoneService micService;
    bool isTranscribing = false;

    public MainPage()
    {
        InitializeComponent();

        micService = DependencyService.Resolve<IMicrophoneService>();
    }

    // ...
}

TranscribeClickedMetoda je volána při klepnutí na transcribeButton instanci:

async void TranscribeClicked(object sender, EventArgs e)
{
    bool isMicEnabled = await micService.GetPermissionAsync();

    // EARLY OUT: make sure mic is accessible
    if (!isMicEnabled)
    {
        UpdateTranscription("Please grant access to the microphone!");
        return;
    }

    // initialize speech recognizer 
    if (recognizer == null)
    {
        var config = SpeechConfig.FromSubscription(Constants.CognitiveServicesApiKey, Constants.CognitiveServicesRegion);
        recognizer = new SpeechRecognizer(config);
        recognizer.Recognized += (obj, args) =>
        {
            UpdateTranscription(args.Result.Text);
        };
    }

    // if already transcribing, stop speech recognizer
    if (isTranscribing)
    {
        try
        {
            await recognizer.StopContinuousRecognitionAsync();
        }
        catch(Exception ex)
        {
            UpdateTranscription(ex.Message);
        }
        isTranscribing = false;
    }

    // if not transcribing, start speech recognizer
    else
    {
        Device.BeginInvokeOnMainThread(() =>
        {
            InsertDateTimeRecord();
        });
        try
        {
            await recognizer.StartContinuousRecognitionAsync();
        }
        catch(Exception ex)
        {
            UpdateTranscription(ex.Message);
        }
        isTranscribing = true;
    }
    UpdateDisplayState();
}

TranscribeClickedMetoda provede následující akce:

  1. Zkontroluje, jestli má aplikace přístup k mikrofonu a brzy ukončí, pokud není.
  2. Vytvoří instanci třídy, SpeechRecognizer Pokud ještě neexistuje.
  3. Zastaví plynulé přepisy, pokud právě probíhá.
  4. Vloží časové razítko a zahájí plynulé přepisy, pokud neprobíhá.
  5. Upozorní aplikaci, aby aktualizovala její vzhled na základě nového stavu aplikace.

Zbývající MainPage metody třídy jsou pomocníky pro zobrazení stavu aplikace:

void UpdateTranscription(string newText)
{
    Device.BeginInvokeOnMainThread(() =>
    {
        if (!string.IsNullOrWhiteSpace(newText))
        {
            transcribedText.Text += $"{newText}\n";
        }
    });
}

void InsertDateTimeRecord()
{
    var msg = $"=================\n{DateTime.Now.ToString()}\n=================";
    UpdateTranscription(msg);
}

void UpdateDisplayState()
{
    Device.BeginInvokeOnMainThread(() =>
    {
        if (isTranscribing)
        {
            transcribeButton.Text = "Stop";
            transcribeButton.BackgroundColor = Color.Red;
            transcribingIndicator.IsRunning = true;
        }
        else
        {
            transcribeButton.Text = "Transcribe";
            transcribeButton.BackgroundColor = Color.Green;
            transcribingIndicator.IsRunning = false;
        }
    });
}

UpdateTranscriptionMetoda zapíše poskytnutý newTextstring prvek do Label elementu s názvem transcribedText . Vynutí, aby tato aktualizace probíhala ve vlákně uživatelského rozhraní, aby ji bylo možné volat z libovolného kontextu, aniž by to způsobilo výjimky. InsertDateTimeRecordZapíše aktuální datum a čas do transcribedText instance, která označuje začátek nového přepisu. Nakonec UpdateDisplayState Metoda aktualizuje Button prvky a, ActivityIndicator aby odrážely, zda právě probíhá přepis.

Vytvoření služeb mikrofonu platformy

Aplikace musí mít přístup přes mikrofon ke shromažďování dat řeči. Rozhraní, které IMicrophoneService má aplikace fungovat, musí být implementováno a zaregistrováno na DependencyService každé platformě.

Android

Vzorový projekt definuje IMicrophoneService implementaci pro Android s názvem AndroidMicrophoneService :

[assembly: Dependency(typeof(AndroidMicrophoneService))]
namespace CognitiveSpeechService.Droid.Services
{
    public class AndroidMicrophoneService : IMicrophoneService
    {
        public const int RecordAudioPermissionCode = 1;
        private TaskCompletionSource<bool> tcsPermissions;
        string[] permissions = new string[] { Manifest.Permission.RecordAudio };

        public Task<bool> GetPermissionAsync()
        {
            tcsPermissions = new TaskCompletionSource<bool>();

            if ((int)Build.VERSION.SdkInt < 23)
            {
                tcsPermissions.TrySetResult(true);
            }
            else
            {
                var currentActivity = MainActivity.Instance;
                if (ActivityCompat.CheckSelfPermission(currentActivity, Manifest.Permission.RecordAudio) != (int)Permission.Granted)
                {
                    RequestMicPermissions();
                }
                else
                {
                    tcsPermissions.TrySetResult(true);
                }

            }

            return tcsPermissions.Task;
        }

        public void OnRequestPermissionResult(bool isGranted)
        {
            tcsPermissions.TrySetResult(isGranted);
        }

        void RequestMicPermissions()
        {
            if (ActivityCompat.ShouldShowRequestPermissionRationale(MainActivity.Instance, Manifest.Permission.RecordAudio))
            {
                Snackbar.Make(MainActivity.Instance.FindViewById(Android.Resource.Id.Content),
                        "Microphone permissions are required for speech transcription!",
                        Snackbar.LengthIndefinite)
                        .SetAction("Ok", v =>
                        {
                            ((Activity)MainActivity.Instance).RequestPermissions(permissions, RecordAudioPermissionCode);
                        })
                        .Show();
            }
            else
            {
                ActivityCompat.RequestPermissions((Activity)MainActivity.Instance, permissions, RecordAudioPermissionCode);
            }
        }
    }
}

AndroidMicrophoneServiceMá následující funkce:

  1. DependencyAtribut registruje třídu pomocí DependencyService .
  2. GetPermissionAsyncMetoda kontroluje, zda jsou požadována oprávnění na základě Android SDK verze, a volání v případě, že dosud nebylo RequestMicPermissions uděleno oprávnění.
  3. RequestMicPermissionsMetoda používá Snackbar třídu k vyžádání oprávnění od uživatele, pokud je požadováno odůvodnění, jinak přímo požaduje oprávnění pro záznam zvuku.
  4. OnRequestPermissionResultMetoda je volána s výsledkem, bool Jakmile uživatel odpoví na žádost o oprávnění.

MainActivityTřída je přizpůsobená tak, aby aktualizovala AndroidMicrophoneService instanci, když jsou žádosti o oprávnění dokončené:

public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity
{
    IMicrophoneService micService;
    internal static MainActivity Instance { get; private set; }
    
    protected override void OnCreate(Bundle savedInstanceState)
    {
        Instance = this;
        // ...
        micService = DependencyService.Resolve<IMicrophoneService>();
    }
    public override void OnRequestPermissionsResult(int requestCode, string[] permissions, [GeneratedEnum] Android.Content.PM.Permission[] grantResults)
    {
        // ...
        switch(requestCode)
        {
            case AndroidMicrophoneService.RecordAudioPermissionCode:
                if (grantResults[0] == Permission.Granted)
                {
                    micService.OnRequestPermissionResult(true);
                }
                else
                {
                    micService.OnRequestPermissionResult(false);
                }
                break;
        }
    }
}

MainActivityTřída definuje statický odkaz s názvem Instance , který je požadován AndroidMicrophoneService objektem při žádosti o oprávnění. Přepíše OnRequestPermissionsResult metodu pro aktualizaci AndroidMicrophoneService objektu, pokud je žádost o oprávnění schválena nebo zakázána uživatelem.

Nakonec musí aplikace pro Android zahrnovat oprávnění k záznamu zvuku do souboru AndroidManifest.xml :

<manifest ...>
    ...
    <uses-permission android:name="android.permission.RECORD_AUDIO" />
</manifest>

iOS

Vzorový projekt definuje IMicrophoneService implementaci pro iOS s názvem iOSMicrophoneService :

[assembly: Dependency(typeof(iOSMicrophoneService))]
namespace CognitiveSpeechService.iOS.Services
{
    public class iOSMicrophoneService : IMicrophoneService
    {
        TaskCompletionSource<bool> tcsPermissions;

        public Task<bool> GetPermissionAsync()
        {
            tcsPermissions = new TaskCompletionSource<bool>();
            RequestMicPermission();
            return tcsPermissions.Task;
        }

        public void OnRequestPermissionResult(bool isGranted)
        {
            tcsPermissions.TrySetResult(isGranted);
        }

        void RequestMicPermission()
        {
            var session = AVAudioSession.SharedInstance();
            session.RequestRecordPermission((granted) =>
            {
                tcsPermissions.TrySetResult(granted);
            });
        }
    }
}

iOSMicrophoneServiceMá následující funkce:

  1. DependencyAtribut registruje třídu pomocí DependencyService .
  2. GetPermissionAsyncMetoda volá RequestMicPermissions požadavek na oprávnění od uživatele zařízení.
  3. RequestMicPermissionsMetoda používá sdílenou AVAudioSession instanci k vyžádání oprávnění k zápisu.
  4. OnRequestPermissionResultMetoda aktualizuje TaskCompletionSource instanci s poskytnutou bool hodnotou.

Nakonec informace o aplikaci pro iOS . plist musí zahrnovat zprávu s informacemi o tom, proč aplikace žádá o přístup k mikrofonu. Upravte soubor info. plist tak, aby zahrnoval následující značky v rámci <dict> elementu:

<plist>
    <dict>
        ...
        <key>NSMicrophoneUsageDescription</key>
        <string>Voice transcription requires microphone access</string>
    </dict>
</plist>

UWP

Vzorový projekt definuje IMicrophoneService implementaci pro UWP s názvem UWPMicrophoneService :

[assembly: Dependency(typeof(UWPMicrophoneService))]
namespace CognitiveSpeechService.UWP.Services
{
    public class UWPMicrophoneService : IMicrophoneService
    {
        public async Task<bool> GetPermissionAsync()
        {
            bool isMicAvailable = true;
            try
            {
                var mediaCapture = new MediaCapture();
                var settings = new MediaCaptureInitializationSettings();
                settings.StreamingCaptureMode = StreamingCaptureMode.Audio;
                await mediaCapture.InitializeAsync(settings);
            }
            catch(Exception ex)
            {
                isMicAvailable = false;
            }

            if(!isMicAvailable)
            {
                await Windows.System.Launcher.LaunchUriAsync(new Uri("ms-settings:privacy-microphone"));
            }

            return isMicAvailable;
        }

        public void OnRequestPermissionResult(bool isGranted)
        {
            // intentionally does nothing
        }
    }
}

UWPMicrophoneServiceMá následující funkce:

  1. DependencyAtribut registruje třídu pomocí DependencyService .
  2. GetPermissionAsyncMetoda se pokusí inicializovat MediaCapture instanci. Pokud se to nepovede, spustí uživatel požadavek na povolení mikrofonu.
  3. OnRequestPermissionResultMetoda existuje pro splnění rozhraní, ale není vyžadována pro implementaci UWP.

Nakonec musí balíček UWP . appxmanifest určit, že aplikace používá mikrofon. dvakrát klikněte na soubor Package. appxmanifest a na kartě možnosti v Visual Studio 2019 vyberte možnost mikrofon :

snímek obrazovky manifestu v Visual Studio 2019

Testování aplikace

Spusťte aplikaci a klikněte na tlačítko přepisovat . Aplikace by měla požádat o přístup k mikrofonu a zahájit proces přepisu. ActivityIndicatorDojde k animaci, která ukazuje, že je přepis aktivní. Při mluvení bude aplikace streamovat zvuková data do prostředku Azure Speech Services, který bude reagovat na přepisu text. Text přepisu se zobrazí v Label prvku jako přijatý.

Poznámka

Emulátory Androidu se nepodařilo načíst a inicializovat knihovny služby Speech. Pro platformu Android se doporučuje testování na fyzickém zařízení.