> We propose to instead learn the hyperparameters themselves by gradient descent, and furthermore to learn the
hyper-hyperparameters by gradient descent as well, and so on ad infinitum.
Made me laugh. Can't believe this hasn't been done yet. Maybe I should stop looking at ML research upon a pedestal (regardless, OpenAI's PPO and TRPO papers were amazing, not to mention their Learning with Dexterity one)
No, it's been done. For example, "Gradient-based Hyperparameter Optimization through Reversible Learning" https://arxiv.org/abs/1502.03492 , Maclaurin et al 2015 (one of their cites). The idea is pretty obvious: of course you'd like to learn the hyperparameters like they were any other parameter. But that's easier said than done.
The problem is that, well, to backpropagate through a hyperparameter, you would need to, say, track how it affects every iteration throughout the entire training run, rather than simply tracking one parameter through a single iteration on a single datapoint. And it's difficult enough to do gradient descent on a single hyperparameter, so it hardly helps to start talking about doing entire stacks! If you can't really do one, doing ad infinitum probably isn't going to work well either.
If you look at their experiment, they're doing a 1 hidden-layer FC NN on MNIST. (Honestly, I'm a little surprised that stacking hyperparams works even on that small a problem.)
Reading the paper, instead of computing the gradient across the training run they compute the gradient for a hyper parameter after each batch and update the hyper parameter then. That keeps the computational cost pretty light. Stacking gradient descent 50 times on itself only costs about double normal gradient descent. That's specific to their experiment, but when done on bigger models the added cost for computing the hyperparameter derivatives should become a smaller fraction.
I'm surprised by the lack of any bigger experiments (imagenet would be nice, but even cifar10 would help) given how computationally light this was. Also surprised that an 11ish author stanford paper did their experiments on 1 cpu.
This is just Bayesian modeling. Move the parameters into the model, push the hyperparameters into a prior. Move the hyperparameters into the model, push the hyperhyperparameters into a hyperprior, etc.
Choosing hyperparameters from minor tuning or literature review or domain expertise or whatever is just a form of creating a prior.
It's been thought of, but the standard view was that it was way too expensive to perform when humans are pretty good at fiddling with them to get good enough results after a little bit of practice.
Ah, the GDGS (gradient descent by grad student) approach where you estimate the gradient direction using an educated guess, tweak the system towards that, run an experiment, write down the results and repeat until you're happy (or run out of time).
I suspect that's because higher LR leads to better exploration of the opt. surface, i.e. it works as an implicit regularizer. The ideal solution would be to develop better regularizers to go with the better optimizers, instead of relying on the noise in the worse optimizer for implicit regularization.
I completely agree, we shouldn't be depending on our optimizers do some approximate Bayesian inference- an optimizer should optimize only.
However, I think it's a different effect- even purely in terms of optimizing the training loss, on a quadratic (with noisy gradients), the short-horizon bias effect exists.
Regarding 2: I saw a talk yesterday by Alex Hernández-García in which he showed that dropout and weight decay can be replaced with data augmentation in many cases. The relevant paper by him and König is https://arxiv.org/abs/1806.03852v2
So we could see Adam optimization with hyper-parameter tuning by Adam? But IIRC this is never guaranteed to always find the global minima/maxima, so why would it in this scenario? Or is this just finding a way to let your optimizer self optimize?
If I understand what they are looking at, they are looking at problems that are simple in the sense of having no local optima, but complex in the sense of having very high dimension.
ie. It's not a problem for the class of problems they are optimizing.
I've been out of that domain for awhile... but when I did a lot of optimizing / fitting in a high dimensional space with a function that had lots of local optima... I found the downhill simplex method with simulated annealing was most effective / robust.
There is a problem with our intuition about gradient descent that blinds us, a little bit.
For a local minimum to exist, that means that the function we're looking at has to have a local minimum when sliced in every dimension.
In our intuition, this is relatively common, because we usually imagine 2d manifolds embedded in 3-space (ie, "hill climbing"). And when there's only 2 dimensions, it's not hard to have a "bowl", where the function curves upward in both dimensions.
In fact, a "saddle point", where one of the dimensions curves up and the other curves down, feels "unlikely" to most peoples' intuition, because we don't often run into physical objects with that shape.
But, saddle points in higher dimensions "should be" far more common than local minima. You only need one dimension to curve downward to have a "hole" where the "water" can escape and continue flowing downhill.
Gradient descent easily gets stuck in 2 dimensions, and so we are often surprised by how well it performs in higher dimensions.
Yes, saddle points are far more common than local minima in high dimension. Unfortunately they're really good at slowing down naive gradient descent...
Not much of a response. Care to expand here? This is a well-understood principle in the existing body of research on convergence in high dimensional spaces.
I'm sorry that I can't find the reference for this right now, but I read a paper a while back showing that (particularly stochastic) gradient descent usually finds good solutions (and that these solutions are very close to each other), although not absolute extrema, to highly dimensional neural networks. Whats more, you usually want to avoid finding absolute extrema solutions because they often suffer from overfitting behaviors.
https://arxiv.org/abs/1606.04474