Inteligencia Artificial
Guía completa sobre Gemma 2: el nuevo modelo abierto de lenguaje grande de Google
Gemma 2 Se basa en su predecesor, ofreciendo un rendimiento y una eficiencia mejorados, junto con un conjunto de características innovadoras que lo hacen especialmente atractivo tanto para la investigación como para aplicaciones prácticas. Lo que distingue a Gemma 2 es su capacidad para ofrecer un rendimiento comparable al de modelos propietarios mucho más grandes, pero en un paquete diseñado para una mayor accesibilidad y uso en configuraciones de hardware más modestas.
Mientras profundizaba en las especificaciones técnicas y la arquitectura de Gemma 2, me impresionó cada vez más el ingenio de su diseño. El modelo incorpora varias técnicas avanzadas, incluidos mecanismos de atención novedosos y enfoques innovadores para el entrenamiento de estabilidad, que contribuyen a sus notables capacidades.
LLM de código abierto de Google Gemma
En esta guía completa, exploraremos Gemma 2 a fondo, examinando su arquitectura, características clave y aplicaciones prácticas. Tanto si eres un experto en IA como si eres un principiante entusiasta en el campo, este artículo busca ofrecerte información valiosa sobre el funcionamiento de Gemma 2 y cómo puedes aprovechar su potencial en tus propios proyectos.
¿Qué es Gemma 2?
Gemma 2 es el nuevo modelo de lenguaje grande de código abierto de Google, diseñado para ser ligero pero potente. Se basa en la misma investigación y tecnología empleadas para crear los modelos Gemini de Google, ofreciendo un rendimiento de vanguardia en un formato más accesible. Gemma 2 está disponible en dos tamaños:
Gema 2 9B: Un modelo de 9 mil millones de parámetros
Gema 2 27B: Un modelo más grande de 27 mil millones de parámetros
Cada tamaño está disponible en dos variantes:
Modelos base: Pre-entrenado en un vasto corpus de datos de texto
Modelos adaptados a instrucciones (IT): Ajustado para un mejor rendimiento en tareas específicas
Accede a los modelos en Google AI Studio: Estudio de IA de Google – Gemma 2
Lea el artículo aquí: Informe técnico Gemma 2
Características y mejoras clave
Gemma 2 introduce varios avances significativos respecto a su predecesor:
1. Mayores datos de entrenamiento
Los modelos se han entrenado con muchos más datos:
Gema 2 27B: Entrenado con 13 billones de tokens
Gema 2 9B: Entrenado con 8 billones de tokens
Este conjunto de datos ampliado, que se compone principalmente de datos web (principalmente en inglés), código y matemáticas, contribuye a mejorar el rendimiento y la versatilidad de los modelos.
2. Atención de ventana corrediza
Gemma 2 implementa un enfoque novedoso para los mecanismos de atención:
Todas las demás capas utilizan una atención de ventana deslizante con un contexto local de 4096 tokens.
Las capas alternas emplean atención global cuadrática completa en todo el contexto del token 8192
Este enfoque híbrido tiene como objetivo equilibrar la eficiencia con la capacidad de capturar dependencias de largo alcance en la entrada.
3. Tapa blanda
Para mejorar la estabilidad y el rendimiento del entrenamiento, Gemma 2 introduce un mecanismo de limitación suave:
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)
Esta técnica evita que los logits crezcan excesivamente sin un truncamiento estricto, manteniendo más información mientras estabiliza el proceso de entrenamiento.
- Gema 2 9B: Un modelo de 9 mil millones de parámetros
- Gema 2 27B: Un modelo más grande de 27 mil millones de parámetros
Cada tamaño está disponible en dos variantes:
- Modelos base: previamente entrenados en un vasto corpus de datos de texto
- Modelos ajustados por instrucción (TI): ajustados para un mejor rendimiento en tareas específicas
4. Destilación del conocimiento
Para el modelo 9B, Gemma 2 emplea técnicas de destilación de conocimientos:
- Capacitación previa: el modelo 9B aprende de un modelo docente más amplio durante la capacitación inicial
- Post-entrenamiento: Tanto el modelo 9B como el 27B utilizan destilación basada en políticas para refinar su rendimiento.
Este proceso ayuda al modelo más pequeño a capturar las capacidades de los modelos más grandes de manera más efectiva.
5. Fusión de modelos
Gemma 2 utiliza una novedosa técnica de fusión de modelos llamada Warp, que combina múltiples modelos en tres etapas:
- Media móvil exponencial (EMA) durante el ajuste del aprendizaje por refuerzo
- Interpolación lineal esférica (SLERP) después de ajustar múltiples políticas
- Interpolación lineal hacia la inicialización (LITI) como paso final
Este enfoque tiene como objetivo crear un modelo final más robusto y capaz.
Puntos de referencia de rendimiento
Gemma 2 demuestra un rendimiento impresionante en varios puntos de referencia:
Gemma 2 en una arquitectura rediseñada, diseñada para un rendimiento excepcional y eficiencia de inferencia
Comenzando con Gemma 2
Para empezar a utilizar Gemma 2 en tus proyectos, tienes varias opciones:
1. Estudio de IA de Google
Para una experimentación rápida sin requisitos de hardware, puede acceder a Gemma 2 a través de Estudio de IA de Google.
2. Transformadores de cara abrazada
Gemma 2 se integra con el popular Abrazando la cara Biblioteca de Transformers. Cómo usarla:
<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)
3. TensorFlow/Keras
Para los usuarios de TensorFlow, Gemma 2 está disponible a través de 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)
Uso avanzado: construcción de un sistema RAG local con Gemma 2
Una aplicación potente de Gemma 2 es la creación de un sistema de Generación Aumentada por Recuperación (RAG). Creemos un sistema RAG simple y completamente local utilizando Gemma 2 e incrustaciones nómicas.
Paso 1: configurar el entorno
Primero, asegúrese de tener instaladas las bibliotecas necesarias:
pip install langchain ollama nomic chromadb
Paso 2: indexación de documentos
Cree un indexador para procesar sus documentos:
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()
Paso 3: Configurar el sistema RAG
Ahora, vamos a crear el sistema RAG usando 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"])
Este sistema RAG utiliza Gemma 2 a través de Ollama para el modelo de lenguaje e incrustaciones de Nomic para la recuperación de documentos. Le permite hacer preguntas basadas en los documentos indexados, proporcionando respuestas con contexto de las fuentes relevantes.
Afinando Gemma 2
Para tareas o dominios específicos, es posible que desees ajustar Gemma 2. Aquí hay un ejemplo básico que utiliza la biblioteca 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")
Recuerde ajustar los parámetros de entrenamiento en función de sus requisitos específicos y recursos computacionales.
Consideraciones y limitaciones éticas
Si bien Gemma 2 ofrece capacidades impresionantes, es fundamental tener en cuenta sus limitaciones y consideraciones éticas:
- Parcialidad: Como todos los modelos de lenguaje, Gemma 2 puede reflejar sesgos presentes en sus datos de entrenamiento. Evalúe siempre críticamente sus resultados.
- Exactitud de los hechos: Si bien es muy capaz, Gemma 2 a veces puede generar información incorrecta o inconsistente. Verifique hechos importantes de fuentes confiables.
- Longitud del contexto: Gemma 2 tiene una longitud de contexto de 8192 tokens. Para documentos o conversaciones más largas, es posible que necesite implementar estrategias para gestionar el contexto de forma eficaz.
- Recursos Computacionales: Especialmente para el modelo 27B, es posible que se requieran importantes recursos computacionales para una inferencia y un ajuste eficientes.
- Uso Responsable:Adhiérase a las prácticas de IA responsable de Google y asegúrese de que su uso de Gemma 2 esté alineado con los principios éticos de IA.
Conclusión
Las funciones avanzadas de Gemma 2, como la atención de ventanas deslizantes, la limitación suave y las novedosas técnicas de fusión de modelos, la convierten en una herramienta poderosa para una amplia gama de tareas de procesamiento del lenguaje natural.
Al aprovechar Gemma 2 en sus proyectos, ya sea a través de inferencia simple, sistemas RAG complejos o modelos ajustados para dominios específicos, puede aprovechar el poder de SOTA AI mientras mantiene el control sobre sus datos y procesos.
