Chitu (Red Rabbit) : un cadre de raisonnement à haute performance basé sur un grand modèle de langage lancé par l'équipe de Tsinghua

Introduction générale

Chitu est un cadre de raisonnement open source développé par l'équipe PACMAN de l'université de Tsinghua, appelé "Red Rabbit", qui est spécialement conçu pour exécuter de grands modèles de langage. Chitu prend en charge une variété de matériels, tels que les GPU NVIDIA et les puces domestiques, et peut être utilisé de manière autonome à des grappes à grande échelle.Son point fort est l'inférence avec des modèles FP8, qui peut réduire considérablement les coûts, comme l'exécution de DeepSeek-671B sur un A800, qui utilise la moitié des GPU et est plus de trois fois plus rapide que vLLM.Le code est disponible publiquement sur GitHub et peut être téléchargé et utilisé gratuitement par les entreprises ou les particuliers. Il s'agit d'un outil prêt à l'emploi pour les environnements de production et qui convient aux équipes qui veulent économiser de l'argent tout en étant performantes.

Liste des fonctions

• Il prend en charge l'inférence des modèles FP8 et BF16, et peut fonctionner sur les anciens GPU et les puces domestiques avec un faible coût et des performances élevées.
• S'adapte à une large gamme de matériel, des CPU purs aux GPU tels que NVIDIA A800, H20, etc., en passant par les clusters à grande échelle.
• Optimisez la vitesse d'inférence avec CUDA Graph pour obtenir des résultats plus rapides en une seule requête.
• Fournit une interface de service qui permet d'invoquer les modèles directement via des requêtes HTTP.
• Prend en charge le raisonnement distribué à plusieurs nœuds, adapté au traitement de tâches à grand volume.
• Code source ouvert que les entreprises peuvent modifier ou optimiser selon leurs besoins.

Utiliser l'aide

Processus d'installation

L'installation de Chitu n'est pas compliquée mais nécessite une certaine préparation. Voici les étapes détaillées :

1. Préparation de l'environnement
   • Système : Ubuntu 22.04 recommandé, machine avec GPU NVIDIA (par exemple A800 ou H20).
   • Logiciels : Installer Git, Python 3.10, CUDA 12.1 (adapté à la version de votre GPU), PyTorch 2.1.
   • Exemple de commande :

     sudo apt update && sudo apt install -y git python3.10 python3-pip
     pip install -U torch==2.1 --index-url https://download.pytorch.org/whl/cu121
     

2. Télécharger le code
   • Cloner localement le code de Chitu en utilisant Git :

     git clone --recursive https://github.com/thu-pacman/chitu
     cd chitu
     

3. Installation des dépendances
   • Installez les paquets Python requis et l'environnement de compilation :

     pip install -r requirements-build.txt
     pip install flash-attn
     

4. compiler et installer
   • Définissez les paramètres de compilation (ajustez TORCH_CUDA_ARCH_LIST en fonction de votre GPU, par exemple 8.0 pour A800) et compilez :

     TORCH_CUDA_ARCH_LIST=8.0 CHITU_SETUP_JOBS=4 MAX_JOBS=4 pip install --no-build-isolation .
     

5. Vérification de l'installation
   • Effectuez un test pour vous assurer que tout va bien :

     torchrun --nproc_per_node 1 test/single_req_test.py
     

Comment l'utiliser

Une fois Chitu chargé, vous pouvez démarrer le service à partir de la ligne de commande ou exécuter un seul test. Voici comment cela fonctionne :

Lancer un service de raisonnement

1. Configuration des chemins d'accès au modèle
   • Préparer les fichiers du modèle, par exemple DeepSeek-R1, dans un répertoire local (par exemple /data/DeepSeek-R1).
   • dans la commande d'édition models.ckpt_dir Le paramètre pointe vers le chemin du modèle.
2. Démarrage des services
   • Démarrer le service autonome avec torchrun, en écoutant sur le port 21002 :

     export WORLD_SIZE=1
     torchrun --nproc_per_node 1 chitu/serve.py \
     serve.port=21002 \
     models=DeepSeek-R1 \
     models.ckpt_dir=/data/DeepSeek-R1 \
     infer.use_cuda_graph=True \
     request.max_new_tokens=100
     

3. Services d'essais
   • Envoyez une requête avec curl et voyez si le modèle répond correctement :

     curl localhost:21002/v1/chat/completions \
     -H "Content-Type: application/json" \
     -d '{"messages": [{"role": "user", "content": "你好，Chitu 是什么？"}]}'
     

   • Le résultat sera au format JSON et contiendra la réponse du modèle.

Exécution d'un seul test de raisonnement

• Si vous ne souhaitez pas lancer le service, vous pouvez simplement tester les résultats du modèle :

  torchrun --nproc_per_node 1 test/single_req_test.py \
  models=DeepSeek-R1 \
  models.ckpt_dir=/data/DeepSeek-R1 \
  request.max_new_tokens=64

• La sortie est affichée dans le terminal, indiquant ce que le modèle a généré.

Raisonnement distribué à plusieurs nœuds

1. Préparer plusieurs machines
   • Assurez-vous que Chitu et les dépendances sont chargés sur chaque machine et que les fichiers de modèle sont sur un stockage partagé.
2. Démarrage des services distribués
   • L'exécuter sur 2 machines avec 8 GPU chacune :

     torchrun --nnodes 2 --nproc_per_node 8 test/single_req_test.py \
     request.max_new_tokens=64 \
     infer.pp_size=2 \
     infer.tp_size=8 \
     models=DeepSeek-R1 \
     models.ckpt_dir=/data/DeepSeek-R1
     

3. Vérifier l'effet
   • Après une exécution sur plusieurs nœuds, le résultat sera plus rapide qu'avec une seule machine, ce qui convient au traitement de demandes volumineuses.

Fonction en vedette Fonctionnement

Économisez de l'argent et gagnez en rapidité avec les modèles FP8

• Chitu prend en charge les modèles au format FP8, qui utilisent moins de GPU et sont plus rapides que BF16.
• Fonctionnement : ajouter au démarrage infer.soft_fp8=TruePar exemple, si le modèle est au format FP8, le modèle doit être au format FP8. Par exemple, si le modèle est au format FP8, le modèle doit être au format FP8 :

  torchrun --nproc_per_node 1 chitu/serve.py \
  serve.port=21002 \
  models=DeepSeek-R1 \
  models.ckpt_dir=/data/DeepSeek-R1 \
  infer.soft_fp8=True
  

Accéléré avec CUDA Graph

• Les requêtes uniques peuvent être accélérées avec CUDA Graph, en ajoutant le paramètre infer.use_cuda_graph=True.
• Effet de test : exécuter une seule inférence et comparer la différence de vitesse avec et sans l'ajout.

essais de performance

• Chitu est livré avec des outils d'analyse comparative permettant de mesurer le débit et la latence :

  python benchmarks/benchmark_serving.py \
  --model "deepseek-r1" \
  --iterations 10 \
  --seq-len 10 \
  --base-url http://localhost:21002
  

• Le résultat indiquera le nombre de jeton pour vous aider à optimiser votre allocation.

mise en garde

• Si vous utilisez plusieurs nœuds, le réseau doit être stable, sinon il tombera.
• Une mémoire GPU insuffisante peut entraîner une erreur OOM, réduisez-la. infer.max_seq_len ou avec moins de nœuds.
• La prise en charge des puces domestiques est encore en cours d'optimisation, il peut être nécessaire de modifier le code pour l'adapter.

Chitu n'est pas difficile à utiliser, il suffit de suivre les étapes et vous serez opérationnel. Sa documentation et sa communauté sont également sur GitHub, vous pouvez donc soulever un problème si vous avez des questions.