Tekst genereren met uw eigen taalmodel met behulp van Windows ML

De Windows ML Text Generation-API vereenvoudigt het genereren van tekst via uw eigen taalmodel. Het verwerkt tokenisatie, automatischregressieve decodering, streaming-uitvoer en annulering voor u, boven op de Windows ML Runtime-API, vergelijkbaar met de manier waarop ONNX Runtime GenAI die lus vereenvoudigt boven op ONNX Runtime. Windows levert geen model voor deze API mee; u kiest, verpakt en distribueert het model, een ONNX- of GGUF-bestand, plus een tokenizer, met uw app.

U maakt nog steeds de onderliggende Runtime-objecten( het model, het uitvoeringsdoel en de pijplijn) en geeft deze door aan de sessie. De API verbergt hardwareplaatsing niet; hiermee hoeft u niet langer uw eigen tokenlus te schrijven.

Ondersteunde modellen

De API voor tekstgeneratie accepteert:

• ONNX (.onnx)- of ORT-indelingsmodellen (.ort), worden uitgevoerd via ONNX Runtime. Het model moet een token-id-invoer, een logits-uitvoer en één status-tensorpaar met vaste capaciteit beschikbaar maken dat de sleutel/waardecache en de volgordepositie bevat. U levert een afzonderlijke tokenizerbron (bijvoorbeeld een tokenizer.json).
• GGUF-modellen (.gguf) worden uitgevoerd via de llama.cpp-back-end. De tokenizer is ingesloten in het model, dus er is geen afzonderlijke tokenizerbron nodig.

De voorbeelden valideren dit contract op basis van de Qwen2.5-0.5B-Instruct-modelfamilie , geëxporteerd met een taakspecifieke grafiek die de sleutel-/waardecache en de volgordepositie in één statuspaar verpakt. Andere taalmodellen met alleen decoderen die dezelfde tokeninvoer, logitsuitvoer en statuscontract aanbieden, moeten ook werken.

Tekst genereren

Een sessie voor het genereren van tekst verpakt een tokenizer en een stateful pijplijn (het model dat eigenaar is van de sleutel-/waardecache). Laad het model en de tokenizer, beschrijf de tokeninvoer van het model, logitsuitvoer en statuscontract en bouw de sessie:

// 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 your ONNX model and its tokenizer.
ComPtr<IWinMLModel> model;
THROW_IF_FAILED(runtime->LoadModelFromFile(
    L"C:\\models\\qwen2.5-0.5b-instruct\\task_model.onnx",
    nullptr,
    model.GetAddressOf()));
ComPtr<IWinMLTokenizer> tokenizer;
THROW_IF_FAILED(WinMLCreateTokenizerFromFile(
    L"C:\\models\\qwen2.5-0.5b-instruct\\tokenizer.json",
    tokenizer.GetAddressOf()));

// Describe the model's token input, logits output, and KV-cache state pair.
winml::tasks::text_generation::onnx::StateTensorPair stateTensorPairs[] = {{1, 1}};
winml::tasks::text_generation::Options options;
options.values = winml::tasks::MakeTextGenerationOptions(/* maxNewTokens */ 64);

winml::tasks::text_generation::onnx::BuildTextGenerationArguments arguments;
arguments.runtime = runtime.Get();
arguments.model = model.Get();
arguments.target = target.Get();
arguments.tokenizer = tokenizer.Get();
arguments.tokenInputName = L"input_ids";
arguments.outputName = L"logits";
arguments.debugName = L"my-text-generation";
arguments.stateTensorPairs = stateTensorPairs;
arguments.sequenceCapacityHint = 128;
arguments.outputKind = WINML_TEXT_GENERATION_OUTPUT_KIND_LOGITS;
arguments.eosPolicy = WINML_TEXT_GENERATION_EOS_POLICY_TOKENIZER_DEFAULT;
arguments.options = &options;

winml::tasks::text_generation::TextGeneration textGeneration;
THROW_IF_FAILED(winml::tasks::text_generation::onnx::BuildTextGeneration(
    arguments, textGeneration));

Roep GenerateText aan met een prompt om een streamingbewerking te starten en haal vervolgens fragmenten op uit de geretourneerde stream totdat de bewerking is voltooid:

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

ComPtr<IWinMLTextGenerationPullStream> stream;
THROW_IF_FAILED(textGeneration.session->GenerateText(
    L"The sky is often",
    textGeneration.options.Get(),
    cancellation.Get(),
    stream.GetAddressOf()));

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

// The terminal result is the authoritative text, token counts, and finish reason.
ComPtr<IWinMLTextGenerationResult> result;
THROW_IF_FAILED(stream->GetResult(result.GetAddressOf()));

Het voltooide resultaat meldt:

• De volledige gegenereerde tekst- en token-id's
• Aantal prompts en gegenereerde tokens
• Een voltooiingsreden: een token voor einde van de reeks, een stoptoken, de aangevraagde tokenlimiet, de sequentiecapaciteit, annulering of een fout

C++ en Python

De systeemeigen API wordt ontsloten via WinMLTasks.h en de getypte C++-helpers onder winml/tasks/text_generation/TextGeneration.hpp. Python toepassingen gebruiken de windowsml.tasks projectie samen met windowsml.runtime.

De Windows ML-voorbeelden bevatten een C++ en Python voorbeeld van het genereren van tekst. In het voorbeeld ziet u de volledige runtime-installatie naast de configuratie voor het genereren van tekst, zodat u kunt zien waar de abstractie begint en hoe u de onderliggende werkstroom aanpast.

Zie ook

• Kant-en-klare lokale LLM's op Windows (Phi Silica en andere Microsoft beheerde modellen)
• Overzicht van Windows ML Runtime-API
• concepten voor Windows ML Runtime-API
• Spraak herkennen met uw eigen Whisper-model met behulp van Windows ML
• Windows ML-voorbeelden
• ONNX Runtime GenAI