Nuances of GP

Loading...

En provenance du cours de National Research University Higher School of Economics

Bayesian Methods for Machine Learning

224 notes

National Research University Higher School of Economics

Bayesian Methods for Machine Learning

224 notes

Cours 3 sur 7 dans Specialization Advanced Machine Learning

Bayesian methods are used in lots of fields: from game development to drug discovery. They give superpowers to many machine learning algorithms: handling missing data, extracting much more information from small datasets. Bayesian methods also allow us to estimate uncertainty in predictions, which is a really desirable feature for fields like medicine. When Bayesian methods are applied to deep learning, it turns out that they allow you to compress your models 100 folds, and automatically tune hyperparametrs, saving your time and money. In six weeks we will discuss the basics of Bayesian methods: from how to define a probabilistic model to how to make predictions from it. We will see how one can fully automate this workflow and how to speed it up using some advanced techniques. We will also see applications of Bayesian methods to deep learning and how to generate new images with it. We will see how new drugs that cure severe diseases be found with Bayesian methods.

À partir de la leçon

Gaussian processes & Bayesian optimization

Welcome to the final week of our course! This time we will see nonparametric Bayesian methods. Specifically, we will learn about Gaussian processes and their application to Bayesian optimization that allows one to perform optimization for scenarios in which each function evaluation is very expensive: oil probe, drug discovery and neural network architecture tuning.

Nonparametric methods6:01

Gaussian processes8:04

GP for machine learning5:34

Derivation of main formula11:19

Nuances of GP12:11

Bayesian optimization10:15

Applications of Bayesian optimization5:04

Rencontrer les enseignants

Daniil Polykovskiy
Researcher
HSE Faculty of Computer Science
Alexander Novikov
Researcher
HSE Faculty of Computer Science

[MUSIC]

In this video, we'll see different tricks that are very useful for

training Gaussian process.

And the first one is, what you should do when you see noisy observations?

As youremember the mean would go exactly through the data points, and

also the covariance, and actually variance would be zero at the data points.

And if you fit the Gaussian process to a noisy signal

like this you will get this quickly changing function.

But actually you can see that there is something like a parabola here,

and also some noise component.

So let's modify our model in a way that it will have some

notion of the noise in the data.

The simplest way to do this is to add the independent Gaussian

noise to all random variables.

So have some new random variable f hat.

It would be equal to the original random process f of x plus some new

independent Gaussian noise.

This means that, we'll independently sample it for

each point of our space rd, that is different axis.

We'll say that the mean of the noise is 0, and the variance would be s squared.

In this case, the mean of the random process was to be 0.

Since we have the sum of two means,

the mean of f of x and epsilon, and those sum up to 0.

And the covariance would change in the following way.

The new covariance would be the old covariance K of xi minus xj,

plus s squared, the variance of the noise.

As an indicator that the points xi and xj are the same.

This happened since there's no covariance between

the noise samples in different positions.

And if we fit the model using this covariance matrix using this kernel,

we will get the following result.

So as you can see, we don't have the 0 variance data points anymore.

And also the mean function became a bit smoother.

However, this still isn't the best we can have.

We can change the parameters of the kernel a bit, and

find the optimal values for them, in this special case.

If for example we have the length scale equal to 0.01,

the covariance will drop really quickly to 0 as we move away from the points.

And so the prediction would look like this.

And this is like the complete garbage.

If we take the length scale to be equal to 10, then it would be too high.

And the prediction will change through really slowly.

And it would be 0 almost however and

the variance would be like two the basic

the variance of the prior process.

So here we select the l to be 2, somewhere in the middle, and

we'll have the process like this.

It actually has some drawbacks, since as you can see, at the position -3 and

3, the process could create and starts to reverse its prediction to 0.

So maybe we could change some other parameters a bit better,

like just letting sigma squared or x squared.

And maybe we'll be able to feed Gaussian processing better and

actually it turns out that we can so this automatically.

We can have all our parameters for

the Gaussian kernel will have sigma squared parameter,

l, and s squared, so three parameters.

We're going to tune them by maximizing the likelihood.

So we take our data points, f of x1, f of x2 sub 1, f of xn and

maximize the probability of this data process to observe given the parameters.

Since everything is Gaussian for Gaussian process, it will be also Gaussian

with mean 0 and the covariance matrix c as we have seen in the previous video.

If you write down what the probability just fraction is equal to read carefully.

You will see that you can optimize this value using simply the gradient ascent.

And using this you will be able to automatically find the optimal values for

the variance sigma squared, the variance s squared, and the length scale parameter l.

So if you run this procedure, you will get something like this.

So we estimated l to be 2, which actually is true.

However, we spent some time doing it by hand, and

this value was selected automatically.

Also, we were able to estimate that the variance of the process

should be 46.4 and the variance of the noise should be 0.7.

As you can see, also on the boundaries, the prediction became a bit better.

So the process doesn't reverse it's direction very quickly.

Let's see how the fitting of this process works for different data points.

In this case, I tried to fit the Gaussian process simply into a noise.

In this case, the Gaussian process estimated that the s

squared parameter versus the noise should be 0.79.

It really believes that all the data

that I gave him is signal noise.

If I try fit a Gaussian process into a data that I sampled

without noise, it will quickly understand it and

will put the noise variance parameter to almost 0.

So in this case it was like 5 times 10 to the power of -17,

which is actually really close to 0.

If however I have the process that has some signal but it also has noise,

you automatically find that the noise variance should

be somewhere in-between 0 and some larger variables.

In this case it estimated to be 0.13.

All right, now let's see how Gaussian process can be

applied to classification problems.

Previously we saw how they can be use for regression, and for

classification it is a bit harder.

So have two labels, two possible labels plus 1 or -1.

We can use latent process f of x, this will show something like,

how sure we are in predicting this or that label.

And if we fit somehow the latent process f of x, we will be able to do

predictions by passing the latent process through a sigmoid function.

So the probability of the label y given f will be simply

an 1 over 1 + exponent of -yf,

which is the sigmoid function of the products y times f.

So to train this model, you will first have to estimate the latent process.

You'll have to estimate the probability of the latent process

in some arbitrary points given the labels that we already know.

So y1 of x1 for example could be plus 1,

y of x could be -1, and so those are just binary decisions.

So we estimated the latent process and

then we could use it to compute the predictions.

We could do this by marginalizing the general probability of labels and

the latent process.

This would be just the simple intro code,

the probability of the label given the latent process.

At time the probability of the latent process and

it is integrated over all possible latent processes.

So the mess here is a bit complex, so I'll skip it for

now and lets just see how the condition works.

So the first step as I said is estimation of the latent process.

So in this case I have the latent points marked as crosses here,

some have the value plus 1, some have the value -1.

And if we fit the latent processes look like this.

So as you can see, as we go to the area where all points have the labels +1,

the values for the latent process would be positive.

And for

the negative examples the probability of the process will be negative.

And here are our predictions,

I just took the latent process and [INAUDIBLE].

So as you can see it is almost one in the positions where there

are many positive points nearby.

The same happens for the negative examples, and

in the points where the targets change from plus 1 to -1 for example.

The variance would be high and the prediction would be,

won't be so certain in this points.

So for example, somewhere in between -1 and -2,

the value of the prediction would be somewhere around 0.5.

It is almost absolutely not sure about the prediction.

One last thing I want to tell you about, our inducing inputs.

When you train a Gaussian process,

it turns out that it is quite computationally expensive.

If you have end points then computing the prediction will cost you

an order of n cube, since you have to invert the covariance matrix.

There is one simple idea called inducing inputs to speed up the Gaussian process.

What you could is you could replace the dataset with a small

number of data points.

For example, those would be like support points in the SVM.

And then you will try to fit the Gaussian process using only those points.

You will select end points as inducing end points.

The precomputing would cost us m squared times n,

which is quite fast when we select small number of points.

Computing the mean would be an order of m, which is almost instantly.

And predicting the variance at h point will cost us an order of m squared.

You can optimize the position, so in these primes and

the division for them using maximal liked destination.

So let's see how it works.

Here I have 100 points and I fitted the Gaussian process using them.

However here, I selected 10 points informally, and

fit the Gaussian process into them.

And as you can see, the values of the Gaussian process didn't change much.

However, the cost of the prediction is much less,

since we have 10 times less points than we had before.

[MUSIC]

Explorer notre catalogue

Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.

Coursera propose un accès universel à la meilleure formation au monde, en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.

© 2018 Coursera Inc. Tous droits réservés.

Télécharger dans l'App Store

Disponible sur Google Play