À medida que os Massive Language Fashions (LLMs) crescem em complexidade e escala, rastrear seu desempenho, experimentos e implantações se torna cada vez mais desafiador. É aí que o MLflow entra – fornecendo uma plataforma abrangente para gerenciar todo o ciclo de vida dos modelos de machine studying, incluindo LLMs.
Neste guia aprofundado, exploraremos como aproveitar o MLflow para rastrear, avaliar e implementar LLMs. Abordaremos tudo, desde a configuração do seu ambiente até técnicas avançadas de avaliação, com muitos exemplos de código e melhores práticas ao longo do caminho.
Funcionalidade do MLflow em Massive Language Fashions (LLMs)
O MLflow se tornou uma ferramenta essencial na comunidade de machine studying e ciência de dados, especialmente para gerenciar o ciclo de vida de modelos de machine studying. Quando se trata de Massive Language Fashions (LLMs), o MLflow oferece um conjunto robusto de ferramentas que simplificam 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 ele fornece a engenheiros e cientistas de dados.
Acompanhamento e gerenciamento de interações LLM
O sistema de rastreamento LLM da MLflow é um aprimoramento de seus recursos de rastreamento existentes, adaptado às necessidades exclusivas dos LLMs. Ele permite o rastreamento abrangente de interações de modelos, incluindo os seguintes aspectos principais:
- Parâmetros: Registro de pares de valores-chave que detalham os parâmetros de entrada para o LLM, como parâmetros específicos do modelo, como
top_ketemperature. 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 a precisão do LLM. Elas podem ser atualizadas dinamicamente conforme a execução progride, oferecendo insights em tempo actual ou pós-processo.
- Previsões: Captura das 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 meticulosamente registradas, 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 generativa e à falta de uma única verdade elementary. O MLflow simplifica isso com ferramentas de avaliação especializadas projetadas para LLMs. Os principais recursos incluem:
- Avaliação de modelo versátil: Suporta avaliação de vários tipos de LLMs, seja um modelo MLflow pyfunc, um URI apontando para um modelo MLflow registrado ou qualquer 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étricas personalizadas: Permite que os usuários definam e implementem métricas personalizadas para atender às necessidades específicas de avaliação, aumentando a flexibilidade e a 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 executar novamente a inferência do modelo.
Implantação e Integração
O MLflow também oferece suporte à implantação e integração perfeitas de LLMs:
- Servidor de implantações MLflow: Atua como uma interface unificada para interagir com vários provedores de LLM. Ele simplifica integrações, gerencia credenciais com segurança e oferece uma experiência de API consistente. Este servidor suporta uma variedade de modelos fundamentais de fornecedores populares de SaaS, bem como modelos auto-hospedados.
- Ponto de extremidade unificado: Facilita a troca fácil entre provedores sem alterações de código, minimizando o tempo de inatividade e aumentando a flexibilidade.
- Visualização de resultados integrados: 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 é um conjunto abrangente de ferramentas e integrações que o torna um recurso inestimável para engenheiros e cientistas de dados que trabalham com modelos avançados de PNL.
Configurando seu ambiente
Antes de mergulharmos no rastreamento de LLMs com MLflow, vamos configurar nosso ambiente de desenvolvimento. Precisaremos instalar o MLflow e várias outras bibliotecas importantes:
pip set up mlflow>=2.8.1 pip set up openai pip set up chromadb==0.4.15 pip set up langchain==0.0.348 pip set up tiktoken pip set up 'mlflow(genai)' pip set up databricks-sdk --upgrade
Após a instalação, é uma boa prática reiniciar seu ambiente Python para garantir que todas as bibliotecas sejam carregadas corretamente. Em um pocket book Jupyter, você pode usar:
import mlflow
import chromadb
print(f"MLflow model: {mlflow.__version__}")
print(f"ChromaDB model: {chromadb.__version__}")
Isso confirmará as versões das principais bibliotecas que usaremos.
Compreendendo os recursos de rastreamento de LLM do MLflow
O sistema de rastreamento de LLM da MLflow se baseia em seus recursos de rastreamento existentes, adicionando recursos projetados especificamente para os aspectos exclusivos dos LLMs. Vamos dividir os principais componentes:
Execuções e Experimentos
No MLflow, uma “execução” representa uma única execução do código do seu 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 de chaves
- Parâmetros: Estas são configurações de entrada para seu LLM, como temperatura, top_k ou max_tokens. Você pode registrá-las usando
mlflow.log_param()oumlflow.log_params(). - Métricas: Medidas quantitativas do desempenho do seu LLM, como precisão, latência ou pontuações personalizadas. Use
mlflow.log_metric()oumlflow.log_metrics()para rastreá-los. - Previsões: Para LLMs, é essential registrar os prompts de entrada e as saídas do modelo. O MLflow os armazena como artefatos no formato CSV usando
mlflow.log_table(). - Artefatos: Quaisquer arquivos ou dados adicionais relacionados à sua execução LLM, como pontos de verificação de modelo, visualizações ou amostras de conjuntos de dados. Use
mlflow.log_artifact()para armazená-los.
Vejamos um exemplo básico de registro de uma execução LLM:
Este exemplo demonstra parâmetros de registro, métricas e entrada/saída como um artefato de tabela.
import mlflow
import openai
def query_llm(immediate, max_tokens=100):
response = openai.Completion.create(
engine="text-davinci-002",
immediate=immediate,
max_tokens=max_tokens
)
return response.selections(0).textual content.strip()
with mlflow.start_run():
immediate = "Clarify the idea of machine studying in easy phrases."
# Log parameters
mlflow.log_param("mannequin", "text-davinci-002")
mlflow.log_param("max_tokens", 100)
# Question the LLM and log the consequence
consequence = query_llm(immediate)
mlflow.log_metric("response_length", len(consequence))
# Log the immediate and response
mlflow.log_table("prompt_responses", {"immediate": (immediate), "response": (consequence)})
print(f"Response: {consequence}")
Implantando LLMs com MLflow
O MLflow fornece recursos poderosos para implementar LLMs, facilitando o atendimento de seus modelos em ambientes de produção. Vamos explorar como implementar um LLM usando os recursos de implementação do MLflow.
Criando um ponto remaining
Primeiro, criaremos um endpoint para nosso LLM usando o cliente de implantação do MLflow:
import mlflow
from mlflow.deployments import get_deploy_client
# Initialize the deployment consumer
consumer = get_deploy_client("databricks")
# Outline the endpoint configuration
endpoint_name = "llm-endpoint"
endpoint_config = {
"served_entities": ({
"identify": "gpt-model",
"external_model": {
"identify": "gpt-3.5-turbo",
"supplier": "openai",
"activity": "llm/v1/completions",
"openai_config": {
"openai_api_type": "azure",
"openai_api_key": "{{secrets and techniques/scope/openai_api_key}}",
"openai_api_base": "{{secrets and techniques/scope/openai_api_base}}",
"openai_deployment_name": "gpt-35-turbo",
"openai_api_version": "2023-05-15",
},
},
}),
}
# Create the endpoint
consumer.create_endpoint(identify=endpoint_name, config=endpoint_config)
Este código configura um ponto de extremidade para um modelo GPT-3.5-turbo usando o Azure OpenAI. Observe o uso de segredos do Databricks para gerenciamento seguro de chaves de API.
Testando o Endpoint
Depois que o endpoint for criado, podemos testá-lo:
<div class="relative flex flex-col rounded-lg">
response = consumer.predict(
endpoint=endpoint_name,
inputs={"immediate": "Clarify the idea of neural networks briefly.","max_tokens": 100,},)
print(response)
Isso enviará um immediate ao nosso modelo implantado e retornará a resposta gerada.
Avaliando LLMs com MLflow
A avaliação é essential para entender o desempenho e o comportamento dos seus LLMs. O MLflow fornece ferramentas abrangentes para avaliar LLMs, incluindo métricas integradas e personalizadas.
Preparando seu LLM para avaliação
Para avaliar seu LLM com mlflow.consider()seu modelo precisa estar em um destes formatos:
- Um
mlflow.pyfunc.PyFuncModelinstância ou um URI apontando para um modelo MLflow registrado. - Uma função Python que recebe entradas de string e gera como saída uma única string.
- Um URI de ponto de extremidade de implantações do MLflow.
- Definir
mannequin=Nonee incluir saídas do modelo nos dados de avaliação.
Vejamos um exemplo usando um modelo MLflow registrado:
import mlflow
import openai
with mlflow.start_run():
system_prompt = "Reply the next query concisely."
logged_model_info = mlflow.openai.log_model(
mannequin="gpt-3.5-turbo",
activity=openai.chat.completions,
artifact_path="mannequin",
messages=(
{"function": "system", "content material": system_prompt},
{"function": "consumer", "content material": "{query}"},
),
)
# Put together analysis information
eval_data = pd.DataFrame({
"query": ("What's machine studying?", "Clarify neural networks."),
"ground_truth": (
"Machine studying is a subset of AI that allows techniques to study and enhance from expertise with out specific programming.",
"Neural networks are computing techniques impressed by organic neural networks, consisting of interconnected nodes that course of and transmit info."
)
})
# Consider the mannequin
outcomes = mlflow.consider(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
)
print(f"Analysis metrics: {outcomes.metrics}")
Este exemplo registra um modelo OpenAI, prepara dados de avaliação e, em seguida, avalia o modelo usando as métricas integradas do MLflow para tarefas de resposta a perguntas.
Métricas de avaliação personalizadas
O MLflow permite que você defina métricas personalizadas para avaliação de LLM. Aqui está um exemplo de criação de uma métrica personalizada para avaliar o profissionalismo das respostas:
from mlflow.metrics.genai import EvaluationExample, make_genai_metric
professionalism = make_genai_metric(
identify="professionalism",
definition="Measure of formal and acceptable communication model.",
grading_prompt=(
"Rating the professionalism of the reply on a scale of 0-4:n"
"0: Extraordinarily informal or inappropriaten"
"1: Informal however respectfuln"
"2: Reasonably formaln"
"3: Skilled and appropriaten"
"4: Extremely formal and expertly crafted"
),
examples=(
EvaluationExample(
enter="What's MLflow?",
output="MLflow is like your pleasant neighborhood toolkit for managing ML tasks. It is tremendous cool!",
rating=1,
justification="The response is informal and makes use of casual language."
),
EvaluationExample(
enter="What's MLflow?",
output="MLflow is an open-source platform for the machine studying lifecycle, together with experimentation, reproducibility, and deployment.",
rating=4,
justification="The response is formal, concise, and professionally worded."
)
),
mannequin="openai:/gpt-3.5-turbo-16k",
parameters={"temperature": 0.0},
aggregations=("imply", "variance"),
greater_is_better=True,
)
# Use the customized metric in analysis
outcomes = mlflow.consider(
logged_model_info.model_uri,
eval_data,
targets="ground_truth",
model_type="question-answering",
extra_metrics=(professionalism)
)
print(f"Professionalism rating: {outcomes.metrics('professionalism_mean')}")
Esta métrica personalizada usa GPT-3.5-turbo para pontuar o profissionalismo das respostas, demonstrando como você pode aproveitar os próprios LLMs para avaliação.
Técnicas avançadas de avaliação de LLM
À medida que os LLMs se tornam mais sofisticados, também o fazem as técnicas para avaliá-los. Vamos explorar alguns métodos avançados de avaliação usando MLflow.
Avaliação de geração aumentada de recuperação (RAG)
Os sistemas RAG combinam o poder dos modelos baseados em recuperação e generativos. Avaliar sistemas RAG requer avaliar os componentes de recuperação e geração. Veja 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
# Load and preprocess paperwork
loader = WebBaseLoader(("https://mlflow.org/docs/newest/index.html"))
paperwork = loader.load()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(paperwork)
# Create vector retailer
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
)
# Analysis perform
def evaluate_rag(query):
consequence = qa_chain({"question": query})
return consequence("consequence"), (doc.page_content for doc in consequence("source_documents"))
# Put together analysis information
eval_questions = (
"What's MLflow?",
"How does MLflow deal with experiment monitoring?",
"What are the primary elements of MLflow?"
)
# Consider utilizing MLflow
with mlflow.start_run():
for query in eval_questions:
reply, sources = evaluate_rag(query)
mlflow.log_param(f"query", query)
mlflow.log_metric("num_sources", len(sources))
mlflow.log_text(reply, f"answer_{query}.txt")
for i, supply in enumerate(sources):
mlflow.log_text(supply, f"source_{query}_{i}.txt")
# Log customized metrics
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 e, em seguida, o avalia registrando perguntas, respostas, fontes recuperadas e métricas personalizadas no MLflow.
A maneira como você divide seus documentos pode impactar significativamente o desempenho do RAG. O MLflow pode ajudar você a avaliar diferentes estratégias de divisão:
Este script avalia diferentes combinações de tamanhos de blocos, sobreposições e métodos de divisão, registrando os resultados no MLflow para facilitar a comparação.
O MLflow fornece várias maneiras de visualizar seus resultados de avaliação de LLM. Aqui estão algumas técnicas:
Você pode criar visualizações personalizadas dos resultados da sua avaliação usando bibliotecas como Matplotlib ou Plotly e registrá-las como artefatos:
Esta função cria um gráfico de linhas comparando uma métrica específica em várias execuções e a registra como um artefato.
