AI-modeller og platforme
Komplet vejledning til Gemma 2: Googles nye åbne stor sprogmodel
Føj Unite.AI til dine foretrukne kilder på Google
Gemma 2 bygger videre på sin forgænger og tilbyder forbedret ydelse og effektivitet samt en række innovative funktioner, der gør den særligt attraktiv for både forskning og praktiske anvendelser. Det, der adskiller Gemma 2 fra andre modeller, er dens evne til at levere ydelse, der er sammenlignelig med meget større proprietære modeller, men i en pakke, der er designet til bredere tilgængelighed og brug på mere beskeden hardware.
Da jeg dykkede ned i de tekniske specifikationer og arkitekturen af Gemma 2, blev jeg mere og mere imponeret over designets ingeniøritet. Modellen inkorporerer flere avancerede teknikker, herunder nytænkede opmærksomhedsmechanismer og innovative tilgange til træningsstabilitet, der bidrager til dens bemærkelsesværdige evner.
Google [securities_stock_price_tag symbol="GOOGL" exchange="NASDAQ"] Open Source LLM Gemma
I denne omfattende vejledning vil vi udforske Gemma 2 i dybden, hvor vi undersøger dens arkitektur, nøglefunktioner og praktiske anvendelser. Uanset om du er en erfaren AI-praktiker eller en entusiastisk nybegynder i feltet, har denne artikel til formål at give værdifulde indsighter i, hvordan Gemma 2 fungerer, og hvordan du kan udnytte dens kraft i dine egne projekter.
Hvad er Gemma 2?
Gemma 2 er Googles nyeste åbne sprogmodel, designet til at være letvægts og kraftfuld. Den er bygget på samme forskning og teknologi, der blev brugt til at skabe Googles Gemini-modeller, og tilbyder state-of-the-art-ydelse i en mere tilgængelig pakke. Gemma 2 findes i to størrelser:
Gemma 2 9B: En model med 9 milliarder parametre
Gemma 2 27B: En større model med 27 milliarder parametre
Hver størrelse er tilgængelig i to varianter:
Base-modeller: Forudtrænet på en enorm mængde tekstdata
Instruction-tuned (IT)-modeller: Finjusteret for bedre ydelse på specifikke opgaver
Adgang til modellerne i Google AI Studio: Google AI Studio – Gemma 2
Læs rapporten her: Gemma 2 Teknisk Rapport
Nøglefunktioner og forbedringer
Gemma 2 introducerer flere betydelige forbedringer over for sin forgænger:
1. Forøget træningsdata
Modellerne er trænet på væsentligt mere data:
Gemma 2 27B: Trænet på 13 billioner tokens
Gemma 2 9B: Trænet på 8 billioner tokens
Denne udvidede dataset, der primært består af webdata (overvejende engelsk), kode og matematik, bidrager til modellernes forbedrede ydelse og fleksibilitet.
2. Sliding Window Attention
Gemma 2 implementerer en ny tilgang til opmærksomhedsmechanismer:
Hver anden lag bruger en sliding window attention med en lokal kontekst på 4096 tokens
Alternativt lag anvender fuld kvadratisk global attention på hele 8192 token konteksten
Denne hybride tilgang sigter mod at balancere effektivitet med evnen til at fange lange afhængigheder i input.
3. Soft-Capping
For at forbedre træningsstabiliteten og ydelsen introducerer Gemma 2 en soft-capping-mekanisme:
<p>def soft_cap(x, cap): return cap * torch.tanh(x / cap)</p> <p># Anvendt på attention logits attention_logits = soft_cap(attention_logits, cap=50.0)</p> # Anvendt på sidste lag logits <p>final_logits = soft_cap(final_logits, cap=30.0)
Denne teknik forhindrer, at logits vokser for stort uden hård afkorting, og opretholder mere information samtidig med, at den stabiliserer træningsprocessen.
- Gemma 2 9B: En model med 9 milliarder parametre
- Gemma 2 27B: En større model med 27 milliarder parametre
Hver størrelse er tilgængelig i to varianter:
- Base-modeller: Forudtrænet på en enorm mængde tekstdata
- Instruction-tuned (IT)-modeller: Finjusteret for bedre ydelse på specifikke opgaver
4. Knowledge Distillation
For 9B-modellen anvender Gemma 2 knowledge distillation-teknikker:
- Forudtræning: 9B-modellen lærer af en større lærermodel under initialtræning
- Eftertræning: Både 9B og 27B-modellerne anvender on-policy distillation til at forfine deres ydelse
Denne proces hjælper den mindre model med at fange de større modellers evner mere effektivt.
5. Model Merging
Gemma 2 anvender en ny model-merging-teknik kaldet Warp, der kombinerer flere modeller i tre faser:
- Exponential Moving Average (EMA) under forstærket træning
- Spherical Linear intERPolation (SLERP) efter finjustering af flere politikker
- Linear Interpolation Towards Initialization (LITI) som sidste trin
Denne tilgang sigter mod at skabe en mere robust og kapabel endelig model.
Ydelsesbenchmarks
Gemma 2 demonstrerer imponerende ydelse på tværs af forskellige benchmarks:
Gemma 2 på en genopbygget arkitektur, designet til både exceptionel ydelse og inferens-effektivitet
Kom i gang med Gemma 2
For at komme i gang med Gemma 2 i dine projekter har du flere muligheder:
1. Google AI Studio
Til hurtig eksperimentering uden hardwarekrav kan du få adgang til Gemma 2 gennem Google AI Studio.
2. Hugging Transformers
Gemma 2 er integreret med den populære Hugging Face Transformers-bibliotek. Her er, hvordan du kan bruge det:
<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># Indlæs model og tokenizer model_name = "google/gemma-2-27b-it" # eller "google/gemma-2-9b-it" for den mindre version tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained(model_name)</p> <p># Forbered input prompt = "Forklar begrebet kvantum-entanglement på en simpel måde." inputs = tokenizer(prompt, return_tensors="pt")</p> <p># Generer tekst outputs = model.generate(**inputs, max_length=200) response = tokenizer.decode(outputs[0], skip_special_tokens=True)</p> print(response)
3. TensorFlow/Keras
For TensorFlow-brugere er Gemma 2 tilgængelig gennem Keras:
<p>import tensorflow as tf from keras_nlp.models import GemmaCausalLM</p> <p># Indlæs model model = GemmaCausalLM.from_preset("gemma_2b_en")</p> <p># Generer tekst prompt = "Forklar begrebet kvantum-entanglement på en simpel måde." output = model.generate(prompt, max_length=200)</p> print(output)
Avanceret brug: Bygning af et lokal RAG-system med Gemma 2
En af de kraftfulde anvendelser af Gemma 2 er i bygning af et Retrieval Augmented Generation (RAG)-system. Lad os oprette et simpelt, fuldt lokalt RAG-system ved hjælp af Gemma 2 og Nomic-embeddings.
Trin 1: Opsætning af miljøet
Først sikre, at du har de nødvendige biblioteker installeret:
<p>pip install langchain ollama nomic chromadb</p>
Trin 2: Indeksning af dokumenter
Opret en indexer til at behandle dine dokumenter:
<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="nomic-ai/nomic-embed-text-v1")</p> <p>def load_and_split_documents(self): loader = DirectoryLoader(self.directory_path, glob="**/*.txt") 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="./chroma_db")</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># Brug indexer = Indexer("stien til dine dokumenter") vector_store = indexer.index()</p>
Trin 3: Opsætning af RAG-systemet
Nu lad os oprette RAG-systemet ved hjælp af 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="gemma2:9b")
self.retriever = self.vector_store.as_retriever(search_kwargs={"k": 3})</p>
<p>self.template = """Brug følgende kontekst til at besvare spørgsmålet i slutningen.
Hvis du ikke kender svaret, så sig blot, at du ikke ved det, prøv ikke at opfinde et svar.</p>
{context}
<p>Spørgsmål: {question}
Svar: """</p>
<p>self.qa_prompt = PromptTemplate(
template=self.template, input_variables=["context", "question"]
)</p>
<p>self.qa_chain = RetrievalQA.from_chain_type(
llm=self.llm,
chain_type="stuff",
retriever=self.retriever,
return_source_documents=True,
chain_type_kwargs={"prompt": self.qa_prompt}
)</p>
<p>def query(self, question):
return self.qa_chain({"query": question})</p>
<p># Brug
rag_system = RAGSystem(vector_store)
response = rag_system.query("Hvad er hovedstaden i Frankrig?")
print(response["result"])</p>
Dette RAG-system anvender Gemma 2 gennem Ollama til sprogmodellen og Nomic-embeddings til dokumenthenting. Det tillader dig at stille spørgsmål baseret på de indekserede dokumenter og giver svar med kontekst fra de relevante kilder.
Fine-tuning af Gemma 2
Til bestemte opgaver eller domæner kan du måske ønske at fine-tune Gemma 2. Her er et grundlæggende eksempel ved hjælp af Hugging Face Transformers-biblioteket:
from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer from datasets import load_dataset <p># Indlæs model og tokenizer model_name = "google/gemma-2-9b-it" tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained(model_name)</p> <p># Forbered dataset dataset = load_dataset("dit_dataset")</p> <p>def tokenize_function(examples): return tokenizer(examples["text"], padding="max_length", truncation=True)</p> <p>tokenized_datasets = dataset.map(tokenize_function, batched=True)</p> <p># Indstil træningsargumenter training_args = TrainingArguments( output_dir="./results", 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="./logs", )</p> <p># Initialiser Trainer trainer = Trainer( model=model, args=training_args, train_dataset=tokenized_datasets["train"], eval_dataset=tokenized_datasets["test"], )</p> # Start fine-tuning trainer.train() <p># Gem den fine-tuned model model.save_pretrained("./fine_tuned_gemma2") tokenizer.save_pretrained("./fine_tuned_gemma2")</p>
Husk at tilpasse træningsparametrene efter dine specifikke behov og beregningsressourcer.
Etiske overvejelser og begrænsninger
Selvom Gemma 2 tilbyder imponerende evner, er det vigtigt at være opmærksom på dens begrænsninger og etiske overvejelser:
- Forudindtagethed: Ligesom alle sprogmodeller kan Gemma 2 reflektere forudindtagetheder, der er til stede i dens træningsdata. Vurder altid kritisk dens output.
- Faktuel nøjagtighed: Selvom den er meget kapabel, kan Gemma 2 nogen gange generere forkert eller inkonsistent information. Verificer vigtige fakta fra pålidelige kilder.
- Kontekstlængde: Gemma 2 har en kontekstlængde på 8192 tokens. For længere dokumenter eller samtaler kan du måske være nødt til at implementere strategier til at håndtere kontekst effektivt.
- Beregningsressourcer: Især for 27B-modellen kan betydelige beregningsressourcer være nødvendige for effektiv inferens og fine-tuning.
- Ansvarlig brug: Overhold Googles ansvarlige AI-praktikker og sikr, at din brug af Gemma 2 er i overensstemmelse med etiske AI-principper.
Konklusion
Gemma 2s avancerede funktioner som sliding window attention, soft-capping og nye model-merging-teknikker gør den til et kraftfuldt værktøj til en bred vifte af naturligsprogsbehandlingsopgaver.
Ved at udnytte Gemma 2 i dine projekter, enten gennem simpel inferens, komplekse RAG-systemer eller fine-tuned modeller til specifikke domæner, kan du tappe ind i kraften af SOTA AI, samtidig med at du opretholder kontrol over dine data og processer.
