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() ); }
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++; } }
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"); }
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; }