Введение

Большие языковые модели (LLM) продемонстрировали высокую эффективность в задачах автоматической генерации программного кода. Современные специализированные модели семейств Code Llama [9], Qwen Coder [6] и DeepSeek-Coder [5] достигают показателей pass@1 на бенчмарке HumanEval [2] в диапазоне 30–80 %, что делает их практически применимыми для автодополнения кода и генерации типовых программных конструкций.

Локальное развёртывание моделей на потребительском аппаратном обеспечении становится возможным благодаря развитию методов квантизации [3, 7] — снижения разрядности представления весов нейронной сети. Это позволяет уменьшить требования к видеопамяти в 2–4 раза и запускать модели уровня 7–15 миллиардов параметров на бытовых GPU с 8 ГБ VRAM.

Компилируемые языки со строгой типизацией (C, C++, Rust) требуют синтаксической и типовой корректности до запуска, тогда как интерпретируемые (Python, JavaScript) допускают выполнение частично корректного кода. Это создаёт основание для гипотезы о неравномерном влиянии квантизации на кодогенерацию для разных классов языков.

Цель настоящей работы — экспериментально исследовать влияние квантизации LLM на качество кодогенерации для компилируемых и интерпретируемых языков и определить, является ли наблюдаемый эффект универсальным или модельно-зависимым.

Обзор существующих подходов

Методы квантизации LLM. Frantar и др. [3] предложили GPTQ — послеобучающее квантование на основе приближённого гессиана, позволяющее квантовать модели до 3–4 бит. Lin и др. [7] развили подход в AWQ с активационно-зависимым взвешиванием каналов. Проект llama.cpp [4] реализует систему K-квантов с блочным масштабированием и разделением уровней квантизации для тензоров внимания и FFN.

Оценка кодогенерации. Стандартным бенчмарком для оценки качества кодогенерации является HumanEval [2], содержащий 164 задачи на Python с тестами. Cassano и др. [1] в проекте MultiPL-E предложили автоматический перевод HumanEval на 18 языков программирования, что обеспечило возможность кросс-языкового сравнения качества генерации.

Квантизация и кодогенерация. Plyaskin и др. [8] изучали влияние квантизации на качество кодогенерации для низкоресурсных языков, показав неравномерную деградацию между языками, но без прямого сопоставления компилируемых и интерпретируемых языков. Систематическое исследование взаимосвязи между типом языка программирования и чувствительностью к квантизации на потребительской аппаратной платформе не проводилось.

Материалы и методы исследования

Аппаратный стенд. Процессор Intel Core i5–13420H, ОЗУ DDR4 16 ГБ, GPU NVIDIA GeForce RTX 4060 (8 ГБ GDDR6, архитектура Ada Lovelace), NVMe SSD 512 ГБ. Операционная система — Windows 11, CUDA 12.6. Инструмент инференса — Ollama (URL: https://ollama.com/) версии 0.6.x.

Исследуемые модели. Для эксперимента отобраны три модели (табл. 1). Qwen 2.5 Coder 7B [6] и DeepSeek Coder V2 Lite [5] — современные специализированные модели для кодогенерации. CodeLlama 7B [9] выбрана как представитель предыдущего поколения для сравнения.

Таблица 1

Характеристики исследуемых моделей

Уровни квантизации. Исследованы два уровня квантизации формата GGUF: Q8_0–8-битное целочисленное квантование (приблизительно двукратное сжатие); Q4_K_M — 4-битное квантование с K-квантами, при котором тензоры FFN квантуются до 4 бит, а тензоры внимания на 1–2 шага выше по разрядности (приблизительно четырёхкратное сжатие) [4].

Бенчмарки. HumanEval [2] — 164 задачи на Python с тестами. HumanEval-C++ из проекта MultiPL-E [1] — 81 задача на C++. Метрика качества — pass@1 при температуре генерации 0,2.

Процедура эксперимента. Для каждой задачи модели передавался промпт с сигнатурой функции и инструкцией сгенерировать тело функции без пояснений. Параметры генерации: температура 0,2, максимальное число токенов 512. Взаимодействие осуществлялось через HTTP API Ollama. Применялась унифицированная процедура извлечения кода: удаление маркеров блоков кода, определение формата ответа (только тело или полная функция) и корректная склейка с тестовым окружением. Тесты для Python запускались в CPython 3.10 с таймаутом 10 секунд, для C++ — компилятором g++ 15.2.0 (MSYS2), стандарт C++17, таймаут 10 секунд. Результат фиксировался как pass (все тесты пройдены) или fail с классификацией ошибки. Потребление видеопамяти регистрировалось утилитой nvidia-smi с интервалом 5 секунд (всего 12 715 замеров).

Результаты исследования и их обсуждение

Результаты замеров pass@1 для всех комбинаций модель × язык × уровень квантизации представлены в таблице 2.

Таблица 2

Результаты pass@1, %

Данные таблицы 2 демонстрируют три принципиально различных паттерна реакции на квантизацию.

Qwen 2.5 Coder 7B демонстрирует устойчивость к квантизации для обоих языков. Деградация pass@1 для Python составляет лишь 2,4 п.п., а для C++ наблюдается даже незначительное улучшение (+1,2 п.п.), которое находится в пределах статистической погрешности. Это свидетельствует о том, что модель изначально обучена с достаточным запасом качества, и 4-битная квантизация не затрагивает критические для корректности веса.

DeepSeek Coder V2 Lite демонстрирует наиболее выраженный эффект: при стабильных результатах для Python (+3,0 п.п., что может объясняться стохастичностью генерации) наблюдается катастрофическая деградация C++ (−33,3 п.п.). Отношение деградации C++ к деградации Python составляет 11,1, что указывает на экстремальную чувствительность MoE-архитектуры к квантизации именно для компилируемых языков. Вероятная причина — при квантизации MoE-модели часть экспертов, ответственных за синтаксические паттерны C++, деградирует непропорционально сильно.

CodeLlama 7B показывает обратный паттерн: значительная деградация для Python (−7,9 п.п.) при минимальных изменениях для C++ (−1,3 п.п.). Однако абсолютные значения pass@1 для C++ крайне низки (16–17 %), что означает: модель изначально не справляется с большинством задач на C++, и квантизация не может ухудшить то, что и так не работает.

Все неудачные генерации C++ при Q4_K_M были классифицированы по типам ошибок (табл. 3).

Таблица 3

Распределение ошибок C++ при Q4_K_M, % от неудачных

Ключевой результат анализа ошибок: 80–96 % неудачных генераций C++ для DeepSeek и CodeLlama приходятся на ошибки компиляции. Для Qwen 2.5 Coder, имеющего значительно меньше неудачных генераций (15 из 81), ошибки более равномерно распределены между компиляцией (40 %) и runtime (53,3 %), что указывает на то, что модель в целом генерирует компилируемый код, а ошибки носят логический характер.

Для Python ошибки распределены иначе (табл. 4): преобладают логические ошибки (38–72 %), значительную долю занимают синтаксические (15–48 %). Runtime-ошибки составляют 8–19 %.

Таблица 4

Распределение ошибок Python при Q4_K_M, % от неудачных

Полученные результаты позволяют уточнить исходную гипотезу. Квантизация не оказывает универсально более сильного влияния на кодогенерацию для компилируемых языков — эффект является модельно-зависимым и определяется взаимодействием трёх факторов: архитектуры модели, качества обучения и характеристик целевого языка.

Роль архитектуры. Наиболее выраженная деградация C++ наблюдается у DeepSeek Coder V2 Lite — единственной MoE-модели в эксперименте. При квантизации MoE-моделей деградация распределяется неравномерно между экспертами, и если эксперты, ответственные за синтаксические паттерны C++ (типы, шаблоны, управление памятью), квантуются агрессивно, это приводит к непропорциональной деградации. Dense-модели (Qwen 2.5 Coder, CodeLlama) демонстрируют более равномерную деградацию.

Роль качества обучения. Qwen 2.5 Coder 7B устойчив к квантизации для обоих языков, что свидетельствует о широких марджинах качества — модель генерирует код с запасом корректности, и квантизационный шум не достигает порога ошибок. CodeLlama 7B, напротив, работает на пределе для C++ (17 % pass@1), и квантизация уже не может ухудшить результат, тогда как для Python (33,5 %) деградация заметна.

Роль компилятора как фильтра. Анализ ошибок подтверждает, что компилятор C++ действует как жёсткий бинарный фильтр: 80–96 % неудачных генераций — ошибки компиляции. В Python аналогичная категория значительно меньше (синтаксические ошибки 15–48 %), а основную долю составляют логические ошибки, которые слабо зависят от типа языка.

Практические рекомендации. Для Qwen 2.5 Coder 7B квантизация Q4_K_M допустима для обоих языков без значимой потери качества. Для DeepSeek Coder V2 Lite при работе с C++ настоятельно рекомендуется Q8_0, тогда как для Python Q4_K_M приемлем. Для CodeLlama 7B рекомендуется обновление до более современной модели вне зависимости от уровня квантизации.

Заключение

Проведено экспериментальное исследование влияния квантизации трёх LLM на качество кодогенерации для Python и C++. Установлено, что влияние квантизации является модельно-зависимым, а не универсально привязанным к типу языка.

DeepSeek Coder V2 Lite (MoE-архитектура) демонстрирует экстремальную чувствительность к квантизации для C++ (−33,3 п.п.) при стабильных результатах для Python, что подтверждает гипотезу о повышенной уязвимости компилируемых языков, но только для MoE-моделей. Qwen 2.5 Coder 7B устойчив к квантизации для обоих языков. CodeLlama 7B деградирует преимущественно для Python.

Установлено, что 80–96 % неудачных генераций C++ составляют ошибки компиляции, что подтверждает роль компилятора как жёсткого бинарного фильтра квантизационного шума.

Сформулированы практические рекомендации: для Qwen 2.5 Coder 7B допустим Q4_K_M для обоих языков; для DeepSeek Coder V2 Lite при работе с C++ необходим Q8_0; для CodeLlama рекомендуется замена на современную модель.

Дальнейшие исследования предполагают: систематическое сравнение Dense- и MoE-архитектур; расширение набора языков (Rust, Go, JavaScript); исследование динамического квантования; использование более сложных бенчмарков (MBPP, SWE-bench).

Литература:

1. Cassano F., Gouwar J., Nguyen D. et al. MultiPL-E: A Scalable and Polyglot Approach to Benchmarking Neural Code Generation // IEEE Transactions on Software Engineering. — 2023. — Vol. 49, No. 7. — P. 3675–3691.
2. Chen M., Tworek J., Jun H. et al. Evaluating Large Language Models Trained on Code // arXiv:2107.03374. — 2021.
3. Frantar E., Ashkboos S., Hoefler T., Alistarh D. GPTQ: Accurate Post-Training Quantization for Generative Pre-Trained Transformers // arXiv:2210.17323. — 2023.
4. Gerganov G. llama.cpp [Электронный ресурс]. — URL: https://github.com/ggml-org/llama.cpp (дата обращения: 20.04.2026).
5. Guo D., Zhu Q., Yang D. et al. DeepSeek-Coder: When the Large Language Model Meets Programming // arXiv:2401.14196. — 2024.
6. Hui B., Yang J., Cui Z. et al. Qwen2.5-Coder Technical Report // arXiv:2409.12186. — 2024.
7. Lin J., Tang J., Tang H. et al. AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration // Proceedings of MLSys. — 2024.
8. Plyaskin A. et al. Impact of Quantization on LLM Code Generation for Low-Resource Languages // arXiv preprint. — 2024.
9. Rozière B., Gehring J., Gloeckle F. et al. Code Llama: Open Foundation Models for Code // arXiv:2308.12950. — 2023.