Guía Completa sobre Gemma 2: El Nuevo Modelo de Lenguaje Abierto de Google

Gemma 2 se basa en su predecesor, ofreciendo un rendimiento y eficiencia mejorados, junto con una suite de características innovadoras que lo hacen particularmente atractivo tanto para aplicaciones de investigación como prácticas. Lo que distingue a Gemma 2 es su capacidad para ofrecer un rendimiento comparable a modelos propietarios mucho más grandes, pero en un paquete diseñado para una accesibilidad y uso más amplios en configuraciones de hardware más modestas.

Al profundizar en las especificaciones técnicas y la arquitectura de Gemma 2, me impresionó cada vez más la ingeniosidad de su diseño. El modelo incorpora varias técnicas avanzadas, incluyendo mecanismos de atención novedosos y enfoques innovadores para la estabilidad del entrenamiento, que contribuyen a sus capacidades notables.

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

En esta guía completa, exploraremos Gemma 2 en profundidad, examinando su arquitectura, características clave y aplicaciones prácticas. Ya sea que seas un practicante de AI experimentado o un entusiasta recién llegado al campo, este artículo tiene como objetivo proporcionar valiosas perspectivas sobre cómo funciona Gemma 2 y cómo puedes aprovechar su poder en tus propios proyectos.

¿Qué es Gemma 2?

Gemma 2 es el nuevo modelo de lenguaje abierto de Google, diseñado para ser ligero pero poderoso. Se basa en la misma investigación y tecnología utilizada para crear los modelos Gemini de Google, ofreciendo un rendimiento de vanguardia en un paquete más accesible. Gemma 2 viene en dos tamaños:

Gemma 2 9B: Un modelo de 9 mil millones de parámetros
Gemma 2 27B: Un modelo más grande de 27 mil millones de parámetros

Cada tamaño está disponible en dos variantes:

Modelos base: Preentrenados en un vasto corpus de datos de texto
Modelos ajustados a instrucciones (IT): Ajustados para un mejor rendimiento en tareas específicas

Accede a los modelos en Google AI Studio: Google AI Studio – Gemma 2

Lee el informe técnico aquí: Informe Técnico de Gemma 2

Características clave y mejoras

Gemma 2 introduce varias mejoras significativas sobre su predecesor:

1. Datos de entrenamiento aumentados

Los modelos han sido entrenados con mucho más datos:

Gemma 2 27B: Entrenado con 13 billones de tokens
Gemma 2 9B: Entrenado con 8 billones de tokens

Este conjunto de datos expandido, que consiste principalmente en datos web (en su mayoría en inglés), código y matemáticas, contribuye al mejor rendimiento y versatilidad de los modelos.

2. Atención con ventana deslizante

Gemma 2 implementa un enfoque novedoso para los mecanismos de atención:

Cada otra capa utiliza una atención con ventana deslizante con un contexto local de 4096 tokens
Las capas alternas emplean una atención global cuadrática completa en todo el contexto de 8192 tokens

Este enfoque híbrido busca equilibrar la eficiencia con la capacidad de capturar dependencias a largo plazo en la entrada.

3. Limitación suave

Para mejorar la estabilidad y el rendimiento del entrenamiento, Gemma 2 introduce un mecanismo de limitación suave:

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

<p># Aplicado a los logits de atención
attention_logits = soft_cap(attention_logits, cap=50.0)</p>

# Aplicado a los logits de la capa final

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

Esta técnica evita que los logits crezcan excesivamente grandes sin truncación dura, manteniendo más información mientras estabiliza el proceso de entrenamiento.

1. Gemma 2 9B: Un modelo de 9 mil millones de parámetros
2. Gemma 2 27B: Un modelo más grande de 27 mil millones de parámetros

Cada tamaño está disponible en dos variantes:

• Modelos base: Preentrenados en un vasto corpus de datos de texto
• Modelos ajustados a instrucciones (IT): Ajustados para un mejor rendimiento en tareas específicas

4. Destilación de conocimiento

Para el modelo de 9B, Gemma 2 emplea técnicas de destilación de conocimiento:

• Preentrenamiento: El modelo de 9B aprende de un modelo docente más grande durante el entrenamiento inicial
• Postentrenamiento: Tanto el modelo de 9B como el de 27B utilizan la destilación de política 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 técnica de fusión de modelos llamada Warp, que combina múltiples modelos en tres etapas:

1. Promedio móvil exponencial (EMA) durante el ajuste fino de aprendizaje por refuerzo
2. Interpolación lineal esférica (SLERP) después del ajuste fino de múltiples políticas
3. Interpolación lineal hacia la inicialización (LITI) como paso final

Este enfoque busca crear un modelo final más robusto y capaz.

Benchmarks de rendimiento

Gemma 2 demuestra un rendimiento impresionante en varios benchmarks:

Gemma 2 en una arquitectura rediseñada, diseñada para un rendimiento y eficiencia de inferencia excepcionales

Empezando con Gemma 2

Para empezar a usar Gemma 2 en tus proyectos, tienes varias opciones:

1. Google AI Studio

Para experimentar rápidamente sin requisitos de hardware, puedes acceder a Gemma 2 a través de Google AI Studio.

2. Hugging Transformers

Gemma 2 está integrado con la biblioteca popular Hugging Face Transformers. Aquí te muestro cómo puedes usarlo:

<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># Carga el modelo y el tokenizador
model_name = &quot;google/gemma-2-27b-it&quot; # o &quot;google/gemma-2-9b-it&quot; para la versión más pequeña
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)</p>

<p># Prepara la entrada
prompt = &quot;Explica el concepto de entrelazamiento cuántico en términos sencillos.&quot;
inputs = tokenizer(prompt, return_tensors=&quot;pt&quot;)</p>

<p># Genera texto
outputs = model.generate(**inputs, max_length=200)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)</p>

print(response)

3. TensorFlow/Keras

Para los usuarios de TensorFlow, Gemma 2 está disponible a través de Keras:

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

<p># Carga el modelo
model = GemmaCausalLM.from_preset(&quot;gemma_2b_en&quot;)</p>

<p># Genera texto
prompt = &quot;Explica el concepto de entrelazamiento cuántico en términos sencillos.&quot;
output = model.generate(prompt, max_length=200)</p>

print(output)

Uso avanzado: Construyendo un sistema RAG local con Gemma 2

Una de las aplicaciones más poderosas de Gemma 2 es en la construcción de un sistema de Generación de Texto con Recuperación de Información (RAG). Crearemos un sistema RAG local simple utilizando Gemma 2 y embeddings de Nomic.

Paso 1: Configuración del entorno

Primero, asegúrate de tener las bibliotecas necesarias instaladas:

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

Paso 2: Indexación de documentos

Crea un indexador para procesar tus documentos:

<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># Uso
indexer = Indexer(&quot;path/to/your/documents&quot;)
vector_store = indexer.index()</p>

Paso 3: Configuración del sistema RAG

Ahora, crearemos el sistema RAG utilizando 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;Usa el siguiente contexto para responder a la pregunta al final.
Si no sabes la respuesta, simplemente di que no sabes, no intentes inventar una respuesta.</p>

{context}

<p>Pregunta: {question}
Respuesta: &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># Uso
rag_system = RAGSystem(vector_store)
response = rag_system.query(&quot;¿Cuál es la capital de Francia?&quot;)
print(response[&quot;result&quot;])</p>

Este sistema RAG utiliza Gemma 2 a través de Ollama para el modelo de lenguaje y embeddings de Nomic para la recuperación de documentos. Permite hacer preguntas basadas en los documentos indexados, proporcionando respuestas con contexto de las fuentes relevantes.

Ajuste fino de Gemma 2

Para tareas o dominios específicos, es posible que desees ajustar Gemma 2. Aquí te muestro un ejemplo básico utilizando la biblioteca Hugging Face Transformers:

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

<p># Carga el modelo y el tokenizador
model_name = &quot;google/gemma-2-9b-it&quot;
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)</p>

<p># Prepara el conjunto de datos
dataset = load_dataset(&quot;tu_conjunto_de_datos&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># Configura los argumentos de entrenamiento
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># Inicializa el entrenador
trainer = Trainer(
model=model,
args=training_args,
train_dataset=tokenized_datasets[&quot;train&quot;],
eval_dataset=tokenized_datasets[&quot;test&quot;],
)</p>

# Comienza el ajuste fino
trainer.train()

<p># Guarda el modelo ajustado
model.save_pretrained(&quot;./fine_tuned_gemma2&quot;)
tokenizer.save_pretrained(&quot;./fine_tuned_gemma2&quot;)</p>

Recuerda ajustar los parámetros de entrenamiento según tus requisitos y recursos computacionales específicos.

Consideraciones éticas y limitaciones

Aunque Gemma 2 ofrece capacidades impresionantes, es crucial ser consciente de sus limitaciones y consideraciones éticas:

• Sesgo: Al igual que todos los modelos de lenguaje, Gemma 2 puede reflejar sesgos presentes en sus datos de entrenamiento. Evalúa críticamente sus salidas.
• Precisión factual: Aunque es muy capaz, Gemma 2 puede generar información incorrecta o inconsistente en ocasiones. Verifica hechos importantes desde fuentes confiables.
• Longitud de contexto: Gemma 2 tiene una longitud de contexto de 8192 tokens. Para documentos o conversaciones más largos, es posible que necesites implementar estrategias para gestionar el contexto de manera efectiva.
• Recursos computacionales: Especialmente para el modelo de 27B, se pueden requerir recursos computacionales significativos para una inferencia y ajuste fino eficientes.
• Uso responsable: Adhiérete a las prácticas de AI responsable de Google y asegúrate de que tu uso de Gemma 2 se alinee con los principios éticos de la AI.

Conclusión

Gemma 2, con características avanzadas como la atención con ventana deslizante, la limitación suave y las técnicas de fusión de modelos novedosas, se convierte en una herramienta poderosa para una amplia gama de tareas de procesamiento de lenguaje natural.

Al aprovechar Gemma 2 en tus proyectos, ya sea a través de inferencia simple, sistemas RAG complejos o modelos ajustados para dominios específicos, puedes aprovechar el poder de la AI de vanguardia mientras mantienes el control sobre tus datos y procesos.