Suivi des grands modèles de langage (LLM) avec MLflow : Un guide complet

À mesure que les grands modèles de langage (LLM) grandissent en complexité et en ampleur, suivre leurs performances, expériences et déploiements devient de plus en plus difficile. C’est là que MLflow entre en jeu – en fournissant une plate-forme complète pour gérer l’ensemble du cycle de vie des modèles d’apprentissage automatique, y compris les LLM.

Dans ce guide approfondi, nous allons explorer comment exploiter MLflow pour suivre, évaluer et déployer les LLM. Nous allons couvrir tout, desde la configuration de votre environnement jusqu’à des techniques d’évaluation avancées, avec de nombreux exemples de code et de bonnes pratiques en cours de route.

Fonctionnalité de MLflow dans les grands modèles de langage (LLM)

MLflow est devenu un outil essentiel dans la communauté de l’apprentissage automatique et de la science des données, en particulier pour la gestion du cycle de vie des modèles d’apprentissage automatique. Lorsqu’il s’agit de grands modèles de langage (LLM), MLflow propose un ensemble robuste d’outils qui simplifient considérablement le processus de développement, de suivi, d’évaluation et de déploiement de ces modèles. Voici une vue d’ensemble de la façon dont MLflow fonctionne dans l’espace LLM et des avantages qu’il offre aux ingénieurs et aux scientifiques des données.

Suivi et gestion des interactions LLM

Le système de suivi LLM de MLflow est une amélioration de ses capacités de suivi existantes, conçues spécifiquement pour les besoins uniques des LLM. Il permet un suivi complet des interactions de modèle, notamment les aspects clés suivants :

• Paramètres : enregistrement de paires clé-valeur qui détaillent les paramètres d’entrée pour le LLM, tels que des paramètres spécifiques au modèle comme top_k et temperature. Cela fournit un contexte et une configuration pour chaque exécution, en garantissant que tous les aspects de la configuration du modèle sont capturés.
• Métriques : mesures quantitatives qui fournissent des informations sur les performances et la précision du LLM. Ces métriques peuvent être mises à jour dynamiquement à mesure que l’exécution progresse, offrant des insights en temps réel ou post-traitement.
• Prédictions : capture des entrées envoyées au LLM et des sorties correspondantes, qui sont stockées sous forme d’artefacts dans un format structuré pour une récupération et une analyse faciles.
• Artefacts : au-delà des prédictions, MLflow peut stocker divers fichiers de sortie tels que des visualisations, des modèles sérialisés et des fichiers de données structurés, permettant une documentation et une analyse détaillées des performances du modèle.

Cette approche structurée garantit que toutes les interactions avec le LLM sont soigneusement enregistrées, fournissant une lignée et un suivi de qualité complets pour les modèles de génération de texte.

Évaluation des LLM

Évaluer les LLM présente des défis uniques en raison de leur nature générative et du manque d’un seul référentiel. MLflow simplifie cela avec des outils d’évaluation spécialisés conçus pour les LLM. Les fonctionnalités clés incluent :

• Évaluation de modèle versatile : prend en charge l’évaluation de différents types de LLM, qu’il s’agisse d’un modèle pyfunc MLflow, d’un URI pointant vers un modèle MLflow enregistré ou de n’importe quelle fonction Python appelable représentant votre modèle.
• Métriques complètes : propose une gamme de métriques adaptées à l’évaluation des LLM, notamment des métriques de modèle SaaS (par exemple, pertinence de la réponse) et des métriques basées sur des fonctions (par exemple, ROUGE, Flesch Kincaid).
• Collections de métriques prédéfinies : en fonction du cas d’utilisation, tel que la réponse à des questions ou la synthèse de texte, MLflow fournit des métriques prédéfinies pour simplifier le processus d’évaluation.
• Création de métriques personnalisées : permet aux utilisateurs de définir et de mettre en œuvre des métriques personnalisées pour répondre à des besoins d’évaluation spécifiques, améliorant la flexibilité et la profondeur de l’évaluation du modèle.
• Évaluation avec des jeux de données statiques : permet l’évaluation de jeux de données statiques sans spécifier de modèle, ce qui est utile pour des évaluations rapides sans réexécuter l’inférence du modèle.

Déploiement et intégration

MLflow prend également en charge le déploiement et l’intégration sans effort des LLM :

• Serveur de déploiement MLflow : agit comme une interface unifiée pour interagir avec plusieurs fournisseurs de LLM. Il simplifie les intégrations, gère les informations d’identification de manière sécurisée et offre une expérience d’API cohérente. Ce serveur prend en charge une gamme de modèles fondamentaux de fournisseurs SaaS populaires ainsi que des modèles auto-hébergés.
• Point de terminaison unifié : facilite le commutation entre les fournisseurs sans modification de code, minimisant les temps d’arrêt et améliorant la flexibilité.
• Affichage intégré des résultats : fournit des résultats d’évaluation complets, qui peuvent être consultés directement dans le code ou via l’interface utilisateur MLflow pour une analyse détaillée.

L’ensemble complet d’outils et d’intégrations de MLflow en fait un atout inestimable pour les ingénieurs et les scientifiques des données qui travaillent avec des modèles NLP avancés.

Configuration de votre environnement

Avant de plonger dans le suivi des LLM avec MLflow, configurons notre environnement de développement. Nous devrons installer MLflow et plusieurs autres bibliothèques clés :

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

Après l’installation, il est recommandé de redémarrer votre environnement Python pour vous assurer que toutes les bibliothèques sont correctement chargées. Dans un notebook Jupyter, vous pouvez utiliser :

import mlflow
import chromadb

print(f"Version de MLflow : {mlflow.__version__}")
print(f"Version de ChromaDB : {chromadb.__version__}")

Cela confirmera les versions des bibliothèques clés que nous allons utiliser.

Compréhension des capacités de suivi LLM de MLflow

Le système de suivi LLM de MLflow s’appuie sur ses capacités de suivi existantes, en ajoutant des fonctionnalités spécifiquement conçues pour les aspects uniques des LLM. Décomposons les composants clés :

Exécutions et expériences

Dans MLflow, une “exécution” représente une seule exécution de votre code de modèle, tandis qu’une “expérience” est une collection d’exécutions liées. Pour les LLM, une exécution peut représenter une seule requête ou un lot de prompts traités par le modèle.

Composants de suivi clés

1. Paramètres : ce sont des configurations d’entrée pour votre LLM, telles que la température, top_k ou max_tokens. Vous pouvez les enregistrer à l’aide de mlflow.log_param() ou mlflow.log_params().
2. Métriques : mesures quantitatives des performances de votre LLM, comme la précision, la latence ou des scores personnalisés. Utilisez mlflow.log_metric() ou mlflow.log_metrics() pour suivre ces métriques.
3. Prédictions : pour les LLM, il est crucial d’enregistrer à la fois les prompts d’entrée et les sorties du modèle. MLflow stocke ces prédictions sous forme d’artefacts au format CSV en utilisant mlflow.log_table().
4. Artefacts : tout fichier ou donnée supplémentaire lié à votre exécution LLM, tel que des points de contrôle de modèle, des visualisations ou des échantillons de données. Utilisez mlflow.log_artifact() pour stocker ces artefacts.

Examinons un exemple de base d’enregistrement d’une exécution LLM :

Cet exemple démontre l’enregistrement de paramètres, de métriques et de l’entrée/sortie sous forme d’artefact de tableau.

import mlflow
import openai

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

with mlflow.start_run():
prompt = "Expliquez le concept d'apprentissage automatique en termes simples."

# Enregistrement des paramètres
mlflow.log_param("model", "text-davinci-002")
mlflow.log_param("max_tokens", 100)

# Interrogation du LLM et enregistrement du résultat
result = query_llm(prompt)
mlflow.log_metric("response_length", len(result))

# Enregistrement du prompt et de la réponse
mlflow.log_table("prompt_responses", {"prompt": [prompt], "response": [result]})

print(f"Réponse : {result}")

Déploiement de LLM avec MLflow

MLflow propose des capacités puissantes pour déployer des LLM, facilitant ainsi le service de vos modèles dans des environnements de production. Explorons comment déployer un LLM en utilisant les fonctionnalités de déploiement de MLflow.

Création d’un point de terminaison

Tout d’abord, nous allons créer un point de terminaison pour notre LLM en utilisant le client de déploiement de MLflow :

import mlflow
from mlflow.deployments import get_deploy_client

# Initialisation du client de déploiement
client = get_deploy_client("databricks")

# Définition de la configuration du point de terminaison
endpoint_name = "llm-endpoint"
endpoint_config = {
"served_entities": [{
"name": "gpt-model",
"external_model": {
"name": "gpt-3.5-turbo",
"provider": "openai",
"task": "llm/v1/completions",
"openai_config": {
"openai_api_type": "azure",
"openai_api_key": "{{secrets/scope/openai_api_key}}",
"openai_api_base": "{{secrets/scope/openai_api_base}}",
"openai_deployment_name": "gpt-35-turbo",
"openai_api_version": "2023-05-15",
},
},
}],
}

# Création du point de terminaison
client.create_endpoint(name=endpoint_name, config=endpoint_config)

Ce code configure un point de terminaison pour un modèle GPT-3.5-turbo en utilisant Azure OpenAI. Notez l’utilisation de secrets Databricks pour la gestion sécurisée des clés d’API.

Test du point de terminaison

Une fois le point de terminaison créé, nous pouvons le tester :

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

response = client.predict(
endpoint=endpoint_name,
inputs={"prompt": "Expliquez le concept de réseaux de neurones brièvement.","max_tokens": 100,},)

print(response)

Cela enverra un prompt à notre modèle déployé et retournera la réponse générée.

Évaluation de LLM avec MLflow

L’évaluation est cruciale pour comprendre les performances et le comportement de vos LLM. MLflow propose des outils complets pour évaluer les LLM, y compris des métriques intégrées et personnalisées.

Préparation de votre LLM pour l’évaluation

Pour évaluer votre LLM avec mlflow.evaluate(), votre modèle doit être sous l’une des formes suivantes :

1. Une instance de mlflow.pyfunc.PyFuncModel ou un URI pointant vers un modèle MLflow enregistré.
2. Une fonction Python qui prend des entrées de type chaîne et retourne une chaîne unique.
3. Un point de terminaison de déploiement MLflow.
4. Définir model=None et inclure les sorties de modèle dans les données d’évaluation.

Examinons un exemple en utilisant un modèle MLflow enregistré :

import mlflow
import openai

with mlflow.start_run():
system_prompt = "Répondez à la question suivante de manière concise."
logged_model_info = mlflow.openai.log_model(
model="gpt-3.5-turbo",
task=openai.chat.completions,
artifact_path="model",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": "{question}"},
],
)

# Préparation des données d'évaluation
eval_data = pd.DataFrame({
"question": ["Qu'est-ce que l'apprentissage automatique ?", "Expliquez les réseaux de neurones."],
"ground_truth": [
"L'apprentissage automatique est un sous-ensemble de l'IA qui permet aux systèmes d'apprendre et de s'améliorer à partir de l'expérience sans programmation explicite.",
"Les réseaux de neurones sont des systèmes de calcul inspirés des réseaux de neurones biologiques, consistant en des nœuds interconnectés qui traitent et transmettent des informations.",
]
})

# Évaluation du modèle
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
)

print(f"Métriques d'évaluation : {results.metrics}")

Cet exemple enregistre un modèle OpenAI, prépare les données d’évaluation, puis évalue le modèle en utilisant les métriques intégrées de MLflow pour les tâches de question-réponse.

Métriques d’évaluation personnalisées

MLflow permet de définir des métriques d’évaluation personnalisées pour les LLM. Voici un exemple de création d’une métrique personnalisée pour évaluer le professionnalisme des réponses :

from mlflow.metrics.genai import EvaluationExample, make_genai_metric

professionalism = make_genai_metric(
name="professionalism",
definition="Mesure du style de communication formel et approprié.",
grading_prompt=(
"Évaluez le professionnalisme de la réponse sur une échelle de 0 à 4 :\n"
"0 : Extrêmement décontracté ou inapproprié\n"
"1 : Décontracté mais respectueux\n"
"2 : Modérément formel\n"
"3 : Professionnel et approprié\n"
"4 : Très formel et expertement rédigé"
),
examples=[
EvaluationExample(
input="Qu'est-ce que MLflow ?",
output="MLflow est comme votre outil de gestion de projets ML amical. C'est super cool !",
score=1,
justification="La réponse est décontractée et utilise un langage informel.",
),
EvaluationExample(
input="Qu'est-ce que MLflow ?",
output="MLflow est une plate-forme open-source pour le cycle de vie de l'apprentissage automatique, y compris l'expérimentation, la reproductibilité et le déploiement.",
score=4,
justification="La réponse est formelle, concise et professionnellement rédigée.",
)
],
model="openai:/gpt-3.5-turbo-16k",
parameters={"temperature": 0.0},
aggregations=["mean", "variance"],
greater_is_better=True,
)

# Utilisation de la métrique personnalisée dans l'évaluation
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
extra_metrics=[professionalism]
)

print(f"Score de professionnalisme : {results.metrics['professionalism_mean']}")

Cette métrique personnalisée utilise GPT-3.5-turbo pour évaluer le professionnalisme des réponses, démontrant comment vous pouvez exploiter les LLM eux-mêmes pour l’évaluation.

Techniques d’évaluation avancées de LLM

À mesure que les LLM deviennent plus sophistiqués, les techniques d’évaluation évoluent également. Explorons certaines méthodes d’évaluation avancées à l’aide de MLflow.

Évaluation de la génération assistée par récupération (RAG)

Les systèmes RAG combinent la puissance des modèles de récupération et de génération. Évaluer les systèmes RAG nécessite d’évaluer à la fois les composants de récupération et de génération. Voici comment vous pouvez configurer un système RAG et l’évaluer à l’aide de 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

# Chargement et prétraitement des documents
loader = WebBaseLoader(["https://mlflow.org/docs/latest/index.html"])
documents = loader.load()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

# Création d'un magasin de vecteurs
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)

# Création d'une chaîne RAG
llm = OpenAI(temperature=0)
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=vectorstore.as_retriever(),
return_source_documents=True
)

# Fonction d'évaluation
def evaluate_rag(question):
result = qa_chain({"query": question})
return result["result"], [doc.page_content for doc in result["source_documents"]]

# Préparation des données d'évaluation
eval_questions = [
"Qu'est-ce que MLflow ?",
"Comment MLflow gère-t-il le suivi des expériences ?",
"Quels sont les principaux composants de MLflow ?",
]

# Évaluation à l'aide de MLflow
with mlflow.start_run():
for question in eval_questions:
answer, sources = evaluate_rag(question)

mlflow.log_param(f"question", question)
mlflow.log_metric("num_sources", len(sources))
mlflow.log_text(answer, f"answer_{question}.txt")

for i, source in enumerate(sources):
mlflow.log_text(source, f"source_{question}_{i}.txt")

# Enregistrement de métriques personnalisées
mlflow.log_metric("avg_sources_per_question", sum(len(evaluate_rag(q)[1]) for q in eval_questions) / len(eval_questions))

Cet exemple configure un système RAG en utilisant LangChain et Chroma, puis l’évalue en enregistrant les questions, les réponses, les documents récupérés et les métriques personnalisées dans MLflow.

Évaluation de la stratégie de découpage

La façon dont vous découpez vos documents peut avoir un impact significatif sur les performances de RAG. MLflow peut vous aider à évaluer différentes stratégies de découpage :

import mlflow
from langchain.text_splitter import CharacterTextSplitter, TokenTextSplitter

def evaluate_chunking_strategy(documents, chunk_size, chunk_overlap, splitter_class):
splitter = splitter_class(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
chunks = splitter.split_documents(documents)

with mlflow.start_run():
mlflow.log_param("chunk_size", chunk_size)
mlflow.log_param("chunk_overlap", chunk_overlap)
mlflow.log_param("splitter_class", splitter_class.__name__)

mlflow.log_metric("num_chunks", len(chunks))
mlflow.log_metric("avg_chunk_length", sum(len(chunk.page_content) for chunk in chunks) / len(chunks))

# Évaluation des performances de récupération (simplifiée)
correct_retrievals = sum(1 for _ in range(100) if simulate_retrieval(chunks))
mlflow.log_metric("retrieval_accuracy", correct_retrievals / 100)

# Évaluation de différentes stratégies
for chunk_size in [500, 1000, 1500]:
for chunk_overlap in [0, 50, 100]:
for splitter_class in [CharacterTextSplitter, TokenTextSplitter]:
evaluate_chunking_strategy(documents, chunk_size, chunk_overlap, splitter_class)

# Comparaison des résultats
best_run = mlflow.search_runs(order_by=["metrics.retrieval_accuracy DESC"]).iloc[0]
print(f"Meilleure stratégie de découpage : {best_run['params.splitter_class']} avec taille {best_run['params.chunk_size']} et chevauchement {best_run['params.chunk_overlap']}")

Ce script évalue différentes combinaisons de tailles de découpage, de chevauchement et de méthodes de découpage, en enregistrant les résultats dans MLflow pour une comparaison facile.

Visualisation des résultats d’évaluation de LLM

MLflow propose diverses façons de visualiser vos résultats d’évaluation de LLM. Voici quelques techniques :

Utilisation de l’interface utilisateur MLflow

Après avoir exécuté vos évaluations, vous pouvez utiliser l’interface utilisateur MLflow pour visualiser les résultats :

1. Lancer l’interface utilisateur MLflow : mlflow ui
2. Ouvrir un navigateur web et accéder à http://localhost:5000
3. Sélectionner votre expérience et vos exécutions pour afficher les métriques, les paramètres et les artefacts

Visualisations personnalisées

Vous pouvez créer des visualisations personnalisées de vos résultats d’évaluation en utilisant des bibliothèques comme Matplotlib ou Plotly, puis les enregistrer comme artefacts :

import matplotlib.pyplot as plt
import mlflow

def plot_metric_comparison(metric_name, run_ids):
plt.figure(figsize=(10, 6))
for run_id in run_ids:
run = mlflow.get_run(run_id)
metric_values = mlflow.get_metric_history(run_id, metric_name)
plt.plot([m.step for m in metric_values], [m.value for m in metric_values], label=run.data.tags.get("mlflow.runName", run_id))

plt.title(f"Comparaison de {metric_name}")
plt.xlabel("Étape")
plt.ylabel(metric_name)
plt.legend()

# Enregistrement et sauvegarde de la visualisation
plt.savefig(f"{metric_name}_comparison.png")
mlflow.log_artifact(f"{metric_name}_comparison.png")

# Utilisation
with mlflow.start_run():
plot_metric_comparison("answer_relevance", ["run_id_1", "run_id_2", "run_id_3"])

Cette fonction crée un graphique de ligne comparant une métrique spécifique sur plusieurs exécutions et l’enregistre comme artefact.

Alternatives à MLflow open source

https://valohai.com/managed-vs-open-source-mlops/

Il existe de nombreuses alternatives à MLflow open source pour gérer les flux de travail d’apprentissage automatique, chacune offrant des fonctionnalités et des intégrations uniques.

MLflow géré par Databricks

MLflow géré, hébergé par Databricks, propose les fonctionnalités de base de MLflow open source mais avec des avantages supplémentaires tels que l’intégration transparente avec l’écosystème Databricks, des fonctionnalités de sécurité avancées et une infrastructure gérée. Cela en fait un excellent choix pour les organisations nécessitant une sécurité et une évolutivité robustes.

Azure Machine Learning

Azure Machine Learning offre une solution d’apprentissage automatique complète sur la plate-forme cloud Azure de Microsoft. Il propose une compatibilité avec les composants MLflow tels que le registre de modèles et le suivi d’expériences, bien qu’il ne soit pas basé sur MLflow.

Plateformes ML dédiées

Plusieurs entreprises proposent des produits ML gérés avec des fonctionnalités diverses :

• neptune.ai : se concentre sur le suivi d’expériences et la gestion de modèles.
• Weights & Biases : propose un suivi d’expériences complet, une versionning de données et des outils de collaboration.
• Comet ML : fournit un suivi d’expériences, une surveillance de la production de modèles et un enregistrement de données.
• Valohai : se spécialise dans les pipelines et l’orchestration d’apprentissage automatique.

Metaflow

Metaflow, développé par Netflix, est un framework open source conçu pour orchestrer les flux de données et les pipelines d’apprentissage automatique. Bien qu’il excelle dans la gestion de déploiements à grande échelle, il manque de fonctionnalités de suivi d’expériences et de gestion de modèles complètes par rapport à MLflow.

Amazon SageMaker et Google Vertex AI

Les deux Amazon SageMaker et Google Vertex AI proposent des solutions MLOps complètes intégrées à leurs plateformes cloud respectives. Ces services offrent des outils robustes pour construire, former et déployer des modèles d’apprentissage automatique à grande échelle.

Détails de la comparaison

MLflow géré vs. MLflow open source

MLflow géré par Databricks offre plusieurs avantages par rapport à la version open source, notamment :

• Configuration et déploiement : intégration transparente avec Databricks réduit le temps de configuration et d’effort.
• Évolutivité : capable de gérer des charges de travail d’apprentissage automatique à grande échelle avec facilité.
• Sécurité et gestion : fonctionnalités de sécurité intégrées telles que le contrôle d’accès basé sur les rôles (RBAC) et le chiffrement des données.
• Intégration : intégration approfondie avec les services Databricks, améliorant l’interopérabilité et la fonctionnalité.
• Stockage et sauvegarde de données : stratégies de sauvegarde automatisées garantissent la sécurité et la fiabilité des données.
• Coût : les utilisateurs paient pour la plate-forme, le stockage et les ressources de calcul.
• Support et maintenance : support et maintenance dédiés fournis par Databricks.

Conclusion

Le suivi de grands modèles de langage avec MLflow fournit un cadre robuste pour gérer les complexités du développement, de l’évaluation et du déploiement de LLM. En suivant les meilleures pratiques et en exploitant les fonctionnalités avancées présentées dans ce guide, vous pouvez créer des expériences LLM plus organisées, reproductibles et éclairantes.

N’oubliez pas que le domaine des LLM évolue rapidement, et de nouvelles techniques d’évaluation et de suivi émergent constamment. Restez à jour avec les dernières versions de MLflow et les recherches sur les LLM pour affiner continuellement vos processus de suivi et d’évaluation.

À mesure que vous appliquez ces techniques dans vos projets, vous développerez une compréhension plus approfondie du comportement et des performances de vos LLM, conduisant à des modèles de langage plus efficaces et fiables.