Penjelasan Gemma: Ringkasan arsitektur keluarga model Gemma

AGU 15, 2024

Ju-yeong Ji Gemma DevRel

Ravin Kumar Google Data Scientist Language Applications

Gemma adalah keluarga model terbuka yang ringan dan canggih yang dibuat dari penelitian dan teknologi yang sama dengan yang digunakan untuk membuat model Gemini.

Beragam variasi Gemma dirancang untuk berbagai kasus penggunaan dan modalitas, seperti:

Modalitas tunggal (Teks masuk, Teks keluar)

Spesialisasi untuk kasus penggunaan coding

Multi modalitas (Teks dan Gambar masuk, Teks keluar)

Ukuran yang bervariasi untuk berbagai tipe hardware, kebutuhan inferensi, dan batasan lainnya.

Arsitektur “Baru”

Karena semua model ini memiliki DNA yang sama, keluarga Gemma menghadirkan cara unik untuk mempelajari arsitektur dan pilihan desain yang tersedia dalam sistem LLM modern. Kami berharap ini dapat berkontribusi pada ekosistem model terbuka yang berlimpah dan mendorong pemahaman yang lebih baik tentang cara kerja sistem LLM.

Seri ini akan membahas:

Gemma 1 (2B, 7B) - Model teks-ke-teks berbasis Transformer.

CodeGemma (2B dan 7B) - Versi Gemma yang disempurnakan, dioptimalkan untuk pelengkapan dan pembuatan kode.

Gemma 2 (2B, 9B, 27B) - Model teks-ke-teks terupdate yang dilatih dengan arsitektur terbaru menggunakan versi 2B dan 9B yang dilatih melalui distilasi dari model yang lebih besar.

RecurrentGemma (2B, 9B) - Model yang dibangun di atas arsitektur Griffin terbaru. Arsitektur ini menggunakan campuran attention lokal dan perulangan linear untuk mencapai inferensi yang cepat ketika membuat urutan yang panjang.

PaliGemma (3B) - Model visi-bahasa yang dapat menerima teks dan gambar serta memberikan output teks.

Cara menggunakan panduan ini

Dalam seri ini, kami akan

Menyusun arsitektur spesifik dari berbagai model

Menjelaskan bagaimana parameter ini memengaruhi pembuatan model (mis. sematan angka, Multi Query vs Multi Head vs Grouped Query)

Memberikan contoh kode model untuk eksplorasi lebih lanjut

Untuk memberikan informasi mengenai model, kami menggunakan modul print Hugging Face Transformers, seperti kode sederhana di bawah ini.

from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("google/gemma-7b")
print(model)

Anda juga bisa menjelajah di dalam model dengan torchinfo atau summary() di Keras Model class API.

Apa yang tidak dibahas dalam panduan ini

Panduan ini bukanlah pengantar tentang AI. Panduan ini menganggap bahwa Anda sudah memiliki pengetahuan dasar tentang neural network, Transformer, dan istilah-istilah terkait, seperti token. Jika Anda membutuhkan penyegaran tentang konsep-konsep ini, berikut adalah beberapa referensi untuk membantu Anda memulai:

Alat pembelajaran neural network yang dapat digunakan langsung di browser

http://playground.tensorflow.org/

Pengantar tentang transformer

Gemma

Gemma adalah LLM berbobot terbuka. Tersedia dalam varian yang disetel dengan instruksi dan varian mentah yang telah dilatih sebelumnya pada berbagai ukuran parameter. Gemma berbasis arsitektur LLM yang diperkenalkan oleh Tim Riset Google dalam makalah Attention Is All You Need. Fungsi utamanya adalah untuk menghasilkan satu per satu tokenword teks, berdasarkan perintah yang diberikan pengguna. Dalam tugas seperti penerjemahan, Gemma mengambil sebuah kalimat dari satu bahasa sebagai input dan mengeluarkan output padanannya dalam bahasa lain.

Seperti yang akan segera Anda lihat, Gemma sendiri selain merupakan model yang luar biasa, juga cocok dengan ekstensi khusus untuk memenuhi berbagai kebutuhan pengguna.

Arsitektur Gemma

Pertama, mari kita lihat dekoder transformer yang menjadi dasar model Gemma.

Tidak seperti arsitektur model transformer enkoder-dekoder asli yang diperkenalkan dalam makalah "Attention Is All You Need", Gemma hanya merupakan model "khusus dekoder".

Parameter inti arsitektur diringkas dalam tabel di bawah ini.

Model dilatih dengan panjang konteks 8192 token. Ini berarti mereka bisa memproses hingga sekitar 6144 kata (menggunakan aturan perhitungan 100 token ~= 75 kata) dalam satu waktu.

Perlu dicatat bahwa batas input sebenarnya bisa bervariasi berdasarkan tugas dan penggunaan. Hal ini dikarenakan pembuatan teks memakai token di dalam jendela konteks, sehingga secara efektif mengurangi ruang untuk input baru. Meskipun batas input teknis selalu konstan, output yang dihasilkan menjadi bagian dari input berikutnya, sehingga memengaruhi pembuatan selanjutnya.

d_model (2B: 2048, 7B: 3072)

d_model merepresentasikan ukuran sematan (representasi vektor kata atau subkata alias token) yang digunakan sebagai input ke dekoder. Ini juga menentukan ukuran representasi internal dalam lapisan dekoder.

“d_model x Num heads x Head size” menentukan nomor parameter dalam self_attn

Nilai d_model yang lebih besar berarti model memiliki lebih banyak "ruang" untuk merepresentasikan berbagai varian kata dan hubungannya. Ini bisa menghasilkan performa yang lebih baik, terutama untuk tugas bahasa kompleks. Namun, meningkatkan d_model juga membuat model lebih besar dan mahal secara komputasi saat dilatih dan digunakan.

Lapisan (2B: 18, 7B: 28)

Transformer terdiri dari beberapa lapisan yang bertumpuk. Model yang lebih dalam memiliki lebih banyak lapisan, dan karenanya memiliki lebih banyak parameter dan dapat mempelajari pola yang lebih rumit. Namun, parameter tambahan ini membuat model juga lebih rentan terhadap overfitting dan membutuhkan lebih banyak sumber daya komputasi.

Kapasitas representasi yang diperbesar ini mungkin mengakibatkan model mempelajari noise atau pola data pelatihan tertentu yang tidak memiliki kemampuan untuk menggeneralisasi contoh-contoh baru.

Selain itu, model yang lebih mendalam sering kali membutuhkan lebih banyak data pelatihan untuk menghindari overfitting. Dalam kasus ketika data yang tersedia terbatas, model mungkin tidak memiliki contoh yang cukup untuk mempelajari representasi yang dapat digeneralisasi, yang menyebabkan memorisasi data pelatihan.

Feedforward hidden dims (2B: 32768, 7B: 49152)

Setiap lapisan Transformer menyertakan jaringan feedforward setelah mekanisme attention. Jaringan ini memiliki dimensinya sendiri, sering kali lebih besar daripada ukuran d_model untuk meningkatkan daya ekspresif model.

Ia diimplementasikan sebagai multi-layer perceptron (MLP), semacam neural network, untuk mentransformasi lebih lanjut sematan dan mengekstrak pola yang lebih rumit.

multi-layer perceptron (MLP) neural network achitecture

Dalam Gemma, non-linearitas ReLU standar digantikan oleh fungsi aktivasi GeGLU, sebuah variasi GLU (Gate Linear Unit). GeGLU membagi aktivasi menjadi dua bagian: bagian sigmoidal dan proyeksi linear. Output dari bagian sigmoidal dikalikan dengan proyeksi linear, menghasilkan fungsi aktivasi non-linear.

Num heads (2B: 8, 7B: 16)

Setiap lapisan Transformer berisi beberapa mekanisme attention yang bekerja secara paralel. "Head" ini memungkinkan model untuk fokus pada berbagai aspek urutan input secara simultan. Menambah jumlah head dapat meningkatkan kemampuan model untuk menangkap beragam hubungan dalam data.

Num KV heads (2B: 1, 7B: 16)

Model 7B menggunakan multi-head attention (MHA), sedangkan model 2B menggunakan multi-query attention (MQA). MQA memiliki proyeksi kunci dan nilai yang sama, yang berarti setiap head berfokus pada representasi dasar yang sama tetapi dengan proyeksi kueri yang berbeda.

MHA asli menawarkan representation learning yang lebih kaya tetapi dengan biaya komputasi yang lebih tinggi. MQA memberikan alternatif yang efisien dan terbukti efektif.

Head size (2B: 256, 7B: 256)

Ukuran ini mengacu pada dimensi setiap head attention dalam mekanisme multi-head attention. Ini dihitung dengan membagi dimensi sematan dengan jumlah head. Misalnya, jika dimensi sematan adalah 2048 dan terdapat 8 head, maka setiap head akan memiliki ukuran 256.

Vocab size (2B: 256128, 7B: 256128)

Ini mendefinisikan jumlah token unik (kata, sub kata, atau karakter) yang dipahami dan bisa diproses oleh model. Tokenizer Gemma berbasis SentencePiece. Ukuran kosakata telah ditentukan sebelum pelatihan. SentencePiece kemudian mempelajari segmentasi subkata yang optimal berdasarkan ukuran kosakata yang dipilih dan data pelatihan. Kosakata Gemma yang berukuran 256 ribu memungkinkannya menangani beragam input teks dan berpotensi meningkatkan performa pada berbagai tugas, mis. menangani input teks multibahasa.

Gemma 7B

GemmaForCausalLM(
  (model): GemmaModel(
    (embed_tokens): Embedding(256000, 3072, padding_idx=0)
    (layers): ModuleList(
      (0-27): 28 x GemmaDecoderLayer(
        (self_attn): GemmaSdpaAttention(
          (q_proj): Linear(in_features=3072, out_features=4096, bias=False)
          (k_proj): Linear(in_features=3072, out_features=4096, bias=False)
          (v_proj): Linear(in_features=3072, out_features=4096, bias=False)
          (o_proj): Linear(in_features=4096, out_features=3072, bias=False)
          (rotary_emb): GemmaRotaryEmbedding()
        )
        (mlp): GemmaMLP(
          (gate_proj): Linear(in_features=3072, out_features=24576, bias=False)
          (up_proj): Linear(in_features=3072, out_features=24576, bias=False)
          (down_proj): Linear(in_features=24576, out_features=3072, bias=False)
          (act_fn): PytorchGELUTanh()
        )
        (input_layernorm): GemmaRMSNorm()
        (post_attention_layernorm): GemmaRMSNorm()
      )
    )
    (norm): GemmaRMSNorm()
  )
  (lm_head): Linear(in_features=3072, out_features=256000, bias=False)
)

embed_tokens (Lapisan Sematan)

Lapisan ini mengonversi token input (kata atau subkata) menjadi representasi numerik padat (sematan) yang bisa diproses oleh model. Lapisan ini memiliki ukuran kosakata 256.000 dan menciptakan sematan berdimensi 3072.

lapisan

Ini adalah inti model, yang terdiri dari 28 blok GemmaDecoderLayer yang ditumpuk. Setiap lapisan ini menyempurnakan sematan token untuk menangkap hubungan yang kompleks antara kata-kata dan konteksnya.

self_attn

Dalam mekanisme self-attention, model ini memberikan bobot yang berbeda pada kata yang ada di dalam input saat membuat kata berikutnya. Memanfaatkan mekanisme scaled dot-product attention, model ini menggunakan proyeksi linear (q_proj, k_proj, v_proj, dan o_proj) untuk menghasilkan kueri, kunci, nilai, dan representasi output.

Semua nilai out_features adalah 4096 yang sama untuk q_proj, k_proj, dan v_proj karena model ini menggunakan Multi Head Attention (MHA). Mereka memiliki 16 head dengan ukuran 256 secara paralel, dengan total 4096 (256 x 16).

Selain itu, model ini memanfaatkan informasi posisional secara lebih efektif dengan menggunakan rotary_emb (GemmaRotaryEmbedding) untuk encoding posisional (alias RoPE).

Terakhir, lapisan o_proj memproyeksikan output attention kembali ke dimensi asli (3072).

Perhatikan bahwa model Gemma 2B menggunakan Multi Query Attention (MQA).

Multi-Query Attention (MQA) architecture used in Gemma 2B model

k_proj dan v_proj berbagi head yang sama dengan ukuran 256, sehingga menghasilkan out_features 256. Sebaliknya, q_proj dan o_proj memiliki 8 head (256 x 8 = 2048) secara paralel.

(self_attn): GemmaSdpaAttention(
          (q_proj): Linear(in_features=2048, out_features=2048, bias=False)
          (k_proj): Linear(in_features=2048, out_features=256, bias=False)
          (v_proj): Linear(in_features=2048, out_features=256, bias=False)
          (o_proj): Linear(in_features=2048, out_features=2048, bias=False)
          (rotary_emb): GemmaRotaryEmbedding()
        )

mlp

Lapisan ini menggunakan gate_proj dan up_proj untuk mekanisme gating, diikuti dengan down_proj untuk mengurangi dimensi kembali ke 3072.

input_layernorm, post_attention_layernorm dan norm

Lapisan normalisasi ini menstabilkan pelatihan dan meningkatkan kemampuan model untuk belajar secara efektif.

lm_head

Lapisan terakhir ini memetakan sematan yang telah disempurnakan (3072) kembali ke distribusi probabilitas untuk token berikutnya dalam ruang kosakata (256000).

CodeGemma (2B dan 7B)

Model CodeGemma adalah model Gemma yang disempurnakan dan dioptimalkan untuk pelengkapan kode dan bantuan chat coding. Model CodeGemma dilatih dengan lebih dari 500 miliar token yang sebagian besar berupa kode. Selain itu, CodeGemma menambahkan kemampuan fill-in-the-middle, yang memungkinkan pelengkapan dilakukan di antara dua bagian teks yang sudah ada.

CodeGemma menyoroti kemampuan penyempurnaan checkpoint Gemma. Melalui pelatihan tambahan, model ini menjadi terspesialisasi pada tugas tertentu, mempelajari pelengkapan yang lebih kompleks bukan hanya pelengkapan sufiks murni.

Penggunaan Code Gemma

Anda bisa menggunakan 4 token yang ditentukan pengguna - 3 untuk FIM dan token "<|file_separator|>" untuk dukungan konteks multi-file.

BEFORE_CURSOR = "<|fim_prefix|>"
AFTER_CURSOR = "<|fim_suffix|>"
AT_CURSOR = "<|fim_middle|>"
FILE_SEPARATOR = "<|file_separator|>"

Bayangkan Anda sedang mencoba melengkapi kode seperti layar di bawah ini.

Code snippet example - CodeGemma (2B and 7B)

Dan perintah inputnya terlihat seperti ini

<|fim_prefix|>import <|fim_suffix|>if __name__ == "__main__":\n    sys.exit(0)<|fim_middle|>

Model akan memberikan "sys" sebagai saran pelengkapan kode.

Anda bisa menjelajahi lebih lanjut tentang CodeGemma di CodeGemma / Panduan memulai.

Apa Berikutnya?

Artikel ini membahas arsitektur Gemma.

Dalam seri artikel kami yang berikutnya, Anda akan menjelajahi model terbaru, Gemma 2. Dengan peningkatan substansial dalam hal keamanan, model ini melampaui pendahulunya dalam hal performa dan efisiensi selama inferensi.

Nantikan informasi selanjutnya dan terima kasih telah membaca!