Gradient-based hyperparameter optimization and meta-learning package based on TensorFlow
This is the new package that implements the algorithms presented in the paper
Forward and Reverse Gradient-Based Hyperparameter Optimization. For the older package see RFHO. FAR-HO features simplified interfaces, additional
capabilities and a tighter integration with tensorflow
.
ReverseHG
), generalization of algorithms presented in Domke [2012] and MacLaurin et Al. [2015] (without reversable dynamics and "reversable dtype"); including the "truncated reverse version" ReverseHG.truncated
, see Truncated Back-propagation for Bilevel Optimization
ForwardHG
)ImplicitHG
), which can be used to implement HOAG algorithm [Pedregosa, 2016]These algorithms algorithms compute, with different procedures, the (approximate) gradient of an outer objective such as a validation error with respect to the outer variables (e.g. hyperparameters). We call the gradient of the outer objective hypergradient. The "online" algorithms may perform several updates of the outer variables before reaching the final iteration, and are in general are much faster then their "batch" version. This procedure is linked to warm restart for solving the inner optimizaiton problem, but the hypergradient is, in general, biased.
IMPORTANT NOTE: This is not a plug-and-play hyperparameter optimizaiton package, but rather a research package that collects some useful methods that aim at simplifying the creation of experiments in gradient-based hyperparameter optimizaiton and related areas. With respect to other HPO packages, here a more specific problem structure is required. Furthermore, depending on the specific problem, the performance may be somewhat sensiteve to algorithmic parameters. As an important example, the inner optimizaion dynamics should not diverge in order for the hypergradients to yield useful informations [ Troubleshooting section coming soon! ].
NOTE II: In Italian FARO means beacon or lighthouse (so... no "H", but the "H" in Italian is silent!) .
These algorithms are useful also in meta-learning where parameters of various meta-learners effectively play the role of outer variables, as explained here in the workshop paper A Bridge Between Hyperparameter Optimization and Learning-to-learn. and Bilevel Programming for Hyperparameter Optimization and Meta-Learning
This package is also described in the workshop paper _ Far-HO: A Bilevel Programming Package for Hyperparameter Optimization and Meta-Learning_ presented at AutoML 2018 at ICML
Clone the repository and run setup script.
git clone git clone https://github.com/lucfra/FAR-HO.git
cd FAR-HO
python setup.py install
Beside "usual" packages (numpy
), FAR-HO is built upon tensorflow
.
Some examples depend on the package experimet_manager
while automatic dataset download (Omniglot) requires datapackage
.
Please note that required packages will not be installed automatically.
Aim of this package is to implement and develop gradient-based hyperparameter optimization (HO) techniques in TensorFlow, thus making them readily applicable to deep learning systems. This optimization techniques find also natural applications in the field of meta-learning and learning-to-learn. Feel free to issues comments, suggestions and feedbacks! You can email me at [email protected] .
ReverseHG
for the optimization of initial starting point (inital weights), weights of each example and learning rate.ReverseHG
, ForwardHG
and online ForwardHG
(RTHO algorithm) in simple settingsget_hyperparameter
(which could be also variables of your model)tensorflow.Tensor
HyperOptimizer
after choosing an hyper-gradient computation algorithm among
ForwardHG
, ReverseHG
and ImplicitHG
(see next section)HyperOptimizer.minimize
specifying passing the outer and inner objectives,
as well as an optimizer for the outer problem (which can be any optimizer form tensorflow
)
and an optimizer for the inner problem (which must be an optimizer contained in this package;
at the moment gradient descent, gradient descent with momentum and Adam algorithms are available,
but it should be quite straightforward to implement other optimizers, email me if you're interested!)HyperOptimizer.run(T, ...)
function inside a tensorflow.Session
,
optimize inner variables (parameters) and perform a step of optimization of outer variables (hyperparameter).Two scripts in the folder autoMLDemos showcase typical usage of this package
import far_ho as far
import tensorflow as tf
model = create_model(...)
lambda1 = far.get_hyperparameter('lambda1', ...)
lambda1 = far.get_hyperparameter('lambda2', ...)
io, oo = create_objective(...)
inner_problem_optimizer = far.GradientDescentOptimizer(lr=far.get_hyperparameter('lr', 0.1))
outer_problem_optimizer = tf.train.AdamOptimizer()
farho = far.HyperOptimizer()
ho_step = farho.minimize(oo, outer_problem_optimizer,
io, inner_problem_optimizer)
T = 100
with tf.Session().as_default():
for _ in range(100):
ho_step(T)
^{1} This is gradient-based optimization and for the computation
of the hyper-gradients second order derivatives of the training error show up
(even tough no Hessian matrix is explicitly computed at any time);
therefore, all the ops used
in the model should have a second order derivative registered in tensorflow
.
^{2} For the hyper-gradients to make sense, hyperparameters should be
real-valued. Moreover, while ReverseHG
should handle generic r-rank tensor
hyperparameters, ForwardHG
requires scalars hyperparameters. Use the keyword argument scalar=True
in get_hyperparameter
for obtaining a scalr splitting of a general tensor.
Forward and Reverse-HG compute the same hypergradient, so the choice is a matter of time versus memory!
The online versions of the algorithms can dramatically speed-up the optimization.
The objective is to minimize some validation function E with respect to
a vector of hyperparameters lambda. The validation error depends on the model output and thus
on the model parameters w.
w should be a minimizer of the training error and the hyperparameter optimization
problem can be naturally formulated as a bilevel optimization problem.
Since these problems are rather hard to tackle, we
explicitly take into account the learning dynamics used to obtain the model
parameters (e.g. you can think about stochastic gradient descent with momentum),
and we formulate
HO as a constrained optimization problem. See the paper for details.
far.HyperOptimizer.minimize
, create variables designed as hyperparameters with far.get_hyperparameter
, no more need to vectorize the model weights, far.optimizers
only need to specify the update as a list of pairs (v, v_{k+1})far.GraphKeys
), use out-of-the-box models (no need to vectorize the model), use any TensorFlow optimizer for the outer objective (validation error)If you use this package please cite
@InProceedings{franceschi2017forward,
title = {Forward and Reverse Gradient-Based Hyperparameter Optimization},
author = {Luca Franceschi and Michele Donini and Paolo Frasconi and Massimiliano Pontil},
booktitle = {Proceedings of the 34th International Conference on Machine Learning},
pages = {1165--1173},
year = {2017},
volume = {70},
series = {Proceedings of Machine Learning Research},
publisher = {PMLR},
pdf = {http://proceedings.mlr.press/v70/franceschi17a/franceschi17a.pdf},
}
@InProceedings{franceschi2018bilevel,
title = {Bilevel Programming for Hyperparameter Optimization and Meta-learning},
author = {Luca Franceschi and Paolo Frasconi and Saverio Salzo and Riccardo Grazzi and Massimiliano Pontil},
booktitle = {Proceedings of the 35th International Conference on Machine Learning (ICML 2018},
year = {2018},
series = {Proceedings of Machine Learning Research},
publisher = {PMLR},
pdf = {http://proceedings.mlr.press/v80/franceschi18a/franceschi18a.pdf},
}
@article{franceschi2017bridge,
title={A Bridge Between Hyperparameter Optimization and Larning-to-learn},
author={Franceschi, Luca and Frasconi, Paolo and Donini, Michele and Pontil, Massimiliano},
journal={arXiv preprint arXiv:1712.06283},
year={2017}
}
This package has been used for the project LDS-GNN: the code for the ICML 2019 paper "Learning Discrete Structures for Graph Neural Networks".