Modelos e plataformas de IA
Rastreando Modelos de Linguagem Grande (LLM) com MLflow: Um Guia Completo
Adicione Unite.AI às suas fontes preferidas no Google
À medida que os Modelos de Linguagem Grande (LLMs) crescem em complexidade e escala, rastrear seu desempenho, experimentos e implantações torna-se cada vez mais desafiador. É aqui que o MLflow entra em cena – fornecendo uma plataforma abrangente para gerenciar todo o ciclo de vida dos modelos de aprendizado de máquina, incluindo LLMs.
Neste guia aprofundado, exploraremos como aproveitar o MLflow para rastrear, avaliar e implantar LLMs. Cobriremos tudo, desde a configuração do ambiente até técnicas de avaliação avançadas, com muitos exemplos de código e boas práticas ao longo do caminho.
Funcionalidade do MLflow em Modelos de Linguagem Grande (LLMs)
MLflow tornou-se uma ferramenta fundamental na comunidade de aprendizado de máquina e ciência de dados, especialmente para gerenciar o ciclo de vida dos modelos de aprendizado de máquina. Quando se trata de Modelos de Linguagem Grande (LLMs), o MLflow oferece uma robusta suíte de ferramentas que simplifica significativamente o processo de desenvolvimento, rastreamento, avaliação e implantação desses modelos. Aqui está uma visão geral de como o MLflow funciona dentro do espaço LLM e os benefícios que fornece aos engenheiros e cientistas de dados.
Rastreando e Gerenciando Interações LLM
O sistema de rastreamento LLM do MLflow é uma extensão de suas capacidades de rastreamento existentes, personalizadas para as necessidades únicas dos LLMs. Ele permite o rastreamento abrangente de interações de modelo, incluindo os seguintes aspectos principais:
- Parâmetros: Pares de valor-chave que detalham os parâmetros de entrada para o LLM, como parâmetros específicos do modelo, como
top_ketemperatura. Isso fornece contexto e configuração para cada execução, garantindo que todos os aspectos da configuração do modelo sejam capturados. - Métricas: Medidas quantitativas que fornecem insights sobre o desempenho e precisão do LLM. Essas podem ser atualizadas dinamicamente à medida que a execução progride, oferecendo insights em tempo real ou pós-processamento.
- Previsões: Capturar as entradas enviadas ao LLM e as saídas correspondentes, que são armazenadas como artefatos em um formato estruturado para fácil recuperação e análise.
- Artefatos: Além das previsões, o MLflow pode armazenar vários arquivos de saída, como visualizações, modelos serializados e arquivos de dados estruturados, permitindo documentação e análise detalhadas do desempenho do modelo.
Essa abordagem estruturada garante que todas as interações com o LLM sejam registradas meticulosamente, fornecendo uma linhagem abrangente e rastreamento de qualidade para modelos de geração de texto.
Avaliação de LLMs
Avaliar LLMs apresenta desafios únicos devido à sua natureza geradora e à falta de uma única verdade fundamental. O MLflow simplifica isso com ferramentas de avaliação especializadas projetadas para LLMs. Recursos principais incluem:
- Avaliação de Modelo Versátil: Suporta a avaliação de vários tipos de LLMs, seja um modelo pyfunc do MLflow, um URI apontando para um modelo registrado do MLflow ou qualquer função Python chamável que represente seu modelo.
- Métricas Abrangentes: Oferece uma gama de métricas personalizadas para avaliação de LLM, incluindo métricas dependentes do modelo SaaS (por exemplo, relevância da resposta) e métricas baseadas em função (por exemplo, ROUGE, Flesch Kincaid).
- Coleções de Métricas Predefinidas: Dependendo do caso de uso, como resposta a perguntas ou resumo de texto, o MLflow fornece métricas predefinidas para simplificar o processo de avaliação.
- Criação de Métrica Personalizada: Permite que os usuários definam e implementem métricas personalizadas para atender a necessidades de avaliação específicas, melhorando a flexibilidade e profundidade da avaliação do modelo.
- Avaliação com Conjuntos de Dados Estáticos: Permite a avaliação de conjuntos de dados estáticos sem especificar um modelo, o que é útil para avaliações rápidas sem rerun da inferência do modelo.
Implantação e Integração
O MLflow também suporta a implantação e integração sem esforço de LLMs:
- Servidor de Implantação do MLflow: Atua como uma interface unificada para interagir com vários provedores de LLM. Ele simplifica as integrações, gerencia credenciais de forma segura e oferece uma experiência de API consistente. Este servidor suporta uma variedade de modelos fundamentais de provedores de SaaS populares, bem como modelos auto-hospedados.
- Ponto de Extremidade Unificado: Facilita a alternância entre provedores sem alterações de código, minimizando o tempo de inatividade e melhorando a flexibilidade.
- Visualização de Resultados Integrada: Fornece resultados de avaliação abrangentes, que podem ser acessados diretamente no código ou por meio da interface do usuário do MLflow para análise detalhada.
O MLflow é uma suíte abrangente de ferramentas e integrações que o torna um ativo inestimável para engenheiros e cientistas de dados que trabalham com modelos de NLP avançados.
Configurando o Ambiente
Antes de mergulharmos no rastreamento de LLMs com o MLflow, vamos configurar nosso ambiente de desenvolvimento. Precisaremos instalar o MLflow e várias outras bibliotecas principais:
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
Após a instalação, é uma boa prática reiniciar o ambiente Python para garantir que todas as bibliotecas sejam carregadas corretamente. Em um notebook Jupyter, você pode usar:
import mlflow
import chromadb
<p>print(f"Versão do MLflow: {mlflow.__version__}")
print(f"Versão do ChromaDB: {chromadb.__version__}")
Isso confirmará as versões das bibliotecas principais que estamos usando.
Entendendo as Capacidades de Rastreamento de LLM do MLflow
O sistema de rastreamento de LLM do MLflow constrói sobre suas capacidades de rastreamento existentes, adicionando recursos especificamente projetados para os aspectos únicos dos LLMs. Vamos desmembrar os componentes principais:
Execuções e Experimentos
No MLflow, uma “execução” representa uma única execução do código do modelo, enquanto um “experimento” é uma coleção de execuções relacionadas. Para LLMs, uma execução pode representar uma única consulta ou um lote de prompts processados pelo modelo.
Componentes de Rastreamento Principais
- Parâmetros: Esses são configurações de entrada para o seu LLM, como temperatura, top_k ou max_tokens. Você pode registrar esses usando
mlflow.log_param()oumlflow.log_params(). - Métricas: Medidas quantitativas do desempenho do seu LLM, como precisão, latência ou escores personalizados. Use
mlflow.log_metric()oumlflow.log_metrics()para rastrear essas. - Previsões: Para LLMs, é crucial registrar tanto as entradas de prompts quanto as saídas do modelo. O MLflow armazena essas como artefatos em formato CSV usando
mlflow.log_table(). - Artefatos: Qualquer arquivo ou dado adicional relacionado à execução do LLM, como checkpoints de modelo, visualizações ou amostras de conjunto de dados. Use
mlflow.log_artifact()para armazenar esses.
Vamos olhar um exemplo básico de registro de uma execução de LLM:
Este exemplo demonstra o registro de parâmetros, métricas e a entrada/saída como um artefato de tabela.
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 = "Explique o conceito de aprendizado de máquina em termos simples."</p>
<p># Registre parâmetros
mlflow.log_param("modelo", "text-davinci-002")
mlflow.log_param("max_tokens", 100)</p>
<p># Consulte o LLM e registre o resultado
result = query_llm(prompt)
mlflow.log_metric("comprimento_da_resposta", len(result))</p>
<p># Registre o prompt e a resposta
mlflow.log_table("prompt_respostas", {"prompt": [prompt], "resposta": [result]})</p>
<p>print(f"Resposta: {result}")
Implantando LLMs com MLflow
O MLflow fornece capacidades poderosas para implantar LLMs, tornando mais fácil servir seus modelos em ambientes de produção. Vamos explorar como implantar um LLM usando os recursos de implantação do MLflow.
Criando um Ponto de Extremidade
Primeiro, criaremos um ponto de extremidade para nosso LLM usando o cliente de implantação do MLflow:
import mlflow
from mlflow.deployments import get_deploy_client
<p># Inicialize o cliente de implantação
client = get_deploy_client("databricks")</p>
<p># Defina a configuração do ponto de extremidade
endpoint_name = "llm-endpoint"
endpoint_config = {
"entidades_servidas": [{
"nome": "gpt-model",
"modelo_externo": {
"nome": "gpt-3.5-turbo",
"provedor": "openai",
"tarefa": "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># Crie o ponto de extremidade
client.create_endpoint(name=endpoint_name, config=endpoint_config)
Este código configura um ponto de extremidade para um modelo GPT-3.5-turbo usando Azure OpenAI. Observe o uso de segredos do Databricks para gerenciamento seguro de chaves de API.
Testando o Ponto de Extremidade
Uma vez criado o ponto de extremidade, podemos testá-lo:
<div class="relative flex flex-col rounded-lg">
<p>response = client.predict(
endpoint=endpoint_name,
inputs={"prompt": "Explique o conceito de redes neurais brevemente.", "max_tokens": 100,},)</p>
print(response)
Isso enviará um prompt para nosso modelo implantado e retornará a resposta gerada.
Avaliando LLMs com MLflow
A avaliação é crucial para entender o desempenho e o comportamento dos seus LLMs. O MLflow fornece ferramentas abrangentes para avaliar LLMs, incluindo métricas incorporadas e personalizadas.
Preparando seu LLM para Avaliação
Para avaliar seu LLM com mlflow.evaluate(), seu modelo precisa estar em uma das seguintes formas:
- Uma instância de
mlflow.pyfunc.PyFuncModelou um URI apontando para um modelo registrado do MLflow. - Uma função Python que aceita entradas de string e retorna uma string única.
- Um URI de ponto de extremidade de implantação do MLflow.
- Defina
modelo=Nonee inclua as saídas do modelo nos dados de avaliação.
Vamos olhar um exemplo usando um modelo registrado do MLflow:
import mlflow
import openai
<p>with mlflow.start_run():
system_prompt = "Responda a seguinte pergunta de forma concisa."
logged_model_info = mlflow.openai.log_model(
model="gpt-3.5-turbo",
task=openai.chat.completions,
artifact_path="modelo",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": "{pergunta}"},
],
)</p>
<p># Prepare dados de avaliação
eval_data = pd.DataFrame({
"pergunta": ["O que é aprendizado de máquina?", "Explique redes neurais."],
"verdade_absoluta": [
"Aprendizado de máquina é um subconjunto de IA que permite que sistemas aprendam e melhorem com a experiência sem programação explícita.",
"Redes neurais são sistemas de computação inspirados em redes neurais biológicas, consistindo em nós interconectados que processam e transmitem informações.",
]
})</p>
<p># Avalie o modelo
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="verdade_absoluta",
model_type="pergunta-e-resposta",
)</p>
<p>print(f"Métricas de avaliação: {results.metrics}")
Este exemplo registra um modelo OpenAI, prepara dados de avaliação e, em seguida, avalia o modelo usando as métricas incorporadas do MLflow para tarefas de pergunta-e-resposta.
Métricas de Avaliação Personalizadas
O MLflow permite que você defina métricas personalizadas para a avaliação de LLM. Aqui está um exemplo de criação de uma métrica personalizada para avaliar a profissionalismo das respostas:
from mlflow.metrics.genai import EvaluationExample, make_genai_metric
<p>profissionalismo = make_genai_metric(
name="profissionalismo",
definition="Medida de estilo de comunicação formal e apropriado.",
grading_prompt=(
"Avalie o profissionalismo da resposta em uma escala de 0 a 4:\n"
"0: Muito casual ou inadequado\n"
"1: Casual, mas respeitoso\n"
"2: Moderadamente formal\n"
"3: Profissional e apropriado\n"
"4: Altamente formal e habilmente elaborado"
),
examples=[
EvaluationExample(
input="O que é MLflow?",
output="MLflow é como sua ferramenta de toolkit amigável para gerenciar projetos de ML. É muito legal!",
score=1,
justification="A resposta é casual e usa linguagem informal.",
),
EvaluationExample(
input="O que é MLflow?",
output="MLflow é uma plataforma de código aberto para o ciclo de vida do aprendizado de máquina, incluindo experimentação, reprodutibilidade e implantação.",
score=4,
justification="A resposta é formal, concisa e profissionalmente redigida.",
)
],
model="openai:/gpt-3.5-turbo-16k",
parameters={"temperatura": 0.0},
agregações=["média", "variação"],
greater_is_better=True,
)</p>
<p># Use a métrica personalizada na avaliação
results = mlflow.evaluate(
logged_model_info.model_uri,
eval_data,
targets="verdade_absoluta",
model_type="pergunta-e-resposta",
extra_metrics=[profissionalismo]
)</p>
<p>print(f"Pontuação de profissionalismo: {results.metrics['profissionalismo_média']}")
Esta métrica personalizada usa o GPT-3.5-turbo para avaliar o profissionalismo das respostas, demonstrando como você pode usar LLMs para avaliação.
Técnicas Avançadas de Avaliação de LLM
À medida que os LLMs se tornam mais sofisticados, as técnicas para avaliá-los também se tornam mais avançadas. Vamos explorar algumas técnicas avançadas de avaliação usando o MLflow.
Avaliação de Geração de Recuperação (RAG)
Sistemas RAG combinam o poder de modelos de recuperação e geradores. Avaliar sistemas RAG exige avaliar tanto os componentes de recuperação quanto os de geração. Aqui está como você pode configurar um sistema RAG e avaliá-lo usando o 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># Carregue e pré-processe documentos
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># Crie um armazenamento de vetores
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)</p>
<p># Crie uma cadeia RAG
llm = OpenAI(temperatura=0)
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=vectorstore.as_retriever(),
return_source_documents=True
)</p>
<p># Função de avaliação
def evaluate_rag(pergunta):
result = qa_chain({"query": pergunta})
return result["result"], [doc.page_content for doc in result["source_documents"]]</p>
<p># Prepare dados de avaliação
eval_questions = [
"O que é MLflow?",
"Como o MLflow lida com o rastreamento de experimentos?",
"Quais são os principais componentes do MLflow?",
]</p>
<p># Avalie usando o MLflow
with mlflow.start_run():
for pergunta in eval_questions:
answer, sources = evaluate_rag(pergunta)</p>
<p>mlflow.log_param(f"pergunta", pergunta)
mlflow.log_metric("num_sources", len(sources))
mlflow.log_text(answer, f"answer_{pergunta}.txt")</p>
<p>for i, source in enumerate(sources):
mlflow.log_text(source, f"source_{pergunta}_{i}.txt")</p>
<p># Registre métricas personalizadas
mlflow.log_metric("avg_sources_per_question", sum(len(evaluate_rag(q)[1]) for q in eval_questions) / len(eval_questions))
Este exemplo configura um sistema RAG usando LangChain e Chroma, então avalia-o registrando perguntas, respostas, fontes recuperadas e métricas personalizadas no MLflow.
Estratégia de Divisão de Dados
A forma como você divide seus documentos pode impactar significativamente o desempenho do RAG. O MLflow pode ajudá-lo a avaliar diferentes estratégias de divisão:
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># Avalie o desempenho de recuperação (simplificado)
correct_retrievals = sum(1 for _ in range(100) if simulate_retrieval(chunks))
mlflow.log_metric("retrieval_accuracy", correct_retrievals / 100)</p>
<p># Avalie diferentes estratégias
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># Compare resultados
best_run = mlflow.search_runs(order_by=["metrics.retrieval_accuracy DESC"]).iloc[0]
print(f"Estratégia de divisão de dados melhor: {best_run['params.splitter_class']} com tamanho {best_run['params.chunk_size']} e sobreposição {best_run['params.chunk_overlap']}")
Este script avalia combinações diferentes de tamanhos de chunk, sobreposições e métodos de divisão, registrando os resultados no MLflow para fácil comparação.
Visualizando Resultados de Avaliação de LLM
O MLflow fornece várias maneiras de visualizar os resultados de avaliação de LLM. Aqui estão algumas técnicas:
Usando a Interface do MLflow
Depois de executar as avaliações, você pode usar a interface do MLflow para visualizar os resultados:
- Inicie a interface do MLflow:
mlflow ui - Abra um navegador da web e navegue para
http://localhost:5000 - Selecione seu experimento e execuções para visualizar métricas, parâmetros e artefatos
Visualizações Personalizadas
Você pode criar visualizações personalizadas dos resultados de avaliação usando bibliotecas como Matplotlib ou Plotly, então registrar como artefatos:
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"Comparação de {metric_name}")
plt.xlabel("Etapa")
plt.ylabel(metric_name)
plt.legend()</p>
<p># Salve e registre o plot
plt.savefig(f"{metric_name}_comparação.png")
mlflow.log_artifact(f"{metric_name}_comparação.png")</p>
<p># Uso
with mlflow.start_run():
plot_metric_comparison("relevância_da_resposta", ["run_id_1", "run_id_2", "run_id_3"])
Esta função cria um gráfico de linha comparando uma métrica específica em várias execuções e registra como um artefato.
Alternativas ao MLflow de Código Aberto
Existem várias alternativas ao MLflow de código aberto para gerenciar fluxos de trabalho de aprendizado de máquina, cada uma oferecendo recursos e integrações únicos.
MLflow Gerenciado pela Databricks
O MLflow gerenciado, hospedado pela Databricks, fornece as funcionalidades principais do MLflow de código aberto, mas com benefícios adicionais, como integração perfeita com o ecossistema da Databricks, recursos de segurança avançados e infraestrutura gerenciada. Isso o torna uma escolha excelente para organizações que precisam de segurança robusta e escalabilidade.
Azure Machine Learning
O Azure Machine Learning oferece uma solução de aprendizado de máquina de ponta a ponta na plataforma de nuvem da Microsoft. Ele fornece compatibilidade com componentes do MLflow, como o registro de modelos e o rastreador de experimentos, embora não seja baseado no MLflow.
Plataformas de ML Dedicadas
Várias empresas fornecem produtos de ML gerenciados com recursos diversificados:
- neptune.ai: Concentra-se no rastreamento de experimentos e gerenciamento de modelos.
- Weights & Biases: Oferece rastreamento de experimentos extensivo, versionamento de conjuntos de dados e ferramentas de colaboração.
- Comet ML: Fornece rastreamento de experimentos, monitoramento de produção de modelos e registro de dados.
- Valohai: Especializa-se em pipelines de aprendizado de máquina e orquestração.
Metaflow
O Metaflow, desenvolvido pela Netflix (NFLX ), é um framework de código aberto projetado para orquestrar fluxos de trabalho de dados e pipelines de ML. Embora ele seja excelente no gerenciamento de implantações em grande escala, ele carece de recursos de rastreamento de experimentos e gerenciamento de modelos abrangentes em comparação com o MLflow.
Amazon SageMaker e Google’s Vertex AI
Tanto o Amazon SageMaker (AMZN ) quanto o Google’s Vertex AI (GOOGL ) fornecem soluções de MLOps completas integradas às suas respectivas plataformas de nuvem. Esses serviços oferecem ferramentas robustas para construir, treinar e implantar modelos de aprendizado de máquina em escala.
Comparação Detalhada
MLflow Gerenciado vs. MLflow de Código Aberto
O MLflow gerenciado pela Databricks oferece várias vantagens sobre a versão de código aberto, incluindo:
- Configuração e Implantação: Integração perfeita com a Databricks reduz o tempo e o esforço de configuração.
- Escalabilidade: Capaz de lidar com grandes cargas de trabalho de aprendizado de máquina com facilidade.
- Segurança e Gerenciamento: Recursos de segurança prontos para uso, como controle de acesso baseado em papéis (RBAC) e criptografia de dados.
- Integração: Integração profunda com os serviços da Databricks, melhorando a interoperabilidade e a funcionalidade.
- Armazenamento e Backup de Dados: Estratégias de backup automatizadas garantem a segurança e a confiabilidade dos dados.
- Custo: Os usuários pagam pela plataforma, armazenamento e recursos de computação.
- Suporte e Manutenção: Suporte e manutenção dedicados fornecidos pela Databricks.
Conclusão
Rastrear Modelos de Linguagem Grande com o MLflow fornece uma estrutura robusta para gerenciar as complexidades do desenvolvimento, avaliação e implantação de LLMs. Ao seguir as práticas recomendadas e aproveitar os recursos avançados delineados neste guia, você pode criar experimentos de LLM mais organizados, reprodutíveis e esclarecedores.
Lembre-se de que o campo dos LLMs está evoluindo rapidamente, e novas técnicas para avaliação e rastreamento estão surgindo constantemente. Mantenha-se atualizado com as últimas versões do MLflow e pesquisas sobre LLMs para refinar continuamente seus processos de rastreamento e avaliação.
À medida que você aplica essas técnicas em seus projetos, você desenvolverá uma compreensão mais profunda do comportamento e do desempenho dos seus LLMs, levando a modelos de linguagem mais eficazes e confiáveis.
