Thank you very much for inviting me and I'm going to talk not so much about COVID but
more about doing artificial intelligence models for biomedical research or machine learning
as we call them actually.
First of all, let me introduce myself, I'm a professor for drug mathematics at the University
of Sarland, I hold the Master Mathematics and Peace Dean Molecular Biology and according
to German law, I'm allowed to teach bioinformatics.
I also have a semi-active blue sky account as it became the plot platform of choice these days
in the community.
First of all, let me tell you a little bit about where I am.
Sarland is a little state in Germany on the French border and geographically it's actually
a closer to Brussels or to Paris than to Berlin.
In Sarland we have nice nature, we have nice food, we have some not-so-nice food and we have
the hand-wants Institute for Pharmaceutical Research and the University with the Center for
Bioinformatics which are my home institutions.
So I will take one minute to make some advertising for the Center for Bioinformatics, we have
the full study program in Bioinformatics in Bethlehem, so if you have someone who wants
to study Bioinformatics, consider sending them there, the Bachelor is taught in German, but
Master is fully in English and we have 90% of international students there.
We have five full professorships and two junior professor groups and the spread of topics
is very broad from everything from algorithms to clinical bioinformatics and to a driven
drug discovery.
Enough of that, let's talk about machine learning and biomedical research.
I stole this figure from a paper, it actually reports models that are used in medicinal
imaging, but it doesn't matter because the trend is the same in every field.
Approximately from mid-2010s, the number of papers reporting some machine learning or AI
model in some biomedical domain exploded and there is no stopping to it, so I think it's growing
and growing uncontrollably.
But as we know AI models are black box models and probably some people have seen this picture
before, razor hand, yes of course.
So you know what the trick is, we don't really know how model learns what it learns.
So here we have a classifier for images, huskies, dogs or wolves and the classifier seems
to be very good on the one error, but if you look closer at what the model actually uses,
what information it uses to make predictions, you figure that dog is not in the image at all
and what you actually trained is a perfect snow detector. The trick is yes, dogs are usually photographed
on some neutral background wolves are predominantly photographed in winter on the snow background
and yeah that's how it worked. It's all very funny, until we actually enter some biomedical
domain. And here COVID comes into play when the epidemic started, of course, the number of
machinery in tools to classify CT scans into COVID and non-COVID also exploded and after
some time into the pandemic, some people actually went into trouble of analyzing some of these
tools and what they discovered is that the models just like the huskies wolf classifier didn't
really learn on relevant information. What it learned was some auxiliary in this case for example labels
on the radiograms. The reason for this was that all COVID samples, so images of COVID
CT scans came from one hospital and the images for healthy, long scans came from a different hospital
which were labeling their scans differently. So basically what the model learned was to detect
these labels and unless you really do analysis, in this case it was some feature important
analysis you never know. And yes what they showed here very nicely if you swap labels
the prediction swaps. So the model didn't learn anything. So if we are thinking about how our models work
in general terms, we as developers have control over the blue area in this image but we don't
have much control about the red area where your model is going to be used, where it will be applied
on some real data. So what we have during the development cycle we have trained validation
and test data and in the deployment time we have some new data inference data. So what does
information leakage have to do with this? Let's first define what is information leakage. By definition
it is use of information during model training process that would not be available during inference.
You can think of your training data as a table. You have features in columns and you have samples
in rows and you can have information leakage across both directions. Feature leakage is very easy.
You have a feature that is highly correlated with the variable that you're trying to predict. For
example you are trying to predict yearly salary of some employees and you have a column that
reports their monthly salary. Very useful but not really what you want to your model to learn.
Another type of leakage is across samples where for example you have samples in the training
set and in the test set that are just identical. You have not cleaned your data properly. You
have duplicates and accidentally they end up in training data and test data.
Which can be theoretical taking care of relatively easily. But there are other more subtle ways
we how this information from the training data can leak into your test data. For example
yeah, parametric visualization, non-identical distribution data when your positive and negative
samples are differently distributed. So what you can try to do since you don't have control over
report. You don't know what will happen during inference time. You can a little bit pay attention
to your training process to try to stop leakage from happening. We published a paper recently where
we have formulated seven questions that every prudent researcher should ask themselves
when training AI models. But I'm going to focus on two of them that are related to a specific type
of data leakage sample similarity. So let's talk about splitting the data while you're training your
model. You have a data set and you need to partition it into a typically into training
validation and test set. Here they are shown in different colors and this is one way of doing this
and this is a different way of doing this. And you see that they are different but you probably
don't know what for. So the idea is that if your partitioning puts the training and test data apart
this makes life of the model kind of hard. You train on one space of data and you're testing
on a different space of the data space and in this way you challenge your model. And hopefully
when it comes to inference the data that will be used for inference will most likely it will
come from a different part of the data space. Hopefully once you challenge your model with
this part of the data space it will also do well on a different part of the data space. That's the
hope. But what you can do without really knowing the inference data. So if we
consider typical biological data sets they can be one-dimensional suppose you have a list of
proteins that you want to predict something for or they can be two-dimensional if you have
protein targets and drugs that can interact with them and then you can split these data sets
from easiest splits to hardest splits. So for one-dimensional data set what you can do to make life
of the model harder is to look for similarities in your data and then try to put clusters of similar
data points into one split. So either training or validation or test split. For two-dimensional
data it's harder because you have similarities across two dimensions. So first thing that you
can do to make life of the model a little bit more difficult than just random misleading the
metrics you can split it by column or by row. In this way some drugs for example will be never seen
by the model during training and then in tests you will see how well it performs on unseen drugs
or similar to some targets and then you can try to account also for similarities and create a split
that will first of all put all similar drugs and targets together. In this way you will inevitably
lose some data because some points you will not be able to classify. So what we are presenting
a tool for controlling data leakage that instead of making models to memory allowing models to
memorize their data are to make models generalized better on unseen data. So this tool takes your
data set and if it is a normal molecules molecular data set it automatically creates all possible
splits of different targets. So now if we consider again this drug target interaction example where
you have some molecules and some drugs and you want to predict whether they bind to each other
we can create all these different splits and here are some metrics that I'm not going to go
into very much detail but what our tool can do it can measure the amount of leakage based on
the similarity between the data points and what we have trained several standards machine learning
models on these splits and what we can show is that the less leakage between the splits the
worse performance of the models and also we could show that our tool makes a life of models harder
than any other tool that was available on the market at the time of publication. So yeah to conclude
that data leakage is a problem in predictive models and it should be addressed before you even start
training your model. It should be addressed when you are looking at your data set and
what is also a bit counterintuitive is that better models that can be can better generalize
to unsend data often perform worse at least in the reported benchmarks. Of course in an independent
benchmark the truth will come out because you would probably challenge models with some hard splits
but if you read papers you often see the benchmarks on random splits and this is a bit
disappointing to people who try to develop really good models. So right that's all from my side
for today thank you very much
Thank you so much for listening to this. The question was is there a way to visualize
yes you can is there a way to visualize information leakage we can't think of a way to visualize it
but we can measure it and we have developed a formula that measures similarity between all data
points in the data sets and between the data sets and in a way this is the objective function
of the optimization problem that we are solving in our tool.
So the question was how many GPUs we need to train the models.
The point of the tool that I was talking about and all the analysis that I was talking about
it was not training the models it was actually before it was data analysis and splitting the
data is also a hard task. So what we did we implemented an optimization problem with
solving and optimization problem using integer linear programming. Now we are doing this with
standard solvers so for bigger data set it's not an issue of time time is usually in hours
but it's often an issue of memory. So one of the next questions that we need to solve is to develop
especially a solver for this.
Thank you very much Olga.