OptimizationTools.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_OPTIMIZATIONTOOLS_H
#define BPP_PHYL_OPTIMIZATIONTOOLS_H
 
#include <Bpp/App/ApplicationTools.h>
#include <Bpp/Io/OutputStream.h>
#include <Bpp/Numeric/Function/SimpleNewtonMultiDimensions.h>
#include <Bpp/Phyl/Likelihood/PhyloLikelihoods/SingleProcessPhyloLikelihood.h>
 
#include "Distance/DistanceEstimation.h"
#include "Distance/AbstractAgglomerativeDistanceMethod.h"
 
 
namespace bpp
{
class NaNListener : public OptimizationListener
{
private:
  OptimizerInterface* optimizer_;
  FunctionInterface* function_;
 
public:
  NaNListener(OptimizerInterface* optimizer, FunctionInterface* function) : optimizer_(optimizer), function_(function) {}
 
  NaNListener(const NaNListener& lr) :
    optimizer_(lr.optimizer_),
    function_(lr.function_)
  {}
 
  NaNListener& operator=(const NaNListener& lr)
  {
    optimizer_ = lr.optimizer_;
    function_  = lr.function_;
    return *this;
  }
 
public:
  void optimizationInitializationPerformed(const OptimizationEvent& event) {}
  void optimizationStepPerformed(const OptimizationEvent& event)
  {
    if (std::isnan(optimizer_->getFunction()->getValue()))
    {
      cerr << "Oups... something abnormal happened!" << endl;
      function_->getParameters().printParameters(cerr);
      throw Exception("Optimization failed because likelihood function returned NaN.");
    }
  }
  bool listenerModifiesParameters () const { return false; }
};
 
 
class OptimizationTools
{
public:
  OptimizationTools();
  virtual ~OptimizationTools();
 
public:
  static std::string OPTIMIZATION_GRADIENT;
  static std::string OPTIMIZATION_NEWTON;
  static std::string OPTIMIZATION_BRENT;
  static std::string OPTIMIZATION_BFGS;
 
  class OptimizationOptions
  {
  public:
    ParameterList parameters;
    std::shared_ptr<OptimizationListener> listener;
    std::string backupFile;
    unsigned int nstep;
    double tolerance; 
    unsigned int nbEvalMax;
    std::shared_ptr<OutputStream> messenger;
    std::shared_ptr<OutputStream> profiler;
    bool reparametrization;
    bool useClock;
    unsigned int verbose;
    std::string optMethodDeriv;
    std::string optMethodModel;
 
 
    OptimizationOptions() :
      parameters(),
      listener(nullptr),
      backupFile("none"),
      nstep(1),
      tolerance(0.000001),
      nbEvalMax(1000000),
      messenger(ApplicationTools::message),
      profiler(ApplicationTools::message),
      reparametrization(false),
      useClock(0),
      verbose(1),
      optMethodDeriv(OPTIMIZATION_NEWTON),
      optMethodModel(OPTIMIZATION_BRENT){};
 
    OptimizationOptions(
      std::shared_ptr<PhyloLikelihoodInterface> lik,
      const std::map<std::string, std::string>& params,
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      bool verb = true,
      int warn = 1);
 
  };
  
  static unsigned int optimizeNumericalParameters(
      std::shared_ptr<PhyloLikelihoodInterface> lik,
      const OptimizationOptions& optopt);
  
  static unsigned int optimizeNumericalParameters2(
      std::shared_ptr<PhyloLikelihoodInterface> lik,
      const OptimizationOptions& optopt);
 
  static unsigned int optimizeNumericalParameters2(
      std::shared_ptr<SingleProcessPhyloLikelihood> lik,
      const OptimizationOptions& optopt);
 
  static std::unique_ptr<DistanceMatrix> estimateDistanceMatrix(
      DistanceEstimation& estimationMethod,
      const ParameterList& parametersToIgnore,
      const std::string& param = DISTANCEMETHOD_INIT,
      unsigned int verbose = 0);
 
  static std::unique_ptr<TreeTemplate<Node>> buildDistanceTree(
      DistanceEstimation& estimationMethod,
      AgglomerativeDistanceMethodInterface& reconstructionMethod,
      const std::string& param,
      OptimizationOptions& optopt);
 
public:
  static std::string DISTANCEMETHOD_INIT;
  static std::string DISTANCEMETHOD_PAIRWISE;
  static std::string DISTANCEMETHOD_ITERATIONS;
};
} // end of namespace bpp.
#endif // BPP_PHYL_OPTIMIZATIONTOOLS_H