void BE::initandstore(std::vector<Variable*> &variables, std::vector<Function*> &functions, std::vector<int> &order)
{
//pe=Double(1.0);
//vector<vector<Function*> > buckets (order.size());
buckets.resize(order.size());
hashtable.resize(order.size());
dirtyBitArrays.resize(order.size());
bucketfuncs.resize(order.size());
margVarList.resize(buckets.size());
this->order = order;
changedindexes.resize(order.size());
vector<int> var_in_pos(order.size());
for(int i=0;i<var_in_pos.size();i++) {
var_in_pos[order[i]]=i;
}
// First put the functions in the proper buckets
for(int i=0;i<functions.size();i++)
{
int pos=order.size();
//LogFunction* function=new LogFunction(*functions[i]);
if(functions[i]->variables().empty())
{
pe*=functions[i]->table()[0];
continue;
}
//Function* function=new Function();
//createFunction(*functions[i],*function);
Function* function = functions[i];
for(int j=0;j<functions[i]->variables().size();j++)
{
if(var_in_pos[functions[i]->variables()[j]->id()] < pos)
pos=var_in_pos[functions[i]->variables()[j]->id()];
}
assert(pos!=(int)order.size());
//check if exceeds ibound
if(buckets[pos].size()==0) {
buckets[pos].resize(1);
}
vector<Variable*> bucket_variables;
for(int j=0;j<buckets[pos][buckets[pos].size()-1].size();j++)
{
do_set_union(bucket_variables,buckets[pos][buckets[pos].size()-1][j]->variables(),bucket_variables,less_than_comparator_variable);
}
if(bucket_variables.size() > ibound) {
vector<Function*> tmpfuncs;
tmpfuncs.push_back(function);
buckets[pos].push_back(tmpfuncs);
} else {
buckets[pos][buckets[pos].size()-1].push_back(function);
}
}
int prval;
currPRVal = 1;
for(int i=0;i<buckets.size();i++)
{
if(buckets[i].empty())
continue;
for(int j=0;j<buckets[i].size();j++)
{
vector<Variable*> bucket_variables;
for(int k=0;k<buckets[i][j].size();k++) {
do_set_union(bucket_variables,buckets[i][j][k]->variables(),bucket_variables,less_than_comparator_variable);
}
vector<Variable*> bucket_variable;
bucket_variable.push_back(variables[order[i]]);
vector<Variable*> marg_variables;
do_set_difference(bucket_variables,bucket_variable,marg_variables,less_than_comparator_variable);
Function* function= new Function();
bucketfuncs[i].push_back(function);
vector<int> htable;
hashtable[i].push_back(htable);
//Function::multiplyAndMarginalize(marg_variables,buckets[i],*function,false);
Function::multiplyAndMarginalizeNew(marg_variables,buckets[i][j],*function,hashtable[i][hashtable[i].size()-1]);
if(i==buckets.size()-1) {
currPRVal *= get_norm_const(*function);
}
//cout<<bucket_variables.size()<<" "<<flush;
//cout<<"buck-vars.size ="<<bucket_variables.size()<<endl;
//cerr<<"Processing bucket "<<i<<" out of "<<buckets.size()<<endl;
if(function->variables().empty())
{
assert((int)function->table().size()==1);
//pe*=function->table()[0];
//currPRVal = function->table()[0];
//delete(function);
continue;
}
//prval = get_norm_const(*function);
//pe*=prval;
//Put the function in the appropriate bucket
int pos=order.size();
//function->print(cout);
//assert(!function->log_table.empty());
for(int k=0;k<function->variables().size();k++)
{
if(var_in_pos[function->variables()[k]->id()] < pos)
pos=var_in_pos[function->variables()[k]->id()];
}
assert(pos!=(int)order.size());
assert(pos > i);
int indextoadd=-1;
vector<Variable*> new_vars;
for(int k=0;k<buckets[pos].size();k++)
{
vector<Variable*> bucket_variables;
for(int m=0;m<buckets[pos][k].size();m++) {
do_set_union(bucket_variables,buckets[pos][k][m]->variables(),bucket_variables,less_than_comparator_variable);
}
do_set_union(bucket_variables,function->variables(),bucket_variables,less_than_comparator_variable);
if(bucket_variables.size() <= ibound) {
indextoadd = k;
new_vars = bucket_variables;
break;
}
}
if(indextoadd==-1) {
vector<Function*> tmp_f;
tmp_f.push_back(function);
buckets[pos].push_back(tmp_f);
} else {
buckets[pos][indextoadd].push_back(function);
}
}
}
for(int i=0;i<buckets.size();i++)
{
changedindexes[i].resize(buckets[i].size());
vector<Variable*> bucket_variable;
bucket_variable.push_back(variables[order[i]]);
for(int j=0;j<buckets[i].size();j++) {
vector<Variable*> bucket_variables;
for(int k=0;k<buckets[i][j].size();k++) {
do_set_union(bucket_variables,buckets[i][j][k]->variables(),bucket_variables,less_than_comparator_variable);
}
vector<Variable*> marg_variables;
do_set_difference(bucket_variables,bucket_variable,marg_variables,less_than_comparator_variable);
margVarList[i].push_back(marg_variables);
}
}
/*
for(int i=0;i<buckets.size();i++){
for(int j=0;j<buckets[i].size();j++){
if (buckets[i][j]!=NULL){
delete(buckets[i][j]);
}
}
}
buckets.clear();
*/
//BESample(variables,functions,order,buckets);
}
void BE::init(std::vector<Variable*> &variables, std::vector<Function*> &functions, std::vector<int> &order)
{
//pe=Double(1.0);
//vector<vector<Function*> > buckets (order.size());
vector<vector<Function*> > tmp_buckets(order.size());
this->order = order;
vector<int> var_in_pos(order.size());
for(int i=0;i<var_in_pos.size();i++) {
var_in_pos[order[i]]=i;
}
// First put the functions in the proper buckets
for(int i=0;i<functions.size();i++)
{
int pos=order.size();
//LogFunction* function=new LogFunction(*functions[i]);
if(functions[i]->variables().empty())
{
pe*=functions[i]->table()[0];
continue;
}
//Function* function=new Function();
//createFunction(*functions[i],*function);
Function* function = functions[i];
for(int j=0;j<functions[i]->variables().size();j++)
{
if(var_in_pos[functions[i]->variables()[j]->id()] < pos)
pos=var_in_pos[functions[i]->variables()[j]->id()];
}
assert(pos!=(int)order.size());
tmp_buckets[pos].push_back(function);
}
int prval;
for(int i=0;i<tmp_buckets.size();i++)
{
if(tmp_buckets[i].empty())
continue;
vector<Variable*> bucket_variables;
for(int j=0;j<tmp_buckets[i].size();j++)
{
do_set_union(bucket_variables,tmp_buckets[i][j]->variables(),bucket_variables,less_than_comparator_variable);
}
//cout<<bucket_variables.size()<<" "<<flush;
//cout<<"buck-vars.size ="<<bucket_variables.size()<<endl;
//cerr<<"Processing bucket "<<i<<" out of "<<buckets.size()<<endl;
// Compute variables required for marginalization
//cerr<<bucket_variables.size()<<endl;
vector<Variable*> bucket_variable;
bucket_variable.push_back(variables[order[i]]);
vector<Variable*> marg_variables;
do_set_difference(bucket_variables,bucket_variable,marg_variables,less_than_comparator_variable);
Function* function= new Function();
Function::multiplyAndMarginalize(marg_variables,tmp_buckets[i],*function,false);
if(i==tmp_buckets.size()-1) {
currPRVal = get_norm_const(*function);
}
if(function->variables().empty())
{
assert((int)function->table().size()==1);
//pe*=function->table()[0];
//currPRVal = function->table()[0];
//delete(function);
continue;
}
//prval = get_norm_const(*function);
//pe*=prval;
//Put the function in the appropriate bucket
int pos=order.size();
//function->print(cout);
//assert(!function->log_table.empty());
for(int j=0;j<function->variables().size();j++)
{
if(var_in_pos[function->variables()[j]->id()] < pos)
pos=var_in_pos[function->variables()[j]->id()];
}
assert(pos!=(int)order.size());
assert(pos > i);
tmp_buckets[pos].push_back(function);
}
/*
for(int i=0;i<buckets.size();i++){
for(int j=0;j<buckets[i].size();j++){
if (buckets[i][j]!=NULL){
delete(buckets[i][j]);
}
}
}
buckets.clear();
*/
//BESample(variables,functions,order,buckets);
}
void AO_COSP::buildSF(int curr_variable)
{
cout<<"BuildSF...."<<curr_variable<<" "<<flush;
int pos_curr_variable=mapped_order[curr_variable];
if(!run_ijgp[pos_curr_variable])
return;
jg->propagate();
vector<Variable*> all_variables;
for(int i=pos_curr_variable;i>-1;i--)
{
if(run_ijgp[i] && i!=pos_curr_variable)
return;
int var=order[i];
cout<<"Var = "<<var<<endl;
all_variables.push_back(gm->variables[var]);
sort(all_variables.begin(),all_variables.end(),less_than_comparator_variable);
int max=INVALID_VALUE;
int max_cluster_id=INVALID_VALUE;
for(int j=0;j<jg->nodes.size();j++)
{
bool found=false;
for(int k=0;k<jg->nodes[j]->variables().size();k++)
{
if(jg->nodes[j]->variables()[k]->id()==var)
{
found=true;
break;
}
}
if(found)
{
vector<Variable*> temp;
do_set_intersection(all_variables,jg->nodes[j]->variables(),temp,less_than_comparator_variable);
if((int)temp.size() > max)
{
max=(int)temp.size();
max_cluster_id=j;
}
}
}
if(max_cluster_id == INVALID_VALUE)
{
//jg->print(cout);
cout<<"invalid value for var = "<<var<<endl;
vector<Variable*> cond_vars;
CPT& cpt=sampling_functions[var];
cpt.variables().push_back(gm->variables[var]);
cpt.cond_variables()=vector<Variable*>();
cpt.setMargVariable(gm->variables[var]);
cpt.table()=vector<Double> (cpt.marg_variable()->domain_size());
for(int j=0;j<cpt.table().size();j++)
{
cpt.table()[j]=Double((double)1.0/(double)cpt.marg_variable()->domain_size());
}
continue;
}
assert(max_cluster_id > INVALID_VALUE);
//Form the function
vector<Variable*> temp;
do_set_intersection(all_variables,jg->nodes[max_cluster_id]->variables(),temp,less_than_comparator_variable);
vector<Variable*> marg_vars;
marg_vars.push_back(gm->variables[var]);
do_set_difference(temp,marg_vars,temp,less_than_comparator_variable);
CPT& cpt=sampling_functions[var];
jg->nodes[max_cluster_id]->getCF(temp,gm->variables[var],cpt);
}
}
AO_COS::AO_COS(GM* gm, vector<int>& order, JG* jg,vector<vector<Variable*> >& ancestors)
{
csp=new GM();
gm->convertToCN(*csp);
cp_algo=new DRC(*csp,jg->i_bound(),order);
//vector<Variable*> all_variables;
//cout<<"\t "<<gm->variables.size()<<endl;
sampling_functions=vector<CPT>(gm->variables.size());
for(int i=0;i<gm->variables.size();i++)
{
int var=order[order.size()-i-1];
vector<Variable*>& all_variables=ancestors[var];
//all_variables.push_back(gm->variables[var]);
//sort(all_variables.begin(),all_variables.end(),less_than_comparator_variable);
// Find the largest cluster in the join graph which has a non-zero intersection with all_variables
int max_cluster_id=INVALID_VALUE;
int max=INVALID_VALUE;
for(int j=0;j<jg->nodes.size();j++)
{
bool found=false;
for(int k=0;k<jg->nodes[j]->variables().size();k++)
{
if(jg->nodes[j]->variables()[k]->id()==var)
{
found=true;
//max_cluster_id=j;
break;
}
}
if(found)
{
//break;
//cout<<"Variable found "<<var<<"\n";
vector<Variable*> temp;
do_set_intersection(all_variables,jg->nodes[j]->variables(),temp,less_than_comparator_variable);
if((int)temp.size() > max)
{
max=(int)temp.size();
max_cluster_id=j;
}
}
}
//max_cluster_id=INVALID_VALUE;
if(max_cluster_id == INVALID_VALUE)
{
//jg->print(cout);
cout<<"invalid value for var = "<<var<<endl;
vector<Variable*> cond_vars;
CPT& cpt=sampling_functions[var];
cpt.variables().push_back(gm->variables[var]);
cpt.cond_variables()=vector<Variable*>();
cpt.setMargVariable(gm->variables[var]);
cpt.table()=vector<Double> (cpt.marg_variable()->domain_size());
for(int j=0;j<cpt.table().size();j++)
{
cpt.table()[j]=Double((double)1.0/(double)cpt.marg_variable()->domain_size());
}
//cpt.epsilonCorrection();
continue;
}
//cout<<i<<endl;
assert(max_cluster_id > INVALID_VALUE);
//Form the function
vector<Variable*> temp;
do_set_intersection(all_variables,jg->nodes[max_cluster_id]->variables(),temp,less_than_comparator_variable);
vector<Variable*> marg_vars;
marg_vars.push_back(gm->variables[var]);
do_set_difference(temp,marg_vars,temp,less_than_comparator_variable);
CPT& cpt=sampling_functions[var];
jg->nodes[max_cluster_id]->getCF(temp,gm->variables[var],cpt);
//Double epsilon(0.1);
//cpt.epsilonCorrection(epsilon);
}
}
JG::JG(GM& gm, int i_bound__, int num_iterations__, vector<int>& order,
JG_TYPE type) :
num_iterations_(num_iterations__), i_bound_(i_bound__), copy_of_gm(&gm) {
//printStacktrace();
vector<int> mapped_order(order.size());
for (int i = 0; i < order.size(); i++)
mapped_order[order[i]] = i;
assert(order.size()==gm.variables.size());
//cerr<<"Creating buckets\n";
// Create buckets
vector<vector<JGHelperFunction> > buckets(order.size());
for (int i = 0; i < gm.functions.size(); i++) {
int min_size = (int) gm.variables.size();
for (int j = 0; j < gm.functions[i]->variables().size(); j++) {
if (gm.functions[i]->variables()[j]->id() >= order.size()) {
gm.functions[i]->print();
exit(1);
}
if (mapped_order[gm.functions[i]->variables()[j]->id()] < min_size) {
min_size = mapped_order[gm.functions[i]->variables()[j]->id()];
}
}
if (min_size == (int) gm.variables.size()) {
for (int j = 0; j < gm.functions[i]->variables().size(); j++) {
cerr << gm.functions[i]->variables()[j]->id() << endl;
}
}
//cout<<min_size<<endl;
buckets[min_size].push_back(JGHelperFunction(
gm.functions[i]->variables(), INVALID_VALUE, gm.functions[i]));
//cout<<"\tAdded\n";
}
//cout<<"buckets created\n";
//Update i_bound
/*
int max_func_size=0;
for(int i=0;i<gm.functions.size();i++)
{
int domain_size=0;
domain_size=Variable::getDomainSize(gm.functions[i]->variables());
if(max_func_size < domain_size)
{
max_func_size=domain_size;
}
}
int avg_domain_size=0;
for(int i=0;i<gm.variables.size();i++)
{
avg_domain_size+=gm.variables[i]->domain_size();
}
avg_domain_size/=(int)gm.variables.size();
cerr<<avg_domain_size<<" "<<max_func_size<<" ";
int i_bound=1;
for(int i=0;i<(i_bound_-1);i++)
{
i_bound*=avg_domain_size;
}
i_bound*=(max_func_size);
*/
//max_cluster_size=i_bound;
cerr << "Dom size i-bound = " << i_bound() << endl;
int old_nodes = 0;
int id = 0;
// Run schematic mini-buckets
for (int i = 0; i < order.size(); i++) {
//cerr<<i<<endl;
// Form mini-buckets by using the first fill rule
for (int j = 0; j < buckets[i].size(); j++) {
bool found = false;
int loc = INVALID_VALUE;
for (int k = old_nodes; k < nodes.size(); k++) {
vector<Variable*> temp_variables;
do_set_union(buckets[i][j].variables, nodes[k]->variables(),
temp_variables, less_than_comparator_variable);
//int domain_size=Variable::getDomainSize(temp_variables);
//if((int)domain_size <= i_bound)
if ((int) temp_variables.size() <= i_bound()) {
found = true;
loc = k;
break;
}
}
// If not found create a mini-bucket
if (!found) {
nodes.push_back(addNode(type));
nodes[nodes.size() - 1]->id() = id;
id++;
nodes[nodes.size() - 1]->variables() = buckets[i][j].variables;
if (buckets[i][j].parent_id != INVALID_VALUE) {
//cout<<"F1\n";
//nodes[nodes.size()-1]->neighbors().push_back(nodes[buckets[i][j].parent_id]);
//nodes[buckets[i][j].parent_id]->neighbors().push_back(nodes[nodes.size()-1]);
JGEdge* edge = addEdge(nodes[nodes.size() - 1],
nodes[buckets[i][j].parent_id], type);
do_set_intersection(nodes[nodes.size() - 1]->variables(),
nodes[buckets[i][j].parent_id]->variables(),
edge->variables(), less_than_comparator_variable);
//edge->setNode1(nodes[nodes.size()-1]);
//edge->setNode2(nodes[buckets[i][j].parent_id]);
do_set_intersection(nodes[nodes.size() - 1]->variables(),
nodes[buckets[i][j].parent_id]->variables(),
edge->variables(), less_than_comparator_variable);
nodes[nodes.size() - 1]->edges().push_back(edge);
nodes[buckets[i][j].parent_id]->edges().push_back(edge);
} else {
//cout<<"F2\n";
nodes[nodes.size() - 1]->addFunction(*buckets[i][j].f);
}
} else {
do_set_union(buckets[i][j].variables, nodes[loc]->variables(),
nodes[loc]->variables(), less_than_comparator_variable);
if (buckets[i][j].parent_id != INVALID_VALUE) {
//cout<<"F3\n";
/*nodes[loc]->neighbors().push_back(nodes[buckets[i][j].parent_id]);
nodes[buckets[i][j].parent_id]->neighbors().push_back(nodes[loc]);*/
JGEdge* edge = addEdge(nodes[loc],
nodes[buckets[i][j].parent_id], type);
do_set_intersection(nodes[loc]->variables(),
nodes[buckets[i][j].parent_id]->variables(),
edge->variables(), less_than_comparator_variable);
//edge->setNode1(nodes[loc]);
//edge->setNode2(nodes[buckets[i][j].parent_id]);
do_set_intersection(nodes[loc]->variables(),
nodes[buckets[i][j].parent_id]->variables(),
edge->variables(), less_than_comparator_variable);
nodes[loc]->edges().push_back(edge);
nodes[buckets[i][j].parent_id]->edges().push_back(edge);
} else {
//cout<<"F4\n";
nodes[loc]->addFunction(*buckets[i][j].f);
}
}
}
vector<Variable*> curr_variable;
curr_variable.push_back(gm.variables[order[i]]);
// Connect the newly created nodes to each other
for (int j = old_nodes; j < (int) nodes.size() - 1; j++) {
//nodes[j]->neighbors().push_back(nodes[j+1]);
//nodes[j+1]->neighbors().push_back(nodes[j]);
JGEdge* edge = addEdge(nodes[j], nodes[j + 1], type);
//edge->setNode1(nodes[j]);
//edge->setNode2(nodes[j+1]);
edge->variables() = curr_variable;
nodes[j]->edges().push_back(edge);
nodes[j + 1]->edges().push_back(edge);
}
if (i < (int) order.size() - 1) {
for (int j = old_nodes; j < nodes.size(); j++) {
vector<Variable*> temp_variables;
do_set_difference(nodes[j]->variables(), curr_variable,
temp_variables, less_than_comparator_variable);
if (temp_variables.empty())
continue;
// Put the node in the appropriate bucket
int min_size = (int) gm.variables.size();
for (int k = 0; k < temp_variables.size(); k++) {
if (min_size > mapped_order[temp_variables[k]->id()]) {
min_size = mapped_order[temp_variables[k]->id()];
}
}
assert(min_size<(int)gm.variables.size());
//if(min_size >=(int) gm.variables.size())
// continue;
buckets[min_size].push_back(JGHelperFunction(temp_variables, j));
}
}
old_nodes = (int) nodes.size();
}
//print();
// Minimize edges
//minimize();
// update node ids
/*for(int i=0;i<nodes.size();i++)
{
nodes[i]->id()=i;
}*/
//print();
//// Set node and edge sizes
//for(int i=0;i<nodes.size();i++)
//{
// // Find domain size
// int domain_size=Variable::getDomainSize(nodes[i]->variables());
// nodes[i]->table()=vector<Double>(domain_size);
// for(int j=0;j<domain_size;j++)
// {
// nodes[i]->table()[j]=Double(1.0);
// }
// for(int j=0;j<nodes[i]->edges().size();j++)
// {
// int domain_size=Variable::getDomainSize(nodes[i]->edges()[j]->variables());
// nodes[i]->edges()[j]->message1()=vector<Double> (domain_size);
// nodes[i]->edges()[j]->message2()=vector<Double> (domain_size);
// for(int k=0;k<domain_size;k++)
// {
// nodes[i]->edges()[j]->message1()[k]=Double(1.0);
// nodes[i]->edges()[j]->message2()[k]=Double(1.0);
// }
// }
//}
//cerr<<"Now putting functions\n";
////reduce();
cout << "Join graph done\n";
}