Kwantificeren van grote taalmodellen voor codegeneratie: een gedifferentieerde replicatie

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

Samenvatting

Grote Taalmodellen (LLMs) hebben een indrukwekkend vermogen getoond in codegeneratie en, specifiek, in het automatisch implementeren van vereisten die in natuurlijke taal zijn beschreven. De effectiviteit van een LLM neemt over het algemeen toe met zijn grootte: hoe meer trainbare parameters een LLM heeft, hoe beter zijn vermogen om code te implementeren. Echter, bij het inzetten van LLM-gebaseerde codegeneratoren, vormen grotere LLMs aanzienlijke uitdagingen met betrekking tot hun geheugen- (en daarmee ook koolstof-)voetafdruk. Eerder werk van Wei et al. stelde voor om kwantisatietechnieken te benutten om de geheugenvoetafdruk van LLM-gebaseerde codegeneratoren te verkleinen zonder hun effectiviteit substantieel te verminderen. Kort gezegd bestudeerden zij LLMs met tot 16B parameters, waarbij ze de precisie kwantiseerden van 32-bits floating point naar 8-bits integers en lieten zien dat dit slechts een beperkte impact had op de codegeneratieprestaties. Gezien het snelle tempo waarin de mogelijkheden van LLMs en kwantisatietechnieken evolueren, presenteren wij in dit werk een gedifferentieerde replicatie van het werk van Wei et al., waarin we (i) aan de ene kant recentere en grotere codegerelateerde LLMs beschouwen, met tot 34B parameters; (ii) de nieuwste ontwikkelingen in modelkwantisatietechnieken, die het mogelijk maken om de compressie te pushen naar het extreme kwantisatieniveau van 2 bits per modelparameter; en (iii) verschillende soorten kalibratiedatasets om het kwantisatieproces te begeleiden, inclusief code-specifieke datasets. Onze empirische evaluatie onthult dat de nieuwe grens voor LLM-kwantisatie 4-bits precisie is, wat resulteert in een gemiddelde vermindering van de geheugenvoetafdruk van 70% vergeleken met het originele model, zonder enige significante prestatievermindering waar te nemen. Daarnaast, wanneer de kwantisatie nog extremer wordt (3 en 2 bits), helpt een code-specifieke kalibratiedataset om het prestatieverlies te beperken.

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.