Ako veľké jazykové modely (LLM) rastú v zložitosti a rozsahu, sledovanie ich výkonu, experimentov a nasadení je čoraz náročnejšie. Tu prichádza na rad MLflow – poskytuje komplexnú platformu na správu celého životného cyklu modelov strojového učenia vrátane LLM.
V tejto podrobnej príručke preskúmame, ako využiť MLflow na sledovanie, hodnotenie a nasadenie LLM. Pokryjeme všetko od nastavenia vášho prostredia až po pokročilé techniky vyhodnocovania s množstvom príkladov kódu a osvedčených postupov.
Funkčnosť MLflow vo veľkých jazykových modeloch (LLM)
MLflow sa stala kľúčovým nástrojom v komunite strojového učenia a dátovej vedy, najmä na riadenie životného cyklu modelov strojového učenia. Pokiaľ ide o veľké jazykové modely (LLM), MLflow ponúka robustnú sadu nástrojov, ktoré výrazne zefektívňujú proces vývoja, sledovania, vyhodnocovania a nasadzovania týchto modelov. Tu je prehľad toho, ako funguje MLflow v rámci priestoru LLM a aké výhody poskytuje inžinierom a dátovým vedcom.
Sledovanie a správa interakcií LLM
Systém sledovania LLM od MLflow je vylepšením jeho existujúcich možností sledovania prispôsobeným jedinečným potrebám LLM. Umožňuje komplexné sledovanie interakcií modelu vrátane nasledujúcich kľúčových aspektov:
- Parametre: Zaznamenávanie párov kľúč – hodnota, ktoré podrobne uvádzajú vstupné parametre pre LLM, ako sú parametre špecifické pre daný model, napr.
top_katemperature. To poskytuje kontext a konfiguráciu pre každé spustenie, čím sa zabezpečí zachytenie všetkých aspektov konfigurácie modelu. - Metriky: Kvantitatívne opatrenia, ktoré poskytujú prehľad o výkonnosti a presnosti LLM. Tieto sa môžu dynamicky aktualizovať v priebehu behu a ponúkajú prehľady v reálnom čase alebo po procese.
- Predpovede: Zachytenie vstupov odoslaných do LLM a zodpovedajúcich výstupov, ktoré sú uložené ako artefakty v štruktúrovanom formáte pre ľahké vyhľadávanie a analýzu.
- Artefakty: Okrem predpovedí môže MLflow ukladať rôzne výstupné súbory, ako sú vizualizácie, serializované modely a štruktúrované dátové súbory, čo umožňuje podrobnú dokumentáciu a analýzu výkonu modelu.
Tento štruktúrovaný prístup zaisťuje, že všetky interakcie s LLM sú starostlivo zaznamenávané, čo poskytuje komplexné sledovanie línie a kvality pre modely generujúce text.
Hodnotenie LLM
Hodnotenie LLM predstavuje jedinečné výzvy kvôli ich generatívnej povahe a nedostatku jedinej základnej pravdy. MLflow to zjednodušuje pomocou špecializovaných hodnotiacich nástrojov navrhnutých pre LLM. Medzi kľúčové vlastnosti patrí:
- Univerzálne hodnotenie modelu: Podporuje vyhodnocovanie rôznych typov LLM, či už ide o pyfunc model MLflow, identifikátor URI ukazujúci na registrovaný model MLflow alebo ľubovoľnú volateľnosť v jazyku Python predstavujúcu váš model.
- Komplexné metriky: Ponúka celý rad metrík prispôsobených pre hodnotenie LLM, vrátane metrík závislých od modelu SaaS (napr. relevantnosť odpovede) a metrík založených na funkciách (napr. ROUGE, Flesch Kincaid).
- Preddefinované metrické kolekcie: V závislosti od prípadu použitia, ako je odpovedanie na otázky alebo zhrnutie textu, poskytuje MLflow preddefinované metriky na zjednodušenie procesu hodnotenia.
- Vytvorenie vlastnej metriky: Umožňuje používateľom definovať a implementovať vlastné metriky tak, aby vyhovovali špecifickým potrebám hodnotenia, čím sa zvyšuje flexibilita a hĺbka hodnotenia modelu.
- Hodnotenie so statickými súbormi údajov: Umožňuje vyhodnocovanie statických množín údajov bez špecifikovania modelu, čo je užitočné pre rýchle hodnotenia bez opakovaného vyvodzovania modelu.
Nasadenie a integrácia
MLflow tiež podporuje bezproblémové nasadenie a integráciu LLM:
- MLflow Deployments Server: Funguje ako jednotné rozhranie na interakciu s viacerými poskytovateľmi LLM. Zjednodušuje integráciu, bezpečne spravuje poverenia a ponúka konzistentné rozhranie API. Tento server podporuje celý rad základných modelov od obľúbených predajcov SaaS, ako aj modely s vlastným hosťovaním.
- Jednotný koncový bod: Uľahčuje jednoduché prepínanie medzi poskytovateľmi bez zmeny kódu, čím sa minimalizujú prestoje a zvyšuje sa flexibilita.
- Integrované zobrazenie výsledkov: Poskytuje komplexné výsledky hodnotenia, ku ktorým je možné pristupovať priamo v kóde alebo prostredníctvom používateľského rozhrania MLflow na podrobnú analýzu.
MLflow je komplexná sada nástrojov a integrácií, vďaka ktorým je neoceniteľným prínosom pre inžinierov a dátových vedcov pracujúcich s pokročilými modelmi NLP.
Nastavenie vášho prostredia
Skôr než sa pustíme do sledovania LLM pomocou MLflow, nastavme naše vývojové prostredie. Budeme musieť nainštalovať MLflow a niekoľko ďalších kľúčových knižníc:
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 inštalácii je dobrým zvykom reštartovať prostredie Pythonu, aby ste sa uistili, že všetky knižnice sú správne načítané. V notebooku Jupyter môžete použiť:
import mlflow
import chromadb
print(f"MLflow version: {mlflow.__version__}")
print(f"ChromaDB version: {chromadb.__version__}")
Týmto potvrdíme verzie kľúčových knižníc, ktoré budeme používať.
Pochopenie možností sledovania LLM spoločnosti MLflow
Systém sledovania LLM spoločnosti MLflow stavia na existujúcich možnostiach sledovania a pridáva funkcie špeciálne navrhnuté pre jedinečné aspekty LLM. Rozoberme hlavné komponenty:
Behy a experimenty
V MLflow predstavuje „beh“ jedno spustenie kódu vášho modelu, zatiaľ čo „experiment“ je súbor súvisiacich spustení. V prípade LLM môže spustenie predstavovať jeden dotaz alebo dávku výziev spracovaných modelom.
Kľúčové komponenty sledovania
- Parametre: Toto sú konfigurácie vstupu pre váš LLM, ako napríklad teplota, top_k alebo max_tokens. Môžete ich prihlásiť pomocou
mlflow.log_param()alebomlflow.log_params(). - Metriky: Kvantitatívne merania výkonnosti vášho LLM, ako je presnosť, latencia alebo vlastné skóre. Použite
mlflow.log_metric()alebomlflow.log_metrics()sledovať tieto. - Predpovede: Pre LLM je dôležité zaznamenať vstupné výzvy aj výstupy modelu. MLflow ich ukladá ako artefakty vo formáte CSV pomocou
mlflow.log_table(). - Artefakty: Akékoľvek ďalšie súbory alebo údaje súvisiace s vaším spustením LLM, ako sú kontrolné body modelu, vizualizácie alebo vzorky množín údajov. Použite
mlflow.log_artifact()tieto uložiť.
Pozrime sa na základný príklad protokolovania behu LLM:
Tento príklad demonštruje parametre protokolovania, metriky a vstup/výstup ako artefakt tabuľky.
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 = "Explain the concept of machine learning in simple terms."
# Log parameters
mlflow.log_param("model", "text-davinci-002")
mlflow.log_param("max_tokens", 100)
# Query the LLM and log the result
result = query_llm(prompt)
mlflow.log_metric("response_length", len(result))
# Log the prompt and response
mlflow.log_table("prompt_responses", {"prompt": (prompt), "response": (result)})
print(f"Response: {result}")
Nasadenie LLM s MLflow
MLflow poskytuje výkonné možnosti na nasadenie LLM, čím uľahčuje obsluhu vašich modelov v produkčných prostrediach. Poďme preskúmať, ako nasadiť LLM pomocou funkcií nasadenia MLflow.
Vytvorenie koncového bodu
Najprv vytvoríme koncový bod pre náš LLM pomocou klienta nasadenia MLflow:
import mlflow
from mlflow.deployments import get_deploy_client
# Initialize the deployment client
client = get_deploy_client("databricks")
# Define the endpoint configuration
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",
},
},
}),
}
# Create the endpoint
client.create_endpoint(name=endpoint_name, config=endpoint_config)
Tento kód nastavuje koncový bod pre model GPT-3.5-turbo pomocou Azure OpenAI. Všimnite si použitie tajomstiev Databricks na bezpečnú správu kľúčov API.
Testovanie koncového bodu
Po vytvorení koncového bodu ho môžeme otestovať:
<div class="relative flex flex-col rounded-lg">
response = client.predict(
endpoint=endpoint_name,
inputs={"prompt": "Explain the concept of neural networks briefly.","max_tokens": 100,},)
print(response)
Toto odošle výzvu nášmu nasadenému modelu a vráti vygenerovanú odpoveď.
Hodnotenie LLM pomocou MLflow
Hodnotenie je kľúčové pre pochopenie výkonu a správania vašich LLM. MLflow poskytuje komplexné nástroje na vyhodnocovanie LLM, vrátane vstavaných aj vlastných metrík.
Príprava vášho LLM na hodnotenie
Ak chcete zhodnotiť svoje LLM pomocou mlflow.evaluate()váš model musí byť v jednej z týchto foriem:
- An
mlflow.pyfunc.PyFuncModelinštanciu alebo URI smerujúce na zaznamenaný model MLflow. - Funkcia Pythonu, ktorá prijíma reťazcové vstupy a vydáva jeden reťazec.
- Identifikátor URI koncového bodu MLflow Deployments.
- Set
model=Nonea zahrnúť výstupy modelu do údajov hodnotenia.
Pozrime sa na príklad s použitím zaznamenaného modelu MLflow:
import mlflow
import openai
with mlflow.start_run():
system_prompt = "Answer the following question concisely."
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}"},
),
)
# Prepare evaluation data
eval_data = pd.DataFrame({
"question": ("What is machine learning?", "Explain neural networks."),
"ground_truth": (
"Machine learning is a subset of AI that enables systems to learn and improve from experience without explicit programming.",
"Neural networks are computing systems inspired by biological neural networks, consisting of interconnected nodes that process and transmit information."
)
})
# Evaluate the model
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
)
print(f"Evaluation metrics: {results.metrics}")
Tento príklad zaznamená model OpenAI, pripraví hodnotiace údaje a potom vyhodnotí model pomocou vstavaných metrík MLflow pre úlohy odpovedania na otázky.
Vlastné metriky hodnotenia
MLflow vám umožňuje definovať vlastné metriky pre hodnotenie LLM. Tu je príklad vytvorenia vlastnej metriky na hodnotenie profesionality odpovedí:
from mlflow.metrics.genai import EvaluationExample, make_genai_metric
professionalism = make_genai_metric(
name="professionalism",
definition="Measure of formal and appropriate communication style.",
grading_prompt=(
"Score the professionalism of the answer on a scale of 0-4:\n"
"0: Extremely casual or inappropriate\n"
"1: Casual but respectful\n"
"2: Moderately formal\n"
"3: Professional and appropriate\n"
"4: Highly formal and expertly crafted"
),
examples=(
EvaluationExample(
input="What is MLflow?",
output="MLflow is like your friendly neighborhood toolkit for managing ML projects. It's super cool!",
score=1,
justification="The response is casual and uses informal language."
),
EvaluationExample(
input="What is MLflow?",
output="MLflow is an open-source platform for the machine learning lifecycle, including experimentation, reproducibility, and deployment.",
score=4,
justification="The response is formal, concise, and professionally worded."
)
),
model="openai:/gpt-3.5-turbo-16k",
parameters={"temperature": 0.0},
aggregations=("mean", "variance"),
greater_is_better=True,
)
# Use the custom metric in evaluation
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
extra_metrics=(professionalism)
)
print(f"Professionalism score: {results.metrics('professionalism_mean')}")
Táto vlastná metrika používa GPT-3.5-turbo na hodnotenie profesionality odpovedí a demonštruje, ako môžete využiť samotné LLM na hodnotenie.
Pokročilé techniky hodnotenia LLM
Ako sa LLM stávajú sofistikovanejšími, menia sa aj techniky na ich vyhodnocovanie. Poďme preskúmať niektoré pokročilé metódy hodnotenia pomocou MLflow.
Retrieval-Augmented Generation (RAG) Hodnotenie
Systémy RAG kombinujú silu modelov založených na vyhľadávaní a generatívnych modelov. Hodnotenie systémov RAG vyžaduje posúdenie komponentov získavania aj generovania. Tu je návod, ako môžete nastaviť systém RAG a vyhodnotiť ho pomocou 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
# Load and preprocess 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)
# Create vector store
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)
# Create RAG chain
llm = OpenAI(temperature=0)
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=vectorstore.as_retriever(),
return_source_documents=True
)
# Evaluation function
def evaluate_rag(question):
result = qa_chain({"query": question})
return result("result"), (doc.page_content for doc in result("source_documents"))
# Prepare evaluation data
eval_questions = (
"What is MLflow?",
"How does MLflow handle experiment tracking?",
"What are the main components of MLflow?"
)
# Evaluate using 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")
# Log custom metrics
mlflow.log_metric("avg_sources_per_question", sum(len(evaluate_rag(q)(1)) for q in eval_questions) / len(eval_questions))
Tento príklad nastaví systém RAG pomocou LangChain a Chroma a potom ho vyhodnotí protokolovaním otázok, odpovedí, získaných zdrojov a vlastných metrík do MLflow.
Spôsob, akým rozdeľujete svoje dokumenty, môže výrazne ovplyvniť výkon RAG. MLflow vám môže pomôcť vyhodnotiť rôzne stratégie rozdeľovania:
Tento skript vyhodnocuje rôzne kombinácie veľkostí častí, presahov a metód delenia a zaznamenáva výsledky do MLflow pre jednoduché porovnanie.
MLflow poskytuje rôzne spôsoby vizualizácie výsledkov hodnotenia LLM. Tu sú niektoré techniky:
Môžete si vytvoriť vlastné vizualizácie výsledkov hodnotenia pomocou knižníc ako Matplotlib alebo Plotly a potom ich zaznamenať ako artefakty:
Táto funkcia vytvorí čiarový graf porovnávajúci konkrétnu metriku v rámci viacerých cyklov a zaznamená ju ako artefakt.
