Line data    Source code

       1             : /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
       2             :    Copyright (c) 2016-2021 The VES code team
       3             :    (see the PEOPLE-VES file at the root of this folder for a list of names)
       4             : 
       5             :    See http://www.ves-code.org for more information.
       6             : 
       7             :    This file is part of VES code module.
       8             : 
       9             :    The VES code module is free software: you can redistribute it and/or modify
      10             :    it under the terms of the GNU Lesser General Public License as published by
      11             :    the Free Software Foundation, either version 3 of the License, or
      12             :    (at your option) any later version.
      13             : 
      14             :    The VES code module is distributed in the hope that it will be useful,
      15             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      16             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      17             :    GNU Lesser General Public License for more details.
      18             : 
      19             :    You should have received a copy of the GNU Lesser General Public License
      20             :    along with the VES code module.  If not, see <http://www.gnu.org/licenses/>.
      21             : +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
      22             : 
      23             : #include "Optimizer.h"
      24             : #include "CoeffsVector.h"
      25             : #include "CoeffsMatrix.h"
      26             : 
      27             : #include "core/ActionRegister.h"
      28             : #include "core/PlumedMain.h"
      29             : 
      30             : 
      31             : 
      32             : namespace PLMD {
      33             : namespace ves {
      34             : 
      35             : //+PLUMEDOC VES_OPTIMIZER OPT_AVERAGED_SGD
      36             : /*
      37             : Averaged stochastic gradient decent with fixed step size.
      38             : 
      39             : \par Algorithm
      40             : 
      41             : This optimizer updates the coefficients according to the averaged stochastic gradient decent algorithm described in ref \cite Bach-NIPS-2013. This algorithm considers two sets of coefficients, the so-called instantaneous coefficients that are updated according to the recursion formula given by
      42             : \f[
      43             : \boldsymbol{\alpha}^{(n+1)} = \boldsymbol{\alpha}^{(n)} -
      44             : \mu \left[
      45             : \nabla \Omega(\bar{\boldsymbol{\alpha}}^{(n)}) +
      46             : \mathbf{H}(\bar{\boldsymbol{\alpha}}^{(n)})
      47             : [\boldsymbol{\alpha}^{(n)}-\bar{\boldsymbol{\alpha}}^{(n)}]
      48             : \right],
      49             : \f]
      50             : where \f$\mu\f$ is a fixed step size and the gradient \f$ \nabla\Omega(\bar{\boldsymbol{\alpha}}^{(n)})\f$ and the Hessian \f$\mathbf{H}(\bar{\boldsymbol{\alpha}}^{(n)})\f$ depend on the averaged coefficients defined as
      51             : \f[
      52             : \bar{\boldsymbol{\alpha}}^{(n)} = \frac{1}{n+1} \sum_{k=0}^{n} \boldsymbol{\alpha}^{(k)}.
      53             : \f]
      54             : This means that the bias acting on the system depends on the averaged coefficients \f$\bar{\boldsymbol{\alpha}}^{(n)}\f$ which leads to a smooth convergence of the bias and the estimated free energy surface. Furthermore, this allows for a rather short sampling time for each iteration, for classical MD simulations typical sampling times are on the order of few ps (around 1000-4000 MD steps).
      55             : 
      56             : Currently it is only supported to employ the diagonal part of the Hessian which is generally sufficient. Support for employing the full Hessian will be added later on.
      57             : 
      58             : The VES bias that is to be optimized should be specified using the
      59             : BIAS keyword.
      60             : The fixed step size \f$\mu\f$ is given using the STEPSIZE keyword.
      61             : The frequency of updating the coefficients is given using the
      62             : STRIDE keyword where the value is given in the number of MD steps.
      63             : For example, if the MD time step is 0.02 ps and STRIDE=2000 will the
      64             : coefficients be updated every 4 ps.
      65             : The coefficients will be outputted to the file given by the
      66             : COEFFS_FILE keyword. How often the coefficients are written
      67             : to this file is controlled by the COEFFS_OUTPUT keyword.
      68             : 
      69             : If the VES bias employs a dynamic target distribution that needs to be
      70             : iteratively updated (e.g. \ref TD_WELLTEMPERED) \cite Valsson-JCTC-2015, you will need to specify
      71             : the stride for updating the target distribution by using
      72             : the TARGETDIST_STRIDE keyword where the stride
      73             : is given in terms coefficient iterations. For example if the
      74             : MD time step is 0.02 ps and STRIDE=1000, such that the coefficients
      75             : are updated every 2 ps, will TARGETDIST_STRIDE=500 mean that the
      76             : target distribution will be updated every 1000 ps.
      77             : 
      78             : The output of the free energy surfaces and biases is controlled by the FES_OUTPUT and the BIAS_OUTPUT
      79             : keywords. It is also possible to output one-dimensional projections of the free energy surfaces
      80             : by using the FES_PROJ_OUTPUT keyword but for that to work you will need to select
      81             : for which argument to do the projections by using the numbered PROJ_ARG keyword in
      82             : the VES bias that is optimized.
      83             : You can also output dynamic target distributions by using the
      84             : TARGETDIST_OUTPUT and TARGETDIST_PROJ_OUTPUT keywords.
      85             : 
      86             : It is possible to start the optimization from some initial set of
      87             : coefficients that have been previously obtained by using the INITIAL_COEFFS
      88             : keyword.
      89             : 
      90             : When restarting simulations it should be sufficient to put the \ref RESTART action
      91             : in the beginning of the input files (or some MD codes the PLUMED should automatically
      92             : detect if it is a restart run) and keep the same input as before The restarting of
      93             : the optimization should be automatic as the optimizer will then read in the
      94             : coefficients from the file given in COEFFS_FILE. For dynamic target
      95             : distribution the code will also read in the final target distribution from the
      96             : previous run (which is always outputted even if the TARGETDIST_OUTPUT keyword
      97             : is not used).
      98             : 
      99             : This optimizer supports the usage of multiple walkers where different copies of the system share the same bias potential (i.e. coefficients) and cooperatively sample the averages needed for the gradient and Hessian. This can significantly help with convergence in difficult cases. It is of course best to start the different copies from different positions in CV space. To activate this option you just need to add the MULTIPLE_WALKERS flag. Note that this is only supported if the MD code support running multiple replicas connected via MPI.
     100             : 
     101             : The optimizer supports the usage of a so-called mask file that can be used to employ different step sizes for different coefficients and/or deactivate the optimization of certain coefficients (by putting values of 0.0). The mask file is read in by using the MASK_FILE keyword and should be in the same format as the coefficient file. It is possible to generate a template mask file by using the OUTPUT_MASK_FILE keyword.
     102             : 
     103             : \par Examples
     104             : 
     105             : In the following input we employ an averaged stochastic gradient decent with a
     106             : fixed step size of 1.0 and update the coefficient every 1000 MD steps
     107             : (e.g. every 2 ps if the MD time step is 0.02 ps). The coefficient are outputted
     108             : to the coefficients.data every 50 iterations while the FES and bias is outputted
     109             : to files every 500 iterations (e.g. every 1000 ps).
     110             : \plumedfile
     111             : phi:   TORSION ATOMS=5,7,9,15
     112             : 
     113             : bf1: BF_FOURIER ORDER=5 MINIMUM=-pi MAXIMUM=pi
     114             : 
     115             : VES_LINEAR_EXPANSION ...
     116             :  ARG=phi
     117             :  BASIS_FUNCTIONS=bf1
     118             :  LABEL=ves1
     119             :  TEMP=300.0
     120             :  GRID_BINS=100
     121             : ... VES_LINEAR_EXPANSION
     122             : 
     123             : OPT_AVERAGED_SGD ...
     124             :   BIAS=ves1
     125             :   STRIDE=1000
     126             :   LABEL=o1
     127             :   STEPSIZE=1.0
     128             :   COEFFS_FILE=coefficients.data
     129             :   COEFFS_OUTPUT=50
     130             :   FES_OUTPUT=500
     131             :   BIAS_OUTPUT=500
     132             : ... OPT_AVERAGED_SGD
     133             : \endplumedfile
     134             : 
     135             : 
     136             : In the following example we employ a well-tempered target distribution that
     137             : is updated every 500 iterations (e.g. every 1000 ps). The target distribution is
     138             : also output to a file every 2000 iterations (the TARGETDIST_OUTPUT keyword).
     139             : Here we also employ MULTIPLE_WALKERS flag to enable the usage of
     140             : multiple walkers.
     141             : \plumedfile
     142             : #SETTINGS NREPLICAS=2
     143             : phi:   TORSION ATOMS=5,7,9,15
     144             : psi:   TORSION ATOMS=7,9,15,17
     145             : 
     146             : bf1: BF_FOURIER ORDER=5 MINIMUM=-pi MAXIMUM=pi
     147             : bf2: BF_FOURIER ORDER=4 MINIMUM=-pi MAXIMUM=pi
     148             : 
     149             : td1: TD_WELLTEMPERED BIASFACTOR=10
     150             : 
     151             : VES_LINEAR_EXPANSION ...
     152             :  ARG=phi,psi
     153             :  BASIS_FUNCTIONS=bf1,bf2
     154             :  LABEL=ves1
     155             :  TEMP=300.0
     156             :  GRID_BINS=100,100
     157             :  TARGET_DISTRIBUTION=td1
     158             :  PROJ_ARG1=phi
     159             :  PROJ_ARG2=psi
     160             : ... VES_LINEAR_EXPANSION
     161             : 
     162             : OPT_AVERAGED_SGD ...
     163             :   BIAS=ves1
     164             :   STRIDE=1000
     165             :   LABEL=o1
     166             :   STEPSIZE=1.0
     167             :   MULTIPLE_WALKERS
     168             :   COEFFS_FILE=coefficients.data
     169             :   COEFFS_OUTPUT=50
     170             :   FES_OUTPUT=500
     171             :   FES_PROJ_OUTPUT=500
     172             :   BIAS_OUTPUT=500
     173             :   TARGETDIST_STRIDE=500
     174             :   TARGETDIST_OUTPUT=2000
     175             : ... OPT_AVERAGED_SGD
     176             : \endplumedfile
     177             : 
     178             : 
     179             : 
     180             : */
     181             : //+ENDPLUMEDOC
     182             : 
     183             : class Opt_BachAveragedSGD : public Optimizer {
     184             : private:
     185             :   std::vector<std::unique_ptr<CoeffsVector>> combinedgradient_pntrs_;
     186             :   unsigned int combinedgradient_wstride_;
     187             :   std::vector<std::unique_ptr<OFile>> combinedgradientOFiles_;
     188             :   double decaying_aver_tau_;
     189             : private:
     190          60 :   CoeffsVector& CombinedGradient(const unsigned int c_id) const {return *combinedgradient_pntrs_[c_id];}
     191             :   double getAverDecay() const;
     192             : public:
     193             :   static void registerKeywords(Keywords&);
     194             :   explicit Opt_BachAveragedSGD(const ActionOptions&);
     195             :   void coeffsUpdate(const unsigned int c_id = 0) override;
     196             : };
     197             : 
     198             : 
     199             : PLUMED_REGISTER_ACTION(Opt_BachAveragedSGD,"OPT_AVERAGED_SGD")
     200             : 
     201             : 
     202          77 : void Opt_BachAveragedSGD::registerKeywords(Keywords& keys) {
     203          77 :   Optimizer::registerKeywords(keys);
     204          77 :   Optimizer::useFixedStepSizeKeywords(keys);
     205          77 :   Optimizer::useMultipleWalkersKeywords(keys);
     206          77 :   Optimizer::useHessianKeywords(keys);
     207          77 :   Optimizer::useMaskKeywords(keys);
     208          77 :   Optimizer::useRestartKeywords(keys);
     209          77 :   Optimizer::useMonitorAverageGradientKeywords(keys);
     210          77 :   Optimizer::useDynamicTargetDistributionKeywords(keys);
     211         154 :   keys.add("hidden","COMBINED_GRADIENT_FILE","the name of output file for the combined gradient (gradient + Hessian term)");
     212         154 :   keys.add("hidden","COMBINED_GRADIENT_OUTPUT","how often the combined gradient should be written to file. This parameter is given as the number of bias iterations. It is by default 100 if COMBINED_GRADIENT_FILE is specficed");
     213         154 :   keys.add("hidden","COMBINED_GRADIENT_FMT","specify format for combined gradient file(s) (useful for decrease the number of digits in regtests)");
     214         154 :   keys.add("optional","EXP_DECAYING_AVER","calculate the averaged coefficients using exponentially decaying averaging using the decaying constant given here in the number of iterations");
     215          77 : }
     216             : 
     217             : 
     218             : 
     219          75 : Opt_BachAveragedSGD::Opt_BachAveragedSGD(const ActionOptions&ao):
     220             :   PLUMED_VES_OPTIMIZER_INIT(ao),
     221          75 :   combinedgradient_wstride_(100),
     222          75 :   decaying_aver_tau_(0.0)
     223             : {
     224          75 :   log.printf("  Averaged stochastic gradient decent, see and cite ");
     225         150 :   log << plumed.cite("Bach and Moulines, NIPS 26, 773-781 (2013)");
     226          75 :   log.printf("\n");
     227          75 :   unsigned int decaying_aver_tau_int=0;
     228          75 :   parse("EXP_DECAYING_AVER",decaying_aver_tau_int);
     229          75 :   if(decaying_aver_tau_int>0) {
     230           2 :     decaying_aver_tau_ = static_cast<double>(decaying_aver_tau_int);
     231           2 :     log.printf("  Coefficients calculated using an exponentially decaying average with a decaying constant of %u iterations, see and cite ",decaying_aver_tau_int);
     232           4 :     log << plumed.cite("Invernizzi, Valsson, and Parrinello, Proc. Natl. Acad. Sci. USA 114, 3370-3374 (2017)");
     233           2 :     log.printf("\n");
     234             :   }
     235             :   //
     236             :   std::vector<std::string> combinedgradient_fnames;
     237          75 :   parseFilenames("COMBINED_GRADIENT_FILE",combinedgradient_fnames);
     238         150 :   parse("COMBINED_GRADIENT_OUTPUT",combinedgradient_wstride_);
     239          75 :   setupOFiles(combinedgradient_fnames,combinedgradientOFiles_,useMultipleWalkers());
     240          75 :   std::string combinedgradient_fmt="";
     241         150 :   parse("COMBINED_GRADIENT_FMT",combinedgradient_fmt);
     242          75 :   if(combinedgradient_fnames.size()>0) {
     243          12 :     for(unsigned int i=0; i<numberOfCoeffsSets(); i++) {
     244          12 :       auto combinedgradient_tmp = Tools::make_unique<CoeffsVector>(*getGradientPntrs()[i]);
     245           6 :       std::string label = getGradientPntrs()[i]->getLabel();
     246           6 :       if(label.find("gradient")!=std::string::npos) {
     247          12 :         label.replace(label.find("gradient"), std::string("gradient").length(), "combined_gradient");
     248             :       }
     249             :       else {
     250             :         label += "_combined";
     251             :       }
     252           6 :       combinedgradient_tmp->setLabels(label);
     253           6 :       if(combinedgradient_fmt.size()>0) {
     254             :         combinedgradient_tmp->setOutputFmt(combinedgradient_fmt);
     255             :       }
     256           6 :       combinedgradient_pntrs_.emplace_back(std::move(combinedgradient_tmp));
     257           6 :     }
     258             :     //
     259           6 :     if(numberOfCoeffsSets()==1) {
     260          12 :       log.printf("  Combined gradient (gradient + Hessian term) will be written out to file %s every %u iterations\n",combinedgradientOFiles_[0]->getPath().c_str(),combinedgradient_wstride_);
     261             :     }
     262             :     else {
     263           0 :       log.printf("  Combined gradient (gradient + Hessian term) will be written out to the following files every %u iterations:\n",combinedgradient_wstride_);
     264           0 :       for(unsigned int i=0; i<combinedgradientOFiles_.size(); i++) {
     265           0 :         log.printf("   coefficient set %u: %s\n",i,combinedgradientOFiles_[i]->getPath().c_str());
     266             :       }
     267             :     }
     268             :   }
     269             :   //
     270             : 
     271          75 :   turnOnHessian();
     272          75 :   checkRead();
     273          75 : }
     274             : 
     275             : 
     276       22675 : void Opt_BachAveragedSGD::coeffsUpdate(const unsigned int c_id) {
     277             :   //
     278       22675 :   if(combinedgradientOFiles_.size()>0 && (getIterationCounter()+1)%combinedgradient_wstride_==0) {
     279          60 :     CombinedGradient(c_id).setValues( ( Gradient(c_id) + Hessian(c_id)*(AuxCoeffs(c_id)-Coeffs(c_id)) ) );
     280          60 :     combinedgradient_pntrs_[c_id]->setIterationCounterAndTime(getIterationCounter()+1,getTime());
     281          60 :     combinedgradient_pntrs_[c_id]->writeToFile(*combinedgradientOFiles_[c_id]);
     282             :   }
     283             :   //
     284             :   double aver_decay = getAverDecay();
     285       22675 :   AuxCoeffs(c_id) += - StepSize(c_id)*CoeffsMask(c_id) * ( Gradient(c_id) + Hessian(c_id)*(AuxCoeffs(c_id)-Coeffs(c_id)) );
     286             :   //AuxCoeffs() = AuxCoeffs() - StepSize() * ( Gradient() + Hessian()*(AuxCoeffs()-Coeffs()) );
     287       22675 :   Coeffs(c_id) += aver_decay * ( AuxCoeffs(c_id)-Coeffs(c_id) );
     288       22675 : }
     289             : 
     290             : 
     291             : inline
     292             : double Opt_BachAveragedSGD::getAverDecay() const {
     293       22675 :   double aver_decay = 1.0 / ( getIterationCounterDbl() + 1.0 );
     294       22675 :   if(decaying_aver_tau_ > 0.0 && (getIterationCounterDbl() + 1.0) > decaying_aver_tau_) {
     295          14 :     aver_decay = 1.0 / decaying_aver_tau_;
     296             :   }
     297             :   return aver_decay;
     298             : }
     299             : 
     300             : 
     301             : }
     302             : }