คู่มือการใช้งาน Gemma 2 ของ Google: โมเดลภาษาขนาดใหญ่แบบเปิด

Gemma 2 สร้างขึ้นจาก Gemma รุ่นก่อนหน้า โดยมีการปรับปรุงประสิทธิภาพและความสามารถใหม่ๆ ที่ทำให้เหมาะสำหรับทั้งการวิจัยและใช้งานจริง สิ่งที่ทำให้ Gemma 2 แตกต่างคือความสามารถในการให้ประสิทธิภาพที่เทียบเท่ากับโมเดลที่ใหญ่กว่า แต่มีขนาดที่เล็กกว่าและสามารถใช้ได้กับฮาร์ดแวร์ที่มีขนาดเล็กกว่า

เมื่อฉันศึกษาสpecifications และสถาปัตยกรรมของ Gemma 2 ฉันรู้สึกประทับใจกับการออกแบบที่ชาญฉลาดของโมเดลนี้ โมเดลนี้รวมเทคนิคขั้นสูงหลายอย่าง เช่น กลไกการให้ความสนใจใหม่ๆ และวิธีการฝึกอบรมที่稳定 ซึ่งช่วยให้โมเดลมีความสามารถที่น่าประทับใจ

Google [securities_stock_price_tag symbol="GOOGL" exchange="NASDAQ"] Open Source LLM Gemma

ในคู่มือนี้ เราจะสำรวจ Gemma 2 อย่างลึกซึ้ง โดยตรวจสอบสถาปัตยกรรม คุณสมบัติหลัก และการประยุกต์ใช้งาน ไม่ว่าคุณจะเป็นนักปฏิบัติงาน AI ที่มีประสบการณ์หรือผู้เริ่มต้นใหม่ในด้านนี้ บทความนี้มีจุดมุ่งหมายเพื่อให้ข้อมูลเชิงลึกที่มีคุณค่าเกี่ยวกับวิธีการทำงานของ Gemma 2 และวิธีการใช้พลังของมันในโครงการของคุณ

什么是 Gemma 2?

Gemma 2 เป็นโมเดลภาษาขนาดใหญ่แบบเปิดของ Google ที่ได้รับการออกแบบให้มีขนาดเล็กแต่มีประสิทธิภาพ มันถูกสร้างขึ้นโดยใช้เทคโนโลยีเดียวกับที่ใช้ในการสร้างโมเดล Gemini ของ Google โดยให้ประสิทธิภาพที่เป็นรัฐของศิลปะในแพ็คเกจที่สามารถเข้าถึงได้ง่ายขึ้น Gemma 2 มี 2 ขนาด:

Gemma 2 9B: โมเดล 9 พันล้านพารามิเตอร์
Gemma 2 27B: โมเดล 27 พันล้านพารามิเตอร์ที่ใหญ่กว่า

ทั้งสองขนาดมี 2 รูปแบบ:

โมเดลฐาน: โมเดลที่ได้รับการฝึกอบรมล่วงหน้าบนข้อมูลข้อความจำนวนมาก
โมเดลที่ได้รับการปรับให้เหมาะสมด้วยคำสั่ง (IT): โมเดลที่ได้รับการปรับให้เหมาะสมสำหรับการทำงานเฉพาะ

เข้าถึงโมเดลใน Google AI Studio: Google AI Studio – Gemma 2

อ่านรายงานทางเทคนิคที่นี่: รายงานทางเทคนิค Gemma 2

คุณสมบัติหลักและความก้าวหน้า

Gemma 2 นำเสนอความก้าวหน้าหลายอย่างเหนือรุ่นก่อนหน้า:

1. ข้อมูลฝึกอบรมที่เพิ่มขึ้น

โมเดลได้รับการฝึกอบรมบนข้อมูลที่มากขึ้น:

Gemma 2 27B: ฝึกอบรมบน 13 ล้านล้านโทเค็น
Gemma 2 9B: ฝึกอบรมบน 8 ล้านล้านโทเค็น

ชุดข้อมูลที่ขยายนี้ ซึ่งประกอบด้วยข้อมูลเว็บ (ส่วนใหญ่เป็นภาษาอังกฤษ) โค้ด และคณิตศาสตร์ ช่วยให้โมเดลมีประสิทธิภาพและความสามารถที่ดีขึ้น

2. การให้ความสนใจแบบสไลด์วินโดว์

Gemma 2 ใช้กลไกการให้ความสนใจแบบใหม่:

ทุกๆ ชั้นจะใช้การให้ความสนใจแบบสไลด์วินโดว์พร้อมบริบทท้องถิ่น 4096 โทเค็น
ชั้นที่สลับกันจะใช้การให้ความสนใจแบบควอแดรติกทั่วทั้งบริบท 8192 โทเค็น

แนวทางแบบผสมผสานนี้มีจุดมุ่งหมายเพื่อสร้างสมดุลระหว่างประสิทธิภาพและความสามารถในการจับข้อมูลที่มีความสัมพันธ์ระยะไกล

3. การจำกัดความเข้มข้นแบบอ่อน

เพื่อปรับปรุงความเสถียรในการฝึกอบรมและประสิทธิภาพ Gemma 2 นำเสนอกลไกการจำกัดความเข้มข้นแบบอ่อน:

<p>def soft_cap(x, cap):
return cap * torch.tanh(x / cap)</p>

<p># ใช้กับลอจิตของการให้ความสนใจ
attention_logits = soft_cap(attention_logits, cap=50.0)</p>

# ใช้กับลอจิตของชั้นสุดท้าย

<p>final_logits = soft_cap(final_logits, cap=30.0)

เทคนิคนี้ป้องกันไม่ให้ลอจิตเติบโตมากเกินไปโดยไม่ต้องตัดทอนอย่างเข้มงวด ทำให้รักษาข้อมูลได้มากขึ้นในขณะเดียวกันก็ทำให้กระบวนการฝึกอบรมมีเสถียรภาพ

1. Gemma 2 9B: โมเดล 9 พันล้านพารามิเตอร์
2. Gemma 2 27B: โมเดล 27 พันล้านพารามิเตอร์ที่ใหญ่กว่า

ทั้งสองขนาดมี 2 รูปแบบ:

• โมเดลฐาน: โมเดลที่ได้รับการฝึกอบรมล่วงหน้าบนข้อมูลข้อความจำนวนมาก
• โมเดลที่ได้รับการปรับให้เหมาะสมด้วยคำสั่ง (IT): โมเดลที่ได้รับการปรับให้เหมาะสมสำหรับการทำงานเฉพาะ

4. การถ่ายทอดความรู้

สำหรับโมเดล 9B Gemma 2 ใช้เทคนิคการถ่ายทอดความรู้:

• การฝึกอบรมล่วงหน้า: โมเดล 9B เรียนรู้จากโมเดลครูที่ใหญ่กว่าในช่วงการฝึกอบรมเริ่มต้น
• หลังการฝึกอบรม: ทั้งโมเดล 9B และ 27B ใช้การถ่ายทอดความรู้แบบนโยบายเพื่อปรับปรุงประสิทธิภาพ

กระบวนการนี้ช่วยให้โมเดลที่เล็กกว่าจับข้อมูลที่มีความสามารถของโมเดลที่ใหญ่กว่าได้อย่างมีประสิทธิภาพ

5. การรวมโมเดล

Gemma 2 ใช้เทคนิคการรวมโมเดลใหม่ๆ ที่เรียกว่า Warp ซึ่งรวมโมเดลหลายๆ โมเดลใน 3 ระยะ:

1. การหาค่าเฉลี่ยแบบเอ็กซ์โปเนนเชียลในช่วงการฝึกอบรมแบบการเสริมสร้าง
2. การอินเทอร์โพเลตแบบสเฟียร์เชิงเส้นหลังการฝึกอบรมนโยบายหลายๆ นโยบาย
3. การอินเทอร์โพเลตเชิงเส้นแบบลีนียร์ต่อการเริ่มต้นเป็นขั้นตอนสุดท้าย

แนวทางนี้มีจุดมุ่งหมายเพื่อสร้างโมเดลที่มีความสามารถและความแข็งแกร่งมากขึ้น

การประเมินประสิทธิภาพ

Gemma 2 แสดงผลการทำงานที่น่าประทับใจในหลายๆ การประเมิน:

Gemma 2 on a redesigned architecture, engineered for both exceptional performance and inference efficiency

การเริ่มต้นใช้งาน Gemma 2

เพื่อเริ่มต้นใช้งาน Gemma 2 ในโครงการของคุณ คุณมีหลายตัวเลือก:

1. Google AI Studio

สำหรับการทดลองอย่างรวดเร็วโดยไม่ต้องมีฮาร์ดแวร์ คุณสามารถเข้าถึง Gemma 2 ผ่าน Google AI Studio

2. Hugging Transformers

Gemma 2 ได้รับการผสานเข้ากับไลบรารี Hugging Face Transformers ที่ได้รับความนิยม ดังนี้:

<div class="relative flex flex-col rounded-lg">
<div class="text-text-300 absolute pl-3 pt-2.5 text-xs">

<p>from transformers import AutoTokenizer, AutoModelForCausalLM</p>

<p># โหลดโมเดลและโทเคไนเซอร์
model_name = &quot;google/gemma-2-27b-it&quot; # หรือ &quot;google/gemma-2-9b-it&quot; สำหรับเวอร์ชันที่เล็กกว่า
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)</p>

<p># เตรียมข้อมูลเข้า
prompt = &quot;อธิบายแนวคิดเรื่องควอนตัมเอนแทงเกิลม์แบบง่าย&quot;
inputs = tokenizer(prompt, return_tensors=&quot;pt&quot;)</p>

<p># สร้างข้อความ
outputs = model.generate(**inputs, max_length=200)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)</p>

print(response)

3. TensorFlow/Keras

สำหรับผู้ใช้ TensorFlow Gemma 2 มีให้ผ่าน Keras:

<p>import tensorflow as tf
from keras_nlp.models import GemmaCausalLM</p>

<p># โหลดโมเดล
model = GemmaCausalLM.from_preset(&quot;gemma_2b_en&quot;)</p>

<p># สร้างข้อความ
prompt = &quot;อธิบายแนวคิดเรื่องควอนตัมเอนแทงเกิลม์แบบง่าย&quot;
output = model.generate(prompt, max_length=200)</p>

print(output)

การใช้งานขั้นสูง: การสร้างระบบ RAG ท้องถิ่นด้วย Gemma 2

หนึ่งในแอปพลิเคชันที่มีประสิทธิภาพของ Gemma 2 คือการสร้างระบบการสร้างข้อความแบบ Retrieval Augmented Generation (RAG) มาทำระบบ RAG ท้องถิ่นแบบง่ายๆ โดยใช้ Gemma 2 และ Nomic embeddings

ขั้นตอนที่ 1: การตั้งค่าสภาพแวดล้อม

ก่อนอื่นให้แน่ใจว่าคุณได้ติดตั้งไลบรารีที่จำเป็น:

<p>pip install langchain ollama nomic chromadb</p>

ขั้นตอนที่ 2: การสร้างดัชนีเอกสาร

สร้างอินเดกเซอร์เพื่อประมวลผลเอกสารของคุณ:

<p>import os
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import DirectoryLoader
from langchain.vectorstores import Chroma
from langchain.embeddings import HuggingFaceEmbeddings</p>

<p>class Indexer:
def __init__(self, directory_path):
self.directory_path = directory_path
self.text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
self.embeddings = HuggingFaceEmbeddings(model_name=&quot;nomic-ai/nomic-embed-text-v1&quot;)</p>

<p>def load_and_split_documents(self):
loader = DirectoryLoader(self.directory_path, glob=&quot;**/*.txt&quot;)
documents = loader.load()
return self.text_splitter.split_documents(documents)</p>

<p>def create_vector_store(self, documents):
return Chroma.from_documents(documents, self.embeddings, persist_directory=&quot;./chroma_db&quot;)</p>

<p>def index(self):
documents = self.load_and_split_documents()
vector_store = self.create_vector_store(documents)
vector_store.persist()
return vector_store</p>

<p># การใช้งาน
indexer = Indexer(&quot;path/to/your/documents&quot;)
vector_store = indexer.index()</p>

ขั้นตอนที่ 3: การตั้งค่าระบบ RAG

ทีนี้ มาทำระบบ RAG โดยใช้ Gemma 2:

<p>from langchain.llms import Ollama
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate</p>

<p>class RAGSystem:
def __init__(self, vector_store):
self.vector_store = vector_store
self.llm = Ollama(model=&quot;gemma2:9b&quot;)
self.retriever = self.vector_store.as_retriever(search_kwargs={&quot;k&quot;: 3})</p>

<p>self.template = &quot;&quot;&quot;ใช้ข้อมูลต่อไปนี้เพื่อตอบคำถามที่สิ้นสุด
หากคุณไม่รู้คำตอบ ให้บอกว่าคุณไม่รู้ อย่าพยายามคิดคำตอบขึ้นมา</p>

{context}

<p>คำถาม: {question}
คำตอบ: &quot;&quot;&quot;</p>

<p>self.qa_prompt = PromptTemplate(
template=self.template, input_variables=[&quot;context&quot;, &quot;question&quot;]
)</p>

<p>self.qa_chain = RetrievalQA.from_chain_type(
llm=self.llm,
chain_type=&quot;stuff&quot;,
retriever=self.retriever,
return_source_documents=True,
chain_type_kwargs={&quot;prompt&quot;: self.qa_prompt}
)</p>

<p>def query(self, question):
return self.qa_chain({&quot;query&quot;: question})</p>

<p># การใช้งาน
rag_system = RAGSystem(vector_store)
response = rag_system.query(&quot;เมืองหลวงของฝรั่งเศสคืออะไร?&quot;)
print(response[&quot;result&quot;])</p>

ระบบ RAG นี้ใช้ Gemma 2 ผ่าน Ollama สำหรับโมเดลภาษา และ Nomic embeddings สำหรับการค้นหาเอกสาร ทำให้คุณสามารถถามคำถามตามเอกสารที่ดัชนีได้ โดยให้คำตอบพร้อมบริบทจากแหล่งที่เกี่ยวข้อง

การปรับให้เหมาะสมของ Gemma 2

สำหรับการใช้งานเฉพาะหรือโดเมน คุณอาจต้องการปรับให้เหมาะสมของ Gemma 2 ตัวอย่างพื้นฐานโดยใช้ไลบรารี Hugging Face Transformers:

from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer
from datasets import load_dataset

<p># โหลดโมเดลและโทเคไนเซอร์
model_name = &quot;google/gemma-2-9b-it&quot;
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)</p>

<p># เตรียมชุดข้อมูล
dataset = load_dataset(&quot;ชุดข้อมูลของคุณ&quot;)</p>

<p>def tokenize_function(examples):
return tokenizer(examples[&quot;text&quot;], padding=&quot;max_length&quot;, truncation=True)</p>

<p>tokenized_datasets = dataset.map(tokenize_function, batched=True)</p>

<p># ตั้งค่าการฝึกอบรม
training_args = TrainingArguments(
output_dir=&quot;./results&quot;,
num_train_epochs=3,
per_device_train_batch_size=4,
per_device_eval_batch_size=4,
warmup_steps=500,
weight_decay=0.01,
logging_dir=&quot;./logs&quot;,
)</p>

<p># เริ่มต้นการฝึกอบรม
trainer = Trainer(
model=model,
args=training_args,
train_dataset=tokenized_datasets[&quot;train&quot;],
eval_dataset=tokenized_datasets[&quot;test&quot;],
)</p>

# เริ่มต้นการฝึกอบรม
trainer.train()

<p># บันทึกโมเดลที่ปรับให้เหมาะสม
model.save_pretrained(&quot;./fine_tuned_gemma2&quot;)
tokenizer.save_pretrained(&quot;./fine_tuned_gemma2&quot;)</p>

จำเป็นต้องปรับพารามิเตอร์การฝึกอบรมตามความต้องการและทรัพยากรการคำนวณของคุณ

ข้อพิจารณาทางจริยธรรมและข้อจำกัด

แม้ว่า Gemma 2 จะมีความสามารถที่น่าประทับใจ แต่ก็มีข้อจำกัดและข้อพิจารณาทางจริยธรรมที่สำคัญ:

• อคติ: เช่นเดียวกับโมเดลภาษาอื่นๆ Gemma 2 อาจสะท้อนอคติที่มีอยู่ในข้อมูลการฝึกอบรมของมัน ตรวจสอบผลลัพธ์ของมันอย่างมีวิจารณญาณเสมอ
• ความถูกต้องของข้อเท็จจริง: แม้ว่า Gemma 2 จะมีความสามารถสูง แต่ก็อาจสร้างข้อมูลที่ไม่ถูกต้องหรือไม่สอดคล้องกัน ตรวจสอบข้อเท็จจริงที่สำคัญจากแหล่งที่เชื่อถือได้
• ความยาวบริบท: Gemma 2 มีความยาวบริบท 8192 โทเค็น สำหรับเอกสารหรือการสนทนาที่ยาวกว่า คุณอาจต้องใช้กลยุทธ์ในการจัดการบริบทอย่างมีประสิทธิภาพ
• ทรัพยากรการคำนวณ: โดยเฉพาะสำหรับโมเดล 27B อาจต้องใช้ทรัพยากรการคำนวณที่มากสำหรับการอนุมานและปรับให้เหมาะสมอย่างมีประสิทธิภาพ
• การใช้งานอย่างรับผิดชอบ: ปฏิบัติตามแนวปฏิบัติ AI ที่รับผิดชอบของ Google และให้แน่ใจว่าการใช้งาน Gemma 2 ของคุณสอดคล้องกับหลักการ AI ที่มีจริยธรรม

สรุป

คุณสมบัติขั้นสูงของ Gemma 2 เช่น การให้ความสนใจแบบสไลด์วินโดว์ การจำกัดความเข้มข้นแบบอ่อน และเทคนิคการรวมโมเดลใหม่ๆ ทำให้เป็นเครื่องมือที่มีประสิทธิภาพสำหรับการประมวลผลภาษาที่หลากหลาย

โดยการใช้ Gemma 2 ในโครงการของคุณ ไม่ว่าจะผ่านการอนุมานอย่างง่าย ระบบ RAG ที่ซับซ้อน หรือโมเดลที่ปรับให้เหมาะสมสำหรับโดเมนเฉพาะ คุณสามารถใช้พลังของ AI ที่มีประสิทธิภาพสูงสุดในขณะเดียวกันก็ควบคุมข้อมูลและกระบวนการของคุณได้