int testBKInfUsingClusters()
{
int ret = TRS_OK;
int seed = pnlTestRandSeed();
pnlSeed( seed );
std::cout<<"seed"<<seed<<std::endl;
int nTimeSlices = -1;
while(nTimeSlices <= 5)
{
trsiRead (&nTimeSlices, "10", "Number of slices");
}
float eps = -1.0f;
while( eps <= 0 )
{
trssRead( &eps, "1.0e-1f", "accuracy in test");
}
CDBN *pDBN = CDBN::Create( pnlExCreateBatNetwork() );
intVecVector clusters;
intVector interfNds;
pDBN->GetInterfaceNodes( &interfNds );
int numIntNds = interfNds.size();
int numOfClusters = pnlRand( 1, numIntNds );
clusters.resize(numOfClusters);
int i;
for( i = 0; i < numIntNds; i++ )
{
( clusters[pnlRand( 0, numOfClusters-1 )] ).push_back( interfNds[i] );
}
intVecVector validClusters;
validClusters.reserve(numOfClusters);
for( i = 0; i < clusters.size(); i++ )
{
if(! clusters[i].empty())
{
validClusters.push_back(clusters[i]);
}
}
CBKInfEngine *pBKInf;
pBKInf = CBKInfEngine::Create( pDBN, validClusters );
C1_5SliceJtreeInfEngine *pJTreeInf;
pJTreeInf = C1_5SliceJtreeInfEngine::Create( pDBN );
intVector nSlices( 1, nTimeSlices );
pEvidencesVecVector pEvid;
pDBN->GenerateSamples( &pEvid, nSlices);
int nnodesPerSlice = pDBN->GetNumberOfNodes();
intVector nodes(nnodesPerSlice, 0);
for( i = 0; i < nnodesPerSlice; i++ )
{
nodes[i] = i;
}
intVector ndsToToggle;
for( i = 0; i < nTimeSlices; i++ )
{
std::random_shuffle( nodes.begin(), nodes.end() );
ndsToToggle.resize( pnlRand(1, nnodesPerSlice) );
int j;
for( j = 0; j < ndsToToggle.size(); j++ )
{
ndsToToggle[j] = nodes[j];
}
(pEvid[0])[i]->ToggleNodeState( ndsToToggle );
}
pBKInf->DefineProcedure( ptSmoothing, nTimeSlices );
pBKInf->EnterEvidence( &(pEvid[0]).front(), nTimeSlices );
pBKInf->Smoothing();
pJTreeInf->DefineProcedure( ptSmoothing, nTimeSlices );
pJTreeInf->EnterEvidence( &pEvid[0].front(), nTimeSlices );
pJTreeInf->Smoothing();
int querySlice = pnlRand( 0, nTimeSlices - 1 );
int queryNode = pnlRand( 0, nnodesPerSlice - 1);
queryNode += (querySlice ? nnodesPerSlice : 0);
intVector query;
pDBN->GetGraph()->GetParents( queryNode, &query );
query.push_back( queryNode );
std::random_shuffle( query.begin(), query.end() );
query.resize( pnlRand(1, query.size()) );
pBKInf->MarginalNodes(&query.front(), query.size(), querySlice);
pJTreeInf->MarginalNodes(&query.front(), query.size(), querySlice);
const CPotential *potBK = pBKInf->GetQueryJPD();
const CPotential *potJTree = pJTreeInf->GetQueryJPD();
if( !potBK->IsFactorsDistribFunEqual( potJTree , eps ) )
{
std::cout<<"BK query JPD \n";
potBK->Dump();
std::cout<<"JTree query JPD \n";
potJTree->Dump();
ret = TRS_FAIL;
}
for( i = 0; i < nTimeSlices; i++ )
{
delete (pEvid[0])[i];
}
delete pBKInf;
delete pJTreeInf;
delete pDBN;
return trsResult( ret, ret == TRS_OK ? "No errors" :
"Bad test on BK Inference using clusters");
}
int main()
{
CBNet *pBNetForArHMM = pnlExCreateRndArHMM();
CDBN *pArHMM = CDBN::Create( pBNetForArHMM );
//Create an inference engine
C1_5SliceJtreeInfEngine* pInfEng;
pInfEng = C1_5SliceJtreeInfEngine::Create(pArHMM);
//Number of time slices for unrolling
int nTimeSlices = 5;
const CPotential* pQueryJPD;
//Crate evidence for every slice
CEvidence** pEvidences;
pEvidences = new CEvidence*[nTimeSlices];
//Let node 1 is always observed
const int obsNodesNums[] = { 1 };
valueVector obsNodesVals(1);
int i;
for( i = 0; i < nTimeSlices; i++ )
{
// Generate random value
obsNodesVals[0].SetInt(rand()%2);
pEvidences[i] = CEvidence::Create( pArHMM, 1, obsNodesNums,
obsNodesVals );
}
// Create smoothing procedure
pInfEng->DefineProcedure(ptSmoothing, nTimeSlices);
// Enter created evidences
pInfEng->EnterEvidence(pEvidences, nTimeSlices);
// Start smoothing process
pInfEng->Smoothing();
// Choose query set of nodes for every slice
int queryPrior[] = { 0 };
int queryPriorSize = 1;
int query[] = { 0, 2 };
int querySize = 2;
std::cout << " Results of smoothing " << std::endl;
int slice = 0;
pInfEng->MarginalNodes( queryPrior, queryPriorSize, slice );
pQueryJPD = pInfEng->GetQueryJPD();
ShowResultsForInference(pQueryJPD, slice);
//pQueryJPD->Dump();
std::cout << std::endl;
for( slice = 1; slice < nTimeSlices; slice++ )
{
pInfEng->MarginalNodes( query, querySize, slice );
pQueryJPD = pInfEng->GetQueryJPD();
ShowResultsForInference(pQueryJPD, slice);
//pQueryJPD->Dump();
}
slice = 0;
//Create filtering procedure
pInfEng->DefineProcedure( ptFiltering );
pInfEng->EnterEvidence( &(pEvidences[slice]), 1 );
pInfEng->Filtering( slice );
pInfEng->MarginalNodes( queryPrior, queryPriorSize );
pQueryJPD = pInfEng->GetQueryJPD();
std::cout << " Results of filtering " << std::endl;
ShowResultsForInference(pQueryJPD, slice);
//pQueryJPD->Dump();
for( slice = 1; slice < nTimeSlices; slice++ )
{
pInfEng->EnterEvidence( &(pEvidences[slice]), 1 );
pInfEng->Filtering( slice );
pInfEng->MarginalNodes( query, querySize );
pQueryJPD = pInfEng->GetQueryJPD();
ShowResultsForInference(pQueryJPD, slice);
//pQueryJPD->Dump();
}
//Create fixed-lag smoothing (online)
int lag = 2;
pInfEng->DefineProcedure( ptFixLagSmoothing, lag );
for (slice = 0; slice < lag + 1; slice++)
{
pInfEng->EnterEvidence( &(pEvidences[slice]), 1 );
}
std::cout << " Results of fixed-lag smoothing " << std::endl;
pInfEng->FixLagSmoothing( slice );
pInfEng->MarginalNodes( queryPrior, queryPriorSize );
pQueryJPD = pInfEng->GetQueryJPD();
ShowResultsForInference(pQueryJPD, slice);
//pQueryJPD->Dump();
std::cout << std::endl;
for( ; slice < nTimeSlices; slice++ )
{
pInfEng->EnterEvidence( &(pEvidences[slice]), 1 );
pInfEng->FixLagSmoothing( slice );
pInfEng->MarginalNodes( query, querySize );
pQueryJPD = pInfEng->GetQueryJPD();
ShowResultsForInference(pQueryJPD, slice);
//pQueryJPD->Dump();
}
delete pInfEng;
for( slice = 0; slice < nTimeSlices; slice++)
{
delete pEvidences[slice];
}
//Create learning procedure for DBN
pEvidencesVecVector evidencesOut;
const int nTimeSeries = 500;
printf("nTimeSlices: %d\n", nTimeSlices);
intVector nSlices(nTimeSeries);
printf("nSlices_len: %d\n", nSlices.size());
//define number of slices in the every time series
pnlRand(nTimeSeries, &nSlices.front(), 3, 20);
printf("nSlices_len: %d\n", nSlices.size());
for(int i=0; i<10; i++){
printf("%d ", nSlices[i]);
}
printf("]\n");
printf("es_len: %d\n", nSlices.size());
// Generate evidences in a random way
pArHMM->GenerateSamples( &evidencesOut, nSlices);
printf("v1: %d\n", evidencesOut.size());
printf("v2: %d\n", evidencesOut[0].size());
// Create DBN for learning
CDBN *pDBN = CDBN::Create(pnlExCreateRndArHMM());
// Create learning engine
CEMLearningEngineDBN *pLearn = CEMLearningEngineDBN::Create( pDBN );
// Set data for learning
pLearn->SetData( evidencesOut );
// Start learning
try
{
pLearn->Learn();
}
catch(CAlgorithmicException except)
{
std::cout << except.GetMessage() << std::endl;
}
std::cout<<"Leraning procedure"<<std::endl;
const CCPD *pCPD1, *pCPD2;
for( i = 0; i < 4; i++ )
{
std::cout<<" initial model"<<std::endl;
pCPD1 = static_cast<const CCPD*>( pArHMM->GetFactor(i) );
ShowCPD( pCPD1 );
std::cout<<" model after learning"<<std::endl;
pCPD2 = static_cast<const CCPD*>( pDBN->GetFactor(i) );
ShowCPD( pCPD2 );
}
for( i = 0; i < evidencesOut.size(); i++ )
{
int j;
for( j = 0; j < evidencesOut[i].size(); j++ )
{
delete evidencesOut[i][j];
}
}
delete pDBN;
delete pArHMM;
delete pLearn;
return 0;
}
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 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 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;
}
