OptimizationTools.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1
 
#ifndef BPP_PHYL_LEGACY_OPTIMIZATIONTOOLS_H
#define BPP_PHYL_LEGACY_OPTIMIZATIONTOOLS_H
 
#include <Bpp/App/ApplicationTools.h>
#include <Bpp/Io/OutputStream.h>
#include <Bpp/Numeric/Function/SimpleNewtonMultiDimensions.h>
#include <Bpp/Phyl/OptimizationTools.h>
 
#include "../Parsimony/DRTreeParsimonyScore.h"
#include "../Tree/TreeTemplate.h"
#include "Likelihood/NNIHomogeneousTreeLikelihood.h"
#include "Tree/NNITopologySearch.h"
 
namespace bpp
{
class NNITopologyListener :
  public virtual TopologyListener
{
private:
  std::shared_ptr<NNITopologySearch> topoSearch_;
  ParameterList parameters_;
  double tolerance_;
  std::shared_ptr<OutputStream> messenger_;
  std::shared_ptr<OutputStream> profiler_;
  unsigned int verbose_;
  unsigned int optimizeCounter_;
  unsigned int optimizeNumerical_;
  std::string optMethod_;
  unsigned int nStep_;
  bool reparametrization_;
 
public:
  NNITopologyListener(
      std::shared_ptr<NNITopologySearch> ts,
      const ParameterList& parameters,
      double tolerance,
      std::shared_ptr<OutputStream> messenger,
      std::shared_ptr<OutputStream> profiler,
      unsigned int verbose,
      const std::string& optMethod,
      unsigned int nStep,
      bool reparametrization) :
    topoSearch_(ts),
    parameters_(parameters),
    tolerance_(tolerance),
    messenger_(messenger),
    profiler_(profiler),
    verbose_(verbose),
    optimizeCounter_(0),
    optimizeNumerical_(1),
    optMethod_(optMethod),
    nStep_(nStep),
    reparametrization_(reparametrization) {}
 
  NNITopologyListener(const NNITopologyListener& tl) :
    topoSearch_(tl.topoSearch_),
    parameters_(tl.parameters_),
    tolerance_(tl.tolerance_),
    messenger_(tl.messenger_),
    profiler_(tl.profiler_),
    verbose_(tl.verbose_),
    optimizeCounter_(tl.optimizeCounter_),
    optimizeNumerical_(tl.optimizeNumerical_),
    optMethod_(tl.optMethod_),
    nStep_(tl.nStep_),
    reparametrization_(tl.reparametrization_)
  {}
 
  NNITopologyListener& operator=(const NNITopologyListener& tl)
  {
    topoSearch_        = tl.topoSearch_;
    parameters_        = tl.parameters_;
    tolerance_         = tl.tolerance_;
    messenger_         = tl.messenger_;
    profiler_          = tl.profiler_;
    verbose_           = tl.verbose_;
    optimizeCounter_   = tl.optimizeCounter_;
    optimizeNumerical_ = tl.optimizeNumerical_;
    optMethod_         = tl.optMethod_;
    nStep_             = tl.nStep_;
    reparametrization_ = tl.reparametrization_;
    return *this;
  }
 
  NNITopologyListener* clone() const { return new NNITopologyListener(*this); }
 
  virtual ~NNITopologyListener() {}
 
public:
  void topologyChangeTested(const TopologyChangeEvent& event) {}
  void topologyChangeSuccessful(const TopologyChangeEvent& event);
  void setNumericalOptimizationCounter(unsigned int c) { optimizeNumerical_ = c; }
};
 
class NNITopologyListener2 :
  public TopologyListener
{
private:
  std::shared_ptr<NNITopologySearch> topoSearch_;
  ParameterList parameters_;
  double tolerance_;
  std::shared_ptr<OutputStream> messenger_;
  std::shared_ptr<OutputStream> profiler_;
  unsigned int verbose_;
  unsigned int optimizeCounter_;
  unsigned int optimizeNumerical_;
  std::string optMethod_;
  bool reparametrization_;
 
public:
  NNITopologyListener2(
      std::shared_ptr<NNITopologySearch> ts,
      const ParameterList& parameters,
      double tolerance,
      std::shared_ptr<OutputStream> messenger,
      std::shared_ptr<OutputStream> profiler,
      unsigned int verbose,
      const std::string& optMethod,
      bool reparametrization) :
    topoSearch_(ts),
    parameters_(parameters),
    tolerance_(tolerance),
    messenger_(messenger),
    profiler_(profiler),
    verbose_(verbose),
    optimizeCounter_(0),
    optimizeNumerical_(1),
    optMethod_(optMethod),
    reparametrization_(reparametrization) {}
 
  NNITopologyListener2(const NNITopologyListener2& tl) :
    topoSearch_(tl.topoSearch_),
    parameters_(tl.parameters_),
    tolerance_(tl.tolerance_),
    messenger_(tl.messenger_),
    profiler_(tl.profiler_),
    verbose_(tl.verbose_),
    optimizeCounter_(tl.optimizeCounter_),
    optimizeNumerical_(tl.optimizeNumerical_),
    optMethod_(tl.optMethod_),
    reparametrization_(tl.reparametrization_)
  {}
 
  NNITopologyListener2& operator=(const NNITopologyListener2& tl)
  {
    topoSearch_        = tl.topoSearch_;
    parameters_        = tl.parameters_;
    tolerance_         = tl.tolerance_;
    messenger_         = tl.messenger_;
    profiler_          = tl.profiler_;
    verbose_           = tl.verbose_;
    optimizeCounter_   = tl.optimizeCounter_;
    optimizeNumerical_ = tl.optimizeNumerical_;
    optMethod_         = tl.optMethod_;
    reparametrization_ = tl.reparametrization_;
    return *this;
  }
 
  NNITopologyListener2* clone() const { return new NNITopologyListener2(*this); }
 
  virtual ~NNITopologyListener2() {}
 
public:
  void topologyChangeTested(const TopologyChangeEvent& event) {}
  void topologyChangeSuccessful(const TopologyChangeEvent& event);
  void setNumericalOptimizationCounter(unsigned int c) { optimizeNumerical_ = c; }
};
 
 
class LegacyOptimizationTools :
  public OptimizationTools
{
public:
  LegacyOptimizationTools();
  virtual ~LegacyOptimizationTools();
 
public:
  static unsigned int optimizeNumericalParameters(
      std::shared_ptr<DiscreteRatesAcrossSitesTreeLikelihoodInterface> tl,
      const ParameterList& parameters,
      std::shared_ptr<OptimizationListener> listener = nullptr,
      unsigned int nstep                             = 1,
      double tolerance                               = 0.000001,
      unsigned int tlEvalMax                         = 1000000,
      std::shared_ptr<OutputStream> messageHandler   = ApplicationTools::message,
      std::shared_ptr<OutputStream> profiler         = ApplicationTools::message,
      bool reparametrization                         = false,
      unsigned int verbose                           = 1,
      const std::string& optMethodDeriv              = OPTIMIZATION_NEWTON,
      const std::string& optMethodModel              = OPTIMIZATION_BRENT);
 
  static unsigned int optimizeNumericalParameters2(
      std::shared_ptr<DiscreteRatesAcrossSitesTreeLikelihoodInterface> tl,
      const ParameterList& parameters,
      std::shared_ptr<OptimizationListener> listener = nullptr,
      double tolerance                               = 0.000001,
      unsigned int tlEvalMax                         = 1000000,
      std::shared_ptr<OutputStream> messageHandler   = ApplicationTools::message,
      std::shared_ptr<OutputStream> profiler         = ApplicationTools::message,
      bool reparametrization                         = false,
      bool useClock                                  = false,
      unsigned int verbose                           = 1,
      const std::string& optMethodDeriv              = OPTIMIZATION_NEWTON);
 
  static unsigned int optimizeBranchLengthsParameters(
      std::shared_ptr<DiscreteRatesAcrossSitesTreeLikelihoodInterface> tl,
      const ParameterList& parameters,
      std::shared_ptr<OptimizationListener> listener = nullptr,
      double tolerance                               = 0.000001,
      unsigned int tlEvalMax                         = 1000000,
      std::shared_ptr<OutputStream> messageHandler   = ApplicationTools::message,
      std::shared_ptr<OutputStream> profiler         = ApplicationTools::message,
      unsigned int verbose                           = 1,
      const std::string& optMethodDeriv              = OPTIMIZATION_NEWTON);
 
private:
  class ScaleFunction :
    public virtual FunctionInterface,
    public ParametrizableAdapter
  {
private:
    std::shared_ptr<TreeLikelihoodInterface> tl_;
    mutable ParameterList brLen_, lambda_;
 
public:
    ScaleFunction(std::shared_ptr<TreeLikelihoodInterface> tl);
 
    ScaleFunction(const ScaleFunction& sf) :
      tl_(sf.tl_),
      brLen_(sf.brLen_),
      lambda_(sf.lambda_)
    {}
 
    ScaleFunction& operator=(const ScaleFunction& sf)
    {
      tl_     = sf.tl_;
      brLen_  = sf.brLen_;
      lambda_ = sf.lambda_;
      return *this;
    }
 
    virtual ~ScaleFunction();
 
    ScaleFunction* clone() const { return new ScaleFunction(*this); }
 
public:
    void setParameters(const ParameterList& lambda);
    double getValue() const;
    const ParameterList& getParameters() const { return lambda_; }
    const Parameter& parameter(const std::string& name) const
    {
      if (name == "lambda") return lambda_[0];
      else throw ParameterNotFoundException("ScaleFunction::getParameter.", name);
    }
    double getParameterValue(const std::string& name) const
    {
      return lambda_.parameter(name).getValue();
    }
    size_t getNumberOfParameters() const { return 1; }
    size_t getNumberOfIndependentParameters() const { return 1; }
 
protected:
    ParameterList& getParameters_() { return lambda_; }
  };
 
public:
  static unsigned int optimizeTreeScale(
      std::shared_ptr<TreeLikelihoodInterface> tl,
      double tolerance                             = 0.000001,
      unsigned int tlEvalMax                       = 1000000,
      std::shared_ptr<OutputStream> messageHandler = ApplicationTools::message,
      std::shared_ptr<OutputStream> profiler       = ApplicationTools::message,
      unsigned int verbose                         = 1);
 
 
  static std::shared_ptr<NNIHomogeneousTreeLikelihood> optimizeTreeNNI(
      std::shared_ptr<NNIHomogeneousTreeLikelihood> tl,
      const ParameterList& parameters,
      bool optimizeNumFirst                        = true,
      double tolBefore                             = 100,
      double tolDuring                             = 100,
      unsigned int tlEvalMax                       = 1000000,
      unsigned int numStep                         = 1,
      std::shared_ptr<OutputStream> messageHandler = ApplicationTools::message,
      std::shared_ptr<OutputStream> profiler       = ApplicationTools::message,
      bool reparametrization                       = false,
      unsigned int verbose                         = 1,
      const std::string& optMethod                 = OptimizationTools::OPTIMIZATION_NEWTON,
      unsigned int nStep                           = 1,
      const std::string& nniMethod                 = NNITopologySearch::PHYML);
 
  static std::shared_ptr<NNIHomogeneousTreeLikelihood> optimizeTreeNNI2(
      std::shared_ptr<NNIHomogeneousTreeLikelihood> tl,
      const ParameterList& parameters,
      bool optimizeNumFirst                        = true,
      double tolBefore                             = 100,
      double tolDuring                             = 100,
      unsigned int tlEvalMax                       = 1000000,
      unsigned int numStep                         = 1,
      std::shared_ptr<OutputStream> messageHandler = ApplicationTools::message,
      std::shared_ptr<OutputStream> profiler       = ApplicationTools::message,
      bool reparametrization                       = false,
      unsigned int verbose                         = 1,
      const std::string& optMethod                 = OptimizationTools::OPTIMIZATION_NEWTON,
      const std::string& nniMethod                 = NNITopologySearch::PHYML);
 
  static std::shared_ptr<DRTreeParsimonyScore> optimizeTreeNNI(
      std::shared_ptr<DRTreeParsimonyScore> tp,
      unsigned int verbose = 1);
};
} // end of namespace bpp.
#endif // BPP_PHYL_LEGACY_OPTIMIZATIONTOOLS_H