Rychlý Start: rozpoznávání řeči uložených v úložišti objektů BLOBQuickstart: Recognize speech stored in blob storage

V tomto rychlém startu použijete REST API k rozpoznávání řeči ze souborů v dávkovém procesu.In this quickstart, you will use a REST API to recognize speech from files in a batch process. Dávkový proces spustí přepis řeči bez jakýchkoli interakcí uživatele.A batch process executes the speech transcription without any user interactions. Poskytuje jednoduchý programovací model bez nutnosti spravovat souběžnost, vlastní modely řeči nebo jiné podrobnosti.It gives you a simple programming model, without the need to manage concurrency, custom speech models, or other details. Zahrnuje pokročilé možnosti kontroly a přitom efektivní využívání prostředků služby Azure Speech Service.It entails advanced control options, while making efficient use of Azure speech service resources.

Další informace o dostupných možnostech a podrobnostech konfigurace najdete v tématu Batch přepis.For more information on the available options and configuration details, see batch transcription.

Následující rychlý Start vás provede ukázkou použití.The following quickstart will walk you through a usage sample.

Pokud si přejete přejít přímo do, zobrazte si nebo stáhněte všechny ukázky sady Speech SDK C# na GitHubu.If you prefer to jump right in, view or download all Speech SDK C# Samples on GitHub. V opačném případě můžeme začít.Otherwise, let's get started.

PožadavkyPrerequisites

Než začnete, nezapomeňte:Before you get started, make sure to:

Otevřete projekt v aplikaci Visual StudioOpen your project in Visual Studio

Prvním krokem je ujistit se, že máte projekt otevřený v aplikaci Visual Studio.The first step is to make sure that you have your project open in Visual Studio.

  1. Spusťte Visual Studio 2019.Launch Visual Studio 2019.
  2. Načtěte projekt a otevřete Program.cs.Load your project and open Program.cs.

Přidat odkaz na Newtonsoft. JSONAdd a reference to Newtonsoft.Json

  1. V Průzkumník řešení klikněte pravým tlačítkem myši na projekt HelloWorld a pak výběrem možnosti spravovat balíčky NuGet Zobrazte správce balíčků NuGet.In the Solution Explorer, right-click the helloworld project, and then select Manage NuGet Packages to show the NuGet Package Manager.
  2. V pravém horním rohu Najděte rozevírací seznam zdroj balíčku a ujistěte se, že nuget.org je vybraná možnost.In the upper-right corner, find the Package Source drop-down box, and make sure that nuget.org is selected.
  3. V levém horním rohu vyberte Procházet.In the upper-left corner, select Browse.
  4. Do vyhledávacího pole zadejte Newtonsoft. JSON a vyberte ENTER.In the search box, type newtonsoft.json and select Enter.
  5. Ve výsledcích hledání vyberte balíček Newtonsoft. JSON a pak vyberte instalovat a nainstalujte nejnovější stabilní verzi.From the search results, select the Newtonsoft.Json package, and then select Install to install the latest stable version.
  6. Přijetím všech smluv a licencí spusťte instalaci.Accept all agreements and licenses to start the installation. Po instalaci balíčku se v okně konzoly Správce balíčků zobrazí potvrzení.After the package is installed, a confirmation appears in the Package Manager Console window.

Začínáme s některým často používaným kódemStart with some boilerplate code

Pojďme přidat kód, který funguje jako kostra pro náš projekt.Let's add some code that works as a skeleton for our project.

class Program
{
    // Replace with your subscription key
    const string SubscriptionKey = "YourSubscriptionKey";

    // Update with your service region
    const string Region = "YourServiceRegion";
    const int Port = 443;
 
    // Recordings and locale
    const string Locale = "en-US";
    const string RecordingsBlobUri = "YourFileUrl";
 
    // Name and description
    const string Name = "Simple transcription";
    const string Description = "Simple transcription description";
 
    const string SpeechToTextBasePath = "api/speechtotext/v2.0/";
 
    static async Task Main()
    {
        // Cognitive Services follows security best practices.
        // If you experience connectivity issues, see:
        // https://docs.microsoft.com/en-us/dotnet/framework/network-programming/tls
 
        await TranscribeAsync();
    }
 
    static async Task TranscribeAsync()
    {
        Console.WriteLine("Starting transcriptions client...");
    }
}

Budete muset nahradit následující hodnoty:You'll need to replace the following values:

  • YourSubscriptionKey: nachází se na stránce klíče Azure Portal pro prostředek řeči.YourSubscriptionKey: found in the the Keys page of the Azure portal for the Speech resource
  • YourServiceRegion: nachází se na stránce přehled Azure Portal pro prostředek řeči.YourServiceRegion: found in the the Overview page of the Azure portal for the Speech resource
  • YourFileUrl: nachází se na stránce BLOB Service/kontejnery Azure Portal prostředku účtu úložiště.YourFileUrl: found in under the Blob service / Containers page of the Azure portal for the Storage account resource
    • Vyberte příslušný kontejner.Select the appropriate container
    • Vyberte požadovaný objekt BLOB.Select the desired blob
    • Zkopírujte adresu URL pod stránku vlastnostiCopy the URL under the Properties page

Obálky JSONJSON Wrappers

Jak REST API přijímá požadavky ve formátu JSON a také vrátí výsledky ve formátu JSON, můžeme s nimi pracovat jenom s řetězci, ale to se nedoporučuje.As the REST API's take requests in JSON format and also return results in JSON we could interact with them using only strings, but that's not recommended. Aby bylo možné žádosti a odpovědi snadněji spravovat, deklarujeme několik tříd, které se použijí pro serializaci nebo deserializaci JSON.In order to make the requests and responses easier to manage, we'll declare a few classes to use for serializing / deserializing the JSON.

Pokračujte a uveďte jejich deklarace po TranscribeAsync.Go ahead and put their declarations after TranscribeAsync.

public class ModelIdentity
{
    ModelIdentity(Guid id) => Id = id;

    public Guid Id { get; private set; }

    public static ModelIdentity Create(Guid Id) => new ModelIdentity(Id);
}

public class Transcription
{
    [JsonConstructor]
    Transcription(
        Guid id,
        string name,
        string description,
        string locale,
        DateTime createdDateTime,
        DateTime lastActionDateTime,
        string status,
        Uri recordingsUrl,
        IReadOnlyDictionary<string, string> resultsUrls)
    {
        Id = id;
        Name = name;
        Description = description;
        CreatedDateTime = createdDateTime;
        LastActionDateTime = lastActionDateTime;
        Status = status;
        Locale = locale;
        RecordingsUrl = recordingsUrl;
        ResultsUrls = resultsUrls;
    }

    public string Name { get; set; }

    public string Description { get; set; }

    public string Locale { get; set; }

    public Uri RecordingsUrl { get; set; }

    public IReadOnlyDictionary<string, string> ResultsUrls { get; set; }

    public Guid Id { get; set; }

    public DateTime CreatedDateTime { get; set; }

    public DateTime LastActionDateTime { get; set; }

    public string Status { get; set; }

    public string StatusMessage { get; set; }
}

public class TranscriptionDefinition
{
    TranscriptionDefinition(
        string name,
        string description,
        string locale,
        Uri recordingsUrl,
        IEnumerable<ModelIdentity> models)
    {
        Name = name;
        Description = description;
        RecordingsUrl = recordingsUrl;
        Locale = locale;
        Models = models;
        Properties = new Dictionary<string, string>
        {
            ["PunctuationMode"] = "DictatedAndAutomatic",
            ["ProfanityFilterMode"] = "Masked",
            ["AddWordLevelTimestamps"] = "True"
        };
    }

    public string Name { get; set; }

    public string Description { get; set; }

    public Uri RecordingsUrl { get; set; }

    public string Locale { get; set; }

    public IEnumerable<ModelIdentity> Models { get; set; }

    public IDictionary<string, string> Properties { get; set; }

    public static TranscriptionDefinition Create(
        string name,
        string description,
        string locale,
        Uri recordingsUrl)
        => new TranscriptionDefinition(name, description, locale, recordingsUrl, new ModelIdentity[0]);
}

Vytvoření a konfigurace klienta httpCreate and configure an Http Client

První věc, kterou budeme potřebovat, je klient http, který má správnou základní adresu URL a sadu ověřování.The first thing we'll need is an Http Client that has a correct base URL and authentication set. Vložte tento kód do TranscribeAsync.Insert this code in TranscribeAsync.

var client = new HttpClient
{
    Timeout = TimeSpan.FromMinutes(25),
    BaseAddress = new UriBuilder(Uri.UriSchemeHttps, $"{Region}.cris.ai", Port).Uri,
    DefaultRequestHeaders =
    {
        { "Ocp-Apim-Subscription-Key", SubscriptionKey }
    }
};

Generovat žádost o přepisGenerate a transcription request

Dále vygenerujeme žádost o přepis.Next, we'll generate the transcription request. Přidejte tento kód do TranscribeAsync.Add this code to TranscribeAsync.

var transcriptionDefinition =
    TranscriptionDefinition.Create(
        Name,
        Description,
        Locale,
        new Uri(RecordingsBlobUri));

var res = JsonConvert.SerializeObject(transcriptionDefinition);
var sc = new StringContent(res);
sc.Headers.ContentType = JsonMediaTypeFormatter.DefaultMediaType;

Odeslat žádost a ověřit její stavSend the request and check its status

Nyní pošleme požadavek službě rozpoznávání řeči a zkontrolujeme kód prvotní odezvy.Now we post the request to the Speech service and check the initial response code. Tento kód odpovědi jednoduše indikuje, jestli služba požadavek přijala.This response code will simply indicate if the service has received the request. Služba vrátí adresu URL v hlavičkách odpovědi, kde je umístění, kde bude uložený stav přepisu.The service will return a Url in the response headers that's the location where it will store the transcription status.

Uri transcriptionLocation = null;
using (var response = await client.PostAsync($"{SpeechToTextBasePath}Transcriptions/", sc))
{
    if (!response.IsSuccessStatusCode)
    {
        Console.WriteLine("Error {0} starting transcription.", response.StatusCode);
        return;
    }

    transcriptionLocation = response.Headers.Location;
}

Počkejte, až se přepis dokončí.Wait for the transcription to complete

Vzhledem k tomu, že služba zpracovává přepis asynchronně, musíme dotazovat se na jeho stav, a to v každém případě často.Since the service processes the transcription asynchronously, we need to poll for its status every so often. Zkontrolujeme každých 5 sekund.We'll check every 5 seconds.

Stav můžeme zjistit načtením obsahu na adrese URL, kterou jsme dostali při odeslání žádosti.We can check the status by retrieving the content at the Url we got when the posted the request. Když získáme obsah zpátky, deserializovatme ho do jedné z našich pomocných tříd, aby bylo snazší pracovat s.When we get the content back, we deserialize it into one of our helper class to make it easier to interact with.

Toto je kód pro cyklické dotazování se zobrazením stavu pro vše s výjimkou úspěšného dokončení. provedeme to ještě dál.Here's the polling code with status display for everything except a successful completion, we'll do that next.

Console.WriteLine($"Created transcription at location {transcriptionLocation}.");
Console.WriteLine("Checking status.");

var completed = false;

// Check for the status of our transcriptions periodically
while (!completed)
{
    Transcription transcription = null;
    using (var response = await client.GetAsync(transcriptionLocation.AbsolutePath))
    {
        var contentType = response.Content.Headers.ContentType;
        if (response.IsSuccessStatusCode &&
            string.Equals(contentType.MediaType, "application/json", StringComparison.OrdinalIgnoreCase))
        {
            transcription = await response.Content.ReadAsAsync<Transcription>();
        }
        else
        {
            Console.WriteLine("Error with status {0} getting transcription result", response.StatusCode);
            continue;
        }
    }

    switch (transcription.Status)
    {
        case "Failed":
            completed = true;
            Console.WriteLine("Transcription failed. Status: {0}", transcription.StatusMessage);
            break;

        case "Succeeded":
            break;

        case "Running":
            Console.WriteLine("Transcription is still running.");
            break;

        case "NotStarted":
            Console.WriteLine("Transcription has not started.");
            break;
    }

    await Task.Delay(TimeSpan.FromSeconds(5));
}

Console.WriteLine("Press any key...");
Console.ReadKey();

Zobrazení výsledků přepisuDisplay the transcription results

Po úspěšném dokončení přepisu budou výsledky uloženy v jiné adrese URL, kterou můžeme získat z odpovědi na stav.Once the service has successfully completed the transcription the results will be stored in another Url that we can get from the status response. Tady vytvoříme požadavek na stažení těchto výsledků do dočasného souboru před čtením a deserializací.Here we make a request to download those results in to a temporary file before reading and deserializing them. Po načtení výsledků je můžete vytisknout do konzoly.Once the results are loaded we can print them to the console. Do case "Succeeded": popisku přidejte následující kód.Add the following code to the case "Succeeded": label.

completed = true;
var webClient = new WebClient();
var filename = Path.GetTempFileName();
webClient.DownloadFile(transcription.ResultsUrls["channel_0"], filename);
var results = File.ReadAllText(filename);
Console.WriteLine($"Transcription succeeded. Results: {Environment.NewLine}{results}");
File.Delete(filename);

Kontrolovat kódCheck your code

V tomto okamžiku by váš kód měl vypadat takto: (do této verze jsme přidali nějaké komentáře.)At this point, your code should look like this: (We've added some comments to this version)

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Threading.Tasks;
using System.Net.Http;
using System.Net.Http.Formatting;

namespace BatchClient
{
    class Program
    {
        // Replace with your subscription key
        const string SubscriptionKey = "YourSubscriptionKey";

        // Update with your service region
        const string Region = "YourServiceRegion";
        const int Port = 443;

        // Recordings and locale
        const string Locale = "en-US";
        const string RecordingsBlobUri = "YourFileUrl";

        // Name and description
        const string Name = "Simple transcription";
        const string Description = "Simple transcription description";

        const string SpeechToTextBasePath = "api/speechtotext/v2.0/";

        static async Task Main()
        {
            // For non-Windows 10 users.
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;

            await TranscribeAsync();
        }

        static async Task TranscribeAsync()
        {
            Console.WriteLine("Starting transcriptions client...");

            // Create the client object and authenticate
            var client = new HttpClient
            {
                Timeout = TimeSpan.FromMinutes(25),
                BaseAddress = new UriBuilder(Uri.UriSchemeHttps, $"{Region}.cris.ai", Port).Uri,
                DefaultRequestHeaders =
                {
                    { "Ocp-Apim-Subscription-Key", SubscriptionKey }
                }
            };

            var transcriptionDefinition =
                TranscriptionDefinition.Create(
                    Name,
                    Description,
                    Locale,
                    new Uri(RecordingsBlobUri));

            var res = JsonConvert.SerializeObject(transcriptionDefinition);
            var sc = new StringContent(res);
            sc.Headers.ContentType = JsonMediaTypeFormatter.DefaultMediaType;

            Uri transcriptionLocation = null;

            using (var response = await client.PostAsync($"{SpeechToTextBasePath}Transcriptions/", sc))
            {
                if (!response.IsSuccessStatusCode)
                {
                    Console.WriteLine("Error {0} starting transcription.", response.StatusCode);
                    return;
                }

                transcriptionLocation = response.Headers.Location;
            }

            Console.WriteLine($"Created transcription at location {transcriptionLocation}.");
            Console.WriteLine("Checking status.");

            var completed = false;

            // Check for the status of our transcriptions periodically
            while (!completed)
            {
                Transcription transcription = null;

                // Get all transcriptions for the user
                using (var response = await client.GetAsync(transcriptionLocation.AbsolutePath))
                {
                    var contentType = response.Content.Headers.ContentType;
                    if (response.IsSuccessStatusCode &&
                        string.Equals(contentType.MediaType, "application/json", StringComparison.OrdinalIgnoreCase))
                    {
                        transcription = await response.Content.ReadAsAsync<Transcription>();
                    }
                    else
                    {
                        Console.WriteLine("Error with status {0} getting transcription result", response.StatusCode);
                        continue;
                    }
                }

                // For each transcription in the list we check the status
                switch (transcription.Status)
                {
                    case "Failed":
                        completed = true;
                        Console.WriteLine("Transcription failed. Status: {0}", transcription.StatusMessage);
                        break;

                    case "Succeeded":
                        completed = true;
                        var webClient = new WebClient();
                        var filename = Path.GetTempFileName();
                        webClient.DownloadFile(transcription.ResultsUrls["channel_0"], filename);
                        var results = File.ReadAllText(filename);
                        Console.WriteLine($"Transcription succeeded. Results: {Environment.NewLine}{results}");
                        File.Delete(filename);
                        break;

                    case "Running":
                        Console.WriteLine("Transcription is still running.");
                        break;

                    case "NotStarted":
                        Console.WriteLine("Transcription has not started.");
                        break;
                }

                await Task.Delay(TimeSpan.FromSeconds(5));
            }

            Console.WriteLine("Press any key...");
            Console.ReadKey();
        }
    }

    public class ModelIdentity
    {
        ModelIdentity(Guid id) => Id = id;

        public Guid Id { get; private set; }

        public static ModelIdentity Create(Guid Id) => new ModelIdentity(Id);
    }

    public class Transcription
    {
        [JsonConstructor]
        Transcription(
            Guid id,
            string name,
            string description,
            string locale,
            DateTime createdDateTime,
            DateTime lastActionDateTime,
            string status,
            Uri recordingsUrl,
            IReadOnlyDictionary<string, string> resultsUrls)
        {
            Id = id;
            Name = name;
            Description = description;
            CreatedDateTime = createdDateTime;
            LastActionDateTime = lastActionDateTime;
            Status = status;
            Locale = locale;
            RecordingsUrl = recordingsUrl;
            ResultsUrls = resultsUrls;
        }

        public string Name { get; set; }

        public string Description { get; set; }

        public string Locale { get; set; }

        public Uri RecordingsUrl { get; set; }

        public IReadOnlyDictionary<string, string> ResultsUrls { get; set; }

        public Guid Id { get; set; }

        public DateTime CreatedDateTime { get; set; }

        public DateTime LastActionDateTime { get; set; }

        public string Status { get; set; }

        public string StatusMessage { get; set; }
    }

    public class TranscriptionDefinition
    {
        TranscriptionDefinition(
            string name,
            string description,
            string locale,
            Uri recordingsUrl,
            IEnumerable<ModelIdentity> models)
        {
            Name = name;
            Description = description;
            RecordingsUrl = recordingsUrl;
            Locale = locale;
            Models = models;
            Properties = new Dictionary<string, string>
            {
                ["PunctuationMode"] = "DictatedAndAutomatic",
                ["ProfanityFilterMode"] = "Masked",
                ["AddWordLevelTimestamps"] = "True"
            };
        }

        public string Name { get; set; }

        public string Description { get; set; }

        public Uri RecordingsUrl { get; set; }

        public string Locale { get; set; }

        public IEnumerable<ModelIdentity> Models { get; set; }

        public IDictionary<string, string> Properties { get; set; }

        public static TranscriptionDefinition Create(
            string name,
            string description,
            string locale,
            Uri recordingsUrl)
            => new TranscriptionDefinition(name, description, locale, recordingsUrl, new ModelIdentity[0]);
    }
}

Sestavení a spuštění aplikaceBuild and run your app

Nyní jste připraveni sestavit aplikaci a otestovat rozpoznávání řeči pomocí služby Speech.Now you're ready to build your app and test our speech recognition using the Speech service.

  1. Zkompilujte kód -z panelu nabídek v aplikaci Visual Studio, vyberte sestavení > řešenísestavení.Compile the code - From the menu bar of Visual Studio, choose Build > Build Solution.
  2. Spusťte aplikaci – z řádku nabídek zvolte ladění > Spustit ladění nebo stiskněte klávesu F5.Start your app - From the menu bar, choose Debug > Start Debugging or press F5.
  3. Spustit rozpoznávání – zobrazí výzvu k vymluvenému vynechání fráze v angličtině.Start recognition - It'll prompt you to speak a phrase in English. Váš hlas se odešle službě Speech, přepisu jako text a vykreslí se v konzole nástroje.Your speech is sent to the Speech service, transcribed as text, and rendered in the console.

Další krokyNext steps

V tomto rychlém startu použijete REST API k rozpoznávání řeči ze souborů v dávkovém procesu.In this quickstart, you will use a REST API to recognize speech from files in a batch process. Dávkový proces spustí přepis řeči bez jakýchkoli interakcí uživatele.A batch process executes the speech transcription without any user interactions. Poskytuje jednoduchý programovací model bez nutnosti spravovat souběžnost, vlastní modely řeči nebo jiné podrobnosti.It gives you a simple programming model, without the need to manage concurrency, custom speech models, or other details. Zahrnuje pokročilé možnosti kontroly a přitom efektivní využívání prostředků služby Azure Speech Service.It entails advanced control options, while making efficient use of Azure speech service resources.

Další informace o dostupných možnostech a podrobnostech konfigurace najdete v tématu Batch přepis.For more information on the available options and configuration details, see batch transcription.

Následující rychlý Start vás provede ukázkou použití.The following quickstart will walk you through a usage sample.

Pokud si přejete přejít přímo v, zobrazte si nebo stáhněte všechny ukázky sady Speech SDK pro sadu Speech na GitHubu.If you prefer to jump right in, view or download all Speech SDK C++ Samples on GitHub. V opačném případě můžeme začít.Otherwise, let's get started.

PožadavkyPrerequisites

Než začnete, nezapomeňte:Before you get started, make sure to:

Otevřete projekt v aplikaci Visual StudioOpen your project in Visual Studio

Prvním krokem je ujistit se, že máte projekt otevřený v aplikaci Visual Studio.The first step is to make sure that you have your project open in Visual Studio.

  1. Spusťte Visual Studio 2019.Launch Visual Studio 2019.
  2. Načtěte projekt a otevřete helloworld.cpp.Load your project and open helloworld.cpp.

Přidat odkazyAdd a references

K urychlení vývoje kódu budeme používat několik externích komponent:To speed up our code development we'll be using a couple of external components:

  • Cpp REST SDK Klientská knihovna pro volání REST pro službu REST.CPP Rest SDK A client library for making REST calls to a REST service.
  • nlohmann/JSON Užitečnou knihovnu JSON pro analýzu/serializaci/deserializaci.nlohmann/json Handy JSON Parsing / Serialization / Deserialization library.

Obě můžou být nainstalované pomocí vcpkg.Both can be installed using vcpkg.

vcpkg install cpprestsdk cpprestsdk:x64-windows
vcpkg install nlohmann-json

Začínáme s některým často používaným kódemStart with some boilerplate code

Pojďme přidat kód, který funguje jako kostra pro náš projekt.Let's add some code that works as a skeleton for our project.

#include <iostream>
#include <strstream>
#include <Windows.h>
#include <locale>
#include <codecvt>
#include <string>

#include <cpprest/http_client.h>
#include <cpprest/filestream.h>
#include <nlohmann/json.hpp>

using namespace std;
using namespace utility;                    // Common utilities like string conversions
using namespace web;                        // Common features like URIs.
using namespace web::http;                  // Common HTTP functionality
using namespace web::http::client;          // HTTP client features
using namespace concurrency::streams;       // Asynchronous streams
using json = nlohmann::json;

const string_t region = U("YourServiceRegion");
const string_t subscriptionKey = U("YourSubscriptionKey");
const string name = "Simple transcription";
const string description = "Simple transcription description";
const string myLocale = "en-US";
const string recordingsBlobUri = "YourFileUrl";

void recognizeSpeech()
{
    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t >> converter;

}

int wmain()
{
    recognizeSpeech();
    cout << "Please press a key to continue.\n";
    cin.get();
    return 0;
}

Budete muset nahradit následující hodnoty:You'll need to replace the following values:

  • YourSubscriptionKey: nachází se na stránce klíče Azure Portal pro prostředek řeči.YourSubscriptionKey: found in the the Keys page of the Azure portal for the Speech resource
  • YourServiceRegion: nachází se na stránce přehled Azure Portal pro prostředek řeči.YourServiceRegion: found in the the Overview page of the Azure portal for the Speech resource
  • YourFileUrl: nachází se na stránce BLOB Service/kontejnery Azure Portal prostředku účtu úložiště.YourFileUrl: found in under the Blob service / Containers page of the Azure portal for the Storage account resource
    • Vyberte příslušný kontejner.Select the appropriate container
    • Vyberte požadovaný objekt BLOB.Select the desired blob
    • Zkopírujte adresu URL pod stránku vlastnostiCopy the URL under the Properties page

Obálky JSONJSON Wrappers

Jak REST API přijímá požadavky ve formátu JSON a také vrátí výsledky ve formátu JSON, můžeme s nimi pracovat jenom s řetězci, ale to se nedoporučuje.As the REST API's take requests in JSON format and also return results in JSON we could interact with them using only strings, but that's not recommended. Aby bylo možné žádosti a odpovědi snadněji spravovat, deklarujeme několik tříd, které se použijí k serializaci/deserializaci formátu JSON a některých metod, které vám pomůžou nlohmann/JSON.In order to make the requests and responses easier to manage, we'll declare a few classes to use for serializing / deserializing the JSON and some methods to assist nlohmann/json.

Pokračujte a uveďte jejich deklarace dřív recognizeSpeech .Go ahead and put their declarations before recognizeSpeech .

class TranscriptionDefinition {
private:
    TranscriptionDefinition(string name,
        string description,
        string locale,
        string recordingsUrl,
        std::list<string> models) {

        Name = name;
        Description = description;
        RecordingsUrl = recordingsUrl;
        Locale = locale;
        Models = models;
    }

public:
    string Name;
    string Description;
    string RecordingsUrl;
    string Locale;
    std::list<string> Models;
    std::map<string, string> properties;

    static TranscriptionDefinition Create(string name, string description, string locale, string recordingsUrl) {
        return TranscriptionDefinition(name, description, locale, recordingsUrl, std::list<string>());
    }
    static TranscriptionDefinition Create(string name, string description, string locale, string recordingsUrl,
        std::list<string> models) {
        return TranscriptionDefinition(name, description, locale, recordingsUrl, models);
    }
};

void to_json(nlohmann::json& j, const TranscriptionDefinition& t) {
    j = nlohmann::json{
            { "description", t.Description },
            { "locale", t.Locale },
            { "models", t.Models },
            { "name", t.Name },
            { "properties", t.properties },
            { "recordingsurl",t.RecordingsUrl }
    };
};

void from_json(const nlohmann::json& j, TranscriptionDefinition& t) {
    j.at("locale").get_to(t.Locale);
    j.at("models").get_to(t.Models);
    j.at("name").get_to(t.Name);
    j.at("properties").get_to(t.properties);
    j.at("recordingsurl").get_to(t.RecordingsUrl);
}

class Transcription {
public:
    string name;
    string description;
    string locale;
    string recordingsUrl;
    map<string, string> resultsUrls;
    string id;
    string createdDateTime;
    string lastActionDateTime;
    string status;
    string statusMessage;
};

void to_json(nlohmann::json& j, const Transcription& t) {
    j = nlohmann::json{
            { "description", t.description },
            { "locale", t.locale },
            { "createddatetime", t.createdDateTime },
            { "name", t.name },
            { "id", t.id },
            { "recordingsurl",t.recordingsUrl },
            { "resultUrls", t.resultsUrls},
            { "status", t.status},
            { "statusmessage", t.statusMessage}
    };
};

void from_json(const nlohmann::json& j, Transcription& t) {
    j.at("description").get_to(t.description);
    j.at("locale").get_to(t.locale);
    j.at("createdDateTime").get_to(t.createdDateTime);
    j.at("name").get_to(t.name);
    j.at("recordingsUrl").get_to(t.recordingsUrl);
    t.resultsUrls = j.at("resultsUrls").get<map<string, string>>();
    j.at("status").get_to(t.status);
    j.at("statusMessage").get_to(t.statusMessage);
}
class Result
{
public:
    string Lexical;
    string ITN;
    string MaskedITN;
    string Display;
};
void from_json(const nlohmann::json& j, Result& r) {
    j.at("Lexical").get_to(r.Lexical);
    j.at("ITN").get_to(r.ITN);
    j.at("MaskedITN").get_to(r.MaskedITN);
    j.at("Display").get_to(r.Display);
}

class NBest : public Result
{
public:
    double Confidence;	
};
void from_json(const nlohmann::json& j, NBest& nb) {
    j.at("Confidence").get_to(nb.Confidence);
    j.at("Lexical").get_to(nb.Lexical);
    j.at("ITN").get_to(nb.ITN);
    j.at("MaskedITN").get_to(nb.MaskedITN);
    j.at("Display").get_to(nb.Display);
}

class SegmentResult
{
public:
    string RecognitionStatus;
    ULONG Offset;
    ULONG Duration;
    std::list<NBest> NBest;
};
void from_json(const nlohmann::json& j, SegmentResult& sr) {
    j.at("RecognitionStatus").get_to(sr.RecognitionStatus);
    j.at("Offset").get_to(sr.Offset);
    j.at("Duration").get_to(sr.Duration);
    sr.NBest = j.at("NBest").get<list<NBest>>();
}

class AudioFileResult
{
public:
    string AudioFileName;
    std::list<SegmentResult> SegmentResults;
    std::list<Result> CombinedResults;
};
void from_json(const nlohmann::json& j, AudioFileResult& arf) {
    j.at("AudioFileName").get_to(arf.AudioFileName);
    arf.SegmentResults = j.at("SegmentResults").get<list<SegmentResult>>();
    arf.CombinedResults = j.at("CombinedResults").get<list<Result>>();
}

class RootObject {
public:
    std::list<AudioFileResult> AudioFileResults;
};
void from_json(const nlohmann::json& j, RootObject& r) {
    r.AudioFileResults = j.at("AudioFileResults").get<list<AudioFileResult>>();
}

Vytvoření a konfigurace klienta httpCreate and configure an Http Client

První věc, kterou budeme potřebovat, je klient http, který má správnou základní adresu URL a sadu ověřování.The first thing we'll need is an Http Client that has a correct base URL and authentication set. Vložit tento kód dorecognizeSpeechInsert this code in recognizeSpeech

utility::string_t service_url = U("https://") + region + U(".cris.ai/api/speechtotext/v2.0/Transcriptions/");
uri u(service_url);

http_client c(u);
http_request msg(methods::POST);
msg.headers().add(U("Content-Type"), U("application/json"));
msg.headers().add(U("Ocp-Apim-Subscription-Key"), subscriptionKey);

Generovat žádost o přepisGenerate a transcription request

Dále vygenerujeme žádost o přepis.Next, we'll generate the transcription request. Přidat tento kód dorecognizeSpeechAdd this code to recognizeSpeech

auto transportdef = TranscriptionDefinition::Create(name, description, myLocale, recordingsBlobUri);

nlohmann::json transportdefJSON = transportdef;

msg.set_body(transportdefJSON.dump());

Odeslat žádost a ověřit její stavSend the request and check its status

Nyní pošleme požadavek službě rozpoznávání řeči a zkontrolujeme kód prvotní odezvy.Now we post the request to the Speech service and check the initial response code. Tento kód odpovědi jednoduše indikuje, jestli služba požadavek přijala.This response code will simply indicate if the service has received the request. Služba vrátí adresu URL v hlavičkách odpovědi, kde je umístění, kde bude uložený stav přepisu.The service will return a Url in the response headers that's the location where it will store the transcription status.


auto response = c.request(msg).get();
auto statusCode = response.status_code();

if (statusCode != status_codes::Accepted)
{
    cout << "Unexpected status code " << statusCode << endl;
    return;
}

string_t transcriptionLocation = response.headers()[U("location")];

cout << "Transcription status is located at " << converter.to_bytes(transcriptionLocation) << endl;

Počkejte, až se přepis dokončí.Wait for the transcription to complete

Vzhledem k tomu, že služba zpracovává přepis asynchronně, musíme dotazovat se na jeho stav, a to v každém případě často.Since the service processes the transcription asynchronously, we need to poll for its status every so often. Zkontrolujeme každých 5 sekund.We'll check every 5 seconds.

Stav můžeme zjistit načtením obsahu na adrese URL, kterou jsme dostali při odeslání žádosti.We can check the status by retrieving the content at the Url we got when the posted the request. Když získáme obsah zpátky, deserializovatme ho do jedné z našich pomocných tříd, aby bylo snazší pracovat s.When we get the content back, we deserialize it into one of our helper class to make it easier to interact with.

Toto je kód pro cyklické dotazování se zobrazením stavu pro vše s výjimkou úspěšného dokončení. provedeme to ještě dál.Here's the polling code with status display for everything except a successful completion, we'll do that next.

bool completed = false;

while (!completed)
{
    auto statusResponse = statusCheckClient.request(statusCheckMessage).get();
    auto statusResponseCode = statusResponse.status_code();

    if (statusResponseCode != status_codes::OK)
    {
        cout << "Fetching the transcription returned unexpected http code " << statusResponseCode << endl;
        return;
    }

    auto body = statusResponse.extract_string().get();
    nlohmann::json statusJSON = nlohmann::json::parse(body);
    Transcription transcriptonStatus = statusJSON;

    if (!_stricmp(transcriptonStatus.status.c_str(), "Failed"))
    {
        completed = true;
        cout << "Transcription has failed " << transcriptonStatus.statusMessage << endl;
    }
    else if (!_stricmp(transcriptonStatus.status.c_str(), "Succeeded"))
    {
    }
    else if (!_stricmp(transcriptonStatus.status.c_str(), "Running"))
    {
        cout << "Transcription is running." << endl;
    }
    else if (!_stricmp(transcriptonStatus.status.c_str(), "NotStarted"))
    {
        cout << "Transcription has not started." << endl;
    }

    if (!completed) {
        Sleep(5000);
    }

}

Zobrazení výsledků přepisuDisplay the transcription results

Po úspěšném dokončení přepisu budou výsledky uloženy v jiné adrese URL, kterou můžeme získat z odpovědi na stav.Once the service has successfully completed the transcription the results will be stored in another Url that we can get from the status response.

Stáhneme obsah této adresy URL, deserializaci JSON a projdete výsledky vytištěním zobrazovaného textu.We'll download the contents of that URL, deserialize the JSON, and loop through the results printing out the display text as we go.

completed = true;
cout << "Success!" << endl;
string result = transcriptonStatus.resultsUrls["channel_0"];
cout << "Transcription has completed. Results are at " << result << endl;
cout << "Fetching results" << endl;

http_client result_client(converter.from_bytes(result));
http_request resultMessage(methods::GET);
resultMessage.headers().add(U("Ocp-Apim-Subscription-Key"), subscriptionKey);

auto resultResponse = result_client.request(resultMessage).get();

auto responseCode = resultResponse.status_code();

if (responseCode != status_codes::OK)
{
    cout << "Fetching the transcription returned unexpected http code " << responseCode << endl;
    return;
}

auto resultBody = resultResponse.extract_string().get();

nlohmann::json resultJSON = nlohmann::json::parse(resultBody);
RootObject root = resultJSON;

for (AudioFileResult af : root.AudioFileResults)
{
    cout << "There were " << af.SegmentResults.size() << " results in " << af.AudioFileName << endl;
    
    for (SegmentResult segResult : af.SegmentResults)
    {
        cout << "Status: " << segResult.RecognitionStatus << endl;

        if (!_stricmp(segResult.RecognitionStatus.c_str(), "success") && segResult.NBest.size() > 0)
        {
            cout << "Best text result was: '" << segResult.NBest.front().Display << "'" << endl;
        }
    }
}

Kontrolovat kódCheck your code

V tomto okamžiku by váš kód měl vypadat takto: (do této verze jsme přidali nějaké komentáře.)At this point, your code should look like this: (We've added some comments to this version)

#include <iostream>
#include <strstream>
#include <Windows.h>
#include <locale>
#include <codecvt>
#include <string>

#include <cpprest/http_client.h>
#include <cpprest/filestream.h>
#include <nlohmann/json.hpp>

using namespace std;
using namespace utility;                    // Common utilities like string conversions
using namespace web;                        // Common features like URIs.
using namespace web::http;                  // Common HTTP functionality
using namespace web::http::client;          // HTTP client features
using namespace concurrency::streams;       // Asynchronous streams
using json = nlohmann::json;

const string_t region = U("YourServiceRegion");
const string_t subscriptionKey = U("YourSubscriptionKey");
const string name = "Simple transcription";
const string description = "Simple transcription description";
const string myLocale = "en-US";
const string recordingsBlobUri = "YourFileUrl";

class TranscriptionDefinition {
private:
    TranscriptionDefinition(string name,
        string description,
        string locale,
        string recordingsUrl,
        std::list<string> models) {

        Name = name;
        Description = description;
        RecordingsUrl = recordingsUrl;
        Locale = locale;
        Models = models;
    }

public:
    string Name;
    string Description;
    string RecordingsUrl;
    string Locale;
    std::list<string> Models;
    std::map<string, string> properties;

    static TranscriptionDefinition Create(string name, string description, string locale, string recordingsUrl) {
        return TranscriptionDefinition(name, description, locale, recordingsUrl, std::list<string>());
    }
    static TranscriptionDefinition Create(string name, string description, string locale, string recordingsUrl,
        std::list<string> models) {
        return TranscriptionDefinition(name, description, locale, recordingsUrl, models);
    }
};

void to_json(nlohmann::json& j, const TranscriptionDefinition& t) {
    j = nlohmann::json{
            { "description", t.Description },
            { "locale", t.Locale },
            { "models", t.Models },
            { "name", t.Name },
            { "properties", t.properties },
            { "recordingsurl",t.RecordingsUrl }
    };
};

void from_json(const nlohmann::json& j, TranscriptionDefinition& t) {
    j.at("locale").get_to(t.Locale);
    j.at("models").get_to(t.Models);
    j.at("name").get_to(t.Name);
    j.at("properties").get_to(t.properties);
    j.at("recordingsurl").get_to(t.RecordingsUrl);
}

class Transcription {
public:
    string name;
    string description;
    string locale;
    string recordingsUrl;
    map<string, string> resultsUrls;
    string id;
    string createdDateTime;
    string lastActionDateTime;
    string status;
    string statusMessage;
};

void to_json(nlohmann::json& j, const Transcription& t) {
    j = nlohmann::json{
            { "description", t.description },
            { "locale", t.locale },
            { "createddatetime", t.createdDateTime },
            { "name", t.name },
            { "id", t.id },
            { "recordingsurl",t.recordingsUrl },
            { "resultUrls", t.resultsUrls},
            { "status", t.status},
            { "statusmessage", t.statusMessage}
    };
};

void from_json(const nlohmann::json& j, Transcription& t) {
    j.at("description").get_to(t.description);
    j.at("locale").get_to(t.locale);
    j.at("createdDateTime").get_to(t.createdDateTime);
    j.at("name").get_to(t.name);
    j.at("recordingsUrl").get_to(t.recordingsUrl);
    t.resultsUrls = j.at("resultsUrls").get<map<string, string>>();
    j.at("status").get_to(t.status);
    j.at("statusMessage").get_to(t.statusMessage);
}
class Result
{
public:
    string Lexical;
    string ITN;
    string MaskedITN;
    string Display;
};
void from_json(const nlohmann::json& j, Result& r) {
    j.at("Lexical").get_to(r.Lexical);
    j.at("ITN").get_to(r.ITN);
    j.at("MaskedITN").get_to(r.MaskedITN);
    j.at("Display").get_to(r.Display);
}

class NBest : public Result
{
public:
    double Confidence;	
};
void from_json(const nlohmann::json& j, NBest& nb) {
    j.at("Confidence").get_to(nb.Confidence);
    j.at("Lexical").get_to(nb.Lexical);
    j.at("ITN").get_to(nb.ITN);
    j.at("MaskedITN").get_to(nb.MaskedITN);
    j.at("Display").get_to(nb.Display);
}

class SegmentResult
{
public:
    string RecognitionStatus;
    ULONG Offset;
    ULONG Duration;
    std::list<NBest> NBest;
};
void from_json(const nlohmann::json& j, SegmentResult& sr) {
    j.at("RecognitionStatus").get_to(sr.RecognitionStatus);
    j.at("Offset").get_to(sr.Offset);
    j.at("Duration").get_to(sr.Duration);
    sr.NBest = j.at("NBest").get<list<NBest>>();
}

class AudioFileResult
{
public:
    string AudioFileName;
    std::list<SegmentResult> SegmentResults;
    std::list<Result> CombinedResults;
};
void from_json(const nlohmann::json& j, AudioFileResult& arf) {
    j.at("AudioFileName").get_to(arf.AudioFileName);
    arf.SegmentResults = j.at("SegmentResults").get<list<SegmentResult>>();
    arf.CombinedResults = j.at("CombinedResults").get<list<Result>>();
}

class RootObject {
public:
    std::list<AudioFileResult> AudioFileResults;
};
void from_json(const nlohmann::json& j, RootObject& r) {
    r.AudioFileResults = j.at("AudioFileResults").get<list<AudioFileResult>>();
}


void recognizeSpeech()
{
    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t >> converter;

    utility::string_t service_url = U("https://") + region + U(".cris.ai/api/speechtotext/v2.0/Transcriptions/");
    uri u(service_url);

    http_client c(u);
    http_request msg(methods::POST);
    msg.headers().add(U("Content-Type"), U("application/json"));
    msg.headers().add(U("Ocp-Apim-Subscription-Key"), subscriptionKey);

    auto transportdef = TranscriptionDefinition::Create(name, description, myLocale, recordingsBlobUri);

    nlohmann::json transportdefJSON = transportdef;

    msg.set_body(transportdefJSON.dump());

    auto response = c.request(msg).get();
    auto statusCode = response.status_code();

    if (statusCode != status_codes::Accepted)
    {
        cout << "Unexpected status code " << statusCode << endl;
        return;
    }

    string_t transcriptionLocation = response.headers()[U("location")];

    cout << "Transcription status is located at " << converter.to_bytes(transcriptionLocation) << endl;

    http_client statusCheckClient(transcriptionLocation);
    http_request statusCheckMessage(methods::GET);
    statusCheckMessage.headers().add(U("Ocp-Apim-Subscription-Key"), subscriptionKey);

    bool completed = false;

    while (!completed)
    {
        auto statusResponse = statusCheckClient.request(statusCheckMessage).get();
        auto statusResponseCode = statusResponse.status_code();

        if (statusResponseCode != status_codes::OK)
        {
            cout << "Fetching the transcription returned unexpected http code " << statusResponseCode << endl;
            return;
        }

        auto body = statusResponse.extract_string().get();
        nlohmann::json statusJSON = nlohmann::json::parse(body);
        Transcription transcriptonStatus = statusJSON;

        if (!_stricmp(transcriptonStatus.status.c_str(), "Failed"))
        {
            completed = true;
            cout << "Transcription has failed " << transcriptonStatus.statusMessage << endl;
        }
        else if (!_stricmp(transcriptonStatus.status.c_str(), "Succeeded"))
        {
            completed = true;
            cout << "Success!" << endl;
            string result = transcriptonStatus.resultsUrls["channel_0"];
            cout << "Transcription has completed. Results are at " << result << endl;
            cout << "Fetching results" << endl;

            http_client result_client(converter.from_bytes(result));
            http_request resultMessage(methods::GET);
            resultMessage.headers().add(U("Ocp-Apim-Subscription-Key"), subscriptionKey);

            auto resultResponse = result_client.request(resultMessage).get();

            auto responseCode = resultResponse.status_code();

            if (responseCode != status_codes::OK)
            {
                cout << "Fetching the transcription returned unexpected http code " << responseCode << endl;
                return;
            }

            auto resultBody = resultResponse.extract_string().get();
            
            nlohmann::json resultJSON = nlohmann::json::parse(resultBody);
            RootObject root = resultJSON;

            for (AudioFileResult af : root.AudioFileResults)
            {
                cout << "There were " << af.SegmentResults.size() << " results in " << af.AudioFileName << endl;
                
                for (SegmentResult segResult : af.SegmentResults)
                {
                    cout << "Status: " << segResult.RecognitionStatus << endl;

                    if (!_stricmp(segResult.RecognitionStatus.c_str(), "success") && segResult.NBest.size() > 0)
                    {
                        cout << "Best text result was: '" << segResult.NBest.front().Display << "'" << endl;
                    }
                }
            }
        }
        else if (!_stricmp(transcriptonStatus.status.c_str(), "Running"))
        {
            cout << "Transcription is running." << endl;
        }
        else if (!_stricmp(transcriptonStatus.status.c_str(), "NotStarted"))
        {
            cout << "Transcription has not started." << endl;
        }

        if (!completed) {
            Sleep(5000);
        }

    }
}

int wmain()
{
    recognizeSpeech();
    cout << "Please press a key to continue.\n";
    cin.get();
    return 0;
}

Sestavení a spuštění aplikaceBuild and run your app

Nyní jste připraveni sestavit aplikaci a otestovat rozpoznávání řeči pomocí služby Speech.Now you're ready to build your app and test our speech recognition using the Speech service.

Další krokyNext steps


V tomto rychlém startu použijete REST API k rozpoznávání řeči ze souborů v dávkovém procesu.In this quickstart, you will use a REST API to recognize speech from files in a batch process. Dávkový proces spustí přepis řeči bez jakýchkoli interakcí uživatele.A batch process executes the speech transcription without any user interactions. Poskytuje jednoduchý programovací model bez nutnosti spravovat souběžnost, vlastní modely řeči nebo jiné podrobnosti.It gives you a simple programming model, without the need to manage concurrency, custom speech models, or other details. Zahrnuje pokročilé možnosti kontroly a přitom efektivní využívání prostředků služby Azure Speech Service.It entails advanced control options, while making efficient use of Azure speech service resources.

Další informace o dostupných možnostech a podrobnostech konfigurace najdete v tématu Batch přepis.For more information on the available options and configuration details, see batch transcription.

Následující rychlý Start vás provede ukázkou použití.The following quickstart will walk you through a usage sample.

Pokud si přejete přejít přímo v, můžete si prohlédnout nebo stáhnout všechny ukázky sady Speech SDK Java na GitHubu.If you prefer to jump right in, view or download all Speech SDK Java Samples on GitHub. V opačném případě můžeme začít.Otherwise, let's get started.

PožadavkyPrerequisites

Než začnete, nezapomeňte:Before you get started, make sure to:

Otevření projektu v zatměníOpen your project in Eclipse

Prvním krokem je ujistit se, že máte projekt otevřený v zatmění.The first step is to make sure that you have your project open in Eclipse.

  1. Spuštění EclipseLaunch Eclipse
  2. Načtěte projekt a otevřete Main.java.Load your project and open Main.java.

Přidat odkaz na gsonAdd a reference to Gson

V tomto rychlém startu použijeme externí serializátor/deserializaci JSON.We'll be using an external JSON serializer / deserializer in this quickstart. Pro Java jsme zvolili gson.For Java we've chosen Gson.

Otevřete soubor pom. XML a přidejte následující odkaz.Open your pom.xml and add the following reference.

<dependencies>
  <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.8.6</version>
  </dependency>
</dependencies>

Začínáme s některým často používaným kódemStart with some boilerplate code

Pojďme přidat kód, který funguje jako kostra pro náš projekt.Let's add some code that works as a skeleton for our project.

package quickstart;

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Date;
import java.util.Dictionary;
import java.util.Hashtable;
import java.util.UUID;

import com.google.gson.Gson;
public class Main {

    private static String region = "YourServiceRegion";
    private static String subscriptionKey = "YourSubscriptionKey";
    private static String Locale = "en-US";
    private static String RecordingsBlobUri = "YourFileUrl";
    private static String Name = "Simple transcription";
    private static String Description = "Simple transcription description";

    public static void main(String[] args) throws IOException, InterruptedException {
        System.out.println("Starting transcriptions client...");
    }
}

Budete muset nahradit následující hodnoty:You'll need to replace the following values:

  • YourSubscriptionKey: nachází se na stránce klíče Azure Portal pro prostředek řeči.YourSubscriptionKey: found in the the Keys page of the Azure portal for the Speech resource
  • YourServiceRegion: nachází se na stránce přehled Azure Portal pro prostředek řeči.YourServiceRegion: found in the the Overview page of the Azure portal for the Speech resource
  • YourFileUrl: nachází se na stránce BLOB Service/kontejnery Azure Portal prostředku účtu úložiště.YourFileUrl: found in under the Blob service / Containers page of the Azure portal for the Storage account resource
    • Vyberte příslušný kontejner.Select the appropriate container
    • Vyberte požadovaný objekt BLOB.Select the desired blob
    • Zkopírujte adresu URL pod stránku vlastnostiCopy the URL under the Properties page

Obálky JSONJSON Wrappers

Jak REST API přijímá požadavky ve formátu JSON a také vrátí výsledky ve formátu JSON, můžeme s nimi pracovat jenom s řetězci, ale to se nedoporučuje.As the REST API's take requests in JSON format and also return results in JSON we could interact with them using only strings, but that's not recommended. Aby bylo možné žádosti a odpovědi snadněji spravovat, deklarujeme několik tříd, které se použijí pro serializaci nebo deserializaci JSON.In order to make the requests and responses easier to manage, we'll declare a few classes to use for serializing / deserializing the JSON.

Pokračujte a uveďte jejich deklarace dřív Main.Go ahead and put their declarations before Main.

final class Transcription {
    public String name;
    public String description;
    public String locale;
    public URL recordingsUrl;
    public Hashtable<String, String> resultsUrls;
    public UUID id;
    public Date createdDateTime;
    public Date lastActionDateTime;
    public String status;
    public String statusMessage;
}

final class TranscriptionDefinition {
    private TranscriptionDefinition(String name, String description, String locale, URL recordingsUrl,
            ModelIdentity[] models) {
        this.Name = name;
        this.Description = description;
        this.RecordingsUrl = recordingsUrl;
        this.Locale = locale;
        this.Models = models;
        this.properties = new Hashtable<String, String>();
        this.properties.put("PunctuationMode", "DictatedAndAutomatic");
        this.properties.put("ProfanityFilterMode", "Masked");
        this.properties.put("AddWordLevelTimestamps", "True");
    }

    public String Name;
    public String Description;
    public URL RecordingsUrl;
    public String Locale;
    public ModelIdentity[] Models;
    public Dictionary<String, String> properties;

    public static TranscriptionDefinition Create(String name, String description, String locale, URL recordingsUrl) {
        return TranscriptionDefinition.Create(name, description, locale, recordingsUrl, new ModelIdentity[0]);
    }

    public static TranscriptionDefinition Create(String name, String description, String locale, URL recordingsUrl,
            ModelIdentity[] models) {
        return new TranscriptionDefinition(name, description, locale, recordingsUrl, models);
    }
}

final class ModelIdentity {
    private ModelIdentity(UUID id) {
        this.Id = id;
    }

    public UUID Id;

    public static ModelIdentity Create(UUID Id) {
        return new ModelIdentity(Id);
    }
}

class AudioFileResult {
    public String AudioFileName;
    public SegmentResult[] SegmentResults;
}

class RootObject {
    public AudioFileResult[] AudioFileResults;
}

class NBest {
    public double Confidence;
    public String Lexical;
    public String ITN;
    public String MaskedITN;
    public String Display;
}

class SegmentResult {
    public String RecognitionStatus;
    public String Offset;
    public String Duration;
    public NBest[] NBest;
}

Vytvoření a konfigurace klienta httpCreate and configure an Http Client

První věc, kterou budeme potřebovat, je klient http, který má správnou základní adresu URL a sadu ověřování.The first thing we'll need is an Http Client that has a correct base URL and authentication set. Vložit tento kód do Main[!code-java]Insert this code in Main [!code-java]

Generovat žádost o přepisGenerate a transcription request

Dále vygenerujeme žádost o přepis.Next, we'll generate the transcription request. Přidat tento kód do Main[!code-java]Add this code to Main [!code-java]

Odeslat žádost a ověřit její stavSend the request and check its status

Nyní pošleme požadavek službě rozpoznávání řeči a zkontrolujeme kód prvotní odezvy.Now we post the request to the Speech service and check the initial response code. Tento kód odpovědi jednoduše indikuje, jestli služba požadavek přijala.This response code will simply indicate if the service has received the request. Služba vrátí adresu URL v hlavičkách odpovědi, kde je umístění, kde bude uložený stav přepisu.The service will return a Url in the response headers that's the location where it will store the transcription status.

Gson gson = new Gson();

OutputStream stream = postConnection.getOutputStream();
stream.write(gson.toJson(definition).getBytes());
stream.flush();

int statusCode = postConnection.getResponseCode();

if (statusCode != HttpURLConnection.HTTP_ACCEPTED) {
    System.out.println("Unexpected status code " + statusCode);
    return;
}

Počkejte, až se přepis dokončí.Wait for the transcription to complete

Vzhledem k tomu, že služba zpracovává přepis asynchronně, musíme dotazovat se na jeho stav, a to v každém případě často.Since the service processes the transcription asynchronously, we need to poll for its status every so often. Zkontrolujeme každých 5 sekund.We'll check every 5 seconds.

Stav můžeme zjistit načtením obsahu na adrese URL, kterou jsme dostali při odeslání žádosti.We can check the status by retrieving the content at the Url we got when the posted the request. Když získáme obsah zpátky, deserializovatme ho do jedné z našich pomocných tříd, aby bylo snazší pracovat s.When we get the content back, we deserialize it into one of our helper class to make it easier to interact with.

Toto je kód pro cyklické dotazování se zobrazením stavu pro vše s výjimkou úspěšného dokončení. provedeme to ještě dál.Here's the polling code with status display for everything except a successful completion, we'll do that next.

String transcriptionLocation = postConnection.getHeaderField("location");

System.out.println("Transcription is located at " + transcriptionLocation);

URL transcriptionUrl = new URL(transcriptionLocation);

boolean completed = false;
while (!completed) {
    {
        HttpURLConnection getConnection = (HttpURLConnection) transcriptionUrl.openConnection();
        getConnection.setRequestProperty("Ocp-Apim-Subscription-Key", subscriptionKey);
        getConnection.setRequestMethod("GET");

        int responseCode = getConnection.getResponseCode();

        if (responseCode != HttpURLConnection.HTTP_OK) {
            System.out.println("Fetching the transcription returned unexpected http code " + responseCode);
            return;
        }

        Transcription t = gson.fromJson(new InputStreamReader(getConnection.getInputStream()),
                Transcription.class);

        switch (t.status) {
        case "Failed":
            completed = true;
            System.out.println("Transcription has failed " + t.statusMessage);
            break;
        case "Succeeded":
            break;
        case "Running":
            System.out.println("Transcription is running.");
            break;
        case "NotStarted":
            System.out.println("Transcription has not started.");
            break;
        }

        if (!completed) {
            Thread.sleep(5000);
        }
    }

Zobrazení výsledků přepisuDisplay the transcription results

Po úspěšném dokončení přepisu budou výsledky uloženy v jiné adrese URL, kterou můžeme získat z odpovědi na stav.Once the service has successfully completed the transcription the results will be stored in another Url that we can get from the status response.

Stáhneme obsah této adresy URL, deserializaci JSON a projdete výsledky vytištěním zobrazovaného textu.We'll download the contents of that URL, deserialize the JSON, and loop through the results printing out the display text as we go.

package quickstart;

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Date;
import java.util.Dictionary;
import java.util.Hashtable;
import java.util.UUID;

import com.google.gson.Gson;

final class Transcription {
    public String name;
    public String description;
    public String locale;
    public URL recordingsUrl;
    public Hashtable<String, String> resultsUrls;
    public UUID id;
    public Date createdDateTime;
    public Date lastActionDateTime;
    public String status;
    public String statusMessage;
}

final class TranscriptionDefinition {
    private TranscriptionDefinition(String name, String description, String locale, URL recordingsUrl,
            ModelIdentity[] models) {
        this.Name = name;
        this.Description = description;
        this.RecordingsUrl = recordingsUrl;
        this.Locale = locale;
        this.Models = models;
        this.properties = new Hashtable<String, String>();
        this.properties.put("PunctuationMode", "DictatedAndAutomatic");
        this.properties.put("ProfanityFilterMode", "Masked");
        this.properties.put("AddWordLevelTimestamps", "True");
    }

    public String Name;
    public String Description;
    public URL RecordingsUrl;
    public String Locale;
    public ModelIdentity[] Models;
    public Dictionary<String, String> properties;

    public static TranscriptionDefinition Create(String name, String description, String locale, URL recordingsUrl) {
        return TranscriptionDefinition.Create(name, description, locale, recordingsUrl, new ModelIdentity[0]);
    }

    public static TranscriptionDefinition Create(String name, String description, String locale, URL recordingsUrl,
            ModelIdentity[] models) {
        return new TranscriptionDefinition(name, description, locale, recordingsUrl, models);
    }
}

final class ModelIdentity {
    private ModelIdentity(UUID id) {
        this.Id = id;
    }

    public UUID Id;

    public static ModelIdentity Create(UUID Id) {
        return new ModelIdentity(Id);
    }
}

class AudioFileResult {
    public String AudioFileName;
    public SegmentResult[] SegmentResults;
}

class RootObject {
    public AudioFileResult[] AudioFileResults;
}

class NBest {
    public double Confidence;
    public String Lexical;
    public String ITN;
    public String MaskedITN;
    public String Display;
}

class SegmentResult {
    public String RecognitionStatus;
    public String Offset;
    public String Duration;
    public NBest[] NBest;
}

public class Main {

    private static String region = "YourServiceRegion";
    private static String subscriptionKey = "YourSubscriptionKey";
    private static String Locale = "en-US";
    private static String RecordingsBlobUri = "YourFileUrl";
    private static String Name = "Simple transcription";
    private static String Description = "Simple transcription description";

    public static void main(String[] args) throws IOException, InterruptedException {
        System.out.println("Starting transcriptions client...");
        String url = "https://" + region + ".cris.ai/api/speechtotext/v2.0/Transcriptions/";
        URL serviceUrl = new URL(url);

        HttpURLConnection postConnection = (HttpURLConnection) serviceUrl.openConnection();
        postConnection.setDoOutput(true);
        postConnection.setRequestMethod("POST");
        postConnection.setRequestProperty("Content-Type", "application/json");
        postConnection.setRequestProperty("Ocp-Apim-Subscription-Key", subscriptionKey);

        TranscriptionDefinition definition = TranscriptionDefinition.Create(Name, Description, Locale,
                new URL(RecordingsBlobUri));

        Gson gson = new Gson();

        OutputStream stream = postConnection.getOutputStream();
        stream.write(gson.toJson(definition).getBytes());
        stream.flush();

        int statusCode = postConnection.getResponseCode();

        if (statusCode != HttpURLConnection.HTTP_ACCEPTED) {
            System.out.println("Unexpected status code " + statusCode);
            return;
        }

        String transcriptionLocation = postConnection.getHeaderField("location");

        System.out.println("Transcription is located at " + transcriptionLocation);

        URL transcriptionUrl = new URL(transcriptionLocation);

        boolean completed = false;
        while (!completed) {
            {
                HttpURLConnection getConnection = (HttpURLConnection) transcriptionUrl.openConnection();
                getConnection.setRequestProperty("Ocp-Apim-Subscription-Key", subscriptionKey);
                getConnection.setRequestMethod("GET");

                int responseCode = getConnection.getResponseCode();

                if (responseCode != HttpURLConnection.HTTP_OK) {
                    System.out.println("Fetching the transcription returned unexpected http code " + responseCode);
                    return;
                }

                Transcription t = gson.fromJson(new InputStreamReader(getConnection.getInputStream()),
                        Transcription.class);

                switch (t.status) {
                case "Failed":
                    completed = true;
                    System.out.println("Transcription has failed " + t.statusMessage);
                    break;
                case "Succeeded":
                    completed = true;
                    String result = t.resultsUrls.get("channel_0");
                    System.out.println("Transcription has completed. Results are at " + result);

                    System.out.println("Fetching results");
                    URL resultUrl = new URL(result);

                    HttpURLConnection resultConnection = (HttpURLConnection) resultUrl.openConnection();
                    resultConnection.setRequestProperty("Ocp-Apim-Subscription-Key", subscriptionKey);
                    resultConnection.setRequestMethod("GET");

                    responseCode = resultConnection.getResponseCode();

                    if (responseCode != HttpURLConnection.HTTP_OK) {
                        System.out.println("Fetching the transcription returned unexpected http code " + responseCode);
                        return;
                    }

                    RootObject root = gson.fromJson(new InputStreamReader(resultConnection.getInputStream()),
                            RootObject.class);

                    for (AudioFileResult af : root.AudioFileResults) {
                        System.out
                                .println("There were " + af.SegmentResults.length + " results in " + af.AudioFileName);
                        for (SegmentResult segResult : af.SegmentResults) {
                            System.out.println("Status: " + segResult.RecognitionStatus);
                            if (segResult.RecognitionStatus.equalsIgnoreCase("success") && segResult.NBest.length > 0) {
                                System.out.println("Best text result was: '" + segResult.NBest[0].Display + "'");
                            }
                        }
                    }

                    break;
                case "Running":
                    System.out.println("Transcription is running.");
                    break;
                case "NotStarted":
                    System.out.println("Transcription has not started.");
                    break;
                }

                if (!completed) {
                    Thread.sleep(5000);
                }
            }
        }
    }
}

Kontrolovat kódCheck your code

V tomto okamžiku by váš kód měl vypadat takto: (do této verze jsme přidali nějaké komentáře.) [! Code-Java [] (~/samples-cognitive-services-speech-sdk/quickstart/java/jre/from-blob/src/quickstart/Main.java]At this point, your code should look like this: (We've added some comments to this version) [!code-java[](~/samples-cognitive-services-speech-sdk/quickstart/java/jre/from-blob/src/quickstart/Main.java]

Sestavení a spuštění aplikaceBuild and run your app

Nyní jste připraveni sestavit aplikaci a otestovat rozpoznávání řeči pomocí služby Speech.Now you're ready to build your app and test our speech recognition using the Speech service.

Další krokyNext steps

V tomto rychlém startu použijete REST API k rozpoznávání řeči ze souborů v dávkovém procesu.In this quickstart, you will use a REST API to recognize speech from files in a batch process. Dávkový proces spustí přepis řeči bez jakýchkoli interakcí uživatele.A batch process executes the speech transcription without any user interactions. Poskytuje jednoduchý programovací model bez nutnosti spravovat souběžnost, vlastní modely řeči nebo jiné podrobnosti.It gives you a simple programming model, without the need to manage concurrency, custom speech models, or other details. Zahrnuje pokročilé možnosti kontroly a přitom efektivní využívání prostředků služby Azure Speech Service.It entails advanced control options, while making efficient use of Azure speech service resources.

Další informace o dostupných možnostech a podrobnostech konfigurace najdete v tématu Batch přepis.For more information on the available options and configuration details, see batch transcription.

Následující rychlý Start vás provede ukázkou použití.The following quickstart will walk you through a usage sample.

Pokud si přejete přejít přímo do, zobrazte si nebo Stáhněte si ukázky Python SDK pro řeč na GitHubu.If you prefer to jump right in, view or download all Speech SDK Python Samples on GitHub. V opačném případě můžeme začít.Otherwise, let's get started.

PožadavkyPrerequisites

Než začnete, nezapomeňte:Before you get started, make sure to:

Stažení a instalace klientské knihovny rozhraní APIDownload and install the API client library

Chcete-li spustit ukázku, je třeba vygenerovat knihovnu Python pro REST API, která je generována prostřednictvím Swagger.To execute the sample you need to generate the Python library for the REST API which is generated through Swagger.

Pro instalaci použijte tento postup:Follow these steps for the installation:

  1. Přejděte do části https://editor.swagger.io (Soubor > Nový > Jiné).Go to https://editor.swagger.io.
  2. Klikněte na soubora pak na importovat adresu URL.Click File, then click Import URL.
  3. Zadejte adresu URL Swagger, včetně oblasti pro předplatné služby Speech: https://<your-region>.cris.ai/docs/v2.0/swagger.Enter the Swagger URL including the region for your Speech service subscription: https://<your-region>.cris.ai/docs/v2.0/swagger.
  4. Klikněte na vygenerovat klienta a vyberte Python.Click Generate Client and select Python.
  5. Uložte klientskou knihovnu.Save the client library.
  6. Extrahujte stažený soubor Python-Client-Generated. zip někam do systému souborů.Extract the downloaded python-client-generated.zip somewhere in your file system.
  7. Do prostředí Pythonu nainstalujte extrahovaný klientský modul Pythonu pomocí PIP: pip install path/to/package/python-client.Install the extracted python-client module in your Python environment using pip: pip install path/to/package/python-client.
  8. Instalovaný balíček má název swagger_client.The installed package has the name swagger_client. Pomocí příkazu python -c "import swagger_client"můžete ověřit, zda byla instalace úspěšná.You can check that the installation worked using the command python -c "import swagger_client".

Poznámka

Kvůli známé chybě v modulu pro vytváření Swaggermůže dojít k chybám při importu swagger_client balíčku.Due to a known bug in the Swagger autogeneration, you might encounter errors on importing the swagger_client package. Ty je možné opravit odstraněním řádku s obsahem.These can be fixed by deleting the line with the content

from swagger_client.models.model import Model  # noqa: F401,E501

ze souboru swagger_client/models/model.py a řádku s obsahemfrom the file swagger_client/models/model.py and the line with the content

from swagger_client.models.inner_error import InnerError  # noqa: F401,E501

ze souboru swagger_client/models/inner_error.py uvnitř nainstalovaného balíčku.from the file swagger_client/models/inner_error.py inside the installed package. Chybová zpráva vám sdělí, kde jsou tyto soubory umístěny pro vaši instalaci.The error message will tell you where these files are located for your installation.

Nainstalovat další závislostiInstall other dependencies

Ukázka používá requests knihovnu.The sample uses the requests library. Můžete ji nainstalovat pomocí příkazuYou can install it with the command

pip install requests

Začínáme s některým často používaným kódemStart with some boilerplate code

Pojďme přidat kód, který funguje jako kostra pro náš projekt.Let's add some code that works as a skeleton for our project.

#!/usr/bin/env python
# coding: utf-8
from typing import List

import logging
import sys
import requests
import time
import swagger_client as cris_client


logging.basicConfig(stream=sys.stdout, level=logging.DEBUG, format="%(message)s")

# Your subscription key and region for the speech service
SUBSCRIPTION_KEY = "YourSubscriptionKey"
SERVICE_REGION = "YourServiceRegion"

NAME = "Simple transcription"
DESCRIPTION = "Simple transcription description"

LOCALE = "en-US"
RECORDINGS_BLOB_URI = "<Your SAS Uri to the recording>"

# Set subscription information when doing transcription with custom models
ADAPTED_ACOUSTIC_ID = None  # guid of a custom acoustic model
ADAPTED_LANGUAGE_ID = None  # guid of a custom language model


def transcribe():
    logging.info("Starting transcription client...")


if __name__ == "__main__":
    transcribe()

Budete muset nahradit následující hodnoty:You'll need to replace the following values:

  • YourSubscriptionKey: nachází se na stránce klíče Azure Portal pro prostředek řeči.YourSubscriptionKey: found in the the Keys page of the Azure portal for the Speech resource
  • YourServiceRegion: nachází se na stránce přehled Azure Portal pro prostředek řeči.YourServiceRegion: found in the the Overview page of the Azure portal for the Speech resource
  • YourFileUrl: nachází se na stránce BLOB Service/kontejnery Azure Portal prostředku účtu úložiště.YourFileUrl: found in under the Blob service / Containers page of the Azure portal for the Storage account resource
    • Vyberte příslušný kontejner.Select the appropriate container
    • Vyberte požadovaný objekt BLOB.Select the desired blob
    • Zkopírujte adresu URL pod stránku vlastnostiCopy the URL under the Properties page

Vytvoření a konfigurace klienta httpCreate and configure an Http Client

První věc, kterou budeme potřebovat, je klient http, který má správnou základní adresu URL a sadu ověřování.The first thing we'll need is an Http Client that has a correct base URL and authentication set. Vložit tento kód do transcribe[!code-python]Insert this code in transcribe [!code-python]

Generovat žádost o přepisGenerate a transcription request

Dále vygenerujeme žádost o přepis.Next, we'll generate the transcription request. Přidat tento kód do transcribe[!code-python]Add this code to transcribe [!code-python]

Odeslat žádost a ověřit její stavSend the request and check its status

Nyní pošleme požadavek službě rozpoznávání řeči a zkontrolujeme kód prvotní odezvy.Now we post the request to the Speech service and check the initial response code. Tento kód odpovědi jednoduše indikuje, jestli služba požadavek přijala.This response code will simply indicate if the service has received the request. Služba vrátí adresu URL v hlavičkách odpovědi, kde je umístění, kde bude uložený stav přepisu.The service will return a Url in the response headers that's the location where it will store the transcription status.

data, status, headers = transcription_api.create_transcription_with_http_info(transcription_definition)

# extract transcription location from the headers
transcription_location: str = headers["location"]

# get the transcription Id from the location URI
created_transcription: str = transcription_location.split('/')[-1]

logging.info("Created new transcription with id {}".format(created_transcription))

Počkejte, až se přepis dokončí.Wait for the transcription to complete

Vzhledem k tomu, že služba zpracovává přepis asynchronně, musíme dotazovat se na jeho stav, a to v každém případě často.Since the service processes the transcription asynchronously, we need to poll for its status every so often. Zkontrolujeme každých 5 sekund.We'll check every 5 seconds.

Vytvoříme výčet všech přepisů, které prostředek služby Speech Service zpracovává, a hledáme ten, který jsme vytvořili.We'll enumerate all the transcriptions that this Speech service resource is processing and look for the one we created.

Toto je kód pro cyklické dotazování se zobrazením stavu pro vše s výjimkou úspěšného dokončení. provedeme to ještě dál.Here's the polling code with status display for everything except a successful completion, we'll do that next.

logging.info("Checking status.")

completed = False

while not completed:
    running, not_started = 0, 0

    # get all transcriptions for the user
    transcriptions: List[cris_client.Transcription] = transcription_api.get_transcriptions()

    # for each transcription in the list we check the status
    for transcription in transcriptions:
        if transcription.status in ("Failed", "Succeeded"):
            # we check to see if it was the transcription we created from this client
            if created_transcription != transcription.id:
                continue

            completed = True

            if transcription.status == "Succeeded":
            else:
                logging.info("Transcription failed :{}.".format(transcription.status_message))
                break
        elif transcription.status == "Running":
            running += 1
        elif transcription.status == "NotStarted":
            not_started += 1

    logging.info("Transcriptions status: "
            "completed (this transcription): {}, {} running, {} not started yet".format(
                completed, running, not_started))

    # wait for 5 seconds
    time.sleep(5)

Zobrazení výsledků přepisuDisplay the transcription results

Po úspěšném dokončení přepisu budou výsledky uloženy v jiné adrese URL, kterou můžeme získat z odpovědi na stav.Once the service has successfully completed the transcription the results will be stored in another Url that we can get from the status response.

Tady zobrazíme výsledek JSON a zobrazíme ho.Here we get that result JSON and display it.

results_uri = transcription.results_urls["channel_0"]
results = requests.get(results_uri)
logging.info("Transcription succeeded. Results: ")
logging.info(results.content.decode("utf-8"))

Kontrolovat kódCheck your code

V tomto okamžiku by váš kód měl vypadat takto: (do této verze jsme přidali nějaké komentáře.)[!code-python]At this point, your code should look like this: (We've added some comments to this version) [!code-python]

Sestavení a spuštění aplikaceBuild and run your app

Nyní jste připraveni sestavit aplikaci a otestovat rozpoznávání řeči pomocí služby Speech.Now you're ready to build your app and test our speech recognition using the Speech service.

Další krokyNext steps

V tomto rychlém startu použijete REST API k rozpoznávání řeči ze souborů v dávkovém procesu.In this quickstart, you will use a REST API to recognize speech from files in a batch process. Dávkový proces spustí přepis řeči bez jakýchkoli interakcí uživatele.A batch process executes the speech transcription without any user interactions. Poskytuje jednoduchý programovací model bez nutnosti spravovat souběžnost, vlastní modely řeči nebo jiné podrobnosti.It gives you a simple programming model, without the need to manage concurrency, custom speech models, or other details. Zahrnuje pokročilé možnosti kontroly a přitom efektivní využívání prostředků služby Azure Speech Service.It entails advanced control options, while making efficient use of Azure speech service resources.

Další informace o dostupných možnostech a podrobnostech konfigurace najdete v tématu Batch přepis.For more information on the available options and configuration details, see batch transcription.

Následující rychlý Start vás provede ukázkou použití.The following quickstart will walk you through a usage sample.

Pokud si přejete přejít přímo do, zobrazte si nebo Stáhněte si ukázky JavaScriptu pro sadu Speech SDK na GitHubu.If you prefer to jump right in, view or download all Speech SDK JavaScript Samples on GitHub. V opačném případě můžeme začít.Otherwise, let's get started.

PožadavkyPrerequisites

Než začnete, nezapomeňte:Before you get started, make sure to:

Vytvoření nového souboru JSCreate a new JS file

Prvním krokem je, abyste se ujistili, že máte projekt otevřený v oblíbeném editoru.The first step is to make sure that you have your project open in your favorite editor.

Zavolejte soubor index. js.Call your file index.js.

Začínáme s některým často používaným kódemStart with some boilerplate code

Pojďme přidat kód, který funguje jako kostra pro náš projekt.Let's add some code that works as a skeleton for our project.

const https = require("https");

// Replace with your subscription key
SubscriptionKey = "YourSubscriptionKey";

// Update with your service region
Region = "YourServiceRegion";
Port = 443;

// Recordings and locale
Locale = "en-US";
RecordingsBlobUri = "YourFileUrl";

// Name and description
Name = "Simple transcription";
Description = "Simple transcription description";

SpeechToTextBasePath = "/api/speechtotext/v2.0/";

Budete muset nahradit následující hodnoty:You'll need to replace the following values:

  • YourSubscriptionKey: nachází se na stránce klíče Azure Portal pro prostředek řeči.YourSubscriptionKey: found in the the Keys page of the Azure portal for the Speech resource
  • YourServiceRegion: nachází se na stránce přehled Azure Portal pro prostředek řeči.YourServiceRegion: found in the the Overview page of the Azure portal for the Speech resource
  • YourFileUrl: nachází se na stránce BLOB Service/kontejnery Azure Portal prostředku účtu úložiště.YourFileUrl: found in under the Blob service / Containers page of the Azure portal for the Storage account resource
    • Vyberte příslušný kontejner.Select the appropriate container
    • Vyberte požadovaný objekt BLOB.Select the desired blob
    • Zkopírujte adresu URL pod stránku vlastnostiCopy the URL under the Properties page

Obálky JSONJSON Wrappers

Jak REST API přijímá požadavky ve formátu JSON a také vrátí výsledky ve formátu JSON.As the REST API's take requests in JSON format and also return results in JSON. Abychom lépe pochopili žádosti a odpovědi, deklarujeme několik tříd, které se použijí pro serializaci nebo deserializaci formátu JSON.In order to make the requests and responses easier to understand, we'll declare a few classes to use for serializing / deserializing the JSON.

class ModelIdentity {
    id;
}

class Transcription {
    Name;
    Description;
    Locale;
    RecordingsUrl;
    ResultsUrls;
    Id;
    CreatedDateTime;
    LastActionDateTime;
    Status;
    StatusMessage;
}

class TranscriptionDefinition {
    Name;
    Description;
    RecordingsUrl;
    Locale;
    Models;
    Properties;
}

Vytvoří úvodní žádost o přepis.Create an initial transcription request.

Dále vygenerujeme žádost o přepis.Next, we'll generate the transcription request.

const ts = {
    Name: Name,
    Description: Description,
    Locale: Locale,
    RecordingsUrl: RecordingsBlobUri,
    Properties: {
        "PunctuationMode": "DictatedAndAutomatic",
        "ProfanityFilterMode": "Masked",
        "AddWordLevelTimestamps": "True"
    },
    Models: []
}

const postPayload = JSON.stringify(ts);

const startOptions = {
    hostname: Region + ".cris.ai",
    port: Port,
    path: SpeechToTextBasePath + "Transcriptions/",
    method: "POST",
    headers: {
        "Content-Type": "application/json",
        'Content-Length': postPayload.length,
        "Ocp-Apim-Subscription-Key": SubscriptionKey
    }
}

Odešlete žádost o přepis.Send the transcription request.

Nyní pošleme požadavek službě rozpoznávání řeči a zkontrolujeme kód prvotní odezvy.Now we post the request to the Speech service and check the initial response code. Tento kód odpovědi jednoduše indikuje, jestli služba požadavek přijala.This response code will simply indicate if the service has received the request. Služba vrátí adresu URL v hlavičkách odpovědi, kde je umístění, kde bude uložený stav přepisu.The service will return a Url in the response headers that's the location where it will store the transcription status.

Pak zavoláme metodu CheckTranscriptionStatus , která zkontroluje stav a nakonec vypíše výsledky.Then we'll call a method CheckTranscriptionStatus to check on the status and eventually print the results. Budeme implementovat CheckTranscriptionStatus Další.We'll implement CheckTranscriptionStatus next.

const request = https.request(startOptions, (response) => {
    if (response.statusCode != 202) {
        console.error("Error, status code " + response.statusCode);
    } else {

        const transcriptionLocation = response.headers.location;

        console.info("Created transcription at location " + transcriptionLocation);
        console.info("Checking status.");

        CheckTranscriptionStatus(transcriptionLocation);
    }
});

request.on("error", error => {
    console.error(error);
});

request.write(postPayload);
request.end();

Zkontroluje stav požadavků.Check the requests status

Vzhledem k tomu, že služba zpracovává přepis asynchronně, musíme dotazovat se na jeho stav, a to v každém případě často.Since the service processes the transcription asynchronously, we need to poll for its status every so often. Zkontrolujeme každých 5 sekund.We'll check every 5 seconds.

Stav můžeme zjistit načtením obsahu na adrese URL, kterou jsme dostali při odeslání žádosti.We can check the status by retrieving the content at the Url we got when the posted the request. Když získáme obsah zpátky, deserializovatme ho do jedné z našich pomocných tříd, aby bylo snazší pracovat s.When we get the content back, we deserialize it into one of our helper class to make it easier to interact with.

Toto je kód pro cyklické dotazování se zobrazením stavu pro vše s výjimkou úspěšného dokončení. provedeme to ještě dál.Here's the polling code with status display for everything except a successful completion, we'll do that next.

CheckTranscriptionStatuspřevezme adresu URL stavu z žádosti o přepis a každých 5 sekund se dotazuje, dokud neindikuje úspěch nebo a chybu.CheckTranscriptionStatus takes the status URL from the transcription request and polls it every 5 seconds until it indicates success or and error. Pak volá PrintResults k vytištění výsledků přepisu.It then calls PrintResults to print the results of the transcription. Budeme implementovat PrintResults Další.We'll implement PrintResults next.

function CheckTranscriptionStatus(statusUrl) {
    transcription = null;
    const fetchOptions = {
        headers: {
            "Ocp-Apim-Subscription-Key": SubscriptionKey
        }
    }

    const fetchRequest = https.get(new URL(statusUrl), fetchOptions, (response) => {
        if (response.statusCode !== 200) {
            console.info("Error retrieving status: " + response.statusCode);
        } else {
            let responseText = '';
            response.setEncoding('utf8');
            response.on("data", (chunk) => {
                responseText += chunk;
            });

            response.on("end", () => {
                const statusObject = JSON.parse(responseText);

                var done = false;
                switch (statusObject.status) {
                    case "Failed":
                        console.info("Transcription failed. Status: " + transcription.StatusMessage);
                        done = true;
                        break;
                    case "Succeeded":
                        done = true;
                        PrintResults(statusObject.resultsUrls["channel_0"]);
                        break;
                    case "Running":
                        console.info("Transcription is still running.");
                        break;
                    case "NotStarted":
                        console.info("Transcription has not started.");
                        break;
                }

                if (!done) {
                    setTimeout(() => {
                        CheckTranscriptionStatus(statusUrl);
                    }, (5000));
                }
            });
        }
    });

    fetchRequest.on("error", error => {
        console.error(error);
    });
}

Zobrazení výsledků přepisuDisplay the transcription results

Po úspěšném dokončení přepisu budou výsledky uloženy v jiné adrese URL, kterou můžeme získat z odpovědi na stav.Once the service has successfully completed the transcription the results will be stored in another Url that we can get from the status response. Tady vytvoříme požadavek na stažení těchto výsledků do dočasného souboru před čtením a deserializací.Here we make a request to download those results in to a temporary file before reading and deserializing them. Po načtení výsledků je můžete vytisknout do konzoly.Once the results are loaded we can print them to the console.

function PrintResults(resultUrl)
{
    const fetchOptions = {
        headers: {
            "Ocp-Apim-Subscription-Key": SubscriptionKey
        }
    }

    const fetchRequest = https.get(new URL(resultUrl), fetchOptions, (response) => {
        if (response.statusCode !== 200) {
            console.info("Error retrieving status: " + response.statusCode);
        } else {
            let responseText = '';
            response.setEncoding('utf8');
            response.on("data", (chunk) => {
                responseText += chunk;
            });

            response.on("end", () => {
                console.info("Transcription Results:");
                console.info(responseText);
            });
        }
    });
}

Kontrolovat kódCheck your code

V tomto okamžiku váš kód by měl vypadat takto:At this point, your code should look like this:

const https = require("https");

// Replace with your subscription key
SubscriptionKey = "YourSubscriptionKey";

// Update with your service region
Region = "YourServiceRegion";
Port = 443;

// Recordings and locale
Locale = "en-US";
RecordingsBlobUri = "YourFileUrl";

// Name and description
Name = "Simple transcription";
Description = "Simple transcription description";

SpeechToTextBasePath = "/api/speechtotext/v2.0/";

class ModelIdentity {
    id;
}

class Transcription {
    Name;
    Description;
    Locale;
    RecordingsUrl;
    ResultsUrls;
    Id;
    CreatedDateTime;
    LastActionDateTime;
    Status;
    StatusMessage;
}

class TranscriptionDefinition {
    Name;
    Description;
    RecordingsUrl;
    Locale;
    Models;
    Properties;
}

const ts = {
    Name: Name,
    Description: Description,
    Locale: Locale,
    RecordingsUrl: RecordingsBlobUri,
    Properties: {
        "PunctuationMode": "DictatedAndAutomatic",
        "ProfanityFilterMode": "Masked",
        "AddWordLevelTimestamps": "True"
    },
    Models: []
}

const postPayload = JSON.stringify(ts);

const startOptions = {
    hostname: Region + ".cris.ai",
    port: Port,
    path: SpeechToTextBasePath + "Transcriptions/",
    method: "POST",
    headers: {
        "Content-Type": "application/json",
        'Content-Length': postPayload.length,
        "Ocp-Apim-Subscription-Key": SubscriptionKey
    }
}

function PrintResults(resultUrl)
{
    const fetchOptions = {
        headers: {
            "Ocp-Apim-Subscription-Key": SubscriptionKey
        }
    }

    const fetchRequest = https.get(new URL(resultUrl), fetchOptions, (response) => {
        if (response.statusCode !== 200) {
            console.info("Error retrieving status: " + response.statusCode);
        } else {
            let responseText = '';
            response.setEncoding('utf8');
            response.on("data", (chunk) => {
                responseText += chunk;
            });

            response.on("end", () => {
                console.info("Transcription Results:");
                console.info(responseText);
            });
        }
    });
}

function CheckTranscriptionStatus(statusUrl) {
    transcription = null;
    const fetchOptions = {
        headers: {
            "Ocp-Apim-Subscription-Key": SubscriptionKey
        }
    }

    const fetchRequest = https.get(new URL(statusUrl), fetchOptions, (response) => {
        if (response.statusCode !== 200) {
            console.info("Error retrieving status: " + response.statusCode);
        } else {
            let responseText = '';
            response.setEncoding('utf8');
            response.on("data", (chunk) => {
                responseText += chunk;
            });

            response.on("end", () => {
                const statusObject = JSON.parse(responseText);

                var done = false;
                switch (statusObject.status) {
                    case "Failed":
                        console.info("Transcription failed. Status: " + transcription.StatusMessage);
                        done = true;
                        break;
                    case "Succeeded":
                        done = true;
                        PrintResults(statusObject.resultsUrls["channel_0"]);
                        break;
                    case "Running":
                        console.info("Transcription is still running.");
                        break;
                    case "NotStarted":
                        console.info("Transcription has not started.");
                        break;
                }

                if (!done) {
                    setTimeout(() => {
                        CheckTranscriptionStatus(statusUrl);
                    }, (5000));
                }
            });
        }
    });

    fetchRequest.on("error", error => {
        console.error(error);
    });
}

const request = https.request(startOptions, (response) => {
    if (response.statusCode != 202) {
        console.error("Error, status code " + response.statusCode);
    } else {

        const transcriptionLocation = response.headers.location;

        console.info("Created transcription at location " + transcriptionLocation);
        console.info("Checking status.");

        CheckTranscriptionStatus(transcriptionLocation);
    }
});

request.on("error", error => {
    console.error(error);
});

request.write(postPayload);
request.end();

Spuštění aplikaceRun your app

Nyní jste připraveni sestavit aplikaci a otestovat rozpoznávání řeči pomocí služby Speech.Now you're ready to build your app and test our speech recognition using the Speech service.

Spusťte aplikaci -spusťte index. js uzlu.Start your app - Run node index.js.

Další krokyNext steps

Zobrazení nebo stažení ukázek sady Speech SDK na GitHubu.View or download all Speech SDK Samples on GitHub.

Další podpora jazyků a platforemAdditional language and platform support

Pokud jste na tuto kartu klikli, pravděpodobně jste v oblíbeném programovacím jazyce nezobrazili rychlý Start.If you've clicked this tab, you probably didn't see a quickstart in your favorite programming language. Nedělejte si starosti, máme další materiály pro rychlý Start a ukázky kódu dostupné na GitHubu.Don't worry, we have additional quickstart materials and code samples available on GitHub. Pomocí tabulky Najděte správnou ukázku kombinace programovacího jazyka a platformy/OS.Use the table to find the right sample for your programming language and platform/OS combination.

JazykLanguage Další rychlé startyAdditional Quickstarts Ukázky kódůCode samples
C#C# Od mic, ze souboruFrom mic, From file .NET Framework, .NET Core, UWP, Unity, Xamarin.NET Framework, .NET Core, UWP, Unity, Xamarin
C++C++ Od mic, ze souboruFrom mic, From file Windows, Linux, MacOSWindows, Linux, macOS
JavaJava Od mic, ze souboruFrom mic, From file Android, JREAndroid, JRE
JavaScriptJavaScript Prohlížeč z MIC, Node. js ze souboruBrowser from mic, Node.js from file Windows, Linux, macOSWindows, Linux, macOS
Objective-CObjective-C iOS od mic, MacOS od miciOS from mic, macOS from mic iOS, MacOSiOS, macOS
PythonPython Od mic, ze souboruFrom mic, From file Windows, Linux, macOSWindows, Linux, macOS
SwiftSwift iOS od mic, MacOS od miciOS from mic, macOS from mic iOS, MacOSiOS, macOS