I assume you can see this now. Yes. And
since you're so kindly Okay.
I will start.
Thank you very much for the possibility to speak. And I will now follow Isaac's talk,
talking about discussing generative models and events in relation following his talk
on the detector simulation. So, what I'm going to present has been done together
with Miko, like and you can see it's gotten clean and time on the data.
Position simulations based on fish printable MonteCarlo generators are
currently at the heart of any analysis. They're linking the fundamental theory
side, which is basically given by a minimal set of parameters. We see a very
complex detector site where we are facing very large amounts of data and in order to
understand data, you need to simulations to give very precise, unrelated events
samples
in order to get a correct interpretation.
Now, these simulations are facing a lot of challenges. One of them that I should
already mentioned is the slow detector simulations that we have this chance for
us I find instantly complex high dimensional phase space, which has to be
mapped out very precisely. If this mapping is not precisely, then we're facing a very
low unweighting efficiency, making the entire simulation process very
inefficient. This is where neural networks cannot
find solution.
And in particular, their ability to generate very flexible parameterizations.
And the interpolation property allow us to really accurately map this complex face
space. afterwards. They're also very fast navigation, as you've already pointed out,
and is already also a lot of generative models on the market which we can
basically simply pick up and use domain three generative adversarial networks
variational auto encoders and normalizing flows. This is not that new anymore. So
here you see, by all means non complete overview of papers that have already used
these techniques for event generation. They're very roughly categorized in four
categories. First of all, we can use machine learning in order to integrate it
into the MonteCarlo process itself for instance, by estimating matrix element or
for the neural important sampling
in liquid with Magnus gonna
talk about this later, then we can use it for event generation where we start with a
formal mentor often event, which is what I will be focusing on. Then I should already
explained to the technical part, and finally somewhat orthogonal to these three
categories. We can also try to inverse the entire process without your network
unfoldings it detector distribution. Looking at this overview, you see that
very many of these papers, focus on the generative adversarial network are
suitable
and in the following I will do the same. And let me therefore just give a very
short
recap for those who are not familiar with it.
So, the generative adversarial network basically starts with training data up
here. So, this is a treatment. On the other hand, we have some random numbers
which will be inputted into a generator to generate an event sample and we have a
second neural network the discriminator distinguishing these two and a stranger it
we are training loss given a camp. This is now counteracted by the generator who is
trying to fool the discriminator by making noise more similar events so that in the
end when the training has converged successfully, then January is going to
generate events that follows the underlying distribution of the data Why do
we use scans so often and not variational encoders? Well, this is can actually not
be stated like this in absolute value. However, it turns out on on average, very
often the GaNS have a better capability of generating truthful events and very
realistic looking events. It's often a photographer ration out encoders under the
large community tree supporting both approaches. But then on the other hand, is
also more or less big disadvantage of the cans. And many people have already worked
with this have faced unstable training conditions. However, I assume you all the
people who work with this already so there's a lot of solutions on the market,
which you can use in order to face these problems. First of all, you can use
urbanization for the discriminator, for instance, for implementing gradient
penalty, and this is also applied with all the projects that I'm going to present
later. You can modify the training objective by using different Kind of loss
functions but again most prominently I guess the question again and then you can
also process the data. For instance by and making use of symmetries by the whitening
or by using feature meditation out of District so you can very nicely stabilizer
again training Once you've done this we can now look at a realistic and final
state that we want to generate and we start here with TT Bach process. With this
we have six particles in the final, final state. And since when fixing the external
masses and don't enforce momentum conservation by hand doesn't turn 18
dimensional output especially challenges here are the intermediate particles in
particular the invariant mass and within face base boundaries of can arise. From
the very first thing one wants to check so they're not flat observables for instance,
from intermediate practical legs, the top work, which you can see here as the PT of
the top structures that again is very nicely able to
follow the data that we feed it with.
However, when we look now at the ratio of one and two data, we also find that there
is a systematic undershoot in the tails. So in particular, there were we have no
statistics, we have to be very careful of what is being learned. This is
particularly important for the future and when we are when a big target for the
future will be to estimate these kind of uncertainties and to control them when we
want to really use neural networks for event generation. And the next one is
invariant masses in between. That is very difficult again, since it has to combine
information from all of the different final states in order to get the invariant
mass for instance of the W on top. And you see a normal vanilla game is simply going
to generate this green curve down here which is really not coincide with the true
distribution, either but we can use here as the so called maximum mean discrepancy
Mt loss where we use some arbitrary kernel in between. And with this help, we can
actually train the neural network, and it starts to actually produce very nicely the
data distribution. We see when we use for instance, economical doesn't disappoint.
Now that we've solved this, we can move on to actually two dimensional correlations.
And here we see for instance, a correlation between the top and the
bottom.
And if we want to quantify Okay, how well does this
data generate a distribution curve correspond to the true distribution, we
can find some take slice yet PT of the top to 100 TV, that is shown on the right hand
side and you see again, the generated events nicely follows the true data
distribution all the way up to the Face Face boundary weight goes down
into the tails.
So with this we've shown now that Ghana is actually able to We'll learn the
underlying distribution of data that it's trained on. And we thought, Okay, well,
maybe they can also
can do
some more complex task. For this, we look at two distributions that are represented
by samples, and we want to train them again, that is able to consistently
generate a multi dimensional difference between these two distributions. By this
keeping track of all the correlations in the data. The side effects that we're
hoping for here is that it can eat a very effeminate use statistical uncertainty
coming from the fact when we have distributions that have high statistics
that are close to each other, resulting in very large statistic uncertainties. And
the difference here is interpolation. Probably properties of the can can act in
our favor,
such an application. Such a setup
would have many applications for instance of linear subtraction multitrack merging
onto subtraction, or background subtraction, where it's particularly
important that we preserve the correlation underline data. First, we have to extend
our again set up and the most prominent changes are here that we're using two
discriminators one for each of the training data sets representing the two
different distributions. And the fact that one of the discriminators only gets a
subset of the generated events.
Some results, the first one here is set up tempo.
So, we give the network two different data training sets for the data. One is in blue
dotted in here. So this dotted line between solid line the dotted alpha
training data from proton proton to a plus and minus and red dotted as proton proton
via gamma t plus and minus so this most gamma background, and we train it with the
red and the blue data points. And afterwards we see what a network can
actually generate and we see that it but honor produces exactly these distributions
but it can also be properly generates a difference between the two. Second
example, this one was a bit more difficult. So here we actually, as a
physics background, as said, we are looking at Syrian certainties, which will
be a limiting factor for the high luminosity nhc. And for this, we have to
attack the higher order calculations. And one of the tasks that they have to do
there is to subtract the equation Qahtani see what I pulled from real emission
terms, like emission. In this case, we have some space distribution appear in
blue, and we have to subtract the dipole, which are the dotted data in red. And
again, we train the network with the blue and the red data. And the result is a
black line down here. For which we zoom in on the right hand side. And you see here
now the gray bands are actually indicating the statistics, uncertainty, statistical
uncertainty coming from a naive subtraction of the bins of the
distribution and we'll see how that neural network is just very nicely interpolating
through these data over to orders of magnitude three if you're taking the
concept of big data we train and actually are way larger event numbers years and the
difference between the two.
Having
completed this, I want to come to the last project, which actually goes now the other
way. So, here we want to use again to unfold detector events. So, a detector
simulation is typically some kind of process. So, in principle, even though it
will be pride dependent in principle, it should be possible to invert this process
to map
the distribution from before the detective simulation to after the,
from after the second summation
to before the detector simulation. first attempt at this was with neural networks
was done here already a nice paper by title. And our aim is now to unfold this
on the full face. So, to do the multi dimensional version of this, for this, we
cannot use a symbol again, because they will not be any connection between the
input and the discriminator, which is very important to include a notion of
statistical or probabilistic behavior here, and also offer the to get a notion
of distance between before and after the detector. So, basically the idea is if I
have a very high energetic laptop, it should also probably be in some kind of
high energetic region, also detector and vice versa. Now, here's the setup for this
and you see the detector level information enters both the generator as well as
the discriminator. After what?
And now how can we test if our unfolding was successful, so we train it on the full
data set. But we already know that again, it's very good at learning the full
structure of the data set and mapping it to new distribution. So after doing this
In the afterwards, slice our data set for the testing, for instance, EA, Grecian,
etc, that we slice it into PT of the leading and second leading and taking
roughly 38% of the data, and then we just unfold this part and see if it actually
matches the corresponding partner level distribution. And you see again here in
blue as the data and dotted is the data and the solid lines are generated, and for
the distribution, and you see this works very nicely. Now, very interesting
question that might arise us, okay. We know unfolding in some way prior
dependent. What happens now if we put any test data that just never was in the
training data. For this, we generated new events, namely w prime events, and
inserted this into our test data set afterwards. And we know of course, a truth
distribution which is given here in red, and the Standard Model distribution as I
given green here, which is what we train on unfolding. This obtains a blue
distribution down here. And even though Okay, the width is somewhat broader,
obviously than than the red distribution, the truth, it very nicely finds the exact
placement often very often. So w prime was this already come to the conclusion. So
we've seen that with scans, we can actually learn underlying distributions
from events. And if we have any kind of special features that we want to learn, we
can do this with the nmt without having to insert first hand information. This is
very important when we potentially don't know what the width of the particle
actually is. So we can just tell it to look at certain combinations and learn
from the data. In particular for GaNS, often people struggle with stabilizing
also training but it says a lot of solutions that one can try out, read
infinite difference in specifying gaps. And so with the list beforehand was a lot
of nice papers where you can duration. Having learned this distribution, we can
go from more complex models. For instance, we cannot successfully sample
have a successful
implementation of a sample based production which could be used for
background detection or linear subtraction and event generation. Finally, we can
unfold high dimensional detector distributions with again, by employing
fully conditional again, because this has a notion of locality. And what's next?
With this, I
come to the end. And I'm curious for questions. Thank you very much.
Okay, great.
I guess I should encourage people also to, if they're going if they come up with a
question during their, during the talk, they can raise their hands during the talk
as well.
But yeah, are there any questions from the room?
Um, I was kind of curious about one. So I think the last application that you
mentioned here, you were able to sort of discover a new physics signal that you
injected having already trained this using standard, like known physics. Yes. Um, I
guess one question here, which is, it's probably a difficult one to answer is,
if you know that you're known physics is not modeled correctly.
And then you try to use this technique. How are you distinguishing between Miss
modeling and something that might be near physics?
Or the question? Yes. It's obviously very difficult. And at this stage, I wouldn't.
I wouldn't say that we can answer this properly already. We were actually rather
surprised that this worked as good as it did. But of course, the problem always
accrues the moment we have new physics in our data set. And we are trying to model
it with standard model physics. So I think this is just off as a possibility to see
how good we can go with unfolding. We know that the unfolding process is prior
dependence, or whatever we do, it depends in a way on the data set we trained on
because this is what the network is trained to map on. So I think the most
important is to understand how prior dependencies like how much goes into it,
and which parts are more independent.
For this, we just have to look more disk kind of distributions and try to
understand what's next release?
Yeah, I guess it kind of goes in the direction of if you can parameterize
certain types of flexibility into the model, but I think that's so much deeper
question.
Yes, at this point, I mean, you could for instance, train This with w prime data
making it conditional on the math. But we wanted to start with a model and see okay
what what happens if we now put something inside that it has just never see what
what is the outcome