Le framework d'inférence de Microsoft apporte des modèles de langage volumineux de 1 bit aux appareils locaux

En octobre, 17, 2024, Microsoft a annoncé BitNet.cpp, un framework d'inférence conçu pour exécuter des modèles de langage volumineux (LLM) quantifiés à 1 bit. BitNet.cpp est une avancée significative dans l'IA de génération, permettant le déploiement efficace de LLM à 1 bit sur des processeurs standards, sans nécessiter de GPU coûteux. Ce développement démocratise l'accès aux LLM, les rendant disponibles sur une large gamme d'appareils et offrant de nouvelles possibilités dans les applications d'IA sur appareil.

Comprendre les grands modèles de langage de 1 bit

Les modèles de langage volumineux (LLM) ont traditionnellement nécessité des ressources de calcul importantes en raison de l'utilisation de nombres à virgule flottante de haute précision (généralement FP16 ou BF16) pour les pondérations des modèles. Cette nécessité a rendu le déploiement des LLM coûteux et gourmand en énergie.

À la base, les LLM 1 bit utilisent des techniques de quantification extrêmes pour représenter les poids des modèles en utilisant seulement trois valeurs possibles : -1, 0 et 1, d’où le terme « 1.58 bit » (car il faut un peu plus d’un bit pour encoder trois états).

Système de poids ternaire

Le Concept

La quantification 1 bit dans BitNet.cpp est un système de pondération ternaire. BitNet fonctionne avec seulement trois valeurs possibles pour chaque paramètre :

• -1 (négatif)
• 0 (neutre)
• 1 (positif)

Cela entraîne un besoin de stockage d'environ 1.58 bits par paramètre, d'où le nom BitNet b1.58Cette réduction drastique de la largeur des bits des paramètres conduit à une réduction impressionnante de l'utilisation de la mémoire et de la complexité de calcul, car la plupart des multiplications à virgule flottante sont remplacées par de simples additions et soustractions.

Fondation mathématique

La quantification 1 bit implique la transformation des poids et des activations en leur représentation ternaire via les étapes suivantes :

1. Binarisation des poids

La binarisation des poids consiste à les centraliser autour de la moyenne (α), ce qui donne une représentation ternaire. La transformation s'exprime mathématiquement comme suit :

Wf =Signez(W-α)

Où? :

• W est la matrice de poids d'origine.
• α est la moyenne des poids.
• Signe(x) Retours +1 if x > 0 et -1 autrement.

2. Quantification d'activation

La quantification des activations garantit que les entrées sont limitées à une largeur de bits spécifiée :

x^e =Quant(x)=Agrafe(γx×Qb ,-Qb +ϵ,Qb -ϵ)

Où? :

• Qb = 2(b−1)2^{(b-1)}2(b-1) est le niveau de quantification maximal pour b- largeur de bit.
• γ est la valeur absolue maximale de x (noté comme ∣∣x∣∣∞ ).
• ε est un petit nombre pour éviter les débordements lors des calculs.

3. Opération BitLinear

La couche BitLinear remplace les multiplications matricielles traditionnelles par une opération simplifiée :

y=Wf ×x^e ×(Qb βγ )

Où? :

• β est un facteur d'échelle utilisé pour minimiser les erreurs d'approximation.
• γ met à l'échelle les activations.
• Q_b est le facteur de quantification.

Cette transformation permet des calculs efficaces tout en préservant les performances du modèle.

Implications en termes de performances

Efficacité de la mémoire

Le système de pondération ternaire réduit considérablement les besoins en mémoire :

• LLM traditionnels: 16 bits par poids
• BitNet.cpp: 1.58 bits par poids

Cette réduction se traduit par une économie de mémoire d'environ 90% par rapport aux modèles 16 bits traditionnels, permettant aux modèles plus grands de s'adapter aux mêmes contraintes matérielles.

Vitesse d'inférence, efficacité énergétique (Apple M2)

Vitesse d'inférence, efficacité énergétique (i7-13700H)

1. Vitesse d'inférence : plus rapide sur les deux processeurs

Vitesse d'inférence est représenté par le nombre de jetons traités par seconde. Voici le détail des observations :

• Sur Apple M2 Ultra : BitNet.cpp atteint jusqu'à 5.07x accélération pour les modèles plus grands (30B) par rapport à Llama.cpp, avec une vitesse de pointe de 593.43 jetons par seconde pour un modèle 125M, qui est un 1.37x accélération. Pour les modèles plus grands comme les 3.8B et 7B, BitNet.cpp maintient une vitesse supérieure à 84.77 jetons par seconde, démontrant ainsi son efficacité à toutes les échelles.
• Sur Intel i7-13700H : BitNet.cpp permet des améliorations de vitesse encore plus spectaculaires. Avec une taille de modèle de 7B, BitNet.cpp offre une accélération incroyable de 5.68x par rapport à Llama.cpp. Pour les modèles plus petits comme 125M, il traite 389.08 jetons par seconde, lequel est 2.37x plus rapide que Llama.cpp.

2. Efficacité énergétique : un changement radical pour les appareils Edge

Les graphiques fournis incluent également comparaisons des coûts de l'énergie, ce qui montre une réduction significative de la consommation d'énergie par jeton traité :

• Sur Apple M2 Ultra : Les économies d'énergie de BitNet.cpp sont substantielles. Pour le modèle 700M, il consomme 55.4% moins d'énergie par jeton par rapport à Llama.cpp, passant de 0.314 à 0.140 ans, qui. Cette tendance se poursuit pour les modèles plus grands, le modèle 70B affichant une 70.0% de réduction de la consommation d'énergie.
• Sur Intel i7-13700H : BitNet.cpp offre 71.9% d'économie d'énergie pour le modèle 700M, avec une consommation passant de 1.367 à 0.384. Bien que les données énergétiques pour le modèle 70B dans Llama.cpp ne soient pas disponibles, BitNet.cpp reste efficace, avec une consommation d'énergie de 17.33 pour le modèle 70B.

3. Dépasser la référence de vitesse de lecture humaine

L’une des informations les plus intéressantes de ces graphiques est la référence à vitesse de lecture humaine, marqué à 5 à 7 jetons par seconde. Cette ligne rouge montre que les deux implémentations, en particulier BitNet.cpp, peuvent facilement dépasser les vitesses de lecture humaines, même pour les plus grands modèles :

• On Apple M2 Ultra, BitNet.cpp surpasse la vitesse de lecture humaine pour toutes les tailles de modèle, la vitesse la plus basse étant 8.67 jetons par seconde pour un modèle 70B.
• On Intel i7-13700H, le modèle 100B atteint toujours 1.70 jetons par seconde, touchant presque la plage inférieure de la vitesse de lecture humaine, tandis que tous les modèles plus petits dépassent cette référence.

Considérations relatives à la formation

Estimateur direct (STE)

Étant donné que la quantification à 1 bit introduit des fonctions non différentiables, la formation implique une technique spécialisée connue sous le nom de Estimateur direct (STE). Dans cette approche, les gradients circulent sans modification à travers des points non différentiables. Voici une implémentation simplifiée en Python :

class StraightThroughEstimator(Function):
    @staticmethod
    def forward(ctx, input):
        return input.sign()

    @staticmethod
    def backward(ctx, grad_output):
        return grad_output

Entraînement de précision mixte

Pour maintenir la stabilité pendant l'entraînement, précision mixte est employé :

• Poids et activations:Quantifié avec une précision de 1 bit.
• Gradients et états d'optimisation:Stocké avec une précision supérieure.
• Poids latents:Maintenu avec une haute précision pour faciliter des mises à jour précises pendant la formation.

Stratégie de taux d'apprentissage élevé

L'un des défis spécifiques aux modèles 1 bit est que les petites mises à jour peuvent ne pas affecter les poids binarisés. Pour atténuer ce problème, le taux d'apprentissage est augmenté, ce qui garantit une convergence plus rapide et une meilleure optimisation par rapport aux approches traditionnelles.

Quantification et normalisation de groupe

BitNet.cpp présente Quantification et normalisation de groupe pour améliorer le parallélisme du modèle. Au lieu de calculer les paramètres pour l'ensemble de la matrice de pondération, BitNet divise les pondérations et les activations en plusieurs groupes (G).

Ce regroupement permet un traitement parallèle efficace sans communication inter-groupe supplémentaire, permettant ainsi une formation et une inférence de modèles à grande échelle.

Notes d'implémentation et optimisations

Optimisation du processeur

BitNet.cpp exploite plusieurs optimisations de bas niveau pour atteindre des performances CPU optimales :

• Opérations vectorisées:Utilise les instructions SIMD pour effectuer des manipulations de bits efficacement.
• Accès à la mémoire compatible avec le cache:Structure les données pour minimiser les échecs de cache.
• Traitement parallèle:Répartit efficacement la charge de travail sur plusieurs cœurs de processeur.

Voici un exemple d'une fonction clé implémentant la quantification et l'inférence dans BitNet :

 
def bitlinear_forward(input, weight, scale):
    # Quantize the input using absmax quantization
    input_q = quantize(input)
    
    # Perform binary matrix multiplication
    output = binary_matmul(input_q, weight)
    
    # Scale the output to match the original precision
    return output * scale

def quantize(x):
    # Perform absmax quantization
    scale = torch.max(torch.abs(x))
    return torch.clamp(x / scale, -1, 1) * scale

# Binarization function for 1-bit weights
def binarize_weights(W):
    alpha = W.mean()
    W_binarized = np.sign(W - alpha)
    return W_binarized