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++;
}
}
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--;
}
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;
}
