Модели и платформы ИИ
Отслеживание больших языковых моделей с помощью MLflow: полное руководство
Добавьте Unite.AI в избранные источники в Google
По мере роста сложности и масштаба больших языковых моделей (БЯМ) отслеживание их производительности, экспериментов и развертываний становится все более сложной задачей. Именно здесь на помощь приходит MLflow – предоставляющий комплексную платформу для управления всем жизненным циклом моделей машинного обучения, включая БЯМ.
В этом подробном руководстве мы рассмотрим, как использовать MLflow для отслеживания, оценки и развертывания БЯМ. Мы рассмотрим все, от настройки среды до продвинутых методов оценки, с множеством примеров кода и лучших практик на пути.
Функциональность MLflow в больших языковых моделях (БЯМ)
MLflow стал ключевым инструментом в сообществе машинного обучения и数据 науки, особенно для управления жизненным циклом моделей машинного обучения. Когда речь идет о больших языковых моделях (БЯМ), MLflow предлагает мощный набор инструментов, которые значительно упрощают процесс разработки, отслеживания, оценки и развертывания этих моделей. Давайте рассмотрим, как MLflow функционирует в области БЯМ и какие преимущества он предоставляет инженерам и ученым.
Отслеживание и управление взаимодействиями БЯМ
Система отслеживания БЯМ в MLflow является расширением существующих возможностей отслеживания, адаптированных для уникальных потребностей БЯМ. Она позволяет проводить комплексное отслеживание взаимодействий с моделью, включая следующие ключевые аспекты:
- Параметры: регистрация пар ключ-значение, которые описывают входные параметры для БЯМ, такие как модель-специфические параметры, как
top_kиtemperature. Это обеспечивает контекст и конфигурацию для каждого запуска, гарантируя, что все аспекты конфигурации модели захвачены. - Метрики: количественные меры, которые предоставляют информацию о производительности и точности БЯМ. Эти метрики можно обновлять динамически по мере прогресса запуска, предлагая реальные или пост-процессные идеи.
- Прогнозы: захват входных данных, отправляемых в БЯМ, и соответствующих выходных данных, которые хранятся в виде артефактов в структурированном формате для легкого извлечения и анализа.
- Артефакты: помимо прогнозов, MLflow может хранить различные выходные файлы, такие как визуализации, сериализованные модели и структурированные файлы данных, позволяя проводить подробную документацию и анализ производительности модели.
Этот структурированный подход гарантирует, что все взаимодействия с БЯМ тщательно записаны, обеспечивая комплексную линию и качественное отслеживание для текстовых моделей.
Оценка БЯМ
Оценка БЯМ представляет уникальные проблемы из-за их генеративной природы и отсутствия единой истины. MLflow упрощает эту задачу с помощью специализированных инструментов оценки, предназначенных для БЯМ. Ключевые функции включают:
- Универсальная оценка моделей: поддерживает оценку различных типов БЯМ, будь то модель MLflow pyfunc, URI, указывающий на зарегистрированную модель MLflow, или любой вызываемый Python, представляющий вашу модель.
- Комплексные метрики: предлагает ряд метрик, адаптированных для оценки БЯМ, включая как метрики, зависящие от модели (например, актуальность ответа), так и функциональные метрики (например, ROUGE, Flesch Kincaid).
- Предварительно определенные коллекции метрик: в зависимости от случая использования, такого как ответы на вопросы или суммаризация текста, MLflow предоставляет предварительно определенные метрики для упрощения процесса оценки.
- Создание пользовательских метрик: позволяет пользователям определять и реализовывать пользовательские метрики для удовлетворения конкретных потребностей оценки, повышая гибкость и глубину оценки модели.
- Оценка с помощью статических наборов данных: позволяет оценивать статические наборы данных без указания модели, что полезно для быстрой оценки без повторного запуска модели.
Развертывание и интеграция
MLflow также поддерживает бесшовное развертывание и интеграцию БЯМ:
- Сервер развертывания MLflow: выступает в качестве унифицированного интерфейса для взаимодействия с несколькими провайдерами БЯМ. Он упрощает интеграции, управляет учетными данными безопасно и предлагает последовательный API-опыт. Этот сервер поддерживает ряд фундаментальных моделей от популярных провайдеров SaaS, а также самохозяйственные модели.
- Унифицированный конечная точка: облегчает переключение между провайдерами без изменений в коде, минимизируя простой и повышая гибкость.
- Интегрированный вид результатов: предоставляет комплексные результаты оценки, которые можно получить напрямую в коде или через интерфейс MLflow для подробного анализа.
MLflow является комплексным набором инструментов и интеграций, что делает его бесценным активом для инженеров и ученых, работающих с продвинутыми моделями NLP.
Настройка среды
Прежде чем мы приступим к отслеживанию БЯМ с помощью MLflow, давайте настроим нашу среду разработки. Нам нужно установить 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
После установки рекомендуется перезапустить среду Python, чтобы убедиться, что все библиотеки загружены правильно. В блокноте Jupyter можно использовать:
import mlflow
import chromadb
<p>print(f"MLflow version: {mlflow.__version__}")
print(f"ChromaDB version: {chromadb.__version__}")
Это подтвердит версии ключевых библиотек, которые мы будем использовать.
Понимание возможностей отслеживания БЯМ в MLflow
Система отслеживания БЯМ в MLflow строится на основе существующих возможностей отслеживания, добавляя функции, специально разработанные для уникальных аспектов БЯМ. Давайте рассмотрим ключевые компоненты:
Запуски и эксперименты
В MLflow “запуск” представляет собой один выполненный экземпляр вашего кода модели, а “эксперимент” – это коллекция связанных запусков. Для БЯМ запуск может представлять один запрос или пакет входных данных, обработанных моделью.
Ключевые компоненты отслеживания
- Параметры: это входные конфигурации для вашей БЯМ, такие как температура, top_k или max_tokens. Вы можете регистрировать их с помощью
mlflow.log_param()илиmlflow.log_params(). - Метрики: количественные меры производительности вашей БЯМ, такие как точность, задержка или пользовательские оценки. Используйте
mlflow.log_metric()илиmlflow.log_metrics()для отслеживания этих метрик. - Прогнозы: для БЯМ важно регистрировать как входные запросы, так и выходные данные модели. MLflow хранит их в виде артефактов в формате CSV с помощью
mlflow.log_table(). - Артефакты: любые дополнительные файлы или данные, связанные с запуском БЯМ, такие как контрольные точки модели, визуализации или образцы наборов данных. Используйте
mlflow.log_artifact()для хранения этих артефактов.
Давайте рассмотрим базовый пример регистрации запуска БЯМ:
Этот пример демонстрирует регистрацию параметров, метрик и входных/выходных данных в виде артефакта таблицы.
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 = "Объясните концепцию машинного обучения в простых терминах."</p>
<p># Регистрация параметров
mlflow.log_param("model", "text-davinci-002")
mlflow.log_param("max_tokens", 100)</p>
<p># Запрос БЯМ и регистрация результата
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}")
Развертывание БЯМ с помощью MLflow
MLflow предоставляет мощные возможности для развертывания БЯМ, что делает проще обслуживание ваших моделей в производственных средах. Давайте рассмотрим, как развернуть БЯМ с помощью возможностей развертывания MLflow.
Создание конечной точки
Сначала мы создадим конечную точку для нашей БЯМ с помощью клиента развертывания MLflow:
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)
Этот код настраивает конечную точку для модели GPT-3.5-turbo с помощью Azure OpenAI. Обратите внимание на использование секретов Databricks для безопасного управления ключами API.
Тестирование конечной точки
После создания конечной точки мы можем протестировать ее:
<div class="relative flex flex-col rounded-lg">
<p>response = client.predict(
endpoint=endpoint_name,
inputs={"prompt": "Объясните концепцию нейронных сетей кратко.","max_tokens": 100,},)</p>
print(response)
Это отправит запрос в нашу развернутую модель и вернет сгенерированный ответ.
Оценка БЯМ с помощью MLflow
Оценка имеет решающее значение для понимания производительности и поведения ваших БЯМ. MLflow предоставляет комплексные инструменты для оценки БЯМ, включая как встроенные, так и пользовательские метрики.
Подготовка БЯМ к оценке
Чтобы оценить вашу БЯМ с помощью mlflow.evaluate(), ваша модель должна быть в одном из следующих форм:
- Экземпляр
mlflow.pyfunc.PyFuncModelили URI, указывающий на зарегистрированную модель MLflow. - Функция Python, которая принимает строковые входные данные и возвращает одну строку.
- URI конечной точки развертывания MLflow.
- Установите
model=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 позволяет определять пользовательские метрики для оценки БЯМ. Давайте рассмотрим пример создания пользовательской метрики для оценки профессионализма ответов:
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="Что такое MLflow?",
output="MLflow - это как ваш дружественный инструментарий для управления проектами машинного обучения. Это очень круто!",
score=1,
justification="Ответ неформальный и использует неформальный язык."
),
EvaluationExample(
input="Что такое MLflow?",
output="MLflow - это открытая платформа для жизненного цикла машинного обучения, включая экспериментирование, воспроизводимость и развертывание.",
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']}")
Эта пользовательская метрика использует GPT-3.5-turbo для оценки профессионализма ответов, демонстрируя, как можно использовать БЯМ самих для оценки.
Продвинутые методы оценки БЯМ
По мере того, как БЯМ становятся более сложными, так же становятся и методы их оценки. Давайте рассмотрим некоторые продвинутые методы оценки с помощью 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?",
"Как MLflow обрабатывает отслеживание экспериментов?",
"Каковы основные компоненты 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 с помощью LangChain и Chroma, а затем оценивает ее, регистрируя вопросы, ответы, извлеченные источники и пользовательские метрики в 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># Оценка производительности извлечения (упрощенная)
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']} с размером {best_run['params.chunk_size']} и перекрытием {best_run['params.chunk_overlap']}")
Этот скрипт оценивает разные комбинации размеров чанков, перекрытий и методов разделения, регистрируя результаты в MLflow для легкого сравнения.
Визуализация результатов оценки БЯМ
MLflow предоставляет различные способы визуализации результатов оценки ваших БЯМ. Давайте рассмотрим некоторые методы:
Использование интерфейса MLflow
После выполнения оценок вы можете использовать интерфейс MLflow для визуализации результатов:
- Запустите интерфейс MLflow:
mlflow ui - Откройте веб-браузер и перейдите по адресу
http://localhost:5000 - Выберите ваш эксперимент и запуски, чтобы просмотреть метрики, параметры и артефакты
Пользовательские визуализации
Вы можете создавать пользовательские визуализации результатов оценки с помощью библиотек, таких как 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"])
Эта функция создает линейный график, сравнивающий определенную метрику между несколькими запусками, и регистрирует его в качестве артефакта.
Альтернативы открытому MLflow
Существует множество альтернатив открытому MLflow для управления потоками машинного обучения, каждая из которых предлагает уникальные функции и интеграции.
Управляемый MLflow от Databricks
Управляемый MLflow, размещенный на Databricks, предоставляет основные функции открытого MLflow, но с дополнительными преимуществами, такими как бесшовная интеграция с экосистемой Databricks, продвинутые функции безопасности и управляемую инфраструктуру. Это делает его отличным выбором для организаций, которым требуются надежная безопасность и масштабируемость.
Azure Machine Learning
Azure Machine Learning предлагает комплексное решение для машинного обучения на платформе Azure. Он обеспечивает совместимость с компонентами MLflow, такими как реестр моделей и отслеживание экспериментов, хотя и не основан на MLflow.
Посвященные платформы ML
Несколько компаний предоставляют управляемые продукты ML с разнообразными функциями:
- neptune.ai: фокусируется на отслеживании экспериментов и управлении моделями.
- Weights & Biases: предлагает обширное отслеживание экспериментов, версионирование наборов данных и инструменты сотрудничества.
- Comet ML: обеспечивает отслеживание экспериментов, мониторинг моделей в производстве и регистрацию данных.
- Valohai: специализируется на потоках машинного обучения и оркестровке.
Metaflow
Metaflow, разработанный Netflix (NFLX ), является открытой платформой, предназначенной для оркестровки потоков данных и моделей машинного обучения. Хотя он отлично подходит для управления крупномасштабными развертываниями, он лишен комплексных функций отслеживания экспериментов и управления моделями по сравнению с MLflow.
Amazon SageMaker и Google’s Vertex AI
И Amazon (AMZN ) SageMaker, и Google’s (GOOGL ) Vertex AI предоставляют комплексные решения MLOps, интегрированные в свои облачные платформы. Эти сервисы предлагают надежные инструменты для создания, обучения и развертывания моделей машинного обучения в масштабе.
Подробное сравнение
Управляемый MLflow vs. открытый MLflow
Управляемый MLflow от Databricks предлагает несколько преимуществ над открытой версией, включая:
- Настройка и развертывание: бесшовная интеграция с Databricks снижает время и усилия по настройке.
- Масштабируемость: способен обрабатывать крупномасштабные задачи машинного обучения с легкостью.
- Безопасность и управление: встроенные функции безопасности, такие как контроль доступа на основе ролей (RBAC) и шифрование данных.
- Интеграция: глубокая интеграция с сервисами Databricks, повышающая совместимость и функциональность.
- Хранение и резервное копирование данных: автоматические стратегии резервного копирования обеспечивают безопасность и надежность данных.
- Стоимость: пользователи платят за платформу, хранение и вычислительные ресурсы.
- Поддержка и обслуживание: специализированная поддержка и обслуживание, предоставляемые Databricks.
Заключение
Отслеживание больших языковых моделей с помощью MLflow обеспечивает надежную основу для управления сложностями разработки, оценки и развертывания БЯМ. Следуя лучшим практикам и используя продвинутые функции, изложенные в этом руководстве, вы можете создать более организованные, воспроизводимые и информативные эксперименты с БЯМ.
Помните, что область БЯМ развивается быстро, и новые методы оценки и отслеживания постоянно появляются. Оставайтесь в курсе последних выпусков MLflow и исследований БЯМ, чтобы постоянно совершенствовать ваши процессы отслеживания и оценки.
По мере применения этих методов в ваших проектах, вы будете развивать более глубокое понимание поведения и производительности ваших БЯМ, что приведет к более эффективным и надежным языковым моделям.
