GitLab

between.  This should make syncing more robust to sudden hardware failure that
happens right when saving to disk.

early stopping based on observing the loss on held out data.

using train_one_step(), you will get the behavior of automatic disk syncs at
the end of training.

training_label_type instead of a single label_type.  This way, the label
type used for training can be distinct from the type output by the network.
This change breaks backwards compatibility with the previous API.

training thread) out of the object into the calling code rather than
terminating the application.

Add an overload of dnn_trainer::train_one_step that takes a pair of
iterators rather than a std::vector.

progress" estimate.  I also renamed the get/set functions for the shrink amount
to have a consistent name and use the word "factor" instead of "amount".

object as an input.  This allows the solvers to exhibit a more complex behavior
that depends on the specific layer.  It also removes the learning rate from the
solver's parameter set and pushes it entirely into the core training code.
This also removes the need for the separate "step size" which previously was
multiplied with the output of the solvers.

Most of the code is still the same, and in the core and trainer the step_size
variables have just been renamed to learning_rate.  The dnn_trainer's relevant
member functions have also been renamed.

The examples have been updated to reflect these API changes.  I also cleaned up
the resnet definition and added better downsampling.

- Made layer() recurse into repeat objects so that the index given to layer()
  does what you would expect.
- Added an operator<< for network objects that prints the network architecture.

how much the current step size has converged.

automatic step size reduction code a little.

network (which would needlessly double VRAM usage).  I also added a
set_synchronization_file() method so you can tell it to automatically
synchronize itself to disk every so often during training.  This makes resuming
an interrupted training session trivially easy.

the loss isn't being reduced.  Also, there is a stopping condition now based on
how large the current learning rate is.  That is, training stops when the learning
rate gets small enough and it is clear that no progress is being made.

networks.  This revolved mostly around removing really deep template recursions
since that upsets the compiler when you make really deep networks.

train_one_step() member function.  Also improved how the host to device transfers
are overlapped with kernel computation.