QLoRA на RX 6600: как заставить RDNA2 работать там, где AMD сказала «нет»

Почему ваша RX 6600 «не подходит» для QLoRA (и почему это бред)

Вы купили RX 6600. 8GB GDDR6, RDNA2 архитектура, цена в два раза ниже RTX 4060. Идеально для экспериментов с QLoRA, правда? Заходите на сайт AMD, читаете системные требования ROCm 6.2 (актуально на 30.01.2026):

Первая реакция: «AMD, вы серьёзно?». Вторая: «Значит, купил не то». Третья (правильная): «Подождите, а что технически мешает?».

Ответ прост до смешного. Ничего. Абсолютно ничего не мешает. RDNA2 в RX 6600 имеет те же вычислительные блоки, ту же архитектуру памяти, тот же набор инструкций, что и в официально поддерживаемых RX 7700 XT. Разница только в количестве этих блоков. Поддержку отключили искусственно — маркетинговое решение, чтобы продавать дорогие карты.

Что сломается, если мы включим поддержку

Ничего не сломается. Но будут нюансы, о которых AMD умалчивает:

• Проприетарные библиотеки: MIOpen, rocBLAS — оптимизированы под конкретные конфигурации. На RX 6600 они будут работать, но не на максимальной скорости. Разница 15-25%.
• Проверка при установке: Установщик ROCm проверяет PCI ID вашей карты. Если нет в белом списке — отказ.
• Драйвер ядра: Модуль amdgpu загружает прошивку только для «разрешённых» карт.

Всё это — программные ограничения. Железо готово. Нам нужно обмануть систему.

Патчим ядро: самый опасный (и рабочий) способ

Предупреждаю сразу: если вы не комфортно чувствуете себя в терминале, лучше остановиться. Или купить NVIDIA. Здесь мы будем модифицировать драйвер ядра Linux.

1 Подготовка системы: Ubuntu 24.04 LTS

Нужна свежая система. Не Ubuntu 22.04, не Fedora 39 — только 24.04. Почему? Потому что ядро 6.8+ имеет лучшую поддержку RDNA2, а в репозиториях есть ROCm 6.2.

# Обновляем всё
sudo apt update && sudo apt full-upgrade -y

# Ставим зависимости для сборки ядра
sudo apt install build-essential libncurses-dev bison flex libssl-dev libelf-dev \
  dwarves zstd git cmake pkg-config -y

# Устанавливаем ROCm (без драйверов, только библиотеки)
sudo apt install rocm-llvm rocm-dev rocm-libs miopen-hip rocblas -y

2 Скачиваем и патчим исходники ядра

Берём ядро 6.8.0 — золотая середина между стабильностью и поддержкой новинок. Новее 6.10 не берите: там могут быть изменения, которые сломают наш патч.

# Скачиваем ядро
cd ~
wget https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.8.tar.xz
tar -xf linux-6.8.tar.xz
cd linux-6.8

# Клонируем патч-файл
wget https://gist.githubusercontent.com/anon/raw/linux-6.8-amdgpu-rdna2.patch

# Применяем патч
patch -p1 < linux-6.8-amdgpu-rdna2.patch

Что делает этот патч? Он добавляет PCI ID RX 6600 (0x73ff) в массив поддерживаемых устройств драйвера amdgpu. В файле drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c ищете массив pciidlist и дописываете:

/* RX 6600 */
{0x1002, 0x73ff, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_NAVI23},

3 Конфигурируем и собираем ядро

# Копируем конфиг текущего ядра
cp /boot/config-$(uname -r) .config

# Обновляем конфиг для нового ядра
make olddefconfig

# Включаем необходимые модули AMDGPU
scripts/config --enable CONFIG_DRM_AMDGPU_CIK
scripts/config --enable CONFIG_DRM_AMDGPU_USERPTR
scripts/config --enable CONFIG_DRM_AMD_DC
scripts/config --enable CONFIG_DRM_AMD_DC_DCN

# Собираем ядро (это займёт 30-60 минут в зависимости от CPU)
make -j$(nproc) bindeb-pkg

После сборки в директорию выше появятся .deb пакеты. Устанавливаем их:

cd ..
sudo dpkg -i linux-image-6.8.0*.deb linux-headers-6.8.0*.deb

Перезагружаемся. При загрузке Grub выберите новое ядро 6.8.0. После загрузки проверьте:

uname -r  # Должно быть 6.8.0
lsmod | grep amdgpu  # Должен быть загружен

Устанавливаем ROCm с костылями

Теперь, когда ядро видит карту как «поддерживаемую», можно ставить полный ROCm. Но установщик всё равно проверит PCI ID. Обманем его.

4 Патчим установщик ROCm

Скачиваем .deb пакет rocm-dkms напрямую с сайта AMD (версия 6.2.0, актуально на 30.01.2026).

wget https://repo.radeon.com/amdgpu-install/6.2/ubuntu/pool/main/r/rocm-dkms/rocm-dkms_6.2.0.60002-1_all.deb

# Распаковываем пакет
mkdir rocm-dkms-extract
cd rocm-dkms-extract
dpkg-deb -x ../rocm-dkms_6.2.0.60002-1_all.deb .
dpkg-deb -e ../rocm-dkms_6.2.0.60002-1_all.deb

# Редактируем скрипт postinst
nano DEBIAN/postinst

В файле postinst ищем функцию check_gpu_support(). В ней будет массив supported_gpus. Добавляем наш PCI ID:

supported_gpus=(
  "0x744c" "0x7480" "0x73a0" "0x73a1" "0x73a2" "0x73a3"
  "0x73ff"  # Добавляем RX 6600
)

Перепаковываем пакет и устанавливаем:

dpkg-deb -b . ../rocm-dkms-patched.deb
cd ..
sudo dpkg -i rocm-dkms-patched.deb

Проверяем, что ROCm видит карту

# Проверяем доступность HIP
hipconfig

# Смотрим, видит ли ROCm устройство
rocm-smi

Если в rocm-smi видите вашу RX 6600 — поздравляю, самый сложный этап пройден. Если нет — проверьте dmesg на ошибки загрузки amdgpu.

Устанавливаем окружение для QLoRA

Теперь стандартная часть. Используем PEFT и transformers от Hugging Face, но с поправкой на HIP.

# Создаём виртуальное окружение
python -m venv ~/qlora-env
source ~/qlora-env/bin/activate

# Устанавливаем PyTorch с поддержкой HIP
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm6.2

# Устанавливаем остальные зависимости
pip install transformers accelerate datasets peft bitsandbytes
pip install scipy sentencepiece protobuf

Запускаем QLoRA: практический пример

Берём небольшую модель, например Qwen2.5-1.5B — поместится в 8GB с запасом для LoRA адаптеров.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from peft import LoraConfig, get_peft_model, TaskType
from trl import SFTTrainer
from datasets import load_dataset

# Проверяем устройство
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")
print(f"GPU name: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'None'}")

# Загружаем модель и токенизатор
model_name = "Qwen/Qwen2.5-1.5B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

# Настраиваем LoRA
lora_config = LoraConfig(
    r=16,  # Rank
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type=TaskType.CAUSAL_LM
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

# Подготавливаем датасет (пример)
dataset = load_dataset("json", data_files="your_data.json", split="train")

def format_instruction(example):
    return {"text": f"### Instruction: {example['instruction']}\n### Response: {example['response']}"}

dataset = dataset.map(format_instruction)

# Настройки обучения
training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=2,  # Меньше из-за 8GB памяти
    gradient_accumulation_steps=4,
    warmup_steps=100,
    logging_steps=10,
    save_steps=500,
    eval_steps=500,
    fp16=True,  # Обязательно для RX 6600
    gradient_checkpointing=True,  # Экономит память
    optim="adamw_8bit",  # 8-битный Adam
)

# Тренируем
trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
    tokenizer=tokenizer,
    max_seq_length=512,
)

trainer.train()

Ошибки, которые гарантированно встретятся (и как их исправить)

Альтернатива: llama.cpp с QLoRA адаптерами

Если PyTorch с HIP работает слишком медленно, есть другой путь. Обучаете LoRA адаптеры на CPU (долго, но работает), затем применяете их к квантованной модели через llama.cpp.

# Конвертируем модель в GGUF формат
python convert.py ~/model --outtype f16 --outfile model.f16.gguf

# Квантуем до Q4_K_M (лучшее качество/размер)
./quantize model.f16.gguf model.q4_k_m.gguf Q4_K_M

# Применяем LoRA адаптеры (скрипт нужно найти или написать)
python apply_lora.py --model model.q4_k_m.gguf --lora lora_adapters.bin --out model_qlora.gguf

Запускаете через llama.cpp с ROCm бэкендом. Скорость будет выше, чем у PyTorch, но функциональность ограничена инференсом.

Стоит ли игра свеч?

Давайте честно. Если вам нужно стабильное окружение для продакшена — купите NVIDIA. Даже старая RTX 3060 12GB будет проще.

Но если у вас уже есть RX 6600, вы любите ковыряться в ядре и получаете кайф от взлома систем — это идеальный проект. Производительность? Ожидайте 60-70% от аналогичной NVIDIA карты. Но цена была в два раза ниже, помните?

Главное — теперь вы знаете правду. Технических ограничений нет. Есть только файлы конфигурации, которые можно отредактировать. И ядро, которое можно пересобрать. И установщик, который можно обмануть.

AMD могла бы добавить одну строчку в свой драйвер. Но не добавила. Пришлось добавить вам.