Gemma 4 31B 로컬에서 실행하는 방법: Unsloth, Ollama, llama.cpp, HuggingFace

Google DeepMind가 2026년 초에 Gemma 4를 공개했고, 그중 31B instruction-tuned 변형이 딱 좋은 밸런스를 보여줍니다. 프라이빗 모델들과 추론 벤치마크에서 겨룰 만큼 크고, 그래도 괜찮은 소비자용 GPU에서 돌아갈 만큼 작습니다. MMLU Pro에서 85.2%, AIME 2026에서 89.2%를 기록했고, 크기가 두 배인 모델들과 비슷한 성능입니다.

문제는 항상 "그래서 이걸 어떻게 돌리지?"였죠. 30.7B 파라미터 모델을 풀 정밀도로 돌리려면 VRAM이 약 62GB 필요합니다. 그런 거 한 장에 가진 사람은 없죠. 하지만 적절한 양자화와 도구만 있으면 24GB RTX 4090에서 돌릴 수 있고, 16GB 카드에서는 CPU로 일부 오프로드하는 것도 가능합니다. GPU 인스턴스를 부담 없이 쓰고 싶다면 LightNode를 VPS 제공자로 추천합니다.

이 가이드에서는 4가지 방법을 다루며, 대부분의 사람에게 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는 4가지 크기로 나옵니다. 크기마다 하드웨어 요구량 차이가 크니 잘 고르는 게 중요합니다.

변형	총 파라미터	활성 파라미터	컨텍스트	모달리티	용도
E2B	5.1B	2.3B 유효	128K	텍스트, 이미지, 오디오	스마트폰, 라즈베리파이
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 파라미터지만 Mixture-of-Experts 아키텍처 덕분에 추론 시 3.8B만 활성화됩니다 (128개 중 8개 전문가 활성 + 1개 공유). 4B 모델만큼 빠르면서 31B에 가까운 품질을 냅니다. GPU가 12-16GB VRAM이라면 Q4 양자화의 26B A4B가 아마 최선일 겁니다.

31B Dense는 이 가이드의 초점입니다. 모든 파라미터가 매 forward pass마다 활성화되는 풀 모델이죠. 최고 품질, 최고 하드웨어 요구량.

네 변형 모두 설정 가능한 사고 모드(chain-of-thought 추론), 네이티브 시스템 프롬프트, 함수 호출, 140개 이상의 언어를 지원합니다.

하드웨어 요구사항

방법을 고르기 전에 가진 하드웨어부터 확인하세요.

Gemma 4 31B-it 기준

양자화	필요 VRAM	품질 손실	대표 하드웨어
FP16 (풀 정밀도)	~62 GB	없음	A100, 멀티 GPU
Q8_0 (8-bit)	~32 GB	무시 가능	RTX 4090 (24GB) + CPU 오프로드
Q5_K_M (5-bit)	~22 GB	최소	RTX 4090, RTX 3090
Q4_K_M (4-bit)	~18 GB	약간	RTX 4080, RTX 3090
Q3_K_M (3-bit)	~14 GB	체감됨	RTX 4070, 부분 오프로드

Gemma 4 26B A4B (MoE) 기준

양자화	필요 VRAM	품질 손실	대표 하드웨어
Q5_K_M	~14 GB	최소	RTX 4070 Ti
Q4_K_M	~10 GB	약간	RTX 4070, RTX 3080
Q3_K_M	~8 GB	체감됨	RTX 4060 Ti 8GB

CPU만 있는 경우 E4B나 E2B 변형이 무난하게 돕니다. 31B를 CPU로 돌리는 건 기술적으로 가능하지만 엄청 느립니다 (최신 CPU 기준 1-3 tokens/초).

RAM 요구량: VRAM 외에 런타임 오버헤드용으로 시스템 RAM 8-16GB를 추가로 확보하세요. CPU로 레이어를 오프로드하면 더 필요합니다.

방법 1: Unsloth Studio (추천)

Unsloth가 Gemma 4를 로컬에서 돌리는 가장 쉬운 방법입니다. 모델 다운로드, 양자화 선택, 추론까지 하나의 웹 UI에서 처리합니다. 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 파일을 호스팅합니다. 24GB GPU면 Q4_K_M이나 Q5_K_M을 선택하세요. 16GB라면 Q3_K_M으로
3. 다운로드: 다운로드 버튼 클릭. Q4_K_M 변형은 약 18GB
4. 채팅 시작: 다운로드가 끝나면 모델이 자동으로 채팅 인터페이스에 로드됩니다

Unsloth에서 제공하는 Gemma 4 31B-it GGUF 변형:

파일	크기	양자화
gemma-4-31B-it-Q3_K_M.gguf	~14 GB	3-bit (균형)
gemma-4-31B-it-Q4_K_M.gguf	~18 GB	4-bit (추천)
gemma-4-31B-it-Q5_K_M.gguf	~22 GB	5-bit (고품질)
gemma-4-31B-it-Q6_K.gguf	~26 GB	6-bit (거의 무손실)
gemma-4-31B-it-Q8_0.gguf	~32 GB	8-bit (사실상 무손실)

HuggingFace 저장소는 unsloth/gemma-4-31B-it-GGUF에 있습니다.

채팅 인터페이스 사용법

Unsloth Studio 채팅에서 지원하는 기능:

• 텍스트 대화와 사고 모드 토글
• 이미지 업로드: 드래그 앤 드롭으로 이미지 질문
• PDF/DOCX 업로드: 문서 내용 추출 및 토론
• 코드 실행: 모델이 샌드박스에서 코드를 작성하고 테스트
• 커스텀 시스템 프롬프트: 동작과 페르소나 설정

Gemma 4의 사고 모드를 켜려면 채팅 설정에서 "Thinking" 옵션을 켜세요. chain-of-thought 추론이 활성화되어 모델이 최종 답변 전에 단계별로 문제를 풉니다.

Unsloth로 파인튜닝하기

추론을 넘어 학습도 하고 싶다면 Unsloth가 지원합니다:

• LoRA 파인튜닝: VRAM을 최대 70% 적게 쓰면서 어댑터 학습
• GRPO 강화학습: 사용 가능한 가장 효율적인 RL 라이브러리
• Data Recipes: PDF, CSV, DOCX에서 자동으로 학습 데이터셋 생성
• 멀티 GPU 지원: 현재 사용 가능, 개선 예정

Gemma 4 31B 파인튜닝을 하려면 최소 24GB GPU 1장과 QLoRA(4-bit 양자화 학습)가 필요합니다.

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

# VRAM이 부족하면 더 작은 MoE 변형
ollama run gemma4:26b-a4b-it

# 더 작은 dense 모델
ollama run gemma4:e4b-it
ollama run gemma4:e2b-it

Ollama는 기본적으로 Q4_K_M으로 양자화합니다. 다른 양자화를 원하면:

# 특정 양자화로 실행
ollama run gemma4:31b-it-q5_K_M

API 사용

Ollama는 11434 포트에서 로컬 API를 노출합니다:

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 모델 다운로드

Unsloth의 HuggingFace 저장소에서 양자화된 모델을 받으세요:

# huggingface-cli 설치
pip install huggingface-hub

# Q4_K_M 다운로드 (24GB 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은 약 2/3를 오프로드)
• -c 8192: 컨텍스트 길이(토큰). 긴 문서면 256K까지 늘리되, 컨텍스트가 길수록 VRAM을 더 씁니다
• --temp 1.0: Google이 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에서 웹 UI에 접속하거나 OpenAI 호환 API를 호출하세요:

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와 CPU 사이에 레이어를 분배하세요:

# 16GB GPU에서 Q4 모델 (~18GB)을 돌릴 때
# 약 40개 레이어를 GPU에, 나머지는 CPU에
./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 40 \
  -c 4096

GPU 풀 오프로드보다는 느리지만 작은 카드에도 돌아갑니다. CPU 성능과 오프로드 레이어 수에 따라 대략 5-15 tokens/초를 기대하세요.

방법 4: HuggingFace Transformers

애플리케이션을 만들고 프로그래밍 제어가 필요하다면 HuggingFace Transformers가 모델에 직접 접근할 수 있는 경로를 제공합니다. 풀 정밀도나 커스텀 양자화를 선택할 수 있습니다.

설치

pip install -U transformers torch accelerate

이미지 지원을 위해서는:

pip install -U transformers torch torchvision accelerate

풀 정밀도로 실행 (62GB+ 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-bit 양자화로 실행 (18GB VRAM)

from transformers import AutoProcessor, AutoModelForCausalLM, BitsAndBytesConfig

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

# 4-bit 양자화 설정
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는 chain-of-thought 추론을 지원합니다. 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 GB	최고 품질, 32GB+ VRAM 필요
Q6_K	6-bit	~26 GB	거의 무손실, 24GB+ VRAM
Q5_K_M	5-bit	~22 GB	품질/크기 최적 밸런스
Q4_K_M	4-bit	~18 GB	최적 균형, 24GB GPU에 딱 맞음
Q3_K_M	3-bit	~14 GB	작은 GPU, 약간의 품질 손실
Q2_K	2-bit	~10 GB	최후의 수단, 눈에 띄는 품질 저하

추천: 24GB GPU는 Q4_K_M, 4GB 여유가 있다면 Q5_K_M. Q4_K_M과 Q5_K_M의 품질 차이는 벤치마크에서는 측정되지만 일상 사용에서는 느끼기 어렵습니다. Q3_K_M 이하는 다른 선택지가 없을 때만 고려하세요.

_K_M 접미사는 "K-quantization, medium"을 뜻합니다. _K_S(small, 더 많은 압축)와 _K_L(large, 더 적은 압축) 변형도 있습니다. 기본 추천은 _K_M입니다.

성능 팁

컨텍스트 길이 관리

Gemma 4 31B는 최대 256K 토큰의 컨텍스트를 지원하지만, 컨텍스트의 토큰마다 VRAM을 소모합니다. 실전 가이드라인:

• 4K 토큰: 모델이 돌아가는 GPU면 어디나 편안
• 8K 토큰: 대부분의 대화에서 표준, 여전히 편안
• 32K 토큰: 양자화에 따라 약 4-6GB VRAM 추가 필요
• 128K+ 토큰: 상당한 VRAM 또는 적극적인 오프로드 필요

-c 8192로 시작해서 필요할 때만 늘리세요.

샘플링 파라미터

Google이 Gemma 4에 추천하는 설정:

temperature = 1.0
top_p = 0.95
top_k = 64

대부분의 모델이 쓰는 값과 다릅니다. Gemma 4에 temperature=0.7을 쓰지 마세요. 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가 여러 개라면 Transformers에서 device_map="auto"가 자동으로 분배합니다. 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

문제 해결

Out of Memory (CUDA OOM)

가장 흔한 문제입니다. 절망의 순서대로 해결책:

1. 더 작은 양자화 사용: Q5에서 Q4로, Q4에서 Q3으로
2. 컨텍스트 길이 줄이기: -c를 8192에서 4096이나 2048으로
3. CPU로 오프로드: -ngl을 줄여서 일부 레이어를 CPU에
4. 26B A4B MoE 변형 사용: 같은 품질, VRAM의 일부만 필요
5. E4B 변형 사용: 어디서든 돌아감

CPU에서 느린 추론

CPU로 돌린다면 31B 모델에서 1-3 tokens/초를 기대하세요. 대안:

• E4B나 E2B 모델로 전환 (CPU에서 10-20 tok/s)
• GPU 클라우드 인스턴스 사용 (LightNode에서 GPU VPS 옵션 제공)
• CPU의 명령어 세트(AVX2, AVX-512)를 활성화해서 llama.cpp 빌드

모델 다운로드 실패

Q4_K_M 파일이 약 18GB입니다. 다운로드가 계속 실패하면:

# 이어올리기를 지원하는 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

또는 이어올리기를 지원하는 다운로드 매니저를 사용하세요. HuggingFace CDN은 큰 파일에서 불안정할 수 있습니다.

"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-16GB)	Unsloth 또는 Ollama에서 Q3/Q4
VRAM이 24GB+	어떤 방법이든, Q4_K_M이나 Q5_K_M 사용
이미지 이해가 필요함	Unsloth Studio 또는 HuggingFace Transformers
파인튜닝을 하고 싶음	Unsloth (LoRA/GRPO 학습 내장)

처음 시작하는 대부분의 사람에게 Unsloth Studio가 가장 저항이 적은 경로입니다. 설치하고, Gemma 4를 검색하고, GPU에 맞는 양자화를 고르고, 채팅을 시작하세요. 설치부터 첫 대화까지 약 15분이면 됩니다.

터미널에 익숙하고 그냥 모델을 돌리고 싶다면 Ollama로 두 명령어면 끝입니다. 프로그래밍 접근이 필요하거나 모델 위에 뭔가를 만들고 있다면 4-bit 양자화의 HuggingFace Transformers가 완전한 Python API를 제공합니다.

마무리

Gemma 4 31B를 로컬에서 돌리는 게 놀라울 정도로 실용적이 됐습니다. 1년 전에 이 품질 수준의 30B 모델은 연구 프로젝트였습니다. 지금은 Unsloth나 Ollama로 15분 안에 설정이 끝나고, 오늘 살 수 있는 소비자용 하드웨어에서 돌아갑니다.

모델 자체도 추론, 코딩, 멀티모달 작업에서 프라이빗 대안과 겨룹니다. 256K 컨텍스트, 내장 사고 모드, 이미지 이해, 함수 호출 덕분에 실험이 아니라 실제 작업에 쓸 만합니다.

원격 GPU에서 모델을 호스팅하려면 LightNode에서 시간 단위로 과금하는 GPU VPS 인스턴스를 제공합니다. 필요할 때 켜고 안 쓸 때 끄면 됩니다.

HuggingFace의 Gemma 4 모델 카드에 전체 기술 세부사항이 있고, Unsloth GGUF 저장소에서 모든 양자화 변형을 다운로드할 수 있습니다.