Seguimiento de Modelos de Lenguaje Grande (LLM) con MLflow: Una Guía Completa

A medida que los Modelos de Lenguaje Grande (LLM) crecen en complejidad y escala, realizar un seguimiento de su rendimiento, experimentos y despliegues se vuelve cada vez más desafiante. Es aquí donde entra en juego MLflow, proporcionando una plataforma integral para gestionar todo el ciclo de vida de los modelos de aprendizaje automático, incluidos los LLM.

En esta guía detallada, exploraremos cómo aprovechar MLflow para realizar un seguimiento, evaluar y desplegar LLM. Cubriremos todo, desde la configuración del entorno hasta técnicas de evaluación avanzadas, con numerosos ejemplos de código y mejores prácticas en el camino.

Funcionalidad de MLflow en Modelos de Lenguaje Grande (LLM)

MLflow se ha convertido en una herramienta fundamental en la comunidad de aprendizaje automático y ciencia de datos, especialmente para gestionar el ciclo de vida de los modelos de aprendizaje automático. Cuando se trata de Modelos de Lenguaje Grande (LLM), MLflow ofrece una robusta suite de herramientas que simplifican significativamente el proceso de desarrollo, seguimiento, evaluación y despliegue de estos modelos. A continuación, se presenta una visión general de cómo funciona MLflow dentro del espacio de LLM y los beneficios que proporciona a los ingenieros y científicos de datos.

Seguimiento y Gestión de Interacciones de LLM

El sistema de seguimiento de LLM de MLflow es una mejora de sus capacidades de seguimiento existentes, adaptadas a las necesidades únicas de los LLM. Permite un seguimiento integral de las interacciones del modelo, incluidos los siguientes aspectos clave:

• Parámetros: Registro de pares clave-valor que detallan los parámetros de entrada para el LLM, como parámetros específicos del modelo como top_k y temperatura. Esto proporciona contexto y configuración para cada ejecución, asegurando que todos los aspectos de la configuración del modelo se capturen.
• Métricas: Medidas cuantitativas que proporcionan información sobre el rendimiento y la precisión del LLM. Estas pueden actualizarse dinámicamente a medida que avanza la ejecución, ofreciendo información en tiempo real o posterior al proceso.
• Predicciones: Es crucial registrar tanto las entradas enviadas al LLM como las salidas del modelo, que se almacenan como artefactos en un formato estructurado para su fácil recuperación y análisis.
• Artefactos: Más allá de las predicciones, MLflow puede almacenar varios archivos de salida, como visualizaciones, modelos serializados y archivos de datos estructurados, lo que permite una documentación y análisis detallados del rendimiento del modelo.

Este enfoque estructurado garantiza que todas las interacciones con el LLM se registren meticulosamente, proporcionando una línea de tiempo y un seguimiento de calidad para los modelos generadores de texto.

Evaluación de LLM

Evaluar LLM plantea desafíos únicos debido a su naturaleza generativa y la falta de una verdad única. MLflow simplifica esto con herramientas de evaluación especializadas diseñadas para LLM. Las características clave incluyen:

• Evaluación de Modelos Versátiles: Admite la evaluación de varios tipos de LLM, ya sea un modelo pyfunc de MLflow, una URI que apunta a un modelo registrado de MLflow o cualquier función Python que represente su modelo.
• Métricas Comprehensivas: Ofrece una gama de métricas adaptadas para la evaluación de LLM, incluidas métricas dependientes del modelo (por ejemplo, relevancia de la respuesta) y métricas basadas en funciones (por ejemplo, ROUGE, Flesch Kincaid).
• Colecciones de Métricas Predefinidas: Dependiendo del caso de uso, como la respuesta a preguntas o la resumen de textos, MLflow proporciona métricas predefinidas para simplificar el proceso de evaluación.
• Creación de Métricas Personalizadas: Permite a los usuarios definir e implementar métricas personalizadas para satisfacer necesidades de evaluación específicas, mejorando la flexibilidad y la profundidad de la evaluación del modelo.
• Evaluación con Conjuntos de Datos Estáticos: Permite la evaluación de conjuntos de datos estáticos sin especificar un modelo, lo cual es útil para evaluaciones rápidas sin volver a ejecutar la inferencia del modelo.

Despliegue e Integración

MLflow también admite el despliegue y la integración sin problemas de LLM:

• Servidor de Despliegues de MLflow: Actúa como una interfaz unificada para interactuar con varios proveedores de LLM. Simplifica las integraciones, gestiona las credenciales de forma segura y ofrece una experiencia de API coherente. Este servidor admite una gama de modelos fundamentales de proveedores de SaaS populares, así como modelos autohospedados.
• Punto de Conexión Unificado: Facilita el cambio entre proveedores sin cambios en el código, minimizando el tiempo de inactividad y mejorando la flexibilidad.
• Vista de Resultados Integrada: Proporciona resultados de evaluación comprehensivos, que se pueden accederectamente en el código o a través de la interfaz de usuario de MLflow para un análisis detallado.

La suite integral de herramientas y integraciones de MLflow lo convierte en un activo invaluable para ingenieros y científicos de datos que trabajan con modelos de NLP avanzados.

Configuración del Entorno

Antes de sumergirnos en el seguimiento de LLM con MLflow, configuraremos nuestro entorno de desarrollo. Necesitaremos instalar MLflow y varias bibliotecas clave:

pip install mlflow>=2.8.1
pip install openai
pip install chromadb==0.4.15
pip install langchain==0.0.348
pip install tiktoken
pip install 'mlflow[genai]'
pip install databricks-sdk --upgrade

Después de la instalación, es una buena práctica reiniciar el entorno de Python para asegurarse de que todas las bibliotecas estén cargadas correctamente. En un cuaderno de Jupyter, puede usar:

import mlflow
import chromadb

print(f"Versión de MLflow: {mlflow.__version__}")
print(f"Versión de ChromaDB: {chromadb.__version__}")

Esto confirmará las versiones de las bibliotecas clave que estaremos utilizando.

Comprensión de las Capacidades de Seguimiento de LLM de MLflow

El sistema de seguimiento de LLM de MLflow se basa en las capacidades de seguimiento existentes, agregando características diseñadas específicamente para los aspectos únicos de los LLM. Desglosemos los componentes clave:

Ejecuciones y Experimentos

En MLflow, una “ejecución” representa una sola ejecución del código del modelo, mientras que un “experimento” es una colección de ejecuciones relacionadas. Para LLM, una ejecución puede representar una sola consulta o un lote de promtps procesados por el modelo.

Componentes de Seguimiento Clave

1. Parámetros: Estos son configuraciones de entrada para su LLM, como temperatura, top_k o max_tokens. Puede registrarlos usando mlflow.log_param() o mlflow.log_params().
2. Métricas: Medidas cuantitativas del rendimiento de su LLM, como precisión, latencia o puntuaciones personalizadas. Use mlflow.log_metric() o mlflow.log_metrics() para realizar un seguimiento de estas.
3. Predicciones: Para LLM, es crucial registrar tanto las entradas enviadas al LLM como las salidas del modelo. MLflow almacena estas como artefactos en formato CSV utilizando mlflow.log_table().
4. Artefactos: Cualquier archivo o dato adicional relacionado con la ejecución de LLM, como puntos de control del modelo, visualizaciones o muestras de datos. Use mlflow.log_artifact() para almacenar estos.

Veamos un ejemplo básico de registro de una ejecución de LLM:

Este ejemplo demuestra el registro de parámetros, métricas y la entrada/salida como un artefacto de tabla.

import mlflow
import openai

def consulta_llm(prompt, max_tokens=100):
respuesta = openai.Completion.create(
engine="text-davinci-002",
prompt=prompt,
max_tokens=max_tokens
)
return respuesta.choices[0].text.strip()

with mlflow.start_run():
prompt = "Explicar el concepto de aprendizaje automático en términos sencillos."

# Registro de parámetros
mlflow.log_param("modelo", "text-davinci-002")
mlflow.log_param("max_tokens", 100)

# Consulta al LLM y registro del resultado
resultado = consulta_llm(prompt)
mlflow.log_metric("longitud_respuesta", len(resultado))

# Registro de la entrada y la salida
mlflow.log_table("prompt_respuestas", {"prompt": [prompt], "respuesta": [resultado]})

print(f"Respuesta: {resultado}")

Despliegue de LLM con MLflow

MLflow proporciona capacidades poderosas para desplegar LLM, facilitando el despliegue de sus modelos en entornos de producción. Exploraremos cómo desplegar un LLM utilizando las características de despliegue de MLflow.

Creación de un Punto de Conexión

Primero, crearemos un punto de conexión para nuestro LLM utilizando el cliente de despliegue de MLflow:

import mlflow
from mlflow.deployments import get_deploy_client

# Inicializar el cliente de despliegue
cliente = get_deploy_client("databricks")

# Definir la configuración del punto de conexión
nombre_punto_conexion = "punto_conexion_llm"
config_punto_conexion = {
"entidades_atendidas": [{
"nombre": "gpt-modelo",
"modelo_externo": {
"nombre": "gpt-3.5-turbo",
"proveedor": "openai",
"tarea": "llm/v1/completions",
"config_openai": {
"tipo_api_openai": "azure",
"clave_api_openai": "{{secrets/alcance/clave_api_openai}}",
"base_api_openai": "{{secrets/alcance/base_api_openai}}",
"nombre_despliegue_openai": "gpt-35-turbo",
"version_api_openai": "2023-05-15",
},
},
}],
}

# Crear el punto de conexión
cliente.create_endpoint(name=nombre_punto_conexion, config=config_punto_conexion)

Este código establece un punto de conexión para un modelo GPT-3.5-turbo utilizando Azure OpenAI. Tenga en cuenta el uso de secretos de Databricks para la gestión segura de claves de API.

Prueba del Punto de Conexión

Una vez creado el punto de conexión, podemos probarlo:

<div class="relative flex flex-col rounded-lg">

respuesta = cliente.predict(
endpoint=nombre_punto_conexion,
inputs={"prompt": "Explique el concepto de redes neuronales brevemente.", "max_tokens": 100,},)

print(respuesta)

Esto enviará una entrada al modelo desplegado y devolverá la respuesta generada.

Evaluación de LLM con MLflow

La evaluación es crucial para comprender el rendimiento y el comportamiento de sus LLM. MLflow proporciona herramientas comprehensivas para evaluar LLM, incluidas métricas integradas y personalizadas.

Preparación del LLM para la Evaluación

Para evaluar su LLM con mlflow.evaluate(), su modelo debe estar en una de estas formas:

1. Una instancia de mlflow.pyfunc.PyFuncModel o una URI que apunta a un modelo de MLflow registrado.
2. Una función de Python que toma entradas de cadena y devuelve una sola cadena.
3. Una URI de punto de conexión de Despliegues de MLflow.
4. Establecer modelo=None e incluir las salidas del modelo en los datos de evaluación.

Veamos un ejemplo utilizando un modelo de MLflow registrado:

import mlflow
import openai

with mlflow.start_run():
prompt_sistema = "Responda la siguiente pregunta de manera concisa."
info_modelo_registrado = mlflow.openai.log_model(
modelo="gpt-3.5-turbo",
tarea=openai.chat.completions,
path_artefacto="modelo",
mensajes=[
{"rol": "sistema", "contenido": prompt_sistema},
{"rol": "usuario", "contenido": "{pregunta}"},
],
)

# Preparar datos de evaluación
datos_evaluacion = pd.DataFrame({
"pregunta": ["¿Qué es el aprendizaje automático?", "Explique las redes neuronales."],
"verdad_grund": [
"El aprendizaje automático es un subconjunto de la IA que permite a los sistemas aprender y mejorar con la experiencia sin programación explícita.",
"Las redes neuronales son sistemas de cómputo inspirados en las redes neuronales biológicas, compuestos por nodos interconectados que procesan y transmiten información.",
]
})

# Evaluar el modelo
resultados = mlflow.evaluate(
info_modelo_registrado.model_uri,
datos_evaluacion,
targets="verdad_grund",
tipo_modelo="pregunta-respuesta",
)

print(f"Métricas de evaluación: {resultados.metrics}")

Este ejemplo registra un modelo de OpenAI, prepara datos de evaluación y luego evalúa el modelo utilizando las métricas integradas de MLflow para tareas de respuesta a preguntas.

Métricas de Evaluación Personalizadas

MLflow permite definir métricas personalizadas para la evaluación de LLM. Aquí hay un ejemplo de creación de una métrica personalizada para evaluar la profesionalidad de las respuestas:

from mlflow.metrics.genai import EvaluationExample, make_genai_metric

profesionalidad = make_genai_metric(
nombre="profesionalidad",
definicion="Medida del estilo de comunicación formal y apropiado.",
prompt_calificacion=(
"Puntuar la profesionalidad de la respuesta en una escala de 0-4:\n"
"0: Extremadamente casual o inapropiado\n"
"1: Casual pero respetuoso\n"
"2: Moderadamente formal\n"
"3: Profesional y apropiado\n"
"4: Altamente formal y expertamente elaborado"
),
ejemplos=[
EvaluationExample(
entrada="¿Qué es MLflow?",
salida="MLflow es como tu amigable herramienta de barrio para gestionar proyectos de aprendizaje automático. ¡Es super genial!",
puntuacion=1,
justificacion="La respuesta es casual y utiliza lenguaje informal.",
),
EvaluationExample(
entrada="¿Qué es MLflow?",
salida="MLflow es una plataforma de código abierto para el ciclo de vida del aprendizaje automático, incluyendo experimentación, reproducibilidad y despliegue.",
puntuacion=4,
justificacion="La respuesta es formal, concisa y profesionalmente redactada.",
)
],
modelo="openai:/gpt-3.5-turbo-16k",
parametros={"temperatura": 0.0},
agregaciones=["media", "varianza"],
mayor_es_mejor=True,
)

# Usar la métrica personalizada en la evaluación
resultados = mlflow.evaluate(
info_modelo_registrado.model_uri,
datos_evaluacion,
targets="verdad_grund",
tipo_modelo="pregunta-respuesta",
metricas_extra=[profesionalidad]
)

print(f"Puntuación de profesionalidad: {resultados.metrics['profesionalidad_media']}")

Esta métrica personalizada utiliza GPT-3.5-turbo para puntuar la profesionalidad de las respuestas, demostrando cómo puede aprovechar los LLM para la evaluación.

Técnicas de Evaluación Avanzadas de LLM

A medida que los LLM se vuelven más sofisticados, también lo hacen las técnicas para evaluarlos. Exploraremos algunas técnicas de evaluación avanzadas utilizando MLflow.

Evaluación de Generación con Recuperación (RAG)

Los sistemas RAG combinan el poder de los modelos de recuperación y generación. Evaluar sistemas RAG requiere evaluar tanto el componente de recuperación como el de generación. Aquí hay cómo puede configurar un sistema RAG y evaluarlo utilizando MLflow:

from langchain.document_loaders import WebBaseLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# Cargar y preprocesar documentos
cargador = WebBaseLoader([“https://mlflow.org/docs/latest/index.html”])
documentos = cargador.load()
divisor_texto = CharacterTextSplitter(tamaño_chunk=1000, superposicion_chunk=0)
textos = divisor_texto.split_documentos(documentos)

# Crear almacén de vectores
incrustaciones = OpenAIEmbeddings()
almacen_vectores = Chroma.from_documentos(textos, incrustaciones)

# Crear cadena RAG
llm = OpenAI(temperatura=0)
cadena_preguntas_recuperacion = RetrievalQA.from_chain_type(
llm=llm,
tipo_cadena=”stuff”,
recuperador=almacen_vectores.as_recuperador(),
devuelve_documentos_fuente=True
)

# Función de evaluación
def evaluar_rag(pregunta):
resultado = cadena_preguntas_recuperacion({“consulta”: pregunta})
return resultado[“resultado”], [doc.page_content for doc in resultado[“documentos_fuente”]]

# Preparar datos de evaluación
preguntas_evaluacion = [
“¿Qué es MLflow?”,
“¿Cómo maneja MLflow el seguimiento de experimentos?”,
“¿Cuáles son los componentes principales de MLflow?”,
]

# Evaluar utilizando MLflow
with mlflow.start_run():