FlashMLA : Optimisation des noyaux de décodage MLA pour les GPU Hopper (DeepSeek Open Source Week Day 1)

Introduction générale

FlashMLA est un programme développé par la DeepSeek AI a développé un noyau de décodage MLA (Multi-head Latent Attention) efficace optimisé pour les GPU NVIDIA Hopper Architecture, conçu pour améliorer les performances du traitement des séquences de longueur variable. Le projet a été ouvert sur GitHub et est disponible gratuitement pour les développeurs. Il prend en charge le calcul de précision BF16 et la mise en cache KV paginée (taille de bloc 64), et offre de bonnes performances sur le H800 SXM5, avec jusqu'à 3000 Go/s de bande passante dans les configurations à forte intensité de mémoire, et jusqu'à 580 TFLOPS dans les configurations à forte intensité de calcul. FlashMLA s'est inspiré de FlashAttention 2&3 et du projet Cutlass, et est adapté aux environnements de production dès sa sortie. DeepSeek AI a démontré son innovation dans la technologie de l'IA à travers ce projet open source, qui a attiré beaucoup d'attention.

Liste des fonctions

• Décodage efficace de l'AMLOptimisé pour les GPU Hopper afin d'accélérer de manière significative le traitement des séquences de longueur variable.
• Prise en charge de la précision BF16Les opérations en virgule flottante de demi-précision permettent d'améliorer l'efficacité des calculs tout en conservant la précision.
• Pagination KV CachingLa gestion de la mémoire et l'amélioration des performances de l'inférence sont assurées par un mécanisme de pagination dont la taille des blocs est de 64.
• Haute performanceLe GPU H800 offre jusqu'à 3 000 Go/s de bande passante mémoire et 580 TFLOPS de puissance de calcul.
• source ouverteLe code source complet est fourni pour permettre aux développeurs de procéder à des modifications et à des intégrations personnalisées.

Utiliser l'aide

Processus d'installation

FlashMLA est un projet open source basé sur GitHub, vous devez vous assurer que l'environnement répond aux exigences et terminer l'installation avant de l'utiliser. Voici les étapes détaillées :

1. la préparation à l'environnement

• système d'exploitationPrise en charge des systèmes Linux (Ubuntu 20.04 ou supérieur recommandé).
• exigences en matière de matérielPour cela, il faut disposer d'un GPU NVIDIA Hopper Architecture (tel que le H800 SXM5).
• dépendance logicielle: :
  • CUDA 12.6 ou supérieur (voir le site web de NVIDIA pour les instructions d'installation).
  • PyTorch 2.0 ou supérieur (recommandé via pip install torch (Installation).
  • Python 3.8 ou supérieur.
• Outils d'inspectionPour le téléchargement de code depuis GitHub, assurez-vous que Git est installé.

2. télécharger le code source

1. Ouvrez un terminal et entrez la commande suivante pour cloner le dépôt FlashMLA :

   git clone https://github.com/deepseek-ai/FlashMLA.git

2. Accédez au catalogue de projets :

   cd FlashMLA
   

3. installation des dépendances

Le projet dépend de PyTorch et de CUDA, qui peuvent être installés à l'aide des commandes suivantes :

pip install -r requirements.txt

Si ce n'est pas le cas requirements.txt il est facile de s'assurer que PyTorch est installé :

pip install torch torchvision

Vérifiez que CUDA est disponible :

python -c "import torch; print(torch.cuda.is_available())"

exportations True Indique que la configuration de l'environnement est réussie.

4. la compilation et les tests

FlashMLA fournit des plug-ins CUDA pré-compilés, mais veillez à ce qu'ils correspondent à votre version CUDA locale :

1. Allez dans le répertoire source et exécutez le script de compilation (s'il y en a un) :

   python setup.py install
   

2. Testez l'installation et exécutez l'exemple de code :

   python example.py
   

Si aucune erreur n'est signalée, l'installation est terminée.

Comment l'utiliser

La caractéristique principale de FlashMLA est de fournir un support efficace de décodage MLA pour les tâches d'inférence de modèles d'IA. Voici les étapes :

Fonction 1 : charger et exécuter FlashMLA

1. Importation du module: :
   Introduction des fonctions de base de FlashMLA dans les scripts Python :

   from flash_mla import get_mla_metadata, flash_mla_with_kvcache
   

2. Préparation de la saisie des données: :
   • cache_seqlens: Définit la longueur de séquence de la mémoire cache KV.
   • q_i: tenseur de requête.
   • kvcache_iLes données mises en cache par le KV.
   • block_tableTable de blocs pour le cache de pagination.
3. Obtenir des métadonnées: :

   tile_scheduler_metadata, num_splits = get_mla_metadata(cache_seqlens, s_q * h_q // h_kv, h_kv)
   

4. décoder en cours d'exécution: :

   o_i, lse_i = flash_mla_with_kvcache(q_i, kvcache_i, block_table, cache_seqlens, dv, tile_scheduler_metadata, num_splits, causal=True)
   

   exportations o_i est le résultat du décodage.lse_i est la valeur de la somme logarithmique.

Fonction 2 : Optimiser le traitement des séquences de longueur variable

• prendreFlashMLA : Lorsqu'il s'agit de séquences d'entrée de longueur dynamique, FlashMLA réduit l'encombrement de la mémoire en paginant le cache KV.
• gréement: :
  1. Configurer les paramètres de pagination : la taille des blocs est fixée à 64 et peut être ajustée en modifiant le paramètre cache_seqlens Contrôle la longueur de la séquence.
  2. Spécifier au moment de l'exécution causal=True(c) S'assurer que le mécanisme d'attention causale est en vigueur.
• effetLe H800 offre une bande passante mémoire de 3000 Go/s pour les tâches d'inférence à grande échelle.

Fonction 3 : Test de performance

• Méthodes d'essai: :
  1. Modifiez l'exemple de script (par exemple example.py), ce qui augmente la taille des données d'entrée.
  2. Utilisez le code suivant pour enregistrer les performances :

     import time
     start = time.time()
     # 运行解码代码
     o_i, lse_i = flash_mla_with_kvcache(...)
     print(f"耗时: {time.time() - start} 秒")
     

• Résultats attendusLa technologie de l'information et de la communication (TIC) permet de réaliser des économies de temps et d'argent : près de 3 000 Go/s pour les tâches à forte intensité de mémoire et 580 TFLOPS pour les tâches à forte intensité de calcul.

mise en garde

• compatibilité matérielleLes GPU Hopper sont les seuls à être pris en charge ; il est recommandé d'utiliser le modèle H800 ou un modèle équivalent.
• Conseils de débogageSi vous rencontrez des erreurs CUDA, vérifiez les correspondances de versions ou demandez l'aide de la communauté dans GitHub Issues.
• environnement de productionLes modèles d'inférence : s'intègrent directement dans les processus d'inférence de modèles existants, en veillant à ce que les formats de données d'entrée soient compatibles avec les exigences de FlashMLA.

Avec les étapes ci-dessus, les utilisateurs peuvent rapidement commencer à utiliser FlashMLA et profiter de l'amélioration des performances apportée par son décodage efficace. Le code complet et la documentation peuvent être trouvés dans le dépôt GitHub, et il est recommandé d'ajuster les paramètres en fonction des besoins réels du projet.