sse_loss.hpp

Go to the documentation of this file.

#ifndef MLPACK_METHODS_XGBOOST_LOSS_FUNCTIONS_SSE_LOSS_HPP
#define MLPACK_METHODS_XGBOOST_LOSS_FUNCTIONS_SSE_LOSS_HPP

#include <mlpack/prereqs.hpp>

namespace mlpack {
namespace ensemble {

class SSELoss
{
 public:
  // Default constructor---No regularization.
  SSELoss() : alpha(0), lambda(0) { /* Nothing to do. */}

  SSELoss(const double alpha, const double lambda):
      alpha(alpha), lambda(lambda)
  {
    // Nothing to do.
  }

  template<typename VecType>
  typename VecType::elem_type InitialPrediction(const VecType& values)
  {
    // Sanity check for empty vector.
    if (values.n_elem == 0)
      return 0;

    return arma::accu(values) / (typename VecType::elem_type) values.n_elem;
  }

  template<typename MatType, typename WeightVecType>
  double OutputLeafValue(const MatType& /* input */,
                         const WeightVecType& /* weights */)
  {
    return -ApplyL1(arma::accu(gradients)) / (arma::accu(hessians) + lambda);
  }

  double Evaluate(const size_t begin, const size_t end)
  {
    return std::pow(ApplyL1(arma::accu(gradients.subvec(begin, end))), 2) /
        (arma::accu(hessians.subvec(begin, end)) + lambda);
  }

  template<bool UseWeights, typename MatType, typename WeightVecType>
  double Evaluate(const MatType& input, const WeightVecType& /* weights */)
  {
    // Calculate gradients and hessians.
    gradients = (input.row(1) - input.row(0)).t();
    hessians = arma::vec(input.n_cols, arma::fill::ones);

    return std::pow(ApplyL1(arma::accu(gradients)), 2) /
        (arma::accu(hessians) + lambda);
  }
 private:
  const double lambda;
  const double alpha;
  arma::vec gradients;
  arma::vec hessians;

  double ApplyL1(const double sumGradients)
  {
    if (sumGradients > alpha)
    {
      return sumGradients - alpha;
    }
    else if (sumGradients < - alpha)
    {
      return sumGradients + alpha;
    }
    
    return 0;
  }
};

} // namespace ensemble
} // namespace mlpack

#endif