int factor_compute_params(const gsl_vector_int* f, const gsl_vector* x,
double y, double* params) {
//TBD
int s;
int i;
double y2 = y * y;
int f_size = factor_size(f);
int* a = (int*) malloc(f->size * sizeof(int));
if (!a) {
return -1;
}
*params = 1.0;
for (s = 1; s < f_size; s++) {
factor_scalar_to_vector(f, s, a);
for (i = 0; i < f->size; i++) {
if (a[i]) {
a[i]--;
params[s] = params[factor_vector_to_scalar(f, a)]
* gsl_vector_get(x, i);
continue;
}
}
}
free(a);
return 0;
}
int factorTest(void) {
int i;
gsl_vector_int* f = gsl_vector_int_alloc(3);
if (!f) {
return -1;
}
gsl_vector_int_set(f, 0, 2);
gsl_vector_int_set(f, 1, 4);
gsl_vector_int_set(f, 2, 5);
int n = 3;
int m = factor_size(f);
printf("m:%d\n", m);
int a[3];
int s = 1;
factor_scalar_to_vector(f, s, a);
printf("s:%d\n", s);
for (i = 0; i < n; i++) {
printf("a[%d]:%d\n", i, a[i]);
}
s = factor_vector_to_scalar(f, a);
printf("s:%d\n\n", s);
s = 39;
factor_scalar_to_vector(f, s, a);
printf("s:%d\n", s);
for (i = 0; i < n; i++) {
printf("a[%d]:%d\n", i, a[i]);
}
s = factor_vector_to_scalar(f, a);
printf("s:%d\n\n", s);
s = 25;
factor_scalar_to_vector(f, s, a);
printf("s:%d\n", s);
for (i = 0; i < n; i++) {
printf("a[%d]:%d\n", i, a[i]);
}
s = factor_vector_to_scalar(f, a);
printf("s:%d\n\n", s);
return 0;
}
int measurement_compute_params(Measurement* meas, const gsl_vector_int* f,
double* allparams) {
int i = 0;
double* params;
int f_size;
int m_size;
if ((m_size = measurement_size(meas))) {
f_size = factor_size(f);
allparams = (double*) malloc(f_size * m_size * sizeof(double));
if (allparams) {
while (meas) {
params = &allparams[i];
factor_compute_params(f, meas->x, meas->y, params);
meas->params = params;
i += f_size;
meas = meas->next;
}
} else
return -1;
}
return m_size;
}
/////////////////////////////////////////////////////////////////////////
// Load the UAI file. Each factor as a different vertex
void loadUAIfile(graphlab::distributed_control& dc, graph_type& graph, string graph_file)
{
// Not sure why this is needed
dc.barrier();
// Open file
ifstream in(graph_file.c_str());
//CHECK(in.good(),"Could not open file: "+graph_file);
CHECK(in.good());
// Read type of network
string name;
in >> name;
//CHECK(name.compare("MARKOV")==0, "Only Markov networks are supported. Are you sure this is a typeUAI energy file?");
CHECK(name.compare("MARKOV")==0);
// Read size of graph
int nnodes, nfactors;
in >> nnodes;
//CHECK(nnodes>0, "No. of nodes can't be negative. Are you sure this is a typeUAI energy file?");
CHECK(nnodes>0);
// Read node cardinalities
vector<int> cardinalities(nnodes,0);
int cardinality_i, sum_of_cardinalities = 0;
for (int i = 0; i != nnodes; ++i)
{
in >> cardinality_i;
cardinalities[i] = cardinality_i;
sum_of_cardinalities += cardinality_i;
//cout << cardinalities[i] << " ";
//CHECK(in.good(), "Could not finish reading cardinalities. Are you sure this is a typeUAI energy file?");
CHECK(in.good());
}
// Read no. of factors
in >> nfactors;
//factor_size.resize(nfactors); factor_id.resize(nfactors);
vector<int> factor_size(nfactors,0); //vector<int> factor_id(nfactors,0);
vector< vector<int> > factor_memb; factor_memb.resize(nfactors);
int temp1, temp2;
// Loop and read factor members
for (int i=0; i!=nfactors; ++i)
{
in >> temp1;
factor_size[i] = temp1;
factor_memb[i].resize(temp1);
for (int j=0; j!=temp1; ++j)
{
in >> temp2;
factor_memb[i][j] = temp2;
}
//CHECK(in.good(), "Could not finish reading cardinalities. Are you sure this is a typeUAI energy file?");
CHECK(in.good());
}
if (opts.verbose > 0)
cout
<< "Finished Reading UAI-Preamble:"
<< " #Nodes = " << nnodes
<< ", #Factors = "<< nfactors
<< ", Average Cardinality = " << double(sum_of_cardinalities)/nfactors
<< "\n";
// Now read factor potentials
for (int i=0; i!=nfactors; ++i)
{
int cardprod; double potential_value; //, energy;
in >> cardprod;
vertex_data vdata;
vdata.nvars = factor_size[i];
if (vdata.nvars > 1) {
vdata.degree = vdata.nvars; // Factor degree.
}
vdata.cards.resize(factor_size[i]);
vdata.neighbors.resize(factor_size[i]);
vector<edge_data> edata(factor_size[i]);
int cardprod2 = 1;
for (int j=0; j!=factor_size[i]; ++j)
{
vdata.cards[j] = cardinalities[factor_memb[i][j]];
vdata.neighbors[j] = factor_memb[i][j]; // afm (check if this was intended!)
cardprod2 *= vdata.cards[j];
// Also create edge structs here
if (factor_size[i]>1)
{
edata[j].varid = factor_memb[i][j];
edata[j].card = cardinalities[edata[j].varid];
edata[j].multiplier_messages.setZero(edata[j].card);
edata[j].local_messages.setZero(edata[j].card);
}
}
//CHECK_EQ(cardprod, cardprod2, "Incorrectly sized factor");
CHECK_EQ(cardprod, cardprod2);
// Read factor potentials
vdata.potentials.resize(cardprod);
for (int k = 0; k != cardprod; ++k)
{
in >> potential_value;
//energy = Potential2Energy(potential_value);
vdata.potentials[k] = log10(potential_value);
}
//CHECK(in.good(), "Could not finish reading factor tables. Are you sure this is a typeUAI energy file?");
CHECK(in.good());
// allocate factors evenly to different machines.
if (i%dc.numprocs() != dc.procid())
continue;
// If all is well, add vertex and edges
graph.add_vertex(i,vdata);
if (factor_size[i] > 1) // if not a unary, add edges to unaries
for (int j=0; j!=factor_size[i]; ++j)
graph.add_edge(i,edata[j].varid,edata[j]);
if (opts.verbose > 1)
{
cout << "Machine #" << dc.procid() << ", Vertex Id = " << i
<< " with " << vdata.nvars << " variables.";
if (factor_size[i] > 1)
{
cout << ", Edges = ";
for (int j=0; j!=factor_size[i]; ++j)
cout << ", (" << i << "," << edata[j].varid << ")";
}
cout << "\n";
cout << "potential: " << vdata.potentials << "\n";
}
} // End of reading factors
dc.barrier();
} // end of loading UAI file
/////////////////////////////////////////////////////////////////////////
// Load the UAI file. Each factor as a different vertex
void loadUAIfile(graphlab::distributed_control& dc, graph_type& graph, string graph_file, int& nodes)
{
// Not sure why this is needed
dc.barrier();
// Open file
ifstream in(graph_file.c_str());
//CHECK(in.good(),"Could not open file: "+graph_file);
CHECK(in.good());
// Read type of network
string name;
in >> name;
//CHECK(name.compare("MARKOV")==0, "Only Markov networks are supported. Are you sure this is a typeUAI energy file?");
CHECK(name.compare("MARKOV")==0);
// Read size of graph
int nnodes, nfactors;
in >> nnodes;
nodes = nnodes;
//CHECK(nnodes>0, "No. of nodes can't be negative. Are you sure this is a typeUAI energy file?");
CHECK(nnodes>0);
// Read node cardinalities
vector<int> cardinalities(nnodes,0);
int cardinality_i, sum_of_cardinalities = 0;
for (int i = 0; i != nnodes; ++i)
{
in >> cardinality_i;
cardinalities[i] = cardinality_i;
sum_of_cardinalities += cardinality_i;
//CHECK(in.good(), "Could not finish reading cardinalities. Are you sure this is a typeUAI energy file?");
CHECK(in.good());
}
int vid = 0;
if(opts.algorithm != 0){
for(int i = 0; i < nnodes; i++){ //temporary .. put condition
vertex_data vdata;
vdata.factor_type = VAR;
vdata.nvars = 1;
vdata.cards.resize(1, cardinalities[i]);
vdata.potentials.setZero(cardinalities[i]);
vdata.beliefs.setConstant(cardinalities[i], 0.5);
graph.add_vertex(vid, vdata);
vid++;
}
}
// Read no. of factors
in >> nfactors;
//factor_size.resize(nfactors); factor_id.resize(nfactors);
vector<int> factor_size(nfactors,0); //vector<int> factor_id(nfactors,0);
vector< vector<int> > factor_memb; factor_memb.resize(nfactors);
int temp1, temp2;
// Loop and read factor members
for (int i=0; i!=nfactors; ++i)
{
in >> temp1;
factor_size[i] = temp1;
factor_memb[i].resize(temp1);
for (int j=0; j!=temp1; ++j)
{
in >> temp2;
factor_memb[i][j] = temp2;
}
//CHECK(in.good(), "Could not finish reading cardinalities. Are you sure this is a typeUAI energy file?");
CHECK(in.good());
}
if (opts.verbose > 1)
cout
<< "Finished Reading UAI-Preamble:"
<< " #Nodes = " << nnodes
<< ", #Factors = "<< nfactors
<< ", Average Cardinality = " << double(sum_of_cardinalities)/nfactors
<< "\n";
// Now read factor potentials
for (int i=0; i!=nfactors; ++i)
{
int cardprod; double potential_value; //, energy;
in >> cardprod;
vertex_data vdata;
vdata.nvars = factor_size[i];
if (vdata.nvars > 1) {
vdata.degree = vdata.nvars; // Factor degree.
vdata.factor_type = DENSE;
}
else {
vdata.degree = 1; // Factor degree.
vdata.factor_type = XOR;
}
vdata.cards.resize(factor_size[i]);
vdata.neighbors.resize(factor_size[i]);
vector<edge_data> edata(factor_size[i]);
vector<int> varid(factor_size[i]);
vector<int> card(factor_size[i]);
int cardprod2 = 1;
for (int j=0; j!=factor_size[i]; ++j)
{
vdata.cards[j] = cardinalities[factor_memb[i][j]];
vdata.neighbors[j] = factor_memb[i][j]; // afm (check if this was intended!)
cardprod2 *= vdata.cards[j];
// Also create edge structs here
//if (factor_size[i]>1)
// {
varid[j] = factor_memb[i][j];
card[j] = cardinalities[varid[j]];
edata[j].multiplier_messages.setZero(card[j]);
edata[j].local_messages.setZero(card[j]);
edata[j].potentials.setZero(card[j]);
// }
}
//CHECK_EQ(cardprod, cardprod2, "Incorrectly sized factor");
CHECK_EQ(cardprod, cardprod2);
// Read factor potentials
vdata.potentials.resize(cardprod);
vdata.beliefs.resize(cardprod);
int x_offset = 0;
for(int x=0; x< vdata.nvars; x++){
for(int y=0; y<vdata.cards[x]; y++){
vdata.beliefs[x_offset+y] = 1.0/vdata.cards[x];
}
x_offset += vdata.cards[x];
}
vdata.factor_beliefs.setConstant(cardprod, 1.0/cardprod);
for (int k = 0; k != cardprod; ++k)
{
in >> potential_value;
//energy = Potential2Energy(potential_value);
vdata.potentials[k] = log10(potential_value) ;
}
//CHECK(in.good(), "Could not finish reading factor tables. Are you sure this is a typeUAI energy file?");
CHECK(in.good());
vdata.potentials.maxCoeff(&vdata.best_configuration);
// allocate factors evenly to different machines.
if (i%dc.numprocs() != dc.procid())
continue;
// If all is well, add vertex and edge
graph.add_vertex(vid ,vdata);
if (factor_size[i] > 1 || opts.algorithm > 0) // if not a unary, add edges to unaries
for (int j=0; j!=factor_size[i]; ++j)
graph.add_edge(vid,varid[j],edata[j]);
//after adding everything increment vertex id
vid++;
if (opts.verbose > 1)
{
cout << "Machine #" << dc.procid() << ", Vertex Id = " << i
<< " with " << vdata.nvars << " variables.";
if (factor_size[i] > 1)
{
cout << ", Edges = ";
for (int j=0; j!=factor_size[i]; ++j)
cout << ", (" << i << "," << varid[j] << ")";
}
cout << "\n";
cout << "potential: " << vdata.potentials << "\n";
}
} // End of reading factors
dc.barrier();
} // end of loading UAI file
