Llama-3: Fine-tuning que alcanza el 90% del rendimiento de GPT-4 a una fracción del coste

La empresa Together AI ha anunciado un avance significativo en el mundo de los modelos de código abierto con su modelo Llama-3. Este desarrollo demuestra que los modelos de código abierto están alcanzando rápidamente a los modelos cerrados, sin comprometer la propiedad privada. Los clientes de Together AI han utilizado sus propios datos para ajustar pequeños modelos OSS como Llama-3, logrando ejecutar tareas con mayor precisión que incluso los modelos de código cerrado más avanzados.

Fine-tuning con Together AI

Los usuarios de la plataforma Together AI pueden ajustar el modelo Llama-3-8b con sus datos propios, creando un modelo personalizado que supera a las alternativas líderes de código abierto como Llama-3-70b y que es comparable a las alternativas de código cerrado como GPT-4, todo a una fracción del costo. Un ejemplo de este proceso muestra cómo un modelo Llama-3-8B ajustado pasó de una precisión del 47% en el modelo base a un 65% de precisión, superando al Llama-3-70B (64%) y acercándose al GPT-4 (71%).

Transformación del Dataset

El primer paso es descargar el dataset Math Instruct desde HuggingFace y limpiarlo para eliminar duplicados, reservando 1,000 problemas para evaluaciones. Luego, se transforma el dataset en un archivo .jsonl, ya que es el formato que soporta Together AI.

import json

dataset = "MathInstruct-207k"
old_file_path = f"{dataset}.json"
new_file_path = f"Formatted{dataset}.jsonl"

with open(old_file_path, "r", encoding="utf-8") as old_file:
    old_data = json.load(old_file)

llama_format = """
system
{system_prompt}user
{user_question}assistant
{model_answer}
"""
formatted_data = []
system_prompt = "You're a helpful assistant that answers math problems."

with open(new_file_path, "w", encoding="utf-8") as new_file:
    for piece in old_data:
        temp_data = {
            "text": llama_format.format(
                system_prompt=system_prompt,
                user_question=piece["instruction"],
                model_answer=piece["output"],
            )
        }
        new_file.write(json.dumps(temp_data))
        new_file.write("\n")

Subida y verificación del dataset

Una vez validado el dataset, se sube a Together AI a través del SDK de Python.

import os
from together import Together

client = Together(api_key=os.environ.get("TOGETHER_API_KEY"))
dataset = "MathInstruct-207k"

response = client.files.upload(file=f"Formatted{dataset}.jsonl")
fileId = response.model_dump()["id"]

file_metadata = client.files.retrieve(fileId)
print(file_metadata)

Creación del trabajo de Fine-tuning

Luego, se crea un trabajo de fine-tuning usando Llama-3-8B como modelo base, especificando el dataset subido, usando 5 épocas, y opcionalmente añadiendo una clave API de Weights and Biases para monitorear el trabajo.

resp = client.fine_tuning.create(
    suffix="mathinstruct-207k-v2",
    model="meta-llama/Meta-Llama-3-8B-Instruct",
    training_file=fileId,
    n_epochs=5,
    batch_size=8,
    learning_rate=1e-5,
    wandb_api_key=os.environ.get("WANDB_API_KEY"),
)

Evaluación del modelo ajustado

Una vez finalizado el trabajo de fine-tuning, se evalúa el modelo ajustado en comparación con el modelo base y otros modelos de gran tamaño como Llama-3-70B y GPT-4. Se define un dataset de evaluación y se prueba con ambos modelos para evaluar la precisión.

import json
from together import AsyncTogether
import os
import asyncio

async_together_client = AsyncTogether(api_key=os.environ.get("TOGETHER_API_KEY"))

base_model = "meta-llama/Llama-3-8b-chat-hf"
top_oss_model = "meta-llama/Llama-3-70b-chat-hf"
finetuned_model = "FINETUNED_MODEL_ID"
eval_dataset = "EvalDataset-1000.json"

async def chatCompletion(model, instruction):
    completion = await async_together_client.chat.completions.create(
        messages=[
            {"role": "user", "content": instruction},
        ],
        model=model,
        max_tokens=1500,
    )
    return completion.choices[0].message.content

async def main():
    with open(eval_dataset, "r", encoding="utf-8") as eval_file:
        eval_data = json.load(eval_file)

    results = []

    for example in eval_data:
        (
            baseModelCompletion,
            topOSSModelCompletion,
            finetunedModelCompletion,
        ) = await asyncio.gather(
            chatCompletion(base_model, example["instruction"]),
            chatCompletion(top_oss_model, example["instruction"]),
            chatCompletion(finetuned_model, example["instruction"]),
        )
        results.append(
            {
                "groundTruthAnswer": example["output"],
                "baseModelAnswer": baseModelCompletion,
                "topOSSModelAnswer": topOSSModelCompletion,
                "fineTunedModelAnswer": finetunedModelCompletion,
            }
        )

    with open("results.json", "w", encoding="utf-8") as results_file:
        json.dump(results, results_file, indent=4)

Resultados

La evaluación de un dataset de 1000 problemas matemáticos mostró que el modelo ajustado Llama-3-8B superó al modelo base en casi un 20%, superó al modelo OSS líder Llama-3-70B, y alcanzó más del 90% de la precisión de GPT-4, siendo mucho más rápido y 50 veces más barato.

Conclusión

El fine-tuning de pequeños modelos de código abierto como Llama-3-8B puede resultar en un modelo personalizado que es más pequeño, rápido, barato y preciso para realizar tareas específicas. Además, no compromete la flexibilidad ni la propiedad, permitiendo usar datos propios para ajustar un modelo y luego utilizarlo en Together AI o descargarlo para ejecutarlo localmente.

vía: Together.ai