int GibbsMPEforScalarGaussianBNet( float eps)
{
std::cout<<std::endl<<"Gibbs MPE for scalar gaussian BNet"<<std::endl;
int ret =1;
CBNet *pBnet = pnlExCreateScalarGaussianBNet();
std::cout<<"BNet has been created \n";
CGibbsSamplingInfEngine *pGibbsInf = CGibbsSamplingInfEngine::Create( pBnet );
pGibbsInf->SetBurnIn( 100);
pGibbsInf->SetMaxTime( 10000 );
std::cout<<"burnIN and MaxTime have been defined \n";
pEvidencesVector evidences;
pBnet->GenerateSamples(&evidences, 1 );
std::cout<<"evidence has been generated \n";
const int ndsToToggle[] = { 0, 3 };
evidences[0]->ToggleNodeState( 2, ndsToToggle );
intVecVector queryes(1);
queryes[0].push_back(0);
pGibbsInf->SetQueries( queryes);
std::cout<<"set queries"<<std::endl;
pGibbsInf->EnterEvidence( evidences[0], 1 );
std::cout<<"enter evidence"<<std::endl;
intVector query(1,0);
pGibbsInf->MarginalNodes( &query.front(),query.size() );
std::cout<<"marginal nodes"<<std::endl;
const CEvidence *pEvGibbs = pGibbsInf->GetMPE();
CJtreeInfEngine *pJTreeInf = CJtreeInfEngine::Create(pBnet);
pJTreeInf->EnterEvidence(evidences[0], 1);
pJTreeInf->MarginalNodes(&query.front(), query.size());
const CEvidence* pEvJTree = pJTreeInf->GetMPE();
std::cout<<"result of gibbs"<<std::endl<<std::endl;
pEvGibbs->Dump();
pEvJTree->Dump();
delete evidences[0];
delete pGibbsInf;
delete pJTreeInf;
delete pBnet;
return ret;
}
int GibbsForInceneratorBNet(float eps)
{
std::cout<<std::endl<<"Gibbs for Incenerator BNet"<< std::endl;
CBNet *pBnet;
pEvidencesVector evidences;
CJtreeInfEngine *pJTreeInf;
CGibbsSamplingInfEngine *pGibbsInf;
const CPotential *pQueryPot1, *pQueryPot2;
int i, ret;
pBnet = tCreateIncineratorBNet();
evidences.clear();
pBnet->GenerateSamples( &evidences, 1 );
const int ndsToToggle1[] = { 0, 1, 3 };
evidences[0]->ToggleNodeState( 3, ndsToToggle1 );
const int *flags = evidences[0]->GetObsNodesFlags();
std::cout<<"observed nodes"<<std::endl;
for( i = 0; i < pBnet->GetNumberOfNodes(); i++ )
{
if ( flags[i] )
{
std::cout<<"node "<<i<<"; ";
}
}
std::cout<<std::endl<<std::endl;
const int querySz1 = 2;
const int query1[] = { 0, 1 };
pJTreeInf = CJtreeInfEngine::Create(pBnet);
pJTreeInf->EnterEvidence( evidences[0] );
pJTreeInf->MarginalNodes( query1,querySz1 );
pGibbsInf = CGibbsSamplingInfEngine::Create( pBnet );
intVecVector queries(1);
queries[0].clear();
queries[0].push_back( 0 );
queries[0].push_back( 1 );
pGibbsInf->SetQueries( queries );
pGibbsInf->EnterEvidence( evidences[0] );
pGibbsInf->MarginalNodes( query1, querySz1 );
pQueryPot1 = pGibbsInf->GetQueryJPD();
pQueryPot2 = pJTreeInf->GetQueryJPD();
std::cout<<"result of gibbs"<<std::endl<<std::endl;
pQueryPot1->Dump();
std::cout<<"result of junction"<<std::endl;
pQueryPot2->Dump();
ret = pQueryPot1->IsFactorsDistribFunEqual( pQueryPot2, eps, 0 );
delete evidences[0];
//CJtreeInfEngine::Release(&pJTreeInf);
delete pJTreeInf;
delete pGibbsInf;
delete pBnet;
return ret;
///////////////////////////////////////////////////////////////////////////////
}
int GibbsForAsiaBNet( float eps )
{
///////////////////////////////////////////////////////////////////////////////
std::cout<<std::endl<<" Asia BNet "<< std::endl;
CBNet* pBnet = pnlExCreateAsiaBNet();
int ret;
pEvidencesVector evidences;
pBnet->GenerateSamples( &evidences, 1 );
const int ndsToToggle[] = { 1, 2, 5, 7 };
evidences[0]->ToggleNodeState( 4, ndsToToggle );
CGibbsSamplingInfEngine *pGibbsInf;
pGibbsInf = CGibbsSamplingInfEngine::Create(pBnet);
intVecVector queries(1);
queries[0].push_back(0);
queries[0].push_back(2);
queries[0].push_back(7);
pGibbsInf->SetQueries(queries);
pGibbsInf->EnterEvidence( evidences[0] );
CJtreeInfEngine *pJTreeInf = CJtreeInfEngine::Create(pBnet);
pJTreeInf->EnterEvidence( evidences[0] );
const int querySz = 2;
const int query[] = {0, 2};
pGibbsInf->MarginalNodes( query,querySz );
pGibbsInf->MarginalNodes( query,querySz );
pJTreeInf->MarginalNodes( query,querySz );
const CPotential *pQueryPot1 = pGibbsInf->GetQueryJPD();
const CPotential *pQueryPot2 = pJTreeInf->GetQueryJPD();
ret = pQueryPot1-> IsFactorsDistribFunEqual( pQueryPot2, eps, 0 );
std::cout<<"Test on gibbs for asia bnet"<<std::endl;
std::cout<<"result of gibbs"<<std::endl;
pQueryPot1->Dump();
std::cout<<std::endl<<"result of junction"<<std::endl;
pQueryPot2->Dump();
delete evidences[0];
//CJtreeInfEngine::Release(&pJTreeInf);
delete pJTreeInf;
delete pGibbsInf;
delete pBnet;
return ret;
///////////////////////////////////////////////////////////////////////////////
}
void CBKInfEngine::Backward( int maximize )
{
m_CurrentTime--;
intVecVector::iterator clustersItFrom, clustersItEnd;
clustersItFrom = m_clusters1_5Sl.begin();
clustersItEnd = clustersItFrom + GetNumOfClusters();
CJtreeInfEngine *pFutureInf = *m_JTreeInfIter;
m_JTreeInfIter--;
CJtreeInfEngine *pCurrentInf = *m_JTreeInfIter;
intVector::iterator JTreeNdsIt = m_clqs1_5Sl.begin();
intVecVector::iterator clustersItTo;
if( pCurrentInf ->GetModel()->GetNumberOfNodes() == GetPriorSliceBNet()->GetNumberOfNodes() )
{
clustersItTo = m_clustersPrSl.begin();
JTreeNdsIt = m_clqsPrSl.begin();
}
else
{
clustersItTo = m_clusters1_5Sl.begin()+ m_clustersPrSl.size();
JTreeNdsIt = m_clqs1_5Sl.begin() + m_clustersPrSl.size();
}
distrPVector::iterator sepIt = (*m_CDistrOnSepIter).begin();
const CPotential * queryPotF;
for( ; clustersItFrom != clustersItEnd; clustersItFrom++, clustersItTo++, JTreeNdsIt++, sepIt++ )
{
pFutureInf->MarginalNodes( &(clustersItFrom->front()), clustersItFrom->size(), 1 );
if( maximize )
{
queryPotF = pFutureInf->GetQueryMPE();
}
else
{
queryPotF = pFutureInf->GetQueryJPD();
}
//hack
queryPotF->GetDistribFun()->
DivideInSelfData(&(clustersItTo->front()),&(clustersItTo->front()),
*sepIt);
pCurrentInf->MultJTreeNodePotByDistribFun(*JTreeNdsIt, &(clustersItTo->front()),
queryPotF->GetDistribFun());
}
pCurrentInf->DistributeEvidence();
m_CDistrOnSepIter--;
}
void CParEMLearningEngine::Learn()
{
CStaticGraphicalModel *pGrModel = this->GetStaticModel();
PNL_CHECK_IS_NULL_POINTER(pGrModel);
PNL_CHECK_LEFT_BORDER(GetNumEv() - GetNumberProcEv() , 1);
CJtreeInfEngine *pCurrentInfEng = NULL;
CFactor *parameter = NULL;
int exit = 0;
int numberOfParameters = pGrModel->GetNumberOfParameters();
int domainNodes;
int infIsNeed = 0;
int itsML = 0;
// !!!
float loglik = -FLT_MAX;
float loglikOld = -FLT_MAX;
float epsilon = GetPrecisionEM();
float stopExpression = epsilon + 1.0f;
int iteration = 0;
int currentEvidNumber;
int bMaximize = 0;
int bSumOnMixtureNode = 0;
const CEvidence* pCurrentEvid;
int start_mpi, finish_mpi;
int NumberOfProcesses, MyRank;
int numSelfEvidences;
MPI_Comm_size(MPI_COMM_WORLD, &NumberOfProcesses);
MPI_Comm_rank(MPI_COMM_WORLD, &MyRank);
int d = 0;
do
{
iteration++;
numSelfEvidences = (GetNumEv() - GetNumberProcEv()) / NumberOfProcesses;
start_mpi = GetNumberProcEv() + numSelfEvidences * MyRank; // !!!
if (MyRank < NumberOfProcesses - 1)
finish_mpi = start_mpi + numSelfEvidences; // !!!
else
finish_mpi = GetNumEv(); // !!!
for(int ev = start_mpi; ev < finish_mpi; ev++)
{
infIsNeed = 0;
currentEvidNumber = ev; // !!!
pCurrentEvid = m_Vector_pEvidences[currentEvidNumber];
if( !pCurrentEvid)
{
PNL_THROW(CNULLPointer, "evidence")
}
infIsNeed = !GetObsFlags(ev)->empty(); // !!!
if(infIsNeed)
{
// create inference engine
if(!pCurrentInfEng)
{
pCurrentInfEng = CJtreeInfEngine::Create(pGrModel);
}
pCurrentInfEng->EnterEvidence(pCurrentEvid, bMaximize,
bSumOnMixtureNode);
}
for(domainNodes = 0; domainNodes < numberOfParameters; domainNodes++)
{
parameter = pGrModel->GetFactor(domainNodes);
if(infIsNeed)
{
int DomainSize;
const int *domain;
parameter->GetDomain(&DomainSize, &domain);
if (IsDomainObserved(DomainSize, domain, currentEvidNumber))
{
const CEvidence *pEvidences[] = { pCurrentEvid };
parameter->UpdateStatisticsML(pEvidences, 1);
}
else
{
pCurrentInfEng->MarginalNodes(domain, DomainSize, 1);
const CPotential * pMargPot = pCurrentInfEng->GetQueryJPD();
parameter ->UpdateStatisticsEM(pMargPot, pCurrentEvid);
}
}
else
{
const CEvidence *pEvidences[] = { pCurrentEvid };
parameter->UpdateStatisticsML(pEvidences, 1);
}
}
itsML = itsML || !infIsNeed;
}
for(domainNodes = 0; domainNodes < numberOfParameters; domainNodes++ )
{
parameter = pGrModel->GetFactor(domainNodes);
CNumericDenseMatrix<float> *matForSending;
int matDim;
const int *pMatRanges;
int dataLength;
const float *pDataForSending;
matForSending = static_cast<CNumericDenseMatrix<float>*>
((parameter->GetDistribFun())->GetStatisticalMatrix(stMatTable));
matForSending->GetRanges(&matDim, &pMatRanges);
matForSending->GetRawData(&dataLength, &pDataForSending);
float *pDataRecv = new float[dataLength];
float *pDataRecv_copy = new float[dataLength];
MPI_Status status;
MPI_Allreduce((void*)pDataForSending, pDataRecv, dataLength, MPI_FLOAT, MPI_SUM,
MPI_COMM_WORLD);
CNumericDenseMatrix<float> *RecvMatrix =
static_cast<CNumericDenseMatrix<float>*>
(parameter->GetDistribFun()->GetStatisticalMatrix(stMatTable));
int dataLength_new;
float *pData_new;
RecvMatrix->GetRawData(&dataLength_new, (const float**)(&pData_new));
for(int t=0;t<dataLength_new;t++)
pData_new[t]=pDataRecv[t];
}
switch (pGrModel->GetModelType())
{
case mtBNet:
{
loglikOld = loglik;
loglik = 0.0f;
for(domainNodes = 0; domainNodes < numberOfParameters; domainNodes++)
{
parameter = pGrModel->GetFactor(domainNodes);
loglik += parameter->ProcessingStatisticalData(m_numberOfAllEvidences);
}
break;
}
case mtMRF2:
case mtMNet:
{
loglikOld = loglik;
loglik = _LearnPotentials();
break;
}
default:
{
PNL_THROW(CBadConst, "model type")
break;
}
}
stopExpression =
float(fabs(2 * (loglikOld - loglik) / (loglikOld + loglik)));
exit = ((stopExpression > epsilon) && (iteration <= GetMaxIterEM())) && !itsML;
if(exit)
{
ClearStatisticData();
}
delete pCurrentInfEng;
pCurrentInfEng = NULL;
}while(exit);
if(iteration > GetMaxIterEM())
{
PNL_THROW(CNotConverged, "maximum number of iterations")
}
SetNumProcEv( GetNumEv() );
}
int testRandomFactors()
{
int ret = TRS_OK;
int nnodes = 0;
int i;
while(nnodes <= 0)
{
trsiRead( &nnodes, "5", "Number of nodes in Model" );
}
//create node types
int seed1 = pnlTestRandSeed();
//create string to display the value
char *value = new char[20];
#if 0
value = _itoa(seed1, value, 10);
#else
sprintf( value, "%d", seed1 );
#endif
trsiRead(&seed1, value, "Seed for srand to define NodeTypes etc.");
delete []value;
trsWrite(TW_CON|TW_RUN|TW_DEBUG|TW_LST, "seed for rand = %d\n", seed1);
//create 2 node types and model domain for them
nodeTypeVector modelNodeType;
modelNodeType.resize(2);
modelNodeType[0] = CNodeType( 1, 4 );
modelNodeType[1] = CNodeType( 1, 3 );
intVector NodeAssociat;
NodeAssociat.assign(nnodes, 0);
for( i = 0; i < nnodes; i++ )
{
float rand = pnlRand( 0.0f, 1.0f );
if( rand < 0.5f )
{
NodeAssociat[i] = 1;
}
}
CModelDomain* pMDDiscr = CModelDomain::Create( modelNodeType,
NodeAssociat );
//create random graph - number of nodes for every node is rand too
int lowBorder = nnodes - 1;
int upperBorder = int((nnodes * (nnodes - 1))/2);
int numEdges = pnlRand( lowBorder, upperBorder );
mark:
CGraph* pGraph = tCreateRandomDAG( nnodes, numEdges, 1 );
if ( pGraph->NumberOfConnectivityComponents() != 1 )
{
delete pGraph;
goto mark;
}
CBNet* pDiscrBNet = CBNet::CreateWithRandomMatrices( pGraph, pMDDiscr );
//start jtree inference just for checking
//the model is valid for inference and all operations can be made
CEvidence* pDiscrEmptyEvid = CEvidence::Create( pMDDiscr, 0, NULL, valueVector() );
CJtreeInfEngine* pDiscrInf = CJtreeInfEngine::Create( pDiscrBNet );
pDiscrInf->EnterEvidence( pDiscrEmptyEvid );
const CPotential* pot = NULL;
for( i = 0; i < nnodes; i++ )
{
intVector domain;
pDiscrBNet->GetFactor(i)->GetDomain( &domain );
pDiscrInf->MarginalNodes( &domain.front(), domain.size() );
pot = pDiscrInf->GetQueryJPD();
}
//make copy of Graph for using with other models
pGraph = CGraph::Copy( pDiscrBNet->GetGraph() );
delete pDiscrInf;
delete pDiscrBNet;
delete pDiscrEmptyEvid;
delete pMDDiscr;
//create gaussian model domain
modelNodeType[0] = CNodeType( 0, 4 );
modelNodeType[1] = CNodeType( 0, 2 );
CModelDomain* pMDCont = CModelDomain::Create( modelNodeType,
NodeAssociat );
CBNet* pContBNet = CBNet::CreateWithRandomMatrices( pGraph, pMDCont );
CEvidence* pContEmptyEvid = CEvidence::Create( pMDCont, 0, NULL, valueVector() );
CNaiveInfEngine* pContInf = CNaiveInfEngine::Create( pContBNet );
pContInf->EnterEvidence( pContEmptyEvid );
for( i = 0; i < nnodes; i++ )
{
intVector domain;
pContBNet->GetFactor(i)->GetDomain( &domain );
pContInf->MarginalNodes( &domain.front(), domain.size() );
pot = pContInf->GetQueryJPD();
}
pGraph = CGraph::Copy(pContBNet->GetGraph());
delete pContInf;
delete pContBNet;
delete pContEmptyEvid;
delete pMDCont;
//find the node that haven't any parents
//and change its node type for it to create Conditional Gaussian CPD
int numOfNodeWithoutParents = -1;
intVector parents;
parents.reserve(nnodes);
for( i = 0; i < nnodes; i++ )
{
pGraph->GetParents( i, &parents );
if( parents.size() == 0 )
{
numOfNodeWithoutParents = i;
break;
}
}
//change node type of this node, make it discrete
CNodeType ntTab = CNodeType( 1,4 );
modelNodeType.push_back( ntTab );
NodeAssociat[numOfNodeWithoutParents] = 2;
//need to change this model domain
CModelDomain* pMDCondGau = CModelDomain::Create( modelNodeType, NodeAssociat );
CBNet* pCondGauBNet = CBNet::CreateWithRandomMatrices( pGraph, pMDCondGau );
//need to create evidence for all gaussian nodes
intVector obsNodes;
obsNodes.reserve(nnodes);
int numGauVals = 0;
for( i = 0; i < numOfNodeWithoutParents; i++ )
{
int GauSize = pMDCondGau->GetVariableType(i)->GetNodeSize();
numGauVals += GauSize;
obsNodes.push_back( i );
}
for( i = numOfNodeWithoutParents + 1; i < nnodes; i++ )
{
int GauSize = pMDCondGau->GetVariableType(i)->GetNodeSize();
numGauVals += GauSize;
obsNodes.push_back( i );
}
valueVector obsGauVals;
obsGauVals.resize( numGauVals );
floatVector obsGauValsFl;
obsGauValsFl.resize( numGauVals);
pnlRand( numGauVals, &obsGauValsFl.front(), -3.0f, 3.0f);
//fill the valueVector
for( i = 0; i < numGauVals; i++ )
{
obsGauVals[i].SetFlt(obsGauValsFl[i]);
}
CEvidence* pCondGauEvid = CEvidence::Create( pMDCondGau, obsNodes, obsGauVals );
CJtreeInfEngine* pCondGauInf = CJtreeInfEngine::Create( pCondGauBNet );
pCondGauInf->EnterEvidence( pCondGauEvid );
pCondGauInf->MarginalNodes( &numOfNodeWithoutParents, 1 );
pot = pCondGauInf->GetQueryJPD();
pot->Dump();
delete pCondGauInf;
delete pCondGauBNet;
delete pCondGauEvid;
delete pMDCondGau;
return trsResult( ret, ret == TRS_OK ? "No errors" :
"Bad test on RandomFactors");
}
void CBKInfEngine::Forward(const CEvidence *pEvidence, int maximize )
{
PNL_CHECK_IS_NULL_POINTER(pEvidence);
PNL_CHECK_IS_NULL_POINTER(*m_JTreeInfIter);
CJtreeInfEngine *pastEng;
if( !m_isExact )
{
if(m_CRingDistrOnSep.size())
{
pastEng = CJtreeInfEngine::Copy(*m_JTreeInfIter);
}
else
{
pastEng = *m_JTreeInfIter;
}
pastEng->DistributeEvidence();
}
else
{
pastEng = *m_JTreeInfIter;
}
m_JTreeInfIter++;
PNL_CHECK_IS_NULL_POINTER(*m_JTreeInfIter);
if( (*m_JTreeInfIter)->GetModel()->GetNumberOfNodes() == GetPriorSliceBNet()->GetNumberOfNodes() )
{
//CJtreeInfEngine::Release(&(*m_JTreeInfIter));
delete (*m_JTreeInfIter);
(*m_JTreeInfIter) = CJtreeInfEngine::Copy(m_p1_5SliceJtreeInf);
}
(*m_JTreeInfIter)->ShrinkObserved( pEvidence, maximize );
intVecVector::iterator clustersItFrom, clustersItEnd;
if( GetTime() == 1 )
{
clustersItFrom = m_clustersPrSl.begin();
clustersItEnd = m_clustersPrSl.end();
}
else
{
clustersItFrom = m_clusters1_5Sl.begin() + m_clustersPrSl.size();
clustersItEnd = m_clusters1_5Sl.end();
}
intVecVector::iterator clustersItTo = m_clusters1_5Sl.begin();
intVector::iterator JTreeNdsIt = m_clqs1_5Sl.begin();
distrPVector::iterator sepIt = distrPVector::iterator();
if(m_CRingDistrOnSep.size())
{
sepIt = (*m_CDistrOnSepIter).begin();
}
const CPotential *queryPot;
for( ; clustersItFrom != clustersItEnd; clustersItFrom++, clustersItTo++, JTreeNdsIt++)
{
pastEng->MarginalNodes( &(clustersItFrom->front()), clustersItFrom->size(), 1 );
if( maximize )
{
queryPot = pastEng->GetQueryMPE();
}
else
{
queryPot = pastEng->GetQueryJPD();
}
(*m_JTreeInfIter)->MultJTreeNodePotByDistribFun(*JTreeNdsIt, &(clustersItTo->front()),
queryPot->GetDistribFun());
if(m_CRingDistrOnSep.size())
{
delete (*sepIt);
*sepIt = queryPot->GetDistribFun()->CloneWithSharedMatrices();
sepIt++;
}
}
(*m_JTreeInfIter)->CollectEvidence();
if( !m_isExact && m_CRingDistrOnSep.size())
{
//CJtreeInfEngine::Release(&pastEng);
delete pastEng;
pastEng = NULL;
}
m_CurrentTime++;
if(m_CRingDistrOnSep.size())
{
m_CDistrOnSepIter++;
}
}
bool pnl::EqualResults(CJtreeInfEngine& eng1, CJtreeInfEngine& eng2,
float epsilon, int doPrint, int doFile, float *maxDiff)
{
CJunctionTree *JTree1, *JTree2;
JTree1 = eng1.GetJTree();
JTree2 = eng2.GetJTree();
int NumOfNds1 = JTree1->GetNumberOfNodes();
int NumOfNds2 = JTree2->GetNumberOfNodes();
int numOfNdsInClq;
const int *clique;
const floatVector *myVector;
int node;
#if 0
FILE *out;
if (doFile)
{
out = fopen( "jtree1.out", "w" );
for(node = 0; node < NumOfNds1; node++)
{
JTree1->GetNodeContent(node, &numOfNdsInClq, &clique);
fprintf(out, "Nodes of clique %d :\n", node);
for (int i = 0; i < numOfNdsInClq; i++)
fprintf(out, "%d ", clique[i]);
CMatrix<float>* mat = NULL;
CPotential* p = JTree1->GetNodePotential(node);
mat = p->GetDistribFun()->GetMatrix(matTable);
CNumericDenseMatrix<float>* myMatrix =
static_cast<CNumericDenseMatrix<float>*>(mat->ConvertToDense());
fprintf(out,"\nMatrix of potential of clique %d:\n", node);
myVector = (myMatrix)->GetVector();
for(int j = 0; j < myVector->size(); j++)
{
fprintf(out,"%f ",(*myVector)[j]);
}
fprintf(out,"\n\n");
}
fclose( out );
out = fopen( "jtree2.out", "w" );
for(node = 0; node < NumOfNds2; node++)
{
JTree2->GetNodeContent(node, &numOfNdsInClq, &clique);
fprintf(out, "Nodes of clique %d :\n", node);
for (int i = 0; i < numOfNdsInClq; i++)
fprintf(out, "%d ", clique[i]);
CMatrix<float>* mat = JTree2->GetNodePotential(node)->
GetDistribFun()->GetMatrix(matTable);
CNumericDenseMatrix<float>* myMatrix =
static_cast<CNumericDenseMatrix<float>*>(mat->ConvertToDense());
fprintf(out,"\nMatrix of potential of clique %d:\n", node);
const floatVector *myVector = (myMatrix)->GetVector();
for(int j = 0; j < myVector->size(); j++)
{
fprintf(out,"%f ",(*myVector)[j]);
}
fprintf(out,"\n\n");
}
fclose( out );
}
#endif
bool res = 1;
if (NumOfNds1 != NumOfNds2)
res = 0;
CDistribFun* distrib1;
if (maxDiff)
{
*maxDiff = 0;
}
float maxDifference;
for(node = 0; node < NumOfNds1; node++)
{
distrib1 = JTree1->GetNodePotential(node)->GetDistribFun();
if (!(distrib1->IsEqual(JTree2->GetNodePotential(node)->
GetDistribFun(), epsilon, 1, &maxDifference)))
{
res = 0;
if (maxDiff && (*maxDiff < maxDifference))
{
*maxDiff = maxDifference;
}
#if 0
if (doPrint)
printf("clique %d: notOK maxDiff = %.6f\n", node, maxDifference);
#endif
}
else
{
#if 0
if (doPrint)
printf("clique %d: OK\n", node);
#endif
}
}
return res;
}
int CompareFixLagSmoothingArHMM(CDBN* pDBN, int nTimeSlice, float eps)
{
CBNet * pUnrolledDBN;
pUnrolledDBN = static_cast<CBNet *>(pDBN->UnrollDynamicModel(nTimeSlice));
int itogResult = 1;
int result = 0;
int lag = rand()%(nTimeSlice-1);
lag = 2;
/////////////////////////////////////////////////////////////////////////////
//Create inference for unrolled DBN
////////////////////////////////////////////////////////////////////////////
C1_5SliceJtreeInfEngine *pDynamicJTree;
pDynamicJTree = C1_5SliceJtreeInfEngine::Create(pDBN);
pDynamicJTree->DefineProcedure(ptFixLagSmoothing, lag);
CEvidence *myEvidenceForUnrolledDBN;
pEvidencesVector myEvidencesForDBN;
CreateEvidencesArHMM(pDBN, nTimeSlice, &myEvidencesForDBN);
intVector queryForDBN, queryForDBNPrior;
intVecVector queryForUnrollBnet;
DefineQueryArHMM(pDBN, nTimeSlice,
&queryForDBNPrior, &queryForDBN, &queryForUnrollBnet);
int slice;
for(slice = 0; slice < nTimeSlice; slice++)
{
//////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//Create inference (smoothing) for DBN
pDynamicJTree->EnterEvidence(&(myEvidencesForDBN[slice]), 1);
if(slice >= lag)
{
pDynamicJTree->FixLagSmoothing(slice);
CBNet * pUnrolledOnISlice =
static_cast<CBNet *>(pDBN->UnrollDynamicModel(slice+1));
myEvidenceForUnrolledDBN =
CreateEvidenceForUnrolledArHMM(pUnrolledOnISlice , slice+1, myEvidencesForDBN);
CJtreeInfEngine *pUnrolJTree =
CJtreeInfEngine::Create(pUnrolledOnISlice);
pUnrolJTree->EnterEvidence(myEvidenceForUnrolledDBN);
pUnrolJTree->MarginalNodes(&(queryForUnrollBnet[slice-lag]).front(),
(queryForUnrollBnet[slice-lag]).size());
if(slice-lag)
{
pDynamicJTree->MarginalNodes(&queryForDBN.front(),
queryForDBN.size());
}
else
{
pDynamicJTree->MarginalNodes(&queryForDBNPrior.front(),
queryForDBNPrior.size());
}
const CPotential* qJPD1 = pUnrolJTree->GetQueryJPD();
const CPotential* qJPD2 = pDynamicJTree->GetQueryJPD();
result = CompareArHMM( qJPD1, qJPD2, eps);
if(!result)
{
itogResult = FALSE;
}
delete myEvidenceForUnrolledDBN;
//CJtreeInfEngine::Release(&pUnrolJTree);
delete pUnrolJTree;
delete (pUnrolledOnISlice);
}
}
for( slice = 0; slice < (myEvidencesForDBN).size(); slice++ )
{
delete myEvidencesForDBN[slice];
}
delete pDynamicJTree;
delete pUnrolledDBN;
return itogResult;
}
int CompareViterbyArHMM( CDBN* pDBN, int nTimeSlice, float eps )
{
CBNet * pUnrolledDBN;
pUnrolledDBN = static_cast<CBNet *>( pDBN->UnrollDynamicModel( nTimeSlice ) );
/////////////////////////////////////////////////////////////////////////////
//Create inference for unrolled DBN
////////////////////////////////////////////////////////////////////////////
CEvidence *myEvidenceForUnrolledDBN;
pEvidencesVector myEvidencesForDBN;
CreateEvidencesArHMM( pDBN, nTimeSlice, &myEvidencesForDBN );
myEvidenceForUnrolledDBN =
CreateEvidenceForUnrolledArHMM(pUnrolledDBN , nTimeSlice, myEvidencesForDBN);
CJtreeInfEngine *pUnrolJTree = CJtreeInfEngine::Create( pUnrolledDBN );
//////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//Create inference (smoothing) for DBN
C1_5SliceJtreeInfEngine *pDynamicJTree;
pDynamicJTree = C1_5SliceJtreeInfEngine::Create( pDBN );
pUnrolJTree->EnterEvidence( myEvidenceForUnrolledDBN, 1 );
pDynamicJTree->DefineProcedure( ptViterbi, nTimeSlice );
pDynamicJTree->EnterEvidence( &myEvidencesForDBN.front(), nTimeSlice );
pDynamicJTree->FindMPE();
/////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////
intVector queryForDBN, queryForDBNPrior;
intVecVector queryForUnrollBnet;
DefineQueryArHMM( pDBN, nTimeSlice,
&queryForDBNPrior, &queryForDBN, &queryForUnrollBnet );
int itogResult = TRUE;
int slice;
for(slice = 0; slice < nTimeSlice; slice++)
{
pUnrolJTree->MarginalNodes( &(queryForUnrollBnet[slice]).front(),
(queryForUnrollBnet[slice]).size() );
if( slice )
{
pDynamicJTree->MarginalNodes( &queryForDBN.front(),
queryForDBN.size(), slice );
}
else
{
pDynamicJTree->MarginalNodes( &queryForDBNPrior.front(),
queryForDBNPrior.size(), slice );
}
intVector pObsNodesOut1;
intVector pObsNodesOut2;
pnlVector<const unsigned char*> vals1;
pnlVector<const unsigned char*> vals2;
const CEvidence* pEv1 = pUnrolJTree->GetMPE();
const CEvidence* pEv2 = pDynamicJTree->GetMPE();
int nObsNodes = pEv1->GetNumberObsNodes();
const CNodeType *const* nt = pEv1->GetNodeTypes();
for(int i = 0; i < nObsNodes; i++)
{
if(nt[i]->IsDiscrete())
{
const int v1 = (pEv1->GetValueBySerialNumber(i)->GetInt());
const int v2 = (pEv2->GetValueBySerialNumber(i)->GetInt());
if (v2 != v1)
{
itogResult = 0;
break;
}
}
else
{
int nodeSz = nt[i]->GetNodeSize();
for( int j = 0; j < nodeSz; j++)
{
const float v1 = pEv1->GetValueBySerialNumber(i)[j].GetFlt();
const float v2 = pEv2->GetValueBySerialNumber(i)[j].GetFlt();
if (v2 != v1)
{
itogResult = 0;
break;
}
}
}
}
if( !itogResult )
{
if( pUnrolJTree->GetQueryMPE()->
IsFactorsDistribFunEqual(pDynamicJTree->GetQueryMPE(), eps ) )
{
itogResult = 1;
}
else
{
pEv1->Dump();
pEv2->Dump();
}
}
}
for( slice = 0; slice < myEvidencesForDBN.size(); slice++ )
{
delete myEvidencesForDBN[slice];
}
delete myEvidenceForUnrolledDBN;
delete pUnrolJTree;
delete pUnrolledDBN;
delete pDynamicJTree;
return itogResult;
}
int CompareSmoothingArHMM( CDBN* pDBN, int nTimeSlice, float eps )
{
CBNet * pUnrolledDBN;
pUnrolledDBN = static_cast<CBNet *>( pDBN->UnrollDynamicModel( nTimeSlice ) );
int result = 0;
/////////////////////////////////////////////////////////////////////////////
//Create inference for unrolled DBN
////////////////////////////////////////////////////////////////////////////
CEvidence *myEvidenceForUnrolledDBN;
pEvidencesVector myEvidencesForDBN;
CreateEvidencesArHMM( pDBN, nTimeSlice, &myEvidencesForDBN);
CJtreeInfEngine *pUnrolJTree = CJtreeInfEngine::Create( pUnrolledDBN );
myEvidenceForUnrolledDBN =
CreateEvidenceForUnrolledArHMM(pUnrolledDBN, nTimeSlice, myEvidencesForDBN);
//////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//Create inference (smoothing) for DBN
C1_5SliceJtreeInfEngine *pDynamicJTree;
pDynamicJTree = C1_5SliceJtreeInfEngine::Create( pDBN );
pUnrolJTree->EnterEvidence( myEvidenceForUnrolledDBN );
pDynamicJTree->DefineProcedure( ptSmoothing, nTimeSlice );
pDynamicJTree->EnterEvidence( &myEvidencesForDBN.front(), nTimeSlice );
pDynamicJTree->Smoothing();
/////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////
intVector queryForDBN, queryForDBNPrior;
intVecVector queryForUnrollBnet;
DefineQueryArHMM( pDBN, nTimeSlice,
&queryForDBNPrior, &queryForDBN, &queryForUnrollBnet );
int itogResult = TRUE;
int slice;
for(slice = 0; slice < nTimeSlice; slice++)
{
pUnrolJTree->MarginalNodes( &(queryForUnrollBnet[slice]).front(),
(queryForUnrollBnet[slice]).size() );
if( slice )
{
pDynamicJTree->MarginalNodes( &queryForDBN.front(),
queryForDBN.size(), slice );
}
else
{
pDynamicJTree->MarginalNodes( &queryForDBNPrior.front(),
queryForDBNPrior.size(), slice );
}
result = CompareArHMM( pUnrolJTree->GetQueryJPD(),
pDynamicJTree->GetQueryJPD(), eps );
if( !result )
{
itogResult = FALSE;
}
}
for( slice = 0; slice < myEvidencesForDBN.size(); slice++ )
{
delete myEvidencesForDBN[slice];
}
delete myEvidenceForUnrolledDBN;
//CJtreeInfEngine::Release(&pUnrolJTree);
delete pUnrolJTree;
delete pUnrolledDBN;
delete pDynamicJTree;
return result;
}
int timeJTreeInfEngine()
{
int ret = TRS_OK;
char filename[120];
trstRead(filename, sizeof(filename), DSL_NETWORK_NAME, "Model name");
trsTimerStart(0);
CBNet* pBNet = ConvertFromDSLNet(filename);
trsTimerStop(0);
double timeOfDSL2PNLConversion = trsTimerSec(0);
if( pBNet == NULL )
{
ret = TRS_FAIL;
return trsResult( ret, ret == TRS_OK ? "No errors" : "JTree timing FAILED");
}
const CModelDomain* pModelDomain = pBNet->GetModelDomain();
const int numOfNds = pBNet->GetNumberOfNodes();
const int numOfObsNds = NUM_OF_OBS_NDS;
assert( numOfObsNds <= numOfNds );
intVector obsNds(numOfObsNds);
valueVector obsNdsVals(numOfObsNds);
SetRndObsNdsAndVals( pModelDomain, &obsNds, &obsNdsVals );
CEvidence* pEvidence = CEvidence::Create( pModelDomain, obsNds,
obsNdsVals );
trsTimerStart(1);
CJtreeInfEngine* pJTreeInfEngine = CJtreeInfEngine::Create(pBNet);
trsTimerStop(1);
double timeOfInfCreation = trsTimerSec(1);
const int numOfEnterEvidenceLoops = TIMES_TO_RUN_ENTER_EVIDENCE;
assert( numOfEnterEvidenceLoops > 0 );
trsTimerStart(2);
int i = 0;
for( ; i < numOfEnterEvidenceLoops; ++i )
{
pJTreeInfEngine->EnterEvidence(pEvidence);
}
trsTimerStop(2);
double timeOfEnterEvidence = trsTimerSec(2);
double averageTimeOfEnterEvidence = timeOfEnterEvidence
/numOfEnterEvidenceLoops;
double freqCPU = trsClocksPerSec();
trsCSVString8( "d", func_name,
trsDouble(timeOfInfCreation),
trsDouble(averageTimeOfEnterEvidence),
trsDouble(freqCPU),
"\n JTree inference creation ",
"\n average time for entering evidence ",
"\n CPU frequency " );
trsWrite( TW_RUN | TW_CON,
" %s performance measurement:\n\n", func_name );
trsWrite( TW_RUN | TW_CON,
" Conversion from DSL to PNL network took %g seconds\n"
" JTree inference engine creation took %g seconds\n"
" Average entering evidence time is %g seconds\n",
timeOfDSL2PNLConversion,
timeOfInfCreation,
averageTimeOfEnterEvidence );
delete pEvidence;
//CJtreeInfEngine::Release(&pJTreeInfEngine);
delete pJTreeInfEngine;
delete pBNet;
return trsResult( ret, ret == TRS_OK ? "No errors" : "JTree timing FAILED");
}
