DeepSeek-R1-FP4 : version optimisée pour le FP4 de l'inférence DeepSeek-R1 25x plus rapide

Introduction générale

DeepSeek-R1-FP4 est un modèle de langage quantifié optimisé par NVIDIA et mis à disposition en libre accès, basé sur la technologie DeepSeek L'IA Profondeur de l'eau-R1 Développement. Il quantifie les poids et les valeurs d'activation en types de données FP4 à l'aide de l'optimiseur de modèle TensorRT, ce qui permet au modèle de réduire considérablement les besoins en ressources tout en maintenant des performances élevées. Avec environ 1,6 fois moins d'espace disque et de mémoire GPU que le modèle original, il est parfaitement adapté à une inférence efficace dans les environnements de production. Optimisé spécifiquement pour l'architecture Blackwell de NVIDIA, le modèle est censé fournir une inférence jusqu'à 25 fois plus rapide par jeton Il est 20 fois moins cher et présente un fort potentiel de performance. Prenant en charge des longueurs de contexte allant jusqu'à 128K, il est adapté au traitement de tâches textuelles complexes et est ouvert à une utilisation commerciale et non commerciale, offrant aux développeurs une solution d'IA rentable.

Liste des fonctions

• Raisonnement efficaceLa quantification FP4 permet d'améliorer considérablement la vitesse d'inférence et d'optimiser l'utilisation des ressources.
• Soutien à long termeLongueur de contexte maximale : 128 Ko, ce qui convient au traitement des tâches de génération de texte de longue durée.
• Déploiement de TensorRT-LLMLa solution : peut être rapidement déployée pour fonctionner sur les GPU NVIDIA à l'aide de la structure TensorRT-LLM.
• utilisation de l'open sourceLes objectifs du programme sont les suivants : soutien aux scénarios commerciaux et non commerciaux, permettant des modifications libres et le développement de produits dérivés.
• l'optimisation des performancesIl est conçu pour l'architecture Blackwell et offre une efficacité d'inférence et un rapport coût-efficacité très élevés.

Utiliser l'aide

Processus d'installation et de déploiement

Le déploiement de DeepSeek-R1-FP4 nécessite un certain support matériel et logiciel, en particulier le GPU NVIDIA et le framework TensorRT-LLM. Vous trouverez ci-dessous un guide d'installation et d'utilisation détaillé pour aider les utilisateurs à démarrer rapidement.

1. préparation à l'environnement

• exigences en matière de matérielPour les tests plus importants, il est recommandé d'utiliser au moins un GPU à haute performance (par ex. A100/H100). Les GPU NVIDIA à architecture Blackwell (par ex. B200) sont recommandés, ce qui nécessite au moins 8 GPU (chacun avec ~336 Go de VRAM non quantifié, ~1342 Go après quantification pour satisfaire aux exigences du modèle). Pour les tests plus petits, il est recommandé d'utiliser au moins un GPU haute performance (par exemple A100/H100).
• dépendance logicielle:
  • Système d'exploitation : Linux (par exemple Ubuntu 20.04 ou version ultérieure).
  • Pilote NVIDIA : dernière version (prend en charge CUDA 12.4 ou supérieur).
  • TensorRT-LLM : La dernière version de la branche master doit être compilée à partir des sources GitHub.
  • Python : 3.11 ou plus récent.
  • Autres bibliothèques :tensorrt_llm,torch etc.

2. télécharger le modèle

• entretiens Page du visage de l'étreinteCliquez sur l'onglet "Fichiers et versions".
• Télécharger le fichier du modèle (par exemple model-00001-of-00080.safetensors (etc., soit un total de 80 tranches, d'une taille totale de plus de 400 Go).
• Enregistrer le fichier dans un répertoire local, par exemple /path/to/model/.

3. installer TensorRT-LLM

• Clonez le dernier dépôt TensorRT-LLM depuis GitHub :

  git clone https://github.com/NVIDIA/TensorRT-LLM.git
  cd TensorRT-LLM

• Compilation et installation :

  make build
  pip install -r requirements.txt
  

• Vérifier l'installation :

  python -c "import tensorrt_llm; print(tensorrt_llm.__version__)"
  

4. modèle de déploiement

• Chargez et exécutez le modèle en utilisant le code d'exemple fourni :

  from tensorrt_llm import SamplingParams, LLM
  # 初始化模型
  llm = LLM(
  model="/path/to/model/nvidia/DeepSeek-R1-FP4",
  tensor_parallel_size=8,  # 根据 GPU 数量调整
  enable_attention_dp=True
  )
  # 设置采样参数
  sampling_params = SamplingParams(max_tokens=32)
  # 输入提示
  prompts = [
  "你好，我的名字是",
  "美国总统是",
  "法国的首都是",
  "AI的未来是"
  ]
  # 生成输出
  outputs = llm.generate(prompts, sampling_params)
  for output in outputs:
  print(output)
  

• Avant d'exécuter le code ci-dessus, assurez-vous que les ressources du GPU ont été allouées correctement. Si les ressources sont insuffisantes, ajustez le paramètre tensor_parallel_size Paramètres.

5. guide d'utilisation fonctionnelle

Raisonnement efficace

• La force principale de DeepSeek-R1-FP4 est sa technologie de quantification FP4. Au lieu d'ajuster manuellement les paramètres du modèle, les utilisateurs peuvent simplement s'assurer que leur matériel supporte l'architecture Blackwell et expérimenter une augmentation de la vitesse d'inférence. Lors de l'exécution, il est recommandé de définir max_tokens permet de contrôler la longueur de la sortie afin d'éviter le gaspillage des ressources.
• Exemple : exécutez un script Python dans un terminal, entrez différentes invites et observez la vitesse et la qualité de la sortie.

traitement contextuel de longue durée

• Le modèle prend en charge des longueurs de contexte allant jusqu'à 128K, ce qui convient à la génération de longs articles ou au traitement de dialogues complexes.
• Fonctionnement : dans le prompts Saisissez un contexte long, comme le début d'un article de 5 000 mots, puis définissez le paramètre max_tokens=1000Le texte est généré de la même manière que le texte qui suit. Vérifiez la cohérence du texte généré après exécution.
• Attention : les contextes longs peuvent augmenter l'utilisation de la mémoire, il est recommandé de surveiller l'utilisation de la mémoire du GPU.

l'optimisation des performances

• Si vous utilisez les GPU Blackwell, vous pouvez directement bénéficier d'une accélération de 25 fois de l'inférence. Si d'autres architectures sont utilisées (par exemple A100), le gain de performance peut être légèrement inférieur, mais toujours nettement supérieur au modèle non quantifié.
• Suggestion d'utilisation : dans un environnement multi-GPU, réglez le paramètre tensor_parallel_size afin d'utiliser pleinement les ressources matérielles. Par exemple, 8 GPU est réglé sur 8 et 4 GPU sur 4.

6. questions fréquemment posées et solutions

• mémoire vidéo insuffisanteSi l'on vous demande d'indiquer un dépassement de capacité de mémoire, réduisez la capacité de mémoire de l'appareil. tensor_parallel_size ou utiliser une version moins quantifiée (par exemple le format GGUF fourni par la communauté).
• Raisonnement lentTensorRT-LLM : Assurez-vous que TensorRT-LLM a été compilé correctement et que l'accélération GPU est activée, vérifiez que la version du pilote correspond.
• anomalie de sortieLe format de l'invite de saisie doit être vérifié afin de s'assurer qu'aucun caractère spécial n'interfère avec le modèle.

Recommandations d'utilisation

• utilisation initialeLes modèles : Commencez par des indices simples et augmentez progressivement la longueur du contexte afin de vous familiariser avec la performance du modèle.
• environnement de productionLes utilisateurs sont invités à tester plusieurs séries d'invites avant le déploiement pour s'assurer que le résultat est conforme aux attentes. Il est recommandé d'optimiser l'accès multi-utilisateurs à l'aide d'outils de répartition de la charge.
• Personnalisation du développeurLes modèles peuvent être modifiés sur la base de licences libres pour s'adapter à des tâches spécifiques, telles que la génération de code ou les systèmes de questions-réponses.

Avec ces étapes, les utilisateurs peuvent rapidement déployer et utiliser DeepSeek-R1-FP4 pour profiter de la commodité d'une inférence efficace.