Beispiel #1
0
int main(int argv, char** argc){
	// parse arguments
  dd::CmdParser cmd_parser = parse_input(argv, argc);

  // run gibbs sampler
  if(cmd_parser.app_name == "gibbs"){
    gibbs(cmd_parser);
  } else if (cmd_parser.app_name == "em") {
      em(cmd_parser);
  }

}
void SimulatedAnnealingInference::PerformInference() {
	// Initialize best solution
	unsigned int var_count =
		static_cast<unsigned int>(fg->Cardinalities().size());
	primal_best.resize(var_count);
	primal_best_energy = std::numeric_limits<double>::infinity();

	// Initialize Gibbs sampler
	GibbsSampler gibbs(fg);

	// Calculate exponential multiplier alpha such that T(sa_steps)=Tfinal.
	double alpha = std::exp(std::log(Tfinal / T0) /
		static_cast<double>(sa_steps));
	gibbs.SetInverseTemperature(1.0 / T0);
	gibbs.Sweep(1);

	// Perform annealing
	for (unsigned int k = 1; k <= sa_steps; ++k) {
		// Logarithmic schedule (Geman and Geman)
		// temperature = anneal_C / std::log(1.0 + static_cast<double>(k));

		// Exponential schedule
		double temperature = T0 * std::pow(alpha, static_cast<double>(k));
		gibbs.SetInverseTemperature(1.0 / temperature);
		double cur_energy = fg->EvaluateEnergy(gibbs.State());
		double energy_delta;
		for (unsigned int vi = 0; vi < var_count; ++vi) {
			unsigned int new_state = gibbs.SampleSite(vi, energy_delta);
			gibbs.SetState(vi, new_state);
			cur_energy += energy_delta;
			if (cur_energy < primal_best_energy) {
				// Re-evaluate for numerical reasons
				cur_energy = fg->EvaluateEnergy(gibbs.State());
				if (cur_energy < primal_best_energy) {
					primal_best_energy = cur_energy;
					std::copy(gibbs.State().begin(), gibbs.State().end(),
						primal_best.begin());
				}
			}
		}

	}
}
int main() {
  const double HBC = Constants::HBCFmMeV;
  const double PI = Constants::Pi;
  
	//std::vector<double> Ska35S2009{-172.485, 172.087, -1767.71, 0.282732, 
  //    12899.2, 0.413266, 0.35};
  double Tmin = 1.e-2;
  double Tmax = 2.e2;
  EOSSkyrme eos = EOSSkyrme::FromErmalSkyrme(ErmalSkyrmeParameters::Ska35S2009);
  EOSSingleNucleus eosSN(eos, false, Tmin, Tmax);
  GibbsPhaseConstruct gibbs(eos, false, Tmin, Tmax);
  EOSElectron eosEl; 
   
  // Read in pre-calculated EoS data 
  std::ifstream ifs("eos_data.arx");
  if (ifs) {
    boost::archive::binary_iarchive ia(ifs); 
    ia >> gibbs;
    ifs.close();
  } else {
Beispiel #4
0
void gibbs(dd::CmdParser & cmd_parser){

  // number of NUMA nodes
  int n_numa_node = numa_max_node() + 1;
  // number of max threads per NUMA node
  int n_thread_per_numa = (sysconf(_SC_NPROCESSORS_CONF))/(n_numa_node);

  // get command line arguments
  std::string fg_file = cmd_parser.fg_file->getValue();

  std::string weight_file = cmd_parser.weight_file->getValue();
  std::string variable_file = cmd_parser.variable_file->getValue();
  std::string factor_file = cmd_parser.factor_file->getValue();
  std::string edge_file = cmd_parser.edge_file->getValue();
  std::string meta_file = cmd_parser.meta_file->getValue();

  std::string output_folder = cmd_parser.output_folder->getValue();

  int n_learning_epoch = cmd_parser.n_learning_epoch->getValue();
  int n_samples_per_learning_epoch = cmd_parser.n_samples_per_learning_epoch->getValue();
  int n_inference_epoch = cmd_parser.n_inference_epoch->getValue();

  double stepsize = cmd_parser.stepsize->getValue();
  double stepsize2 = cmd_parser.stepsize2->getValue();
  // hack to support two parameters to specify step size
  if (stepsize == 0.01) stepsize = stepsize2;
  double decay = cmd_parser.decay->getValue();

  int n_datacopy = cmd_parser.n_datacopy->getValue();
  double reg_param = cmd_parser.reg_param->getValue();
  double reg1_param = cmd_parser.reg1_param->getValue();
  bool is_quiet = cmd_parser.quiet->getValue();
  bool sample_evidence = cmd_parser.sample_evidence->getValue();
  int burn_in = cmd_parser.burn_in->getValue();
  bool learn_non_evidence = cmd_parser.learn_non_evidence->getValue();

  Meta meta = read_meta(fg_file); 

  if (is_quiet) {
    std::cout << "Running in quiet mode..." << std::endl;
  } else {
    std::cout << std::endl;
    std::cout << "#################MACHINE CONFIG#################" << std::endl;
    std::cout << "# # NUMA Node        : " << n_numa_node << std::endl;
    std::cout << "# # Thread/NUMA Node : " << n_thread_per_numa << std::endl;
    std::cout << "################################################" << std::endl;
    std::cout << std::endl;
    std::cout << "#################GIBBS SAMPLING#################" << std::endl;
    std::cout << "# fg_file            : " << fg_file << std::endl;
    std::cout << "# edge_file          : " << edge_file << std::endl;
    std::cout << "# weight_file        : " << weight_file << std::endl;
    std::cout << "# variable_file      : " << variable_file << std::endl;
    std::cout << "# factor_file        : " << factor_file << std::endl;
    std::cout << "# meta_file          : " << meta_file << std::endl;
    std::cout << "# output_folder      : " << output_folder << std::endl;
    std::cout << "# n_learning_epoch   : " << n_learning_epoch << std::endl;
    std::cout << "# n_samples/l. epoch : " << n_samples_per_learning_epoch << std::endl;
    std::cout << "# n_inference_epoch  : " << n_inference_epoch << std::endl;
    std::cout << "# stepsize           : " << stepsize << std::endl;
    std::cout << "# decay              : " << decay << std::endl;
    std::cout << "# regularization     : " << reg_param << std::endl;
    std::cout << "# l1 regularization     : " << reg1_param << std::endl;
    std::cout << "################################################" << std::endl;
    std::cout << "# IGNORE -s (n_samples/l. epoch). ALWAYS -s 1. #" << std::endl;
    std::cout << "# IGNORE -t (threads). ALWAYS USE ALL THREADS. #" << std::endl;
    std::cout << "################################################" << std::endl;


    std::cout << "# nvar               : " << meta.num_variables << std::endl;
    std::cout << "# nfac               : " << meta.num_factors << std::endl;
    std::cout << "# nweight            : " << meta.num_weights << std::endl;
    std::cout << "# nedge              : " << meta.num_edges << std::endl;
    std::cout << "################################################" << std::endl;
  }

  // run on NUMA node 0
  numa_run_on_node(0);
  numa_set_localalloc();

  // load factor graph
  dd::FactorGraph fg(meta.num_variables, meta.num_factors, meta.num_weights, meta.num_edges);
  fg.load(cmd_parser, is_quiet);
  dd::GibbsSampling gibbs(&fg, &cmd_parser, n_datacopy, sample_evidence, burn_in, learn_non_evidence);

  // number of learning epochs
  // the factor graph is copied on each NUMA node, so the total epochs =
  // epochs specified / number of NUMA nodes
  int numa_aware_n_learning_epoch = (int)(n_learning_epoch/n_numa_node) + 
                            (n_learning_epoch%n_numa_node==0?0:1);

  // learning
  /*gibbs.learn(numa_aware_n_learning_epoch, n_samples_per_learning_epoch,
    stepsize, decay, reg_param, reg1_param, meta_file, is_quiet);*/
  gibbs.learn(numa_aware_n_learning_epoch, n_samples_per_learning_epoch,
              stepsize, decay, reg_param, reg1_param, is_quiet);

  // dump weights
  gibbs.dump_weights(is_quiet);

  // number of inference epochs
  int numa_aware_n_epoch = (int)(n_inference_epoch/n_numa_node) + 
                            (n_inference_epoch%n_numa_node==0?0:1);

  // inference
  gibbs.inference(numa_aware_n_epoch, is_quiet);
  gibbs.aggregate_results_and_dump(is_quiet);


  // print weights from inference result
  for(long t=0;t<fg.n_weight;t++) {
      std::cout<<fg.infrs->weight_values[t]<<std::endl;
  }

  // print weights from factor graph
  std::cout<<"PRINTING WEIGHTS FROM WEIGHT VARIABLE"<<std::endl;
  for(long t=0;t<fg.n_weight;t++) {
      std::cout<<fg.weights[t].weight<<std::endl;
  }
}
Beispiel #5
0
void em(dd::CmdParser & cmd_parser){

  // number of NUMA nodes
  int n_numa_node = numa_max_node() + 1;
  // number of max threads per NUMA node
  int n_thread_per_numa = (sysconf(_SC_NPROCESSORS_CONF))/(n_numa_node);

  // get command line arguments
  std::string fg_file = cmd_parser.fg_file->getValue();

  std::string weight_file = cmd_parser.weight_file->getValue();
  std::string variable_file = cmd_parser.variable_file->getValue();
  std::string factor_file = cmd_parser.factor_file->getValue();
  std::string edge_file = cmd_parser.edge_file->getValue();
  std::string meta_file = cmd_parser.meta_file->getValue();

  std::string output_folder = cmd_parser.output_folder->getValue();

  int n_learning_epoch = cmd_parser.n_learning_epoch->getValue();
  int n_samples_per_learning_epoch = cmd_parser.n_samples_per_learning_epoch->getValue();
  int n_inference_epoch = cmd_parser.n_inference_epoch->getValue();

  double stepsize = cmd_parser.stepsize->getValue();
  double stepsize2 = cmd_parser.stepsize2->getValue();
  // hack to support two parameters to specify step size
  if (stepsize == 0.01) stepsize = stepsize2;
  double decay = cmd_parser.decay->getValue();

  int n_datacopy = cmd_parser.n_datacopy->getValue();
  double reg_param = cmd_parser.reg_param->getValue();
  double reg1_param = cmd_parser.reg1_param->getValue();
  bool is_quiet = cmd_parser.quiet->getValue();
  bool check_convergence = cmd_parser.check_convergence->getValue();
  bool sample_evidence = cmd_parser.sample_evidence->getValue();
  int burn_in = cmd_parser.burn_in->getValue();
  int n_iter = cmd_parser.n_iter->getValue();
  int wl_conv = cmd_parser.wl_conv->getValue();
  int delta = cmd_parser.delta->getValue();
  bool learn_non_evidence = cmd_parser.learn_non_evidence->getValue();

  Meta meta = read_meta(fg_file);

  if (is_quiet) {
    std::cout << "Running in quiet mode..." << std::endl;
  } else {
    std::cout << std::endl;
    std::cout << "#################MACHINE CONFIG#################" << std::endl;
    std::cout << "# # NUMA Node        : " << n_numa_node << std::endl;
    std::cout << "# # Thread/NUMA Node : " << n_thread_per_numa << std::endl;
    std::cout << "################################################" << std::endl;
    std::cout << std::endl;
    std::cout << "#################GIBBS SAMPLING#################" << std::endl;
    std::cout << "# fg_file            : " << fg_file << std::endl;
    std::cout << "# edge_file          : " << edge_file << std::endl;
    std::cout << "# weight_file        : " << weight_file << std::endl;
    std::cout << "# variable_file      : " << variable_file << std::endl;
    std::cout << "# factor_file        : " << factor_file << std::endl;
    std::cout << "# meta_file          : " << meta_file << std::endl;
    std::cout << "# output_folder      : " << output_folder << std::endl;
    std::cout << "# n_learning_epoch   : " << n_learning_epoch << std::endl;
    std::cout << "# n_samples/l. epoch : " << n_samples_per_learning_epoch << std::endl;
    std::cout << "# n_inference_epoch  : " << n_inference_epoch << std::endl;
    std::cout << "# stepsize           : " << stepsize << std::endl;
    std::cout << "# decay              : " << decay << std::endl;
    std::cout << "# regularization     : " << reg_param << std::endl;
    std::cout << "# l1 regularization     : " << reg1_param << std::endl;
    std::cout << "################################################" << std::endl;
    std::cout << "# IGNORE -s (n_samples/l. epoch). ALWAYS -s 1. #" << std::endl;
    std::cout << "# IGNORE -t (threads). ALWAYS USE ALL THREADS. #" << std::endl;
    std::cout << "################################################" << std::endl;


    std::cout << "# nvar               : " << meta.num_variables << std::endl;
    std::cout << "# nfac               : " << meta.num_factors << std::endl;
    std::cout << "# nweight            : " << meta.num_weights << std::endl;
    std::cout << "# nedge              : " << meta.num_edges << std::endl;
    std::cout << "################################################" << std::endl;
  }

  // run on NUMA node 0
  numa_run_on_node(0);
  numa_set_localalloc();

  // load factor graph
  dd::FactorGraph fg(meta.num_variables, meta.num_factors, meta.num_weights, meta.num_edges);
  fg.load(cmd_parser, is_quiet);
  dd::GibbsSampling gibbs(&fg, &cmd_parser, n_datacopy, sample_evidence, burn_in, learn_non_evidence);

  // Initialize EM instance
  dd::ExpMax expMax(&fg, &gibbs, wl_conv, delta, check_convergence);

  // number of inference epochs
  int numa_aware_n_epoch;
  int numa_aware_n_learning_epoch;

  // EM init -- run Maximzation (semi-supervised learning)

  // Maximization step
  numa_aware_n_learning_epoch = (int)(n_learning_epoch/n_numa_node) +
                                (n_learning_epoch%n_numa_node==0?0:1);
  expMax.maximization(numa_aware_n_learning_epoch, n_samples_per_learning_epoch,
                      stepsize, decay, reg_param, reg1_param, is_quiet);
  /*expMax.maximization(numa_aware_n_learning_epoch, n_samples_per_learning_epoch,
                      stepsize, decay, reg_param, reg1_param, meta_file, is_quiet);*/

  while (!expMax.hasConverged && n_iter > 0) {

    // Expectation step
    numa_aware_n_epoch = (int)(n_inference_epoch/n_numa_node) +
                         (n_inference_epoch%n_numa_node==0?0:1);
    expMax.expectation(numa_aware_n_epoch,is_quiet);


    // Maximization step
    numa_aware_n_learning_epoch = (int)(n_learning_epoch/n_numa_node) +
                                  (n_learning_epoch%n_numa_node==0?0:1);
    /*expMax.maximization(numa_aware_n_learning_epoch, n_samples_per_learning_epoch,
                        stepsize, decay, reg_param, reg1_param, meta_file, is_quiet);*/
    expMax.maximization(numa_aware_n_learning_epoch, n_samples_per_learning_epoch,
                        stepsize, decay, reg_param, reg1_param, is_quiet);

    //Decrement iteration counter
    n_iter--;
  }

  expMax.dump_weights(is_quiet);
  expMax.aggregate_results_and_dump(is_quiet);


}
int main() {
  double HBC = Constants::HBCFmMeV;
  
  //EOSSkyrme eos;
	//std::vector<double> Ska35S2009{-172.485, 172.087, -1767.71, 0.282732, 
  //    12899.2, 0.413266, 0.35};
  EOSSkyrme eos = EOSSkyrme::FromErmalSkyrme(ErmalSkyrmeParameters::Ska35S2009);
  GibbsPhaseConstruct gibbs(eos, false);
  
  // Calculat self bound liquid densities
  std::ofstream selfBoundFile; 
  selfBoundFile.open("self_bound.out");
  selfBoundFile << "# [1] Nb " << std::endl;
  selfBoundFile << "# [2] T (MeV) " << std::endl;
  selfBoundFile << "# [3] Ye " << std::endl;
  selfBoundFile << "# [4] P " << std::endl;
  selfBoundFile << "# [5] Mun " << std::endl;
  selfBoundFile << "# [6] Mup " << std::endl;
  selfBoundFile << "# [7] Nn (low density) " << std::endl;
  selfBoundFile << "# [8] Np (low density) " << std::endl;
  selfBoundFile << "# [9] P (low density) " << std::endl;
  
  std::ofstream outFile; 
  outFile.open("gibbs_boundary.out");
  outFile << "#[1] Nn_1 (fm^-3)" << std::endl; 
  outFile << "#[2] Nn_2 (fm^-3)" << std::endl; 
  outFile << "#[3] Np_1 (fm^-3)" << std::endl; 
  outFile << "#[4] Np_2 (fm^-3)" << std::endl; 
  outFile << "#[5] P (MeV fm^-3)" << std::endl; 
  outFile << "#[6] Mun (MeV fm^-3)" << std::endl; 
  outFile << "#[7] Mup (MeV fm^-3)" << std::endl; 
  outFile << "#[8] T (MeV)" << std::endl; 
  
  double TStart = 0.1/HBC; 
  double TEnd = 0.01/HBC;
  auto phaseBoundFull = gibbs.FindFixedTPhaseBoundary(TStart);
  std::cout << phaseBoundFull.size() << std::endl;
   
  for (double lT = log10(TStart); lT>=log10(TEnd); lT -= 1.0) {
    double T = pow(10.0, lT);
    std::cout << T * HBC << " "; 
    
    //auto selfBound = gibbs.SelfBoundPoints(T);  
    //for (auto &ptpair : selfBound) {
    //  auto pt = ptpair.second;
    //  selfBoundFile << pt.Nb() << " " << pt.T()*HBC << " " << pt.Ye() << " "  
    //      << pt.P() << " " << pt.Mun() << " " << pt.Mup() << " "; 
    //  auto eosPts = 
    //      eos.FromMuAndT(EOSData::InputFromTMunMup(pt.T(), pt.Mun(), pt.Mup()));
    //  if (eosPts.size()>0) {
    //    selfBoundFile << eosPts[0].Np() << " " << eosPts[0].Nn() << " " 
    //        << eosPts[0].P(); 
    //  }
    //  selfBoundFile << std::endl;
    //} 
    //selfBoundFile << std::endl; 
   
    // Calculate phase boundaries
    auto phaseBound = phaseBoundFull; 
    if (T < TStart)  
      phaseBound = gibbs.FindFixedTPhaseBoundary(T, phaseBoundFull); 
    
    std::cout << phaseBound.size() << std::endl; 
    if (phaseBound.size() > 0) {
      // Write out the phase boundary
      for (auto &a : phaseBound) {
        outFile << (a.first).Nn() << " "; 
        outFile << (a.second).Nn() << " "; 
        outFile << (a.first).Np() << " "; 
        outFile << (a.second).Np() << " ";
        outFile << (a.first).P()*HBC << " ";
        outFile << (a.first).Mun()*HBC << " ";
        outFile << (a.first).Mup()*HBC << " ";
        outFile << (a.first).T()*HBC << std::endl;
      }
      outFile << std::endl; 
    } 
  }  
   
  selfBoundFile.close();
  outFile.close(); 
  return 0;
}
int main() 
{
  struct stat buffer;   
  double HBC = Constants::HBCFmMeV;
  std:: array<std::string,5> Skyrmenames09 = {"Ska35s2009.xml","Ska25s2009.xml","SKT109.xml","SKT209.xml","SKT309.xml"};
  std:: array<std::string,5> Skyrmenames1 = {"Ska35s201.xml","Ska25s201.xml","SKT11.xml","SKT21.xml","SKT31.xml"};
  std:: string eos_dataName_ermal("eos_data_"),eos_dataName_saturation("eos_data_sat_"), eos_dataName; 
  for (int counter = 0; counter < 5; counter++)
  {
	eos_dataName=eos_dataName_ermal+Skyrmenames09[counter];
	if((stat (eos_dataName.c_str(), &buffer) != 0))
	{
			EOSSkyrme eos = EOSSkyrme::FromErmalSkyrme(ErmalSkyrmeParameters::ErmalAllSkyrme09[counter]);
			EOSSingleNucleus gibbs(eos);
			std::ofstream ofs(eos_dataName.c_str()); 
			boost::archive::text_oarchive oa(ofs); 
			oa << gibbs; 
			ofs.close();
	}
	eos_dataName=eos_dataName_ermal+Skyrmenames1[counter];
	if((stat (eos_dataName.c_str(), &buffer) != 0))
	{
			EOSSkyrme eos = EOSSkyrme::FromErmalSkyrme(ErmalSkyrmeParameters::ErmalAllSkyrme1[counter]);
			EOSSingleNucleus gibbs(eos);
			std::ofstream ofs(eos_dataName.c_str()); 
			boost::archive::text_oarchive oa(ofs); 
			oa << gibbs; 
			ofs.close();
	}
	eos_dataName=eos_dataName_saturation+Skyrmenames09[counter];
	if((stat (eos_dataName.c_str(), &buffer) != 0))
	{
			EOSSkyrme eos = EOSSkyrme::FromSaturation(SaturationSkyrmeParameters::SaturationSkyrme09[counter]);
			EOSSingleNucleus gibbs(eos);
			std::ofstream ofs(eos_dataName.c_str()); 
			boost::archive::text_oarchive oa(ofs); 
			oa << gibbs; 
			ofs.close();
	}
	eos_dataName=eos_dataName_saturation+Skyrmenames1[counter];
	if((stat (eos_dataName.c_str(), &buffer) != 0))
	{
			EOSSkyrme eos = EOSSkyrme::FromSaturation(SaturationSkyrmeParameters::SaturationSkyrme1[counter]);
			EOSSingleNucleus gibbs(eos);
			std::ofstream ofs(eos_dataName.c_str()); 
			boost::archive::text_oarchive oa(ofs); 
			oa << gibbs; 
			ofs.close();
	}
  }
  //GibbsPhaseConstruct reloadGibbs(eos, false); 
  //
  //std::ifstream ifs("eos_data.xml");
  //boost::archive::text_iarchive ia(ifs); 
  //ia >> reloadGibbs;
  //ifs.close();
  
   
   
  return 0;
}