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:
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:
Dalam seri ini, kami akan
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.
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
Pengantar tentang transformer
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.
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 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.
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.
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.
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.
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.
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.
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.
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.
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.
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)
)
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.
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.
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).
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()
)
Lapisan ini menggunakan gate_proj dan up_proj untuk mekanisme gating, diikuti dengan down_proj untuk mengurangi dimensi kembali ke 3072.
Lapisan normalisasi ini menstabilkan pelatihan dan meningkatkan kemampuan model untuk belajar secara efektif.
Lapisan terakhir ini memetakan sematan yang telah disempurnakan (3072) kembali ke distribusi probabilitas untuk token berikutnya dalam ruang kosakata (256000).
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.
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.
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.
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!
Gemma
CodeGemma
