Postingan sebelumnya dalam seri “Penjelasan Gemma” memberikan ringkasan mendetail mengenai arsitektur keluarga model Gemma. Anda bisa menemukan link ke setiap postingannya di bawah ini:
Dalam postingan ini, Anda akan menjelajahi model terbaru, Gemma 3. Mari kita gali lebih dalam.
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.
Meskipun arsitektur Gemma 3 mewarisi aspek-aspek dari pendahulunya, ia juga menghadirkan modifikasi baru seperti yang dijelaskan di bawah ini.
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.
Arsitektur telah dimodifikasi untuk mengurangi penggunaan memori cache KV, yang cenderung meningkat dengan konteks panjang.
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.
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.
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.
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:
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>")
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.")
Output
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.
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)
)
)
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.
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)
)
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.
Laporan teknis kami memberikan perincian secara mendalam, tetapi inilah ringkasan singkat dari temuan utama Gemma 3:
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!