Rastreando Modelos de Linguagem Grande (LLM) com MLflow: Um Guia Completo

À medida que os Modelos de Linguagem Grande (LLMs) crescem em complexidade e escala, rastrear seu desempenho, experimentos e implantações se torna cada vez mais desafiador. É aqui que o MLflow entra em cena – fornecendo uma plataforma abrangente para gerenciar o ciclo de vida completo 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 no espaço de LLM e os benefícios que fornece a engenheiros e cientistas de dados.

Rastreamento e Gerenciamento de Interações LLM

O sistema de rastreamento LLM do MLflow é uma extensão de suas capacidades de rastreamento existentes, personalizado para as necessidades únicas dos LLMs. Ele permite o rastreamento abrangente de interações do modelo, incluindo os seguintes aspectos principais:

• Parâmetros: Registros de pares de valor-chave que detalham os parâmetros de entrada para o LLM, como parâmetros específicos do modelo, como top_k e temperatura. 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 métricas podem ser atualizadas dinamicamente à medida que a execução progride, oferecendo insights em tempo real ou pós-processamento.
• Previsões: Captura 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 a documentação detalhada e análise 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 verdade única. 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 do MLflow registrado, ou qualquer função Python chamável que represente seu modelo.
• Métricas Abrangentes: Oferece uma variedade de métricas personalizadas para a avaliação de LLMs, incluindo métricas dependentes de modelo SaaS (por exemplo, relevância de 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étricas Personalizadas: 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 a necessidade de reexecutar a 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 integrações, gerencia credenciais de forma segura e oferece uma experiência de API consistente. Esse servidor suporta uma gama de modelos fundamentais de provedores SaaS populares, bem como modelos auto-hospedados.
• Ponto de Extremidade Unificado: Facilita a alternância fácil 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 acessadosetamente no código ou por meio da interface do usuário do MLflow para análise detalhada.

A suíte abrangente de ferramentas e integrações do MLflow 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

Depois da 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

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 estaremos usando.

Entendendo as Capacidades de Rastreamento de LLM do MLflow

O sistema de rastreamento de LLM do MLflow se baseia em suas capacidades de rastreamento existentes, adicionando recursos específicamente projetados para os aspectos únicos dos LLMs. Vamos quebrar 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

1. Parâmetros: Esses são configurações de entrada para o seu LLM, como temperatura, top_k ou max_tokens. Você pode registrá-los usando mlflow.log_param() ou mlflow.log_params().
2. Métricas: Medidas quantitativas do desempenho do seu LLM, como precisão, latência ou escores personalizados. Use mlflow.log_metric() ou mlflow.log_metrics() para rastrear essas métricas.
3. 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().
4. 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:

Esse exemplo demonstra o registro de parâmetros, métricas e a entrada/saída como um artefato de tabela.

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 = "Explique o conceito de aprendizado de máquina em termos simples."

# Registre os parâmetros
mlflow.log_param("modelo", "text-davinci-002")
mlflow.log_param("max_tokens", 100)

# Consulte o LLM e registre o resultado
result = query_llm(prompt)
mlflow.log_metric("comprimento_da_resposta", len(result))

# Registre o prompt e a resposta
mlflow.log_table("prompt_respostas", {"prompt": [prompt], "resposta": [result]})

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

# Inicialize o cliente de implantação
client = get_deploy_client("databricks")

# Defina a configuração do ponto de extremidade
nome_ponto_de_extremidade = "ponto-de-extremidade-llm"
config_ponto_de_extremidade = {
"entidades_servidas": [{
"nome": "gpt-modelo",
"modelo_externo": {
"nome": "gpt-3.5-turbo",
"provedor": "openai",
"tarefa": "llm/v1/completions",
"config_openai": {
"tipo_api_openai": "azure",
"chave_api_openai": "{{secrets/escopo/chave_api_openai}}",
"base_api_openai": "{{secrets/escopo/base_api_openai}}",
"nome_implantação_openai": "gpt-35-turbo",
"versao_api_openai": "2023-05-15",
},
},
}],
}

# Crie o ponto de extremidade
client.create_endpoint(name=nome_ponto_de_extremidade, config=config_ponto_de_extremidade)

Esse 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 de chaves de API seguro.

Testando o Ponto de Extremidade

Uma vez criado o ponto de extremidade, podemos testá-lo:

<div class="relative flex flex-col rounded-lg">

resposta = client.predict(
endpoint=nome_ponto_de_extremidade,
inputs={"prompt": "Explique o conceito de redes neurais brevemente.", "max_tokens": 100,},)

print(resposta)

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 dessas formas:

1. Uma instância de mlflow.pyfunc.PyFuncModel ou um URI apontando para um modelo do MLflow registrado.
2. Uma função Python que aceita entradas de string e produz uma única string de saída.
3. Um URI de ponto de extremidade de implantação do MLflow.
4. Defina modelo=None e inclua as saídas do modelo nos dados de avaliação.

Vamos olhar um exemplo usando um modelo do MLflow registrado:

import mlflow
import openai

with mlflow.start_run():
prompt_sistema = "Responda a seguinte pergunta de forma concisa."
info_modelo_registrado = mlflow.openai.log_model(
modelo="gpt-3.5-turbo",
tarefa=openai.chat.completions,
caminho_artefato="modelo",
mensagens=[
{"papel": "sistema", "conteudo": prompt_sistema},
{"papel": "usuario", "conteudo": "{pergunta}"},
],
)

# Prepare os dados de avaliação
dados_avaliacao = pd.DataFrame({
"pergunta": ["O que é aprendizado de máquina?", "Explique redes neurais."],
"verdade_terra": [
"O aprendizado de máquina é um subconjunto da IA que permite que os 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.",
]
})

# Avalie o modelo
resultados = mlflow.evaluate(
info_modelo_registrado.modelo_uri,
dados_avaliacao,
alvos="verdade_terra",
tipo_modelo="resposta-pergunta",
)

print(f"Métricas de avaliação: {resultados.metricas}")

Esse exemplo registra um modelo OpenAI, prepara os dados de avaliação e, em seguida, avalia o modelo usando as métricas incorporadas do MLflow para tarefas de resposta a perguntas.

Métricas de Avaliação Personalizadas

O MLflow permite que você defina métricas personalizadas para a avaliação de LLMs. Aqui está um exemplo de criação de uma métrica personalizada para avaliar a profissionalidade das respostas:

from mlflow.metrics.genai import ExemploAvaliacao, criar_metrica_genai

profissionalismo = criar_metrica_genai(
nome="profissionalismo",
definicao="Medida de estilo de comunicação formal e apropriado.",
prompt_avaliacao=(
"Pontue a profissionalidade da resposta em uma escala de 0-4:\n"
"0: Extremamente casual ou inadequado\n"
"1: Casual, mas respeitoso\n"
"2: Moderadamente formal\n"
"3: Profissional e apropriado\n"
"4: Altamente formal e habilmente elaborado"
),
exemplos=[
ExemploAvaliacao(
entrada="O que é MLflow?",
saida="MLflow é como sua ferramenta de gerenciamento de projetos de ML amigável. É super legal!",
pontuacao=1,
justificativa="A resposta é casual e usa linguagem informal.",
),
ExemploAvaliacao(
entrada="O que é MLflow?",
saida="MLflow é uma plataforma de código aberto para o ciclo de vida do aprendizado de máquina, incluindo experimentação, reprodutibilidade e implantação.",
pontuacao=4,
justificativa="A resposta é formal, concisa e profissionalmente redigida.",
)
],
modelo="openai:/gpt-3.5-turbo-16k",
parametros={"temperatura": 0.0},
agregacoes=["media", "variancia"],
maior_eh_melhor=True,
)

# Use a métrica personalizada na avaliação
resultados = mlflow.evaluate(
info_modelo_registrado.modelo_uri,
dados_avaliacao,
alvos="verdade_terra",
tipo_modelo="resposta-pergunta",
metricas_extras=[profissionalismo]
)

print(f"Pontuação de profissionalismo: {resultados.metricas['profissionalismo_media']}")

Essa métrica personalizada usa o GPT-3.5-turbo para pontuar a profissionalidade das respostas, demonstrando como você pode aproveitar os 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 evoluem. Vamos explorar algumas técnicas avançadas de avaliação usando o MLflow.

Avaliação de Geração com Recuperação (RAG)

Os sistemas RAG combinam o poder dos modelos de recuperação e geração. Avaliar sistemas RAG exige avaliar tanto o componente de recuperação quanto o 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

# Carregue e pré-processe os documentos
carregador = WebBaseLoader([“https://mlflow.org/docs/latest/index.html”])
documentos = carregador.load()
divisor_texto = CharacterTextSplitter(tamanho_chunk=1000, sobreposicao_chunk=0)
textos = divisor_texto.split_documents(documentos)

# Crie um repositório de vetores
incrustacoes = OpenAIEmbeddings()
repositorio_vetores = Chroma.from_documents(textos, incrustacoes)

# Crie uma cadeia RAG
llm = OpenAI(temperatura=0)
cadeia_qa = RetrievalQA.from_chain_type(
llm=llm,
tipo_cadeia=”stuff”,
recuperador=repositorio_vetores.as_recuperador(),
retornar_documentos_fonte=True
)

# Função de avaliação
def avaliar_rag(pergunta):
resultado = cadeia_qa({“query”: pergunta})
return resultado[“resultado”], [doc.conteudo_pagina for doc in resultado[“documentos_fonte”]]

# Prepare os dados de avaliação
perguntas_avaliacao = [
“O que é MLflow?”,
“Como o MLflow lida com o rastreamento de experimentos?”,
“Quais são os principais componentes do MLflow?”,
]

# Avalie usando o MLflow
with mlflow.start_run():