old_code_3.svn-base

Probabilistic graphical models in matlab.

/*
 DiscreteGraph * make_discrete_graph(int argc, char * const argv[])
 {
	 DiscreteGraph * g;
	 
	 if (argc > 1)
	 {
		 if (!read_graph_from_file (argv[1], g))
		 {
			 cout << "A parsing error has occured reading file: '" << argv[1] << "'." << endl;
			 return 0;
		 }
	 }
	 
	 else
	 {
		 g = make_random_graph <DiscreteGraph> (10, 0.2);
	 }	
	 
	 randomize_discrete_pairwise_symmetric_graph(*g);
	 
	 set_observations (*g);
	 //initialize_random_variables (*g);
	 
	 return g;
 }
 
 NPGraph * make_non_parametric_graph(int argc, char * const argv[])
 {
	 NPGraph * g;
	 
	 if (argc > 1)
	 {
		 if (!read_graph_from_file (argv[1], g))
		 {
			 cout << "A parsing error has occured reading file: '" << argv[1] << "'." << endl;
			 return 0;
		 }
	 }
	 
	 else
	 {
		 g = make_random_graph <NPGraph> (10, 0.2);
	 }	
	 
	 randomize_non_parametric_pairwise_graph(*g);
	 
	 //set_observations (*g);
	 initialize_random_variables (*g);
	 
	 return g;
 }
 */
 
 
 
// Full initialization

/*

template < class Graph>
void Experiment<Graph>::initialize()
{
	computed_errors.clear();	
	next_sample_time = sampling_interval;
	runs.clear();
	initialize_random_variables (g);
}

template < class Graph>
void Experiment<Graph>::run(const string reference_file, const string add_on)
{
	read_reference_means (reference_file, g);
	
	if (np_tree_gibbs)
	{
		
		for (current_run = 0; current_run < number_runs ; ++current_run)
		{
			runs.push_back(Run());
			
			non_parametric_tree_gibbs_sampler( g, single_running_time , running_particles, 1, using_timer);
			
			string st("tree_means_");
			st += add_on;
			
			export_computed_means (st, g);
			
			next_sample_time = sampling_interval;
			initialize_random_variables (g);
		}
		
		string st("tree_errors_");
		st += add_on;
		
		export_errors(st);

		initialize();
		
		set_observations (g);
		//set_special_mrf_observations (g);
	}

	
	if (metropolis_bool)
	{
		
		for (current_run = 0; current_run < number_runs ; ++current_run)
		{
			runs.push_back(Run());
			
			::metropolis(g, single_running_time, 0, using_timer);
		
			string st("metropolis_means_");
			st += add_on;
			
			export_computed_means (st, g);
			
			next_sample_time = sampling_interval;
			initialize_random_variables (g);
		}
		
		string st("metropolis_errors_");
		
		st += add_on;
		
		export_errors(st);
		initialize();
		set_observations (g);
		//set_special_mrf_observations (g);
	}

}



template < class Graph>
void Experiment<Graph>::set_ground_truth_method(const string s)
{
	string gr_tr = "metropolis";

if ( gr_tr.compare( s) == 0)
{
	ground_metropolis = true;
}

	gr_tr = "tree";

if ( gr_tr.compare( s ) == 0)
{
	ground_tree = true;
}

}

*/


/*
template < >
Experiment<DiscreteGraph>::Experiment( DiscreteGraph & a, const unsigned int b, const unsigned int running_time, const bool c, const bool d): g(a), number_runs(b), single_running_time(running_time), running_particles(100), burnoff(0), monitoring(true), np_tree_gibbs(c), metropolis_bool(d), ground_metropolis(false), ground_tree(false), ground_exact(false), using_timer(true)
{
	randomize_discrete_pairwise_symmetric_graph(g);

	set_observations (g);
	
	initialize_random_variables (g);
}


template <>
void Experiment< DiscreteGraph>::obtain_ground_truth(const string output_file_name, const unsigned int time)
{	
	bool monitoring_bkp (monitoring);
	
	monitoring = false;
	
	
	set_observations (g);
	initialize_random_variables (g);
	
	cout << "We get ground truth on discrete case" << endl; 
	
	if (ground_exact)
	{
		//get_exact_inference_by_combine(g);
		
		//message_passing(g);
	}
	
	
	if (ground_metropolis)
	{
		::gibbs_sampler(g, time, 0, true);
	}
	
	if (ground_tree)
	{
	non_parametric_tree_gibbs_sampler(g, time, 150, 1, true);
	}
	
	
	 
	export_computed_means (output_file_name, g);
	
	//display_variables_graph(g);
	
	initialize();
	
	monitoring = monitoring_bkp;

}

template <> void Experiment<DiscreteGraph>::record_errors()
{
		graph_traits<DiscreteGraph>::vertex_iterator u, u_end;
		
		double current_error(0.0);
		
		for (tie (u, u_end) = vertices (*g); u != u_end; ++u)
		{
			if (out_degree (*u, *g) != 1)
			{
				static_cast <DiscreteRandomVariable * > ( (*g)[*u]->get_random_variable())->compute_mean();
				current_error += static_cast <DiscreteRandomVariable * > ((*g)[*u]->get_random_variable())->get_mean_error ();
			}
		}
		
		// cout << "Error: " << current_error << endl;
		
		runs[current_run].record_errors(current_error);
	
}

template <>
void Experiment<DiscreteGraph>::run(const string reference_file, const string add_on)
{
	
	read_reference_means (reference_file, g);
	
	set_observations (g);
	initialize_random_variables (g);

	
	if (metropolis_bool)
	{
		
		for (current_run = 0; current_run < number_runs ; ++current_run)
		{
			runs.push_back(Run());
			
			::gibbs_sampler(g, single_running_time, burnoff, using_timer);
			
			string st("metropolis_means_");
			st += add_on;
			
			export_computed_means (st, g);
			
			next_sample_time = sampling_interval;
			initialize_random_variables (g);
		}
		
		string st("metropolis_errors_");
		
		st += add_on;
		
		export_errors(st);
		initialize();
		set_observations (g);
		//set_special_mrf_observations (g);
	}
	
	
	if (np_tree_gibbs)
	{
		
		for (current_run = 0; current_run < number_runs ; ++current_run)
		{
			runs.push_back(Run());
			
			non_parametric_tree_gibbs_sampler(g, single_running_time, running_particles, 5, using_timer);
			
			string st("tree_means_");
			st += add_on;
			
			export_computed_means (st, g);
			
			next_sample_time = sampling_interval;
			initialize_random_variables (g);
		}
		
		string st("tree_errors_");
		st += add_on;
		
		export_errors(st);
		
		initialize();
		
		set_observations (g);
		//set_special_mrf_observations (g);
	}

	
}

*/

/*

template < class Graph>
Experiment<Graph>::Experiment( Graph & a, const unsigned int b, const unsigned int running_time, const bool c, const bool d): g(a), number_runs(b), single_running_time(running_time), running_particles(100), sampling_interval(1.0), next_sample_time(sampling_interval), monitoring(true), np_tree_gibbs(c), metropolis_bool(d), ground_metropolis(false), ground_tree(false), using_timer(true)
{
	randomize_non_parametric_pairwise_graph(g);

	set_observations (g);
	
	initialize_random_variables (g);
}

template < class Graph>
void Experiment<Graph>::obtain_ground_truth(const string output_file_name, const unsigned int time)
{	
	bool monitoring_bkp (monitoring);
	
	monitoring = false;
	
	cout << "We are trying to get ground truth" << endl;
	
	if ( ground_metropolis)
	{
		metropolis (g, time, time/10, true);
		export_computed_means (output_file_name, g);
	}
	
	if ( ground_tree)
	{
		non_parametric_tree_gibbs_sampler (g, time, 75, 25, true);
		export_computed_means (output_file_name, g);
	}
	
	initialize();
	
	//set_special_mrf_observations (g);
	set_observations (g);
	monitoring = monitoring_bkp;
}

template < class Graph>
void Experiment<Graph>::export_errors(const string output_file_name)
{	
	unsigned int errors_size = runs.front().errors.size();
	
	cout << "Errors size: " << errors_size << endl;
	
	for ( vector <Run>::iterator it = runs.begin(); it != runs.end(); ++it)
	{
		assert (it->errors.size() == errors_size );
	}
	
	computed_errors.resize( errors_size, 0.0);
	
	for (unsigned int i = 0; i < errors_size; ++i)
	{
		
		for ( vector <Run>::iterator it = runs.begin(); it != runs.end(); ++it)
		{
			computed_errors[i] += it->errors[i];
		}
		
		computed_errors[i] = computed_errors[i] /  runs.size();
		
	}
	
	ofstream output_file (output_file_name.c_str());	
	
	for (unsigned int i = 0; i < computed_errors.size(); ++i)
	{
		output_file << i  << " " << computed_errors[i] << "\n";
	}
	
	output_file << endl;
}

*/

		//computed_errors[i] = computed_errors[i] /  runs.size();
	//}
	

	/*
	for (unsigned int i = 0; i < computed_errors.size(); ++i)
	{
		output_file  << computed_errors[i] << " ";
	}
	
	output_file << ")" << endl;
	*/