Fine-tuning Google Gemma con Unsloth: Transformando Lenguaje Natural en Código

Descubre cómo combinar Google Gemma y Unsloth para optimizar el desarrollo de software con consultas en lenguaje natural

En el mundo del desarrollo de software, la posibilidad de convertir simples preguntas en lenguaje natural en fragmentos de código funcional está redefiniendo la productividad de los programadores.

Google Gemma, un modelo de lenguaje de gran escala, combinado con la eficiencia de Unsloth, hace posible transformar ideas en soluciones codificadas con rapidez y precisión.

Este artículo te guiará a través de los pasos para afinar esta poderosa herramienta y maximizar su potencial.

¿Qué es Google Gemma?

Google Gemma es una familia de modelos de lenguaje abiertos creados por Google.

Basados en los modelos Gemini de Google, los modelos Gemma han sido entrenados con 6 billones de tokens de texto.

Su familia incluye un modelo de 2 mil millones de parámetros para aplicaciones ligeras y otro de 7 mil millones para implementaciones avanzadas en GPU y TPU.

Estos modelos destacan por su capacidad de comprensión y razonamiento a gran escala, superando a otros modelos abiertos en tareas como resolución de preguntas, razón lógica y matemáticas.

¿Qué es Unsloth y cómo complementa a Gemma?

Creado por Daniel y Michael Han, Unsloth es una herramienta de optimización diseñada para mejorar la afinación de modelos de lenguaje de gran escala (LLMs).

Destaca por su rapidez y eficiencia en el uso de memoria, logrando acelerar el entrenamiento hasta 30 veces y reducir el consumo de memoria en un 60%.

Compatible con hardware de NVIDIA, AMD e Intel, Unsloth integra técnicas como upcasting inteligente de pesos y entrenamiento en 4 bits con estabilidad mejorada.

Su flexibilidad lo convierte en una opción ideal para proyectos complejos como la afinación de Google Gemma.

Configuración del Entorno para Afinar Google Gemma

Instalación de Librerías Necesarias

Para comenzar, necesitamos preparar el entorno de Python instalando las bibliotecas necesarias.

Usaremos Google Colab para afinar el modelo Gemma. Ejecuta el siguiente comando para instalar Unsloth:

!pip install "unsloth[colab] @ git+https://github.com/unslothai/unsloth.git"

Esto instala Unsloth y las bibliotecas compatibles en Colab, incluyendo datasets y transformers de Hugging Face.

Carga del Modelo Preentrenado

Luego, cargamos el modelo preentrenado:

from unsloth import FastLanguageModel
import torch

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/gemma-7b-bnb-4bit",
    max_seq_length=8192,
    dtype=None,
    load_in_4bit=True
)

El modelo Gemma 7B se carga con pesos cuantificados en 4 bits, optimizando el uso de memoria y acelerando el entrenamiento.

Creación de Adaptadores LoRA

Para personalizar Gemma, creamos adaptadores LoRA que permiten ajustar solo un subconjunto de parámetros del modelo:

model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing=True
)

Esto reduce el sobreajuste y mejora la generalización del modelo, manteniendo su eficiencia.

Preparación del Dataset para la Afinación

Selección y Formateo del Dataset

Utilizamos un dataset estilo Alpaca para entrenar Gemma en la generación de código. El dataset debe incluir columnas como "input", "instruction" y "output". Definimos una función para formatear los datos:

def formatted_train(x):
    if x['input']:
        return f"""### Instruction:
{x['instruction']}

### Input:
{x['input']}

### Response:
{x['output']}<eos>"""
    else:
        return f"""### Instruction:
{x['instruction']}

### Response:
{x['output']}<eos>"""

Carga del Dataset

Luego cargamos el dataset desde Hugging Face y aplicamos el formato:

from datasets import load_dataset, Dataset

data = load_dataset("TokenBender/code_instructions_122k_alpaca_style", split="train")
data = data.map(formatted_train, remove_columns=["instruction", "input", "output"])

Afinación de Google Gemma

Definición de Argumentos de Entrenamiento

Definimos los argumentos de entrenamiento y afinamos el modelo con SFTTrainer:

from trl import SFTTrainer
from transformers import TrainingArguments

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=data,
    dataset_text_field="formatted_text",
    max_seq_length=8192,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=5,
        max_steps=50,
        learning_rate=2e-4,
        logging_steps=1,
        output_dir="outputs"
    )
)
trainer.train()

Generación de Código con el Modelo Afinado

Creación de Prompts

Una vez afinado, probamos el modelo con consultas en lenguaje natural:

def format_test(x):
    return f"""### Instruction:
{x['instruction']}

### Input:
{x['input']}

### Response:"""

prompt = format_test({"instruction": "Escribe una función para eliminar duplicados en una lista", "input": "[1, 1, 2, 3, 4, 4, 5]"})
inputs = tokenizer([prompt], return_tensors="pt").to("cuda")
output = model.generate(**inputs, max_new_tokens=50)
print(tokenizer.decode(output[0]))

Resultados

El modelo generó una función eficiente para eliminar duplicados:

def remove_duplicates(lst):
    seen = set()
    return [x for x in lst if x not in seen and not seen.add(x)]

La combinación de Google Gemma y Unsloth representa un enfoque revolucionario en la transformación de consultas en lenguaje natural a código.

He trabajado con múltiples escenarios y herramientas similares, y esta dupla destaca por su eficiencia, escalabilidad y capacidad de adaptarse a necesidades tanto de principiantes como de expertos en el ámbito del desarrollo de software.

Lo que más valoro de este proceso es su impacto en la productividad.

No solo elimina barreras técnicas tradicionales como la preparación de datos y la gestión compleja de hiperparámetros, sino que también permite a los desarrolladores concentrarse en la creatividad y la resolución de problemas, en lugar de perder tiempo en tareas repetitivas.

Desde el punto de vista práctico, Unsloth aporta un cambio importante en términos de accesibilidad y recursos.

Su capacidad para reducir el consumo de memoria y acelerar procesos hace que modelos como Gemma sean viables incluso en configuraciones de hardware menos robustas.

Esto democratiza la inteligencia artificial, permitiendo que más personas experimenten con modelos avanzados.

En mi experiencia, este tipo de herramientas son un reflejo del futuro del desarrollo tecnológico: accesible, rápido y enfocado en potenciar las habilidades humanas.

Si bien no todas las implementaciones son perfectas, el camino que abren Gemma y Unsloth hacia una programación más intuitiva y eficiente es emocionante y lleno de posibilidades.

Preguntas frecuentes sobre Fine-tuning Google Gemma con Unsloth

¿Qué es Fine-tuning Google Gemma con Unsloth?

Fine-tuning Google Gemma con Unsloth es un concepto relacionado con inteligencia artificial que se basa en aprender a partir de datos para mejorar resultados y tomar decisiones con mayor precisión.

¿Para qué sirve Fine-tuning Google Gemma con Unsloth en la práctica?

Se utiliza para resolver problemas reales como clasificación, predicción, recomendación o automatización, dependiendo del contexto y del tipo de datos disponibles.

¿Necesito saber programar para entender Fine-tuning Google Gemma con Unsloth?

No. Para comprender la idea general basta con entender el proceso y los ejemplos. Programar es útil si quieres implementarlo, pero no es imprescindible para aprender los fundamentos.

¿Qué diferencia hay entre Fine-tuning Google Gemma con Unsloth e inteligencia artificial?

La inteligencia artificial es el campo general. Fine-tuning Google Gemma con Unsloth suele referirse a un enfoque o técnica concreta dentro de ese campo, aplicada a datos y aprendizaje.