Weight-Based Representation Learning for Parameter Inference in Monte Carlo Simulations

This paper introduces a machine learning framework that leverages event-level simulation weights as weak supervision signals to learn parameter-informative representations from high-dimensional data, which are then discretized into summary statistics for likelihood-based inference of physics model parameters, demonstrated through the estimation of the top quark Yukawa coupling in four-top-quark production.

The Gist

The Big Picture: Finding the "Knob" in a Black Box

Imagine you are trying to figure out how a specific dial (a parameter) on a complex machine affects the sound it makes. In physics, this machine is the universe, and the dial is something called the Top Yukawa coupling (a number that tells us how strongly a specific particle, the top quark, interacts with the Higgs boson).

Usually, to figure out what this dial is set to, scientists have to run the machine millions of times, changing the dial slightly each time, and see how the sound changes. This is incredibly slow, expensive, and requires massive amounts of computer power.

This paper proposes a smarter way. Instead of running the machine over and over again, they use a "cheat code" provided by the machine itself: weights.

The Analogy: The Weighted Dice

Imagine you have a bag of dice.

• The Traditional Way: To see how the dice behave, you roll them 1,000 times. Then, you change the dice slightly, roll them 1,000 more times. Then change them again, and roll again. You need thousands of rolls to see the pattern.
• The Paper's Way: The machine (the simulator) gives you a bag of dice, but it also hands you a list of "weights" for every single roll.
  • If a roll happens when the dial is set to "High," the simulator says, "This roll counts as 100 normal rolls."
  • If a roll happens when the dial is set to "Low," the simulator says, "This roll only counts as 0.1 of a normal roll."

The authors realized that these weights are like a secret map. They tell the computer exactly how sensitive the dice are to the dial. By teaching a computer to look at the dice rolls and read these weights, the computer learns the relationship between the roll and the dial setting without needing to re-roll the dice thousands of times.

How They Did It: The Two-Step Detective

The researchers built a two-step AI system (a Machine Learning model) to solve this puzzle using data from simulated particle collisions (specifically, creating four top quarks at once).

Step 1: The Bouncer (Background Rejection)
In a real particle collision, you get a lot of "noise" (unwanted events that look like what you want but aren't).

• The Analogy: Imagine a nightclub. You want to find the VIPs (the signal), but there are lots of regular guests (background noise) who look similar.
• The Action: The first AI acts as a bouncer. It looks at the event and says, "This is definitely a VIP," "This is a regular guest," or "This is a different type of guest." It filters out the noise so the next step only has to deal with the VIPs.

Step 2: The Detective (Parameter Inference)
Now that the AI has the VIPs, it needs to figure out the dial setting.

• The Analogy: The detective looks at the VIPs and notices a pattern. "When the dial is high, the VIPs tend to wear red hats. When the dial is low, they wear blue hats."
• The Action: The second AI learns to distinguish between "High-Weight" events (where the dial setting matters a lot) and "Low-Weight" events. It builds a summary of the data (like a histogram or a bar chart) that shifts shape depending on the dial setting.

The Results: Smarter with Less Data

The team tested this new method against the old, traditional way (which relies on a "surrogate quantity," essentially just counting how many times a specific event happened and guessing the dial setting from that).

• The Finding: The new method, which uses the weights as a hint, was much better at guessing the dial setting.
• The Proof: When they looked at the "confidence intervals" (the range of possible answers), their new method gave a much tighter, more precise range than the old method. It was like the new method could see the dial setting clearly, while the old method was squinting in the dark.

They also tested this on a more complex scenario involving "CP-violation" (a symmetry breaking in physics). Even though the AI was originally trained on just one dial, it could still help solve the puzzle for two dials, outperforming the traditional method again.

Why This Matters (According to the Paper)

The paper claims that by using the weights that simulators already calculate (which describe how probability changes with the dial), scientists can:

1. Save Time and Money: You don't need to run as many simulations. One set of simulations with weights can cover a continuous range of dial settings.
2. Get Better Answers: The AI learns more from the data because it uses the "secret map" (the weights) that was previously ignored.
3. Be Flexible: This approach works even if the data selection criteria (the rules for what events to keep) aren't perfect, making it robust for real-world experiments.

In short, the paper shows that if you teach your computer to listen to the "whispers" (weights) inside the simulation, you can figure out the secrets of the universe much faster and more accurately than by just shouting and waiting for an echo.

Technical Summary

Technical Summary: Weight-Based Representation Learning for Parameter Inference in Monte Carlo Simulations

Problem Statement
Traditional parameter inference in high-energy physics often relies on simulating observations at discrete points of a continuous parameter space (e.g., the top quark Yukawa coupling, $y_t$) to construct likelihoods. This approach faces two primary limitations: it requires immense computational resources to cover the continuous range of parameters, and it often discards valuable latent information available only at the simulation level. While machine learning (ML) has been applied to learn representations from high-dimensional data, standard approaches typically ignore simulation-specific information, such as event-level weights, which encode the sensitivity of the probability distribution to model parameters. Furthermore, existing methods that utilize simulation-level information (e.g., likelihood ratio construction) often require generating separate datasets for different parameter values, leading to exponential scaling of computational costs when inferring multiple parameters.

Methodology
The authors propose a weight-based representation learning framework that exploits event-level weights provided by Monte Carlo simulators to infer model parameters. The core hypothesis is that these weights, which describe the change in probability with respect to model parameters, serve as a weak supervision signal to learn parameter-informative representations.

The methodology is demonstrated using simulated four-top-quark ($t\bar{t}t\bar{t}$) production to infer the top quark Yukawa coupling ($y_t$). The approach involves a two-stage learning strategy:

1. Background Rejection Network: A neural network is trained to distinguish the signal process ($t\bar{t}t\bar{t}$) from dominant background processes ($t\bar{t}$ and $t\bar{t}H$). The output of this network categorizes events into 55 distinct bins based on the separation of signal and background, ensuring sufficient event purity for subsequent analysis.
2. Parameter Inference Network: A second neural network is trained to discriminate between "high-weight" and "low-weight" events. These categories are defined by the ratio of event weights assigned at different values of $y_t$. The network learns to map kinematic features to a representation where the output distribution shifts as $y_t$ changes. Specifically, as $y_t$ increases, the distribution of high-weight events becomes more pronounced.

Data Representation and Inference
The outputs from both networks are used to construct binned summary statistics (template histograms). Events are first binned by the background rejection network (55 categories) and then further subdivided by the parameter inference network into histograms with up to six bins.

Two inference strategies are compared:

• Direct Inference: The event yields in each histogram bin are parametrized as continuous functions of the normalized Yukawa coupling ratio $Y_t = |y_t/y_t^{SM}|$. Signal yields ($t\bar{t}t\bar{t}$) are fitted to a 4th-order polynomial, while background yields ($t\bar{t}$ and $t\bar{t}H$) are fitted to 2nd-order polynomials or scaled by $Y_t^2$. A likelihood function is constructed using these parametrized yields to infer the probable range of $Y_t$.
• Traditional (Surrogate) Inference: A benchmark method where the cross-section of the $t\bar{t}t\bar{t}$ process is inferred via a signal strength parameter ($\mu$). This inferred cross-section is then compared against theoretical predictions to derive bounds on $Y_t$.

Key Results
The study evaluates the performance of the proposed method against the traditional surrogate approach using simulated data corresponding to three data scenarios: 2017 CMS, Full Run 2 (2016–2018) CMS, and the High-Luminosity LHC (HL-LHC).

• Precision: The direct inference method yields tighter constraints on $Y_t$ compared to the traditional method. For instance, at the HL-LHC data level, the direct method achieves a 68% confidence level (CL) range of $1^{+0.112}_{-0.095}$, whereas the traditional method (without parametrizing backgrounds) yields a wider range.
• Systematic vs. Statistical Uncertainty: As expected, statistical uncertainties decrease with increased data volume, but systematic uncertainties remain constant, indicating that further improvements in coupling measurement sensitivity depend on reducing systematic errors.
• Multi-Parameter Extension: The authors extend the framework to a CP-violation case study involving two parameters: a CP-even coupling ($a_t$) and a CP-odd coupling ($b_t$). The summary statistics constructed for the single-parameter case are adapted to infer the joint region of $a_t$ and $b_t$. The results show that the direct inference method provides significantly tighter constraints on the parameter space compared to the surrogate cross-section method, particularly when background processes are parametrized.

Significance and Claims
The paper claims that incorporating simulator-provided event weights into the ML training process allows for the extraction of parameter-sensitive information that is otherwise inaccessible from reconstructed observables alone. By learning the relationship between kinematic features and simulation-level weights, the model can infer parameters over a continuous range without requiring multiple discrete simulations for each parameter value.

The authors emphasize that this approach is computationally efficient, as it replaces the need for multiple simulations across a parameter grid with a single set of simulations augmented by weight calculations. Furthermore, the method is presented as a practical extension of existing histogram-based approaches, offering improved sensitivity over traditional surrogate quantity methods. The paper concludes that while the current work is a proof-of-concept, the framework is robust and can be applied to other parameter inference problems where simulators provide weight calculations, potentially outperforming traditional methods even when the inference model is not explicitly trained on the extended parameters of a modified physics model.