Exemple #1
1
/*------------------------------------------*/
int main ( int argc , char ** argv )
{
	
  // display:
  NOMAD::Display out ( NOMAD::rout );     //zhenghua
  out.precision ( NOMAD::DISPLAY_PRECISION_STD );
	

  std::string error;
  {
    // NOMAD initializations:
    NOMAD::begin ( argc , argv );

    // usage:
    if ( argc < 2 ) {
      NOMAD::display_usage ( out); //zhenghua
      NOMAD::end();
      return EXIT_FAILURE;
    }

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

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

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

    // display help on parameters if option '-h' has been specified:
    if ( opt == "-H" || opt == "-HELP" ) {
      p.help ( argc , argv );
      NOMAD::end();
      return EXIT_SUCCESS;
    }

	  // display developer help on parameters if option '-d' has been specified:
	  if ( opt == "-D" ) {
		  p.help ( argc , argv,true );
		  NOMAD::end();
		  return EXIT_SUCCESS;
	  }  
	  
	  
    // check the number of processess:
#ifdef USE_MPI
    if ( NOMAD::Slave::get_nb_processes() < 2 ) {
				NOMAD::rout << "ERROR: Incorrect command to run with MPI." << std::endl; //zhenghua
      NOMAD::display_usage ( out ); //zhenghua
      NOMAD::end();
      return EXIT_FAILURE;
    }
#endif
    
    try {

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

      // parameters check:
      p.check();

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

      // parameters display:
      if ( NOMAD::Slave::is_master() &&
       	   p.get_display_degree() == NOMAD::FULL_DISPLAY ) 
	out << std::endl
	    << NOMAD::open_block ( "parameters" ) << std::endl
	    << p
	    << NOMAD::close_block();

      // algorithm creation and execution:
      NOMAD::Mads mads ( p , NULL );
      if ( p.get_nb_obj() == 1 )
	mads.run();
      else
	mads.multi_run();

#ifdef MODEL_STATS
      mads.display_model_stats ( out );
#endif

    }
    catch ( std::exception & e ) {
      if ( NOMAD::Slave::is_master() ) {
	error = std::string ( "NOMAD has been interrupted: " ) + e.what();
	NOMAD::rout << std::endl << error << std::endl << std::endl;  //zhenghua
      }
    }
    
    NOMAD::Slave::stop_slaves ( out );
    NOMAD::end();
  }

#ifdef MEMORY_DEBUG
  NOMAD::display_cardinalities ( out );
#endif

  return ( error.empty() ) ? EXIT_SUCCESS : EXIT_FAILURE;
}
Exemple #2
0
/*--------------------------------------------------*/
void NOMAD::Eval_Point::display(const NOMAD::Display &out , bool in_block) const
{
    if (in_block)
    {

        std::ostringstream oss;
        oss << "#" << _tag;
        out << NOMAD::open_block(oss.str())
            << "x    = ( ";
        NOMAD::Point::display(out , " " , 2  , NOMAD::Point::get_display_limit());
        out << " )" << std::endl
            << "F(x) = [ ";
        _bb_outputs.display(out , " " , 2 , NOMAD::Point::get_display_limit());
        out << " ]" << std::endl;
        if (_h.is_defined())
            out << "h    = " << _h << std::endl;
        if (_f.is_defined())
            out << "f    = " << _f << std::endl;
        out.close_block();
    }
    else
    {
        display_tag(out);
        out << " x=( ";
        NOMAD::Point::display(out , " " , 2  , NOMAD::Point::get_display_limit());
        out << " ) F(x)=[ ";
        _bb_outputs.display(out , " " , 2 , NOMAD::Point::get_display_limit());
        out << " ]";
        if (_h.is_defined())
            out << " h=" << _h;
        if (_f.is_defined())
            out << " f=" << _f;
    }
}
/*---------------------------------------------------------*/
void NOMAD::Cache::display ( const NOMAD::Display & out ) const
{
    out << "number of cache points: " << size() << std::endl
    << "size in memory        : ";
    out.display_size_of ( _sizeof );
    out << std::endl << "cache file            : ";
    if ( _locked_file.empty() )
        out << "-" << std::endl;
    else
        out << _locked_file << std::endl;
    
#ifdef DEBUG
    int  nb = size();
    int cnt = 0;
    out << NOMAD::open_block ( "cache points" ) << std::endl;
    const NOMAD::Eval_Point * cur = begin();
    while ( cur ) {
        out << "point ";
        out.display_int_w ( ++cnt , nb );
        out << "/" << nb << ": ";
        cur->display_eval ( out , false );
        out << std::endl;
        cur = next();
    }
    out.close_block();
    
    // this display is repeated here as there can
    // be a lot of points displayed just before:
    out << "number of cache points: " << size() << std::endl
    << "size in memory        : ";
    out.display_size_of ( _sizeof );
    out << std::endl << "cache file            : ";
    if ( _locked_file.empty() )
        out << "-";
    else
        out << _locked_file;
    out << std::endl;
#endif
}
/*---------------------------------------------------------*/
void NOMAD::Cache::display_extern_pts ( const NOMAD::Display & out ) const
{
    int  nb = static_cast<int>(_extern_pts.size());
    int cnt = 0;
    std::list<const NOMAD::Eval_Point *>::const_iterator it , end = _extern_pts.end();
    for ( it = _extern_pts.begin() ; it != end ; ++it ) {
        out << "point ";
        out.display_int_w ( ++cnt , nb );
        out << "/" << nb << ": ";
        (*it)->display_eval ( out , false );
        out << std::endl;
    }
}
Exemple #5
0
/*--------------------------------------------*/
void NOMAD::TGP_Model::display_X(const NOMAD::Display &out           ,
                                 int                    display_limit) const
{
    if (_p == 0 || !_X)
    {
        out << "no interpolation points" << std::endl;
        return;
    }

    int i , j;
    int m  = _bbot.size();
    int i0 = (display_limit > 0) ? _p - display_limit : 0;
    NOMAD::Point x(_n) , bbo(m);

    out << NOMAD::open_block("interpolation points (X)");

    if (i0 > 0)
        out << "..." << std::endl;
    else if (i0 < 0)
        i0 = 0;

    for (i = i0 ; i < _p ; ++i)
    {

        for (j = 0 ; j < _n ; ++j)
            x[j] = _X[i][j];

        bbo = NOMAD::Point(m);
        if (_tgp_models)
            for (j = 0 ; j < m ; ++j)
                if (_tgp_models[j])
                    bbo[j] = (_tgp_models[j]->get_Z())[i];

        out << "#";
        out.display_int_w(i , _p);
        out << " x=(";
        x.display(out , " " , 15 , -1);
        out << " ) f(x)=[";
        bbo.display(out , " " , 15 , -1);
        out << " ]" << std::endl;
    }

    std::ostringstream oss;
    oss << "(size=" << _p << ")";
    out << NOMAD::close_block(oss.str()) << std::endl;
}
Exemple #6
0
/*--------------------------------------------------*/
void NOMAD::Eval_Point::display_tag(const NOMAD::Display &out) const
{
    out << "#";
    out.display_int_w(_tag , NOMAD::Eval_Point::_current_tag);
}
Exemple #7
0
void NOMAD::display_cardinalities ( const NOMAD::Display & out )
{

#ifdef USE_MPI
  if ( !NOMAD::Slave::is_master() )
    return;
#endif

  // compute the biggest int value for appropriate display width:
  int max = (NOMAD::Double::get_max_cardinality() > NOMAD::Point::get_max_cardinality())
    ? NOMAD::Double::get_max_cardinality() : NOMAD::Point::get_max_cardinality();
  if ( NOMAD::Direction::get_max_cardinality() > max )
    max = NOMAD::Direction::get_max_cardinality();
  if ( NOMAD::Set_Element<NOMAD::Eval_Point>::get_max_cardinality() > max )
    max = NOMAD::Set_Element<NOMAD::Eval_Point>::get_max_cardinality();
  if ( NOMAD::Set_Element<NOMAD::Signature>::get_max_cardinality() > max )
    max = NOMAD::Set_Element<NOMAD::Signature>::get_max_cardinality();
  if ( NOMAD::Cache_File_Point::get_max_cardinality() > max )
    max = NOMAD::Cache_File_Point::get_max_cardinality();
 
  // cardinalities display:
  // ----------------------
  out << std::endl
      << NOMAD::open_block ( "important objects in memory" );

  // NOMAD::Signature:
  out << "Signature              : ";
  out.display_int_w ( NOMAD::Signature::get_cardinality() , max );
  out << " (max=";
  out.display_int_w ( NOMAD::Signature::get_max_cardinality() , max );
  out << ")" << std::endl;

  // NOMAD::Double:
  out << "Double                 : ";
  out.display_int_w ( NOMAD::Double::get_cardinality() , max );
  out << " (max=";
  out.display_int_w ( NOMAD::Double::get_max_cardinality() , max );
  out << ")" << std::endl;

  // NOMAD::Point:
  out << "Point                  : ";
  out.display_int_w ( NOMAD::Point::get_cardinality() , max );
  out << " (max=";
  out.display_int_w ( NOMAD::Point::get_max_cardinality() , max );
  out << ")" << std::endl;

  // NOMAD::Direction:
  out << "Direction              : ";
  out.display_int_w ( NOMAD::Direction::get_cardinality() , max );
  out << " (max=";
  out.display_int_w ( NOMAD::Direction::get_max_cardinality() , max );
  out << ")" << std::endl;

  // Set_Element<Eval_Point>:
  out << "Set_Element<Eval_Point>: ";
  out.display_int_w (NOMAD::Set_Element<NOMAD::Eval_Point>::get_cardinality(), max);
  out << " (max=";
  out.display_int_w (NOMAD::Set_Element<NOMAD::Eval_Point>::get_max_cardinality(), max);
  out << ")" << std::endl;

  // Set_Element<NOMAD::Signature>:
  out << "Set_Element<Signature> : ";
  out.display_int_w (NOMAD::Set_Element<NOMAD::Signature>::get_cardinality(), max);
  out << " (max=";
  out.display_int_w (NOMAD::Set_Element<NOMAD::Signature>::get_max_cardinality(), max);
  out << ")" << std::endl;

  // NOMAD::Cache_File_Point:
  out << "Cache_File_Point       : ";
  out.display_int_w ( NOMAD::Cache_File_Point::get_cardinality() , max );
  out << " (max=";
  out.display_int_w ( NOMAD::Cache_File_Point::get_max_cardinality() , max );
  out << ")" << std::endl;

  out << NOMAD::close_block();
}
Exemple #8
0
/*--------------------------------------------*/
void NOMAD::TGP_Model::display(const NOMAD::Display &out) const
{
    if (!_error_str.empty())
    {
        out << "error with model" << std::endl;
        return;
    }

    int i , j;

    // fixed variables:
    out << "fixed_var = [ " << _fv << "]" << std::endl;
    out << "av_index  = ";
    if (_av_index)
    {
        out << "[ ";
        for (i = 0 ; i < _n0 ; ++i)
            out << _av_index[i] << " ";
        out << "]" << std::endl;
    }
    else
        out << "NULL" << std::endl;
    out << "fv_index  = ";
    if (_fv_index)
    {
        out << "[ ";
        for (i = 0 ; i < _n ; ++i)
            out << _fv_index[i] << " ";
        out << "]" << std::endl;
    }
    else
        out << "NULL" << std::endl;

    // bounds:
    out << "lb        = [ " << _lb << "]" << std::endl
        << "ub        = [ " << _ub << "]" << std::endl
        << std::endl;

    // display X:
    if (!_X)
        out << "X = NULL" << std::endl;
    else
    {
        out << "X = [";
        for (i = 0 ; i < _p ; ++i)
        {
            out << "\t";
            for (j = 0 ; j < _n ; ++j)
                out << std::setw(15) << _X[i][j] << " ";
            out << ((i==_p-1) ? "]" : ";") << std::endl;
        }
        out << "size(X)=" << _p << "x" << _n << std::endl << std::endl;
    }

    // display XX:
    if (!_XX)
        out << "XX = NULL" << std::endl;
    else
    {
        out << "XX = [";
        for (i = 0 ; i < _n_XX ; ++i)
        {
            out << "\t";
            for (j = 0 ; j < _n ; ++j)
                out << std::setw(15) << _XX[i][j] << " ";
            out << ((i==_n_XX-1) ? "]" : ";") << std::endl;
        }
        out << "size(XX)=" << _n_XX << "x" << _n << std::endl << std::endl;
    }

    // display models:
    out << std::endl;
    if (_tgp_models)
    {
        int m = _bbot.size();
        for (i = 0 ; i < m ; ++i)
        {
            if (_tgp_models[i])
            {
                std::ostringstream oss;
                oss << "model #" << i;
                out.open_block(oss.str());
                _tgp_models[i]->display(out);
                out.close_block();
            }
            else
                out << "model #" << i << ": NULL" << std::endl;
            out << std::endl;
        }
    }
    else
        out << "no models" << std::endl << std::endl;
}
Exemple #9
0
/*-------------------------------------------------------*/
void NOMAD::TGP_Model::display_X_errors(const NOMAD::Display &out)
{
    if (_p == 0 || !_X)
    {
        out << "no interpolation points" << std::endl;
        return;
    }

    int               i , j , m = _bbot.size();
    NOMAD::Point      min_err(m) , max_err(m) , avg_err(m,0.0) , sd_err(m,0.0);
    NOMAD::Eval_Point x(_n , m);
    double          **err = new double * [_p];

    for (i = 0 ; i < _p ; ++i)
    {

        err[i] = new double[m];

        for (j = 0 ; j < _n ; ++j)
            x[j] = _X[i][j];

        if (predict(x , true))
        {

            for (j = 0 ; j < m ; ++j)
                if (_tgp_models[j])
                {

                    // relative error (in %) for point #i and output #j:
                    err[i][j] = (x.get_bb_outputs()[j].rel_err((_tgp_models[j]->get_Z())[i])
                                 * 100.0).value();

                    // out << "f=" << (_tgp_models[j]->get_Z())[i] << " "
                    //     << "m=" << x.get_bb_outputs()[j] << " err=" << err[i][j]
                    //     << std::endl;

                    if (!min_err[j].is_defined() || err[i][j] < min_err[j].value())
                        min_err[j] = err[i][j];

                    if (!max_err[j].is_defined() || err[i][j] > max_err[j].value())
                        max_err[j] = err[i][j];

                    avg_err[j] += err[i][j];
                }
        }
        else
        {
            for (j = 0 ; j <= i ; ++j)
                delete [] err[j];
            delete [] err;
            out << "cannot predict interpolation errors ("
                << _error_str << ")" << std::endl;
            return;
        }
    }

    for (j = 0 ; j < m ; ++j)
        if (_tgp_models[j])
        {

            // compute the median error:
            NOMAD::Double med_err;
            {
                if (_p == 1)
                    med_err = err[0][j];
                else if (_p == 2)
                    med_err = (err[0][j] + err[1][j]) / 2.0;

                else
                {
                    std::multiset<double> sorted_errors;
                    for (i = 0 ; i < _p ; ++i)
                        sorted_errors.insert(err[i][j]);
                    std::multiset<double>::const_iterator it , end = sorted_errors.end();
                    --end;
                    for (it = sorted_errors.begin() , i = 0 ; it != end ; ++it , ++i)
                    {
                        if (i == (_p+1)/2-1)
                        {
                            med_err = *it;
                            if (_p%2==0)
                            {
                                ++it;
                                med_err = (med_err + *it) / 2.0;
                            }
                            break;
                        }
                    }
                }
            }

            // compute the mean and the standard deviation:
            avg_err[j] /= _p;
            for (i = 0 ; i < _p ; ++i)
                sd_err[j] += (avg_err[j] - err[i][j]).pow2();
            sd_err[j] = (sd_err[j] / _p).sqrt();

            // display:
            if (m > 1)
            {
                std::ostringstream oss;
                oss << "output #" << j;
                if (_tgp_models[j]->is_fixed())
                    oss << " (fixed)";
                else if (_tgp_models[j]->is_binary())
                    oss << " (binary)";
                out << NOMAD::open_block(oss.str());
            }

            out << "min   : ";
            min_err[j].display(out , "%6.2f");
            out << std::endl << "max   : ";
            max_err[j].display(out , "%6.2f");
            out << std::endl << "median: ";
            med_err.display(out , "%6.2f");
            out << std::endl << "mean  : ";
            avg_err[j].display(out , "%6.2f");
            out << std::endl << "sd    : ";
            sd_err[j].display(out , "%6.2f");
            out << std::endl;

            if (m > 1)
                out.close_block();
        }

    for (i = 0 ; i < _p ; ++i)
        delete [] err[i];
    delete [] err;
}
Exemple #10
0
/*----------------------------------------------------------------*/
void NOMAD::TGP_Model::display_Ds2x(const NOMAD::Display &out ,
                                    int          display_limit) const
{
    if (!_Ds2x || _n_XX == 0)
    {
        out << "matrix Ds2x has not been computed" << std::endl;
        return;
    }

    int            i , j , k , m = _bbot.size();
    NOMAD::Point *XX_pt;
    std::multiset<NOMAD::Model_Sorted_Point> pts;
    std::multiset<NOMAD::Model_Sorted_Point>::const_iterator it , end;

    for (i = 0 ; i < m ; ++i)
    {

        if (m > 1)
        {
            std::ostringstream oss;
            oss << "output #" << i;
            out << NOMAD::open_block(oss.str());
        }

        if (_Ds2x[i])
        {

            // 1. sort:
            for (j = 0 ; j < _n_XX ; ++j)
            {

                // construct a NOMAD::Point from matrix _XX:
                XX_pt = new NOMAD::Point(_fv);
                for (k = 0 ; k < _n0 ; ++k)
                    if (_av_index[k] >= 0)
                        (*XX_pt)[k] = _XX[j][_av_index[k]];

                // insert this point in the sorted list:
                pts.insert(NOMAD::Model_Sorted_Point(XX_pt , -_Ds2x[i][j]));
            }

            // 2. display:
            end = pts.end();
            for (j = 0 , it = pts.begin() ; it != end ; ++it , ++j)
            {

                if (display_limit <= 0 || j < display_limit)
                {
                    out << "x=( ";
                    it->get_point()->display(out , " " , 6 , -1);
                    out << " ) Ds2x=" << it->get_dist()*-1.0 << std::endl;
                }

                else if (j == display_limit)
                    out << "..." << std::endl;

                delete it->get_point();
            }

            pts.clear();
        }
        else
            out << "NULL" << std::endl;

        if (m > 1)
            out.close_block();
    }
}