EarlyStopping.hpp

#pragma once
 
#include <cmath>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "Callback.hpp"
#include "utils/Functions.hpp"
 
namespace NeuralNet {
class EarlyStopping : public Callback {
 public:
  EarlyStopping(const std::string& metric = "LOSS", double minDelta = 0,
                int patience = 0) {
    checkMetric(metric, metrics);
    this->metric = metric;
    this->minDelta = minDelta;
    this->patience = patience;
  };
 
  void onEpochBegin(Model& model) override {};
 
  void onEpochEnd(Model& model) override {
    std::unordered_map<std::string, Logs> logs = getLogs(model);
    auto it = logs.find(metric);
 
    if (it == logs.end()) throw std::invalid_argument("Metric not found");
 
    double currentMetric = std::get<double>(it->second);
 
    if (previousMetric == 0) {
      previousMetric = currentMetric;
      return;
    }
 
    double absCurrentDelta = std::abs(currentMetric - previousMetric);
 
    patience = absCurrentDelta <= minDelta ? patience - 1 : patience;
    previousMetric = currentMetric;
 
    if (patience < 0) throw std::runtime_error("Early stopping");
  };
 
  void onTrainBegin(Model& model) override {};
  void onTrainEnd(Model& model) override {};
  void onBatchBegin(Model& model) override {};
  void onBatchEnd(Model& model) override {};
 
  ~EarlyStopping() override = default;
 
 private:
  std::string metric;
  double minDelta, previousMetric = 0;
  int patience;
  std::vector<std::string> metrics = {
      "LOSS", "ACCURACY"};  // Available metrics for this Callback
};
 
}  // namespace NeuralNet