Modelos y plataformas de IA
Seguimiento de Modelos de Lenguaje Grande (LLM) con MLflow: Una Guía Completa
Añade Unite.AI a tus fuentes preferidas en Google
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 de su entorno hasta técnicas de evaluación avanzadas, con muchos 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 exhaustivo de las interacciones del modelo, incluyendo los siguientes aspectos clave:
- Parámetros: Pares de valores clave que detallan los parámetros de entrada para el LLM, como parámetros específicos del modelo como
top_kytemperatura. Esto proporciona contexto y configuración para cada ejecución, asegurando que todos los aspectos de la configuración del modelo estén capturados. - 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 perspectivas en tiempo real o posteriores 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 estén registradas minuciosamente, proporcionando una línea de tiempo y un seguimiento de calidad para los modelos de generación de texto.
Evaluación de LLM
Evaluar LLM presenta 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 modelo versátil: Soporta la evaluación de varios tipos de LLM, ya sea un modelo pyfunc de MLflow, una URI que apunta a un modelo de MLflow registrado 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, incluyendo tanto métricas dependientes del modelo SaaS (por ejemplo, relevancia de la respuesta) como métricas basadas en funciones (por ejemplo, ROUGE, Flesch Kincaid).
- <strong Colecciones de métricas predefinidas: Dependiendo del caso de uso, como la respuesta a preguntas o la resumen de texto, 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, lo que mejora 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 de LLM:
- Servidor de despliegue 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 serie de modelos fundamentales de proveedores SaaS populares, así como modelos autoalojados.
- 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 acceder directamente 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 los 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, configuremos 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 utilizar:
import mlflow
import chromadb
<p>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 sus 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 los LLM, una ejecución puede representar una sola consulta o un lote de prompts procesados por el modelo.
Componentes de Seguimiento Clave
- Parámetros: Estos son configuraciones de entrada para su LLM, como temperatura, top_k o max_tokens. Puede registrarlos utilizando
mlflow.log_param()omlflow.log_params(). - Métricas: Medidas cuantitativas del rendimiento de su LLM, como precisión, latencia o puntuaciones personalizadas. Utilice
mlflow.log_metric()omlflow.log_metrics()para realizar un seguimiento de estas. - Predicciones: Para los LLM, es crucial registrar tanto las entradas como las salidas del modelo. MLflow almacena estas como artefactos en formato CSV utilizando
mlflow.log_table(). - Artefactos: Cualquier archivo o dato adicional relacionado con la ejecución de LLM, como puntos de control del modelo, visualizaciones o muestras de datos. Utilice
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
<p>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()</p>
<p>with mlflow.start_run():
prompt = "Explica el concepto de aprendizaje automático en términos sencillos."</p>
<p># Registra parámetros
mlflow.log_param("modelo", "text-davinci-002")
mlflow.log_param("max_tokens", 100)</p>
<p># Consulta el LLM y registra el resultado
resultado = consulta_llm(prompt)
mlflow.log_metric("longitud_de_respuesta", len(resultado))</p>
<p># Registra el prompt y la respuesta
mlflow.log_table("prompt_respuestas", {"prompt": [prompt], "respuesta": [resultado]})</p>
<p>print(f"Respuesta: {resultado}")
Desplegando 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
<p># Inicializa el cliente de despliegue
cliente = get_deploy_client("databricks")</p>
<p># Define la configuración del punto de conexión
nombre_punto_conexion = "punto_conexion_llm"
config_punto_conexion = {
"entidades_atendidas": [{
"nombre": "modelo_gpt",
"modelo_externo": {
"nombre": "gpt-3.5-turbo",
"proveedor": "openai",
"tarea": "llm/v1/completions",
"config_openai": {
"tipo_api_openai": "azure",
"clave_api_openai": "{{secrets/scope/openai_api_key}}",
"base_api_openai": "{{secrets/scope/openai_api_base}}",
"nombre_despliegue_openai": "gpt-35-turbo",
"version_api_openai": "2023-05-15",
},
},
}],
}</p>
<p># Crea el punto de conexión
cliente.create_endpoint(nombre=nombre_punto_conexion, config=config_punto_conexion)
Este código configura 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">
<p>respuesta = cliente.predict(
punto_conexion=nombre_punto_conexion,
entradas={"prompt": "Explica el concepto de redes neuronales brevemente.", "max_tokens": 100,},)</p>
print(respuesta)
Esto enviará un prompt a nuestro 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, incluyendo métricas incorporadas y personalizadas.
Preparación de su LLM para la Evaluación
Para evaluar su LLM con mlflow.evaluate(), su modelo debe estar en una de estas formas:
- Una instancia de
mlflow.pyfunc.PyFuncModelo una URI que apunta a un modelo de MLflow registrado. - Una función de Python que toma entradas de cadena y devuelve una sola cadena.
- Una URI de punto de conexión de despliegue de MLflow.
- Establezca
modelo=Nonee incluya las salidas del modelo en los datos de evaluación.
Veamos un ejemplo utilizando un modelo de MLflow registrado:
import mlflow
import openai
<p>with mlflow.start_run():
prompt_sistema = "Responde la siguiente pregunta de manera concisa."
info_modelo_registrado = mlflow.openai.log_model(
modelo="gpt-3.5-turbo",
tarea=openai.chat.completions,
ruta_artefacto="modelo",
mensajes=[
{"rol": "sistema", "contenido": prompt_sistema},
{"rol": "usuario", "contenido": "{pregunta}"},
],
)</p>
<p># Prepara datos de evaluación
eval_data = pd.DataFrame({
"pregunta": ["¿Qué es el aprendizaje automático?", "Explica las redes neuronales."],
"verdadfundamental": [
"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 informáticos inspirados en las redes neuronales biológicas, que consisten en nodos interconectados que procesan y transmiten información."
]
})</p>
<p># Evalúa el modelo
resultados = mlflow.evaluate(
info_modelo_registrado.modelo_uri,
eval_data,
targets="verdadfundamental",
tipo_modelo="pregunta-respuesta",
)</p>
<p>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 incorporadas de MLflow para tareas de pregunta-respuesta.
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
<p>profesionalidad = make_genai_metric(
nombre="profesionalidad",
definicion="Medida del estilo de comunicación formal y apropiado.",
prompt_calificacion=(
"Califique la profesionalidad de la respuesta en una escala de 0 a 4:\n"
"0: Muy informal o inapropiado\n"
"1: Informal 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 su herramienta de neighborhood para gestionar proyectos de aprendizaje automático. Es muy genial.",
puntuacion=1,
justificacion="La respuesta es informal y utiliza lenguaje no formal."
),
EvaluationExample(
entrada="¿Qué es MLflow?",
salida="MLflow es una plataforma de código abierto para el ciclo de vida del aprendizaje automático, que incluye 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,
)</p>
<p># Usa la métrica personalizada en la evaluación
resultados = mlflow.evaluate(
info_modelo_registrado.modelo_uri,
eval_data,
targets="verdadfundamental",
tipo_modelo="pregunta-respuesta",
metricas_extra=[profesionalidad]
)</p>
<p>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 se pueden utilizar los propios LLM para la evaluación.
Técnicas Avanzadas de Evaluación 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 avanzadas de evaluación 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í se muestra cómo 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
<p># Carga y preprocesa 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)</p>
<p># Crea almacén de vectores
incrustaciones = OpenAIEmbeddings()
almacen_vectorial = Chroma.from_documentos(textos, incrustaciones)</p>
<p># Crea cadena RAG
llm = OpenAI(temperatura=0)
cadena_preguntas_respuestas = RetrievalQA.from_chain_type(
llm=llm,
tipo_cadena="stuff",
recuperador=almacen_vectorial.as_recuperador(),
devuelve_documentos_fuente=True
)</p>
<p># Función de evaluación
def evaluar_rag(pregunta):
resultado = cadena_preguntas_respuestas({"consulta": pregunta})
return resultado["resultado"], [doc.page_content for doc in resultado["documentos_fuente"]]</p>
<p># Prepara 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?"
]</p>
<p># Evalúa utilizando MLflow
with mlflow.start_run():
for pregunta in preguntas_evaluacion:
respuesta, fuentes = evaluar_rag(pregunta)</p>
<p>mlflow.log_param(f"pregunta", pregunta)
mlflow.log_metric("num_fuentes", len(fuentes))
mlflow.log_text(respuesta, f"respuesta_{pregunta}.txt")</p>
<p>for i, fuente in enumerate(fuentes):
mlflow.log_text(fuente, f"fuente_{pregunta}_{i}.txt")</p>
<p># Registra métricas personalizadas
mlflow.log_metric("promedio_fuentes_por_pregunta", sum(len(evaluar_rag(p)[1]) for p in preguntas_evaluacion) / len(preguntas_evaluacion))
Este ejemplo configura un sistema RAG utilizando LangChain y Chroma, luego lo evalúa registrando preguntas, respuestas, fuentes recuperadas y métricas personalizadas en MLflow.
Evaluación de Estrategia de División
La forma en que divide sus documentos puede afectar significativamente el rendimiento de RAG. MLflow puede ayudar a evaluar diferentes estrategias de división:
import mlflow
from langchain.text_splitter import CharacterTextSplitter, TokenTextSplitter
<p>def evaluar_estrategia_division(documentos, tamaño_chunk, superposicion_chunk, clase_divisor):
divisor = clase_divisor(tamaño_chunk=tamaño_chunk, superposicion_chunk=superposicion_chunk)
chunks = divisor.split_documentos(documentos)</p>
<p>with mlflow.start_run():
mlflow.log_param("tamaño_chunk", tamaño_chunk)
mlflow.log_param("superposicion_chunk", superposicion_chunk)
mlflow.log_param("clase_divisor", clase_divisor.__name__)</p>
<p>mlflow.log_metric("num_chunks", len(chunks))
mlflow.log_metric("longitud_promedio_chunk", sum(len(chunk.page_content) for chunk in chunks) / len(chunks))</p>
<p># Evalúa el rendimiento de recuperación (simplificado)
recuperaciones_correctas = sum(1 for _ in range(100) if simular_recuperacion(chunks))
mlflow.log_metric("precisión_recuperación", recuperaciones_correctas / 100)</p>
<p># Evalúa diferentes estrategias
for tamaño_chunk in [500, 1000, 1500]:
for superposicion_chunk in [0, 50, 100]:
for clase_divisor in [CharacterTextSplitter, TokenTextSplitter]:
evaluar_estrategia_division(documentos, tamaño_chunk, superposicion_chunk, clase_divisor)</p>
<p># Compara resultados
mejor_ejecucion = mlflow.search_runs(order_by=["metrics.precisión_recuperación DESC"]).iloc[0]
print(f"Mejor estrategia de división: {mejor_ejecucion['params.clase_divisor']} con tamaño {mejor_ejecucion['params.tamaño_chunk']} y superposición {mejor_ejecucion['params.superposicion_chunk']}")
Este script evalúa diferentes combinaciones de tamaños de chunk, superposiciones y métodos de división, registrando los resultados en MLflow para una fácil comparación.
Visualización de Resultados de Evaluación de LLM
MLflow proporciona varias formas de visualizar los resultados de evaluación de su LLM. A continuación, se presentan algunas técnicas:
Utilizando la Interfaz de Usuario de MLflow
Después de ejecutar sus evaluaciones, puede utilizar la interfaz de usuario de MLflow para visualizar los resultados:
- Inicie la interfaz de usuario de MLflow:
mlflow ui - Abra un navegador web y navegue hasta:
http://localhost:5000 - Seleccione su experimento y ejecuciones para ver métricas, parámetros y artefactos
Visualizaciones Personalizadas
Puede crear visualizaciones personalizadas de los resultados de evaluación utilizando bibliotecas como Matplotlib o Plotly, y luego registrarlas como artefactos:
import matplotlib.pyplot as plt
import mlflow
<p>def trazar_comparacion_metrica(nombre_metrica, ids_ejecucion):
plt.figure(figsize=(10, 6))
for id_ejecucion in ids_ejecucion:
ejecucion = mlflow.get_run(id_ejecucion)
valores_metrica = mlflow.get_metric_history(id_ejecucion, nombre_metrica)
plt.plot([m.step for m in valores_metrica], [m.value for m in valores_metrica], label=ejecucion.data.tags.get("mlflow.runName", id_ejecucion))</p>
<p>plt.title(f"Comparación de {nombre_metrica}")
plt.xlabel("Paso")
plt.ylabel(nombre_metrica)
plt.legend()</p>
<p># Guarda y registra la trama
plt.savefig(f"{nombre_metrica}_comparacion.png")
mlflow.log_artifact(f"{nombre_metrica}_comparacion.png")</p>
<p># Uso
with mlflow.start_run():
trazar_comparacion_metrica("relevancia_respuesta", ["id_ejecucion_1", "id_ejecucion_2", "id_ejecucion_3"])
Esta función crea una trama de línea que compara una métrica específica en varias ejecuciones y la registra como un artefacto.
Alternativas a MLflow de Código Abierto
Existen numerosas alternativas a MLflow de código abierto para gestionar flujos de trabajo de aprendizaje automático, cada una con características y integraciones únicas.
MLflow Administrado por Databricks
MLflow administrado, alojado por Databricks, proporciona las funcionalidades básicas de MLflow de código abierto, pero con beneficios adicionales como una integración sin problemas con el ecosistema de Databricks, características de seguridad avanzadas y una infraestructura administrada. Esto lo convierte en una excelente opción para organizaciones que necesitan seguridad y escalabilidad robustas.
Azure Machine Learning
Azure Machine Learning ofrece una solución de aprendizaje automático de extremo a extremo en la plataforma de nube de Microsoft Azure. Proporciona compatibilidad con componentes de MLflow como el registro de modelos y el rastreador de experimentos, aunque no se basa en MLflow.
Plataformas de ML Dedicadas
Varias empresas ofrecen productos de ML administrados con características diversas:
- neptune.ai: Se centra en el seguimiento de experimentos y la gestión de modelos.
- Weights & Biases: Ofrece un seguimiento de experimentos extenso, versionado de conjuntos de datos y herramientas de colaboración.
- Comet ML: Proporciona seguimiento de experimentos, monitoreo de modelos en producción y registro de datos.
- Valohai: Se especializa en pipelines y orquestación de aprendizaje automático.
Metaflow
Metaflow, desarrollado por Netflix (NFLX ), es un marco de trabajo de código abierto diseñado para orquestar flujos de trabajo de datos y pipelines de ML. Aunque sobresale en la gestión de despliegues a gran escala, carece de características de seguimiento de experimentos y gestión de modelos comprehensivas en comparación con MLflow.
Amazon SageMaker y Vertex AI de Google
Tanto Amazon SageMaker (AMZN ) como Vertex AI de Google (GOOGL ) proporcionan soluciones de MLOps de extremo a extremo integradas en sus respectivas plataformas de nube. Estos servicios ofrecen herramientas robustas para construir, entrenar y desplegar modelos de aprendizaje automático a escala.
Comparación Detallada
MLflow Administrado vs. MLflow de Código Abierto
MLflow administrado por Databricks ofrece varias ventajas sobre la versión de código abierto, incluyendo:
- Configuración y Despliegue: La integración sin problemas con el ecosistema de Databricks reduce el tiempo de configuración y esfuerzo.
- Escalabilidad: Capaz de manejar cargas de trabajo de aprendizaje automático a gran escala con facilidad.
- Seguridad y Gestión: Características de seguridad incorporadas como control de acceso basado en roles (RBAC) y cifrado de datos.
- Integración: Integración profunda con los servicios de Databricks, mejorando la interoperabilidad y la funcionalidad.
- Almacenamiento y Copia de Seguridad de Datos: Estrategias de copia de seguridad automatizadas garantizan la seguridad y confiabilidad de los datos.
- Costo: Los usuarios pagan por la plataforma, el almacenamiento y los recursos de cómputo.
- Soporte y Mantenimiento: Soporte y mantenimiento dedicados proporcionados por Databricks.
Conclusión
El seguimiento de Modelos de Lenguaje Grande con MLflow proporciona un marco robusto para gestionar las complejidades del desarrollo, evaluación y despliegue de LLM. Siguiendo las mejores prácticas y aprovechando las características avanzadas descritas en esta guía, puede crear experimentos de LLM más organizados, reproducibles e informativos.
Recuerde que el campo de los LLM evoluciona rápidamente, y nuevas técnicas para la evaluación y el seguimiento están surgiendo constantemente. Manténgase actualizado con las últimas versiones de MLflow y la investigación sobre LLM para refinar continuamente sus procesos de seguimiento y evaluación.
A medida que aplique estas técnicas en sus proyectos, desarrollará una comprensión más profunda del comportamiento y el rendimiento de sus LLM, lo que conducirá a modelos de lenguaje más efectivos y confiables.
