44 #ifndef ROL_TYPEE_AUGMENTEDLAGRANGIANALGORITHM_DEF_H
45 #define ROL_TYPEE_AUGMENTEDLAGRANGIANALGORITHM_DEF_H
52 template<
typename Real>
54 : TypeE::
Algorithm<Real>::
Algorithm(), secant_(secant), list_(list), subproblemIter_(0) {
59 Real one(1), p1(0.1), p9(0.9), ten(1.e1), oe8(1.e8), oem8(1.e-8);
60 ParameterList& sublist = list.sublist(
"Step").sublist(
"Augmented Lagrangian");
62 state_->searchSize = sublist.get(
"Initial Penalty Parameter", ten);
66 penaltyUpdate_ = sublist.get(
"Penalty Parameter Growth Factor", ten);
78 print_ = sublist.get(
"Print Intermediate Optimization History",
false);
79 maxit_ = sublist.get(
"Subproblem Iteration Limit", 1000);
80 subStep_ = sublist.get(
"Subproblem Step Type",
"Trust Region");
83 list_.sublist(
"Status Test").set(
"Iteration Limit",
maxit_);
84 list_.sublist(
"Status Test").set(
"Use Relative Tolerances",
false);
86 verbosity_ = list.sublist(
"General").get(
"Output Level", 0);
94 useRelTol_ = list.sublist(
"Status Test").get(
"Use Relative Tolerances",
false);
97 fscale_ = sublist.get(
"Objective Scaling", one);
98 cscale_ = sublist.get(
"Constraint Scaling", one);
101 template<
typename Real>
108 std::ostream &outStream ) {
109 const Real one(1), TOL(1.e-2);
110 Real tol = std::sqrt(ROL_EPSILON<Real>());
121 alobj.
gradient(*state_->gradientVec,x,tol);
125 state_->cnorm = state_->constraintVec->norm();
133 if (useDefaultScaling_) {
136 Ptr<Vector<Real>> ji = x.
clone();
137 Real maxji(0), normji(0);
138 for (
int i = 0; i < c.
dimension(); ++i) {
141 maxji = std::max(normji,maxji);
143 cscale_ = one/std::max(one,maxji);
145 catch (std::exception &e) {
152 state_->gnorm = state_->gradientVec->norm()/std::min(fscale_,cscale_);
155 if (useRelTol_) outerOptTolerance_ *= state_->gnorm;
156 if (useDefaultInitPen_) {
157 const Real oem8(1e-8), oem2(1e-2), two(2), ten(10);
158 state_->searchSize = std::max(oem8,
159 std::min(ten*std::max(one,std::abs(fscale_*state_->value))
160 / std::max(one,std::pow(cscale_*state_->cnorm,two)),oem2*maxPenaltyParam_));
163 minPenaltyReciprocal_ = std::min(one/state_->searchSize,minPenaltyLowerBound_);
164 optTolerance_ = std::max<Real>(TOL*outerOptTolerance_,
165 optToleranceInitial_*std::pow(minPenaltyReciprocal_,optDecreaseExponent_));
166 optTolerance_ = std::min<Real>(optTolerance_,TOL*state_->gnorm);
167 feasTolerance_ = std::max<Real>(TOL*outerFeasTolerance_,
168 feasToleranceInitial_*std::pow(minPenaltyReciprocal_,feasDecreaseExponent_));
171 alobj.
reset(l,state_->searchSize);
173 if (verbosity_ > 1) {
174 outStream << std::endl;
175 outStream <<
"Augmented Lagrangian Initialize" << std::endl;
176 outStream <<
"Objective Scaling: " << fscale_ << std::endl;
177 outStream <<
"Constraint Scaling: " << cscale_ << std::endl;
178 outStream << std::endl;
182 template<
typename Real>
189 std::ostream &outStream ) {
190 const Real one(1), oem2(1e-2);
191 Real tol(std::sqrt(ROL_EPSILON<Real>()));
194 state_->searchSize,g,eres,emul,
195 scaleLagrangian_,HessianApprox_);
196 initialize(x,g,emul,eres,alobj,econ,outStream);
197 Ptr<TypeU::Algorithm<Real>> algo;
200 if (verbosity_ > 0) writeOutput(outStream,
true);
202 while (status_->check(*state_)) {
204 list_.sublist(
"Status Test").set(
"Gradient Tolerance",optTolerance_);
205 list_.sublist(
"Status Test").set(
"Step Tolerance",1.e-6*optTolerance_);
206 algo = TypeU::AlgorithmFactory<Real>(list_,secant_);
207 algo->run(x,g,alobj,outStream);
208 subproblemIter_ = algo->getState()->iter;
211 state_->stepVec->set(x);
212 state_->stepVec->axpy(-one,*state_->iterateVec);
213 state_->snorm = state_->stepVec->norm();
217 state_->iterateVec->set(x);
220 state_->cnorm = state_->constraintVec->norm();
221 alobj.
gradient(*state_->gradientVec,x,tol);
222 if (scaleLagrangian_) {
223 state_->gradientVec->scale(state_->searchSize);
225 state_->gnorm = state_->gradientVec->norm()/std::min(fscale_,cscale_);
234 minPenaltyReciprocal_ = std::min(one/state_->searchSize,minPenaltyLowerBound_);
235 if ( cscale_*state_->cnorm < feasTolerance_ ) {
236 emul.
axpy(state_->searchSize*cscale_,state_->constraintVec->dual());
238 optTolerance_ = std::max(oem2*outerOptTolerance_,
239 optTolerance_*std::pow(minPenaltyReciprocal_,optIncreaseExponent_));
241 feasTolerance_ = std::max(oem2*outerFeasTolerance_,
242 feasTolerance_*std::pow(minPenaltyReciprocal_,feasIncreaseExponent_));
244 state_->snorm += state_->searchSize*cscale_*state_->cnorm;
245 state_->lagmultVec->set(emul);
248 state_->searchSize = std::min(penaltyUpdate_*state_->searchSize,maxPenaltyParam_);
249 optTolerance_ = std::max(oem2*outerOptTolerance_,
250 optToleranceInitial_*std::pow(minPenaltyReciprocal_,optDecreaseExponent_));
251 feasTolerance_ = std::max(oem2*outerFeasTolerance_,
252 feasToleranceInitial_*std::pow(minPenaltyReciprocal_,feasDecreaseExponent_));
254 alobj.
reset(emul,state_->searchSize);
257 if (verbosity_ > 0) writeOutput(outStream,printHeader_);
263 template<
typename Real>
265 std::ios_base::fmtflags osFlags(os.flags());
267 os << std::string(114,
'-') << std::endl;
268 os <<
"Augmented Lagrangian status output definitions" << std::endl << std::endl;
269 os <<
" iter - Number of iterates (steps taken)" << std::endl;
270 os <<
" fval - Objective function value" << std::endl;
271 os <<
" cnorm - Norm of the constraint violation" << std::endl;
272 os <<
" gLnorm - Norm of the gradient of the Lagrangian" << std::endl;
273 os <<
" snorm - Norm of the step" << std::endl;
274 os <<
" penalty - Penalty parameter" << std::endl;
275 os <<
" feasTol - Feasibility tolerance" << std::endl;
276 os <<
" optTol - Optimality tolerance" << std::endl;
277 os <<
" #fval - Number of times the objective was computed" << std::endl;
278 os <<
" #grad - Number of times the gradient was computed" << std::endl;
279 os <<
" #cval - Number of times the constraint was computed" << std::endl;
280 os <<
" subIter - Number of iterations to solve subproblem" << std::endl;
281 os << std::string(114,
'-') << std::endl;
284 os << std::setw(6) << std::left <<
"iter";
285 os << std::setw(15) << std::left <<
"fval";
286 os << std::setw(15) << std::left <<
"cnorm";
287 os << std::setw(15) << std::left <<
"gLnorm";
288 os << std::setw(15) << std::left <<
"snorm";
289 os << std::setw(10) << std::left <<
"penalty";
290 os << std::setw(10) << std::left <<
"feasTol";
291 os << std::setw(10) << std::left <<
"optTol";
292 os << std::setw(8) << std::left <<
"#fval";
293 os << std::setw(8) << std::left <<
"#grad";
294 os << std::setw(8) << std::left <<
"#cval";
295 os << std::setw(8) << std::left <<
"subIter";
300 template<
typename Real>
302 std::ios_base::fmtflags osFlags(os.flags());
303 os << std::endl <<
"Augmented Lagrangian Solver (Type E, Equality Constraints)";
305 os <<
"Subproblem Solver: " << subStep_ << std::endl;
309 template<
typename Real>
311 std::ios_base::fmtflags osFlags(os.flags());
312 os << std::scientific << std::setprecision(6);
313 if ( state_->iter == 0 ) writeName(os);
314 if ( print_header ) writeHeader(os);
315 if ( state_->iter == 0 ) {
317 os << std::setw(6) << std::left << state_->iter;
318 os << std::setw(15) << std::left << state_->value;
319 os << std::setw(15) << std::left << state_->cnorm;
320 os << std::setw(15) << std::left << state_->gnorm;
321 os << std::setw(15) << std::left <<
"---";
322 os << std::scientific << std::setprecision(2);
323 os << std::setw(10) << std::left << state_->searchSize;
324 os << std::setw(10) << std::left << std::max(feasTolerance_,outerFeasTolerance_);
325 os << std::setw(10) << std::left << std::max(optTolerance_,outerOptTolerance_);
326 os << std::scientific << std::setprecision(6);
327 os << std::setw(8) << std::left << state_->nfval;
328 os << std::setw(8) << std::left << state_->ngrad;
329 os << std::setw(8) << std::left << state_->ncval;
330 os << std::setw(8) << std::left <<
"---";
335 os << std::setw(6) << std::left << state_->iter;
336 os << std::setw(15) << std::left << state_->value;
337 os << std::setw(15) << std::left << state_->cnorm;
338 os << std::setw(15) << std::left << state_->gnorm;
339 os << std::setw(15) << std::left << state_->snorm;
340 os << std::scientific << std::setprecision(2);
341 os << std::setw(10) << std::left << state_->searchSize;
342 os << std::setw(10) << std::left << feasTolerance_;
343 os << std::setw(10) << std::left << optTolerance_;
344 os << std::scientific << std::setprecision(6);
345 os << std::setw(8) << std::left << state_->nfval;
346 os << std::setw(8) << std::left << state_->ngrad;
347 os << std::setw(8) << std::left << state_->ncval;
348 os << std::setw(8) << std::left << subproblemIter_;
Real optDecreaseExponent_
Provides the interface to evaluate objective functions.
virtual void scale(const Real alpha)=0
Compute where .
Real feasIncreaseExponent_
virtual void run(Vector< Real > &x, const Vector< Real > &g, Objective< Real > &obj, Constraint< Real > &econ, Vector< Real > &emul, const Vector< Real > &eres, std::ostream &outStream=std::cout) override
Run algorithm on equality constrained problems (Type-E). This general interface supports the use of d...
virtual ROL::Ptr< Vector > clone() const =0
Clone to make a new (uninitialized) vector.
virtual int dimension() const
Return dimension of the vector space.
virtual ROL::Ptr< Vector > basis(const int i) const
Return i-th basis vector.
Real minPenaltyLowerBound_
virtual void axpy(const Real alpha, const Vector &x)
Compute where .
Real optIncreaseExponent_
const Ptr< const Vector< Real > > getConstraintVec(const Vector< Real > &x, Real &tol)
Defines the linear algebra or vector space interface.
Real optToleranceInitial_
void reset(const Vector< Real > &multiplier, const Real penaltyParameter)
void update(const Vector< Real > &x, UpdateType type, int iter=-1)
Update objective function.
void initialize(Vector< Real > &x, const Vector< Real > &g, const Vector< Real > &l, const Vector< Real > &c, AugmentedLagrangianObjective< Real > &alobj, Constraint< Real > &con, std::ostream &outStream=std::cout)
Provides an interface to check status of optimization algorithms for problems with equality constrain...
const Ptr< AlgorithmState< Real > > state_
Provides interface for and implements limited-memory secant operators.
virtual void writeOutput(std::ostream &os, const bool print_header=false) const override
Print iterate status.
Real minPenaltyReciprocal_
const Ptr< CombinedStatusTest< Real > > status_
Provides the interface to evaluate the augmented Lagrangian.
virtual void writeHeader(std::ostream &os) const override
Print iterate header.
Real feasToleranceInitial_
Real feasDecreaseExponent_
virtual void applyAdjointJacobian(Vector< Real > &ajv, const Vector< Real > &v, const Vector< Real > &x, Real &tol)
Apply the adjoint of the the constraint Jacobian at , , to vector .
virtual void writeExitStatus(std::ostream &os) const
void setScaling(const Real fscale=1.0, const Real cscale=1.0)
void initialize(const Vector< Real > &x, const Vector< Real > &g, const Vector< Real > &mul, const Vector< Real > &c)
int getNumberFunctionEvaluations(void) const
virtual void writeName(std::ostream &os) const override
Print step name.
AugmentedLagrangianAlgorithm(ParameterList &list, const Ptr< Secant< Real >> &secant=nullPtr)
void gradient(Vector< Real > &g, const Vector< Real > &x, Real &tol)
Compute gradient.
const Ptr< const Vector< Real > > getObjectiveGradient(const Vector< Real > &x, Real &tol)
int getNumberConstraintEvaluations(void) const
Real getObjectiveValue(const Vector< Real > &x, Real &tol)
Defines the general constraint operator interface.
int getNumberGradientEvaluations(void) const