// @HEADER // ***************************************************************************** // Rapid Optimization Library (ROL) Package // // Copyright 2014 NTESS and the ROL contributors. // SPDX-License-Identifier: BSD-3-Clause // ***************************************************************************** // @HEADER #include "ROL_ParameterList.hpp" #include "ROL_Stream.hpp" #include "Teuchos_GlobalMPISession.hpp" #include "Teuchos_Comm.hpp" #include "Teuchos_DefaultComm.hpp" #include "Teuchos_CommHelpers.hpp" #include "ROL_StdVector.hpp" #include "ROL_StdBoundConstraint.hpp" #include "ROL_Types.hpp" #include "ROL_MonteCarloGenerator.hpp" #include "ROL_StdTeuchosBatchManager.hpp" #include "ROL_OptimizationSolver.hpp" #include "ROL_RiskMeasureFactory.hpp" typedef double RealT; template class ParametrizedObjectiveEx3 : public ROL::Objective { public: Real value( const ROL::Vector &x, Real &tol ) { ROL::Ptr > ex = dynamic_cast&>(x).getVector(); Real quad(0), lin(0); std::vector p = ROL::Objective::getParameter(); unsigned size = static_cast(ex->size()); for ( unsigned i = 0; i < size; i++ ) { quad += (*ex)[i]*(*ex)[i]; lin += (*ex)[i]*p[i+1]; } return std::exp(p[0])*quad + lin + p[size+1]; } void gradient( ROL::Vector &g, const ROL::Vector &x, Real &tol ) { ROL::Ptr > ex = dynamic_cast&>(x).getVector(); ROL::Ptr > eg = dynamic_cast&>(g).getVector(); std::vector p = ROL::Objective::getParameter(); unsigned size = static_cast(ex->size()); const Real two(2); for ( unsigned i = 0; i < size; i++ ) { (*eg)[i] = two*std::exp(p[0])*(*ex)[i] + p[i+1]; } } void hessVec( ROL::Vector &hv, const ROL::Vector &v, const ROL::Vector &x, Real &tol ) { ROL::Ptr > ev = dynamic_cast&>(v).getVector(); ROL::Ptr > ehv = dynamic_cast&>(hv).getVector(); std::vector p = ROL::Objective::getParameter(); unsigned size = static_cast(ev->size()); const Real two(2); for ( unsigned i = 0; i < size; i++ ) { (*ehv)[i] = two*std::exp(p[0])*(*ev)[i]; } } }; void setUpAndSolve(ROL::ParameterList &list, ROL::Ptr > &pObj, ROL::Ptr > &sampler, ROL::Ptr > &x, ROL::Ptr > &bnd, std::ostream & outStream) { x->zero(); ROL::OptimizationProblem problem(pObj,x,bnd); problem.setStochasticObjective(list,sampler); //outStream << "\nCheck Derivatives of Stochastic Objective Function\n"; //problem.check(outStream); ROL::OptimizationSolver solver(problem,list); solver.solve(outStream); } template Real random(const ROL::Ptr > &commptr) { Real val(0); if ( Teuchos::rank(*commptr)==0 ) { srand(time(NULL)); val = (Real)rand()/(Real)RAND_MAX; } Teuchos::broadcast(*commptr,0,&val); return val; } void setRandomVector(std::vector &x, const ROL::Ptr > &commptr) { unsigned dim = static_cast(x.size()); for ( unsigned i = 0; i < dim; i++ ) { x[i] = random(commptr); } } void printSolution(const std::vector &x, std::ostream & outStream) { unsigned dim = static_cast(x.size()); outStream << "x = ("; for ( unsigned i = 0; i < dim-1; i++ ) { outStream << x[i] << ", "; } outStream << x[dim-1] << ")\n"; } int main(int argc, char* argv[]) { Teuchos::GlobalMPISession mpiSession(&argc, &argv); ROL::Ptr > commptr = ROL::toPtr(Teuchos::DefaultComm::getComm()); // This little trick lets us print to std::cout only if a (dummy) command-line argument is provided. int iprint = argc - 1; ROL::Ptr outStream; ROL::nullstream bhs; // outputs nothing if (iprint > 0 && commptr->getRank()==0) outStream = ROL::makePtrFromRef(std::cout); else outStream = ROL::makePtrFromRef(bhs); int errorFlag = 0; try { /**********************************************************************************************/ /************************* CONSTRUCT ROL ALGORITHM ********************************************/ /**********************************************************************************************/ // Get ROL parameterlist std::string filename = "input_03.xml"; auto parlist = ROL::getParametersFromXmlFile( filename ); ROL::ParameterList list = *parlist; // Build ROL algorithm ROL::Ptr > algo; /**********************************************************************************************/ /************************* CONSTRUCT SOL COMPONENTS *******************************************/ /**********************************************************************************************/ // Build vectors unsigned dim = 4; ROL::Ptr > x_ptr = ROL::makePtr>(dim,0.0); ROL::Ptr > x = ROL::makePtr>(x_ptr); ROL::Ptr > d_ptr = ROL::makePtr>(dim,0.0); ROL::Ptr > d = ROL::makePtr>(d_ptr); //setRandomVector(*x_ptr,commptr); //setRandomVector(*d_ptr,commptr); // Build samplers int nSamp = 1000; unsigned sdim = dim + 2; std::vector tmp(2,0.); tmp[0] = -1.; tmp[1] = 1.; std::vector > bounds(sdim,tmp); ROL::Ptr > bman = ROL::makePtr>(commptr); ROL::Ptr > sampler = ROL::makePtr>(nSamp,bounds,bman,false,false,100); // Build risk-averse objective function ROL::Ptr > pObj = ROL::makePtr>(); // Build bound constraints std::vector l(dim,0.0); std::vector u(dim,1.0); ROL::Ptr > bnd = ROL::makePtr>(l,u); bnd->deactivate(); // Test parametrized objective functions *outStream << "Check Derivatives of Parametrized Objective Function\n"; pObj->setParameter(sampler->getMyPoint(0)); pObj->checkGradient(*x,*d,true,*outStream); pObj->checkHessVec(*x,*d,true,*outStream); // Storage for solutions std::vector>> solution; /**********************************************************************************************/ /************************* MEAN VALUE *********************************************************/ /**********************************************************************************************/ *outStream << "\nMean Value\n"; list.sublist("SOL").set("Type","Mean Value"); //setRandomVector(*x_ptr,commptr); setUpAndSolve(list,pObj,sampler,x,bnd,*outStream); printSolution(*x_ptr,*outStream); solution.push_back(std::tuple>("","Mean Value",*x_ptr)); /**********************************************************************************************/ /************************* RISK NEUTRAL *******************************************************/ /**********************************************************************************************/ *outStream << "\nRisk Neutral\n"; list.sublist("SOL").set("Type","Risk Neutral"); //setRandomVector(*x_ptr,commptr); setUpAndSolve(list,pObj,sampler,x,bnd,*outStream); printSolution(*x_ptr,*outStream); solution.push_back(std::tuple>("","Risk Neutral",*x_ptr)); /**********************************************************************************************/ /************************* RISK AVERSE ********************************************************/ /**********************************************************************************************/ for (ROL::ERiskMeasure er = ROL::RISKMEASURE_CVAR; er != ROL::RISKMEASURE_LAST; er++) { std::string name = ROL::ERiskMeasureToString(er); *outStream << std::endl << name << std::endl; list.sublist("SOL").set("Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name",name); if (er == ROL::RISKMEASURE_MEANDEVIATION || er == ROL::RISKMEASURE_MEANVARIANCE || er == ROL::RISKMEASURE_MEANDEVIATIONFROMTARGET || er == ROL::RISKMEASURE_MEANVARIANCEFROMTARGET) { list.sublist("SOL").sublist("Risk Measure").sublist(name).set("Deviation Type","Absolute"); //setRandomVector(*x_ptr,commptr); setUpAndSolve(list,pObj,sampler,x,bnd,*outStream); printSolution(*x_ptr,*outStream); solution.push_back(std::tuple>("Risk",name,*x_ptr)); list.sublist("SOL").sublist("Risk Measure").sublist(name).set("Deviation Type","Upper"); //setRandomVector(*x_ptr,commptr); setUpAndSolve(list,pObj,sampler,x,bnd,*outStream); printSolution(*x_ptr,*outStream); solution.push_back(std::tuple>("Risk",name,*x_ptr)); } else if (er == ROL::RISKMEASURE_CHEBYSHEVSPECTRAL) { list.sublist("SOL").sublist("Risk Measure").sublist(name).set("Weight Type",1); //setRandomVector(*x_ptr,commptr); setUpAndSolve(list,pObj,sampler,x,bnd,*outStream); printSolution(*x_ptr,*outStream); solution.push_back(std::tuple>("Risk",name,*x_ptr)); list.sublist("SOL").sublist("Risk Measure").sublist(name).set("Weight Type",2); //setRandomVector(*x_ptr,commptr); setUpAndSolve(list,pObj,sampler,x,bnd,*outStream); printSolution(*x_ptr,*outStream); solution.push_back(std::tuple>("Risk",name,*x_ptr)); list.sublist("SOL").sublist("Risk Measure").sublist(name).set("Weight Type",3); //setRandomVector(*x_ptr,commptr); setUpAndSolve(list,pObj,sampler,x,bnd,*outStream); printSolution(*x_ptr,*outStream); solution.push_back(std::tuple>("Risk",name,*x_ptr)); } else { //setRandomVector(*x_ptr,commptr); setUpAndSolve(list,pObj,sampler,x,bnd,*outStream); printSolution(*x_ptr,*outStream); solution.push_back(std::tuple>("Risk",name,*x_ptr)); } } /**********************************************************************************************/ /************************* CONVEX COMBINATION OF RISK MEASURES ********************************/ /**********************************************************************************************/ *outStream << "\nConvex Combination if Risk Measures\n"; list.sublist("SOL").set("Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Convex Combination Risk Measure"); //setRandomVector(*x_ptr,commptr); setUpAndSolve(list,pObj,sampler,x,bnd,*outStream); printSolution(*x_ptr,*outStream); solution.push_back(std::tuple>("Risk","Convex Combination of Risk Measures",*x_ptr)); /**********************************************************************************************/ /************************* DEVIATION **********************************************************/ /**********************************************************************************************/ for (ROL::EDeviationMeasure ed = ROL::DEVIATIONMEASURE_MEANVARIANCEQUADRANGLE; ed != ROL::DEVIATIONMEASURE_LAST; ed++) { std::string name = ROL::EDeviationMeasureToString(ed); *outStream << std::endl << "Deviation: " << name << std::endl; list.sublist("SOL").set("Type","Deviation"); list.sublist("SOL").sublist("Deviation Measure").set("Name",name); //setRandomVector(*x_ptr); setUpAndSolve(list,pObj,sampler,x,bnd,*outStream); printSolution(*x_ptr,*outStream); solution.push_back(std::tuple>("Deviation",name,*x_ptr)); } /**********************************************************************************************/ /************************* REGRET *************************************************************/ /**********************************************************************************************/ for (ROL::ERegretMeasure er = ROL::REGRETMEASURE_MEANABSOLUTELOSS; er != ROL::REGRETMEASURE_LAST; er++) { std::string name = ROL::ERegretMeasureToString(er); *outStream << std::endl << "Regret: " << name << std::endl; list.sublist("SOL").set("Type","Regret"); list.sublist("SOL").sublist("Regret Measure").set("Name",name); //setRandomVector(*x_ptr); setUpAndSolve(list,pObj,sampler,x,bnd,*outStream); printSolution(*x_ptr,*outStream); solution.push_back(std::tuple>("Regret",name,*x_ptr)); } /**********************************************************************************************/ /************************* PROBABILITY ********************************************************/ /**********************************************************************************************/ for (ROL::EProbability ep = ROL::PROBABILITY_BPOE; ep != ROL::PROBABILITY_LAST; ep++) { std::string name = ROL::EProbabilityToString(ep); *outStream << std::endl << "Probability: " << name << std::endl; list.sublist("SOL").set("Type","Probability"); list.sublist("SOL").sublist("Probability").set("Name",name); //setRandomVector(*x_ptr); setUpAndSolve(list,pObj,sampler,x,bnd,*outStream); printSolution(*x_ptr,*outStream); solution.push_back(std::tuple>("Probability",name,*x_ptr)); } std::vector>>::iterator it; *outStream << std::endl << std::scientific << std::setprecision(6); for (it = solution.begin(); it != solution.end(); ++it) { *outStream << " "; *outStream << std::setw(20) << std::left << std::get<0>(*it); *outStream << std::setw(50) << std::left << std::get<1>(*it); for (unsigned i = 0; i < dim; ++i) { *outStream << std::setw(18) << std::left << (std::get<2>(*it))[i]; } *outStream << std::endl; } *outStream << std::endl; } catch (std::logic_error& err) { *outStream << err.what() << "\n"; errorFlag = -1000; }; // end try if (errorFlag != 0) std::cout << "End Result: TEST FAILED\n"; else std::cout << "End Result: TEST PASSED\n"; return 0; }