MoreFit: A More Optimised, Rapid and Efficient Fit

This paper introduces MoreFit, a high-performance framework for unbinned maximum likelihood parameter estimation in particle physics that leverages just-in-time compiled computation graphs, novel automatic optimizations, and heterogeneous backends (OpenCL and LLVM/Clang) to achieve superior speed and efficiency across diverse hardware platforms.

The Gist

Imagine you are a detective trying to solve a massive mystery. You have a pile of millions of clues (data points), and you need to figure out the exact settings of a complex machine (the parameters) that created them. In the world of particle physics, this is called an "unbinned maximum likelihood fit."

Basically, you are trying to find the "sweet spot" where your mathematical model matches the real-world data perfectly. The problem is that with millions of clues and hundreds of knobs to turn, this calculation is incredibly slow and eats up a lot of computer power.

Enter MoreFit. Think of MoreFit as a super-smart, high-speed assistant designed specifically to solve these mysteries faster and more efficiently than the old tools.

Here is how it works, broken down into simple concepts:

1. The "Lego Blueprint" (Computation Graphs)

Traditional software often calculates these mysteries by writing out long, rigid instructions for every single step. MoreFit, however, builds a "Computation Graph."

Imagine a Lego blueprint. Instead of just listing every brick, the blueprint shows how the bricks connect. MoreFit draws this map of the math problem. Because it has the whole map, it can see the big picture and spot inefficiencies that a human or a rigid program might miss.

2. The "Auto-Optimizer" (Just-in-Time Compilation)

Once MoreFit has the blueprint, it doesn't just run the instructions; it rewrites them on the fly to be as fast as possible. This is called "Just-in-Time compilation."

Think of it like a chef who, before cooking a meal for a crowd, looks at the recipe and realizes, "Hey, I'm going to chop these onions for every single dish. Instead of chopping them fresh for every plate, I'll chop a giant batch once and keep it ready."

• The Old Way: Chop onions for every single event (slow).
• The MoreFit Way: Realize some parts of the math don't change from event to event, calculate them once, and reuse the result. This saves a massive amount of time.

3. The "Super-Team" (Parallelism & Heterogeneous Architectures)

The old way of doing this was like having one person try to sort a million cards, one by one. MoreFit realizes that sorting cards is an "embarrassingly parallel" job—meaning everyone can do a piece of it at the same time without getting in each other's way.

MoreFit is built to work with a mixed team of computers:

• GPUs (Graphics Cards): These are like a swarm of bees, capable of doing thousands of tiny tasks simultaneously. MoreFit uses open standards (OpenCL) so it can talk to any brand of GPU, not just one specific type.
• CPUs (Processors): These are like a team of highly skilled specialists. MoreFit can also use them, organizing them to work in perfect sync (vectorization) to speed things up.

4. The "Magic Shortcut" (Symbolic Differentiation)

To find the perfect solution, the computer needs to know which way to turn the knobs to get closer to the answer. Usually, it has to guess and check, which is slow.
MoreFit uses symbolic differentiation. Instead of guessing, it uses math rules to write down the exact direction to go. It's like having a GPS that tells you the exact route, rather than someone driving around blindly looking for the right street. This makes the "fitting" process converge (find the answer) in just a few steps instead of hundreds.

5. The "Fake Data" Factory (Pseudo-experiments)

Before trusting a detective's conclusion, you often want to test if their method works by creating fake crime scenes and seeing if they solve them. In physics, this is called generating "pseudo-experiments."
MoreFit is incredibly fast at this too. Because it knows the rules of the game perfectly, it can generate these fake scenarios much faster than other tools, allowing scientists to run thousands of tests to ensure their results are reliable.

The Results: A Race Against Time

The author tested MoreFit against two other famous tools (RooFit and zfit) using two types of puzzles:

1. A simple mass fit: Like finding the weight of an object.
2. A complex angular fit: Like figuring out the 3D rotation of a spinning object.

The Verdict:

• MoreFit was often 10 to 50 times faster than the competition, especially when dealing with large amounts of data.
• On a standard computer processor, it was significantly faster than the old methods.
• On a powerful graphics card (GPU), it was nearly an order of magnitude (10x) faster than the leading competitor.

Summary

MoreFit is a new tool that treats data fitting like a well-organized construction project. By drawing a smart blueprint, rewriting the instructions to remove waste, and using a massive team of workers (GPUs and CPUs) simultaneously, it solves complex physics problems in a fraction of the time it used to take. This allows scientists to do more science with less waiting time and less energy consumption.

Technical Summary

Technical Summary: MoreFit – A More Optimised, Rapid and Efficient Fit

Problem Statement

Parameter estimation via unbinned maximum likelihood fits is a cornerstone of particle physics, offering the advantage of retaining full information without the losses associated with binning. However, modern experiments generate unprecedented data volumes (often $O(10^6)$ events) requiring the determination of complex parameter sets (often $>100$ parameters). Furthermore, rigorous statistical validation, such as coverage correction using pseudo-experiments (e.g., Feldman-Cousins methods), demands performing $O(10^5)$ or more fits per parameter. These computational demands render traditional fitting frameworks time- and energy-consuming, necessitating a solution that can efficiently exploit parallelism across heterogeneous architectures.

Methodology

MoreFit is a C++ fitting framework designed specifically for unbinned maximum likelihood fits, prioritizing parallelism and automatic optimization. Its core strategy relies on computation graphs that are compiled just-in-time (JIT) to generate execution kernels for specific hardware backends.

Core Architecture

1. Computation Graphs: Probability Density Functions (PDFs) are represented as tree-structured computation graphs containing basic operations, functions, variables, and constants. This structure facilitates:

   • Symbolic Differentiation: The framework automatically applies the chain rule to compute analytic gradients and Hessian matrices (second derivatives) required for minimization and uncertainty estimation.
   • Automatic Optimization: The graphs are analyzed to identify and optimize redundant calculations.

2. Compute Backends: MoreFit utilizes open standards to target heterogeneous platforms:

   • OpenCL Backend: The default for GPUs, supporting all major vendors. It generates OpenCL C kernels for likelihood evaluation, gradient/Hessian calculation, and event generation. It employs Kahan summation on the accelerator to minimize host-device data transfer overhead.
   • LLVM/Clang Backend: Designed for CPUs, this backend compiles C kernels JIT. It supports Single Instruction Multiple Data (SIMD) vectorization and multithreaded execution via a thread-pooling strategy to avoid thread creation overhead.

Automatic Optimization Techniques

MoreFit employs several novel, automatic optimization strategies applied to the computation graphs:

• Parameter-Dependent Term Caching: Terms in the likelihood function that depend only on parameters (e.g., normalization integrals) and not on specific event data are identified, calculated once on the host per parameter update, and buffered. These buffered values are passed as constants to the compute kernel, significantly reducing kernel complexity.
• Event-Dependent Term Precomputation: For terms depending solely on event variables (e.g., angular terms in a decay analysis), the framework can precompute these values in a separate kernel step. The resulting higher-dimensional data is then used in a simplified likelihood kernel, avoiding repeated evaluation of complex expressions during the minimization loop.
• Pseudo-Experiment Generation Optimization: During the generation of pseudo-data, all parameters are fixed. MoreFit treats parameter-dependent terms as constants, drastically simplifying the generation graph. It supports on-accelerator generation using pseudo-random number generators (e.g., Xoshiro128++) to minimize host-device transfers.

Key Contributions

• Framework Introduction: The presentation of MoreFit, a lightweight, dependency-minimal C++ library that does not rely on TensorFlow or ROOT (though ROOT compatibility is possible).
• JIT Compilation & Graph Optimization: A novel approach where computation graphs are automatically analyzed and optimized before JIT compilation, allowing for significant performance gains without user intervention.
• Heterogeneous Support: A unified interface for execution on both GPUs (via OpenCL) and CPUs (via LLVM/Clang with SIMD), ensuring broad hardware compatibility.
• Analytic Derivatives: The provision of analytic gradients and Hessians derived via symbolic differentiation, which improves convergence speed compared to numerical differentiation.

Results

The paper benchmarks MoreFit (v0.1) against RooFit (v6.32.08) and zfit (v0.24.2) using an AMD 7950X3D CPU and an NVIDIA Titan V GPU. Two scenarios were tested: a 1D mass fit (4 parameters) and a multidimensional angular fit (8 parameters).

• Performance Gains:
  • Mass Fit: On the CPU with 16 threads, MoreFit with analytic derivatives was up to 2.4 times faster than RooFit's SIMD backend at high statistics ($N=10^6$). On the GPU, MoreFit was nearly an order of magnitude faster than RooFit's CUDA implementation at high statistics.
  • Angular Fit: MoreFit demonstrated a speedup of 6.6x over RooFit's SIMD backend on a single CPU thread at low statistics, increasing to ~11x at intermediate/high statistics. On the GPU, MoreFit outperformed zfit by a factor of 32–48, depending on the dataset size.
• Impact of Analytic Derivatives: Using analytic derivatives significantly reduced the number of minimization iterations (from ~85 to 2–3 for the mass fit; ~200 to 2–3 for the angular fit), leading to substantial speedups, particularly on GPUs where kernel submission overhead is reduced.
• Scalability: MoreFit scales well with thread count on CPUs, showing speedups of up to an order of magnitude at high statistics when using 16 threads compared to a single thread.

Significance and Outlook

The paper claims that MoreFit demonstrates the power of using automatically optimized computation graphs for parameter fits, achieving performance improvements of an order of magnitude or more over existing frameworks. The significance lies in enabling computationally expensive statistical techniques, such as coverage correction, to become feasible and sustainable. By relying on open, vendor-independent standards, MoreFit aims to be broadly usable across diverse hardware.

The authors acknowledge that MoreFit is in an early development stage. Current limitations include a small library of built-in PDFs and the lack of support for binned fits. Future work will focus on expanding the PDF library, implementing efficient general-purpose acceptance corrections, and exploring binned fitting capabilities. The paper concludes that there remains significant potential for improving speed and efficiency in unbinned maximum likelihood fits, contributing to more sustainable use of computational resources in particle physics.