2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
Gemma 2 S'appuyant sur son prédécesseur, il offre des performances et une efficacité améliorées, ainsi qu'une gamme de fonctionnalités innovantes, ce qui le rend particulièrement attractif pour la recherche et les applications pratiques. Ce qui distingue le Gemma 2, c'est qu'il offre des performances comparables à celles des modèles propriétaires plus grands, mais avecprogicielConçu pour une accessibilité plus large et une utilisation sur des configurations matérielles plus modestes.
Au fur et à mesure que je me penche sur les spécifications techniques et l'architecture de Gemma 2, je suis de plus en plus impressionné par la sophistication de sa conception.Le modèle intègre une variété de technologies avancées, notamment de nouvellesmécanisme d'attentionet des méthodes innovantes de stabilité d'entraînement, qui contribuent toutes à ses performances exceptionnelles.
Dans ce guide complet, Gemma 2 sera exploré en profondeur, en examinant son architecture, ses fonctionnalités clés et ses applications pratiques. Que vous soyez un praticien expérimenté de l'IA ou un débutant enthousiaste dans le domaine, cet article vise à fournir des informations précieuses sur le fonctionnement de Gemma 2 et sur la manière dont vous pouvez exploiter ses capacités dans vos propres projets.
Gemma 2 est le dernier open source à grande échelle de Googlemodèle de langage , superbement conçu mais puissant. Il s'appuie sur les mêmes recherches et technologies que celles utilisées pour créer les modèles Google Gemini, offrant des performances de pointe dans un package plus accessible. Gemma 2 est disponible en deux tailles :
Gemma 2 9B: Un modèle à 9 milliards de paramètres
Gemma 2 27B: Un modèle plus grand de 27 milliards de paramètres
Chaque taille est disponible en deux styles :
modèle de base: Pré-formation sur de grandes quantités de données textuelles
Modèle de réglage des instructions (IT): Affiné pour de meilleures performances sur des tâches spécifiques
Accéder aux modèles dans Google AI Studio：Google AI Studio – Gemma 2
Lire le journal ici: Rapport technique de Gemma 2
Gemma 2 introduit plusieurs améliorations significatives par rapport à son prédécesseur :
Ces modèles ont été formés sur plus de données :
Gemma 2 27B: Après une formation avec 13 000 milliards de jetons
Gemma 2 9B: Après une formation avec 8 000 milliards de jetons
Cet ensemble de données étendu se compose principalement de données réseau (principalement en anglais), de code et de mathématiques, contribuant ainsi à améliorer les performances et la polyvalence de vos modèles.
Gemma 2 implémente une nouvelle méthode de mécanisme d'attention :
Toutes les autres couches utilisent un mécanisme d'attention à fenêtre glissante et le contexte local est de 4 096 jetons.
La couche alternée adopte un mécanisme d'attention global entièrement quadratique pour l'ensemble du contexte du jeton 8192.
Cette approche hybride vise à équilibrer l’efficacité avec la capacité de capturer les dépendances à long terme dans l’entrée.
Afin d'améliorer la stabilité et les performances de l'entraînement, Gemma 2 introduit un mécanisme de limite supérieure souple :
def soft_cap(x, cap):
return cap * torch.tanh(x / cap)
# Applied to attention logits
attention_logits = soft_cap(attention_logits, cap=50.0)
# Applied to final layer logits
final_logits = soft_cap(final_logits, cap=30.0)
Cette technique empêche les logits de devenir trop volumineux sans troncature dure, conservant ainsi plus d'informations tout en stabilisant le processus de formation.
Chaque taille est disponible en deux styles :
Pour le modèle 9B, Gemma 2 utilise la technologie d'extraction de connaissances :
Ce processus permet au modèle plus petit de capturer plus efficacement les fonctionnalités du modèle plus grand.
Gemma 2 utilise une nouvelle technologie de fusion de modèles appelée Warp, qui combine plusieurs modèles en trois étapes :
Cette approche vise à créer un modèle final plus robuste et robuste.
Gemma 2 démontre des performances impressionnantes sur une variété de critères :
Gemma 2 présente une architecture repensée conçue pour des performances et une efficacité d'inférence supérieures
Pour commencer à utiliser Gemma 2 dans vos projets, vous disposez des options suivantes :
Gemma 2 est accessible via Google AI Studio,Studio d'intelligence artificielle de Google.
Gemma 2 et visage câlin Intégration de la bibliothèque Transformers. Voici comment l'utiliser :
<div class="relative flex flex-col rounded-lg">
<div class="text-text-300 absolute pl-3 pt-2.5 text-xs">
from transformers import AutoTokenizer, AutoModelForCausalLM
# Load the model and tokenizer
model_name = "google/gemma-2-27b-it" # or "google/gemma-2-9b-it" for the smaller version
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)
# Prepare input
prompt = "Explain the concept of quantum entanglement in simple terms."
inputs = tokenizer(prompt, return_tensors="pt")
# Generate text
outputs = model.generate(**inputs, max_length=200)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)
Pour les utilisateurs de TensorFlow, Gemma 2 est disponible via Keras :
import tensorflow as tf
from keras_nlp.models import GemmaCausalLM
# Load the model
model = GemmaCausalLM.from_preset("gemma_2b_en")
# Generate text
prompt = "Explain the concept of quantum entanglement in simple terms."
output = model.generate(prompt, max_length=200)
print(output)
Une application puissante de Gemma 2 consiste à créer des systèmes de génération augmentée par récupération (RAG). Créons un système RAG simple et entièrement natif en utilisant les intégrations Gemma 2 et Nomic.
Tout d’abord, assurez-vous que les bibliothèques nécessaires sont installées :
pip install langchain ollama nomic chromadb
Créez un indexeur pour traiter les documents :
import os
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import DirectoryLoader
from langchain.vectorstores import Chroma
from langchain.embeddings import HuggingFaceEmbeddings
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")
def load_and_split_documents(self):
loader = DirectoryLoader(self.directory_path, glob="**/*.txt")
documents = loader.load()
return self.text_splitter.split_documents(documents)
def create_vector_store(self, documents):
return Chroma.from_documents(documents, self.embeddings, persist_directory="./chroma_db")
def index(self):
documents = self.load_and_split_documents()
vector_store = self.create_vector_store(documents)
vector_store.persist()
return vector_store
# Usage
indexer = Indexer("path/to/your/documents")
vector_store = indexer.index()
Maintenant, créez le système RAG en utilisant Gemma 2 :
from langchain.llms import Ollama
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate
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})
self.template = """Use the following pieces of context to answer the question at the end.
If you don't know the answer, just say that you don't know, don't try to make up an answer.
{context}
Question: {question}
Answer: """
self.qa_prompt = PromptTemplate(
template=self.template, input_variables=["context", "question"]
)
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}
)
def query(self, question):
return self.qa_chain({"query": question})
# Usage
rag_system = RAGSystem(vector_store)
response = rag_system.query("What is the capital of France?")
print(response["result"])
Ce système RAG utilise Gemma 2 pour Ollama comme modèle de langage et l'intégration Nomic pour la récupération de documents. Il vous permet de poser des questions basées sur des documents indexés et de fournir des réponses contextuelles provenant de sources pertinentes.
Pour des tâches ou des domaines spécifiques, vous devrez peut-être affiner Gemma 2. Voici un exemple de base utilisant la bibliothèque Hugging Face Transformers :
from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer
from datasets import load_dataset
# Load model and tokenizer
model_name = "google/gemma-2-9b-it"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)
# Prepare dataset
dataset = load_dataset("your_dataset")
def tokenize_function(examples):
return tokenizer(examples["text"], padding="max_length", truncation=True)
tokenized_datasets = dataset.map(tokenize_function, batched=True)
# Set up training arguments
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",
)
# Initialize Trainer
trainer = Trainer(
model=model,
args=training_args,
train_dataset=tokenized_datasets["train"],
eval_dataset=tokenized_datasets["test"],
)
# Start fine-tuning
trainer.train()
# Save the fine-tuned model
model.save_pretrained("./fine_tuned_gemma2")
tokenizer.save_pretrained("./fine_tuned_gemma2")
Ajustez les paramètres de formation en fonction des exigences spécifiques et des ressources informatiques.
Bien que Gemma 2 offre des fonctionnalités impressionnantes, il faut être conscient de ses limites et considérations éthiques :
Les fonctionnalités avancées de Gemma 2, telles que l'attention par fenêtre coulissante, les limites supérieures souples et les nouvelles techniques de fusion de modèles, en font un outil puissant pour un large éventail de tâches de traitement du langage naturel.
En tirant parti de Gemma 2 dans vos projets, que ce soit par le biais d'une simple inférence, de systèmes RAG complexes ou de modèles affinés spécifiques à un domaine, vous pouvez exploiter la puissance de SOTA AI tout en gardant le contrôle de vos données et processus.
Adresse d'origine :https://www.unite.ai/guide-complet-sur-le-nouveau-modele-de-langage-ouvert-de-gemma-2-de-google/
Il se consacre à la recherche technologique depuis plus de 30 ans et maîtrise divers langages tels que java, linux, javascript, php, css, etc. Il a apporté de nombreuses contributions dans le domaine de l'open source. station de documentation pour les développeurs pour partager certains problèmes de développement technologique pour référence future.
