Penjelasan Gemma: Yang baru di Gemma 3

30 APRIL 2025

Ju-yeong Ji Sr. Technical Consultant Gen AI – AI Studio

Ravin Kumar Senior Research Engineer Google DeepMind

Postingan sebelumnya dalam seri “Penjelasan Gemma” memberikan ringkasan mendetail mengenai arsitektur keluarga model Gemma. Anda bisa menemukan link ke setiap postingannya di bawah ini:

Penjelasan Gemma: Ringkasan arsitektur keluarga model Gemma

Penjelasan Gemma: Yang baru di Gemma 2

Penjelasan Gemma: Arsitektur RecurrentGemma

Penjelasan Gemma: Arsitektur PaliGemma

Dalam postingan ini, Anda akan menjelajahi model terbaru, Gemma 3. Mari kita gali lebih dalam.

Gemma 3

Perubahan signifikan dari versi sebelumnya adalah dukungan baru Gemma 3 untuk kemampuan visi-bahasa. Mereka yang familier dengan arsitektur PaliGemma mungkin mengenal encoder SigLIP yang digunakan dalam Gemma 3, meskipun telah disesuaikan untuk implementasi khusus ini.

Berikut adalah parameter inti dari model baru ini.

Mari kita pelajari perbedaan dan peningkatan utama dalam Gemma 3.

Perbedaan Utama

Meskipun arsitektur Gemma 3 mewarisi aspek-aspek dari pendahulunya, ia juga menghadirkan modifikasi baru seperti yang dijelaskan di bawah ini.

Dukungan visi-bahasa

Peningkatan utama dalam Gemma 3 adalah kemampuan memahami visi-bahasa baru. Model 4B, 12B, dan 27B menggunakan encoder visi SigLIP khusus, yang memungkinkan model menginterpretasikan input visual.

Encoder visi beroperasi pada gambar persegi 896x896 berukuran tetap. Untuk menangani gambar dengan rasio aspek yang berbeda atau memiliki resolusi tinggi, algoritme “Pan&Scan” digunakan. Ini melibatkan pemotongan gambar secara adaptif, mengubah ukuran setiap potongan menjadi 896x896, dan kemudian melakukan encoding. Meskipun metode ini meningkatkan performa, khususnya apabila informasi yang mendetail sangatlah penting, metode ini menyebabkan peningkatan overhead komputasi selama inferensi.

Selain itu, Gemma 3 memperlakukan gambar sebagai urutan “token lunak” ringkas yang dihasilkan oleh MultiModalProjector. Teknik ini secara signifikan mengurangi sumber daya inferensi yang diperlukan untuk pemrosesan gambar dengan merepresentasikan data visual dengan jumlah tetap 256 vektor.

Sebelum melanjutkan, Anda mungkin bertanya-tanya: “Kapan saya harus menggunakan Gemma 3 versus PaliGemma 2?”

Kekuatan PaliGemma 2 terletak pada fitur yang tidak ditemukan pada Gemma 3, seperti segmentasi gambar dan deteksi objek. Namun, Gemma 3 mengintegrasikan dan memperluas teknologi dari PaliGemma, menawarkan chat multi-giliran dan performa zero-shot yang kuat untuk menangani berbagai tugas visi secara langsung.

Keputusan akhir Anda juga harus mempertimbangkan sumber daya komputasi yang tersedia dan pentingnya fitur tingkat lanjut seperti konteks yang lebih panjang atau dukungan multibahasa, karena Gemma 3 menawarkan peningkatan yang signifikan.

Perubahan Arsitektural untuk Efisiensi Memori

Arsitektur telah dimodifikasi untuk mengurangi penggunaan memori cache KV, yang cenderung meningkat dengan konteks panjang.

Perhatian berselang-seling 5 banding 1

Arsitektur model yang diperbarui terdiri dari blok berselang-seling secara berulang, masing-masing berisi 5 lapisan perhatian lokal dengan jendela geser 1024 dan 1 lapisan perhatian global. Desain ini memungkinkan model menangkap dependensi jangka pendek dan panjang, sehingga menghasilkan respons yang lebih akurat dan relevan secara kontekstual.

^Catatan:^{Gemma 1 hanya mengandalkan perhatian global, sedangkan Gemma 2 memperkenalkan pendekatan hybrid dengan menyelang-nyelingkan lapisan perhatian lokal dan global. Gemma 3 mengintegrasikan 5 lapisan perhatian lokal khusus, sehingga menghasilkan respons yang lebih akurat dan sesuai konteks.}

Gemma 3 local and global attention layers depicted in a table, compared to Gemma 1 and Gemma 2

Tanpa softcapping

Baik Gemma 2 maupun Gemma 3 menggunakan Grouped-Query Attention (GQA) dengan post-norm dan pre-norm dengan RMSNorm. Namun, Gemma 3 mendapatkan akurasi yang lebih baik dan kecepatan pemrosesan yang lebih tinggi dengan mengadopsi QK-norm sebagai pengganti mekanisme soft-capping Gemma 2.

Konteks yang Lebih Panjang

Akibat dari perubahan arsitektur yang dibahas di atas, Gemma 3 memanfaatkan perhatian berselang-seling untuk mengurangi kebutuhan memori, sehingga memungkinkan dukungan untuk konteks yang lebih panjang. Ini memungkinkan analisis dokumen dan percakapan yang lebih panjang tanpa kehilangan konteks. Secara khusus, ia dapat menangani 32k token untuk model 1B dan 128k token untuk model yang lebih besar.

^Catatan:^{Jendela konteks 128k token memungkinkan model memproses jumlah teks yang panjangnya sama dengan sebuah novel biasa (sekitar 80 ribu kata). Ukuran jendela ini sekitar 96 ribu kata, 198 halaman, 500 gambar, atau 8+ menit video dengan kecepatan 1 fps.}

Encoder Visi dan Pemrosesan

Gemma 3 hanya menggunakan perhatian dua arah dengan input gambar.

Perhatian normal (alias perhatian satu arah) seperti membaca. Bayangkan Anda sedang membaca sebuah buku. Anda memahami setiap kata dengan mempertimbangkan kata yang ada sebelumnya. Beginilah cara kerja perhatian normal dalam model bahasa. Prosesnya berurutan dan melihat ke belakang untuk membangun konteks.

Di sisi lain, perhatian dua arah seperti melihat teka-teki. Bayangkan gambar sebagai sebuah teka-teki. “Token Gambar” seperti potongan teka-teki individual. Artinya, setiap bagian “melihat” dan terhubung dengan setiap bagian lain dalam gambar, terlepas dari posisinya. Metode ini mempertimbangkan keseluruhan gambar sekaligus, bukan hanya urutannya. Hal ini memberikan pemahaman yang lengkap, karena setiap bagian terkait dengan setiap bagian lainnya.

Jadi mengapa tidak selalu dibuat dua arah? Meskipun perhatian dua arah (melihat seluruh konteks) terdengar lebih baik, tetapi ia tidak selalu digunakan untuk teks. Semuanya tergantung tugas:

Pemahaman (Dua Arah Baik)
Untuk tugas-tugas ketika kita memiliki seluruh teks dan perlu memahaminya secara mendalam (seperti pada model BERT), perhatian dua arah sangat baik.

Prediksi (Satu Arah Lebih Baik)
Ketika tugas Anda adalah memprediksi kata berikutnya atau membuat teks, pendekatan satu arah (autoregresif) lebih natural. Memprediksi kata yang akan muncul berikutnya pada dasarnya bersifat berurutan. Cara ini juga sering kali lebih efisien secara komputasi.

Perbedaan utamanya adalah bahwa pendekatan dua arah digunakan ketika model tidak membuat urutan.

Visualisasi berikut ini menggambarkan mekanisme perhatian dalam Gemma 3.

Kode:

from transformers.utils.attention_visualizer import AttentionMaskVisualizer
visualizer = AttentionMaskVisualizer("google/gemma-3-4b-it")
visualizer("<start_of_turn>user\n<img>What is this?<end_of_turn>\n<start_of_turn>model\nIt's an image of a cat.<end_of_turn>")

Python

Output:

Anda juga bisa melihat bagaimana mekanisme perhatian ini berbeda dengan PaliGemma. Untuk memberikan konteks perbandingan ini, PaliGemma beroperasi dengan menerima satu gambar atau lebih bersama dengan deskripsi tugas berbasis teks (prompt atau awalan), dan kemudian menghasilkan prediksinya sebagai string teks (jawaban atau akhiran) secara autoregresif.

Kode:

visualizer = AttentionMaskVisualizer("google/paligemma2-3b-mix-224")
visualizer("<img> caption en", suffix="a cat standing on a beach.")

Python

Output

Tokenizer baru

Gemma 3 telah meningkatkan kemampuan multibahasa berkat campuran data yang ditinjau kembali dengan jumlah data multibahasa yang lebih banyak (baik monolingual maupun paralel).

Gemma 3 juga memperkenalkan tokenizer yang lebih baik. Ukuran kosakata berubah menjadi 262k, tetapi menggunakan tokenizer SentencePiece yang sama. Untuk menghindari error, gunakanlah tokenizer baru dengan Gemma 3. Ini adalah tokenizer yang sama dengan Gemini yang lebih seimbang untuk bahasa non-Inggris.

Gemma 3 27B

Gemma3ForConditionalGeneration(
  (vision_tower): SiglipVisionModel(
    (vision_model): SiglipVisionTransformer(
      (embeddings): SiglipVisionEmbeddings(
        (patch_embedding): Conv2d(3, 1152, kernel_size=(14, 14), stride=(14, 14), padding=valid)
        (position_embedding): Embedding(4096, 1152)
      )
      (encoder): SiglipEncoder(
        (layers): ModuleList(
          (0-26): 27 x SiglipEncoderLayer(
            (self_attn): SiglipSdpaAttention(
              (k_proj): Linear(in_features=1152, out_features=1152, bias=True)
              (v_proj): Linear(in_features=1152, out_features=1152, bias=True)
              (q_proj): Linear(in_features=1152, out_features=1152, bias=True)
              (out_proj): Linear(in_features=1152, out_features=1152, bias=True)
            )
            (layer_norm1): LayerNorm((1152,), eps=1e-06, elementwise_affine=True)
            (mlp): SiglipMLP(
              (activation_fn): PytorchGELUTanh()
              (fc1): Linear(in_features=1152, out_features=4304, bias=True)
              (fc2): Linear(in_features=4304, out_features=1152, bias=True)
            )
            (layer_norm2): LayerNorm((1152,), eps=1e-06, elementwise_affine=True)
          )
        )
      )
      (post_layernorm): LayerNorm((1152,), eps=1e-06, elementwise_affine=True)
    )
  )
  (multi_modal_projector): Gemma3MultiModalProjector(
    (mm_soft_emb_norm): Gemma3RMSNorm((1152,), eps=1e-06)
    (avg_pool): AvgPool2d(kernel_size=4, stride=4, padding=0)
  )
  (language_model): Gemma3ForCausalLM(
    (model): Gemma3TextModel(
      (embed_tokens): Gemma3TextScaledWordEmbedding(262208, 5376, padding_idx=0)
      (layers): ModuleList(
        (0-61): 62 x Gemma3DecoderLayer(
          (self_attn): Gemma3Attention(
            (q_proj): Linear(in_features=5376, out_features=4096, bias=False)
            (k_proj): Linear(in_features=5376, out_features=2048, bias=False)
            (v_proj): Linear(in_features=5376, out_features=2048, bias=False)
            (o_proj): Linear(in_features=4096, out_features=5376, bias=False)
            (q_norm): Gemma3RMSNorm((128,), eps=1e-06)
            (k_norm): Gemma3RMSNorm((128,), eps=1e-06)
          )
          (mlp): Gemma3MLP(
            (gate_proj): Linear(in_features=5376, out_features=21504, bias=False)
            (up_proj): Linear(in_features=5376, out_features=21504, bias=False)
            (down_proj): Linear(in_features=21504, out_features=5376, bias=False)
            (act_fn): PytorchGELUTanh()
          )
          (input_layernorm): Gemma3RMSNorm((5376,), eps=1e-06)
          (post_attention_layernorm): Gemma3RMSNorm((5376,), eps=1e-06)
          (pre_feedforward_layernorm): Gemma3RMSNorm((5376,), eps=1e-06)
          (post_feedforward_layernorm): Gemma3RMSNorm((5376,), eps=1e-06)
        )
      )
      (norm): Gemma3RMSNorm((5376,), eps=1e-06)
      (rotary_emb): Gemma3RotaryEmbedding()
      (rotary_emb_local): Gemma3RotaryEmbedding()
    )
    (lm_head): Linear(in_features=5376, out_features=262208, bias=False)
  )
)

Python

^Catatan: ^{Secara teknis, RoPE (Rotary Positional Embedding) ada di dalam SDPA (Scaled Dot-Product Attention), tetapi kami menyederhanakannya dalam diagram ini. Silakan lihat} ^kode^{untuk detail arsitektur yang presisi.}

Gemma 3 1B

Gemma3ForCausalLM(
  (model): Gemma3TextModel(
    (embed_tokens): Gemma3TextScaledWordEmbedding(262144, 1152, padding_idx=0)
    (layers): ModuleList(
      (0-25): 26 x Gemma3DecoderLayer(
        (self_attn): Gemma3Attention(
          (q_proj): Linear(in_features=1152, out_features=1024, bias=False)
          (k_proj): Linear(in_features=1152, out_features=256, bias=False)
          (v_proj): Linear(in_features=1152, out_features=256, bias=False)
          (o_proj): Linear(in_features=1024, out_features=1152, bias=False)
          (q_norm): Gemma3RMSNorm((256,), eps=1e-06)
          (k_norm): Gemma3RMSNorm((256,), eps=1e-06)
        )
        (mlp): Gemma3MLP(
          (gate_proj): Linear(in_features=1152, out_features=6912, bias=False)
          (up_proj): Linear(in_features=1152, out_features=6912, bias=False)
          (down_proj): Linear(in_features=6912, out_features=1152, bias=False)
          (act_fn): PytorchGELUTanh()
        )
        (input_layernorm): Gemma3RMSNorm((1152,), eps=1e-06)
        (post_attention_layernorm): Gemma3RMSNorm((1152,), eps=1e-06)
        (pre_feedforward_layernorm): Gemma3RMSNorm((1152,), eps=1e-06)
        (post_feedforward_layernorm): Gemma3RMSNorm((1152,), eps=1e-06)
      )
    )
    (norm): Gemma3RMSNorm((1152,), eps=1e-06)
    (rotary_emb): Gemma3RotaryEmbedding()
    (rotary_emb_local): Gemma3RotaryEmbedding()
  )
  (lm_head): Linear(in_features=1152, out_features=262144, bias=False)
)

Python

Model 1B hanya-teks ini secara khusus dioptimalkan untuk penggunaan di perangkat, membuat AI tingkat lanjut dapat diakses di sistem seluler dan tersemat. Ini secara signifikan berdampak pada aksesibilitas, privasi, dan performa, karena aplikasi berteknologi AI kini bisa berfungsi secara efisien meskipun dengan konektivitas jaringan yang terbatas atau tanpa jaringan sama sekali.

Temuan Utama

Laporan teknis kami memberikan perincian secara mendalam, tetapi inilah ringkasan singkat dari temuan utama Gemma 3:

Performa Unggul dengan ukuran yang sama:
Model Gemma 3 menghasilkan performa yang lebih unggul dibandingkan dengan Gemma 2 pada kedua versi yang telah dilatih dengan setelan instruksi dalam berbagai tolok ukur. Ini adalah model terbaik yang cocok untuk satu host GPU atau TPU konsumen. Model IT Gemma 27B berada di antara 10 model teratas di LM Arena pada 12 April 2025, mengungguli model terbuka yang jauh lebih besar dan menunjukkan skor Elo yang jauh lebih tinggi daripada Gemma 2.

Pengurangan Memori Cache KV:
Perubahan arsitektur pada Gemma 3 secara efektif mengurangi overhead memori cache KV selama inferensi dengan konteks yang panjang dibandingkan dengan mekanisme perhatian global saja yang digunakan pada Gemma 1 dan rasio lokal/global 1:1 yang digunakan pada Gemma 2.

Penanganan Konteks Panjang yang Efektif:
Model Gemma 3 bisa menggeneralisasi hingga panjang konteks 128k setelah penskalaan ulang RoPE selama pra-pelatihan. Kami meningkatkan frekuensi dasar RoPE dari 10k menjadi 1M pada lapisan self-attention global, dan menjaga frekuensi lapisan lokal pada 10k.

Peningkatan Multibahasa:
Gemma 3 menggunakan tokenizer yang sama dengan Gemini yang lebih seimbang untuk bahasa non-Inggris. Kami juga merevisi campuran data pra-pelatihan dan proses pasca-pelatihan untuk meningkatkan kemampuan multibahasa.

Dampak Resolusi Encoder Visi:
Encoder visi dengan resolusi yang lebih tinggi menghasilkan performa yang lebih baik pada tugas-tugas visi. Metode Pan & Scan semakin meningkatkan performa pada tugas yang melibatkan rasio aspek non-persegi, gambar beresolusi tinggi, dan pembacaan teks dalam gambar.

Ringkasan

Kami menjelajahi arsitektur Gemma 3, menyoroti berbagai fitur baru yang membedakannya dari versi sebelumnya. Pilihan arsitektur ini memungkinkan Gemma 3 bekerja lebih baik pada rangkaian tugas yang lebih luas, termasuk kemampuan multibahasa dan interaksi gambar yang lebih baik, sekaligus membuka jalan bagi model bahasa multimodal yang lebih mumpuni dan ramah sumber daya di masa mendatang yang cocok untuk hardware standar.

Kami percaya inovasi Gemma 3 akan memampukan peneliti dan developer untuk menciptakan model bahasa multimodal generasi berikutnya yang efisien dan kuat.

Terima kasih sudah membaca!