Date: 2022-03-31T04:49:02+00:00

Actual source code: bqnls.c

      1: #include <../src/tao/bound/impls/bqnk/bqnk.h>

      3: static const char *BNK_AS[64] = {"none", "bertsekas"};

      5: static PetscErrorCode TaoBQNLSComputeHessian(Tao tao)
      6: {
      7:   TAO_BNK        *bnk = (TAO_BNK *)tao->data;
      8:   TAO_BQNK       *bqnk = (TAO_BQNK*)bnk->ctx;
      9:   PetscReal      gnorm2, delta;

     11:   /* Compute the initial scaling and update the approximation */
     12:   gnorm2 = bnk->gnorm*bnk->gnorm;
     13:   if (gnorm2 == 0.0) gnorm2 = PETSC_MACHINE_EPSILON;
     14:   if (bnk->f == 0.0) delta = 2.0 / gnorm2;
     15:   else delta = 2.0 * PetscAbsScalar(bnk->f) / gnorm2;
     16:   MatLMVMSymBroydenSetDelta(bqnk->B, delta);
     17:   MatLMVMUpdate(bqnk->B, tao->solution, bnk->unprojected_gradient);
     18:   return 0;
     19: }

     21: static PetscErrorCode TaoBQNLSComputeStep(Tao tao, PetscBool shift, KSPConvergedReason *ksp_reason, PetscInt *step_type)
     22: {
     23:   TAO_BNK        *bnk = (TAO_BNK *)tao->data;
     24:   TAO_BQNK       *bqnk = (TAO_BQNK*)bnk->ctx;
     25:   PetscInt       nupdates;

     27:   MatSolve(bqnk->B, tao->gradient, tao->stepdirection);
     28:   VecScale(tao->stepdirection, -1.0);
     29:   TaoBNKBoundStep(tao, bnk->as_type, tao->stepdirection);
     30:   *ksp_reason = KSP_CONVERGED_ATOL;
     31:   MatLMVMGetUpdateCount(bqnk->B, &nupdates);
     32:   if (nupdates == 0) *step_type = BNK_SCALED_GRADIENT;
     33:   else *step_type = BNK_BFGS;
     34:   return 0;
     35: }

     37: static PetscErrorCode TaoSetFromOptions_BQNLS(PetscOptionItems *PetscOptionsObject,Tao tao)
     38: {
     39:   TAO_BNK        *bnk = (TAO_BNK *)tao->data;
     40:   TAO_BQNK       *bqnk = (TAO_BQNK*)bnk->ctx;
     41:   PetscBool      is_spd;

     43:   PetscOptionsHead(PetscOptionsObject,"Quasi-Newton-Krylov method for bound constrained optimization");
     44:   PetscOptionsEList("-tao_bnk_as_type", "active set estimation method", "", BNK_AS, BNK_AS_TYPES, BNK_AS[bnk->as_type], &bnk->as_type, NULL);
     45:   PetscOptionsReal("-tao_bnk_epsilon", "(developer) tolerance used when computing actual and predicted reduction", "", bnk->epsilon, &bnk->epsilon,NULL);
     46:   PetscOptionsReal("-tao_bnk_as_tol", "(developer) initial tolerance used when estimating actively bounded variables", "", bnk->as_tol, &bnk->as_tol,NULL);
     47:   PetscOptionsReal("-tao_bnk_as_step", "(developer) step length used when estimating actively bounded variables", "", bnk->as_step, &bnk->as_step,NULL);
     48:   PetscOptionsInt("-tao_bnk_max_cg_its", "number of BNCG iterations to take for each Newton step", "", bnk->max_cg_its, &bnk->max_cg_its,NULL);
     49:   PetscOptionsTail();

     51:   TaoSetOptionsPrefix(bnk->bncg,((PetscObject)(tao))->prefix);
     52:   TaoAppendOptionsPrefix(bnk->bncg,"tao_bnk_");
     53:   TaoSetFromOptions(bnk->bncg);

     55:   MatSetOptionsPrefix(bqnk->B, ((PetscObject)tao)->prefix);
     56:   MatAppendOptionsPrefix(bqnk->B, "tao_bqnls_");
     57:   MatSetFromOptions(bqnk->B);
     58:   MatGetOption(bqnk->B, MAT_SPD, &is_spd);
     60:   return 0;
     61: }

     63: /*MC
     64:   TAOBQNLS - Bounded Quasi-Newton Line Search method for nonlinear minimization with bound
     65:              constraints. This method approximates the action of the inverse-Hessian with a
     66:              limited memory quasi-Newton formula. The quasi-Newton matrix and its options are
     67:              accessible via the prefix `-tao_bqnls_`

     69:   Option Database Keys:
     70: + -tao_bnk_max_cg_its - maximum number of bounded conjugate-gradient iterations taken in each Newton loop
     71: . -tao_bnk_as_type - active-set estimation method ("none", "bertsekas")
     72: . -tao_bnk_epsilon - (developer) tolerance for small pred/actual ratios that trigger automatic step acceptance
     73: . -tao_bnk_as_tol - (developer) initial tolerance used in estimating bounded active variables (-as_type bertsekas)
     74: - -tao_bnk_as_step - (developer) trial step length used in estimating bounded active variables (-as_type bertsekas)

     76:   Level: beginner
     77: .seealso: TAOBNK
     78: M*/
     79: PETSC_EXTERN PetscErrorCode TaoCreate_BQNLS(Tao tao)
     80: {
     81:   TAO_BNK        *bnk;
     82:   TAO_BQNK       *bqnk;

     84:   TaoCreate_BQNK(tao);
     85:   tao->ops->setfromoptions = TaoSetFromOptions_BQNLS;

     87:   bnk = (TAO_BNK*)tao->data;
     88:   bnk->update_type = BNK_UPDATE_STEP;
     89:   bnk->computehessian = TaoBQNLSComputeHessian;
     90:   bnk->computestep = TaoBQNLSComputeStep;

     92:   bqnk = (TAO_BQNK*)bnk->ctx;
     93:   bqnk->solve = TaoSolve_BNLS;
     94:   MatSetType(bqnk->B, MATLMVMBFGS);
     95:   return 0;
     96: }