示例#1
0
/**
 * Description not yet available.
 * \param
 */
void laplace_approximation_calculator::generate_antithetical_rvs()
{
  // number of random vectors
  const ivector & itmp=(*num_local_re_array)(1,num_separable_calls);
  //const ivector & itmpf=(*num_local_fixed_array)(1,num_separable_calls);
  for (int i=2;i<=num_separable_calls;i++)
  {
    if (itmp(i) != itmp(i-1))
    {
      cerr << "At present can only use antithetical rv's when "
              "all separable calls are the same size" << endl;
      ad_exit(1);
    }
  }
  int n=itmp(1);
  int samplesize=num_importance_samples;

  // mesh size
  double delta=0.01;
  // maximum of distribution is near here
  double mid=sqrt(double(n-1));
  dmatrix weights(1,2*n,1,2);
  double spread=15;
  if (mid-spread<=0.001)
    spread=mid-0.1;
  double ssum=0.0;
  double x=0.0;
  double tmax=(n-1)*log(mid)-0.5*mid*mid;
  for (x=mid-spread;x<=mid+spread;x+=delta)
  {
    ssum+=exp((n-1)*log(x)-0.5*x*x-tmax);
  }
  double tsum=0;
  dvector dist(1,samplesize+1);
  dist.initialize();
  int is=0;
  int ii;
  for (x=mid-spread;x<=mid+spread;x+=delta)
  {
    tsum+=exp((n-1)*log(x)-0.5*x*x-tmax)/ssum*samplesize;
    int ns=int(tsum);
    for (ii=1;ii<=ns;ii++)
    {
      dist(++is)=x;
    }
    tsum-=ns;
  }
  if (is==samplesize-1)
  {
    dist(samplesize)=mid;
  }
  else if (is<samplesize-1)
  {
    cerr << "This can't happen" << endl;
    exit(1);
  }

  // get random numbers

  random_number_generator rng(rseed);
  if (antiepsilon)
  {
    if (allocated(*antiepsilon))
    {
      delete antiepsilon;
      antiepsilon=0;
    }
  }
  antiepsilon=new dmatrix(1,samplesize,1,n);
  dmatrix & M=*antiepsilon;
  M.fill_randn(rng);

  for (int i=1;i<=samplesize;i++)
  {
    M(i)=M(i)/norm(M(i));
  }
  int nvar=(samplesize-1)*n;
  independent_variables xx(1,nvar);
  ii=0;
  for (int i=2;i<=samplesize;i++)
  {
    for (int j=1;j<=n;j++)
    {
      xx(++ii)=M(i,j);
    }
  }

  fmmt1 fmc(nvar,5);
  //fmm fmc(nvar,5);
  fmc.noprintx=1;
  fmc.iprint=10;
  fmc.maxfn=2500;
  fmc.crit=1.e-6;

  double f;
  double fbest=1.e+50;;
  dvector g(1,nvar);
  dvector gbest(1,nvar);
  dvector xbest(1,nvar);

  gbest.fill_seqadd(1.e+50,0.);
  {
    while (fmc.ireturn>=0)
    {
      //int badflag=0;
      fmc.fmin(f,xx,g);
      if (fmc.ihang)
      {
        //int hang_flag=fmc.ihang;
        //double maxg=max(g);
        //double ccrit=fmc.crit;
        //int current_ifn=fmc.ifn;
      }
      if (fmc.ireturn>0)
      {
         f=fcomp1(xx,dist,samplesize,n,g,M);
         if (f < fbest)
         {
           fbest=f;
           gbest=g;
           xbest=xx;
         }
       }
     }
     xx=xbest;
  }
  ii=0;
  for (int i=2;i<=samplesize;i++)
  {
    for (int j=1;j<=n;j++)
    {
      M(i,j)=xx(++ii);
    }
  }
  for (int i=1;i<=samplesize;i++)
  {
    M(i)*=dist(i)/norm(M(i));
  }
}
示例#2
0
dvec *GSS::train() {
	
	double dtol = _dtol;
	double dstep = 3;
	double a = 1e-1;
	double absTol = 1e-3;
	int check = 0;
	
	std::vector<dvec*> *genSet = new std::vector<dvec*>;
	std::vector<double> *scoreList = new std::vector<double>;
	
	for (int i = 0 ; i < _dim ; i++) {
		dvec *basisElem = new dvec(_dim);
		basisElem->at(i) = 1;
		genSet->push_back(basisElem);
		scoreList->push_back(0);
		basisElem = new dvec(_dim);
		basisElem->at(i) = -1;
		genSet->push_back(basisElem);
		scoreList->push_back(0);
	}
	
	dvec *x;
	if(_init == NULL) x = this->makeRandomVector();
	else x = _init;
	
	double best = _ff->run(x);
	if(_verbose) std::cout << std::endl << "(GSS) Starting a new run at: " << best << std::endl << std::endl;
	
	while ( dstep > dtol ) {
		int success = 0;
		dvec xbest(_dim);
		
		if( dstep == 0.5 ) check = 0;
		
#pragma omp parallel for
		for ( unsigned int n=0 ; n < genSet->size(); n++ ) {
			/*int id = omp_get_thread_num();
#pragma omp critical
			std::cout << n << "," << id << std::endl;*/
			dvec *xn = new dvec(_dim);
			for(unsigned int i=0; i<x->size(); i++) {
				xn->at(i) = x->at(i) + genSet->at(n)->at(i) * dstep;
			}

			double score = _ff->run(xn);
			scoreList->at(n) = score;
#pragma omp critical
			{
				if((score + a*dstep*dstep) < best && fabs((score-best)/best) > absTol) {
					best = score;
					xbest.copy(xn);
					success = 1;
				}
			}

			delete xn;
		}

		if(!success) { //contract
			dstep *= 0.5;
			if( dstep <= dtol && check ) {
				dstep = 1;
			}
			if(_verbose) std::cout << "Contracting (" << dstep << "): " << best << std::endl;
		} else {
			if(_verbose == 2) std::cout << "(GSS) New best found: " << best << std::endl << xbest << std::endl;
			x->copy(xbest);
			check = 1;
		}
	}
	
	if(_verbose) std::cout << "(GSS) Result: " << best << std::endl << *x << std::endl;
	_best = best;
	
	for ( unsigned int n=0 ; n < genSet->size(); n++ ) {
		delete genSet->at(n);
	}
	
	delete genSet;
	delete scoreList;
	
	return x;
}