Erste Schritte mit dem KI Toolkit für Visual Studio Code

Das KI Toolkit für VS Code (AI Toolkit) ist eine VS Code-Erweiterung, mit der Sie KI-Modelle herunterladen, testen, optimieren und mit Ihren Apps oder in der Cloud bereitstellen können. Weitere Informationen finden Sie unter Überblick über das AI Toolkit.

Hinweis

Weitere Dokumentationen und Lernprogramme für das AI Toolkit VS Code finden Sie in der VS Code Dokumentation: AI Toolkit für Visual Studio Code. Sie finden Anleitungen zum Playground, arbeiten mit KI-Modellen, optimieren lokale und cloudbasierte Modelle und vieles mehr.

In diesem Artikel lernen Sie Folgendes:

• Installieren Sie das KI Toolkit für VS Code
• Herunterladen eines Modells aus dem Katalog
• Lokales Ausführen des Modells mithilfe des Playgrounds
• Integrieren eines KI-Modells in Ihre Anwendung mithilfe von REST oder der ONNX-Runtime

Voraussetzungen

• VS Code muss installiert werden. Weitere Informationen finden Sie unter HerunterladenVS Code und Erste Schritte mit VS Code.

Wenn Sie KI-Features verwenden, empfehlen wir Ihnen, den folgenden Abschnitt zu lesen: Entwicklung verantwortungsbewusster generativer KI-Anwendungen und Features unter Windows.

Installieren

Das KI Toolkit ist im Visual Studio Marketplace verfügbar und kann wie jede andere VS Code-Erweiterung installiert werden. Wenn Sie mit der Installation von VS Code Erweiterungen nicht vertraut sind, führen Sie die folgenden Schritte aus:

1. In der Aktivitätsleiste in VS Code wählen Sie Erweiterungen aus.
2. Geben Sie in der Suchleiste Erweiterungen den Typ „AI Toolkit“ ein.
3. Wählen Sie das „AI Toolkit für Visual Studio Code“ aus.
4. Wählen Sie Installieren aus.

Nachdem die Erweiterung installiert wurde, wird das Symbol für das AI Toolkit in Ihrer Aktivitätsleiste angezeigt.

Herunterladen eines Modells aus dem Katalog

Die primäre Randleiste des AI Toolkits ist in Meine Modelle, Katalog, Werkzeugeund Hilfe und Feedbackorganisiert. Die Playground, Bulk Run, Evaluation und Feinabstimmung-Funktionen sind im Abschnitt Tools verfügbar. Um zu beginnen, wählen Sie Modelle im Abschnitt Katalog aus, um das Fenster Modellkatalog zu öffnen:

Sie können die Filter oben im Katalog verwenden, um nach Gehostet von, Publisher, Aufgaben und Modelltyp zu filtern. Es gibt auch einen Schalter für Unterstützung von Feinabstimmung, den Sie aktivieren können, um nur Modelle anzuzeigen, für die eine Feinabstimmung möglich ist.

Tipp

Mit dem Modelltyp Filter können Sie nur Modelle anzeigen, die lokal auf der CPU, GPU oder NPU ausgeführt werden, oder Modelle, die nur Remotezugriffunterstützen. Um die Leistung auf Geräten mit mindestens einer GPUzu optimieren, wählen Sie den Modelltyp lokalen Ausführung mit GPU. Auf diese Weise können Sie ein Modell finden, das für den DirectML- Beschleuniger optimiert ist.

Um zu überprüfen, ob auf Ihrem Windows-Gerät eine GPU vorhanden ist, öffnen Sie den Task-Manager, und wählen Sie dann die Registerkarte Leistung aus. Wenn Sie GPU(s) haben, werden sie unter Namen wie „GPU 0“ oder „GPU 1“ aufgeführt.

Hinweis

Für Copilot+ PCs mit einer neuralen Verarbeitungseinheit (Neural Processing Unit, NPU) können Sie Modelle auswählen, die für den NPU-Beschleuniger optimiert sind. Das Deepseek R1 Distilled-Modell ist für die NPU optimiert und steht zum Download auf Snapdragon-betriebenen Copilot+ PCs unter Windows 11 zur Verfügung. Weitere Informationen finden Sie unter Distilled DeepSeek R1-Modelle lokal auf Copilot+ PCs ausführen, unterstützt von Windows AI Foundry.

Die folgenden Modelle sind derzeit für Windows-Geräte mit einer oder mehreren GPUs verfügbar:

• Mistral 7B (DirectML - Klein, schnell)
• Phi 3 Mini 4K (DirectML - Klein, schnell)
• Phi 3 Mini 128K (DirectML - Klein, schnell)

Wählen Sie das Phi 3 Mini 4K-Modell aus, und klicken Sie auf Herunterladen:

Hinweis

Das Phi 3 Mini 4K-Modell ist ungefähr 2 GB-3 GB groß. Je nach Netzwerkgeschwindigkeit kann das Herunterladen einige Minuten dauern.

Ausführen des Modells im Playground

Nachdem Ihr Modell heruntergeladen wurde, wird es im Abschnitt „Meine Modelle“ bei den Lokalen Modellen angezeigt. Klicken Sie mit der rechten Maustaste auf das Modell, und wählen Sie im Kontextmenü In Playground laden aus:

Geben Sie in der Chatschnittstelle des Playgrounds die folgende Nachricht gefolgt von der Eingabetaste ein:

Die Modellantwort sollte an Sie gestreamt werden:

Warnung

Wenn auf Ihrem Gerät keineGPU verfügbar ist, Sie aber das Phi-3-mini-4k-directml-int4-awq-block-128-onnx-Modell ausgewählt haben, ist die Modellantwort sehr langsam. Stattdessen sollten Sie die CPU-optimierte Version herunterladen: Phi-3-mini-4k-cpu-int4-rtn-block-32-acc-level-4-onnx.

Auch eine Änderung ist möglich:

• Kontextanweisungen: Helfen Sie dem Modell, das größere Bild Ihrer Anforderung zu verstehen. Dies kann Hintergrundinformationen, Beispiele/Demonstrationen des Gewünschten sein oder den Zweck Ihrer Aufgabe erklären.
• Rückschlussparameter:
  • Maximale Antwortlänge: Die maximale Anzahl von Token, die das Modell zurückgibt.
  • Temperatur: Die Modelltemperatur ist ein Parameter, der steuert, wie zufällig die Ausgabe eines Sprachmodells ist. Eine höhere Temperatur bedeutet, dass das Modell mehr Risiken einnimmt, sodass Sie eine vielfältige Mischung aus Wörtern erhalten. Andererseits macht eine niedrigere Temperatur das Modell sicher und hält sich an fokussiertere und vorhersagbare Antworten fest.
  • Top P: Auch bekannt als Nukleus-Sampling, ist eine Einstellung, die steuert, wie viele mögliche Wörter oder Ausdrücke das Sprachmodell berücksichtigt, wenn das nächste Wort vorhergesagt wird.
  • Häufigkeitsstrafe: Dieser Parameter beeinflusst, wie oft das Modell Wörter oder Ausdrücke in seiner Ausgabe wiederholt. Je höher der Wert (näher an 1,0) ist, desto eher vermeidet das Modell die Wiederholung von Wörtern oder Sätzen.
  • Anwesenheitsstrafe: Dieser Parameter wird in generativen KI-Modellen verwendet, um Vielfalt und Spezifität im generierten Text zu fördern. Ein höherer Wert (näher an 1,0) ermutigt das Modell, neuartigere und vielfältigere Token einzuschließen. Bei einem niedrigeren Wert ist es wahrscheinlicher, dass das Modell allgemeine oder klischeehafte Ausdrücke erzeugt.

Integrieren eines KI-Modells in Ihre App

Es gibt zwei Optionen, um das Modell in Ihre Anwendung zu integrieren:

1. Das KI Toolkit wird mit einem lokalen REST API-Webserver geliefert, der das OpenAI-Chat-Vervollständigungsformat verwendet. So können Sie Ihre Anwendung lokal - über den Endpunkt http://127.0.0.1:5272/v1/chat/completions - testen, ohne auf einen Cloud-KI-Modelldienst angewiesen zu sein. Verwenden Sie diese Option, wenn Sie in der Produktion zu einem Cloudendpunkt wechseln möchten. Sie können OpenAI-Clientbibliotheken verwenden, um eine Verbindung mit dem Webserver herzustellen.
2. Verwenden der ONNX-Runtime. Verwenden Sie diese Option, wenn Sie beabsichtigen, das Modell mit Ihrer Anwendung mit Inferencing auf dem Gerät auszuliefern.

Lokaler REST-API Webserver

Mit dem lokalen REST API-Webserver können Sie Ihre Anwendung lokal erstellen und testen, ohne sich auf einen Cloud-KI-Modelldienst verlassen zu müssen. Sie können mit dem Webserver unter Verwendung von REST oder mit einer OpenAI-Clientbibliothek interagieren:

REST

Hier ist ein Beispieltext für Ihre REST Anforderung:

{
    "model": "Phi-3-mini-4k-directml-int4-awq-block-128-onnx",
    "messages": [
        {
            "role": "user",
            "content": "what is the golden ratio?"
        }
    ],
    "temperature": 0.7,
    "top_p": 1,
    "top_k": 10,
    "max_tokens": 100,
    "stream": true
}'

Hinweis

Möglicherweise müssen Sie das Modellfeld auf den Namen des heruntergeladenen Modells aktualisieren.

Sie können den REST Endpunkt mit einem API-Tool wie Postman oder dem CURL-Dienstprogramm testen:

curl -vX POST http://127.0.0.1:5272/v1/chat/completions -H 'Content-Type: application/json' -d @body.json

Python

Installieren der OpenAI Python-Bibliothek:

pip install openai

from openai import OpenAI

client = OpenAI(
    base_url="http://127.0.0.1:5272/v1/",
    api_key="x" # required by API but not used
)

chat_completion = client.chat.completions.create(
    messages=[
        {
            "role": "user",
            "content": "what is the golden ratio?",
        }
    ],
    model="Phi-3-mini-4k-directml-int4-awq-block-128-onnx",
)

print(chat_completion.choices[0].message.content)

C#

Fügen Sie die Azure OpenAI-Clientbibliothek für .NET zu Ihrem Projekt mithilfe von NuGet hinzu:

dotnet add {project_name} package Azure.AI.OpenAI --version 1.0.0-beta.17

Fügen Sie ihrem Projekt eine C#-Datei namens OverridePolicy.cs hinzu, und fügen Sie den folgenden Code ein:

// OverridePolicy.cs
using Azure.Core.Pipeline;
using Azure.Core;

internal partial class OverrideRequestUriPolicy(Uri overrideUri)
    : HttpPipelineSynchronousPolicy
{
    private readonly Uri _overrideUri = overrideUri;

    public override void OnSendingRequest(HttpMessage message)
    {
        message.Request.Uri.Reset(_overrideUri);
    }
}

Fügen Sie anschließend den folgenden Code in die Datei Program.cs ein:

// Program.cs
using Azure.AI.OpenAI;

Uri localhostUri = new("http://localhost:5272/v1/chat/completions");

OpenAIClientOptions clientOptions = new();
clientOptions.AddPolicy(
    new OverrideRequestUriPolicy(localhostUri),
    Azure.Core.HttpPipelinePosition.BeforeTransport);
OpenAIClient client = new(openAIApiKey: "unused", clientOptions);

ChatCompletionsOptions options = new()
{
    DeploymentName = "Phi-3-mini-4k-directml-int4-awq-block-128-onnx",
    Messages =
    {
        new ChatRequestSystemMessage("You are a helpful assistant. Be brief and succinct."),
        new ChatRequestUserMessage("What is the golden ratio?"),
    }
};

StreamingResponse<StreamingChatCompletionsUpdate> streamingChatResponse
    = await client.GetChatCompletionsStreamingAsync(options);

await foreach (StreamingChatCompletionsUpdate chatChunk in streamingChatResponse)
{
    Console.Write(chatChunk.ContentUpdate);
}

Hinweis

Wenn Sie die CPU-Version des Phi3-Modells heruntergeladen haben, müssen Sie das Modellfeld auf Phi-3-mini-4k-cpu-int4-rtn-block-32-acc-level-4-onnx aktualisieren.

ONNX-Runtime

Die ONNX Runtime Generate API stellt die generative KI-Schleife für ONNX-Modelle bereit, einschließlich Rückschlüsse auf ONNX-Runtime, Logits-Verarbeitung, Suche und Sampling sowie KV-Cacheverwaltung. Sie können eine Methode auf hoher Ebene generate() aufrufen oder jede Iteration des Modells in einer Schleife ausführen, jeweils ein Token generieren und optional die Generierungsparameter innerhalb der Schleife aktualisieren.

Es unterstützt die Gier-/Balkensuche sowie TopP- und TopK-Sampling zur Erzeugung von Token-Sequenzen und integrierte Logits-Verarbeitung wie Wiederholungsstrafen. Der folgende Code ist ein Beispiel für die Nutzung der ONNX-Laufzeit in Ihren Anwendungen.

REST

Weitere Informationen finden Sie im Beispiel des lokalen REST API-Webservers. Der KI Toolkit REST Webserver wird mithilfe der ONNX-Runtime erstellt.

Python

Numpy installieren:

pip install numpy

Installieren Sie als Nächstes das ONNX-Runtime-Python-Paket entsprechend Ihrer Plattform- und GPU-Verfügbarkeit in Ihrem Projekt:

Plattform	GPU verfügbar	PyPI
Fenster	Ja (AMD, NVIDIA, Intel, Qualcomm und andere unterstützt)	pip install --pre onnxruntime-genai-directml
Linux	Ja (Nvidia CUDA)	pip install --pre onnxruntime-genai-cuda --index-url=https://aiinfra.pkgs.visualstudio.com/PublicPackages/_packaging/onnxruntime-genai/pypi/simple/
Fenster Linux	Nein	pip install --pre onnxruntime-genai

Tipp

Es wird empfohlen, Python-Pakete mithilfe von venv oder conda in einer virtuellen Umgebung zu installieren.

Kopieren Sie den folgenden Code und fügen Sie ihn in die Python- Datei app.py ein:

# app.py
import onnxruntime_genai as og
import argparse

def main(args):
    print("Loading model...")
    model = og.Model(f'{args.model}')
    print("Model loaded")
    tokenizer = og.Tokenizer(model)
    tokenizer_stream = tokenizer.create_stream()
    search_options = {
        'max_length': 2048
    }

    chat_template = '<|user|>\n{input} <|end|>\n<|assistant|>'

    # Keep asking for input prompts in a loop
    while True:
        text = input("Input: ")
    
        # If there is a chat template, use it
        prompt = f'{chat_template.format(input=text)}'

        input_tokens = tokenizer.encode(prompt)

        params = og.GeneratorParams(model)
        params.set_search_options(**search_options)
        params.input_ids = input_tokens
        
        generator = og.Generator(model, params)
        print("\nOutput: ", end='', flush=True)
        while not generator.is_done():
            generator.compute_logits()
            generator.generate_next_token()
            new_token = generator.get_next_tokens()[0]
            print(tokenizer_stream.decode(new_token), end='', flush=True)
              
        print()
        print()

        # Delete the generator to free the captured graph for the next generator, if graph capture is enabled
        del generator


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument('-m', '--model', type=str, required=True, help='Onnx model folder path (must contain config.json and model.onnx)')
    args = parser.parse_args()
    main(args)

Um die Python-Anwendung auszuführen, verwenden Sie den folgenden Code:

python app.py --model ~/.aitk/models/{path_to_folder_containing_onnx_file}

Hinweis

Das KI Toolkit Cachemodell lädt in einen ausgeblendeten Ordner namens .aitk in Ihrem Benutzerverzeichnis herunter. Sie müssen den Pfad aktualisieren, der für den --model Parameter verwendet wird, um den Speicherort des Ordners zu aktualisieren, der die ONNX-Modelldatei enthält. Beispiel: ~/.aitk/models/microsoft/Phi-3-mini-4k-instruct-onnx/directml/Phi-3-mini-4k-directml-int4-awq-block-128-onnx/

C#

Installieren Sie das ONNX-Runtime-NuGet-Paket entsprechend Ihrer Plattform- und GPU-Verfügbarkeit in Ihrem Projekt:

Plattform	GPU verfügbar	NuGet
Fenster	Ja (AMD, NVIDIA, Intel, Qualcomm und andere unterstützt)	Microsoft.ML.OnnxRuntimeGenAI.DirectML
Linux	Ja (Nvidia CUDA)	Microsoft.ML.OnnxRuntimeGenAI.Cuda
Fenster Linux	Nein	Microsoft.ML.OnnxRuntimeGenAI

Kopieren Sie den folgenden Code, und fügen Sie ihn in Ihre C# Datei ein:

using Microsoft.ML.OnnxRuntimeGenAI;

// update user_name and path placeholders
string modelPath = "C:\\Users\\{user_name}\\.aitk\\models\\{path}"; 
Console.Write("Loading model from " + modelPath + "...");
using Model model = new(modelPath);
Console.Write("Done\n");
using Tokenizer tokenizer = new(model);
using TokenizerStream tokenizerStream = tokenizer.CreateStream();

while (true)
{
    Console.Write("User:");
   
    string? input = Console.ReadLine();
    string prompt = "<|user|>\n" + input + "<|end|>\n<|assistant|>";

    var sequences = tokenizer.Encode(prompt);

    using GeneratorParams generatorParams = new GeneratorParams(model);
    generatorParams.SetSearchOption("max_length", 200);
    generatorParams.SetInputSequences(sequences);

    Console.Out.Write("\nAI:");
    using Generator generator = new(model, generatorParams);
    while (!generator.IsDone())
    { 
        generator.ComputeLogits();
        generator.GenerateNextToken();
        Console.Out.Write(tokenizerStream.Decode(generator.GetSequence(0)[^1]));
        Console.Out.Flush();
    }
    Console.WriteLine();
}

Hinweis

Das KI Toolkit Cache-Modell lädt in einen ausgeblendeten Ordner namens .aitk in Ihrem Benutzerverzeichnis herunter. Sie müssen den modelPath im Code an den Speicherort des Ordners aktualisieren, der die ONNX-Modelldatei enthält. Beispiel: ~/.aitk/models/microsoft/Phi-3-mini-4k-instruct-onnx/directml/Phi-3-mini-4k-directml-int4-awq-block-128-onnx/

Nächster Schritt

Feinabstimmung eines Modells mit dem KI Toolkit für VS Code