Śledzenie Dużych Modeli Językowych (LLM) z MLflow: Kompletny Przewodnik

Konfiguracja Środowiska

Przed rozpoczęciem śledzenia LLM z MLflow, musimy skonfigurować nasze środowisko rozwojowe. Będziemy musieli zainstalować MLflow i kilka innych kluczowych bibliotek:

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

Po instalacji, dobrą praktyką jest ponowne uruchomienie środowiska Python, aby upewnić się, że wszystkie biblioteki są prawidłowo załadowane. W notesie Jupyter, możemy użyć:

import mlflow
import chromadb

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

To potwierdzi wersje kluczowych bibliotek, których będziemy używać.

Zrozumienie Możliwości Śledzenia MLflow

System śledzenia MLflow opiera się na istniejących możliwościach śledzenia, dodając funkcje specjalnie zaprojektowane dla unikalnych aspektów LLM. Rozbijmy kluczowe komponenty:

Uruchomienia i Eksperymenty

W MLflow, “uruchomienie” reprezentuje pojedyncze wykonanie kodu modelu, podczas gdy “eksperyment” jest kolekcją powiązanych uruchomień. Dla LLM, uruchomienie może reprezentować pojedyncze zapytanie lub partię promptów przetworzonych przez model.

Kluczowe Komponenty Śledzenia

1. Parametry: Są to konfiguracje wejściowe dla Twojego LLM, takie jak temperatura, top_k lub max_tokens. Możesz je zalogować za pomocą mlflow.log_param() lub mlflow.log_params().
2. Metryki: Ilościowe miary wydajności Twojego LLM, takie jak dokładność, opóźnienie lub niestandardowe wyniki. Użyj mlflow.log_metric() lub mlflow.log_metrics(), aby śledzić te metryki.
3. Przewidywania: Dla LLM, jest kluczowe zalogowanie zarówno wejściowych promptów, jak i wyjściowych odpowiedzi. MLflow przechowuje je jako artefakty w formacie CSV za pomocą mlflow.log_table().
4. Artefakty: Dowolne dodatkowe pliki lub dane związane z uruchomieniem LLM, takie jak punkty kontrolne modelu, wizualizacje lub próbki danych. Użyj mlflow.log_artifact(), aby przechować je.

Zobaczmy podstawowy przykład logowania uruchomienia LLM:

Ten przykład demonstruje logowanie parametrów, metryk i wejściowych/wyjściowych danych jako artefakt tabeli.

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 = "Wyjaśnij pojęcie machine learning w prosty sposób."

# Loguj parametry
mlflow.log_param("model", "text-davinci-002")
mlflow.log_param("max_tokens", 100)

# Zapytaj LLM i zaloguj wynik
result = query_llm(prompt)
mlflow.log_metric("response_length", len(result))

# Loguj prompt i odpowiedź
mlflow.log_table("prompt_responses", {"prompt": [prompt], "response": [result]})

print(f"Odpowiedź: {result}")

Wdrożenie LLM z MLflow

MLflow oferuje potężne możliwości wdrożenia LLM, ułatwiając ich obsługę w środowiskach produkcyjnych. Zobaczmy, jak wdrożyć LLM za pomocą funkcji wdrożeniowych MLflow:

Tworzenie Punktu Końcowego

Najpierw utworzymy punkt końcowy dla naszego LLM za pomocą klienta wdrożeniowego MLflow:

import mlflow
from mlflow.deployments import get_deploy_client

# Inicjuj klienta wdrożeniowego
client = get_deploy_client("databricks")

# Zdefiniuj konfigurację punktu końcowego
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",
},
},
}],
}

# Utwórz punkt końcowy
client.create_endpoint(name=endpoint_name, config=endpoint_config)

Ten kod ustawia punkt końcowy dla modelu GPT-3.5-turbo przy użyciu Azure OpenAI. Zwróć uwagę na użycie tajemnic Databricks do bezpiecznego zarządzania kluczami API.

Testowanie Punktu Końcowego

Po utworzeniu punktu końcowego, możemy go przetestować:

response = client.predict(
endpoint=endpoint_name,
inputs={"prompt": "Wyjaśnij pojęcie sieci neuronowych krótko.", "max_tokens": 100,},
)

print(response)

To wyśle prompt do naszego wdrożonego modelu i zwróci wygenerowaną odpowiedź.

Ocena LLM z MLflow

Ocena jest kluczowa dla zrozumienia wydajności i zachowania się Twoich LLM. MLflow oferuje kompleksowe narzędzia do oceny LLM, w tym wbudowane i niestandardowe metryki.

Przygotowanie LLM do Oceny

Aby ocenić Twój LLM za pomocą mlflow.evaluate(), Twój model musi być w jednej z następujących form:

1. Instancja mlflow.pyfunc.PyFuncModel lub adres URL wskazujący na zalogowany model MLflow.
2. Funkcja Python, która przyjmuje dane wejściowe jako ciągi i zwraca pojedynczy ciąg.
3. Adres URL punktu końcowego wdrożenia MLflow.
4. Ustaw model=None i dołącz wyjścia modelu do danych oceny.

Zobaczmy przykład z zalogowanym modelem MLflow:

import mlflow
import openai

with mlflow.start_run():
system_prompt = "Odpowiedz na następujące pytanie zwięźle."
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}"},
],
)

# Przygotuj dane oceny
eval_data = pd.DataFrame({
"question": ["Co to jest machine learning?", "Wyjaśnij sieci neuronowe."],
"ground_truth": [
"Machine learning to podzbiór AI, który umożliwia systemom uczenie się i poprawianie bez jawnej programacji.",
"Sieci neuronowe to systemy obliczeniowe inspirowane biologicznymi sieciami neuronowymi, składające się z połączonych węzłów, które przetwarzają i przekazują informacje."
]
})

# Oceń model
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
)

print(f"Metryki oceny: {results.metrics}")

Ten przykład loguje model OpenAI, przygotowuje dane oceny, a następnie ocenia model za pomocą wbudowanych metryk MLflow dla zadań question-answering.

Niestandardowe Metryki Oceny

MLflow pozwala na definiowanie niestandardowych metryk do oceny LLM. Zobaczmy przykład tworzenia niestandardowej metryki do oceny profesjonalizmu odpowiedzi:

from mlflow.metrics.genai import EvaluationExample, make_genai_metric

professionalism = make_genai_metric(
name="professionalism",
definition="Miara formalnego i odpowiedniego stylu komunikacji.",
grading_prompt=(
"Ocena profesjonalizmu odpowiedzi w skali 0-4:\n"
"0: Ekstremalnie swobodny lub nieodpowiedni\n"
"1: Swobodny, ale szanujący\n"
"2: Umiarkowanie formalny\n"
"3: Profesjonalny i odpowiedni\n"
"4: Bardzo formalny i ekspertowo przygotowany"
),
examples=[
EvaluationExample(
input="Co to jest MLflow?",
output="MLflow to jak Twoja przyjazna narzędzia do zarządzania projektami ML. Jest super!",
score=1,
justification="Odpowiedź jest swobodna i używa nieformalnego języka."
),
EvaluationExample(
input="Co to jest MLflow?",
output="MLflow to otwarta platforma dla cyklu życia modeli machine learning, w tym eksperymentowania, powtarzalności i wdrożenia.",
score=4,
justification="Odpowiedź jest formalna, zwięzła i profesjonalnie sformułowana."
)
],
model="openai:/gpt-3.5-turbo-16k",
parameters={"temperature": 0.0},
aggregations=["mean", "variance"],
greater_is_better=True,
)

# Użyj niestandardowej metryki w ocenie
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
extra_metrics=[professionalism]
)

print(f"Wynik profesjonalizmu: {results.metrics['professionalism_mean']}")

Ta niestandardowa metryka używa GPT-3.5-turbo do oceny profesjonalizmu odpowiedzi, pokazując, jak można wykorzystać same LLM do oceny.

Zaawansowane Techniki Oceny LLM

Im bardziej LLM stają się zaawansowane, tym bardziej zaawansowane stają się techniki ich oceny. Zobaczmy kilka zaawansowanych metod oceny przy użyciu MLflow:

Ocena Systemów z Wzmocnionym Pobieraniem (RAG)

Systemy RAG łączą moc modeli opartych na pobieraniu i generowaniu. Ocena systemów RAG wymaga oceny zarówno składników pobierania, jak i generowania. Zobaczmy, jak skonfigurować system RAG i ocenić go za pomocą 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

# Ładuj i przetwarzaj dokumenty
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)

# Tworzy przechowywalnię wektorową
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)

# Tworzy łańcuch RAG
llm = OpenAI(temperature=0)
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=vectorstore.as_retriever(),
return_source_documents=True
)

# Funkcja oceny
def evaluate_rag(question):
result = qa_chain({"query": question})
return result["result"], [doc.page_content for doc in result["source_documents"]]

# Przygotuj dane oceny
eval_questions = [
"Co to jest MLflow?",
"Jak MLflow obsługuje śledzenie eksperymentów?",
"Jakie są główne składniki MLflow?",
]

# Oceń za pomocą 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")

# Loguj niestandardowe metryki
mlflow.log_metric("avg_sources_per_question", sum(len(evaluate_rag(q)[1]) for q in eval_questions) / len(eval_questions))

Ten przykład konfiguruje system RAG przy użyciu LangChain i Chroma, a następnie ocenia go, logując pytania, odpowiedzi, źródła i niestandardowe metryki do MLflow.

Ocena Strategii Podziału

Sposób, w jaki dzielisz dokumenty, może znacznie wpłynąć na wydajność systemu RAG. MLflow może pomóc w ocenie różnych strategii podziału:

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

# Uproszczona ocena wydajności pobierania (uproszczona)
correct_retrievals = sum(1 for _ in range(100) if simulate_retrieval(chunks))
mlflow.log_metric("retrieval_accuracy", correct_retrievals / 100)

# Oceń różne strategie
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)

# Porównaj wyniki
best_run = mlflow.search_runs(order_by=["metrics.retrieval_accuracy DESC"]).iloc[0]
print(f"Najlepsza strategia podziału: {best_run['params.splitter_class']} z rozmiarem {best_run['params.chunk_size']} i nachodzeniem {best_run['params.chunk_overlap']}")

Ten skrypt ocenia różne kombinacje rozmiarów chunków, nachodzenia i metod podziału, logując wyniki do MLflow do łatwego porównania.

Wizualizacja Wyników Oceny LLM

MLflow oferuje różne sposoby wizualizacji wyników oceny LLM:

Używanie Interfejsu MLflow

Po uruchomieniu oceny, możesz użyć interfejsu MLflow do wizualizacji wyników:

1. Uruchom interfejs MLflow: mlflow ui
2. Otwórz przeglądarkę i przejdź do http://localhost:5000
3. Wybierz eksperyment i uruchomienia, aby wyświetlić metryki, parametry i artefakty

Niestandardowe Wizualizacje

Możesz tworzyć niestandardowe wizualizacje wyników oceny za pomocą bibliotek takich jak Matplotlib lub Plotly, a następnie logować je jako artefakty:

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"Porównanie {metric_name}")
plt.xlabel("Krok")
plt.ylabel(metric_name)
plt.legend()

# Zapisz i zaloguj wykres
plt.savefig(f"{metric_name}_comparison.png")
mlflow.log_artifact(f"{metric_name}_comparison.png")

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

Ta funkcja tworzy wykres liniowy porównujący określoną metrykę w różnych uruchomieniach i loguje go jako artefakt.

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

Alternatywy dla MLflow Open Source

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

Istnieje wiele alternatyw dla MLflow Open Source do zarządzania przepływami pracy machine learning, każda oferująca unikalne funkcje i integracje.

Managed MLflow by Databricks

Managed MLflow, hostowany przez Databricks, oferuje podstawowe funkcjonalności MLflow Open Source, ale z dodatkowymi korzyściami, takimi jak bezproblemowa integracja z ekosystemem Databricks, zaawansowane funkcje bezpieczeństwa i zarządzane infrastruktury. To sprawia, że jest to doskonały wybór dla organizacji wymagających solidnego bezpieczeństwa i skalowalności.

Azure Machine Learning

Azure Machine Learning oferuje kompleksowe rozwiązanie machine learning na platformie Azure. Zapewnia zgodność z komponentami MLflow, takimi jak rejestry modeli i śledzenie eksperymentów, chociaż nie opiera się bezpośrednio na MLflow.

Dedicated ML Platforms

Kilka firm oferuje zarządzane produkty ML z różnymi funkcjami:

• neptune.ai: Koncentruje się na śledzeniu eksperymentów i zarządzaniu modelami.
• Weights & Biases: Oferuje obszerny śledzenie eksperymentów, wersjonowanie zbiorów danych i narzędzia współpracy.
• Comet ML: Zapewnia śledzenie eksperymentów, monitorowanie modeli w produkcji i logowanie danych.
• Valohai: Specjalizuje się w pipeline’ach machine learning i orchestracji.

Metaflow

Metaflow, opracowany przez Netflix (NFLX ), jest otwartym frameworkiem do orchestracji przepływów danych i pipeline’ów ML. Chociaż wyróżnia się w zarządzaniu dużymi wdrożeniami, brakuje mu kompleksowych funkcji śledzenia eksperymentów i zarządzania modelami w porównaniu z MLflow.

Amazon SageMaker i Google’s Vertex AI

Oba Amazon SageMaker (AMZN ) i Google’s Vertex AI (GOOGL ) oferują kompleksowe rozwiązania MLOps zintegrowane z ich platformami chmurowymi. Te usługi zapewniają solidne narzędzia do tworzenia, szkolenia i wdrażania modeli machine learning w dużym stopniu.

Szczegółowe Porównanie

Managed MLflow vs. Open Source MLflow

Managed MLflow przez Databricks oferuje kilka zalet w porównaniu z wersją Open Source:

• Konfiguracja i Wdrożenie: Bezproblemowa integracja z ekosystemem Databricks redukuje czas i wysiłek konfiguracyjny.
• Skalowalność: Może obsłużyć duże obciążenia machine learning z łatwością.
• Bezpieczeństwo i Zarządzanie: Funkcje bezpieczeństwa out-of-the-box, takie jak kontrola dostępu oparta na rolach (RBAC) i szyfrowanie danych.
• Integracja: Głęboka integracja z usługami Databricks, zwiększająca interoperacyjność i funkcjonalność.
• Przechowywanie i Kopie Bezpieczeństwa Danych: Zautomatyzowane strategie kopii zapewniają bezpieczeństwo i niezawodność danych.
• Koszt: Użytkownicy płacą za platformę, przechowywanie i zasoby obliczeniowe.
• Wsparcie i Konserwacja: Dedykowane wsparcie i konserwacja zapewnione przez Databricks.

Podsumowanie

Śledzenie Dużych Modeli Językowych z MLflow oferuje solidną ramę do zarządzania złożonościami rozwoju, oceny i wdrożenia LLM. Przez stosowanie najlepszych praktyk i wykorzystanie zaawansowanych funkcji opisanych w tym przewodniku, możesz tworzyć bardziej zorganizowane, powtarzalne i przekonywujące eksperymenty LLM.

Pamiętaj, że obszar LLM rozwija się dynamicznie, a nowe techniki oceny i śledzenia są ciągle rozwijane. Zachowaj aktualność z najnowszymi wersjami MLflow i badaniami nad LLM, aby nieustannie doskonalić procesy śledzenia i oceny.

Gdy zastosujesz te techniki w swoich projektach, rozwiniesz głębsze zrozumienie zachowania i wydajności swoich LLM, prowadząc do bardziej skutecznych i niezawodnych modeli językowych.