Enabling stable preservation of ML algorithms in high-energy physics with petrifyML

Este artigo apresenta o pacote petrifyML, uma ferramenta projetada para garantir a preservação estável e a reprodutibilidade futura de algoritmos de aprendizado de máquina de física de altas energias, convertendo suas configurações para o formato padrão da indústria ONNX ou para código nativo em Python e C++.

O essencial

Imagine que você é um chef que criou uma receita revolucionária para um prato que ajuda cientistas a compreender o universo. Você anotou a receita em um caderno muito específico e complexo, que apenas sua equipe atual de cozinha (uma versão específica de software) consegue ler.

Agora, imagine que, daqui a 10 ou 20 anos, a cozinha muda. A equipe se vai, o software é atualizado e aquele caderno específico torna-se um amontoado ilegível de caracteres. Se alguém quiser preparar aquele prato para verificar seus resultados, não conseguirá. A receita foi perdida.

Este é o problema que cientistas da Física de Altas Energias (HEP) enfrentam com o Aprendizado de Máquina (ML). Eles usam "receitas" complexas (algoritmos) para analisar dados de colisores de partículas. Por muito tempo, essas receitas eram apenas ferramentas internas. Mas agora, as receitas são os resultados. Se as receitas não puderem ser lidas no futuro, a ciência não poderá ser verificada.

Aí entra o petrifyML.

O que é petrifyML?

Pense no petrifyML como uma máquina mágica tradutora e cápsula do tempo. Sua função é pegar aquelas receitas complexas, frágeis e específicas de software e transformá-las em duas coisas:

1. Uma Linguagem Universal (ONNX): É como traduzir sua receita para um formato que toda cozinha do mundo, passada, presente e futura, concorda em entender. É o "PDF" do mundo do aprendizado de máquina.
2. Inglês Simples (Código Nativo): Também pode reescrever a receita em instruções simples e legíveis por humanos (código C++ ou Python) que não precisam de nenhum software especial para rodar. É como escrever a receita em um pedaço de papel que qualquer pessoa pode ler, mesmo sem ter um computador.

Como funciona?

O artigo explica que os cientistas atualmente usam diferentes "ferramentas de cozinha" (pacotes de software como TMVA, scikit-learn, lwtnn) para treinar seus modelos. Essas ferramentas frequentemente falam dialetos diferentes ou dependem de equipamentos pesados e complicados que podem desaparecer no futuro.

O petrifyML atua como uma ponte:

• O Tradutor: Ele pega um modelo treinado em uma dessas ferramentas específicas e o converte para o formato universal ONNX. Isso garante que, mesmo que a ferramenta original desapareça, o modelo ainda possa ser "preparado" (executado) usando ferramentas modernas e padrão.
• O Escrivão: Para modelos mais simples (como Árvores de Decisão Boosted), ele não apenas traduz; reescreve toda a lógica em código de texto simples. É como pegar um relógio mecânico complexo e desenhar cada engrenagem e mola em um papel. Você não precisa mais do relógio; precisa apenas do desenho para reconstruí-lo. Isso garante que o modelo funcione exatamente da mesma forma para sempre, sem precisar de nenhuma atualização específica de software.

Por que isso é importante?

O artigo destaca alguns benefícios-chave:

• Fim do "Funciona na Minha Máquina": Geralmente, se você tentar executar um modelo antigo em um computador novo, ele quebra porque as versões de software não coincidem. O petrifyML remove essa dependência.
• Preparação para o Futuro: Ao converter modelos para ONNX ou código simples, os cientistas garantem que seu trabalho possa ser reinterpreta décadas depois. É como preservar um documento não em um disquete (que pode apodrecer), mas em papel livre de ácido ou em um padrão digital universal.
• Eficiência: O artigo testou essa ferramenta e descobriu que ela funciona rapidamente e não consome muita memória do computador. Os arquivos convertidos são frequentemente menores que os originais, facilitando o armazenamento e o compartilhamento.

A Verificação de "Validação"

Os autores têm o cuidado de dizer: "Apenas entregar a receita traduzida não é suficiente; precisamos garantir que ela tenha o mesmo sabor."
Portanto, o petrifyML inclui um "teste de sabor" embutido. Quando converte um modelo, ele gera automaticamente um script que executa a nova versão e a compara com a versão antiga para garantir que ambas produzam exatamente os mesmos resultados. Se houver até mesmo uma pequena diferença, o usuário saberá que algo deu errado.

Em Resumo

O petrifyML é uma ferramenta projetada para salvar as "receitas" da física de partículas de serem perdidas pelo tempo. Ele pega modelos complexos de aprendizado de máquina dependentes de software e os transforma em um formato padrão universal ou em código simples e legível por humanos. Isso garante que as descobertas científicas feitas hoje possam ser verificadas, compreendidas e confiadas por cientistas daqui a 50 anos, independentemente de qual tecnologia existir naquele momento.

Resumo técnico

Resumo Técnico: Habilitando a Preservação Estável de Algoritmos de ML em Física de Altas Energias com petrifyML

Declaração do Problema
O aprendizado de máquina (ML) em Física de Altas Energias (HEP) evoluiu de uma ferramenta interna para calibração e reconstrução para um componente central e não paramétrico da análise de dados físicos. Embora essa transição aumente a sensibilidade a novos modelos de física, ela introduz desafios significativos para a reprodutibilidade científica. Os algoritmos de ML atuais são tipicamente treinados e implantados usando ferramentas baseadas em Python (por exemplo, TMVA, scikit-learn, lwtnn) que sofrem de instabilidade de versão, dependências pesadas (particularmente o framework ROOT) e incompatibilidade de formatos.

As estratégias de preservação existentes enfrentam limitações:

• Arquivos Pickle/Joblib: Altamente dependentes de versão e instáveis ao longo do tempo; não são adequados para preservação de longo prazo sem containerização completa.
• Formato ONNX: Embora seja um padrão da indústria, muitas ferramentas específicas de HEP (TMVA, lwtnn, MVAUtils) não suportam nativamente a conversão para ONNX. Além disso, a estabilidade de longo prazo dos ambientes de execução ONNX não é garantida sem uma containerização trabalhosa.
• Código Nativo: A conversão para C++ ou Python legíveis elimina dependências, mas é frequentemente limitada a modelos pequenos devido a restrições de tamanho de arquivo.

Existe uma lacuna crítica na "cadeia de preservação de algoritmos" para converter configurações específicas de ML de HEP em formatos estáveis, livres de dependências ou padrões da indústria.

Metodologia
Os autores apresentam o petrifyML, um pacote Python e conjunto de ferramentas de linha de comando projetados para preencher essa lacuna. A ferramenta converte configurações de ML de frameworks comuns de HEP para o formato ONNX ou para código C++/Python nativo.

O pacote é modular, com dependências instaladas via pip com base na tarefa de conversão específica:

1. Árvores de Decisão Boosted (BDTs):
   • scikit-learn: Converte arquivos .pkl ou .job para C++ e Python nativos.
   • TMVA: Converte arquivos XML (arquivos ROOT não são suportados diretamente para esta conversão) para C++ e Python nativos.
   • MVAUtils: Converte arquivos MVAUtils baseados em ROOT (originados de xgboost ou lgbm) para ONNX. Isso utiliza a biblioteca uproot para analisar arquivos sem exigir uma instalação completa do ROOT.
2. Redes Neurais (NNs):
   • TMVA (MLPs): Lê arquivos XML do TMVA, reconstrói a arquitetura e os pesos no TensorFlow/Keras e exporta para ONNX usando tf2onnx.
   • lwtnn: Converte arquivos JSON lightweightneuralnetwork (usados em gatilhos do ATLAS) para ONNX. Atualmente suporta um subconjunto de tipos de camadas (Dense, Normalization, Softmax) e funções de ativação (Relu, Sigmoid, Elu, Tanh).

Principais Recursos e Validação

• Retenção de Metadados: O petrifyML tenta preservar configurações de treinamento e parâmetros de normalização, embora limitado pelas capacidades dos formatos de entrada/saída.
• Scripts de Validação: A ferramenta opcionalmente gera scripts de validação que comparam a saída do modelo convertido com a implementação original usando entradas geradas aleatoriamente (escaladas pelas estatísticas de valor de corte do modelo).
• Controle de Versão: Para conversões ONNX, os usuários podem especificar --opset e --ir-version para garantir compatibilidade com versões específicas do OnnxRuntime, abordando problemas potenciais com padrões ONNX em rápida evolução.
• Geração de Código Nativo: Para BDTs, a ferramenta gera código C++ ou Python legível que é livre de dependências, garantindo "desempenho literal em perpetuidade" para modelos menores.

Resultados e Benchmarks
Os autores realizaram benchmarks do petrifyML em um conjunto de 1.230 modelos (incluindo modelos lwtnn, MVAUtils, scikit-learn e TMVA) usando uma CPU Intel Core i7-14700.

• Desempenho de Conversão:

  • Uso de Memória: Varia de alguns MB para conversões lwtnn/ONNX a ~3,5 GB para grandes florestas xgboost MVAUtils (125.000 árvores). A maioria das conversões requer menos de 200 MB.
  • Tempo: Os tempos de conversão variam significativamente. lwtnn para ONNX leva ~0,04s, enquanto grandes florestas xgboost MVAUtils podem levar >4 minutos. Conversões sucessivas no mesmo ambiente são significativamente mais rápidas devido à importação em cache de módulos.
  • Tamanho do Arquivo: Arquivos convertidos são geralmente compactos. Arquivos ONNX são até 80% menores que os originais (exceto para arquivos MVAUtils altamente otimizados, que podem aumentar de tamanho por um fator de 3). Arquivos C++/Python nativos para BDTs TMVA variam de 5.000 a 41.000 linhas, mas permanecem mais eficientes em espaço que os formatos XML originais.

• Desempenho de Inferência:

  • Precisão: Modelos ONNX convertidos mostram erros de saída relativos inferiores a $10^{-6}$ em comparação com os originais. Conversões de código nativo concordam perfeitamente.
  • Memória: A inferência geralmente requer <100 MB. BDTs C++ nativos são significativamente mais eficientes em memória que implementações em Python ou originais.
  • Velocidade: Tempos de inferência são geralmente pequenos (<0,1s). A inferência C++ nativa para BDTs é frequentemente mais rápida que o modelo original, enquanto a inferência em Python é mais lenta. A diferença relativa de velocidade é considerada negligenciável dada a velocidade absoluta de todos os métodos.

Significado e Alegações
O artigo posiciona o petrifyML não como um substituto para métodos de exportação nativa quando todas as informações estão disponíveis, mas como uma solução necessária para preservar modelos onde a exportação nativa é impossível ou onde o ambiente de treinamento original foi perdido.

• Reprodutibilidade: A ferramenta permite a preservação de longo prazo de algoritmos de ML de HEP convertendo-os em formatos (ONNX ou código nativo) que são menos dependentes de versões específicas de kits de ferramentas ou do framework ROOT pesado.
• Acessibilidade: Ao converter formatos específicos de HEP (como JSON lwtnn ou XML TMVA) para ONNX, a ferramenta permite que esses modelos sejam usados em Python e por frameworks de reinterpretação (por exemplo, Rivet, CheckMATE2) que podem não suportar as bibliotecas específicas de HEP originais.
• Praticidade: Os autores afirmam que a ferramenta aborda com sucesso a questão "insuperável" da dependência do ROOT para muitas ferramentas de reinterpretação e fornece uma alternativa leve para preservar grandes florestas de BDTs que seriam impraticáveis de armazenar como código em texto simples.

O artigo conclui que o petrifyML é um passo prático em direção às "Diretrizes de Les Houches sobre ML reinterpretable", fornecendo um mecanismo para garantir que estudos experimentais baseados em ML permaneçam interpretáveis e reprodutíveis a longo prazo.