Сравнительный тест Qwen3.5: 4B, 9B и 27B модели в Ollama на Radeon 7900XTX

Зачем это вообще нужно? Проблема выбора модели

Скажем прямо: выбирать локальную LLM в 2026 году — это как покупать машину, не зная дорог. Все хотят "самую умную", но забывают, что GPT-5 Pro Max Ultra не влезет в их скромную Radeon 7900XTX. На бумаге 27B модель выглядит круто. На практике она может превратить ваш ПК в дорогой обогреватель, выдавая 2 токена в секунду.

Поэтому сегодня мы не будем гадать. Мы замерим все цифры на реальном железе: AMD Radeon 7900 XTX с 24 ГБ VRAM, свежий Ollama 0.6.4 (на март 2026) и три последние версии Qwen3.5 от Alibaba. Нас интересует один вопрос: насколько сильно мы проигрываем в качестве, переходя с 27B на крошку 4B? И стоит ли эта разница в скорости.

Что мы тестируем и как: железо, софт, метрики

Конфигурация стенда максимально простая, чтобы любой мог повторить:

• Видеокарта: AMD Radeon 7900 XTX (Navi 31, 24 ГБ GDDR6). Никаких NVLink и танцев с бубном.
• Движок: Ollama 0.6.4 с поддержкой ROCm 6.2. Почему Ollama? Потому что это самый простой способ запустить модель одной командой. Для фанатов vLLM у меня есть отдельная битва движков.
• Модели: Qwen3.5:4B, Qwen3.5:9B, Qwen3.5:27B. Используются последние на март 2026 GGUF-квантования от TheBloke (формат Q4_K_M).
• Метрики: Скорость (токенов в секунду), потребление VRAM, качество ответов на стандартные промпты (код, логика, креатив).

1 Установка и настройка Ollama под AMD

Сначала ставим Ollama. Для Linux (Ubuntu 24.04) это одна команда. Для Windows — скачиваем инсталлер с официального сайта. Главный подвох — заставить Ollama увидеть ROCm.

curl -fsSL https://ollama.ai/install.sh | sh
export HSA_OVERRIDE_GFX_VERSION=11.0.0  # Для Navi 31
export HIP_VISIBLE_DEVICES=0

Проверяем, что Ollama использует GPU:

ollama run qwen3.5:4b
>>> /set verbose
>>> /show system

В выводе ищем строки типа "Using GPU: AMD Radeon Graphics". Если видите "Using CPU" — что-то пошло не так с ROCm.

2 Загрузка моделей и первый запуск

Ollama сам скачает модели при первом запуске. Но чтобы избежать сюрпризов, лучше указать точный тег.

# Загружаем все три модели
ollama pull qwen3.5:4b
ollama pull qwen3.5:9b
ollama pull qwen3.5:27b

Проверяем, что модели загрузились:

ollama list

3 Написание скрипта для бенчмарка

Ollama имеет REST API. Мы напишем простой Python-скрипт, который будет измерять скорость генерации и потребление памяти. Установите requests и psutil.

import requests
import time
import psutil
import json

OLLAMA_URL = "http://localhost:11434/api/generate"

PROMPT = """Ты — опытный программист. Напиши функцию на Python, которая проверяет, является ли строка палиндромом. Объясни логику."""

def benchmark_model(model_name, prompt, max_tokens=300):
    """Запускает модель и замеряет скорость."""
    payload = {
        "model": model_name,
        "prompt": prompt,
        "stream": False,
        "options": {
            "num_predict": max_tokens
        }
    }
    
    # Замер памяти до
    gpu_mem_before = get_gpu_memory() if has_rocm() else None
    
    start_time = time.time()
    response = requests.post(OLLAMA_URL, json=payload)
    end_time = time.time()
    
    # Замер памяти после
    gpu_mem_after = get_gpu_memory() if has_rocm() else None
    
    if response.status_code == 200:
        result = response.json()
        total_time = end_time - start_time
        tokens_generated = result.get("eval_count", 0)
        tokens_per_second = tokens_generated / total_time if total_time > 0 else 0
        
        return {
            "model": model_name,
            "time_sec": round(total_time, 2),
            "tokens": tokens_generated,
            "tokens_per_sec": round(tokens_per_second, 2),
            "memory_used_mb": gpu_mem_after - gpu_mem_before if gpu_mem_before and gpu_mem_after else None,
            "response": result.get("response", "")[:500]  # Первые 500 символов
        }
    else:
        print(f"Ошибка для {model_name}: {response.status_code}")
        return None

# Вспомогательные функции (заглушки, реализация зависит от системы)
def get_gpu_memory():
    """Возвращает используемую VRAM в МБ. Для AMD через ROCm можно использовать rocm-smi."""
    # Пример для Linux с rocm-smi
    import subprocess
    try:
        output = subprocess.check_output(['rocm-smi', '--showmeminfo', 'vram', '-t'], text=True)
        # Парсинг вывода. Это пример, реальная реализация сложнее.
        for line in output.split('\n'):
            if 'Used' in line:
                parts = line.split()
                if len(parts) >= 2:
                    return int(parts[-2])
    except:
        pass
    return 0

def has_rocm():
    """Проверяет, доступен ли ROCm."""
    try:
        import subprocess
        subprocess.check_output(['rocm-smi'], stderr=subprocess.DEVNULL)
        return True
    except:
        return False

if __name__ == "__main__":
    models = ["qwen3.5:4b", "qwen3.5:9b", "qwen3.5:27b"]
    results = []
    for model in models:
        print(f"Тестируем {model}...")
        result = benchmark_model(model, PROMPT)
        if result:
            results.append(result)
            print(f"  Скорость: {result['tokens_per_sec']} токенов/сек")
        else:
            print(f"  Провал")
    
    print("\nИтоговые результаты:")
    for r in results:
        print(f"{r['model']}: {r['tokens_per_sec']} токенов/сек, память: {r['memory_used_mb']} МБ")

Скрипт — основа. В реальности для точного замера памяти нужно использовать rocm-smi или AMD's ROCm SMI Library. Но даже эти цифры дадут понимание масштаба.

Цифры, которые всех ждали: результаты тестов

Я прогнал каждую модель на пяти разных промптах (код, логика, творчество, вопрос-ответ, суммаризация). Усредненные результаты на Radeon 7900XTX:

*Качество — субъективная оценка по 5 промптам от 1 до 10. 4B иногда "халтурит" в сложных рассуждениях.

Что это значит на практике? Qwen3.5:4B в 5-6 раз быстрее 27B-версии. Да, вы правильно прочитали. При этом она занимает вчетверо меньше видеопамяти. А теперь главное: для большинства повседневных задач — написание простого кода, ответы на вопросы, суммаризация текста — разница в качестве почти незаметна. 27B блистает в сложных логических цепочках и многоэтапных инструкциях. Но если вам нужен быстрый "умный ассистент", который не заставляет ждать, 4B — темная лошадка.

Где собака зарыта: нюансы и грабли

1. Квантование — ваш друг и враг. Мы тестировали Q4_K_M (среднее качество, хорошая скорость). Если взять более агрессивное квантование (Q2_K), скорость вырастет, но качество просядет, особенно у маленьких моделей. Для 4B я бы не советовал опускаться ниже Q4_K_M. А вот для 27B можно поэкспериментировать с Q3_K_M, чтобы сэкономить память без больших потерь.

2. Температура и seed. По умолчанию Ollama использует температуру 0.8. Для бенчмарков это плохо — результаты будут плавать. В скрипте добавьте в опции "temperature": 0.0 и "seed": 42 для детерминированности. Иначе один раз получите 80 токенов/сек, а другой — 60.

"options": {
  "num_predict": 300,
  "temperature": 0.0,
  "seed": 42
}

3. Контекстное окно. Qwen3.5 поддерживает 128К контекста. Но чем больше контекст вы подаете, тем медленнее работает модель (особенно 27B). По умолчанию Ollama ограничивает контекст. Если вам действительно нужны длинные тексты, смотрите статью про 262К контекст на AMD.

4. Ошибка: "Not enough GPU memory". Если вы пытаетесь запустить 27B модель и получаете эту ошибку, хотя VRAM 24 ГБ хватает, проблема в фрагментации памяти ROCm. Перезапустите Ollama, убедитесь, что нет других процессов, жрущих VRAM. В крайнем случае, перезагрузитесь.

FAQ: вопросы, которые вы хотели задать

Q: Насколько эти результаты применимы к NVIDIA RTX?

A: На NVIDIA картах (например, RTX 4070 Ti Super) скорости будут выше из-за более оптимизированных библиотек CUDA. Но соотношение между моделями сохранится: 4B останется намного быстрее 27B. Конкретные цифры для NVIDIA можно глянуть в разборе Blackwell архитектуры.

Q: А есть ли смысл использовать 9B модель? Она же посерединке.

A: Смысл есть, если вам критично качество чуть лучше, чем у 4B, но 27B слишком медленная. 9B — это компромиссный вариант. На Radeon 7900XTX она работает вполне шустро (~40 токенов/сек). Если вы планируете запускать модель в фоне для каких-то автоматизаций, где скорость не главное, но и глупость не нужна — 9B ваш выбор.

Q: Почему не протестировали Qwen3.5:14B или 72B?

A: 14B на момент марта 2026 года — не самая популярная версия, и ее нет в официальной библиотеке Ollama по умолчанию. 72B в 24 ГБ VRAM просто не влезет даже с квантованием Q2_K. Для таких экспериментов нужно несколько карт, как в истории с 3x3090.

Q: Можно ли использовать эти модели для кодинга?

A: Да, все версии Qwen3.5 тренированы на код. 4B справляется с простыми функциями и объяснениями. Для сложного рефакторинга или генерации целых проектов лучше 27B. Но для подсказок и автодополнения в редакторе — 4B более чем достаточно.

Что делать с этой информацией?

Не верьте слепо графикам и статьям (даже этой). Скачайте Ollama, запустите qwen3.5:4b и qwen3.5:27b. Задайте им свои вопросы. Почувствуйте разницу в скорости и качестве на своих задачах. Только так вы поймете, какая модель вам подходит.

И последний совет: если вы только начинаете погружение в локальные LLM, начните с 4B модели. Она быстро отвечает, не грузит систему, и вы сразу поймете, что вообще можно делать с этими технологиями. А там, глядишь, и до 27B дорастете.

Для тех, кто хочет копнуть глубже в сравнение моделей разных семейств, у меня есть обзор топ-5 маленьких LLM, где Qwen3.5:4B тоже фигурирует.

Подписаться на канал