Как запустить Gemma 4 31B локально: Unsloth, Ollama, llama.cpp и HuggingFace

Google DeepMind выпустила Gemma 4 в начале 2026 года, и 31-миллиардная версия с инструктивной настройкой попала в самую точку: достаточно большая, чтобы конкурировать с проприетарными моделями в бенчмарках на рассуждения, и достаточно маленькая, чтобы работать на приличной потребительской видеокарте. Она набирает 85,2% на MMLU Pro и 89,2% на AIME 2026 без инструментов — это ставит её в один ряд с моделями вдвое большего размера.

Главный вопрос всегда был: "Как мне это вообще запустить?" Модель на 30,7B параметров в полной точности требует около 62 ГБ VRAM. Ни у кого нет этого на одной видеокарте. Но с правильной квантизацией и правильными инструментами можно запустить её на 24-гигабайтной RTX 4090 или даже частично выгрузить на процессор при наличии 16-гигабайтной карты. Мы рекомендуем LightNode в качестве VPS-провайдера, если вам нужны GPU-инстансы без долгосрочных обязательств.

Это руководство описывает четыре метода, при этом Unsloth — основная рекомендация для большинства пользователей.

Содержание

1. Обзор семейства моделей Gemma 4
2. Требования к оборудованию
3. Метод 1: Unsloth Studio (Рекомендуется)
4. Метод 2: Ollama
5. Метод 3: llama.cpp
6. Метод 4: HuggingFace Transformers
7. Понимание форматов квантизации GGUF
8. Советы по производительности
9. Устранение неполадок
10. Какой метод выбрать?

Обзор семейства моделей Gemma 4

Gemma 4 выпускается в четырёх размерах. Выбор правильного варианта важен, потому что скачок требований к оборудованию между ними серьёзный.

Вариант	Всего параметров	Активных параметров	Контекст	Модальности	Лучше всего для
E2B	5,1B	2,3B эффективно	128K	Текст, Изображение, Аудио	Телефоны, Raspberry Pi
E4B	8B	4,5B эффективно	128K	Текст, Изображение, Аудио	Ноутбуки, только CPU
26B A4B (MoE)	25,2B	3,8B активно	256K	Текст, Изображение	Быстрый вывод, меньше VRAM
31B (Dense)	30,7B	30,7B	256K	Текст, Изображение	Максимальное качество

26B A4B — самая хитрая: 25,2B всего параметров, но только 3,8B активны во время вывода благодаря архитектуре Mixture-of-Experts (8 активных экспертов из 128 плюс 1 общий). Она работает почти так же быстро, как модель на 4B, а выдаёт качество близкое к полной 31B. Если у вашей GPU 12-16 ГБ VRAM, 26B A4B с Q4-квантизацией, вероятно, лучший выбор.

31B Dense — та, на которой сфокусировано это руководство. Это полная модель со всеми параметрами, активными при каждом прямом проходе. Лучшее качество, самые высокие требования к оборудованию.

Все четыре варианта поддерживают настраиваемый режим размышлений (chain-of-thought reasoning), нативные системные промпты, вызов функций и более 140 языков.

Требования к оборудованию

Прежде чем выбирать метод, разберитесь, какое у вас оборудование.

Для Gemma 4 31B-it

Квантизация	Нужно VRAM	Потеря качества	Типичное оборудование
FP16 (полная точность)	~62 ГБ	Нет	A100, несколько GPU
Q8_0 (8-bit)	~32 ГБ	Незначительная	RTX 4090 (24 ГБ) + выгрузка на CPU
Q5_K_M (5-bit)	~22 ГБ	Минимальная	RTX 4090, RTX 3090
Q4_K_M (4-bit)	~18 ГБ	Небольшая	RTX 4080, RTX 3090
Q3_K_M (3-bit)	~14 ГБ	Заметная	RTX 4070, частичная выгрузка

Для Gemma 4 26B A4B (MoE)

Квантизация	Нужно VRAM	Потеря качества	Типичное оборудование
Q5_K_M	~14 ГБ	Минимальная	RTX 4070 Ti
Q4_K_M	~10 ГБ	Небольшая	RTX 4070, RTX 3080
Q3_K_M	~8 ГБ	Заметная	RTX 4060 Ti 8 ГБ

Если у вас только процессор, варианты E4B или E2B будут работать без проблем. 31B на процессоре технически возможна, но мучительно медленная (ожидайте 1-3 токена в секунду на современном CPU).

Требование к RAM: Добавьте 8-16 ГБ системной RAM поверх VRAM для накладных расходов среды выполнения, больше, если выгружаете слои на процессор.

Метод 1: Unsloth Studio (Рекомендуется)

Unsloth — самый простой способ запустить Gemma 4 локально. Это веб-интерфейс, который берёт на себя загрузку модели, выбор квантизации и вывод в одном пакете. Работает на Windows, Linux, macOS и WSL.

Почему Unsloth

• Поиск и загрузка моделей с HuggingFace в один клик
• Автоматически подбирает правильную GGUF-квантизацию для вашего оборудования
• Встроенный чат-интерфейс с поддержкой изображений, PDF и документов
• Встроенные вызов инструментов и веб-поиск
• Песочница для выполнения кода
• Никаких танцев с командной строкой

Установка

macOS, Linux, WSL:

curl -fsSL https://unsloth.ai/install.sh | sh

Windows (PowerShell):

irm https://unsloth.ai/install.ps1 | iex

Docker:

docker run -d -e JUPYTER_PASSWORD="mypassword" \
  -p 8888:8888 -p 8000:8000 -p 2222:22 \
  -v $(pwd)/work:/workspace/work \
  --gpus all \
  unsloth/unsloth

Запуск

unsloth studio -H 0.0.0.0 -p 8888

Откройте http://localhost:8888 в браузере. Вы увидите интерфейс Unsloth Studio.

Запуск Gemma 4 31B

1. Найдите модель: В строке поиска введите gemma-4-31B
2. Выберите квантизацию: Unsloth размещает предварительно квантизированные GGUF-файлы. Для 24-гигабайтной GPU выберите Q4_K_M или Q5_K_M. Для 16 ГБ берите Q3_K_M
3. Скачайте: Нажмите "Скачать". Вариант Q4_K_M весит около 18 ГБ
4. Начните общение: После загрузки модель автоматически откроется в чат-интерфейсе

Unsloth предоставляет следующие GGUF-варианты для Gemma 4 31B-it:

Файл	Размер	Квантизация
gemma-4-31B-it-Q3_K_M.gguf	~14 ГБ	3-bit (сбалансированная)
gemma-4-31B-it-Q4_K_M.gguf	~18 ГБ	4-bit (рекомендуется)
gemma-4-31B-it-Q5_K_M.gguf	~22 ГБ	5-bit (высокое качество)
gemma-4-31B-it-Q6_K.gguf	~26 ГБ	6-bit (почти без потерь)
gemma-4-31B-it-Q8_0.gguf	~32 ГБ	8-bit (практически без потерь)

Репозиторий на HuggingFace: unsloth/gemma-4-31B-it-GGUF.

Использование чат-интерфейса

Чат Unsloth Studio поддерживает:

• Текстовые разговоры с переключателем режима размышлений
• Загрузка изображений: Перетащите изображения для визуального ответа на вопросы
• Загрузка PDF/DOCX: Извлечение и обсуждение содержимого документов
• Выполнение кода: Модель может писать и тестировать код в песочнице
• Пользовательские системные промпты: Настройка поведения и персоны

Чтобы включить режим размышлений Gemma 4, переключите опцию "Thinking" в настройках чата. Это активирует цепочку рассуждений, где модель проходит через задачу шаг за шагом, прежде чем дать окончательный ответ.

Файн-тюнинг с Unsloth

Если хочется выйти за рамки простого вывода, Unsloth также умеет обучать:

• LoRA файн-тюнинг: Обучайте адаптеры с экономией VRAM до 70%
• GRPO обучение с подкреплением: Самая эффективная библиотека RL
• Data Recipes: Автоматическое создание обучающих датасетов из PDF, CSV, DOCX-файлов
• Поддержка нескольких GPU: Доступна сейчас, улучшения в пути

Для файн-тюнинга Gemma 4 31B вам понадобится как минимум одна 24-гигабайтная GPU с QLoRA (обучение с 4-битной квантизацией).

Обновление Unsloth

Просто выполните ту же команду установки ещё раз:

# macOS/Linux/WSL
curl -fsSL https://unsloth.ai/install.sh | sh

# Windows
irm https://unsloth.ai/install.ps1 | iex

Метод 2: Ollama

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

Установка

# macOS
brew install ollama

# Linux
curl -fsSL https://ollama.com/install.sh | sh

# Windows
# Скачайте с https://ollama.com/download

Запуск Gemma 4

# Загрузить и запустить 31B-модель
ollama run gemma4:31b-it

# Или меньший MoE-вариант для экономии VRAM
ollama run gemma4:26b-a4b-it

# Или меньшие плотные модели
ollama run gemma4:e4b-it
ollama run gemma4:e2b-it

Ollama по умолчанию квантизирует до Q4_K_M. Если нужна другая квантизация:

# Запустить с конкретной квантизацией
ollama run gemma4:31b-it-q5_K_M

Использование API

Ollama предоставляет локальный API на порту 11434:

import requests

response = requests.post('http://localhost:11434/api/chat', json={
    "model": "gemma4:31b-it",
    "messages": [
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a Python function to merge two sorted lists."}
    ],
    "stream": False
})

print(response.json()['message']['content'])

Плюсы и минусы Ollama

Плюсы: Никакой настройки, автоматическое определение GPU, аккуратный CLI, API-сервер в комплекте, простое управление моделями.

Минусы: Меньше вариантов квантизации, чем у llama.cpp, нет встроенной поддержки изображений для всех моделей (проверяйте текущую совместимость), меньше контроля над параметрами вывода.

Метод 3: llama.cpp

Для максимального контроля над квантизацией, использованием памяти и параметрами вывода — llama.cpp. Это то, что под капотом работает у Ollama и Unsloth для GGUF-вывода.

Сборка из исходников

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# С поддержкой CUDA (NVIDIA)
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)

# С поддержкой Metal (macOS Apple Silicon)
cmake -B build -DGGML_METAL=ON
cmake --build build --config Release -j$(nproc)

# Только CPU
cmake -B build
cmake --build build --config Release -j$(nproc)

Загрузка GGUF-модели

Скачайте квантизированную модель из HuggingFace-репозитория Unsloth:

# Установить huggingface-cli
pip install huggingface-hub

# Скачать Q4_K_M (рекомендуется для 24-гигабайтных GPU)
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q4_K_M.gguf \
  --local-dir ./models

# Или Q5_K_M для лучшего качества
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q5_K_M.gguf \
  --local-dir ./models

Запуск модели

# Простой чат
./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -c 8192 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64 \
  -p "You are a helpful assistant.\nUser: Explain quantum computing in simple terms.\nAssistant:"

Ключевые флаги:

• -ngl 99: Выгрузить все слои на GPU. Уменьшите это число, если VRAM не хватает (например, -ngl 40 выгружает около двух третей слоёв)
• -c 8192: Длина контекста в токенах. Увеличьте до 256K для длинных документов, но больше контекста требует больше VRAM
• --temp 1.0: Google рекомендует temperature=1.0 для Gemma 4
• --top-p 0.95 и --top-k 64: Рекомендуемые параметры сэмплирования

Запуск сервера

./build/bin/llama-server \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -c 8192 \
  --host 0.0.0.0 \
  --port 8080 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64

Затем откройте веб-интерфейс на http://localhost:8080 или вызовите API, совместимый с OpenAI:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8080/v1", api_key="unused")

response = client.chat.completions.create(
    model="gemma-4-31b",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Write a Rust function to reverse a linked list."}
    ]
)

print(response.choices[0].message.content)

Стратегия выгрузки на GPU

Если у вашей GPU не хватает VRAM для полной модели, можно разделить слои между GPU и процессором:

# Для 16-гигабайтной GPU с Q4-моделью (~18 ГБ всего)
# Выгрузить около 40 слоёв на GPU, остальные на процессор
./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 40 \
  -c 4096

Это работает медленнее, чем полная выгрузка на GPU, но влезает в меньшие карты. Ожидайте примерно 5-15 токенов в секунду в зависимости от процессора и количества выгруженных слоёв.

Метод 4: HuggingFace Transformers

Если вы создаёте приложение и вам нужен программный контроль, HuggingFace Transformers даёт прямой доступ к модели с полной точностью или пользовательской квантизацией.

Установка

pip install -U transformers torch accelerate

Для поддержки изображений:

pip install -U transformers torch torchvision accelerate

Запуск в полной точности (62+ ГБ VRAM)

from transformers import AutoProcessor, AutoModelForCausalLM

MODEL_ID = "google/gemma-4-31B-it"

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Explain the difference between TCP and UDP."},
]

text = processor.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=False
)

inputs = processor(text=text, return_tensors="pt").to(model.device)
input_len = inputs["input_ids"].shape[-1]

outputs = model.generate(**inputs, max_new_tokens=1024)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
result = processor.parse_response(response)
print(result)

Запуск с 4-битной квантизацией (18 ГБ VRAM)

from transformers import AutoProcessor, AutoModelForCausalLM, BitsAndBytesConfig

MODEL_ID = "google/gemma-4-31B-it"

# Конфигурация 4-битной квантизации
quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16
)

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    quantization_config=quantization_config,
    device_map="auto"
)

Обработка изображений

Модель 31B поддерживает текстовый и графический ввод:

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "google/gemma-4-31B-it"

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForMultimodalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://example.com/photo.jpg"},
            {"type": "text", "text": "Describe what you see in this image."}
        ]
    }
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
).to(model.device)

input_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs, max_new_tokens=512)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
result = processor.parse_response(response)
print(result)

Включение режима размышлений

Gemma 4 поддерживает цепочку рассуждений. Включите с помощью enable_thinking=True:

text = processor.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=True  # Активирует режим рассуждений
)

Когда режим размышлений включён, модель выдаёт свои внутренние рассуждения, а затем окончательный ответ. Используйте processor.parse_response(response), чтобы отделить размышления от ответа.

Понимание форматов квантизации GGUF

При загрузке GGUF-файлов вы увидите много суффиксов. Вот что они означают на практике.

Формат	Биты	Размер (31B)	Когда использовать
Q8_0	8-bit	~32 ГБ	Лучшее качество, нужно 32+ ГБ VRAM
Q6_K	6-bit	~26 ГБ	Почти без потерь, 24+ ГБ VRAM
Q5_K_M	5-bit	~22 ГБ	Золотая середина качества/размера
Q4_K_M	4-bit	~18 ГБ	Лучший баланс, влезает в 24 ГБ GPU
Q3_K_M	3-bit	~14 ГБ	Меньшая GPU, некоторая потеря качества
Q2_K	2-bit	~10 ГБ	Крайняя мера, заметная деградация

Моя рекомендация: Q4_K_M для 24-гигабайтных GPU, Q5_K_M, если лишние 4 ГБ не жалко. Разница в качестве между Q4_K_M и Q5_K_M измерима в бенчмарках, но незаметна при обычном использовании. Опускаться ниже Q3_K_M стоит только если других вариантов нет.

Суффикс _K_M означает "K-квантизация, средняя." Есть также варианты _K_S (малая, больше сжатие) и _K_L (большая, меньше сжатие). _K_M — рекомендация по умолчанию.

Советы по производительности

Управление длиной контекста

Gemma 4 31B поддерживает до 256K токенов контекста, но каждый токен в контексте потребляет VRAM. Несколько практических ориентиров:

• 4K токенов: Комфортно на любой GPU, вмещающей модель
• 8K токенов: Стандарт для большинства разговоров, по-прежнему комфортно
• 32K токенов: Требует около 4-6 ГБ дополнительной VRAM в зависимости от квантизации
• 128K+ токенов: Требует значительной VRAM или агрессивной выгрузки

Начните с -c 8192 и увеличивайте только при необходимости.

Параметры сэмплирования

Google рекомендует следующие настройки для Gemma 4:

temperature = 1.0
top_p = 0.95
top_k = 64

Они отличаются от того, что используют большинство моделей. Не ставьте temperature=0.7 с Gemma 4; она обучена на temperature=1.0 и даёт лучшие результаты при этой настройке.

Flash Attention

Если используете HuggingFace Transformers, включите Flash Attention для более быстрого вывода и меньшего потребления памяти:

model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    attn_implementation="flash_attention_2",
    device_map="auto"
)

Требуется pip install flash-attn и совместимая GPU (большинство карт NVIDIA RTX подходят).

Мульти-GPU конфигурация

Если у вас несколько GPU, device_map="auto" в Transformers автоматически распределяет модель. Для llama.cpp:

./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -ts 1,1 \  # Разделить поровну между 2 GPU
  -c 8192

Устранение неполадок

Не хватает памяти (CUDA OOM)

Самая частая проблема. Решения в порядке нарастания отчаяния:

1. Используйте меньшую квантизацию: Переключитесь с Q5 на Q4 или с Q4 на Q3
2. Уменьшите длину контекста: Снизьте -c с 8192 до 4096 или 2048
3. Выгрузите на процессор: Уменьшите -ngl, чтобы выгрузить часть слоёв
4. Используйте вариант 26B A4B MoE: Тот же уровень качества, часть VRAM
5. Используйте вариант E4B: Работает на чём угодно

Медленный вывод на процессоре

При работе на CPU ожидайте 1-3 токена в секунду для модели 31B. Варианты:

• Переключитесь на модель E4B или E2B (10-20 tok/s на CPU)
• Используйте облачный GPU-инстанс (LightNode предлагает GPU-VPS)
• Соберите llama.cpp с включёнными наборами инструкций процессора (AVX2, AVX-512)

Ошибки загрузки модели

Файл Q4_K_M весит около 18 ГБ. Если загрузка постоянно обрывается:

# Используйте huggingface-cli с поддержкой докачки
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q4_K_M.gguf \
  --local-dir ./models \
  --local-dir-use-symlinks False

Или используйте менеджер загрузок с поддержкой докачки. CDN HuggingFace может барахлить на больших файлах.

Ошибки "Model not supported"

Убедитесь, что используете последние версии инструментов. Gemma 4 — новая модель, и старые версии llama.cpp, Ollama и Transformers её не поддерживают:

# Обновить llama.cpp
cd llama.cpp && git pull && cmake --build build --config Release -j$(nproc)

# Обновить Ollama
ollama pull gemma4:31b-it  # Автоматически обновится при необходимости

# Обновить Transformers
pip install -U transformers

Какой метод выбрать?

Сценарий	Лучший метод
Хотите GUI, не хотите трогать терминал	Unsloth Studio
Хотите быструю настройку, CLI устраивает	Ollama
Нужен максимальный контроль над выводом	llama.cpp
Создаёте приложение	HuggingFace Transformers
Ограниченная VRAM (8-16 ГБ)	Unsloth или Ollama с Q3/Q4
Есть 24+ ГБ VRAM	Любой метод, используйте Q4_K_M или Q5_K_M
Нужно понимание изображений	Unsloth Studio или HuggingFace Transformers
Хотите файн-тюнинг	Unsloth (LoRA/GRPO обучение встроено)

Для большинства новичков Unsloth Studio — путь наименьшего сопротивления. Установите, найдите Gemma 4, выберите квантизацию под вашу GPU и начинайте общаться. Весь процесс занимает около 15 минут от установки до первого разговора.

Если вам комфортно в терминале и нужно просто запустить модель, Ollama справится за две команды. А если нужен программный доступ или вы строите что-то поверх модели, HuggingFace Transformers с 4-битной квантизацией даст вам полный Python API.

Итоги

Запуск Gemma 4 31B локально стал на удивление практичным. Год назад модель на 30B с таким уровнем качества была бы исследовательским проектом. Теперь это 15-минутная настройка через Unsloth или Ollama, работающая на потребительском оборудовании, которое можно купить сегодня.

Сама модель на равных конкурирует с проприетарными альтернативами в рассуждениях, кодинге и мультимодальных задачах. 256K контекст, встроенный режим размышлений, понимание изображений и вызов функций делают её по-настоящему полезной для реальной работы, а не только для экспериментов.

Для размещения модели на удалённой GPU LightNode предлагает GPU-VPS инстансы с почасовой оплатой — можно запустить, когда нужно, и выключить, когда не нужно.

Карточка модели Gemma 4 на HuggingFace содержит полные технические детали, а репозиторий Unsloth GGUF — все квантизированные варианты, готовые к загрузке.