Theo dõi Mô hình Ngôn ngữ Lớn (LLM) với MLflow: Hướng dẫn Hoàn chỉnh

Khi Mô hình Ngôn ngữ Lớn (LLM) phát triển về độ phức tạp và quy mô, việc theo dõi hiệu suất, thí nghiệm và triển khai của chúng trở nên ngày càng thách thức. Đây là nơi MLflow phát huy tác dụng – cung cấp một nền tảng toàn diện cho việc quản lý toàn bộ vòng đời của mô hình học máy, bao gồm cả LLM.

Trong hướng dẫn này, chúng ta sẽ khám phá cách tận dụng MLflow để theo dõi, đánh giá và triển khai LLM. Chúng ta sẽ bao gồm mọi thứ từ thiết lập môi trường đến các kỹ thuật đánh giá tiên tiến, với nhiều ví dụ mã và thực hành tốt nhất dọc theo đường đi.

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"Phiên bản MLflow: {mlflow.__version__}")
print(f"Phiên bản 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 = "Giải thích khái niệm học máy một cách đơn giản."</p>

<p># Ghi lại thông số
mlflow.log_param("model", "text-davinci-002")
mlflow.log_param("max_tokens", 100)</p>

<p># Truy vấn LLM và ghi lại kết quả
result = query_llm(prompt)
mlflow.log_metric("length_of_response", len(result))</p>

<p># Ghi lại lời nhắc và phản hồi
mlflow.log_table("prompt_responses", {"prompt": [prompt], "response": [result]})</p>

<p>print(f"Phản hồi: {result}")

import mlflow
from mlflow.deployments import get_deploy_client

<p># Khởi tạo máy khách triển khai
client = get_deploy_client("databricks")</p>

<p># Định nghĩa cấu hình điểm cuối
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># Tạo điểm cuối
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": "Giải thích khái niệm mạng nơ-ron một cách ngắn gọn.", "max_tokens": 100,},)</p>

print(response)

Điều này sẽ gửi một lời nhắc đến mô hình đã triển khai của chúng ta và trả về phản hồi được tạo.

Đánh giá LLM với MLflow

Đánh giá là rất quan trọng để hiểu hiệu suất và hành vi của LLM của bạn. MLflow cung cấp các công cụ toàn diện cho việc đánh giá LLM, bao gồm cả các biện pháp đã xây dựng và tùy chỉnh.

Chuẩn bị LLM của Bạn cho Đánh giá

Để đánh giá LLM của bạn bằng cách sử dụng mlflow.evaluate(), mô hình của bạn cần ở một trong các hình thức sau:

1. Một thể hiện mlflow.pyfunc.PyFuncModel hoặc một URI trỏ đến mô hình MLflow đã được ghi lại.
2. Một hàm Python nhận đầu vào chuỗi và trả về một chuỗi đơn.
3. Một URI điểm cuối Triển khai MLflow.
4. Đặt model=None và bao gồm đầu ra mô hình trong dữ liệu đánh giá.

Hãy xem một ví dụ sử dụng mô hình MLflow đã được ghi lại:

import mlflow
import openai

<p>with mlflow.start_run():
system_prompt = "Trả lời câu hỏi sau một cách ngắn gọn."
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># Chuẩn bị dữ liệu đánh giá
eval_data = pd.DataFrame({
"question": ["Mô hình ngôn ngữ lớn là gì?", "Giải thích mạng nơ-ron."],
"ground_truth": [
"Mô hình ngôn ngữ lớn là một mô hình học máy được thiết kế để xử lý và tạo ra ngôn ngữ tự nhiên.",
"Mạng nơ-ron là một mô hình học máy được thiết kế để mô phỏng cách thức hoạt động của não bộ con người.",
]
})</p>

<p># Đánh giá mô hình
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
)</p>

<p>print(f"Biện pháp đánh giá: {results.metrics}")

Ví dụ này ghi lại mô hình OpenAI, chuẩn bị dữ liệu đánh giá và sau đó đánh giá mô hình bằng cách sử dụng các biện pháp đã xây dựng của MLflow cho các nhiệm vụ trả lời câu hỏi.

Biện pháp Đánh giá Tùy chỉnh

MLflow cho phép bạn định nghĩa các biện pháp đánh giá tùy chỉnh cho LLM. Dưới đây là một ví dụ về việc tạo một biện pháp đánh giá tùy chỉnh để đánh giá tính chuyên nghiệp của phản hồi:

from mlflow.metrics.genai import EvaluationExample, make_genai_metric

<p>professionalism = make_genai_metric(
name="professionalism",
definition="Đo lường mức độ chính thức và phù hợp của phong cách giao tiếp.",
grading_prompt=(
"Đánh giá tính chuyên nghiệp của câu trả lời trên thang điểm từ 0-4:\n"
"0: Rất không chính thức hoặc không phù hợp\n"
"1: Không chính thức nhưng vẫn trang trọng\n"
"2: Trung bình chính thức\n"
"3: Chuyên nghiệp và phù hợp\n"
"4: Rất chính thức và được thiết kế chuyên nghiệp"
),
examples=[
EvaluationExample(
input="Mô hình ngôn ngữ lớn là gì?",
output="Mô hình ngôn ngữ lớn là một mô hình học máy được thiết kế để xử lý và tạo ra ngôn ngữ tự nhiên.",
score=4,
justification="Câu trả lời rất chính thức và được thiết kế chuyên nghiệp.",
),
],
model="openai:/gpt-3.5-turbo-16k",
parameters={"temperature": 0.0},
aggregations=["mean", "variance"],
greater_is_better=True,
)</p>

<p># Sử dụng biện pháp đánh giá tùy chỉnh trong đánh giá
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
extra_metrics=[professionalism]
)</p>

<p>print(f"Điểm tính chuyên nghiệp: {results.metrics['professionalism_mean']}")

Biện pháp đánh giá tùy chỉnh này sử dụng GPT-3.5-turbo để đánh giá tính chuyên nghiệp của phản hồi, thể hiện cách bạn có thể tận dụng LLM để đánh giá.

Kỹ thuật Đánh giá LLM Tiên tiến

Khi LLM trở nên tinh vi hơn, các kỹ thuật đánh giá cũng trở nên tinh vi hơn. Hãy khám phá một số phương pháp đánh giá tiên tiến bằng cách sử dụng MLflow.

Đánh giá Tạo Tăng Cường (RAG)

Hệ thống RAG kết hợp sức mạnh của mô hình tạo và mô hình truy xuất. Đánh giá hệ thống RAG đòi hỏi phải đánh giá cả thành phần truy xuất và tạo:

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># Tải và tiền xử lý tài liệu
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># Tạo kho vecto
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)</p>

<p># Tạo chuỗi 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># Hàm đánh giá
def evaluate_rag(question):
result = qa_chain({"query": question})
return result["result"], [doc.page_content for doc in result["source_documents"]]</p>

<p># Chuẩn bị dữ liệu đánh giá
eval_questions = [
"Mô hình ngôn ngữ lớn là gì?",
"Làm thế nào để MLflow xử lý theo dõi thí nghiệm?",
"Những thành phần chính của MLflow là gì?",
]</p>

<p># Đánh giá bằng cách sử dụng 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># Ghi lại các biện pháp đánh giá tùy chỉnh
mlflow.log_metric("avg_sources_per_question", sum(len(evaluate_rag(q)[1]) for q in eval_questions) / len(eval_questions))