Note :

Configurer un système d'évaluation de l'inférence LLM simple avec vLLM sur Oracle Cloud Infrastructure Compute

Présentation

Comprendre les caractéristiques de performance d'un système vous permet de faire des choix éclairés sur ses composants et ce qu'il faut attendre d'eux. Dans ce tutoriel, nous allons configurer un système complet d'analyse comparative pour l'inférence de grand modèle de langage (LLM) par IA. À l'aide de cela, vous pouvez exécuter diverses expériences pour évaluer l'adéquation d'une forme de calcul Oracle Cloud Infrastructure (OCI) particulière pour le LLM et les exigences de performance à l'esprit pour comparer différents LLM les uns aux autres.

Dans ce tutoriel, nous utilisons le populaire serveur d'inférence à code source libre vLLM, qui prend en charge de nombreux LLM à la fine pointe de la technologie et offre des optimisations de performance essentielles pour servir efficacement ces modèles et est en mesure de traiter des milliers de demandes concurrentes. De plus, nous utilisons le rayon LLMPerf pour exécuter les points de référence.

Note : Ce tutoriel suppose que vous disposez d'une location OCI avec un quota de GPU. Pour plus d'informations sur les quotas, voir Quotas du service de calcul.

Objectifs

Préalables

Tâche 1 : Configurer le réseau

Dans cette tâche, configurez votre réseau en nuage virtuel (VCN) pour fournir une configuration fonctionnelle et sécurisée permettant d'exécuter vos points de référence. Dans cet exemple, nous avons besoin d'un VCN avec un sous-réseau public et un sous-réseau privé. Vous pouvez utiliser l'Assistant Configuration de VCN ou configurer manuellement tous les composants, en vous assurant que les listes de sécurité autorisent l'accès SSH et qu'une passerelle NAT est affectée au sous-réseau privé.

Aperçu de l'architecture de la solution comprenant un sous-réseau privé et public, un hôte bastion et la machine virtuelle GPU en cours de test

Avant de provisionner les instances de calcul OCI et de procéder à la configuration de référence, il est important de s'assurer que les paramètres réseau sont correctement configurés. Par défaut, le réseau provisionné autorise uniquement le trafic essentiel entre les sous-réseaux. Pour autoriser le trafic réseau requis pour l'analyse comparative, vous devrez ajuster ces paramètres pour autoriser le trafic HTTP entre les sous-réseaux publics et privés. Plus précisément, ajoutez une règle de trafic entrant à la liste de sécurité du sous-réseau privé qui autorise le trafic du bloc CIDR du VCN vers le port de destination 8000.

Tâche 2 : Provisionner des instances de calcul OCI

Dans cette tâche, provisionnez deux instances de calcul OCI pour notre configuration de référence. L'une étant une instance de machine virtuelle (MV) réservée aux processeurs qui agit en tant qu'hôte bastion et machine client de référence, l'autre étant l'instance équipée de processeurs graphiques en cours de test.

  1. Provisionnez une instance VM.Flex.E5 avec huit OCPU et Oracle Linux 8. Le client bastion / benchmark ne nécessite pas de GPU car il enverra uniquement des demandes au modèle hébergé sur une machine distincte, d'où le choix d'une forme d'UC. Assurez-vous de sélectionner le sous-réseau public dans les paramètres du réseau et n'oubliez pas de charger votre clé publique SSH (ou de télécharger la clé privée fournie si vous préférez).

  2. Provisionnez une instance VM.GPU.A10.1. Pour rationaliser la configuration, provisionnez l'instance à l'aide d'une image Oracle Linux 8 qui inclut des pilotes NVIDIA et le cadre CUDA. Commencez par sélectionner la forme souhaitée, puis revenez au menu de sélection d'image et choisissez la variante d'Oracle Linux 8 avec prise en charge intégrée des processeurs graphiques. Cette instance doit être provisionnée dans le sous-réseau privé, ce qui signifie qu'elle n'est accessible qu'à l'aide de l'hôte bastion. Assurez-vous également de configurer la clé SSH.

Capture d'écran de la sélection de l'image Oracle Linux 8 avec prise en charge intégrée des processeurs graphiques

Tâche 3 : Configurer le client Benchmark

Dans cette tâche, nous installerons tous les composants requis pour nos tests de performance et configurerons l'hôte GPU.

  1. Connectez-vous à l'hôte bastion avec votre clé SSH et configurez toutes les exigences pour LLMPerf à l'aide de la commande suivante.

    sudo dnf install epel-release -y
sudo yum-config-manager --enable ol8_baseos_latest ol8_appstream ol8_addons ol8_developer_EPEL
sudo dnf install git python3.11 python3.11-devel python3.11-pip -y

  2. Clonez le référentiel Ray LLMPerf, configurez Python venv et installez LLMPerf à l'aide de la commande suivante.

    git clone https://github.com/ray-project/llmperf.git
cd llmperf
mkdir venv && python3.11 -mvenv venv && source venv/bin/activate

  3. Avant d'installer LLMPerf (et ses dépendances Python), modifiez le fichier pyproject.toml et supprimez la clause d'exigence Python. La clause limite inutilement la version de Python à une valeur inférieure à 3.11.

    diff --git a/pyproject.toml b/pyproject.toml
index 7687fb2..521a2a7 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -8,7 +8,6 @@ version = "0.1.0"
 description = "A framework for load testing LLM APIs"
 authors = [{name="Avnish Narayan", email="avnish@anyscale.com"}]
 license = {text= "Apache-2.0"}
-requires-python = ">=3.8, <3.11"
 dependencies = ["pydantic<2.5",
                 "ray",
                 "pytest>=6.0",

  4. Exécutez la commande pip install -e pour finaliser la configuration.

Tâche 4 : Configurer la cible de référence

Dans cette tâche, nous allons mettre en place l'objectif de référence lui-même. Comme nous avons déjà provisionné le noeud avec les pilotes nécessaires et le cadre CUDA (Compute Unified Device Architecture), il nous suffit d'installer vLLM et ses dépendances python et de déployer le modèle que nous souhaitons comparer.

Note : L'instance de calcul GPU que vous avez provisionnée réside dans un sous-réseau privé. Pour y parvenir, vous devez d'abord vous connecter à l'hôte bastion et configurer la clé SSH privée que vous avez choisie pour la cible de référence. Ce n'est qu'alors que vous pourrez vous connecter à la cible de référence à l'aide de son adresse IP privée.

  1. Installez les ensembles nécessaires, comme la configuration initiale sur l'hôte bastion. En outre, mettez à jour le pare-feu de l'hôte pour autoriser le trafic entrant sur le port 8000 à l'aide de la commande suivante.

    sudo dnf install epel-release -y
sudo yum-config-manager --enable ol8_baseos_latest ol8_appstream ol8_addons ol8_developer_EPEL
sudo dnf install git python3.11 python3.11-devel python3.11-pip -y
sudo firewall-cmd --permanent --zone=public --add-port=8000/tcp
sudo firewall-cmd --reload

  2. Exécutez la commande suivante pour installer vLLM et ses exigences.

    mkdir venv
python3.11 -mvenv venv && source venv/bin/activate
pip install -U pip "bitsandbytes>=0.44.0" vllm gpustat mistral_common

  3. Nous sommes prêts à démarrer vLLM avec le modèle que nous aimerions tester.

    export HF_TOKEN=<your huggingface token>
export MODEL="meta-llama/Llama-3.2-3B-Instruct"
ulimit -Sn 65536 # increase limits to avoid running out of files that can be opened
vllm serve $MODEL --tokenizer-mode auto --config-format hf --load-format auto \
                  --enforce-eager --max-model-len 65536

    Note : Nous devons réduire la longueur du contexte du modèle pour l'adapter à la mémoire du processeur graphique A10, nous réduisons la longueur du contexte de la taille par défaut des jetons 128k à des jetons 64k. Après le chargement, le modèle vLLM doit commencer à produire ses statistiques d'inférence à intervalles réguliers.

    INFO 12-09 15:46:36 metrics.py:449] Avg prompt throughput: 0.0 tokens/s, Avg generation throughput: 0.0 tokens/s, Running: 0 reqs, Swapped: 0 reqs, Pending: 0 reqs, GPU KV cache usage: 0.0%, CPU KV cache usage: 0.0%.

  4. Nous laissons le serveur continuer à fonctionner en arrière-plan pendant que nous passons à un autre terminal où nous allons maintenant tester et comparer notre configuration. Un test simple peut être exécuté avec curl comme suit.

    export HOST="<the ip address of the benchmark machine"
export MODEL="meta-llama/Llama-3.2-3B-Instruct"
curl --location "http://${HOST}:8000/v1/chat/completions"     --header 'Content-Type: application/json'     --header 'Authorization: Bearer token'     --data '{
        "model": "'"$MODEL"'",
        "messages": [
          {
            "role": "user",
            "content": "What is the question to the answer to the ultimate question of life, the universe, and everything. You may give a humorous response."
          }
        ]
    }' -s | jq

    La sortie sera :

    {
  "id": "chatcmpl-f11306f943604d41bad84be1dadd9da6",
  "object": "chat.completion",
  "created": 1733997638,
  "model": "meta-llama/Llama-3.2-3B-Instruct",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "You want to know the ultimate question to the answer of 42?\n\nWell, after years of intense research and contemplation, I've discovered that the answer is actually a giant, cosmic joke. The question is: \"What's for lunch?\"",
        "tool_calls": []
      },
      "logprobs": null,
      "finish_reason": "stop",
      "stop_reason": null
    }
  ],
  "usage": {
    "prompt_tokens": 62,
    "total_tokens": 112,
    "completion_tokens": 50,
    "prompt_tokens_details": null
  },
  "prompt_logprobs": null
}

Tâche 5 : Exécuter la référence

Maintenant, nous sommes prêts à exécuter notre benchmark. Compte tenu d'un scénario d'application particulier avec un grand modèle de langage choisi, nous aimerions comprendre sur le système cible quelles sont les caractéristiques de performance de l'exécution simultanée de demandes d'inférence.

Penchons-nous sur le scénario suivant :

PARAMÈTRE VALEUR
MODÈLE Meta LLaMa 3.2 3B Instructions
CAS D'UTILISATION chat
JETONS D'ENTRÉE N(200, 40)
JETONS DE SORTIE N (100, 10)
DEMANDES CONCURRENTES 1 - 32

  1. Créez le script suivant nommé llm_benchmark.sh sur le client de référence (hôte bastion) dans le répertoire de base.

    #!/usr/bin/env bash

set -xe

# Use vLLM OpenAPI endpoint
export OPENAI_API_BASE="http://<benchmark host>:8000/v1"
# API key is not in use, but needs to be set for llmbench
export OPENAI_API_KEY="none"

model="meta-llama/Llama-3.2-3B-Instruct"

modelname="${model##*/}"
mkdir "$modelname"

concurrent_requests=(1 2 4 8 16 32)

pushd llmperf

source venv/bin/activate

for cr in "${concurrent_requests[@]}"
do
    python3 token_benchmark_ray.py --model $model \
        --mean-input-tokens 200 --stddev-input-tokens 40 \
        --mean-output-tokens 100 --stddev-output-tokens 10 \
        --max-num-completed-requests $((cr * 100)) --num-concurrent-requests $cr \
        --metadata "use_case=chatbot" \
        --timeout 1800 --results-dir "../$modelname/result_outputs_chat_creq_$cr" --llm-api openai
done
popd

    Ce script vous permettra d'exécuter automatiquement une série de benchmarks avec llmperf avec un nombre croissant de demandes concurrentes (à partir de 1 et doublant successivement jusqu'à 32). Comme vous pouvez le voir à partir des arguments transmis au script token_benchmark_ray.py, nous définissons les entrées et les sorties de jeton telles que définies dans le tableau ci-dessus.

  2. Exécutez votre script de référence à l'aide de la commande suivante.

    bash -x llm_benchmark.sh

Une fois terminé, vous trouverez un nouveau répertoire nommé Llama-3.2-3B-Instruct dans votre répertoire de base, où tous les résultats de l'expérience seront stockés au format JSON, que vous pouvez télécharger et post-traiter à l'aide de votre outil d'analyse de données préféré.

Note : Un moyen facile de transformer vos points de référence en tracé consiste à extraire les chiffres qui vous intéressent le plus à l'aide d'un petit script d'interpréteur de commandes et de jq au format .csv, qui peut facilement être copié dans Excel.

echo "concurrent_requests,token_throughput"
for i in *; do
    cat $i/*_summary.json | jq -r '[.num_concurrent_requests, .results_request_output_throughput_token_per_s_mean] | join(",")'
done;

Remerciements

Autres ressources d'apprentissage

Explorez d'autres laboratoires sur le site docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal Oracle Learning YouTube. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir la documentation sur le produit, visitez Oracle Help Center.