Démarrez avec AI Toolkit pour Visual Studio Code.

La boîte à outils d'IA pour VS Code (AI Toolkit) est une extension VS Code qui vous permet de télécharger, tester, affiner et déployer des modèles d'IA avec vos applications ou dans le cloud. Pour plus d’informations, consultez Vue d’ensemble de l’AI Toolkit.

Remarque

Des documents et didacticiels supplémentaires pour le kit VS Code d'outils IA sont disponibles dans la documentation VS Code : AI Toolkit for Visual Studio Code. Vous trouverez des conseils sur Playground, l’utilisation de modèles IA, l’optimisation des modèles locaux et cloud, etc.

Dans cet article, vous allez apprendre à :

• Installez le AI Toolkit pour VS Code
• Télécharger un modèle à partir du catalogue
• Exécuter le modèle localement à l’aide du terrain de jeu
• Intégrer un modèle IA à votre application avec REST ou le runtime ONNX

Prérequis

• VS Code doit être installé. Pour plus d’informations, consultez Télécharger VS Code et Commencer avec VS Code.

Lorsque vous utilisez des fonctionnalités IA, nous vous recommandons de vous référer à l’article suivant : Développement d’applications et de fonctionnalités d’IA générative responsable sur Windows.

Installer

Si vous ne connaissez pas l’installation des extensions VS Code, procédez comme suit :

1. Dans la barre d’activité de VS Code, sélectionnez Extensions
2. Dans la barre de recherche extensions, tapez « AI Toolkit »
3. Sélectionnez « AI Toolkit pour Visual Studio code »
4. Sélectionnez Installer

Une fois l’extension installée, l’icône du AI Toolkit s’affiche dans votre barre d’activité.

Télécharger un modèle à partir du catalogue

La barre latérale principale du kit de ressources IA est organisée en Mes modèles, Catalogue, Outilset Aide et Commentaires. Les fonctionnalités de Playground, Run en bloc, Évaluation et Réglage fin sont disponibles dans la section Outils. Pour commencer, sélectionnez Modèles dans la section Catalogue pour ouvrir la fenêtre Catalogue de modèles.

Vous pouvez utiliser les filtres en haut du catalogue pour filtrer par Hébergé par, Éditeur, Tâches, et Type de modèle. Il existe également un commutateur Réglage précis que vous pouvez activer pour n'afficher que les modèles dont il est possible d'effectuer un réglage précis.

Conseil

Le filtre Type de modèle vous permet de n’afficher que les modèles qui s’exécutent localement sur le processeur, le GPU ou le NPU, ou bien ceux qui ne prennent en charge qu'un Accès à distance. Pour optimiser les performances sur les appareils qui ont au moins un GPU, sélectionnez le type de modèle exécution locale avec GPU. Cela permet de trouver un modèle optimisé pour l’accélérateur DirectML.

Pour vérifier si vous disposez d’un GPU sur votre appareil Windows, ouvrez le Gestionnaire de tâches, puis sélectionnez l’onglet Analyse des performances. Si vous avez des GPU, ils sont répertoriés sous des noms tels que « GPU 0 » ou « GPU 1 ».

Remarque

Pour les PC Copilot+ avec une unité de traitement neuronale (NPU), vous pouvez sélectionner des modèles optimisés pour l’accélérateur NPU. Le modèle Distilled Deepseek R1 est optimisé pour le NPU et disponible pour le téléchargement sur des PC Copilot+ alimentés par Snapdragon exécutant Windows 11. Pour plus d’informations, consultez Exécuter des modèles DeepSeek R1 distillés localement sur des PC Copilot+, alimentés par Windows AI Foundry.

Les modèles suivants sont actuellement disponibles pour les appareils Windows avec un ou plusieurs GPU :

• Mistral 7B (DirectML - Petit, Rapide)
• Phi 3 Mini 4K (DirectML - Petit, Rapide)
• Phi 3 Mini 128K (DirectML - Petit, Rapide)

Sélectionnez le modèle Phi 3 Mini 4K, puis cliquez sur Télécharger:

Remarque

Le modèle Phi 3 Mini 4K est d’environ 2 Go à 3 Go de taille. Selon la vitesse de votre réseau, le téléchargement peut prendre quelques minutes.

Exécuter le modèle dans le terrain de jeu

Une fois que votre modèle a été téléchargé, il apparaît dans la section Mes modèles sous modèles locaux. Cliquez avec le bouton droit sur le modèle et sélectionnez Charger dans Playground dans le menu contextuel :

Dans l’interface de conversation du terrain de jeu, saisissez le message suivant suivi de la touche Entrée :

Vous devez voir la réponse du modèle retransmis en continu vers vous :

Avertissement

Si vous n’avez pas de GPU disponible sur votre appareil, mais que vous avez sélectionné le modèle Phi-3-mini-4k-directml-int4-awq-block-128-onnx, la réponse du modèle sera très lente. Vous devez plutôt télécharger la version optimisée du processeur : Phi-3-mini-4k-cpu-int4-rtn-block-32-acc-level-4-onnx.

Il est également possible de modifier :

• Instructions contextuelles : aidez le modèle à comprendre l’image plus grande de votre demande. Il peut s’agir d’informations générales, d’exemples/démonstrations de ce que vous souhaitez ou d’explication de l’objectif de votre tâche.
• Paramètres d’inférence :
  • Longueur de réponse maximale : nombre maximal de jetons retournés par le modèle.
  • Température : la température du modèle est un paramètre qui contrôle la façon dont la sortie d’un modèle de langage est aléatoire. Une température plus élevée signifie que le modèle prend plus de risques, ce qui vous donne un mélange diversifié de mots. D’autre part, une température inférieure rend le modèle jouable en toute sécurité, en s’appuyant sur des réponses plus ciblées et prévisibles.
  • Top P : également appelé échantillonnage de noyau, est un paramètre qui contrôle le nombre de mots ou d’expressions possibles que le modèle de langage prend en compte lors de la prédiction du mot suivant
  • Pénalité de fréquence : ce paramètre influence la fréquence à laquelle le modèle répète des mots ou des expressions dans sa sortie. Plus la valeur est élevée (plus proche de 1,0) encourage le modèle à éviter de répéter des mots ou des expressions.
  • Pénalité de présence : ce paramètre est utilisé dans les modèles IA génératifs pour encourager la diversité et la spécificité dans le texte généré. Une valeur plus élevée (plus proche de 1,0) encourage le modèle à inclure des jetons plus nouveaux et diversifiés. Une valeur inférieure est plus susceptible pour le modèle de générer des expressions courantes ou clichés.

Intégrer un modèle IA à votre application

Il existe deux options pour intégrer le modèle à votre application :

1. La boîte à outils d'IA est livrée avec un serveur Web local REST API qui utilise le format de complétion de chat OpenAI. Cela vous permet de tester votre application localement (à l’aide du point de terminaison http://127.0.0.1:5272/v1/chat/completions) sans avoir à compter sur un service de modèle IA cloud. Utilisez cette option si vous envisagez de basculer vers un point de terminaison cloud en production. Vous pouvez utiliser des bibliothèques clientes OpenAI pour vous connecter au serveur web.
2. Utilisation du runtime ONNX. Utilisez cette option si vous envisagez d’expédier le modèle avec votre application avec l’inférence sur l’appareil.

Serveur web d’API REST local.

Le serveur web d’API REST local vous permet de générer et de tester votre application localement sans avoir à compter sur un service de modèle IA cloud. Vous pouvez interagir avec le serveur web avec REST ou une bibliothèque de client OpenAI :

REST

Voici un exemple de corps pour votre requête REST :

{
    "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
}'

Remarque

Vous pourriez avoir à mettre à jour le champ de modèle avec le nom du modèle que vous avez téléchargé.

Vous pouvez tester le point de terminaison REST avec un outil d’API tel que Postman ou l’utilitaire CURL :

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

Python

Installez la bibliothèque Python OpenAI :

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#

Ajoutez la bibliothèque de client Azure OpenAI pour .NET à votre projet à l’aide de NuGet :

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

Ajoutez un fichier C# appelé OverridePolicy.cs à votre projet et collez le code suivant :

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

Ensuite, collez le code suivant dans votre fichier Program.cs :

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

Remarque

Si vous avez téléchargé la version processeur du modèle Phi3, vous devez mettre à jour le champ de modèle vers Phi-3-mini-4k-cpu-int4-rtn-block-32-acc-level-4-onnx.

ONNX Runtime

L’API ONNX Runtime Generate fournit la boucle IA générative pour les modèles ONNX, notamment l’inférence avec le runtime ONNX, le traitement des logits, la recherche et l’échantillonnage et la gestion du cache KV. Vous pouvez appeler une méthode generate() de haut niveau ou exécuter chaque itération du modèle dans une boucle, en générant un jeton à la fois, et éventuellement mettre à jour les paramètres de génération à l’intérieur de la boucle.

Il prend en charge la recherche gourmande/par faisceau et l’échantillonnage TopP, TopK pour générer des séquences de jetons et le traitement des logits intégrés comme des pénalités de répétition. Le code suivant illustre une façon dont vous pouvez tirer parti du runtime ONNX dans vos applications.

REST

Reportez-vous à l’exemple présenté dans Serveur web d’API REST local. Le serveur Web AI Toolkit REST est construit en utilisant le Runtime ONNX.

Python

Installez Numpy :

pip install numpy

Ensuite, installez le package Python du runtime ONNX dans votre projet en fonction de la disponibilité de votre plateforme et de votre GPU :

Plateforme	GPU disponible	PyPI
Fenêtres	Oui (AMD, NVIDIA, Intel, Soc, ainsi que d’autres pris en charge)	pip install --pre onnxruntime-genai-directml
Linux	Oui (Nvidia CUDA)	pip install --pre onnxruntime-genai-cuda --index-url=https://aiinfra.pkgs.visualstudio.com/PublicPackages/_packaging/onnxruntime-genai/pypi/simple/
Fenêtres Linux	Non	pip install --pre onnxruntime-genai

Conseil

Nous vous recommandons d’installer les packages Python dans un environnement virtuel à l’aide de venv ou conda.

Ensuitez, copiez et collez le code suivant dans un fichier Python nommé app.py :

# 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)

Utilisez le code suivant pour exécuter l’application Python :

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

Remarque

Le AI Toolkit met en cache les téléchargements de modèles dans un dossier caché nommé .aitk dans votre répertoire utilisateur - vous devrez mettre à jour le chemin utilisé pour le paramètre --model à l'emplacement du dossier contenant le fichier de modèle ONNX. Par exemple, ~/.aitk/models/microsoft/Phi-3-mini-4k-instruct-onnx/directml/Phi-3-mini-4k-directml-int4-awq-block-128-onnx/

C#

Installez le package NuGet du runtime ONNX dans votre projet en fonction de la disponibilité de votre plateforme et de votre GPU :

Plateforme	GPU disponible	NuGet
Fenêtres	Oui (AMD, NVIDIA, Intel, Soc, ainsi que d’autres pris en charge)	Microsoft.ML.OnnxRuntimeGenAI.DirectML
Linux	Oui (Nvidia CUDA)	Microsoft.ML.OnnxRuntimeGenAI.Cuda
Fenêtres Linux	Non	Microsoft.ML.OnnxRuntimeGenAI

Copiez et collez le code suivant dans votre fichier C# :

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

Remarque

Le AI Toolkit met en cache les téléchargements de modèles dans un dossier caché nommé .aitk dans votre répertoire utilisateur - vous devrez mettre à jour le modelPath dans le code à l'emplacement du dossier contenant le fichier de modèle ONNX. Par exemple, ~/.aitk/models/microsoft/Phi-3-mini-4k-instruct-onnx/directml/Phi-3-mini-4k-directml-int4-awq-block-128-onnx/

étape suivante

Affinez un modèle avec AI Toolkit for VS Code