int GibbsForSparseBNet( float eps)
{
CBNet *pDenseBnet;
CBNet *pSparseBnet;
CGibbsSamplingInfEngine *pGibbsInfDense;
CGibbsSamplingInfEngine *pGibbsInfSparse;
pEvidencesVector evidences;
const CPotential *pQueryPot1, *pQueryPot2;
int ret;
pDenseBnet = tCreateIncineratorBNet();
pSparseBnet = pDenseBnet->ConvertToSparse();
evidences.clear();
pDenseBnet->GenerateSamples( &evidences, 1 );
const int ndsToToggle1[] = { 0, 1, 3 };
evidences[0]->ToggleNodeState( 3, ndsToToggle1 );
const int querySz1 = 2;
const int query1[] = { 0, 1 };
pGibbsInfDense = CGibbsSamplingInfEngine::Create( pDenseBnet );
pGibbsInfSparse = CGibbsSamplingInfEngine::Create( pSparseBnet );
intVecVector queries(1);
queries[0].clear();
queries[0].push_back( 0 );
queries[0].push_back( 1 );
pGibbsInfSparse->SetQueries( queries );
pGibbsInfSparse->EnterEvidence( evidences[0] );
pGibbsInfSparse->MarginalNodes( query1, querySz1 );
pGibbsInfDense->SetQueries( queries );
pGibbsInfDense->EnterEvidence( evidences[0] );
pGibbsInfDense->MarginalNodes( query1, querySz1 );
pQueryPot1 = pGibbsInfDense->GetQueryJPD();
pQueryPot2 = pGibbsInfSparse->GetQueryJPD();
ret = pQueryPot1->IsFactorsDistribFunEqual( pQueryPot2, eps, 0 );
delete evidences[0];
delete pGibbsInfSparse;
delete pGibbsInfDense;
delete pDenseBnet;
delete pSparseBnet;
return ret;
}
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 GibbsForSingleGaussian(float eps)
{
std::cout<<std::endl<<"Using Gibbs for testing samples from gaussian"<<std::endl;
int nnodes = 1;
int numnt = 1;
CNodeType *nodeTypes = new CNodeType[numnt];
nodeTypes[0] = CNodeType(0,2);
intVector nodeAssociation = intVector(nnodes,0);
CGraph *graph;
graph = CGraph::Create(nnodes, 0, NULL, NULL);
CBNet *pBnet = CBNet::Create( nnodes, numnt, nodeTypes,
&nodeAssociation.front(),graph );
pBnet->AllocFactors();
pBnet->AllocFactor(0);
float mean[2] = {0.0f, 0.0f};
intVector ranges(2,1);
ranges[0] = 2;
///////////////////////////////////////////////////////////////////
CNumericDenseMatrix<float> *mean0 = CNumericDenseMatrix<float>::Create( 2, &ranges.front(), mean);
ranges[1] = 2;
float cov[4] = {1.0f, 0.3f, 0.3f, 1.0f};
CNumericDenseMatrix<float> *cov0 =
CNumericDenseMatrix<float>::Create( 2, &ranges.front(), cov);
pBnet->GetFactor(0)->AttachMatrix( mean0, matMean );
pBnet->GetFactor(0)->AttachMatrix( cov0, matCovariance );
/////////////////////////////////////////////////////////////////////
CGibbsSamplingInfEngine *pGibbsInf = CGibbsSamplingInfEngine::Create( pBnet );
pGibbsInf->SetBurnIn( 100 );
pGibbsInf->SetMaxTime( 5000 );
pEvidencesVector evidences;
pBnet->GenerateSamples(&evidences, 1 );
const int ndsToToggle[] = { 0 };
evidences[0]->ToggleNodeState( 1, ndsToToggle );
intVector query(1,0);
intVecVector queryes(1);
queryes[0].push_back(0);
pGibbsInf->SetQueries( queryes);
pGibbsInf->EnterEvidence( evidences[0] );
pGibbsInf->MarginalNodes( &query.front(),query.size() );
const CPotential *pQueryPot1 = pGibbsInf->GetQueryJPD();
std::cout<<"result of gibbs"<<std::endl<<std::endl;
pQueryPot1->Dump();
delete evidences[0];
delete pGibbsInf;
delete pBnet;
delete []nodeTypes;
return 1;
}
int GibbsForScalarGaussianBNet( float eps)
{
std::cout<<std::endl<<" Scalar gaussian BNet (5 nodes)"<< std::endl;
CBNet *pBnet;
pEvidencesVector evidences;
CGibbsSamplingInfEngine *pGibbsInf;
const CPotential *pQueryPot1, *pQueryPot2;
int i, ret;
////////////////////////////////////////////////////////////////////////
//Do the example from Satnam Alag's PhD thesis, UCB ME dept 1996 p46
//Make the following polytree, where all arcs point down
//
// 0 1
// \ /
// 2
// / \
// 3 4
//
//////////////////////////////////////////////////////////////////////
int nnodes = 5;
int numnt = 1;
CNodeType *nodeTypes = new CNodeType[numnt];
nodeTypes[0] = CNodeType(0,1);
intVector nodeAssociation = intVector(nnodes,0);
int nbs0[] = { 2 };
int nbs1[] = { 2 };
int nbs2[] = { 0, 1, 3, 4 };
int nbs3[] = { 2 };
int nbs4[] = { 2 };
ENeighborType ori0[] = { ntChild };
ENeighborType ori1[] = { ntChild };
ENeighborType ori2[] = { ntParent, ntParent, ntChild, ntChild };
ENeighborType ori3[] = { ntParent };
ENeighborType ori4[] = { ntParent };
int *nbrs[] = { nbs0, nbs1, nbs2, nbs3, nbs4 };
ENeighborType *orient[] = { ori0, ori1, ori2, ori3, ori4 };
intVector numNeighb = intVector(5,1);
numNeighb[2] = 4;
CGraph *graph;
graph = CGraph::Create(nnodes, &numNeighb.front(), nbrs, orient);
pBnet = CBNet::Create( nnodes, numnt, nodeTypes, &nodeAssociation.front(),graph );
pBnet->AllocFactors();
for( i = 0; i < nnodes; i++ )
{
pBnet->AllocFactor(i);
}
//now we need to create data for factors - we'll create matrices
floatVector smData = floatVector(1,0.0f);
floatVector bigData = floatVector(1,1.0f);
intVector ranges = intVector(2, 1);
ranges[0] = 1;
smData[0] = 1.0f;
CNumericDenseMatrix<float> *mean0 = CNumericDenseMatrix<float>::Create( 2, &ranges.front(), &smData.front());
bigData[0] = 4.0f;
CNumericDenseMatrix<float> *cov0 = CNumericDenseMatrix<float>::Create( 2, &ranges.front(), &bigData.front());
pBnet->GetFactor(0)->AttachMatrix(mean0, matMean);
pBnet->GetFactor(0)->AttachMatrix(cov0, matCovariance);
float val = 1.0f;
CNumericDenseMatrix<float> *mean1 = CNumericDenseMatrix<float>::Create( 2, &ranges.front(), &val );
CNumericDenseMatrix<float> *cov1 = CNumericDenseMatrix<float>::Create( 2, &ranges.front(), &val );
pBnet->GetFactor(1)->AttachMatrix(mean1, matMean);
pBnet->GetFactor(1)->AttachMatrix(cov1, matCovariance);
smData[0] = 0.0f;
CNumericDenseMatrix<float> *mean2 = CNumericDenseMatrix<float>::Create(2, &ranges.front(), &smData.front());
smData[0] = 2.0f;
CNumericDenseMatrix<float> *w21 = CNumericDenseMatrix<float>::Create(2, &ranges.front(), &smData.front());
bigData[0] = 2.0f;
CNumericDenseMatrix<float> *cov2 = CNumericDenseMatrix<float>::Create(2, &ranges.front(), &bigData.front());
bigData[0] = 1.0f;
CNumericDenseMatrix<float> *w20 = CNumericDenseMatrix<float>::Create(2, &ranges.front(), &bigData.front());
pBnet->GetFactor(2)->AttachMatrix( mean2, matMean );
pBnet->GetFactor(2)->AttachMatrix( cov2, matCovariance );
pBnet->GetFactor(2)->AttachMatrix( w20, matWeights,0 );
pBnet->GetFactor(2)->AttachMatrix( w21, matWeights,1 );
val = 0.0f;
CNumericDenseMatrix<float> *mean3 = CNumericDenseMatrix<float>::Create(2, &ranges.front(), &val);
val = 4.0f;
CNumericDenseMatrix<float> *cov3 = CNumericDenseMatrix<float>::Create(2, &ranges.front(), &val);
smData[0] = 1.1f;
CNumericDenseMatrix<float> *w30 = CNumericDenseMatrix<float>::Create(2, &ranges.front(), &smData.front());
pBnet->GetFactor(3)->AttachMatrix( mean3, matMean );
pBnet->GetFactor(3)->AttachMatrix( cov3, matCovariance );
pBnet->GetFactor(3)->AttachMatrix( w30, matWeights,0 );
smData[0] = -0.8f;
CNumericDenseMatrix<float> *mean4 = CNumericDenseMatrix<float>::Create(2, &ranges.front(), &smData.front());
bigData[0] = 1.2f;
CNumericDenseMatrix<float> *cov4 = CNumericDenseMatrix<float>::Create(2, &ranges.front(), &bigData.front());
bigData[0] = 2.0f;
CNumericDenseMatrix<float> *w40 = CNumericDenseMatrix<float>::Create(2, &ranges.front(), &bigData.front());
pBnet->GetFactor(4)->AttachMatrix( mean4, matMean );
pBnet->GetFactor(4)->AttachMatrix( cov4, matCovariance );
pBnet->GetFactor(4)->AttachMatrix( w40, matWeights,0 );
evidences.clear();
pBnet->GenerateSamples( &evidences, 1 );
const int ndsToToggle2[] = { 0, 1, 2 };
evidences[0]->ToggleNodeState( 3, ndsToToggle2 );
const int *flags1 = evidences[0]->GetObsNodesFlags();
std::cout<<"observed nodes"<<std::endl;
for( i = 0; i < pBnet->GetNumberOfNodes(); i++ )
{
if ( flags1[i] )
{
std::cout<<"node "<<i<<"; ";
}
}
std::cout<<std::endl<<std::endl;
const int querySz2 = 1;
const int query2[] = { 0 };
CNaiveInfEngine *pNaiveInf = CNaiveInfEngine::Create(pBnet);
pNaiveInf->EnterEvidence( evidences[0] );
pNaiveInf->MarginalNodes( query2,querySz2 );
pGibbsInf = CGibbsSamplingInfEngine::Create( pBnet );
pGibbsInf->SetNumStreams( 1 );
pGibbsInf->SetMaxTime( 10000 );
pGibbsInf->SetBurnIn( 1000 );
intVecVector queries(1);
queries[0].clear();
queries[0].push_back( 0 );
//queries[0].push_back( 2 );
pGibbsInf->SetQueries( queries );
pGibbsInf->EnterEvidence( evidences[0] );
pGibbsInf->MarginalNodes( query2, querySz2 );
pQueryPot1 = pGibbsInf->GetQueryJPD();
pQueryPot2 = pNaiveInf->GetQueryJPD();
std::cout<<"result of gibbs"<<std::endl<<std::endl;
pQueryPot1->Dump();
std::cout<<"result of naive"<<std::endl;
pQueryPot2->Dump();
ret = pQueryPot1->IsFactorsDistribFunEqual( pQueryPot2, eps, 0 );
delete evidences[0];
delete pNaiveInf;
delete pGibbsInf;
delete pBnet;
return ret;
////////////////////////////////////////////////////////////////////////////////////////
}
int GibbsForSimplestGaussianBNet( float eps)
{
std::cout<<std::endl<<"Gibbs for simplest gaussian BNet (3 nodes) "<<std::endl;
int nnodes = 3;
int numnt = 2;
CNodeType *nodeTypes = new CNodeType[numnt];
nodeTypes[0] = CNodeType(0,1);
nodeTypes[1] = CNodeType(0,2);
intVector nodeAssociation = intVector(nnodes,1);
nodeAssociation[0] = 0;
int nbs0[] = { 1 };
int nbs1[] = { 0, 2 };
int nbs2[] = { 1 };
ENeighborType ori0[] = { ntChild };
ENeighborType ori1[] = { ntParent, ntChild };
ENeighborType ori2[] = { ntParent };
int *nbrs[] = { nbs0, nbs1, nbs2 };
ENeighborType *orient[] = { ori0, ori1, ori2 };
intVector numNeighb = intVector(3);
numNeighb[0] = 1;
numNeighb[1] = 2;
numNeighb[2] = 1;
CGraph *graph;
graph = CGraph::Create(nnodes, &numNeighb.front(), nbrs, orient);
CBNet *pBnet = CBNet::Create( nnodes, numnt, nodeTypes,
&nodeAssociation.front(),graph );
pBnet->AllocFactors();
for(int i = 0; i < nnodes; i++ )
{
pBnet->AllocFactor(i);
}
floatVector data(1,0.0f);
intVector ranges(2,1);
///////////////////////////////////////////////////////////////////
CNumericDenseMatrix<float> *mean0 =
CNumericDenseMatrix<float>::Create( 2, &ranges.front(), &data.front());
data[0] = 0.3f;
CNumericDenseMatrix<float> *cov0 =
CNumericDenseMatrix<float>::Create( 2, &ranges.front(), &data.front());
pBnet->GetFactor(0)->AttachMatrix( mean0, matMean );
pBnet->GetFactor(0)->AttachMatrix( cov0, matCovariance );
/////////////////////////////////////////////////////////////////////
ranges[0] = 2;
data.resize(2);
data[0] = -1.0f;
data[1] = 0.0f;
CNumericDenseMatrix<float> *mean1 =
CNumericDenseMatrix<float>::Create( 2, &ranges.front(), &data.front());
ranges[1] = 2;
data.resize(4);
data[0] = 1.0f;
data[1] = 0.1f;
data[3] = 3.0f;
data[2] = 0.1f;
CNumericDenseMatrix<float> *cov1 =
CNumericDenseMatrix<float>::Create( 2, &ranges.front(), &data.front());
ranges[1] =1;
data.resize(2);
data[0] = 1.0f;
data[1] = 0.5f;
CNumericDenseMatrix<float> *weight1 =
CNumericDenseMatrix<float>::Create( 2, &ranges.front(), &data.front());
pBnet->GetFactor(1)->AttachMatrix( mean1, matMean );
pBnet->GetFactor(1)->AttachMatrix( cov1, matCovariance );
pBnet->GetFactor(1)->AttachMatrix( weight1, matWeights,0 );
///////////////////////////////////////////////////////////////////////////
ranges[0] = 2;
data.resize(2);
data[0] = 1.0f;
data[1] = 20.5f;
CNumericDenseMatrix<float> *mean2 =
CNumericDenseMatrix<float>::Create( 2, &ranges.front(), &data.front());
ranges[1] = 2;
data.resize(4);
data[0] = 1.0f;
data[1] = 0.0f;
data[3] = 9.0f;
data[2] = 0.0f;
CNumericDenseMatrix<float> *cov2 =
CNumericDenseMatrix<float>::Create( 2, &ranges.front(), &data.front());
data.resize(2);
data[0] = 1.0f;
data[1] = 3.5f;
data[2] = 1.0f;
data[3] = 0.5f;
CNumericDenseMatrix<float> *weight2 =
CNumericDenseMatrix<float>::Create( 2, &ranges.front(), &data.front());
pBnet->GetFactor(2)->AttachMatrix( mean2, matMean );
pBnet->GetFactor(2)->AttachMatrix( cov2, matCovariance );
pBnet->GetFactor(2)->AttachMatrix( weight2, matWeights,0 );
///////////////////////////////////////////////////////////////////////////
pEvidencesVector evidences;
pBnet->GenerateSamples( &evidences, 1 );
const int ndsToToggle[] = { 0, 1 };
evidences[0]->ToggleNodeState( 2, ndsToToggle );
intVector query(1,1);
CNaiveInfEngine *pNaiveInf = CNaiveInfEngine::Create(pBnet);
pNaiveInf->EnterEvidence( evidences[0] );
pNaiveInf->MarginalNodes( &query.front(),query.size() );
CGibbsSamplingInfEngine *pGibbsInf = CGibbsSamplingInfEngine::Create( pBnet );
intVecVector queryes(1);
queryes[0].push_back(1);
pGibbsInf->SetQueries( queryes);
pGibbsInf->EnterEvidence( evidences[0] );
pGibbsInf->MarginalNodes( &query.front(),query.size() );
const CPotential *pQueryPot1 = pGibbsInf->GetQueryJPD();
const CPotential *pQueryPot2 = pNaiveInf->GetQueryJPD();
std::cout<<"result of gibbs"<<std::endl<<std::endl;
pQueryPot1->Dump();
std::cout<<"result of naive"<<std::endl;
pQueryPot2->Dump();
int ret = pQueryPot1->IsFactorsDistribFunEqual( pQueryPot2, eps, 0 );
delete evidences[0];
delete pNaiveInf;
delete pGibbsInf;
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;
///////////////////////////////////////////////////////////////////////////////
}
int testSetStatistics()
{
int ret = TRS_OK;
float eps = 0.1f;
int seed = pnlTestRandSeed();
pnlSeed( seed );
CBNet *pBNet = pnlExCreateCondGaussArBNet();
CModelDomain *pMD = pBNet->GetModelDomain();
CGraph *pGraph = CGraph::Copy(pBNet->GetGraph());
CBNet *pBNet1 = CBNet::CreateWithRandomMatrices( pGraph, pMD );
pEvidencesVector evidences;
int nEvidences = pnlRand( 3000, 4000);
pBNet->GenerateSamples( &evidences, nEvidences );
int i;
for( i = 0; i < nEvidences; i++)
{
//evidences[i]->MakeNodeHiddenBySerialNum(0);
}
CEMLearningEngine *pLearn = CEMLearningEngine::Create(pBNet1);
pLearn->SetData( nEvidences, &evidences.front() );
pLearn->SetMaxIterEM();
pLearn->Learn();
for( i = 0; i < pBNet->GetNumberOfFactors(); i++ )
{
if( ! pBNet->GetFactor(i)->IsFactorsDistribFunEqual(pBNet1->GetFactor(i), eps))
{
ret = TRS_FAIL;
pBNet->GetFactor(i)->GetDistribFun()->Dump();
pBNet1->GetFactor(i)->GetDistribFun()->Dump();
}
}
CDistribFun *pDistr;
const CMatrix<float>* pMat;
CFactor *pCPD;
pDistr = pBNet1->GetFactor(0)->GetDistribFun();
pMat = pDistr->GetStatisticalMatrix(stMatTable);
pCPD = pBNet->GetFactor(0);
pCPD->SetStatistics(pMat, stMatTable);
pCPD->ProcessingStatisticalData(nEvidences);
if( ! pCPD->IsFactorsDistribFunEqual(pBNet1->GetFactor(0), 0.0001f) )
{
ret = TRS_FAIL;
}
pDistr = pBNet1->GetFactor(1)->GetDistribFun();
int parentVal;
pCPD = pBNet->GetFactor(1);
parentVal = 0;
pCPD->SetStatistics(pMat, stMatCoeff);
pMat = pDistr->GetStatisticalMatrix(stMatMu, &parentVal);
pCPD->SetStatistics(pMat, stMatMu, &parentVal);
pMat = pDistr->GetStatisticalMatrix(stMatSigma, &parentVal);
pCPD->SetStatistics(pMat, stMatSigma, &parentVal);
parentVal = 1;
pMat = pDistr->GetStatisticalMatrix(stMatMu, &parentVal);
pCPD->SetStatistics(pMat, stMatMu, &parentVal);
pMat = pDistr->GetStatisticalMatrix(stMatSigma, &parentVal);
pCPD->SetStatistics(pMat, stMatSigma, &parentVal);
pCPD->ProcessingStatisticalData(nEvidences);
if( ! pCPD->IsFactorsDistribFunEqual(pBNet1->GetFactor(1), eps) )
{
ret = TRS_FAIL;
}
for( i = 0; i < nEvidences; i++)
{
delete evidences[i];
}
delete pLearn;
delete pBNet1;
delete pBNet;
return trsResult( ret, ret == TRS_OK ? "No errors" :
"Bad test on SetStatistics");
}
int main()
{
PNL_USING
//we create very small model to start inference on it
// the model is from Kevin Murphy's BNT\examples\static\belprop_polytree_gaussain
/*
Do the example from Satnam Alag's PhD thesis, UCB ME dept 1996 p46
Make the following polytree, where all arcs point down
0 1
\ /
2
/ \
3 4
*/
int i;
//create this model
int nnodes = 5;
int numnt = 2;
CNodeType *nodeTypes = new CNodeType[numnt];
nodeTypes[0] = CNodeType(0,2);
nodeTypes[1] = CNodeType(0,1);
intVector nodeAssociation = intVector(nnodes,0);
nodeAssociation[1] = 1;
nodeAssociation[3] = 1;
int nbs0[] = { 2 };
int nbs1[] = { 2 };
int nbs2[] = { 0, 1, 3, 4 };
int nbs3[] = { 2 };
int nbs4[] = { 2 };
int *nbrs[] = { nbs0, nbs1, nbs2, nbs3, nbs4 };
int numNeighb[] = {1, 1, 4, 1, 1};
ENeighborType ori0[] = { ntChild };
ENeighborType ori1[] = { ntChild };
ENeighborType ori2[] = { ntParent, ntParent, ntChild, ntChild };
ENeighborType ori3[] = { ntParent };
ENeighborType ori4[] = { ntParent };
ENeighborType *orient[] = { ori0, ori1, ori2, ori3, ori4 };
CGraph *pGraph;
pGraph = CGraph::Create(nnodes, numNeighb, nbrs, orient);
CBNet *pBNet;
pBNet = CBNet::Create( nnodes, numnt, nodeTypes, &nodeAssociation.front(), pGraph );
//Allocation space for all factors of the model
pBNet->AllocFactors();
for( i = 0; i < nnodes; i++ )
{
//Allocation space for all matrices of CPD
pBNet->AllocFactor(i);
}
//now we need to create data for CPDs - we'll create matrices
CFactor *pCPD;
floatVector smData = floatVector(2,0.0f);
floatVector bigData = floatVector(4,1.0f);
intVector ranges = intVector(2, 1);
ranges[0] = 2;
smData[0] = 1.0f;
CNumericDenseMatrix<float> *mean0 = CNumericDenseMatrix<float>::
Create( 2, &ranges.front(), &smData.front());
bigData[0] = 4.0f;
bigData[3] = 4.0f;
ranges[1] = 2;
CNumericDenseMatrix<float> *cov0 = CNumericDenseMatrix<float>::
Create( 2, &ranges.front(), &bigData.front());
pCPD = pBNet->GetFactor(0);
pCPD->AttachMatrix(mean0, matMean);
pCPD->AttachMatrix(cov0, matCovariance);
ranges[0] = 1;
ranges[1] = 1;
float val = 1.0f;
CNumericDenseMatrix<float> *mean1 = CNumericDenseMatrix<float>::
Create( 2, &ranges.front(), &val );
CNumericDenseMatrix<float> *cov1 = CNumericDenseMatrix<float>::
Create( 2, &ranges.front(), &val );
pCPD = pBNet->GetFactor(1);
pCPD->AttachMatrix(mean1, matMean);
pCPD->AttachMatrix(cov1, matCovariance);
smData[0] = 0.0f;
smData[1] = 0.0f;
ranges[0] = 2;
CNumericDenseMatrix<float> *mean2 = CNumericDenseMatrix<float>::
Create(2, &ranges.front(), &smData.front());
smData[0] = 2.0f;
smData[1] = 1.0f;
CNumericDenseMatrix<float> *w21 = CNumericDenseMatrix<float>::
Create(2, &ranges.front(), &smData.front());
bigData[0] = 2.0f;
bigData[1] = 1.0f;
bigData[2] = 1.0f;
bigData[3] = 1.0f;
ranges[1] = 2;
CNumericDenseMatrix<float> *cov2 = CNumericDenseMatrix<float>::
Create(2, &ranges.front(), &bigData.front());
bigData[0] = 1.0f;
bigData[1] = 2.0f;
bigData[2] = 1.0f;
bigData[3] = 0.0f;
CNumericDenseMatrix<float> *w20 = CNumericDenseMatrix<float>::
Create(2, &ranges.front(), &bigData.front());
pCPD = pBNet->GetFactor(2);
pCPD->AttachMatrix( mean2, matMean );
pCPD->AttachMatrix( cov2, matCovariance );
pCPD->AttachMatrix( w20, matWeights,0 );
pCPD->AttachMatrix( w21, matWeights,1 );
val = 0.0f;
ranges[0] = 1;
ranges[1] = 1;
CNumericDenseMatrix<float> *mean3 = CNumericDenseMatrix<float>::
Create(2, &ranges.front(), &val);
val = 1.0f;
CNumericDenseMatrix<float> *cov3 = CNumericDenseMatrix<float>::
Create(2, &ranges.front(), &val);
ranges[1] = 2;
smData[0] = 1.0f;
smData[1] = 1.0f;
CNumericDenseMatrix<float> *w30 = CNumericDenseMatrix<float>::
Create(2, &ranges.front(), &smData.front());
pCPD = pBNet->GetFactor(3);
pCPD->AttachMatrix( mean3, matMean );
pCPD->AttachMatrix( cov3, matCovariance );
pCPD->AttachMatrix( w30, matWeights,0 );
ranges[0] = 2;
ranges[1] = 1;
smData[0] = 0.0f;
smData[1] = 0.0f;
CNumericDenseMatrix<float> *mean4 = CNumericDenseMatrix<float>::
Create(2, &ranges.front(), &smData.front());
ranges[1] = 2;
bigData[0] = 1.0f;
bigData[1] = 0.0f;
bigData[2] = 0.0f;
bigData[3] = 1.0f;
CNumericDenseMatrix<float> *cov4 = CNumericDenseMatrix<float>::
Create(2, &ranges.front(), &bigData.front());
bigData[2] = 1.0f;
CNumericDenseMatrix<float> *w40 = CNumericDenseMatrix<float>::
Create(2, &ranges.front(), &bigData.front());
pCPD = pBNet->GetFactor(4);
pCPD->AttachMatrix( mean4, matMean );
pCPD->AttachMatrix( cov4, matCovariance );
pCPD->AttachMatrix( w40, matWeights,0 );
//Generate random evidences for the modes
int nEv = 1000;
pEvidencesVector evid;
pBNet->GenerateSamples( &evid, nEv );
/////////////////////////////////////////////////////////////////////
//Create copy of initial model with random matrices
CGraph *pGraphCopy = CGraph::Copy(pGraph);
CBNet *pLearnBNet = CBNet::CreateWithRandomMatrices(pGraphCopy, pBNet->GetModelDomain() );
// Creating learning process
CEMLearningEngine *pLearn = CEMLearningEngine::Create(pLearnBNet);
pLearn->SetData(nEv, &evid.front());
pLearn->Learn();
CNumericDenseMatrix<float> *pMatrix;
int length = 0;
const float *output;
///////////////////////////////////////////////////////////////////////
std::cout<<" results of learning (number of evidences = "<<nEv<<std::endl;
for (i = 0; i < nnodes; i++ )
{
int j;
std::cout<<"\n matrix mean for node "<<i;
std::cout<<"\n initial BNet \n";
pMatrix = static_cast<CNumericDenseMatrix<float>*>
(pBNet->GetFactor(i)->GetMatrix(matMean));
pMatrix->GetRawData(&length, &output);
for ( j = 0; j < length; j++ )
{
std::cout<<" "<<output[j];
}
std::cout<<"\n BNet with random matrices after learning \n ";
pMatrix = static_cast<CNumericDenseMatrix<float>*>
(pLearnBNet->GetFactor(i)->GetMatrix(matMean));
pMatrix->GetRawData(&length, &output);
for ( j = 0; j < length; j++)
{
std::cout<<" "<<output[j];
}
std::cout<<"\n \n matrix covariance for node "<<i<<'\n';
std::cout<<"\n initial BNet \n";
pMatrix = static_cast<CNumericDenseMatrix<float>*>
(pBNet->GetFactor(i)->GetMatrix(matCovariance));
pMatrix->GetRawData(&length, &output);
for (j = 0; j < length; j++ )
{
std::cout<<" "<<output[j];
}
std::cout<<"\n BNet with random matrices after learning \n ";
pMatrix = static_cast<CNumericDenseMatrix<float>*>
(pLearnBNet->GetFactor(i)->GetMatrix(matCovariance));
pMatrix->GetRawData(&length, &output);
for ( j = 0; j < length; j++ )
{
std::cout<<" "<<output[j];
}
std::cout<<"\n ___________________________\n";
}
for( i = 0; i < nEv; i++)
{
delete evid[i];
}
delete pLearn;
delete pLearnBNet;
delete pBNet;
return 1;
}