Beispiel #1
0
/*---------------------------------------*/
void nomad_ ( int    * n       ,          // # of variables
	      int    * m       ,          // # of outputs (obj + m-1 constraints)
	      double * x       ,          // starting point (IN) / solution (OUT)
	      double * lb      ,          // lower bounds for each variable
	      double * ub      ,          // upper bounds
	      int    * max_bbe ,          // max # of evaluations (-1: not considered)
	      int    * display_degree ) { // display_degree (0-4; 0: no display)

  // display:
  Display out ( std::cout );
  out.precision ( DISPLAY_PRECISION_STD );

  try {

    int i;

    // parameters creation:
    Parameters p ( out );

    p.set_DIMENSION (*n);             // number of variables

    vector<bb_output_type> bbot (*m); // definition of output types:
    bbot[0] = OBJ;                    // first output : objective value to minimize
    for ( i = 1 ; i < *m ; ++i )      // other outputs: constraints cj <= 0
      bbot[i] = PB;
    p.set_BB_OUTPUT_TYPE ( bbot );

    // starting point and bounds:
    Point px0 ( *n );
    Point plb ( *n );
    Point pub ( *n );
    for ( i = 0 ; i < *n ; ++i ) {
      px0[i] = x [i];
      if ( lb[i] > -1e20 )
	plb[i] = lb[i];
      if ( ub[i] < 1e20 )
	pub[i] = ub[i];
    }
    p.set_X0          ( px0 );
    p.set_LOWER_BOUND ( plb );
    p.set_UPPER_BOUND ( pub );

	 p.set_LH_SEARCH ( 50, 0 );
	 p.set_INITIAL_MESH_SIZE(0.1);
    // maximum number of black-box evaluations:
    if ( *max_bbe > 0 )
      p.set_MAX_BB_EVAL ( *max_bbe );

    // display degree:
    p.set_DISPLAY_DEGREE ( *display_degree );

    // parameters validation:
    p.check();

    // custom evaluator creation:
    My_Evaluator ev ( p );

    // algorithm creation and execution:
    Mads mads ( p , &ev );
    mads.run();

    // get the solution:
    const Eval_Point * bf = mads.get_best_feasible();
    if ( bf )
      for ( i = 0 ; i < *n ; ++i )
	x[i] = (*bf)[i].value();
  }
  catch ( exception & e ) {
    cerr << "\nNOMAD has been interrupted (" << e.what() << ")\n\n";
  }
}
Beispiel #2
0
/*------------------------------------------*/
int main ( int argc , char ** argv ) {

  // display:
  Display out ( std::cout );
  out.precision ( DISPLAY_PRECISION_STD );

  // NOMAD initializations:
  begin ( argc , argv );

  try {

    // usage:
    if ( argc < 2 ) {
      display_usage ( cerr );
      return EXIT_SUCCESS;
    }

    // parameters file:
    string param_file_name = argv[1];
    string opt             = param_file_name;
    NOMAD::toupper(opt);

    // display version if option '-v' has been specified:
    if ( opt == "-V" ) {
      display_version ( out );
      return EXIT_SUCCESS;
    }

    // display info if option '-i' has been specified:
    if ( opt == "-I" || opt == "-INFO" ) {
      display_info  ( out );
      display_usage ( out );
      return EXIT_SUCCESS;
    }
    
    // parameters creation:
    Parameters p ( out );

    // display help on parameters if option '-h' has been specified:
    if ( opt == "-H" || opt == "-HELP" ) {
      p.help( (argc>2) ? argv[2] : "all" );
      return EXIT_SUCCESS;
    }

    // read parameters file:
    p.read ( param_file_name );

    // parameters check:
    p.check();

    // display NOMAD info:
    if ( p.get_display_degree() > 1 )
      display_info ( out );

    // parameters display:
    if ( p.get_display_degree() > 2 )
      out << endl << "parameters:" << endl << p << endl;

    // single-objective:
    if ( p.get_nb_obj() == 1 ) {

      // custom evaluator:
      My_Evaluator ev ( p );

      // algorithm creation and execution:
      Mads mads ( p , &ev );
      mads.run();

      // plot the last point:
      const Eval_Point * bf = mads.get_best_feasible();
      if ( bf )
	ev.plot_success ( mads.get_stats().get_bb_eval() , bf->get_f() );
    }

    // bi-objective:
    else {

      // custom evaluator:
      My_Multi_Obj_Evaluator ev ( p );

      // algorithm creation and execution:
      Mads mads ( p , &ev );
      mads.multi_run();
    }


  }
  catch ( exception & e ) {
    cerr << "\nNOMAD has been interrupted (" << e.what() << ")\n\n";
  }

  GUI_wait();


  Slave::stop_slaves ( out );
  end();

  return EXIT_SUCCESS;
}
Beispiel #3
0
/*----------------------------------------*/
void Master_Slaves::mads_run ( Cache & cache ) {

  const Eval_Point * best_feasible   = NULL;
  const Eval_Point * best_infeasible = NULL;
  Double             old_f           = INF;
  bool               stop_algo       = false;
  int                run_index       = 0;
  int                mesh_index      = 0;
  double             default_eps     = Double::get_epsilon();
  int                n               = _p.get_dimension();
  int              * free_vars       = new int [_ns];
  Point              x0 ( n ) , delta_0 , delta_min;

  /*---------------------*/
  /*      main loop      */
  /*---------------------*/
  while ( !stop_algo ) {
    
    best_feasible   = NULL;
    best_infeasible = NULL;

    // random SEED:
    _p.set_SEED ( get_pid() + run_index );

    // Halton seed:
    _p.set_HALTON_SEED ( 7999 + 99 * _rank + 20 * run_index );
    
    // first run:
    if ( run_index == 0 ) {

      // max number of evaluations for regular slaves:
      if ( _rank != 1 )
	_p.set_MAX_BB_EVAL ( _bbe );

      // display:
      // p.set_DISPLAY_STATS ( "process #" + itos(_rank) + " BBE OBJ" );
      // p.set_DISPLAY_DEGREE ( FULL_DISPLAY );
      _p.set_DISPLAY_DEGREE ( NO_DISPLAY );
    }

    // force the parameters check:
    _p.force_check_flag();

    /*------------------*/
    /*  pollster slave  */
    /*------------------*/
    if ( _rank == 1 ) {
     
      stop_type stop_reason = UNKNOWN_STOP_REASON;
    
      Mesh::get_delta_m ( delta_0             , 
			  _initial_mesh_size  ,
			  _mesh_update_basis  ,
			  _initial_mesh_index ,
			  mesh_index             );

      // we set a very small epsilon in order to accept
      // very small initial mesh sizes:
      Double::set_epsilon ( 1e-16 );

      if ( !check_delta ( delta_0 ) )
	stop_algo = true;
      
      else {

	// first run:
	if ( run_index == 0 ) {

	  // directions:
	  {
	    int  halton_seed   = _p.get_halton_seed();
	    bool use_orthomads = _p.has_orthomads_directions();	    
	    _p.reset_directions   ( halton_seed );
	    _p.set_DIRECTION_TYPE ( (use_orthomads) ? ORTHO_1 : LT_1 );
	  }
	
	  // cache search:
	  _p.set_CACHE_SEARCH               ( true  );
	  _p.set_OPPORTUNISTIC_CACHE_SEARCH ( false ); 
	}

	// other runs:
	else {
	
	  // stop_algo may be set to 'false' here:
	  receive_optimization_data ( stop_algo , x0 , old_f );

	  // starting point:
	  _p.reset_X0();
	  _p.set_X0 ( x0 );
	}

	if ( !stop_algo ) {

	  // pollster mesh:
	  _p.set_INITIAL_MESH_INDEX ( mesh_index );
	  _p.set_MAX_MESH_INDEX     ( mesh_index );
	  _p.set_INITIAL_MESH_SIZE  ( delta_0 );
	  _p.set_MIN_MESH_SIZE      ( delta_0 );

	  // check the parameters:
	  _p.check();
	  Double::set_epsilon ( default_eps );

	  Mads mads ( _p , NULL , NULL , &cache , NULL );
	  stop_reason     = mads.run();
	  best_feasible   = mads.get_best_feasible();
	  best_infeasible = mads.get_best_infeasible();

	  bool success = false;

	  if ( best_feasible ) {

	    success = (best_feasible->get_f() < old_f);
	    
	    if ( _debug )
	      _p.out() << "POLLSTER: ELL="
		       << mesh_index << " BBE="
		       << mads.get_stats().get_bb_eval()
		       << " OLD_F=" << old_f << " NEW_F="
		       << best_feasible->get_f()
		       << " SUCCESS=" << success << endl;
	  }

	  // pollster mesh update:
	  if ( success )
	    --mesh_index;
	  else 
	    ++mesh_index;
	}
      }

      send_optimization_result ( mesh_index      ,
				 stop_algo       ,
				 best_feasible   ,
				 best_infeasible ,
				 stop_reason       );
    }
    
    /*------------------*/
    /*  regular slaves  */
    /*------------------*/
    else {

      int i , j , pollster_mesh_index;

      receive_optimization_data ( stop_algo           ,
				  x0                  ,
				  old_f               ,
				  pollster_mesh_index ,
				  free_vars             );

      if ( _debug ) {
	_p.out() << "SLAVE #" << _rank
		 << ": OPTIM. DATA: [STOP=" << stop_algo
		 << "] [POLLSTER_MESH_INDEX=" << pollster_mesh_index
		 << "] [X0=" << x0 << " ] [f(X0)="
		 << old_f << "] [FREE VARS= ";
	for ( i = 0 ; i < _ns ; ++i )
	  _p.out() << free_vars[i] << " ";
	_p.out() << " ]" << endl;
      }

      if ( !stop_algo ) {

	// starting point:
	_p.reset_X0();
	_p.set_X0 ( x0 );

	// mesh of the regular slave:
	int ell_0 = 0;
	if ( pollster_mesh_index < ell_0 )
	  ell_0 = pollster_mesh_index;


	Mesh::get_delta_m ( delta_0             ,
			    _initial_mesh_size  ,
			    _mesh_update_basis  ,
			    _initial_mesh_index ,
			    ell_0                 );
	
	Mesh::get_delta_m ( delta_min           , 
			    _initial_mesh_size  ,
			    _mesh_update_basis  ,
			    _initial_mesh_index ,
			    pollster_mesh_index   );
	

	Double::set_epsilon ( 1e-16 );
	if ( !check_delta ( delta_0 ) || !check_delta ( delta_min ) )
	  stop_algo = true;
      
	else {

	  // mesh of the regular slave:
	  _p.set_INITIAL_MESH_INDEX ( ell_0               );
 	  _p.set_MAX_MESH_INDEX     ( pollster_mesh_index );
 	  _p.set_INITIAL_MESH_SIZE  ( delta_0             );
	  _p.set_MIN_MESH_SIZE      ( delta_min           );

	  // free variables:
	  {
	    _p.reset_fixed_variables();
	    bool fix_var;
	    for ( i = 0 ; i < n ; ++i ) {
	      fix_var = true;
	      for ( j = 0 ; j < _ns ; ++j )      
		if ( free_vars[j] == i ) {
		  fix_var = false;
		  break;
		}
	      if ( fix_var )
		_p.set_FIXED_VARIABLE ( i );
	    }
	  }

	  // check the parameters:
	  _p.check();
	  Double::set_epsilon ( default_eps );

	  // MADS run:
	  Mads mads ( _p , NULL , NULL , &cache , NULL );
	  mads.run();
	  best_feasible   = mads.get_best_feasible();
	  best_infeasible = mads.get_best_infeasible();
	  
	  if ( _debug && best_feasible ) {
	    _p.out() << "RANK #" << _rank << ": POLLSTER_ELL="
		     << pollster_mesh_index << " VARS = [";
	    for ( i = 0 ; i < _ns ; ++i )
	      _p.out() << free_vars[i] << " ";
	    _p.out() << " ] BBE=" << mads.get_stats().get_bb_eval()
		     << " OLD_F=" << old_f << " NEW_F="
		     << best_feasible->get_f()
		     << " SUCCESS="
		     << (best_feasible->get_f() < old_f)
		     << endl;
	  }
	}
      }

      {
	int       tmp1 = -1;
	bool      tmp2 = false;
	stop_type tmp3 = UNKNOWN_STOP_REASON;
	send_optimization_result ( tmp1            ,
				   tmp2            ,
				   best_feasible   ,
				   best_infeasible ,
				   tmp3              );
      }
    }
    
    // loop increment:
    ++run_index;
  }

  delete [] free_vars;
}
Beispiel #4
0
/*------------------------------------------*/
int main ( int argc , char ** argv ) {

  // display:
  Display out ( std::cout );
  out.precision ( DISPLAY_PRECISION_STD );

  // NOMAD initializations:
  begin ( argc , argv );

  try {

    // usage:
    if ( argc != 4 ) {
      cerr << "\nusage: multi param.txt nb_circles nb_mads_runs\n\n";
      return 1;
    }

    int NBC = atoi(argv[2] );

    if ( NBC < 4 ) {
      cerr << "\nthe number of circles must be > 3\n\n";
      return 1;
    }

    int   N = 2*NBC-3;
    //int   M = ( NBC * ( NBC + 1 ) - 8 ) / 2;
    int   M = 2;

    // list of x0 points (LH strategy is used):
    // -----------------

    vector<Point *> x0_pts;

    // srand ( static_cast<int> ( time(0) ) );
    srand(0);
    rand();

    int i;
    int nb_mads_runs = atoi ( argv[3] );

    LH_x0 ( N , nb_mads_runs , x0_pts );

    // read best_x.txt:
    ifstream fin ( "best_x.txt");

    if ( !fin.fail() )
      for ( int i = 0 ; i < N ; ++i )
        fin >> (*x0_pts[0])[i];

    fin.close();

    // display all starting points:
    out << endl;
    for ( int j = 0 ; j < nb_mads_runs ; ++j )
      out << "starting point # " << j << ": ( " << *x0_pts[j] << " )" << endl;
    out << endl;

    // parameters creation:
    // --------------------
    Parameters param ( out );

    param.set_DIMENSION (N);
    vector<bb_output_type> bbot (M+1);
    for ( i = 0 ; i < M ; ++i )
      bbot[i] = PB;
    bbot[M] = OBJ;
    param.set_BB_OUTPUT_TYPE ( bbot );

    Point lb ( N , LB );
    Point ub ( N , UB );
    param.set_LOWER_BOUND ( lb );
    param.set_UPPER_BOUND ( ub );

    param.read ( argv[1] );

    param.set_DISPLAY_DEGREE (0);

    param.set_X0 ( *x0_pts[0] );

    // parameters check:
    param.check();

    // out << param << endl;

    // custom evaluator creation:
    My_Evaluator ev ( param , NBC , M );

    const Eval_Point * cur_x;
    Point              best_x (N);
    Double             best_f = INF , worst_f = 0.0 , avg_f = 0.0;

    // MADS runs:
    // ----------
    int bbe = 0;
    i = 0;
    while ( true ) {

      // algorithm creation:
      Mads mads ( param , &ev );
      mads.run();

      bbe += mads.get_cache().size();

      // displays and remember the best point:
      out << "run #" << setw(2) << i << ": ";
      cur_x = mads.get_best_feasible();
      if ( cur_x ) {

	out << "f=" << cur_x->get_f() << endl;

        if ( cur_x->get_f() < best_f ) {

	  best_f = cur_x->get_f();
	  best_x = *cur_x;
	}

	if ( cur_x->get_f() > worst_f )
	  worst_f = cur_x->get_f();

	avg_f += cur_x->get_f();

      }
      else
	out << "NULL" << endl;

      if ( ++i == nb_mads_runs )
	break;

      // preparation of next run:
      mads.reset();
      param.reset_X0();
      param.set_X0 ( *x0_pts[i] );
      param.check();
    }

    // display the solution:
    out << endl << "bb eval : " << bbe << endl
	<< "best    : " << best_f;
    out << endl
	<< "worst   : " << worst_f << endl
	<< "solution: ";
    out << "x = ( ";
    best_x.display ( out , " " , -1 , -1 );
    out << " ) f(x) = " << best_f.value();
    out << endl << endl;

    ofstream fout ( "best_x.txt" );
    fout << setprecision(32);
    best_x.display ( fout , " " , -1 , -1 );
    fout.close();

    // delete x0 points:
    for ( i = 0 ; i < nb_mads_runs ; ++i )
      delete x0_pts[i];
  }
  catch ( exception & e ) {
    cerr << "\nNOMAD has been interrupted (" << e.what() << ")\n\n";
  }

  end();

  return EXIT_SUCCESS;
}