void CDynamicGraphicalModel::FindInterfaceNodes()
{
int i, j;
CGraph *graph = m_pGrModel->GetGraph();
int nnodes = graph->GetNumberOfNodes();
int numberOfNeighbors;
const int *neighbors;
const ENeighborType *orientation;
for( i = 0; i < nnodes/2; i++ )
{
graph->GetNeighbors(i, &numberOfNeighbors, &neighbors, &orientation);
for( j = 0; j < numberOfNeighbors; j++ )
{
if( neighbors[j] >= nnodes/2 )
{
m_InterfaceNodes.push_back(i);
break;
}
}
}
}
void
CGraphPersistence::Save(CPNLBase *pObj, CContextSave *pContext)
{
CGraph *pG = dynamic_cast<CGraph*>(pObj);
std::stringstream buf;
PNL_CHECK_IS_NULL_POINTER(pG);
int nNode = pG->GetNumberOfNodes();
intVector neig;
neighborTypeVector neigType;
pContext->AddAttribute("SavingType", "ByEdges");
{
char buf2[12];
sprintf(buf2, "%i", nNode);
pContext->AddAttribute("NumberOfNodes", buf2);
}
for(int i = 0; i < nNode; ++i)
{
pG->GetNeighbors(i, &neig, &neigType);
buf << i << ":";
for(int j = neig.size(); --j >= 0;)
{
buf << neig[j] << "_(" << neighTypeSymbols[neigType[j]] << ") ";
}
buf << '\n';
}
pContext->AddText(buf.str().c_str());
}
CGraph *C1_5SliceInfEngine::Create1_5SliceGraph()
{
int node, i, j;
CGraph *graph = GrModel()->GetGraph();
int nnodesInDBN = graph->GetNumberOfNodes();
int numberOfInterfaceNodes;
const int *interfaceNodes;
GrModel()->GetInterfaceNodes(&numberOfInterfaceNodes, &interfaceNodes);
int nnodes = nnodesInDBN/2 + numberOfInterfaceNodes;
CGraph *pFinalGraph = CGraph::Create( nnodes, NULL, NULL, NULL );
PNL_CHECK_IF_MEMORY_ALLOCATED( pFinalGraph );
int numberOfNeighbors;
const int *neighbors;
const ENeighborType *orientation;
int newNumber;
intVector FinalNeighbors;
pnlVector<ENeighborType> FinalOrientation;
intVector newIntNodes( numberOfInterfaceNodes );
int numberOfNonIntNodes = nnodesInDBN/2 - numberOfInterfaceNodes;
for ( node = 0; node < numberOfInterfaceNodes; node++ )
{
newIntNodes[node] = interfaceNodes[node] - numberOfNonIntNodes;
}
for( i = nnodesInDBN/2; i < nnodesInDBN; i++ )
{
graph->GetNeighbors(i, &numberOfNeighbors, &neighbors, &orientation);
FinalNeighbors.resize(numberOfNeighbors);
for ( j = 0; j < numberOfNeighbors; j++ )
{
newNumber = neighbors[j] - numberOfNonIntNodes;
FinalNeighbors[j] = ( newNumber < numberOfInterfaceNodes ) ?
( std::find( newIntNodes.begin(), newIntNodes.end(),
newNumber) - newIntNodes.begin() ) : newNumber;
}
pFinalGraph->SetNeighbors( i - numberOfNonIntNodes, numberOfNeighbors,
&(FinalNeighbors.front()), orientation );
}
return pFinalGraph;
}
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;
}
void CSpecPearlInfEngine::ComputeProductLambda( int nodeNumber, fgMessage lambda,
fgMessage& resMes,
int except ) const
{
int i;
CGraph *theGraph = m_pGraphicalModel->GetGraph();
int numNeighb;
const int *neighbors;
const ENeighborType *orientations;
theGraph->GetNeighbors( nodeNumber, &numNeighb, &neighbors, &orientations );
if( orientations[0] == ntNeighbor )
{
return;// InitMessage( nodeNumber, ( m_pGraphicalModel->GetNodeType(nodeNumber) ) );
}
//getting parameter from the model
int nodes = nodeNumber;
int numOfParams;
CFactor ** param;
m_pGraphicalModel->GetFactors(1, &nodes, &numOfParams, ¶m );
if( !numOfParams )
{
PNL_THROW( CInvalidOperation, "no parameter" )
}
//we want to find parameter in which nodeNumber is a child - last in domain
const CFactor *parameter = param[0];
//to check last node in domain
const int *BigDomain; int bigDomSize;
//flag to check - if there isn't such domain
int bSuchDom = 0;
for ( i = 0; i < numOfParams; i++ )
{
param[i]->GetDomain( &bigDomSize, &BigDomain );
if( BigDomain[bigDomSize-1] == nodeNumber )
{
parameter = param[i];
bSuchDom = 1;
break;
}
}
if( !bSuchDom )
{
//we need to produce message without any interesting information - only ones
//fgMessage allData = InitMessage( nodeNumber, m_pGraphicalModel->GetNodeType( nodeNumber ) );
return;// allData;
}
//getting data from parameter
/*fgMessage paramData = static_cast<CPotential*>(parameter->Clone());//->_GetDistribFun();
//getting domain for marginalize and multiply
parameter->GetDomain( &bigDomSize, &BigDomain );
//we need to use serial numbers
intVector domNumbers( bigDomSize );
for ( i = 0; i < bigDomSize; i++ )
{
domNumbers[i] = i;
}
//we need to find all parents, collect their messages
// put the pointers to them into array, call CPD_to_pi()
int location;
intVector parentIndices;
//we create vector of messages in the same order as in domain - they are first in domain
std::vector<fgMessage> parentMessages = std::vector<fgMessage>(bigDomSize - 1);
int keepNode = -1;
for( i = 0; i < numNeighb; i++ )
{
location = std::find( BigDomain, BigDomain + bigDomSize,
neighbors[i] ) - BigDomain;
if( ( orientations[i] == ntParent ) && ( location < bigDomSize ) )
{
parentMessages[location] = m_curMessages[m_curState][nodeNumber][i];
if( neighbors[i] != except )
{
parentIndices.push_back(location);
}
if (neighbors[i] == except)
{
keepNode = location;
}
}
}
//fgMessage resMes1 = paramData->_GetDistribFun()->_CPD_to_lambda(lambda, parentMessages.begin(),
// parentIndices.begin(), parentIndices.size(), keepNode, m_bMaximize);
//return resMes1;*/
}
void DefineQueryArHMM( CDBN *pDBN, int nTimeSlice,
intVector * queryForDBNPrior,
intVector * queryForDBN,
intVecVector *queryForUnrollBnet )
{
///////////////////////////////////////////////////////////////////////////
//Define query for unrolled DBN and DBN (it is parents of some random node)
/////////////////////////////////////////////////////////////////////////////
int numOfNodesInDBN=pDBN->GetNumberOfNodes();
int numOfInterfaceNodes;
const int * interfaceNodes;
pDBN->GetInterfaceNodes( &numOfInterfaceNodes, &interfaceNodes );
/////////////////////////////////////////////////////////////////////////////
int node = ( int )( rand()%( numOfNodesInDBN - 1 ) ) ;
/////////////////////////////////////////////////////////////////////////////
(*queryForUnrollBnet).resize( nTimeSlice );
/////////////////////////////////////////////////////////////////////////////
int numOfNeighbors;
const int * neighbors;
const ENeighborType * types;
/////////////////////////////////////////////////////////////////////////////
CGraph *pPriorGraph = pDBN->CreatePriorSliceGraph();
pPriorGraph->GetNeighbors( node, &numOfNeighbors, &neighbors, &types );
int i;
for( i = 0; i < numOfNeighbors; i++ )
{
if( types[i] == ntParent )
{
(*queryForDBNPrior).push_back( neighbors[i] );
(*queryForUnrollBnet)[0].push_back( neighbors[i] );
}
}
(*queryForDBNPrior).push_back( node );
(*queryForUnrollBnet)[0].push_back( node );
delete pPriorGraph;
//////////////////////////////////////////////////////////////////////////////
node += numOfNodesInDBN;
pDBN->GetGraph()->GetNeighbors( node, &numOfNeighbors, &neighbors, &types );
int slice;
for( i = 0; i < numOfNeighbors; i++ )
{
if( types[i] == ntParent )
{
(*queryForDBN).push_back( neighbors[i] );
for( slice = 0; slice < nTimeSlice - 1; slice++ )
{
(*queryForUnrollBnet)[slice+1].push_back( neighbors[i] +
slice*numOfNodesInDBN );
}
}
}
(*queryForDBN).push_back( node );
for( slice = 0; slice < nTimeSlice - 1; slice++ )
{
(*queryForUnrollBnet)[slice+1].push_back( node + slice*numOfNodesInDBN );
}
}
