Lingua

Riconosci il parlato con il tuo modello Whisper usando Windows ML

Importante

Le API di Windows ML Runtime e di riconoscimento vocale sono attualmente sperimentali e non sono supportate per l'uso in ambienti di produzione. Le app che provano queste API non devono essere pubblicate in Microsoft Store.

Importante

Le API Windows ML Runtime e Riconoscimento vocale sono attualmente disponibili in C++ e Python; C# non è attualmente supportato. Segnalare se si è interessati a usare queste API da C# aprendo una segnalazione nel repository GitHub di Windows ML.

L'API di riconoscimento vocale di Windows ML semplifica l'esecuzione del riconoscimento vocale automatico (ASR) tramite il proprio modello Whisper. Compone una pipeline del codificatore Whisper, una pipeline di decodificatore e un tokenizer, quindi gestisce automaticamente il ciclo di trascrizione autoregressiva, l'output di streaming e l'annullamento, basandosi sull'API Windows ML Runtime. Windows non offre un modello per questa API. È possibile scegliere, pacchettizzare e distribuire il modello Whisper, ovvero i file del codificatore e del decodificatore, oltre a un tokenizer, con l'app.

Tip

Se non è necessario un modello Whisper specifico o una distribuzione personalizzata e si vuole solo usare il riconoscimento vocale sul dispositivo con un modello gestito da Microsoft, usare invece l'API Riconoscimento vocale pronta per l'uso.

È comunque possibile creare gli oggetti Runtime sottostanti, ovvero i modelli encoder e decoder, la destinazione di esecuzione e le pipeline, e passarli alla sessione. L'API non nasconde il posizionamento hardware; rimuove solo la necessità di scrivere un ciclo di decodifica personalizzato.

Modelli supportati

L'API di riconoscimento vocale è progettata specificamente per l'architettura encoder/decoder Whisper — non è un'API ASR generica. Fornisci:

  • Modelli di codificatore e decodificatore ONNX (encoder_model.onnx e decoder_model.onnx), eseguiti tramite ONNX Runtime

Un file del tokenizer accompagna la coppia codificatore/decodificatore. Il tensore di input contiene campioni PCM a virgola mobile mono, oltre a frequenza di campionamento e metadati di lunghezza valida.

Trascrivere audio

Fornire un tensore Runtime contenente campioni di forma d'onda. Caricare i modelli di codificatore e decodificatore Whisper, compilare una pipeline per ognuno e comporli con un tokenizer in una sessione:

// Create the runtime and an execution target (CPU here; GPU/NPU also available).
ComPtr<IWinMLRuntime> runtime;
THROW_IF_FAILED(WinMLCreateRuntime(IID_PPV_ARGS(runtime.GetAddressOf())));
ComPtr<IWinMLExecutionTarget> target;
THROW_IF_FAILED(runtime->CreateCpuExecutionTarget(target.GetAddressOf()));

// Load the Whisper encoder as its own single-stage pipeline.
ComPtr<IWinMLModel> encoderModel;
THROW_IF_FAILED(runtime->LoadModelFromFile(
    L"C:\\models\\whisper\\encoder_model.onnx", nullptr, encoderModel.GetAddressOf()));
ComPtr<IWinMLPipelineBuilder> encoderBuilder;
THROW_IF_FAILED(runtime->CreatePipelineBuilder(encoderBuilder.GetAddressOf()));
ComPtr<IWinMLStage> encoderStage;
THROW_IF_FAILED(encoderBuilder->AddModelStage(
    encoderModel.Get(), target.Get(), L"whisper-encoder", encoderStage.GetAddressOf()));
ComPtr<IWinMLPipeline> encoderPipeline;
THROW_IF_FAILED(encoderBuilder->Build(encoderPipeline.GetAddressOf()));

// Load the Whisper decoder the same way.
ComPtr<IWinMLModel> decoderModel;
THROW_IF_FAILED(runtime->LoadModelFromFile(
    L"C:\\models\\whisper\\decoder_model.onnx", nullptr, decoderModel.GetAddressOf()));
ComPtr<IWinMLPipelineBuilder> decoderBuilder;
THROW_IF_FAILED(runtime->CreatePipelineBuilder(decoderBuilder.GetAddressOf()));
ComPtr<IWinMLStage> decoderStage;
THROW_IF_FAILED(decoderBuilder->AddModelStage(
    decoderModel.Get(), target.Get(), L"whisper-decoder", decoderStage.GetAddressOf()));
ComPtr<IWinMLPipeline> decoderPipeline;
THROW_IF_FAILED(decoderBuilder->Build(decoderPipeline.GetAddressOf()));

ComPtr<IWinMLTokenizer> tokenizer;
THROW_IF_FAILED(WinMLCreateTokenizerFromFile(
    L"C:\\models\\whisper\\tokenizer.json", tokenizer.GetAddressOf()));

// Compose the encoder/decoder pipelines and tokenizer into a session.
const winml::tasks::speech::asr::AutomaticSpeechRecognitionArguments arguments{
    runtime.Get(),
    tokenizer.Get(),
    {
        encoderPipeline.Get(),
        encoderStage.Get(),
        decoderPipeline.Get(),
        decoderStage.Get(),
        target.Get(),
    },
};
winml::tasks::speech::asr::AutomaticSpeechRecognition speechRecognition;
THROW_IF_FAILED(winml::tasks::speech::asr::BuildAutomaticSpeechRecognition(
    arguments, speechRecognition));

Chiamare TranscribeWaveform per avviare un'operazione di streaming, quindi eseguire il pull dei frammenti dal flusso restituito fino al completamento:

ComPtr<IWinMLCancellationSource> cancellation;
THROW_IF_FAILED(speechRecognition.tasks->CreateCancellationSource(
    cancellation.GetAddressOf()));

ComPtr<IWinMLAutomaticSpeechRecognitionPullStream> stream;
THROW_IF_FAILED(speechRecognition.session->TranscribeWaveform(
    waveform.Get(),
    &waveformMetadata,
    cancellation.Get(),
    stream.GetAddressOf()));

// Pull transcript text one fragment at a time until the stream completes.
WINML_AUTOMATIC_SPEECH_RECOGNITION_READ_STATUS status{};
LPCWSTR fragment = nullptr;
while (SUCCEEDED(stream->ReadNext(&status, &fragment)) &&
    status == WINML_AUTOMATIC_SPEECH_RECOGNITION_READ_STATUS_UPDATE)
{
    std::wprintf(L"%ls", fragment);
}

// The terminal result is the authoritative transcript and finish reason.
ComPtr<IWinMLAutomaticSpeechRecognitionResult> result;
THROW_IF_FAILED(stream->GetResult(result.GetAddressOf()));

waveform e waveformMetadata provengono dal proprio codice di caricamento audio: un tensore di runtime che contiene campioni PCM a virgola mobile mono, oltre alla frequenza di campionamento e ai metadati di lunghezza valida che la descrivono.

Il risultato completato segnala la trascrizione completa e un motivo di fine, ad esempio un token di fine trascrizione, l'annullamento o un errore.

C++ e Python

L'API nativa viene esposta tramite WinMLTasks.h e gli helper C++ tipizzati in winml/tasks/speech/asr/WhisperAutomaticSpeechRecognition.hpp. Python applicazioni usano la windowsml.tasks proiezione insieme a windowsml.runtime.

Gli esempi di Windows ML includono un esempio di trascrizione Whisper in C++ e Python. L'esempio mostra l'installazione completa del runtime accanto alla configurazione del riconoscimento vocale, in modo da poter vedere dove inizia l'astrazione e come personalizzare il flusso di lavoro sottostante.

Vedere anche

  • Ultimo aggiornamento: