बड़ी भाषा मॉडल (LLM) को MLflow के साथ ट्रैक करना: एक पूर्ण गाइड

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"MLflow संस्करण: {mlflow.__version__}")
print(f"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 = "मशीन लर्निंग की अवधारणा को सरल शब्दों में समझाएं।"
# पैरामीटर लॉग करें
mlflow.log_param("मॉडल", "text-davinci-002")
mlflow.log_param("max_tokens", 100)</p>

<p># LLM को प्रश्न करें और परिणाम लॉग करें
result = query_llm(prompt)
mlflow.log_metric("response_length", len(result))</p>

<p># प्रोम्प्ट और प्रतिक्रिया लॉग करें
mlflow.log_table("prompt_responses", {"prompt": [prompt], "response": [result]})</p>

<p>print(f"प्रतिक्रिया: {result}")

import mlflow
from mlflow.deployments import get_deploy_client

<p># तैनाती क्लाइंट को आरंभ करें
client = get_deploy_client("databricks")</p>

<p># एंडपॉइंट कॉन्फ़िगरेशन परिभाषित करें
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># एंडपॉइंट बनाएं
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": "न्यूरल नेटवर्क की अवधारणा को संक्षेप में समझाएं।", "max_tokens": 100,},
)</p>

print(response)

यह हमारे तैनात मॉडल को एक प्रोम्प्ट भेजेगा और उत्पन्न प्रतिक्रिया को वापस करेगा।

MLflow के साथ LLM मूल्यांकन

मूल्यांकन LLM के प्रदर्शन और व्यवहार को समझने के लिए महत्वपूर्ण है। MLflow LLM के मूल्यांकन के लिए व्यापक उपकरण प्रदान करता है, जिसमें निर्मित और कस्टम मेट्रिक्स दोनों शामिल हैं।

LLM को मूल्यांकन के लिए तैयार करना

आपके LLM को mlflow.evaluate() के साथ मूल्यांकन करने के लिए, आपका मॉडल निम्नलिखित रूपों में से एक में होना चाहिए:

1. एक mlflow.pyfunc.PyFuncModel उदाहरण या एक URI जो एक लॉग किए गए MLflow मॉडल को इंगित करता है।
2. एक पायथन फ़ंक्शन जो स्ट्रिंग इनपुट लेता है और एक स्ट्रिंग आउटपुट देता है।
3. एक MLflow तैनाती एंडपॉइंट URI।
4. मॉडल को None पर सेट करें और मूल्यांकन डेटा में मॉडल आउटपुट शामिल करें।

आइए एक उदाहरण देखें जो एक लॉग किए गए MLflow मॉडल का उपयोग करता है:

import mlflow
import openai

<p>with mlflow.start_run():
system_prompt = "निम्नलिखित प्रश्न का उत्तर संक्षेप में दें।"
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># मूल्यांकन डेटा तैयार करें
eval_data = pd.DataFrame({
"question": ["मशीन लर्निंग क्या है?", "न्यूरल नेटवर्क की व्याख्या करें।"],
"ground_truth": [
"मशीन लर्निंग एक उपकरण है जो सिस्टम को अनुभव से सीखने और बेहतर बनाने में मदद करता है।",
"न्यूरल नेटवर्क जटिल डेटा को संसाधित करने के लिए एक प्रकार का मॉडल है।",
]
})</p>

<p># मॉडल का मूल्यांकन करें
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
)</p>

<p>print(f"मूल्यांकन मेट्रिक्स: {results.metrics}")

यह उदाहरण एक OpenAI मॉडल को लॉग करता है, मूल्यांकन डेटा तैयार करता है, और फिर MLflow के निर्मित मेट्रिक्स का उपयोग करके मॉडल का मूल्यांकन करता है।

कस्टम मूल्यांकन मेट्रिक्स

MLflow आपको LLM मूल्यांकन के लिए कस्टम मेट्रिक्स को परिभाषित करने की अनुमति देता है। यहाँ एक उदाहरण है जो प्रतिक्रियाओं की पेशेवरता का मूल्यांकन करने के लिए एक कस्टम मेट्रिक बनाता है:

from mlflow.metrics.genai import EvaluationExample, make_genai_metric

<p>professionalism = make_genai_metric(
name="professionalism",
definition="संचार शैली की औपचारिकता और उपयुक्तता का माप।",
grading_prompt=(
"उत्तर की पेशेवरता को 0-4 के पैमाने पर अंक दें:\n"
"0: बहुत ही अनौपचारिक या अनुचित\n"
"1: अनौपचारिक लेकिन सम्मानजनक\n"
"2: मध्यम रूप से औपचारिक\n"
"3: पेशेवर और उपयुक्त\n"
"4: अत्यधिक औपचारिक और विशेषज्ञ रूप से तैयार किया गया"
),
examples=[
EvaluationExample(
input="मशीन लर्निंग क्या है?",
output="मशीन लर्निंग एक उपकरण है जो सिस्टम को अनुभव से सीखने में मदद करता है।",
score=4,
justification="उत्तर औपचारिक, संक्षिप्त और पेशेवर रूप से शब्दित है।"
),
EvaluationExample(
input="न्यूरल नेटवर्क की व्याख्या करें।",
output="न्यूरल नेटवर्क जटिल डेटा को संसाधित करने के लिए एक प्रकार का मॉडल है।",
score=4,
justification="उत्तर स्पष्ट, संक्षिप्त और पेशेवर रूप से प्रस्तुत किया गया है।"
)
],
model="openai:/gpt-3.5-turbo-16k",
parameters={"temperature": 0.0},
aggregations=["mean", "variance"],
greater_is_better=True,
)</p>

<p># कस्टम मेट्रिक का उपयोग मूल्यांकन में
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
extra_metrics=[professionalism]
)</p>

<p>print(f"पेशेवरता स्कोर: {results.metrics['professionalism_mean']}")

यह कस्टम मेट्रिक LLM की प्रतिक्रियाओं की पेशेवरता का मूल्यांकन करने के लिए GPT-3.5-turbo का उपयोग करती है, जो LLM के मूल्यांकन में एक महत्वपूर्ण पहलू है।

उन्नत LLM मूल्यांकन तकनीकें

जैसे-जैसे LLM अधिक परिष्कृत होते जा रहे हैं, उनके मूल्यांकन के लिए नए तरीके भी विकसित हो रहे हैं। आइए MLflow का उपयोग करके कुछ उन्नत मूल्यांकन विधियों पर चर्चा करें:

पुनर्प्राप्ति-संवर्धित पीढ़ी (RAG) मूल्यांकन

RAG प्रणाली पुनर्प्राप्ति-आधारित और उत्पन्न मॉडलों की शक्ति को मिलाती है। RAG प्रणालियों का मूल्यांकन करने के लिए, पुनर्प्राप्ति और पीढ़ी दोनों घटकों का मूल्यांकन करना आवश्यक है। यहाँ एक उदाहरण है कि कैसे एक RAG प्रणाली सेट अप की जा सकती है और 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># दस्तावेज़ लोड और प्रीप्रोसेस करें
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># वेक्टर स्टोर बनाएं
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)</p>

<p># 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># मूल्यांकन फ़ंक्शन
def evaluate_rag(question):
result = qa_chain({"query": question})
return result["result"], [doc.page_content for doc in result["source_documents"]]</p>

<p># मूल्यांकन डेटा तैयार करें
eval_questions = [
"मशीन लर्निंग क्या है?",
"न्यूरल नेटवर्क की व्याख्या करें।",
"MLflow के मुख्य घटक क्या हैं?",
]</p>

<p># 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># कस्टम मेट्रिक्स लॉग करें
mlflow.log_metric("avg_sources_per_question", sum(len(evaluate_rag(q)[1]) for q in eval_questions) / len(eval_questions))

यह उदाहरण एक RAG प्रणाली सेट अप करता है और MLflow का उपयोग करके इसका मूल्यांकन करता है, जिसमें प्रश्न, उत्तर, पुनर्प्राप्त स्रोत, और कस्टम मेट्रिक्स लॉग किए जाते हैं।

चंकिंग रणनीति मूल्यांकन

दस्तावेजों को चंक में विभाजित करने का तरीका RAG प्रदर्शन पर महत्वपूर्ण प्रभाव डाल सकता है। MLflow आपको विभिन्न चंकिंग रणनीतियों का मूल्यांकन करने में मदद कर सकता है:

import mlflow
from langchain.text_splitter import CharacterTextSplitter, TokenTextSplitter

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

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

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

<p># पुनर्प्राप्ति प्रदर्शन का मूल्यांकन (सimplified)
correct_retrievals = sum(1 for _ in range(100) if simulate_retrieval(chunks))
mlflow.log_metric("retrieval_accuracy", correct_retrievals / 100)</p>

<p># विभिन्न रणनीतियों का मूल्यांकन करें
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)</p>

<p># परिणामों की तुलना करें
best_run = mlflow.search_runs(order_by=["metrics.retrieval_accuracy DESC"]).iloc[0]
print(f"सर्वश्रेष्ठ चंकिंग रणनीति: {best_run['params.splitter_class']} with size {best_run['params.chunk_size']} and overlap {best_run['params.chunk_overlap']}")

यह स्क्रिप्ट विभिन्न चंक आकार, ओवरलैप, और विभाजन विधियों का मूल्यांकन करती है और परिणामों को MLflow में लॉग करती है, जिससे तुलना करना आसान हो जाता है।

LLM मूल्यांकन परिणामों का दृश्यीकरण

MLflow आपके LLM मूल्यांकन परिणामों को दृश्यीकृत करने के लिए विभिन्न तरीके प्रदान करता है:

MLflow UI का उपयोग

मूल्यांकन चलाने के बाद, आप MLflow UI का उपयोग करके परिणामों को देख सकते हैं:

1. MLflow UI शुरू करें: mlflow ui
2. एक वेब ब्राउज़र में http://localhost:5000 पर जाएं
3. अपने प्रयोग और रन का चयन करें और मेट्रिक्स, पैरामीटर, और कलाकृतियों को देखें

कस्टम दृश्यीकरण

आप Matplotlib या Plotly जैसे पुस्तकालयों का उपयोग करके अपने मूल्यांकन परिणामों के कस्टम दृश्यीकरण बना सकते हैं और उन्हें कलाकृतियों के रूप में लॉग कर सकते हैं:

import matplotlib.pyplot as plt
import mlflow

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

<p>plt.title(f"{metric_name} तुलना")
plt.xlabel("चरण")
plt.ylabel(metric_name)
plt.legend()</p>

<p># प्लॉट को सहेजें और लॉग करें
plt.savefig(f"{metric_name}_comparison.png")
mlflow.log_artifact(f"{metric_name}_comparison.png")</p>

<p># उपयोग
with mlflow.start_run():
plot_metric_comparison("answer_relevance", ["run_id_1", "run_id_2", "run_id_3"])

यह फ़ंक्शन एक विशिष्ट मेट्रिक की तुलना के लिए एक रेखा ग्राफ़ बनाता है और इसे एक कलाकृति के रूप में लॉग करता है।

div]:bg-bg-300 [&_pre]:-mr-4 md:[&_pre]:-mr-9″>

ओपन सोर्स MLflow के विकल्प

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

ओपन सोर्स MLflow के लिए कई विकल्प हैं जो मशीन लर्निंग वर्कफ़्लो के प्रबंधन के लिए विभिन्न सुविधाएं और एकीकरण प्रदान करते हैं।

डेटाब्रिक्स द्वारा प्रबंधित MLflow

प्रबंधित MLflow, जो डेटाब्रिक्स द्वारा होस्ट किया जाता है, ओपन सोर्स MLflow की मुख्य कार्यक्षमता प्रदान करता है, लेकिन अतिरिक्त लाभों के साथ, जैसे कि डेटाब्रिक्स के पारिस्थितिकी तंत्र के साथ सहज एकीकरण, उन्नत सुरक्षा सुविधाएं, और प्रबंधित बुनियादी ढांचा। यह बड़े पैमाने पर मशीन लर्निंग कार्यभार को संभालने में सक्षम है और संगठनों के लिए एक उत्कृष्ट विकल्प है जिन्हें मजबूत सुरक्षा और मापनीयता की आवश्यकता होती है।

एज़्योर मशीन लर्निंग

एज़्योर मशीन लर्निंग माइक्रोसॉफ्ट के एज़्योर क्लाउड प्लेटफ़ॉर्म पर एक एंड-टू-एंड मशीन लर्निंग समाधान प्रदान करती है। यह MLflow के घटकों के साथ संगत है, जैसे कि मॉडल रजिस्ट्री और प्रयोग ट्रैकर, लेकिन यह MLflow पर आधारित नहीं है।

विशिष्ट ML प्लेटफ़ॉर्म

कई कंपनियां विभिन्न सुविधाओं के साथ प्रबंधित ML उत्पाद प्रदान करती हैं:

• neptune.ai: प्रयोग ट्रैकिंग और मॉडल प्रबंधन पर केंद्रित है।
• Weights & Biases: व्यापक प्रयोग ट्रैकिंग, डेटासेट संस्करणन, और सहयोग उपकरण प्रदान करता है।
• Comet ML: प्रयोग ट्रैकिंग, मॉडल उत्पादन निगरानी, और डेटा लॉगिंग प्रदान करता है।
• Valohai: मशीन लर्निंग पाइपलाइन और ऑर्केस्ट्रेशन पर विशेषज्ञता रखता है।

मेटाफ़्लो

मेटाफ़्लो, जो नेटफ्लिक्स द्वारा विकसित किया गया है, एक ओपन सोर्स फ्रेमवर्क है जो डेटा वर्कफ़्लो और ML पाइपलाइनों को ऑर्केस्ट्रेट करने के लिए डिज़ाइन किया गया है। हालांकि यह बड़े पैमाने पर तैनाती का प्रबंधन करने में उत्कृष्ट है, लेकिन यह MLflow की तुलना में व्यापक प्रयोग ट्रैकिंग और मॉडल प्रबंधन सुविधाएं प्रदान नहीं करता है।

अमेज़ॅन सेजमेकर और गूगल का वर्टेक्स AI

अमेज़ॅन सेजमेकर और गूगल का वर्टेक्स AI दोनों अपने-अपने क्लाउड प्लेटफ़ॉर्म पर एंड-टू-एंड MLOps समाधान प्रदान करते हैं। ये सेवाएं मॉडल के निर्माण, प्रशिक्षण, और तैनाती के लिए मजबूत उपकरण प्रदान करती हैं, लेकिन वे MLflow के साथ सीधे एकीकरण प्रदान नहीं करती हैं।

विस्तृत तुलना

प्रबंधित MLflow बनाम ओपन सोर्स MLflow

प्रबंधित MLflow डेटाब्रिक्स द्वारा प्रदान किया जाता है, जो ओपन सोर्स MLflow की तुलना में कई लाभ प्रदान करता है, जिनमें शामिल हैं:

• सेटअप और तैनाती: डेटाब्रिक्स के पारिस्थितिकी तंत्र के साथ सहज एकीकरण सेटअप समय और प्रयास को कम करता है।
• मापनीयता: बड़े पैमाने पर मशीन लर्निंग कार्यभार को संभालने में सक्षम है।
• सुरक्षा और प्रबंधन: बॉक्स से बाहर सुरक्षा सुविधाएं, जैसे कि भूमिका-आधारित एक्सेस कंट्रोल (RBAC) और डेटा एन्क्रिप्शन।
• एकीकरण: डेटाब्रिक्स की सेवाओं के साथ गहरा एकीकरण, जो अंतरक्रियाशीलता और कार्यक्षमता को बढ़ाता है।
• डेटा भंडारण और बैकअप: स्वचालित बैकअप रणनीतियां डेटा सुरक्षा और विश्वसनीयता सुनिश्चित करती हैं।
• लागत: उपयोगकर्ता प्लेटफ़ॉर्म, स्टोरेज, और कंप्यूट रिसोर्सेज़ के लिए भुगतान करते हैं।
• सUPPORT और रखरखाव: डेटाब्रिक्स द्वारा समर्पित समर्थन और रखरखाव प्रदान किया जाता है।

निष्कर्ष

MLflow के साथ बड़ी भाषा मॉडल को ट्रैक करना एक मजबूत ढांचा प्रदान करता है जो LLM विकास, मूल्यांकन, और तैनाती की जटिलताओं को प्रबंधित करने में मदद करता है। इस गाइड में दिए गए सर्वोत्तम प्रथाओं और उन्नत सुविधाओं का पालन करके, आप अपने LLM प्रयोगों को अधिक संगठित, पुनरुत्पादक, और सूचित बना सकते हैं।

LLM का क्षेत्र तेजी से विकसित हो रहा है, और नए मूल्यांकन और ट्रैकिंग तकनीकें निरंतर उभर रही हैं। MLflow के नवीनतम रिलीज़ और LLM अनुसंधान के साथ अप-टू-डेट रहें ताकि आप अपनी ट्रैकिंग और मूल्यांकन प्रक्रियाओं को लगातार परिष्कृत कर सकें।

जैसा कि आप अपनी परियोजनाओं में इन तकनीकों को लागू करते हैं, आप अपने LLM के व्यवहार और प्रदर्शन की गहरी समझ विकसित करेंगे, जो अधिक प्रभावी और विश्वसनीय भाषा मॉडल की ओर ले जाएगा।