Suivre les Modèles de Langage à Grande Échelle (LLM) avec MLflow : Un Guide Complet

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

import mlflow
import chromadb

<p>print(f"Version MLflow : {mlflow.__version__}")
print(f"Version ChromaDB : {chromadb.__version__}")

import mlflow
import openai

<p>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()</p>

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

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

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

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

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

import mlflow
from mlflow.deployments import get_deploy_client

<p># Initialisation du client de déploiement
client = get_deploy_client("databricks")</p>

<p># 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",
},
},
}],
}</p>

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

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

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

print(response)

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

Évaluation des 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 chaîne et retourne une chaîne unique.
3. Un URI de point de terminaison de déploiement MLflow.
4. Définir model=None et inclure les sorties du modèle dans les données d’évaluation.

Décomposons un exemple en utilisant un modèle MLflow enregistré :

import mlflow
import openai

<p>with mlflow.start_run():
system_prompt = "Répondez brièvement à la question suivante."
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}"},
],
)</p>

<p># 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, composés de nœuds interconnectés qui traitent et transmettent des informations.",
]
})</p>

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

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

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

Métriques d’Évaluation Personalisé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 la professionnalisme des réponses :

from mlflow.metrics.genai import EvaluationExample, make_genai_metric

<p>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 boîte à outils amie pour la gestion des projets d'apprentissage automatique. 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,
)</p>

<p># 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]
)</p>

<p>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 utiliser les LLM eux-mêmes pour l’évaluation.

Techniques d’Évaluation Avancées des LLM

À mesure que les LLM deviennent plus sophistiqués, les techniques d’évaluation évoluent également. Décomposons certaines méthodes d’évaluation avancées en utilisant MLflow.

Évaluation de la Génération Augmenté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. L’évaluation des 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 en utilisant 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># 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)</p>

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

<p># 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
)</p>

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

<p># 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 ?",
]</p>

<p># Évaluation en utilisant MLflow
with mlflow.start_run():
for question in eval_questions:
answer, sources = evaluate_rag(question)</p>

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

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

<p># 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))