Język

Generuj tekst przy użyciu własnego modelu językowego przy użyciu usługi Windows ML

Important

Interfejsy API Windows ML Runtime i Text Generation są obecnie eksperymentalne i nie są obsługiwane do użycia w środowiskach produkcyjnych. Aplikacje, które wypróbują te interfejsy API, nie powinny być publikowane w sklepie Microsoft Store.

Important

Interfejsy API Windows ML Runtime i Text Generation są obecnie dostępne w języku C++ i Python; Język C# nie jest obecnie obsługiwany. Daj nam znać, jeśli interesuje Cię używanie tych interfejsów API z języka C#, publikując problem w repozytorium GitHub ml Windows ML!

Interfejs API generowania tekstu w usłudze Windows ML upraszcza uruchamianie generowania tekstu na własnym modelu językowym. Obsługuje tokenizację, dekodowanie autoregresywne, strumieniowe dane wyjściowe i anulowanie w oparciu o Windows ML Runtime API — podobnie jak ONNX Runtime GenAI upraszcza ten proces w oparciu o ONNX Runtime. Windows nie dostarcza modelu dla tego interfejsu API; wybierasz, pakujesz i dystrybuujesz model — plik ONNX lub GGUF oraz tokenizator — razem z aplikacją.

Wskazówka

Jeśli nie potrzebujesz określonego modelu i chcesz tylko generowania tekstu na urządzeniu z modelem zarządzanym przez firmę Microsoft, użyj zamiast tego jednego z gotowych do użycia lokalnych modeli LLM.

Nadal tworzysz obiekty bazowe Runtime — model, cel wykonywania i potok — i przekazujesz je do sesji. Interfejs API nie ukrywa rozmieszczenia sprzętu; usuwa tylko konieczność zapisania własnej pętli tokenu.

Obsługiwane modele

Interfejs API generowania tekstu akceptuje:

  • Modele ONNX () lub .ort (.onnx) są uruchamiane za pośrednictwem ONNX Runtime. Model musi udostępniać wejście identyfikatora tokenu, wyjście logitów i jedną parę tensorów stanu o stałej pojemności, która przechowuje pamięć podręczną klucza/wartości i pozycję sekwencji. Podajesz oddzielne źródło tokenizatora (na przykład tokenizer.json).
  • Modele GGUF (.gguf) są uruchamiane przez zaplecze llama.cpp. Tokenizer jest osadzony w modelu, więc nie jest potrzebne żadne oddzielne źródło tokenizatora.

Próbki weryfikują ten kontrakt względem rodziny modeli Qwen2.5-0.5B-Instruct wyeksportowanej z grafem specyficznym dla zadania, który pakuje pamięć podręczną klucz/wartość i pozycję sekwencji w jedną parę stanów. Inne modele językowe typu decoder-only, które udostępniają te same dane wejściowe w postaci tokenów, wyjście logits i interfejs stanu, powinny również działać.

Generowanie tekstu

Sesja generowania tekstu opakowuje tokenizator i potok stanowy (model, który jest właścicielem pamięci podręcznej klucz/wartość). Załaduj model i tokenizator, opisz dane wejściowe tokenu modelu, dane wyjściowe logits i kontrakt stanu oraz skompiluj sesję:

// 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));

Wywołaj GenerateText, podając monit, aby uruchomić operację przesyłania strumieniowego, a następnie ściągaj fragmenty ze zwróconego strumienia, aż strumień zasygnalizuje zakończenie:

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()));

Ukończony wynik raportuje:

  • Pełny wygenerowany tekst i identyfikatory tokenów
  • Liczba tokenów monitu i wygenerowanych tokenów
  • Przyczyna zakończenia — token zakończenia sekwencji, token zatrzymania, żądany limit tokenu, pojemność sekwencji, anulowanie lub błąd

C++ i Python

Natywny interfejs API jest uwidaczniany za pomocą funkcji WinMLTasks.h i typowanych pomocników C++ w obszarze winml/tasks/text_generation/TextGeneration.hpp. Aplikacje Python używają składnika projection razem z elementem windowsml.runtime.

Przykłady Windows ML obejmują przykład generowania tekstu w językach C++ i Python. W przykładzie pokazano pełną konfigurację środowiska uruchomieniowego obok konfiguracji generowania tekstu, aby zobaczyć, gdzie zaczyna się abstrakcja i jak dostosować bazowy przepływ pracy.

Informacje dodatkowe

  • Ostatnia aktualizacja o