void
CPersistIDNet::TraverseSubobject(CPNLBase *pObj, CContext *pContext)
{
CIDNet *pModel = dynamic_cast<CIDNet*>(pObj);
pContext->Put(pModel->GetGraph(), "Graph");
TraverseSubobjectOfGrModel(pModel, pContext);
}
// ============================================================================
int main(int argc, char* argv[])
{
CIDNet* pIDNet;
#ifdef CREATE_LIMID_BY_FUNCTION
pIDNet = CreatePigsLIMID();
// pIDNet = CreateAppleJackLIMID();
// pIDNet = CreateOilLIMID();
// pIDNet = CreateLIMIDWith2DecInClick();
#endif
#ifdef LOAD_LIMID_BY_XML
pIDNet = LoadIDNetFromXML(argv[1]);
#endif
#ifdef IS_DUMP
pIDNet->GetGraph()->Dump();
#endif
CLIMIDInfEngine *pInfEng = NULL;
pInfEng = CLIMIDInfEngine::Create(pIDNet);
pInfEng->DoInference();
#ifdef IS_DUMP
pFactorVector *Vec = pInfEng->GetPolitics();
printf("\n=====================\nPolitics are:\n");
for (int i = 0; i < Vec->size(); i++)
{
(*Vec)[i]->GetDistribFun()->Dump();
}
float res = pInfEng->GetExpectation();
printf("\nNumber of iterations is %d", pInfEng->GetIterNum());
printf("\nExpectation is %.3f", res);
#endif
CLIMIDInfEngine::Release(&pInfEng);
delete pIDNet;
return 0;
}
CIDNet* CreateRandomIDNet(int num_nodes, int num_indep_nodes,
int max_size_family, int num_decision_nodes, int max_num_states_chance_nodes,
int max_num_states_decision_nodes, int min_utility, int max_utility,
bool is_uniform_start_policy)
{
PNL_CHECK_RANGES(num_decision_nodes, 1, num_nodes-1);
PNL_CHECK_LEFT_BORDER(max_num_states_chance_nodes, 1);
PNL_CHECK_LEFT_BORDER(max_num_states_decision_nodes, 1);
PNL_CHECK_LEFT_BORDER(max_utility, min_utility);
CGraph* pGraph =
CreateRandomAndSpecificForIDNetGraph(num_nodes, num_indep_nodes,
max_size_family);
if (!pGraph->IsDAG())
{
PNL_THROW(CInconsistentType, " the graph should be a DAG ");
}
if (!pGraph->IsTopologicallySorted())
{
PNL_THROW(CInconsistentType,
" the graph should be sorted topologically ");
}
if (pGraph->NumberOfConnectivityComponents() > 1)
{
PNL_THROW(CInconsistentType, " the graph should be linked ");
}
int i, j, k;
CNodeType *nodeTypes = new CNodeType [num_nodes];
intVector nonValueNodes(0);
intVector posibleDecisionNodes(0);
nonValueNodes.resize(0);
posibleDecisionNodes.resize(0);
for (i = 0; i < num_nodes; i++)
{
if (pGraph->GetNumberOfChildren(i) == 0)
{
nodeTypes[i].SetType(1, 1, nsValue);
}
else
{
nonValueNodes.push_back(i);
posibleDecisionNodes.push_back(i);
}
}
int ind_decision_node;
int num_states;
int index;
int node;
intVector neighbors(0);
neighborTypeVector neigh_types(0);
num_decision_nodes = (num_decision_nodes > posibleDecisionNodes.size()) ?
posibleDecisionNodes.size() : num_decision_nodes;
for (i = 0; (i < num_decision_nodes) && (posibleDecisionNodes.size()>0); i++)
{
ind_decision_node = rand() % posibleDecisionNodes.size();
node = posibleDecisionNodes[ind_decision_node];
num_states = GetRandomNumberOfStates(max_num_states_decision_nodes);
nodeTypes[node].SetType(1, num_states, nsDecision);
index = -1;
for (j = 0; j < nonValueNodes.size(); j++)
{
if (nonValueNodes[j] == node)
{
index = j;
break;
}
}
if (index != -1)
nonValueNodes.erase(nonValueNodes.begin() + index);
posibleDecisionNodes.erase(posibleDecisionNodes.begin() +
ind_decision_node);
pGraph->GetNeighbors(node, &neighbors, &neigh_types);
for (j = 0; j < neighbors.size(); j++)
{
index = -1;
for (k = 0; k < posibleDecisionNodes.size(); k++)
{
if (neighbors[j] == posibleDecisionNodes[k])
{
index = k;
break;
}
}
if (index != -1)
posibleDecisionNodes.erase(posibleDecisionNodes.begin() + index);
}
}
for (i = 0; i < nonValueNodes.size(); i++)
{
num_states = GetRandomNumberOfStates(max_num_states_chance_nodes);
nodeTypes[nonValueNodes[i]].SetType(1, num_states, nsChance);
}
int *nodeAssociation = new int[num_nodes];
for (i = 0; i < num_nodes; i++)
{
nodeAssociation[i] = i;
}
CIDNet *pIDNet = CIDNet::Create(num_nodes, num_nodes, nodeTypes,
nodeAssociation, pGraph);
pGraph = pIDNet->GetGraph();
CModelDomain* pMD = pIDNet->GetModelDomain();
CFactor **myParams = new CFactor*[num_nodes];
int *nodeNumbers = new int[num_nodes];
int **domains = new int*[num_nodes];
intVector parents(0);
for (i = 0; i < num_nodes; i++)
{
nodeNumbers[i] = pGraph->GetNumberOfParents(i) + 1;
domains[i] = new int[nodeNumbers[i]];
pGraph->GetParents(i, &parents);
for (j = 0; j < parents.size(); j++)
{
domains[i][j] = parents[j];
}
domains[i][nodeNumbers[i]-1] = i;
}
pIDNet->AllocFactors();
for (i = 0; i < num_nodes; i++)
{
myParams[i] = CTabularCPD::Create(domains[i], nodeNumbers[i], pMD);
}
float **data = new float*[num_nodes];
int size_data;
int num_states_node;
int num_blocks;
intVector size_nodes(0);
float belief, sum_beliefs;
for (i = 0; i < num_nodes; i++)
{
size_data = 1;
size_nodes.resize(0);
for (j = 0; j < nodeNumbers[i]; j++)
{
size_nodes.push_back(pIDNet->GetNodeType(domains[i][j])->GetNodeSize());
size_data *= size_nodes[j];
}
num_states_node = size_nodes[size_nodes.size() - 1];
num_blocks = size_data / num_states_node;
data[i] = new float[size_data];
switch (pIDNet->GetNodeType(i)->GetNodeState())
{
case nsChance:
{
for (j = 0; j < num_blocks; j++)
{
sum_beliefs = 0.0;
for (k = 0; k < num_states_node - 1; k++)
{
belief = GetBelief(1.0f - sum_beliefs);
data[i][j * num_states_node + k] = belief;
sum_beliefs += belief;
}
belief = 1.0f - sum_beliefs;
data[i][j * num_states_node + num_states_node - 1] = belief;
}
break;
}
case nsDecision:
{
if (is_uniform_start_policy)
{
belief = 1.0f / float(num_states_node);
for (j = 0; j < num_blocks; j++)
{
sum_beliefs = 0.0;
for (k = 0; k < num_states_node - 1; k++)
{
data[i][j * num_states_node + k] = belief;
sum_beliefs += belief;
}
data[i][j * num_states_node + num_states_node - 1] =
1.0f - sum_beliefs;
}
}
else
{
for (j = 0; j < num_blocks; j++)
{
sum_beliefs = 0.0;
for (k = 0; k < num_states_node - 1; k++)
{
belief = GetBelief(1.0f - sum_beliefs);
data[i][j * num_states_node + k] = belief;
sum_beliefs += belief;
}
belief = 1.0f - sum_beliefs;
data[i][j * num_states_node + num_states_node - 1] = belief;
}
}
break;
}
case nsValue:
{
for (j = 0; j < num_blocks; j++)
{
data[i][j] = float(GetUtility(min_utility, max_utility));
}
break;
}
}
}
for (i = 0; i < num_nodes; i++)
{
myParams[i]->AllocMatrix(data[i], matTable);
pIDNet->AttachFactor(myParams[i]);
}
delete [] nodeTypes;
delete [] nodeAssociation;
return pIDNet;
}