Prise en main d’AI Toolkit pour Visual Studio Code

L’AI Toolkit pour VS Code (AI Toolkit) est une extension VS Code qui vous permet de télécharger, tester, ajuster et déployer des modèles IA avec vos applications ou le cloud. Pour plus d’informations, consultez la Vue d’ensemble d’AI Toolkit.

Dans cet article, vous allez apprendre à :

• Installer 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.

Installer

L’AI Toolkit est disponible dans Visual Studio Marketplace et peut être installé comme n’importe quelle autre extension VS Code. 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 d’AI Toolkit s’affiche dans votre barre d’activité.

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

La barre latérale principale d’AI Toolkit est organisée en Modèles et Ressources. Les fonctionnalités Playground et Fine-tuning sont disponibles dans la section Ressources. Pour commencer, sélectionnez Catalogue de modèles :

Conseil

Vous remarquerez que les cartes modèles indiquent la taille du modèle, la plateforme et le type d’accélérateur (CPU, GPU). Pour optimiser les performances sur les appareils Windows qui ont au moins un GPU, sélectionnez des versions de modèle qui ciblent uniquement Windows. Cela garantit que vous disposez d’un modèle optimisé pour l’accélérateur DirectML. Les noms de modèle sont au format de {model_name}-{accelerator}-{quantization}-{format}.

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 ».

Ensuite, téléchargez le modèle suivant en fonction de la disponibilité d’un GPU sur votre appareil.

Plateforme(s)	GPU disponible	Nom du modèle	Taille (Go)
Windows	Oui	Phi-3-mini-4k-directml-int4-awq-block-128-onnx	2,13 Go
Linux	Oui	Phi-3-mini-4k-cuda-int4-onnx	2,30 Go
Windows Mac Linux	Non	Phi-3-mini-4k-cpu-int4-rtn-block-32-acc-level-4-onnx	2,72 Go

Remarque

Le modèle Phi3-mini (int4) a une taille d’environ 2 à 3 Go. 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 votre modèle téléchargé, sélectionnez Charger dans le terrain de jeu sur le modèle carte dans le catalogue :

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. L’AI Toolkit est fourni avec un serveur web d’API REST local 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 ToolkitREST est généré à l’aide du 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
Windows	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/
Windows 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

AI Toolkit met en cache les téléchargements de modèles dans un dossier caché nommé .aitk dans votre répertoire utilisateur. Vous devez mettre à jour le chemin d’accès 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
Windows	Oui (AMD, NVIDIA, Intel, Soc, ainsi que d’autres pris en charge)	Microsoft.ML.OnnxRuntimeGenAI.DirectML
Linux	Oui (Nvidia CUDA)	Microsoft.ML.OnnxRuntimeGenAI.Cuda
Windows 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

AI Toolkit met en cache les téléchargements de modèles dans un dossier caché nommé .aitk dans votre répertoire utilisateur. Vous devez mettre à jour le modelPath dans le code avec 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/

Étapes suivantes

• Ajuster un modèle avec AI Toolkit pour VS Code