void optimize_sinusoid( BOOSTNS::random::mt19937 & rng, const po::variables_map & options ) { Numeric regionwidth = 1.0; Numeric eps = 0.1, lipsch = 20; RDISOptimizer * popt = NULL; const string domain = BOOSTNS::str( BOOSTNS::format( "%1%:%2%" ) % ( -regionwidth/2.0 ) % ( regionwidth/2.0 ) ); // ( regionwidth / 4.0 ) % ( 5.0*regionwidth/4.0 ) ); eps = options.count( "epsilon" ) ? options[ "epsilon" ].as< Numeric >() : eps; lipsch = options.count( "lipschitz" ) ? options[ "lipschitz" ].as< Numeric >() : lipsch; if ( options.count( "timeAsSeed" ) && options[ "timeAsSeed" ].as< bool >() ) { rng.seed( std::time(NULL) + getpid() ); if ( options[ "sampleOffset"].as< size_t >() > 0 ) { std::cout << "WARNING: sampleOffset and timeAsSeed should not both be set" << std::endl; } } const bool isBCD = ( options.count( "opttype" ) && options[ "opttype" ].as< string >() == "bcd" ); size_t h = options[ "sinHeight" ].as< size_t >(); size_t bf = options[ "sinBF" ].as< size_t >(); size_t arity = options[ "sinArity" ].as< size_t >(); bool oddArity = options[ "sinOddArity" ].as< bool >(); OptimizableFunctionSP funcsp = OptimizableFunctionGenerator::makeHighDimSinusoid( h, bf, arity, oddArity ); OptimizableFunction & fsinusoid = *funcsp; std::cout << fsinusoid << std::endl; CGDSubspaceOptimizer ssopt( fsinusoid ); ssopt.setParameters( options ); // create the optimizer popt = new RDISOptimizer( fsinusoid, ssopt, options ); RDISOptimizer & opt = *popt; setSignalHandler( &opt ); opt.setApproxFactors( options[ "approxfactors" ].as< bool >() ); opt.setUseCache( false ); // opt.setUseExactCaching( false ); const Numeric MaxVal = std::numeric_limits< Numeric >::max(); size_t sampleOffset = options[ "sampleOffset" ].as< size_t >(); size_t nsamples = options[ "nsamples" ].as< size_t >() + sampleOffset; const NumericInterval dom = fsinusoid.getVariables()[0]->getDomain().interval(); BOOSTNS::random::uniform_real_distribution<> unif( dom.lower(), dom.upper() ); std::vector< State > initialStates( nsamples ); // create all the random initial states up front (so they're consistent // across runs if the seed doesn't change) for ( size_t i = 0; i < nsamples; ++i ) { for ( VariableID vid = 0; vid < fsinusoid.getNumVars(); ++vid ) { initialStates[i].push_back( unif( rng ) ); } } const Clock::time_point start = Clock::now(); Clock::time_point timeout = Clock::time_point::max(); if ( options.count( "timeout" ) ) { size_t ms = 1000.0 * options[ "timeout" ].as< Numeric >(); timeout = Clock::now() + bc::milliseconds( ms ); } Numeric bestfopt = NumericMAX; State bestx; size_t i = sampleOffset; for ( ; i < nsamples; ) { Numeric finit = MaxVal; const State & xinit = initialStates[i]; std::cout << "[" << i << "] optimization starting -- bounds: " << fsinusoid.computeBounds() << std::endl; std::cout << "eps: " << eps << ", lipschitz: " << lipsch << ", step: " << eps / lipsch << ", finit: " << finit << std::endl << "xinit: " << xinit << std::endl; std::cout << "initial eval: " << eval( fsinusoid, xinit ) << std::endl; ++i; if ( options.count( "useDA" ) ) { throw "deterministic annealing not yet supported"; } else if ( options.count( "useCP" ) ) { throw "cutting plane not yet supported"; } State xopt; Numeric result = MaxVal; bool timedOut = false; if ( !isBCD ) { result = opt.optimize( &xinit, finit, timeout, true, start ); xopt = opt.getOptState(); opt.printStats(); timedOut = ( opt.wasStopped() || opt.timedOut() ); } else { timedOut = doBCDOpt( fsinusoid, ssopt, options, xinit, timeout, start, xopt, result ); } const Duration elapsed = Clock::now() - start; assert( !xopt.empty() ); std::cout << "sinusoid opt. result: " << result << std::endl << "\tat " << xopt << std::endl; Numeric actual = eval( fsinusoid, xopt ); std::cout << "actual eval: " << actual << " after " << elapsed.count() << " seconds " << std::endl; if ( actual < bestfopt ) { bestfopt = actual; bestx = xopt; } if ( timedOut ) { std::cout << "timeout detected..." << std::endl; break; break; } } }
void optimize_BA( BOOSTNS::random::mt19937 & rng, const po::variables_map & options, const string & bafile ) { // get optimization type from command line const string opttype = options[ "opttype" ].as< string >(); const bool isRDIS = ( opttype == "rdis" ); const bool isBCD = ( opttype == "bcd" ); // const bool isDisc = ( opttype == "discrete" ); // const bool isGrid = ( opttype == "grid" ); Numeric eps = 1.0, lipsch = 20; RDISOptimizer * popt = NULL; assert( isRDIS || isBCD /*|| isDisc || isGrid*/ ); eps = options.count( "epsilon" ) ? options[ "epsilon" ].as< Numeric >() : eps; lipsch = options.count( "lipschitz" ) ? options[ "lipschitz" ].as< Numeric >() : lipsch; if ( options.count( "timeAsSeed" ) && options[ "timeAsSeed" ].as< bool >() ) { rng.seed( std::time(NULL) + getpid() ); if ( options[ "sampleOffset"].as< size_t >() > 0 ) { std::cout << "WARNING: sampleOffset and timeAsSeed should not both be set" << std::endl; } } VariableCount ncams = options.count( "ncams" ) ? options["ncams"].as< size_t >() : 0; VariableCount npts = options.count( "npts" ) ? options["npts"].as< size_t >() : 0; // load and initialize the BA problem we'll optimize BundleAdjustmentFunction bafunc; if ( !bafunc.load( bafile, ncams, npts ) ) { std::cout << "loading file " << bafile << " failed -- exiting" << std::endl; return; } SubspaceOptimizer * pssopt; if ( options["useCGD"].as< bool >() ) { pssopt = new CGDSubspaceOptimizer( bafunc ); } else { pssopt = new LMSubspaceOptimizer( bafunc ); } SubspaceOptimizer & ssopt = *pssopt; //// CGDSubspaceOptimizer ssopt( bafunc ); // LMSubspaceOptimizer ssopt( bafunc ); ssopt.setParameters( options ); // create the optimizer and initialize it properly // popt = ( isRDIS ? // new OptimizerISGD( bafunc, ssopt, options ) : // new OptimizerDG( bafunc, options ) ); popt = new RDISOptimizer( bafunc, ssopt, options ); RDISOptimizer & opt = *popt; setSignalHandler( &opt ); // opt.setOptType( 3 ); // opt.setUseFiniteDiffs( true ); // opt.setUseLinearLB( false ); opt.setApproxFactors( options[ "approxfactors" ].as< bool >() ); opt.setUseCache( !isRDIS ); // opt.setUseExactCaching( isDisc ); const Numeric MaxVal = std::numeric_limits< Numeric >::max(); size_t sampleOffset = options[ "sampleOffset" ].as< size_t >(); size_t nsamples = options[ "nsamples" ].as< size_t >() + sampleOffset; std::vector< State > initialStates( nsamples ); if ( options.count( "randinit" ) && !options["randinit"].as< bool >() ) { sampleOffset = 0; nsamples = 1; initialStates.clear(); initialStates.push_back( bafunc.getInitialState() ); } else { // create all the random initial states up front (so they're consistent // across runs if the seed doesn't change) for ( size_t i = 0; i < nsamples; ++i ) { for ( VariableID vid = 0; vid < bafunc.getNumVars(); ++vid ) { NumericInterval si = bafunc.getVariables()[vid]->getDomain().getSamplingInterval(); BOOSTNS::random::uniform_real_distribution<> unif( si.lower(), si.upper() ); initialStates[i].push_back( unif( rng ) ); } // if ( i >= sampleOffset ) { // std::cout << "state " << i << ": " << initialStates[i] << std::endl; // } } } const Clock::time_point start = Clock::now(); Clock::time_point timeout = Clock::time_point::max(); if ( options.count( "timeout" ) ) { size_t ms = 1000.0 * options[ "timeout" ].as< Numeric >(); timeout = Clock::now() + bc::milliseconds( ms ); } Numeric bestfopt = NumericMAX; State bestx; size_t i = sampleOffset; for ( ; i < nsamples; ) { Numeric finit = MaxVal; const State & xinit = initialStates[i]; std::cout << "[" << i << "] optimization starting -- bounds: " << bafunc.computeBounds() << std::endl; std::cout << "eps: " << eps << ", lipschitz: " << lipsch << ", step: " << eps / lipsch << ", finit: " << finit << std::endl << "xinit: " << xinit << std::endl; std::cout << "initial eval: " << bafunc.eval( xinit ) << std::endl; if ( options.count( "useDA" ) ) { throw "deterministic annealing not yet supported"; } else if ( options.count( "useCP" ) ) { throw "cutting plane not yet supported"; } ++i; State xopt; Numeric result = MaxVal; bool timedOut = false; if ( !isBCD ) { if ( options["ignoreCamVars"].as< bool >() ) { for ( Variable * v : bafunc.getVariables() ) { if ( bafunc.getVarType( v->getID() ) == BundleAdjust::CAM_FOCAL || bafunc.getVarType( v->getID() ) == BundleAdjust::CAM_RDL_K1 || bafunc.getVarType( v->getID() ) == BundleAdjust::CAM_RDL_K2 ) { bafunc.getVariables()[i]->assign( bafunc.getInitialState()[i] ); } } } result = opt.optimize( &xinit, finit, timeout, true, start ); xopt = opt.getOptState(); opt.printStats(); timedOut = ( opt.wasStopped() || opt.timedOut() ); } else { if ( options["ignoreCamVars"].as< bool >() ) { std::cout << "IGNORECAMVARS OPTION NOT SUPPORTED FOR BCD" << std::endl; } timedOut = doBCDOpt( bafunc, ssopt, options, xinit, timeout, start, xopt, result ); } assert( !xopt.empty() ); const Duration elapsed = Clock::now() - start; std::cout << "bundle adjustment opt. result: " << result << std::endl << "\tat " << xopt << std::endl; Numeric actual = bafunc.eval( xopt ); std::cout << "actual eval: " << actual << " after " << elapsed.count() << " seconds" << std::endl; if ( actual < bestfopt ) { bestfopt = actual; bestx = xopt; } if ( timedOut ) { std::cout << "timeout detected..." << std::endl; break; } } const Duration elapsed = Clock::now() - start; std::cout << "----------------" << std::endl; std::cout << "best: " << bestfopt << " in " << ( i - sampleOffset ) << " samples after " << elapsed.count() << " seconds at state " << std::endl << bestx << std::endl; }