GitLab

* add cuda test for loss_binary_log_per_pixel and some needed refactoring

* add cuda test for loss_multiclass_log_per_pixel

* forgot to add cpu version in loss

* remove a line I added by mistake

* fix typos

* declare label_to_ignore as static

* use tensor_index function instead of index method

* test cuda and cpu gradients values

* use DLIB_TEST instead of DLIB_CASSERT

* add cuda implementation for loss_multiclass_log_per_pixel_weighted

* add test for cuda and cpu implementations

* fix comment

* move weighted label to its own file

* Update path in doc
Co-authored-by: Davis E. King <davis685@gmail.com>

* add loss_multilabel_log

* add alias template for loss_multilabel_log

* add missing assert

* increment truth iterator

* rename loss to loss_multibinary_log

* rename loss to loss_multibinary_log

* explicitly capture dims in lambda

* wip: attempt to use cuda for loss mse channel

* wip: maybe this is a step in the right direction

* Try to fix dereferencing the truth data (#1)

* Try to fix dereferencing the truth data

* Fix memory layout

* fix loss scaling and update tests

* rename temp1 to temp

* readd lambda captures for output_width and output_height

clangd was complaining about this, and suggested me to remove them
in the first, place:

```
Lambda capture 'output_height' is not required to be captured for this use (fix available)
Lambda capture 'output_width' is not required to be captured for this use (fix available)
```

* add a weighted_loss typedef to loss_multiclass_log_weighted_ for consistency

* update docs for weighted losses

* refactor multi channel loss and add cpu-cuda tests

* make operator() const

* make error relative to the loss value
Co-authored-by: Juha Reunanen <juha.reunanen@tomaattinen.com>

* add loss_multiclass_log_weighted

* fix class name in loss_abstract

* add loss_multiclass_log_weighted test

* rename test function to match class name

* fix typo

* reuse the weighted label struct across weighted losses

* do not break compatibility with loss_multiclass_log_per_pixel_weighted

* actually test the loss and fix docs

* fix build with gcc 9

* Add new loss layer for binary loss per pixel

* Add instance segmentation example - first version of training code

* Add MMOD options; get rid of the cache approach, and instead load all MMOD rects upfront

* Improve console output

* Set filter count

* Minor tweaking

* Inference - first version, at least compiles!

* Ignore overlapped boxes

* Ignore even small instances

* Set overlaps_ignore

* Add TODO remarks

* Revert "Set overlaps_ignore"

This reverts commit 65adeff1f89af62b10c691e7aa86c04fc358d03e.

* Set result size

* Set label image size

* Take ignore-color into account

* Fix the cropping rect's aspect ratio; also slightly expand the rect

* Draw the largest findings last

* Improve masking of the current instance

* Add some perturbation to the inputs

* Simplify ground-truth reading; fix random cropping

* Read even class labels

* Tweak default minibatch size

* Learn only one class

* Really train only instances of the selected class

* Remove outdated TODO remark

* Automatically skip images with no detections

* Print to console what was found

* Fix class index problem

* Fix indentation

* Allow to choose multiple classes

* Draw rect in the color of the corresponding class

* Write detector window classes to ostream; also group detection windows by class (when ostreaming)

* Train a separate instance segmentation network for each classlabel

* Use separate synchronization file for each seg net of each class

* Allow more overlap

* Fix sorting criterion

* Fix interpolating the predicted mask

* Improve bilinear interpolation: if output type is an integer, round instead of truncating

* Add helpful comments

* Ignore large aspect ratios; refactor the code; tweak some network parameters

* Simplify the segmentation network structure; make the object detection network more complex in turn

* Problem: CUDA errors not reported properly to console
Solution: stop and join data loader threads even in case of exceptions

* Minor parameters tweaking

* Loss may have increased, even if prob_loss_increasing_thresh > prob_loss_increasing_thresh_max_value

* Add previous_loss_values_dump_amount to previous_loss_values.size() when deciding if loss has been increasing

* Improve behaviour when loss actually increased after disk sync

* Revert some of the earlier change

* Disregard dumped loss values only when deciding if learning rate should be shrunk, but *not* when deciding if loss has been going up since last disk sync

* Revert "Revert some of the earlier change"

This reverts commit 6c852124efe6473a5c962de0091709129d6fcde3.

* Keep enough previous loss values, until the disk sync

* Fix maintaining the dumped (now "effectively disregarded") loss values count

* Detect cats instead of aeroplanes

* Add helpful logging

* Clarify the intention and the code

* Review fixes

* Add operator== for the other pixel types as well; remove the inline

* If available, use constexpr if

* Revert "If available, use constexpr if"

This reverts commit 503d4dd3355ff8ad613116e3ffcc0fa664674f69.

* Simplify code as per review comments

* Keep estimating steps_without_progress, even if steps_since_last_learning_rate_shrink < iter_without_progress_thresh

* Clarify console output

* Revert "Keep estimating steps_without_progress, even if steps_since_last_learning_rate_shrink < iter_without_progress_thresh"

This reverts commit 9191ebc7762d17d81cdfc334a80ca9a667365740.

* To keep the changes to a bare minimum, revert the steps_since_last_learning_rate_shrink change after all (at least for now)

* Even empty out some of the previous test loss values

* Minor review fixes

* Can't use C++14 features here

* Do not use the struct name as a variable name

* Add test case that makes MMOD loss go negative with certain ignore-rect configuration

* Disregard duplicate truth boxes

* Minor optimization

* Remove possibly outdated comment

* Clarify the detection count test criterion a little

* Review fix

* Review fixes:
- for perf reasons, keep only the first rect for each truth idx
- fix warning message grammar

* Clear truth_idxs between samples

* Move truth_idxs inside loop body after all

* Push to truth_idxs even when the box can't be detected; improve formatting

add loss_mean_squared_per_channel_and_pixel

fixed check for excessive detections in loss_mmod_

Ran into the problem where dets.size() was equal to max_num_initial_dets which then throws a subscript out of range error when accesing: dets[max_num_initial_dets].detection_confidence.  This fixes that issue.

* Added weighted labels to loss_binary_log

* Added weighted labels to loss_binary_log

* Clarified docs.

* clarified docs

* Problem: log loss may become infinite, if g[idx] goes zero
Solution: limit the input of the log function to 1e-6 (or more)

* Parameterize the safe_log epsilon limit, and make the default value 1e-10

* Add capability to train scale-variant MMOD models

* Review fixes: change bool scale_invariant to strongly typed enum, etc

* Add serialization and deserialization of assumed_input_layer_type

* Fix code formatting

* Rename things as per review feedback

* Review fix: move enum use_image_pyramid outside mmod_options

* Continue execution with net, if deserialization of shape predictor fails

* Revert "Continue execution with net, if deserialization of shape predictor fails"

This reverts commit 8ea4482c043b5b98b97ed5b78bfc6916a1e2a453.

0.5*MSE.  The only thing this effects is the logging messages that print during
training, which were confusing since the reported loss was half the size you
would expect.

early iterations since the model might produce a huge number of false alarms
while the detector is still bad.  Processing all these detections can cause it
to run slowly until the model is good enough to avoid really excessive amounts
of false alarms.  This change puts more of a limit on the number of false
alarms processed during those early iterations and avoids the slowdown.

doesn't effect normal use, but it's still wrong and this change fixes it.

sizes.  It would pick a bad size in some cases.

the label in the way you would expect.  In particular, loss_mmod_ is now a
multi-class loss and therefore capable of learning a detector that can output
detections with different labels.

checks if the user is giving truth boxes that can't be detected because the
non-max suppression settings would prevent them from being output at the same
time.  If this happens then we print a warning message and set one of the
offending boxes to "ignore".