Transformers documentation

Gemma4

Transformers

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Model ini disumbangkan ke Hugging Face Transformers pada 2026-04-02.

Gemma4

Ikhtisar

Gemma 4 adalah model multimodal dengan varian pra-pelatihan dan penyetelan instruksi, tersedia dalam ukuran parameter E2B, E4B, 31B, dan 26B-A4B (MoE). Model Gemma 4 menyediakan kemampuan berikut:

Penalaran: Semua model dalam keluarga ini dirancang sebagai penalar yang sangat mumpuni, dengan mode berpikir yang dapat dikonfigurasi.
Multimodalitas yang Diperluas: Memproses Teks, Gambar dengan dukungan rasio aspek dan resolusi yang bervariasi (semua model), Video, dan Audio (fitur bawaan pada model E2B dan E4B).
Jendela Konteks yang Lebih Besar: Model-model kecil memiliki jendela konteks 128K, sedangkan model-model lainnya mendukung 256K.
Kemampuan Coding & Agentic yang Ditingkatkan: Mencapai peningkatan yang signifikan pada benchmark coding sekaligus dukungan function-calling bawaan, yang menggerakkan agen otonom yang sangat mumpuni.
Dukungan System Prompt Native: Gemma 4 memperkenalkan dukungan bawaan untuk peran sistem, memungkinkan percakapan yang lebih terstruktur dan dapat dikendalikan.

Anda dapat menemukan semua checkpoint asli Gemma 4 di bawah rilis Gemma 4.

Model Gemma4 Vision

Perbedaan utama dari rilis Gemma sebelumnya untuk visi adalah desain baru untuk memproses gambar dengan ukuran berbeda menggunakan jumlah token dengan anggaran tetap. Berbeda dengan banyak model yang memaksa setiap gambar menjadi persegi berukuran tetap (seperti 224×224), Gemma 4 mempertahankan rasio aspek alami gambar sambil menyesuaikannya ke ukuran yang tepat. Ada beberapa batasan yang perlu diikuti:

Jumlah total piksel harus muat dalam anggaran patch
Ketinggian dan lebar keduanya harus dapat dibagi habis oleh 48 (= ukuran patch 16 × kernel pooling 3)

Gemma 4 tidak menerapkan normalisasi mean/std ImageNet standar yang digunakan oleh banyak model visi lainnya. Lapisan patch embedding milik model itu sendiri menangani penskalaan akhir secara internal (menggeser nilai ke rentang [-1, 1]).

Jumlah “soft token” (disebut juga vision token) yang dapat dihasilkan oleh image processor dapat dikonfigurasi. Opsi yang didukung diuraikan di bawah ini dan nilai defaultnya adalah 280 soft token per gambar.

Token Lunak	Patches (sebelum pooling)	Luas Gambar Perkiraan
70	630	~161K piksel
140	1,260	~323K piksel
280	2,520	~645K piksel
560	5,040	~1,3 juta piksel
1,120	10,080	~2,6 juta piksel

Untuk mengkodekan informasi posisi untuk setiap patch dalam gambar, Gemma 4 menggunakan tabel posisi 2D yang dipelajari. Tabel posisi menyimpan hingga 10.240 posisi per sumbu, yang memungkinkan model untuk menangani gambar yang sangat besar. Setiap posisi adalah vektor yang dipelajari dengan dimensi yang sama dengan patch embedding. 2D RoPE yang digunakan oleh Gemma 4 secara independen memutar setengah dimensi kepala perhatian untuk sumbu x dan setengah lainnya untuk sumbu y. Hal ini memungkinkan model untuk memahami hubungan spasial seperti “di atas,” “di bawah,” “di kiri,” dan “di kanan.”

Embedding Per-Lapisan (PLE)

Gemma 4 memperkenalkan sistem Per-Layer Embeddings (PLE) yang memberikan sinyal residual tambahan ke setiap lapisan decoder, alih-alih hanya mengandalkan satu embedding bersama di input.

PLE menggabungkan dua komponen yang dijumlahkan dan diskalakan dengan 1/√2 sebelum dimasukkan ke setiap lapisan decoder:

Token-identity (get_per_layer_inputs): mencari input_ids di embed_tokens_per_layer, yaitu Gemma4TextScaledWordEmbedding yang mengalikan dengan √(hidden_size_per_layer_input). Output yang dikemas di-reshape dari [batch, seq, num_hidden_layers * hidden_size_per_layer_input] menjadi [batch, seq, num_hidden_layers, hidden_size_per_layer_input].
Context-aware (project_per_layer_inputs): memproyeksikan inputs_embeds melalui per_layer_model_projection (lapisan Linear), menskalakan dengan 1/√(hidden_size), membentuk ulang menjadi [batch, seq, num_layers, ple_dim], dan menormalisasi dengan per_layer_projection_norm (RMSNorm).

Ketika kedua komponen tersedia, input per-lapisan akhir adalah (token_identity + context_aware) * (1/√2). Untuk input multimodal di mana input_ids tidak tersedia, hanya proyeksi yang sadar konteks yang digunakan.

Contoh penggunaan

Contoh di bawah ini menunjukkan cara menghasilkan teks berdasarkan gambar dengan Pipeline atau kelas AutoModel.

from transformers import pipeline


pipeline = pipeline(
    task="image-text-to-text",
    model="google/gemma-4-E2B-it",
)
pipeline(
    images="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg",
    text="<|image|>\n\nWhat is shown in this image?"
)

</hfoption> <hfoption id="AutoModel">

from transformers import AutoModelForImageTextToText, AutoProcessor


model = AutoModelForImageTextToText.from_pretrained(
    "google/gemma-4-E2B-it",
    device_map="auto",
    attn_implementation="sdpa"
)
processor = AutoProcessor.from_pretrained(
    "google/gemma-4-E2B-it",
    padding_side="left"
)

messages = [
    {
        "role": "user", "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
            {"type": "text", "text": "What is shown 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]

output = model.generate(**inputs, max_new_tokens=50, cache_implementation="static")
print(processor.decode(output[0][input_len:], skip_special_tokens=True))

Pemanggilan fungsi

from transformers import AutoModelForCausalLM, AutoProcessor


WEATHER_TOOL = {
    "type": "function",
    "function": {
        "name": "get_n_day_weather_forecast",
        "description": "Get an N-day weather forecast",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "The city and state, e.g. San Francisco, CA",
                },
                "format": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "The temperature unit to use",
                },
                "num_days": {
                    "type": "integer",
                    "description": "The number of days to forecast",
                },
            },
            "required": ["location", "format", "num_days"],
        },
    },
}

messages = [
    {
        "role": "user",
        "content": "What's the weather like the next 3 days in San Francisco, CA (using F)?",
    },
]

model = AutoModelForCausalLM.from_pretrained(
    "google/gemma-4-E2B-it",
    device_map="auto",
    attn_implementation="sdpa"
)
processor = AutoProcessor.from_pretrained(
    "google/gemma-4-E2B-it",
    padding_side="left"
)

text = processor.apply_chat_template(
    messages,
    tools=[WEATHER_TOOL],
    tokenize=False,
    add_generation_prompt=True,
)

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

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

Audio (Hanya E2B dan E4B)

from transformers import AutoModelForMultimodalLM, AutoProcessor


messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "Please transcribe the following audio:"},
            {
                "type": "audio",
                "url": "https://huggingface.co/datasets/eustlb/audio-samples/resolve/main/dude_where_is_my_car.wav",
            },
        ],
    }
]

model = AutoModelForMultimodalLM.from_pretrained(
    "google/gemma-4-E2B-it",
    device_map="auto",
    attn_implementation="sdpa"
)
processor = AutoProcessor.from_pretrained(
    "google/gemma-4-E2B-it",
    padding_side="left"
)

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

input_len = inputs["input_ids"].shape[-1]

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

Transformers

Gemma4

Ikhtisar

Model Gemma4 Vision

Embedding Per-Lapisan (PLE)

Contoh penggunaan

Pemanggilan fungsi

Audio (Hanya E2B dan E4B)

Gemma4AudioConfig

kelas transformers.Gemma4AudioConfig

Gemma4VisionConfig

kelas transformers.Gemma4VisionConfig

Gemma4TextConfig

kelas transformers.Gemma4TextConfig

Gemma4Config

kelas transformers.Gemma4Config

Gemma4AudioFeatureExtractor

kelas transformers.Gemma4AudioFeatureExtractor

__call__

Gemma4ImageProcessorPil

kelas transformers.Gemma4ImageProcessorPil

praproses

Gemma4ImageProcessor

kelas transformers.Gemma4ImageProcessor

praproses

Gemma4VideoProcessor

kelas transformers.Gemma4VideoProcessor

praproses

Gemma4Processor

kelas transformers.Gemma4Processor

__call__

Gemma4PreTrainedModel

kelas transformers.Gemma4PreTrainedModel

forward

Gemma4AudioModel

kelas transformers.Gemma4AudioModel

forward

Gemma4VisionModel

kelas transformers.Gemma4VisionModel

forward

Gemma4TextModel

kelas transformers.Gemma4TextModel

forward

Gemma4ForCausalLM

kelas transformers.Gemma4ForCausalLM

forward

Gemma4Model

kelas transformers.Gemma4Model

forward

Gemma4ForConditionalGeneration

kelas transformers.Gemma4ForConditionalGeneration

forward

call

call