Quantification des grands modèles de langage pour la génération de code : une réplication différenciée

Quantizing Large Language Models for Code Generation: A Differentiated Replication

March 10, 2025

Auteurs: Alessandro Giagnorio, Antonio Mastropaolo, Saima Afrin, Massimiliano Di Penta, Gabriele Bavota

cs.AI

Résumé

Les grands modèles de langage (LLM) ont démontré une capacité impressionnante en génération de code, et plus spécifiquement, à implémenter automatiquement des exigences décrites en langage naturel. L'efficacité des LLM augmente généralement avec leur taille : plus le nombre de paramètres entraînables du LLM est élevé, meilleure est sa capacité à générer du code. Cependant, lorsqu'il s'agit de déployer des générateurs de code basés sur des LLM, les modèles plus volumineux posent des défis importants liés à leur empreinte mémoire (et, par conséquent, carbone). Un travail précédent de Wei et al. a proposé d'exploiter des techniques de quantification pour réduire l'empreinte mémoire des générateurs de code basés sur des LLM sans dégrader substantiellement leur efficacité. En bref, ils ont étudié des LLM comportant jusqu'à 16 milliards de paramètres, en quantifiant leur précision de 32 bits en virgule flottante à 8 bits en entier, et ont montré leur impact limité sur les performances de génération de code. Compte tenu du rythme rapide auquel les capacités des LLM et les techniques de quantification évoluent, dans ce travail, nous présentons une réplication différenciée de l'étude de Wei et al. dans laquelle nous considérons (i) d'une part, des LLM plus récents et plus volumineux, allant jusqu'à 34 milliards de paramètres ; (ii) les dernières avancées en matière de techniques de quantification de modèles, qui permettent de pousser la compression jusqu'au niveau extrême de 2 bits par paramètre de modèle ; et (iii) différents types de jeux de données de calibration pour guider le processus de quantification, y compris des jeux de données spécifiques au code. Notre évaluation empirique révèle que la nouvelle frontière pour la quantification des LLM est une précision de 4 bits, entraînant une réduction moyenne de l'empreinte mémoire de 70 % par rapport au modèle original, sans observer de diminution significative des performances. De plus, lorsque la quantification devient encore plus extrême (3 et 2 bits), un jeu de données de calibration spécifique au code aide à limiter la perte de performance.

English

Large Language Models (LLMs) have shown an impressive capability in code generation and, specifically, to automatically implement requirements described in natural language. The LLM effectiveness generally increases with its size: The higher the number of LLM's trainable parameters the better its ability to implement code. However, when it comes to deploying LLM-based code generators, larger LLMs pose significant challenges related to their memory (and, consequently, carbon) footprint. A previous work by Wei et al. proposed to leverage quantization techniques to reduce the memory footprint of LLM-based code generators without substantially degrading their effectiveness. In short, they studied LLMs featuring up to 16B parameters, quantizing their precision from floating point 32 bits down to int 8 bits and showing their limited impact on code generation performance. Given the fast pace at which LLM capabilities and quantization techniques are evolving, in this work we present a differentiated replication of the work by Wei et al. in which we consider (i) on the one side, more recent and larger code-related LLMs, of up to 34B parameters; (ii) the latest advancements in model quantization techniques, which allow pushing the compression to the extreme quantization level of 2 bits per model parameter and; (iii) different types of calibration datasets to guide the quantization process, including code-specific ones. Our empirical evaluation reveals that the new frontier for LLM quantization is 4-bit precision, resulting in an average memory footprint reduction of 70% compared to the original model without observing any significant decrease in performance. Additionally, when the quantization becomes even more extreme (3 and 2 bits), a code-specific calibration dataset helps to limit the loss of performance.