Bỏ qua nội dung chính

Cách Chạy Gemma 4 31B trên Máy cục bộ: Unsloth, Ollama, llama.cpp và HuggingFace

BlogsGemma 4Google DeepMindLocal AIUnslothGGUFLlama.cppKhoảng 15 phút

Cách Chạy Gemma 4 31B trên Máy cục bộ: Unsloth, Ollama, llama.cpp và HuggingFace

Google DeepMind phát hành Gemma 4 vào đầu năm 2026, và phiên bản instruction-tuned 31B nằm đúng điểm ngọt: đủ lớn để cạnh tranh với các model độc quyền trên benchmark reasoning, đủ nhỏ để chạy trên một GPU tiêu dùng khá tốt. Nó đạt 85.2% trên MMLU Pro và 89.2% trên AIME 2026 không dùng tools, đặt nó vào cùng hàng với các model lớn gấp đôi.

Vấn đề luôn là "làm sao mình chạy cái này?" Model 30.7B tham số ở full precision cần khoảng 62GB VRAM. Chẳng ai có nhiều vậy trên một card đồ họa duy nhất. Nhưng với lượng tử hóa đúng và công cụ phù hợp, bạn có thể chạy nó trên RTX 4090 24GB, hoặc thậm chí offload một phần sang CPU trên card 16GB. Chúng tôi khuyên dùng LightNode làm nhà cung cấp VPS nếu bạn muốn instance GPU không cần cam kết.

Hướng dẫn này bao gồm bốn phương pháp, với Unsloth là khuyên dùng chính cho đa số người dùng.

Mục lục

  1. Tổng quan Về Họ Model Gemma 4
  2. Yêu Cầu Phần Cứng
  3. Phương pháp 1: Unsloth Studio (Khuyên dùng)
  4. Phương pháp 2: Ollama
  5. Phương pháp 3: llama.cpp
  6. Phương pháp 4: HuggingFace Transformers
  7. Hiểu Về Các Định Dạng Lượng Tử GGUF
  8. Mẹo Hiệu Năng
  9. Khắc Phục Sự Cố
  10. Bạn Nên Chọn Phương Pháp Nào?

Tổng quan Về Họ Model Gemma 4

Gemma 4 có bốn kích thước. Chọn đúng thì quan trọng vì bước nhảy phần cứng giữa chúng là khá lớn.

Biến thểTổng ParamParam Hoạt độngNgữ cảnhModalitetPhù hợp
E2B5.1B2.3B hiệu quả128KVăn bản, Hình ảnh, Âm thanhĐiện thoại, Raspberry Pi
E4B8B4.5B hiệu quả128KVăn bản, Hình ảnh, Âm thanhLaptop, chỉ CPU
26B A4B (MoE)25.2B3.8B hoạt động256KVăn bản, Hình ảnhInference nhanh, ít VRAM
31B (Dense)30.7B30.7B256KVăn bản, Hình ảnhChất lượng tối đa

Biến thể 26B A4B là cái thông minh: 25.2B tham số tổng cộng, nhưng chỉ 3.8B hoạt động trong lúc inference nhờ kiến trúc Mixture-of-Experts (8 expert hoạt động trong 128, cộng 1 shared). Nó chạy nhanh như model 4B trong khi chất lượng gần bằng 31B đầy đủ. Nếu GPU của bạn có 12-16GB VRAM, 26B A4B với lượng tử Q4 chắc chắn là lựa chọn tốt nhất.

31B Dense là điểm tập trung của hướng dẫn này. Đây là model đầy đủ với tất cả tham số hoạt động trên mỗi forward pass. Chất lượng tốt nhất, yêu cầu phần cứng cao nhất.

Cả bốn biến thể đều hỗ trợ chế độ suy nghĩ có thể cấu hình (reasoning chain-of-thought), system prompt gốc, function calling và hơn 140 ngôn ngữ.

Yêu Cầu Phần Cứng

Trước khi chọn phương pháp, hãy xem xét phần cứng bạn đang có.

Cho Gemma 4 31B-it

Lượng tửVRAM CầnMất Chất lượngPhần Cứng Tiêu biểu
FP16 (full precision)~62 GBKhôngA100, nhiều GPU
Q8_0 (8-bit)~32 GBRất ítRTX 4090 (24GB) + CPU offload
Q5_K_M (5-bit)~22 GBTối thiểuRTX 4090, RTX 3090
Q4_K_M (4-bit)~18 GBNhỏRTX 4080, RTX 3090
Q3_K_M (3-bit)~14 GBDễ nhận thấyRTX 4070, offload một phần

Cho Gemma 4 26B A4B (MoE)

Lượng tửVRAM CầnMất Chất lượngPhần Cứng Tiêu biểu
Q5_K_M~14 GBTối thiểuRTX 4070 Ti
Q4_K_M~10 GBNhỏRTX 4070, RTX 3080
Q3_K_M~8 GBDễ nhận thấyRTX 4060 Ti 8GB

Nếu bạn chỉ có CPU, các biến thể E4B hoặc E2B sẽ chạy thoải mái. 31B trên CPU về mặt kỹ thuật là có thể nhưng cực kỳ chậm (kỳ vọng 1-3 token/giây trên CPU hiện đại).

Yêu cầu RAM: Cộng thêm 8-16GB RAM hệ thống vượt ngoài VRAM cho overhead runtime, nhiều hơn nếu bạn đang offload layer sang CPU.

Phương pháp 1: Unsloth Studio (Khuyên dùng)

Unsloth là cách dễ nhất để chạy Gemma 4 trên máy cục bộ. Đây là giao diện web xử lý tải model, chọn lượng tử và inference trong một gói duy nhất. Hoạt động trên Windows, Linux, macOS và WSL.

Tại sao chọn Unsloth

  • Tìm kiếm và tải model từ HuggingFace trong một click
  • Tự động chọn lượng tử GGUF phù hợp với phần cứng của bạn
  • Giao diện chat tích hợp sẵn hỗ trợ hình ảnh, PDF và tài liệu
  • Tool calling và tìm kiếm web đã tích hợp sẵn
  • Sandbox thực thi code
  • Không cần đối phó với command line

Cài đặt

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

Khởi động

unsloth studio -H 0.0.0.0 -p 8888

Mở http://localhost:8888 trong trình duyệt. Bạn sẽ thấy giao diện Unsloth Studio.

Chạy Gemma 4 31B

  1. Tìm model: Trong thanh tìm kiếm model, gõ gemma-4-31B
  2. Chọn lượng tử: Unsloth lưu trữ các file GGUF đã được lượng tử sẵn. Cho GPU 24GB, chọn Q4_K_M hoặc Q5_K_M. Cho 16GB, dùng Q3_K_M
  3. Tải về: Nhấn tải về. Biến thể Q4_K_M có kích thước khoảng 18GB
  4. Bắt đầu chat: Sau khi tải xong, model tự động nạp vào giao diện chat

Unsloth cung cấp các biến thể GGUF sau cho Gemma 4 31B-it:

FileKích thướcLượng tử
gemma-4-31B-it-Q3_K_M.gguf~14 GB3-bit (cân bằng)
gemma-4-31B-it-Q4_K_M.gguf~18 GB4-bit (khuyên dùng)
gemma-4-31B-it-Q5_K_M.gguf~22 GB5-bit (chất lượng cao)
gemma-4-31B-it-Q6_K.gguf~26 GB6-bit (gần như không mất)
gemma-4-31B-it-Q8_0.gguf~32 GB8-bit (hầu như không mất)

Repo HuggingFace nằm tại unsloth/gemma-4-31B-it-GGUF.

Sử dụng Giao diện Chat

Chat của Unsloth Studio hỗ trợ:

  • Hội thoại văn bản với bật/tắt chế độ suy nghĩ
  • Tải hình ảnh lên: Kéo thả hình ảnh để hỏi đáp trực quan
  • Tải PDF/DOCX lên: Trích xuất và thảo luận nội dung tài liệu
  • Thực thi code: Model có thể viết và thử code trong sandbox
  • System prompt tùy chỉnh: Đặt hành vi và persona

Để bật chế độ suy nghĩ của Gemma 4, bật tùy chọn "Thinking" trong cài đặt chat. Điều này kích hoạt reasoning chain-of-thought, nơi model giải quyết vấn đề từng bước một trước khi đưa ra câu trả lời cuối cùng.

Fine-Tuning với Unsloth

Nếu bạn muốn vượt qua inference, Unsloth cũng xử lý luôn training:

  • Fine-tuning LoRA: Huấn luyện adapter với đến 70% VRAM ít hơn
  • GRPO reinforcement learning: Thư viện RL hiệu quả nhất hiện có
  • Data Recipes: Tự động tạo dataset training từ file PDF, CSV, DOCX
  • Hỗ trợ nhiều GPU: Sẵn có với các cải tiến sắp tới

Cho fine-tuning Gemma 4 31B, bạn cần ít nhất một GPU 24GB với QLoRA (training lượng tử 4-bit).

Cập nhật Unsloth

Chạy lại cùng lệnh cài đặt:

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

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

Phương pháp 2: Ollama

Ollama là cách nhanh nhất để bắt đầu nếu bạn thích command line. Nó tự động xử lý tải model, phát hiện GPU và serving.

Cài đặt

# macOS
brew install ollama

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

# Windows
# Tải từ https://ollama.com/download

Chạy Gemma 4

# Pull và chạy model 31B
ollama run gemma4:31b-it

# Hoặc biến thể MoE nhỏ hơn cho ít VRAM
ollama run gemma4:26b-a4b-it

# Hoặc các model dense nhỏ hơn
ollama run gemma4:e4b-it
ollama run gemma4:e2b-it

Ollama mặc định tự động lượng tử về Q4_K_M. Nếu bạn muốn lượng tử khác:

# Chạy với lượng tử cụ thể
ollama run gemma4:31b-it-q5_K_M

Sử dụng API

Ollama cung cấp API cục bộ trên port 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'])

Ưu và Nhược điểm của Ollama

Ưu điểm: Zero cấu hình, phát hiện GPU tự động, CLI sạch sẽ, API server tích hợp sẵn, quản lý model đơn giản.

Nhược điểm: Ít lựa chọn lượng tử hơn llama.cpp, không có hỗ trợ hình ảnh tích hợp sẵn cho tất cả model (kiểm tra tính tương thích hiện tại), ít kiểm soát hơn trên các tham số inference.

Phương pháp 3: llama.cpp

Để có kiểm soát tối đa về lượng tử, sử dụng bộ nhớ và tham số inference, llama.cpp là lựa chọn đúng. Đây là công nghệ nằm sau Ollama và Unsloth cho inference GGUF.

Build từ Source

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

# Với hỗ trợ CUDA (NVIDIA)
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)

# Với hỗ trợ Metal (macOS Apple Silicon)
cmake -B build -DGGML_METAL=ON
cmake --build build --config Release -j$(nproc)

# Chỉ CPU
cmake -B build
cmake --build build --config Release -j$(nproc)

Tải Model GGUF

Lấy model đã được lượng tử từ repo HuggingFace của Unsloth:

# Cài đặt huggingface-cli
pip install huggingface-hub

# Tải Q4_K_M (khuyên dùng cho GPU 24GB)
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q4_K_M.gguf \
  --local-dir ./models

# Hoặc Q5_K_M cho chất lượng tốt hơn
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q5_K_M.gguf \
  --local-dir ./models

Chạy Model

# Chat cơ bản
./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:"

Các flag quan trọng:

  • -ngl 99: Offload tất cả layer sang GPU. Giảm số này nếu bạn không đủ VRAM (ví dụ, -ngl 40 offload khoảng hai phần ba layer)
  • -c 8192: Độ dài ngữ cảnh tính bằng token. Tăng lên 256K cho tài liệu dài, nhưng nhiều ngữ cảnh hơn = nhiều VRAM hơn
  • --temp 1.0: Google khuyên dùng temperature=1.0 cho Gemma 4
  • --top-p 0.95 và --top-k 64: Các tham số sampling được khuyên dùng

Khởi động Server

./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

Sau đó truy cập web UI tại http://localhost:8080 hoặc gọi API tương thích 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)

Chiến lược GPU Offloading

Nếu GPU của bạn không đủ VRAM cho toàn bộ model, bạn có thể chia layer giữa GPU và CPU:

# Cho GPU 16GB với model Q4 (~18GB tổng cộng)
# Offload khoảng 40 layer sang GPU, phần còn lại sang CPU
./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 40 \
  -c 4096

Cách này chậm hơn full GPU offload nhưng vừa với card nhỏ hơn. Kỳ vọng khoảng 5-15 token/giây tùy thuộc vào CPU và số layer bạn offload.

Phương pháp 4: HuggingFace Transformers

Nếu bạn đang xây dựng ứng dụng và cần kiểm soát theo chương trình, HuggingFace Transformers cho bạn truy cập trực tiếp model với full precision hoặc lượng tử tùy chỉnh.

Cài đặt

pip install -U transformers torch accelerate

Cho hỗ trợ hình ảnh:

pip install -U transformers torch torchvision accelerate

Chạy ở Full Precision (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)

Chạy với Lượng tử 4-bit (18GB VRAM)

from transformers import AutoProcessor, AutoModelForCausalLM, BitsAndBytesConfig

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

# Cấu hình lượng tử 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"
)

Xử lý Hình ảnh

Model 31B hỗ trợ đầu vào văn bản và hình ảnh:

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)

Bật Chế độ Suy nghĩ

Gemma 4 hỗ trợ reasoning chain-of-thought. Bật nó bằng cách đặt enable_thinking=True:

text = processor.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=True  # Kích hoạt chế độ reasoning
)

Khi thinking được bật, model xuất ra reasoning nội bộ theo sau là câu trả lời cuối. Dùng processor.parse_response(response) để tách suy nghĩ khỏi câu trả lời.

Hiểu Về Các Định Dạng Lượng Tử GGUF

Nếu bạn tải file GGUF, bạn sẽ thấy nhiều hậu tố khác nhau. Đây là ý nghĩa thực tế của chúng.

Định dạngBitKích thước (31B)Khi nào Dùng
Q8_08-bit~32 GBChất lượng tốt nhất, cần VRAM 32GB+
Q6_K6-bit~26 GBGần như không mất, VRAM 24GB+
Q5_K_M5-bit~22 GBĐiểm ngọt cho chất lượng/kích thước
Q4_K_M4-bit~18 GBCân bằng tốt nhất, vừa GPU 24GB
Q3_K_M3-bit~14 GBGPU nhỏ hơn, mất chất lượng một chút
Q2_K2-bit~10 GBPhương án cuối cùng, suy giảm rõ rệt

Khuyên dùng của tôi: Q4_K_M cho GPU 24GB, Q5_K_M nếu bạn có thêm 4GB dư thừa. Chênh lệch chất lượng giữa Q4_K_M và Q5_K_M đo được trên benchmark nhưng khó nhận thấy trong sử dụng hàng ngày. Xuống dưới Q3_K_M không đáng trừ khi bạn thực sự không có lựa chọn nào khác.

Hậu tố _K_M có nghĩa là "K-quantization, medium." Còn có các biến thể _K_S (small, nén nhiều hơn) và _K_L (large, nén ít hơn). _K_M là khuyên dùng mặc định.

Mẹo Hiệu Năng

Quản lý Độ dài Ngữ cảnh

Gemma 4 31B hỗ trợ đến 256K token ngữ cảnh, nhưng mỗi token trong ngữ cảnh tiêu tốn VRAM. Vài hướng dẫn thực tế:

  • 4K token: Thoải mái trên bất kỳ GPU nào vừa model
  • 8K token: Tiêu chuẩn cho đa số hội thoại, vẫn thoải mái
  • 32K token: Cần khoảng 4-6GB VRAM thêm tùy vào lượng tử
  • 128K+ token: Cần VRAM đáng kể hoặc offloading tích cực

Bắt đầu với -c 8192 và chỉ tăng khi bạn cần.

Tham số Sampling

Google khuyên dùng các cài đặt này cho Gemma 4:

temperature = 1.0
top_p = 0.95
top_k = 64

Cái này khác với phần lớn các model. Đừng dùng temperature=0.7 với Gemma 4; nó được train cho temperature=1.0 và sản xuất kết quả tốt hơn ở cài đặt đó.

Flash Attention

Nếu bạn dùng HuggingFace Transformers, bật Flash Attention để inference nhanh hơn và sử dụng bộ nhớ thấp hơn:

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

Điều này yêu cầu pip install flash-attn và GPU tương thích (đa số card NVIDIA RTX đều được).

Setup Nhiều GPU

Nếu bạn có nhiều GPU, device_map="auto" trong Transformers tự động xử lý việc chia. Cho llama.cpp:

./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -ts 1,1 \  # Chia đều giữa 2 GPU
  -c 8192

Khắc Phục Sự Cố

Hết Bộ nhớ (CUDA OOM)

Vấn đề phổ biến nhất. Các giải pháp theo thứ tự:

  1. Dùng lượng tử nhỏ hơn: Chuyển từ Q5 sang Q4, hoặc Q4 sang Q3
  2. Giảm độ dài ngữ cảnh: Hạ -c từ 8192 xuống 4096 hoặc 2048
  3. Offload sang CPU: Giảm -ngl để offload một số layer
  4. Dùng biến thể 26B A4B MoE: Cùng mức chất lượng, chỉ một phần nhỏ VRAM
  5. Dùng biến thể E4B: Chạy trên bất kỳ thứ gì

Inference Chậm trên CPU

Nếu bạn chạy trên CPU, kỳ vọng 1-3 token/giây cho model 31B. Các lựa chọn:

  • Chuyển sang model E4B hoặc E2B (10-20 token/giây trên CPU)
  • Dùng instance cloud GPU (LightNode có các lựa chọn VPS GPU)
  • Build llama.cpp với instruction set của CPU bật (AVX2, AVX-512)

Lỗi Tải Model

File Q4_K_M khoảng 18GB. Nếu tải liên tục thất bại:

# Dùng huggingface-cli với hỗ trợ resume
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

Hoặc dùng trình quản lý tải hỗ trợ resume. CDN HuggingFace có thể hay bị lỗi cho file lớn.

Lỗi "Model không được hỗ trợ"

Đảm bảo bạn đang dùng phiên bản mới nhất của các công cụ. Gemma 4 còn mới và các phiên bản cũ của llama.cpp, Ollama và Transformers chưa hỗ trợ:

# Cập nhật llama.cpp
cd llama.cpp && git pull && cmake --build build --config Release -j$(nproc)

# Cập nhật Ollama
ollama pull gemma4:31b-it  # Tự động cập nhật nếu cần

# Cập nhật Transformers
pip install -U transformers

Bạn Nên Chọn Phương Pháp Nào?

Tình huốngPhương pháp Tốt nhất
Bạn muốn GUI, không muốn đụng terminalUnsloth Studio
Bạn muốn setup nhanh nhất, CLI cũng đượcOllama
Bạn cần kiểm soát tối đa về inferencellama.cpp
Bạn đang xây dựng ứng dụngHuggingFace Transformers
Bạn có VRAM hạn chế (8-16GB)Unsloth hoặc Ollama với Q3/Q4
Bạn có VRAM 24GB+Bất kỳ phương pháp nào, dùng Q4_K_M hoặc Q5_K_M
Bạn cần hiểu hình ảnhUnsloth Studio hoặc HuggingFace Transformers
Bạn muốn fine-tuneUnsloth (training LoRA/GRPO tích hợp sẵn)

Cho đa số người mới bắt đầu, Unsloth Studio là đường đi ít chống đối nhất. Cài đặt, tìm Gemma 4, chọn lượng tử phù hợp với GPU, và bắt đầu chat. Cả quá trình mất khoảng 15 phút từ cài đặt đến hội thoại đầu tiên.

Nếu bạn thoải mái với terminal và chỉ muốn chạy model, Ollama đưa bạn đến đó trong hai lệnh. Và nếu bạn cần truy cập theo chương trình hoặc đang xây dựng gì đó trên model, HuggingFace Transformers với lượng tử 4-bit cho bạn đầy đủ Python API.

Tổng kết

Chạy Gemma 4 31B trên máy cục bộ đã trở nên cực kỳ thực tế. Một năm trước, một model 30B ở mức chất lượng này sẽ là một dự án nghiên cứu. Bây giờ nó là một quá trình cài đặt 15 phút với Unsloth hoặc Ollama, và chạy trên phần cứng tiêu dùng mà bạn có thể mua ngay hôm nay.

Bản thân model cũng cho thấy khả năng cạnh tranh với các lựa chọn độc quyền trong các nhiệm vụ reasoning, coding và multimodal. Ngữ cảnh 256K, chế độ suy nghĩ tích hợp sẵn, hiểu hình ảnh và function calling làm cho nó thực sự hữu dụng cho công việc thực tế, không chỉ là thử nghiệm.

Để host model trên GPU từ xa, LightNode cung cấp các instance VPS GPU với thanh toán theo giờ, để bạn có thể khởi động khi cần và tắt khi không.

Model card Gemma 4 trên HuggingFace có đầy đủ chi tiết kỹ thuật, và repo GGUF Unsloth có tất cả các biến thể đã lượng tử sẵn sàng tải về.

Tập trung giới thiệu máy chủ VPS toàn cầu.