Uso de Routellm para optimizar el uso de LLM

Routellm es un marco flexible para servir y evaluar enrutadores LLM, diseñados para maximizar el rendimiento y minimizar el costo.

Características clave:

• Integración perfecta: actúa como un reemplazo de entrega para el cliente Operai o se ejecuta como un compatible con OpenAI servidorenrutando de manera inteligente consultas más simples a modelos más baratos.
• Enrutadores previamente capacitados fuera de la caja, demostrado que redujo los costos hasta en un 85%, al tiempo que preservan el 95% del rendimiento de GPT-4 en puntos de referencia ampliamente utilizados como MT Bench.
• Excelencia rentable: coincide con el rendimiento de las principales ofertas comerciales, mientras que es más de 40% más barato.
• Extensible y personalizable: agregue fácilmente nuevos enrutadores, umbrales de tune fino y compare el rendimiento en múltiples puntos de referencia.

En este tutorial, caminaremos por cómo:

• Cargue y use un enrutador previamente capacitado.
• Calibrarlo para su propio caso de uso.
• Comportamiento de enrutamiento de prueba en diferentes tipos de indicaciones.
• Mira el Códigos completos aquí.

Instalación de las dependencias

!pip install "routellm[serve,eval]"

Cargando la tecla API de OpenAI

Para obtener una llave de API de OpenAI, visite https://platform.openai.com/settings/organization/api-keys y generar una nueva clave. Si es un nuevo usuario, es posible que deba agregar detalles de facturación y realizar un pago mínimo de $ 5 para activar el acceso a la API.

Routellm aprovecha a Litellm para admitir las finalizaciones de chat desde una amplia gama de modelos de código abierto y de código cerrado. Puede consultar la lista de proveedores en https://litellm.vercel.app/docs/providers Si quieres usar algún otro modelo. Mira el Códigos completos aquí.

import os
from getpass import getpass
os.environ['OPENAI_API_KEY'] = getpass('Enter OpenAI API Key: ')

Descargar el archivo de configuración

Routellm utiliza un archivo de configuración para ubicar los puntos de control del enrutador previo al estado de la aparición y los conjuntos de datos en los que fueron capacitados. Este archivo le dice al sistema dónde encontrar los modelos que deciden si enviar una consulta al modelo fuerte o débil. Mira el Códigos completos aquí.

¿Necesito editarlo?

Para la mayoría de los usuarios, no. La configuración predeterminada ya apunta a enrutadores bien entrenados (MF, Bert, Causal_llm) que funcionan fuera de la caja. Solo necesita cambiarlo si planea:

• Entrena tu propio enrutador en un conjunto de datos personalizado.
• Reemplace el algoritmo de enrutamiento por completo con uno nuevo.

Para este tutorial, mantendremos la configuración tal como está y simplemente:

• Establezca nuestros nombres de modelos fuertes y débiles en el código.
• Agregue nuestras claves API para los proveedores elegidos.
• Use un umbral calibrado para equilibrar el costo y la calidad.
• Mira el Códigos completos aquí.

!wget https://raw.githubusercontent.com/lm-sys/RouteLLM/main/config.example.yaml

Inicializando el controlador de rutellm

En este bloque de código, importamos las bibliotecas necesarias e inicializamos el controlador Routellm, que administrará cómo se enrutan las indicaciones entre los modelos. Especificamos enrutadores =[“mf”] Para usar el enrutador de factorización de matriz, un modelo de decisión previa al detenimiento que predice si una consulta debe enviarse al modelo fuerte o débil.

El parámetro Strong_Model se establece en “GPT-5”, un modelo de alta calidad pero más caro, mientras que el parámetro Weak_Model está establecido en “O4-Mini”, una alternativa más rápida y barata. Para cada mensaje entrante, el enrutador evalúa su complejidad contra un umbral y elige automáticamente la opción más rentable, lo que el modelo más barato maneja las tareas simples, mientras que las más desafiantes obtienen las capacidades del modelo más sólidas.

Esta configuración le permite equilibrar la eficiencia de rentabilidad y la calidad de la respuesta sin intervención manual. Mira el Códigos completos aquí.

import os
import pandas as pd
from routellm.controller import Controller

client = Controller(
    routers=["mf"],  # Model Fusion router
    strong_model="gpt-5",       
    weak_model="o4-mini"     
)

!python -m routellm.calibrate_threshold --routers mf --strong-model-pct 0.1 --config config.example.yaml

Este comando ejecuta el proceso de calibración umbral de Routellm para el enrutador de factorización de matriz (MF). El argumento –Strong-Model-PCT 0.1 le dice al sistema que encuentre el valor umbral que enruta aproximadamente el 10% de las consultas al modelo fuerte (y el resto al modelo débil).

Usando el archivo –config config.example.yaml para la configuración del modelo y el enrutador, se determinó la calibración:

Para llamadas modelo al 10% con MF, el umbral óptimo es 0.24034.

Esto significa que cualquier consulta con una puntuación de complejidad asignada por el enrutador por encima de 0.24034 se enviará al modelo fuerte, mientras que aquellos a continuación se dirigirán al modelo débil, alineando con la compensación de costo-calidad deseada.

Definición del umbral y provoca variables

Aquí, definimos un conjunto diverso de indicaciones de prueba diseñadas para cubrir una gama de niveles de complejidad. Incluyen preguntas objetivas simples (que probablemente se enrutarán al modelo débil), tareas de razonamiento medio (casos de umbral límite) y solicitudes de alta complejidad o creativa (más adecuado para el modelo fuerte), junto con tareas de generación de código para probar las capacidades técnicas. Mira el Códigos completos aquí.

threshold = 0.24034

prompts = [
    # Easy factual (likely weak model)
    "Who wrote the novel 'Pride and Prejudice'?",
    "What is the largest planet in our solar system?",
    
    # Medium reasoning (borderline cases)
    "If a train leaves at 3 PM and travels 60 km/h, how far will it travel by 6:30 PM?",
    "Explain why the sky appears blue during the day and red/orange during sunset.",
    
    # High complexity / creative (likely strong model)
    "Write a 6-line rap verse about climate change using internal rhyme.",
    "Summarize the differences between supervised, unsupervised, and reinforcement learning with examples.",
    
    # Code generation
    "Write a Python function to check if a given string is a palindrome, ignoring punctuation and spaces.",
    "Generate SQL to find the top 3 highest-paying customers from a 'sales' table."
]

Evaluación de la tasa de victorias

El siguiente código calcula la tasa de ganancia para cada indicador de la prueba utilizando el enrutador MF, mostrando la probabilidad de que el modelo fuerte supere al modelo débil.

Basado en el umbral calibrado de 0.24034, dos indicaciones –

“Si un tren sale a las 3 p.m. y viaja 60 km/h, ¿hasta dónde viajará a las 6:30 p.m.? ” (0.303087)

“Escriba una función de pitón para verificar si una cadena determinada es un palíndromo, ignorando la puntuación y los espacios. ” (0.272534)

– exceder el umbral y se enrutaría al modelo fuerte.

Todas las demás indicaciones permanecen por debajo del umbral, lo que significa que serían atendidos por el modelo más débil y más barato. Mira el Códigos completos aquí.

win_rates = client.batch_calculate_win_rate(prompts=pd.Series(prompts), router="mf")

# Store results in DataFrame
_df = pd.DataFrame({
    "Prompt": prompts,
    "Win_Rate": win_rates
})

# Show full text without truncation
pd.set_option('display.max_colwidth', None)

Estos resultados también ayudan a ajustar la estrategia de enrutamiento: al analizar la distribución de la tasa de ganancia, podemos ajustar el umbral para equilibrar un mejor ahorro de costos y rendimiento.

Enrutamiento de enrutamiento a través del enrutador de fusión del modelo calibrado (MF)

Este código itera sobre la lista de indicaciones de prueba y envía cada uno al controlador de rutellas utilizando el enrutador MF calibrado con el umbral especificado (enrutador-mf- {umbral}).

Para cada aviso, el enrutador decide si utilizar el modelo fuerte o débil basado en la tasa de victorias calculada.

La respuesta incluye tanto la salida generada como el modelo real que fue seleccionado por el enrutador.

Estos detalles, el aviso, el modelo utilizado y la salida generada, se almacenan en la lista de resultados para un análisis posterior. Mira el Códigos completos aquí.

results = []
for prompt in prompts:
    response = client.chat.completions.create(
        model=f"router-mf-{threshold}",
        messages=[{"role": "user", "content": prompt}]
    )
    message = response.choices[0].message["content"]
    model_used = response.model  # RouteLLM returns the model actually used
    
    results.append({
        "Prompt": prompt,
        "Model Used": model_used,
        "Output": message
    })

df = pd.DataFrame(results)

En los resultados, las indicaciones 2 y 6 excedieron la tasa de ganancia umbral y, por lo tanto, se enrutaron al modelo fuerte GPT-5, mientras que el resto fue manejado por el modelo más débil.

Mira el Códigos completos aquí. No dude en ver nuestro Página de Github para tutoriales, códigos y cuadernos. Además, siéntete libre de seguirnos Gorjeo Y no olvides unirte a nuestro Subreddit de 100k+ ml y suscribirse a Nuestro boletín.

Soy un graduado de ingeniería civil (2022) de Jamia Millia Islamia, Nueva Delhi, y tengo un gran interés en la ciencia de datos, especialmente las redes neuronales y su aplicación en varias áreas.