示例#1
0
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;

    ////////////////////////////////////////////////////////////////////////////////////////
}
示例#2
0
CBNet *CreateTestTabularNetWithDecTreeNodeBNet()
{
	//   Baysam network     
	//        0 1...8 9       0,1, 9- discrete nodes distribution type is tabular, size is 2
	//        \ \  / /      10 - is discrete desigion tree node
	//            10        
	//          
	//      
	//
	// Desigion tree on the node 10 is
	//
	//     0
	//    / \	
	//   1	 2
	//  / \ / \
	// 3  4 5  6
	//  	   
    const int nnodes = 11; //Number of nodes
    const int numNt =  1; //number of Node types (all nodes are discrete)
    CNodeType* nodeTypes = new CNodeType [numNt];
	int size = 2;
    int i;
	nodeTypes[0] = CNodeType( 1,size );
    int *nodeAssociation = new int[nnodes];
    for( i = 0; i < nnodes; i++ )
	{
		nodeAssociation[i] = 0;
	};
    int *numOfNeigh;
    numOfNeigh = new int[nnodes];

	for( i = 0; i < nnodes - 1; i++ )
	{
		numOfNeigh[i] = 1;
	};
	numOfNeigh[nnodes - 1] = nnodes - 1;

    int **neigh;
	neigh = new int*[nnodes];
    for( i = 0; i < nnodes - 1; i++ )
	{
		neigh[i] = new int;
		neigh[i][0] = nnodes - 1;

	};
	neigh[nnodes - 1] = new int[nnodes - 1];

    for( i = 0; i < nnodes - 1; i++ )
	{
		neigh[nnodes - 1][i] = i;
	};

	ENeighborType **orient;
    orient = new ENeighborType*[nnodes];

	for( i = 0; i < nnodes - 1; i++ )
	{
		orient[i] = new ENeighborType;
		orient[i][0] = ntChild;

	};
    
	orient[nnodes - 1] = new ENeighborType[nnodes - 1];

	for( i = 0; i < nnodes - 1; i++ )
	{
		orient[nnodes - 1][i] = ntParent;
	};

    CGraph* pGraph = CGraph::Create( nnodes, numOfNeigh, neigh, orient);

    //Create static BNet
    CBNet* pBNet = CBNet::Create( nnodes, numNt, nodeTypes, nodeAssociation, pGraph );
    pBNet->AllocFactors();


    int nnodesInDom = 1;
    int *domains;
	domains = new int[nnodes -1];
	for( i = 0; i < nnodes - 1; i++ )
	{
		domains[i] = i;
	};
    float table[] = { 0.3f, 0.7f};

    CTabularCPD **pCPDPar;
	pCPDPar = new CTabularCPD*[nnodes - 1];
	for( i = 0; i < nnodes - 1; i++ )
	{
		pCPDPar[i] = CTabularCPD::Create( &domains[i], nnodesInDom, pBNet->GetModelDomain(), table );
		pBNet->AttachFactor(pCPDPar[i]);
	};	
		

    int nnodesInChilddom = nnodes;
	int *domainChild; 
	domainChild = new int[ nnodes ];

		for( i = 0; i < nnodes; i++ )
		{
			domainChild[i] = i;
		};

    CTreeCPD *pCPDChild = CTreeCPD::Create( domainChild, nnodesInChilddom, pBNet->GetModelDomain());
    // creating tree on node 11
	// 1) start of graph creation
     const int nnodesT = 7; 
    int numOfNeighT[] = {2, 3, 3, 1, 1, 1, 1 };
    int neigh0T[] = {1, 2};
    int neigh1T[] = {0, 3, 4};
    int neigh2T[] = {0, 5, 6};
    int neigh3T[] = {1};
    int neigh4T[] = {1};
    int neigh5T[] = {2};
    int neigh6T[] = {2};
    

    ENeighborType orient0T[] = { ntChild, ntChild };
    ENeighborType orient1T[] = { ntParent, ntChild, ntChild };
    ENeighborType orient2T[] = { ntParent, ntChild, ntChild  };
    ENeighborType orient3T[] = { ntParent };
    ENeighborType orient4T[] = { ntParent };
    ENeighborType orient5T[] = { ntParent };
    ENeighborType orient6T[] = { ntParent };
   

    int *neighT[] = { neigh0T, neigh1T, neigh2T, neigh3T, neigh4T, neigh5T, neigh6T };
    ENeighborType *orientT[] = { orient0T, orient1T, orient2T, orient3T, orient4T, orient5T, orient6T };

    CGraph* pGraphT = CGraph::Create( nnodesT, numOfNeighT, neighT, orientT);
    // end of graph creation
	// 2) start of filling tree nodes
    TreeNodeFields fnode0; //This structures will contain properties of all     
    TreeNodeFields fnode1; //tree nodes 
    TreeNodeFields fnode2; //
    TreeNodeFields fnode3; //
    TreeNodeFields fnode4; //
    TreeNodeFields fnode5; //
    TreeNodeFields fnode6; //

	// start of filling information of node 0  
    fnode0.isTerminal = false; // means that this node is split
    fnode0.Question = 0; // question type on node 0. 
	                     // Value 0 means that that question type is "="
						 //	Value 1 means that that question type is ">"
    fnode0.questionValue = 0; //Asking value
    fnode0.node_index = 0;    // Index of asked desigion tree parent
	// end of filling information of node 0  

    // start of filling information of node 1  
    fnode1.isTerminal = false;
    fnode1.Question = 0;
    fnode1.questionValue = 0;
    fnode1.node_index = 1;
    // end of filling information of node 1  
    
    // start of filling information of node 2 
    fnode2.isTerminal = false;
    fnode2.Question = 0;
    fnode2.questionValue = 0;
    fnode2.node_index = 1;
	// end of filling information of node 2  

	// start of filling information of node 3	
    fnode3.isTerminal = true; //means that this node is terminal
    fnode3.probVect = new float[2];
    fnode3.probVect[0] = 0.3f;  //Terminal nodes probabilities.
    fnode3.probVect[1] = 0.7f;  //This properties doesn`t fill when desigion tree node
								// is continuous node.
	// end of filling information of node 3
    
	// start of filling information of node 4
    fnode4.isTerminal = true;
    fnode4.probVect = new float[2];
    fnode4.probVect[0] = 0.6f;
    fnode4.probVect[1] = 0.4f;
	// end of filling information of node 4

    // start of filling information of node 5
    fnode5.isTerminal = true;
    fnode5.probVect = new float[2];
    fnode5.probVect[0] = 0.9f;
    fnode5.probVect[1] = 0.1f;
	// end of filling information of node 5

	// start of filling information of node 6
    fnode6.isTerminal = true;
    fnode6.probVect = new float[2];
    fnode6.probVect[0] = 0.2f;
    fnode6.probVect[1] = 0.8f;
	// end of filling information of node 6
   
    TreeNodeFields fields[7];
    fields[0] = fnode0;
    fields[1] = fnode1;
    fields[2] = fnode2;
    fields[3] = fnode3;
    fields[4] = fnode4;
    fields[5] = fnode5;
    fields[6] = fnode6;
   
   
    pCPDChild->UpdateTree(pGraphT,fields);
    pBNet->AttachFactor(pCPDChild);
    return pBNet;
}
示例#3
0
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;

}
示例#4
0
void CBICLearningEngine::Learn()
{
    CEMLearningEngine *pLearn = NULL;

    float resultBIC = -FLT_MAX;
    CBNet *pResultBNet = NULL;
    intVector resultOrder;
    
    
    pEvidencesVector pEv(m_Vector_pEvidences.size(), NULL );
    
    CModelDomain *pMD = m_pGrModel->GetModelDomain();
    
    int nnodes = m_pGrModel->GetNumberOfNodes();
    
    nodeTypeVector varTypes;
    pMD->GetVariableTypes(&varTypes);

    intVector varAss( pMD->GetVariableAssociations(), pMD->GetVariableAssociations() + nnodes );
       
    intVector currentAssociation(nnodes);
    intVector currentObsNodes(nnodes);
    int i;
    for( i = 0; i < nnodes; i++ )
    {
	currentObsNodes[i] = i;
    }

    CGraph *pGraph = CGraph::Create(nnodes, NULL, NULL, NULL);
    CBNet *pBNet;
    int lineSz = int( nnodes * ( nnodes - 1 ) / 2 );
    intVecVector connect;
    intVector indexes(lineSz, 0);
    int startNode, endNode;
    int ind;
    for( ind = 0; ind < lineSz ; )
    {
	if( indexes[ind] == 1 )
	{
	    FindNodesByNumber(&startNode, &endNode, nnodes, ind);
	    pGraph->RemoveEdge(startNode, endNode );
	    indexes[ind] = 0;
	    ind++;
	}
	else
	{
	    FindNodesByNumber(&startNode, &endNode, nnodes, ind);
	    pGraph->AddEdge(startNode, endNode, 1 );
	    indexes[ind] = 1;
	    ind = 0;
	    connect.clear();
	    pGraph->GetConnectivityComponents(&connect);
	    if( connect.size() == 1 )
	    {
		
		do
		{
		    CGraph *pCopyGraph = CGraph::Copy(pGraph);
		    int j;
		    for( j = 0; j < nnodes; j++ )
		    {
			currentAssociation[j] = varAss[currentObsNodes[j]];
		    }
		    
		    pBNet = CBNet::Create(nnodes, varTypes, currentAssociation, pCopyGraph);
		    pBNet->AllocFactors();
		    for( j = 0; j < nnodes; j++ )
		    {
			pBNet->AllocFactor( j );
			pBNet->GetFactor(j)->CreateAllNecessaryMatrices();
		    }

		    int dimOfModel = DimOfModel(pBNet);
		    int k;
		    for( k = 0; k < pEv.size(); k++ )
		    {
			valueVector vls; 
			m_Vector_pEvidences[k]->GetRawData(&vls);
			pEv[k] = CEvidence::Create( pBNet->GetModelDomain(),currentObsNodes, vls );
		    }
		    
		    
		    pLearn = CEMLearningEngine::Create(pBNet);
		    pLearn->SetData(pEv.size(), &pEv.front());
		    pLearn->Learn();
		    int nsteps;
		    const float *score;
		    pLearn->GetCriterionValue(&nsteps, &score);
		    float log_lik = score[nsteps-1];
		    float BIC = log_lik - 0.5f*float( dimOfModel*log(float(pEv.size())) );
		    
		    if( BIC >= resultBIC )
		    {
			delete pResultBNet;
			resultBIC = BIC;
			m_critValue.push_back(BIC);
			pResultBNet = pBNet;
			resultOrder.assign( currentObsNodes.begin(), currentObsNodes.end() );
		    }
		    else
		    {
			delete pBNet;
		    }
		    for( k = 0; k < pEv.size(); k++ )
		    {
			delete pEv[k];
		    }

		    delete pLearn;
		}while(std::next_permutation(currentObsNodes.begin(), currentObsNodes.end()));
		
	    }
	    
	}
    }
    
    delete pGraph;
    m_pResultGrModel = pResultBNet;
    m_resultRenaming.assign(resultOrder.begin(), resultOrder.end());
    
}
CBNet* CreateBNet()
{
	// Creation Water-Sprinkler Bayesian network

	const int numOfNds = 4;//*<-

	// 1 STEP:
	// need to specify the graph structure of the model;
	// there are two way to do it

	CGraph *pGraph;

		// Graph creation using neighbors list

		int numOfNbrs[numOfNds] = { 2, 2, 2, 2 };//*<-
		int nbrs0[] = { 1, 2 };//*<-
		int nbrs1[] = { 0, 3 };//*<-
		int nbrs2[] = { 0, 3 };//*<-
		int nbrs3[] = { 1, 2 };//*<-

		// number of neighbors for every node
		int *nbrs[] = { nbrs0, nbrs1, nbrs2, nbrs3 };//*<-

		// neighbors can be of either one of the three following types:
		// a parent, a child (for directed arcs) or just a neighbor (for undirected graphs).
		// Accordingly, the types are ntParent, ntChild or ntNeighbor.

		ENeighborType nbrsTypes0[] = { ntChild, ntChild };//*<-
		ENeighborType nbrsTypes1[] = { ntParent, ntChild };//*<-
		ENeighborType nbrsTypes2[] = { ntParent, ntChild };//*<-
		ENeighborType nbrsTypes3[] = { ntParent, ntParent };//*<-

		ENeighborType *nbrsTypes[] = { nbrsTypes0, nbrsTypes1,nbrsTypes2, nbrsTypes3 };//*<-

		// this is creation of a directed graph for the BNet model using neighbors list
		pGraph = CGraph::Create( numOfNds, numOfNbrs, nbrs, nbrsTypes );

	// 2 STEP:
	// Creation NodeType objects and specify node types for all nodes of the model.

	nodeTypeVector  nodeTypes;

	// number of node types is 1, because all nodes are of the same type
	// all four are discrete and binary
	CNodeType nt(1,2);//*<-
	nodeTypes.push_back(nt);

	intVector nodeAssociation;
	// reflects association between node numbers and node types
	// nodeAssociation[k] is a number of node type object in the
	// node types array for the k-th node
	nodeAssociation.assign(numOfNds, 0);

	// 2 STEP:
	// Creation base for BNet using Graph, types of nodes and nodes association

	CBNet* pBNet = CBNet::Create( numOfNds, nodeTypes, nodeAssociation, pGraph );

	// 3 STEP:
	// Allocation space for all factors of the model
	pBNet->AllocFactors();

	// 4 STEP:
	// Creation factors and attach their to model

	//create raw data tables for CPDs
	float table0[] = { 0.5f, 0.5f };//*<-
	float table1[] = { 0.5f, 0.5f, 0.9f, 0.1f };
	float table2[] = { 0.8f, 0.2f, 0.2f, 0.8f };
	float table3[] = { 1.0f, 0.0f, 0.1f, 0.9f, 0.1f, 0.9f, 0.01f, 0.99f };

	float* table[] = { table0, table1, table2, table3 };//*<-

	int i;
	for( i = 0; i < numOfNds; ++i )
	{
		pBNet->AllocFactor(i);

		CFactor* pFactor = pBNet->GetFactor(i);

		pFactor->AllocMatrix( table[i], matTable );
	}

	return pBNet;
}
示例#6
0
CBNet* CreateRandomBayessian(CGraph* pGraph, int max_num_states)
{
    PNL_CHECK_LEFT_BORDER( max_num_states, 1 );
    PNL_CHECK_IF_MEMORY_ALLOCATED( pGraph );

    if( !pGraph->IsDAG() )
    {
        PNL_THROW( CInconsistentType, " the graph should be a DAG " );
    }
    if( !pGraph->IsTopologicallySorted() )
    {
        PNL_THROW( CInconsistentType, 
            " the graph should be sorted topologically " );
    }
    if (pGraph->NumberOfConnectivityComponents() > 1)
    {
        PNL_THROW( CInconsistentType, " the graph should be linked " );
    }

    int i, j, k;

    int num_nodes = pGraph->GetNumberOfNodes();
    CNodeType *nodeTypes = new CNodeType [num_nodes];
    int num_states;
    
    for ( i = 0; i < num_nodes; i++ )
    {
        num_states = GetRandomNumberOfStates(max_num_states);
        nodeTypes[i].SetType(1, num_states, nsChance);
    }

    int *nodeAssociation = new int[num_nodes];
    for ( i = 0; i < num_nodes; i++ )
    {
        nodeAssociation[i] = i;
    }

    CBNet *pBNet = CBNet::Create( num_nodes, num_nodes, nodeTypes,
                                     nodeAssociation, pGraph );
    
    CModelDomain* pMD = pBNet->GetModelDomain();
    
    CFactor **myParams = new CFactor*[num_nodes];
    int *nodeNumbers = new int[num_nodes];
    int **domains = new int*[num_nodes];

    intVector parents(0);
    for ( i = 0; i < num_nodes; i++)
    {
        nodeNumbers[i] = pGraph->GetNumberOfParents(i) + 1;
        domains[i] = new int[nodeNumbers[i]];
        pGraph->GetParents(i, &parents);
        
        for ( j = 0; j < parents.size(); j++ )
            domains[i][j] = parents[j];
        domains[i][nodeNumbers[i]-1] = i;
    }

    pBNet->AllocFactors();

    for( i = 0; i < num_nodes; i++ )
    {
        myParams[i] = CTabularCPD::Create( domains[i], 
            nodeNumbers[i], pMD);
    }

    float **data = new float*[num_nodes];
    int size_data;
    int num_states_node;
    int num_blocks;
    intVector size_nodes(0);
    float belief, sum_beliefs;

    for ( i = 0; i < num_nodes; i++ )
    {
        size_data = 1;
        size_nodes.resize(0);
        for ( j = 0; j < nodeNumbers[i]; j++ )
        {
            size_nodes.push_back(pBNet->GetNodeType(
                domains[i][j])->GetNodeSize());
            size_data *= size_nodes[j];
        }
        num_states_node = size_nodes[size_nodes.size() - 1];
        num_blocks = size_data / num_states_node;
        
        data[i] = new float[size_data];

        for ( j = 0; j < num_blocks; j++ )
        {
            sum_beliefs = 0.0;
            for ( k = 0; k < num_states_node - 1; k++ )
            {
                belief = GetBelief(1.0 - sum_beliefs);
                data[i][j * num_states_node + k] = belief;
                sum_beliefs += belief;
            }
            belief = 1.0 - sum_beliefs;
            data[i][j * num_states_node + num_states_node - 1] = belief;
        }
    }

    for( i = 0; i < num_nodes; i++ )
    {
        myParams[i]->AllocMatrix(data[i], matTable);
        pBNet->AttachFactor(myParams[i]);
    }    

    delete [] nodeTypes;
    delete [] nodeAssociation;

    return pBNet;
}
int testBayesLearningEngine()
{
    
    int ret = TRS_OK;
    int i, j;
    const int nnodes = 4;//Number of nodes
    int numNt = 1;//number of Node Types

    float eps = -1.0f;
    while( eps <= 0)
    {
	trssRead( &eps, "0.01f", "accuracy in test");
    }
    CNodeType *nodeTypes = new CNodeType [numNt];
    for( i=0; i < numNt; i++ )
    {
	nodeTypes[i] = CNodeType(1,2);//all nodes are discrete and binary
    }

    int nodeAssociation[] = {0, 0, 0, 0};
    int obs_nodes[] = { 0, 1, 2, 3 };
    int numOfNeigh[] = { 2, 2, 2, 2};

    int neigh0[] = { 1, 2 };
    int neigh1[] = { 0, 3 };
    int neigh2[] = { 0, 3 };
    int neigh3[] = { 1, 2 };

    ENeighborType orient0[] = { ntChild, ntChild };
    ENeighborType orient1[] = { ntParent, ntChild };
    ENeighborType orient2[] = { ntParent, ntChild };
    ENeighborType orient3[] = { ntParent, ntParent };

    int *neigh[] = { neigh0, neigh1, neigh2, neigh3 };
    ENeighborType *orient[] = { orient0, orient1, orient2, orient3 };

    float prior0[] = { 1.f, 1.f };
    float prior1[] = { 1.f, 1.f, 1.f, 1.f };
    float prior2[] = { 1.f, 1.f, 1.f, 1.f };
    float prior3[] = { 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f };

    float* priors[] = { prior0,prior1,prior2,prior3 };

    float zero_array[] = { 1,1,1,1, 1,1,1,1 };

    float test_data0[] = { 0.636364f, 0.363636f };
    float test_data1[] = { 0.6f, 0.4f, 0.777778f, 0.222222f };
    float test_data2[] = { 0.866667f, 0.133333f, 0.111111f, 0.888889f };
    float test_data3[] = { 0.888889f, 0.111111f, 0.111111f, 0.888889f,
	0.142857f, 0.857143f, 0.333333f, 0.666667f };
    float* test_data_first[] = { test_data0, test_data1, test_data2, test_data3 };

    float test_data4[] = { 0.519231f, 0.480769f };
    float test_data5[] = { 0.571429f, 0.428571f, 0.884615f, 0.115385f };
    float test_data6[] = { 0.857143f, 0.142857f, 0.0769231f, 0.923077f };
    float test_data7[] = { 0.937500f, 0.0625000f, 0.12f, 0.88f,
	0.166667f, 0.833333f, 0.2f, 0.8f };
    float* test_data_second[] = { test_data4, test_data5, test_data6, test_data7 };

    CGraph* Graph = CGraph::Create( nnodes, numOfNeigh, neigh,
	orient);

    CBNet *myBNet = CBNet::Create(nnodes, numNt, nodeTypes,
	nodeAssociation, Graph );

    myBNet->AllocFactors();
    for ( int node = 0; node < nnodes; node++ )
    {
	myBNet->AllocFactor( node );
	//allocate empty CPT matrix, it needs to be allocated even if
	//we are going to learn train it.
	(myBNet->GetFactor( node ))->AllocMatrix( zero_array, matTable );
	//allocate prior matrices
	(myBNet->GetFactor( node ))->AllocMatrix( priors[node], matDirichlet );
	static_cast<CCPD *>(myBNet->GetFactor( node ))->NormalizeCPD();
    }

    ///////////////////////////////////////////////////////////////
    //Reading cases from disk

    FILE *fp;
    const int nEv = 50;
    CEvidence **m_pEv;
    m_pEv = new CEvidence *[nEv];
    std::vector<valueVector> Evidence(nEv);
    for( int ev = 0; ev < nEv; ev++)
    {
	Evidence[ev].resize(nnodes);
    }

    int simbol;
    char *argv = "../c_pgmtk/tests/testdata/cases1";
    fp = fopen(argv, "r");
    if(!fp)
    {
        argv = "../testdata/cases1";
        if ((fp = fopen(argv, "r")) == NULL)
	{
            printf( "can't open file %s\n", argv );
	    ret = TRS_FAIL;
	    return trsResult( ret, ret == TRS_OK ? "No errors" :
	        "Bad test: no file with cases");
	}
    }
    if (fp)
    {
	i = 0;
	j = 0;
	while( i < nEv)
	{
	    simbol = getc( fp );
	    if( isdigit( simbol ) )
	    {
		(Evidence[i])[j].SetInt(simbol - '0');
		j++;
		if( ( j - nnodes ) == 0 )
		{
		    i++;
		    j = 0;
		}
	    }
	}
    }

    for( i = 0; i < nEv; i++ )
    {
	m_pEv[i] = CEvidence::Create(myBNet->GetModelDomain(),
	    nnodes, obs_nodes, Evidence[i]);
    }

    //create bayesin learning engine
    CBayesLearningEngine *pLearn = CBayesLearningEngine::Create(myBNet);

    //Learn only portion of evidences
    pLearn->SetData(20, m_pEv);
    pLearn ->Learn();

    ///////////////////////////////////////////////////////////////////////////////
    CNumericDenseMatrix<float> *pMatrix;
    int length = 0;
    const float *output;

    for ( i = 0; i < nnodes; i++)
    {
	pMatrix = static_cast<CNumericDenseMatrix<float>*>(myBNet->
	    GetFactor(i)->GetMatrix(matTable));
	pMatrix->GetRawData(&length, &output);
	for (j = 0; j < length; j++)
	{
	    if( fabs(output[j] - test_data_first[i][j] ) > eps )
	    {
		ret = TRS_FAIL;
		return trsResult( ret, ret == TRS_OK ? "No errors" :
		"Bad test on BayesLearningEngine");
		break;
	    }

	}
    }

    //Learn second portion of evidences
    pLearn->AppendData(20, m_pEv+20);
    pLearn->AppendData(10, m_pEv+40);
    pLearn ->Learn();

    //check second portion
    for ( i = 0; i < nnodes; i++)
    {
	pMatrix = static_cast<CNumericDenseMatrix<float>*>(myBNet->
	    GetFactor(i)->GetMatrix(matTable));
	pMatrix->GetRawData(&length, &output);
	for (j = 0; j < length; j++)
	{
	    if( fabs(output[j] - test_data_second[i][j] ) > eps )
	    {
		ret = TRS_FAIL;
		return trsResult( ret, ret == TRS_OK ? "No errors" :
		"Bad test on BayesLearningEngine");
		break;
	    }

	}
    }

    for( i = 0; i < nEv; i++ )
    {
	delete (m_pEv[i]);

    }
    delete []m_pEv;
    delete (pLearn);
    delete (myBNet);
    delete [](nodeTypes);
    fclose(fp);
    return trsResult( ret, ret == TRS_OK ? "No errors"
	: "Bad test on BayesLearningEngine");
}
bool CStaticStructLearnSEM::LearnOneStep()
{
	intVecVector decompsition;
	CGraph* graph = m_pCurrBNet->GetGraph();
	graph->GetConnectivityComponents( &decompsition );
	CEMLearningEngine* pEMLearn;
	if(decompsition.size() > 1)
	{
		CExInfEngine< CJtreeInfEngine, CBNet, PNL_EXINFENGINEFLAVOUR_DISCONNECTED > *pInf = 
                	CExInfEngine< CJtreeInfEngine, CBNet, PNL_EXINFENGINEFLAVOUR_DISCONNECTED >::
       		Create( m_pCurrBNet  );
		pEMLearn = CEMLearningEngine::Create(m_pCurrBNet, pInf);
	}
	else
    {
        CJtreeInfEngine *pInf = CJtreeInfEngine::Create(m_pCurrBNet);
        pEMLearn = CEMLearningEngine::Create(m_pCurrBNet, pInf);
    }

	int i;
	for(i=0; i<decompsition.size(); i++)
		decompsition[i].clear();
	decompsition.clear();

	ConvertToCurrEvidences(m_pCurrBNet);
	pEMLearn->SetData(m_numberOfAllEvidences, &m_vCurrEvidences.front());
	
	pEMLearn->SetMaxIterEM(m_IterEM);

//	pEMLearn->ClearStatisticData();
	pCPDVector vNeighborCPDs;
	floatVector vNeighborLLs;
	EDGEOPVECTOR vValidMoves;
	intVector vRevCorrespDel;
	CreateNeighborCPDs(m_pCurrBNet, &vNeighborCPDs, &vValidMoves, &vRevCorrespDel);

	pEMLearn->LearnExtraCPDs(m_nMaxFanIn+1, &vNeighborCPDs, &vNeighborLLs);

//	m_pCurrBNet = static_cast<CBNet*>(pEMLearn->GetStaticModel());
	const float* familyLL = pEMLearn->GetFamilyLogLik();
	floatVector familyScores(m_nNodes,0);
	int j, freeparams;
	float logebase = (float)log(float(m_numberOfAllEvidences));
	float total_score = 0.0f;
	CFactor* pCPD;
	for(i=0; i<m_nNodes; i++)
	{
		pCPD = m_pCurrBNet->GetFactor(i);
		freeparams = pCPD->GetNumberOfFreeParameters();
		familyScores[i] = familyLL[i] - 0.5f * float(freeparams) * logebase;
		total_score += familyScores[i];
	}
	int nMoves = vValidMoves.size();
	floatVector neighborScores(nMoves, 0);
	for(i=0; i<nMoves; i++)
	{
		pCPD = static_cast<CFactor*>(vNeighborCPDs[i]);
		freeparams = pCPD->GetNumberOfFreeParameters();
		neighborScores[i] = vNeighborLLs[i] - 0.5f * float(freeparams) * logebase;
	}

	int start, end, max_position=0;
	float tmp_score, best_score = -1e37f; 
	EDGEOP move;
	for(i=0; i<nMoves; i++)
	{
		move = vValidMoves[i];
		switch (move.DAGChangeType)
		{
		case DAG_DEL : 
			end = move.originalEdge.endNode;
			tmp_score = neighborScores[i] - familyScores[end];
			if( best_score<tmp_score )
			{
				best_score = tmp_score;
				max_position = i;
			}
			break;

		case DAG_ADD :
			end = move.originalEdge.endNode;
			tmp_score = neighborScores[i] - familyScores[end];
			if( best_score<tmp_score )
			{
				best_score = tmp_score;
				max_position = i;
			}
			break;

		case DAG_REV :
			end = move.originalEdge.startNode;
			tmp_score = neighborScores[i] - familyScores[end];
			
			end = move.originalEdge.endNode;
			tmp_score += neighborScores[vRevCorrespDel[i]] - familyScores[end];
			if( best_score<tmp_score )
			{
				best_score = tmp_score;
				max_position = i;
			}
			break;
		}
	}

	move = vValidMoves[max_position];
	start = move.originalEdge.startNode;
	end = move.originalEdge.endNode;
	EDAGChangeType changeType = move.DAGChangeType;
	CCPD *addCPD=0, *delCPD=0;
	switch (changeType)
	{
	case DAG_DEL : 
		delCPD = static_cast<CCPD*>((vNeighborCPDs[max_position])->Clone());
		break;

	case DAG_ADD :
		addCPD = static_cast<CCPD*>((vNeighborCPDs[max_position])->Clone());
		break;

	case DAG_REV :
		addCPD = static_cast<CCPD*>((vNeighborCPDs[max_position])->Clone());
		delCPD = static_cast<CCPD*>((vNeighborCPDs[vRevCorrespDel[max_position]])->Clone());			
		break;
	}

	delete pEMLearn;
	for(i=0; i<vNeighborCPDs.size(); i++)
	{
		delete vNeighborCPDs[i];
	}
	vNeighborCPDs.clear();
	for(i=0; i<m_numberOfAllEvidences; i++)
	{
		delete m_vCurrEvidences[i];
	}
	m_vCurrEvidences.clear();
	vValidMoves.clear();
	float score_gate = (float)fabs(m_minProgress * total_score);
	if(best_score <= score_gate)
	{
		if(changeType == DAG_REV)
		{
			delete addCPD;
			delete delCPD;
		}
		if(changeType == DAG_ADD)delete addCPD;
		if(changeType == DAG_DEL)delete delCPD;
		return false;
	}

	total_score += best_score;
	CDAG* pDAG = CDAG::Create(*(m_pCurrBNet->GetGraph()));
	int node, node1, newnode;
	if(!(pDAG->DoMove(start, end, changeType)))
	{
		PNL_THROW(CInternalError, "There are some internal errors");
	}

	intVector vRenaming, Old2New;
	CDAG* iDAG;
	int TopologicSorted = pDAG->IsTopologicallySorted();
	if( TopologicSorted )
	{
		iDAG = pDAG->Clone();
		for(i=0; i<m_nNodes; i++) vRenaming.push_back(i);
	}
	else
		iDAG = pDAG->TopologicalCreateDAG(vRenaming);
	pDAG->Dump();
	intVector gRename;
	for(i=0; i<m_nNodes; i++)
	{
		node = vRenaming[i];
		node1 = m_vGlobalRenaming[node];
		gRename.push_back(node1);
	}
	m_vGlobalRenaming.assign(gRename.begin(), gRename.end());

	int pos;
	for(i=0; i<m_nNodes; i++)
	{
		pos = std::find(vRenaming.begin(), vRenaming.end(), i) - vRenaming.begin();
		Old2New.push_back(pos);
	}

	const int* oldNodeAsso = m_pCurrBNet->GetNodeAssociations();
	intVector newNodeAsso(m_nNodes,0);
	for(i=0; i<m_nNodes; i++)
	{
		newNodeAsso[i] = oldNodeAsso[vRenaming[i]];
	}
	nodeTypeVector vpnt;
	m_pCurrBNet->GetNodeTypes(&vpnt);
	CBNet* pBNet = CBNet::Create(m_nNodes, vpnt.size(), &vpnt.front(), 
		           &newNodeAsso.front(), static_cast<CGraph*>(iDAG));
	CModelDomain* pMDnew = pBNet->GetModelDomain();
	pBNet->AllocFactors();
	intVector domainNew, domainOld;
	const CFactor* factor=0;
	CFactor* curFactor;
	for(i=0; i<m_nNodes; i++)
	{
		domainNew.clear();
		newnode = Old2New[i];
		if( (i != start) && (i != end) )
		{
			factor = m_pCurrBNet->GetFactor(i);
		}
		else
		{
			if(changeType == DAG_REV)
			{
				if(i == start)
					factor = addCPD->Clone();
				if(i == end)
					factor = delCPD->Clone();
			}
			if(changeType == DAG_DEL)
			{
				if(i == start)
					factor = m_pCurrBNet->GetFactor(i);
				if(i == end)
					factor = delCPD->Clone();
			}
			if(changeType == DAG_ADD)
			{
				if(i == start)
					factor = m_pCurrBNet->GetFactor(i);
				if(i == end)
					factor = addCPD->Clone();
			}
		}
		factor->GetDomain(&domainOld);
		for(j=0; j<domainOld.size(); j++)
		{
			domainNew.push_back(Old2New[domainOld[j]]);
		}
		curFactor = CFactor::CopyWithNewDomain(factor, domainNew, pMDnew);
		pBNet->AttachFactor(curFactor);
	}

	if(changeType == DAG_REV)
	{
		delete addCPD;
		delete delCPD;
	}
	if(changeType == DAG_ADD)delete addCPD;
	if(changeType == DAG_DEL)delete delCPD;

	delete m_pCurrBNet;
	delete pDAG;
	m_pCurrBNet = pBNet;
	m_critValue.push_back(total_score);
	return true;
}
示例#9
0
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;
}
示例#10
0
CBNet* CreateTwoNodeEx(void)
{
    const int numOfNds = 2;
    int numOfNbrs[numOfNds] = { 1, 1 };

    int nbrs0[] = { 1 };
    int nbrs1[] = { 0 };

    ENeighborType nbrsTypes0[] = { ntChild };
    ENeighborType nbrsTypes1[] = { ntParent };

    int *nbrs[] = { nbrs0, nbrs1 };
    ENeighborType *nbrsTypes[] = { nbrsTypes0, nbrsTypes1 };

    CGraph* pGraph = CGraph::Create(numOfNds, numOfNbrs, nbrs, nbrsTypes);

    CModelDomain* pMD;

    nodeTypeVector variableTypes;

    int nVariableTypes = 2;
    variableTypes.resize(nVariableTypes);

    variableTypes[0].SetType(0, 1);
    variableTypes[1].SetType(1, 2);

    intVector variableAssociation;
    int nnodes = pGraph->GetNumberOfNodes();
    variableAssociation.assign(nnodes, 1);
    variableAssociation[0] = 0;
    variableAssociation[1] = 1;

    pMD = CModelDomain::Create(variableTypes, variableAssociation);

    CBNet *pBNet = CBNet::Create(pGraph, pMD);

    pBNet->AllocFactors();

    int nnodes0 = 1;
    int domain0[] = { 0 };
    float mean0 = 0.0f;
    float cov0 = 1.0f;
    CGaussianCPD *pCPD0 = CGaussianCPD::Create(domain0, nnodes0, pMD);
    pCPD0->AllocDistribution(&mean0, &cov0, 1.0f, NULL);
    pBNet->AttachFactor(pCPD0);

    int nnodes1 = 2;
    int domain1[] = { 0, 1 };

    CSoftMaxCPD *pCPD3 = CSoftMaxCPD::Create(domain1, nnodes1, pMD);

    int parInd0[] = { 0 };

//  float weight30[] = { -1.0f,-1.0f };
//  float offset30[] = { 1.0f, 1.0f };

    float weight30[] = { -0.3059f, -1.1777f };
    float offset30[] = { 0.0886f, 0.2034f };

    pCPD3->AllocDistribution(weight30, offset30, parInd0);

    pBNet->AttachFactor(pCPD3);

    return pBNet;
}
示例#11
0
// ----------------------------------------------------------------------------
CBNet* CreateSevenNodeExDiscrete(void)
{

    // 0  1   2
    // |\ \  /
    // | \ \ /
    // |    3
    // |   / \ 
    // |  4   5
    // |/
    // 6
    // 0, 1, 5 -  continuous
    // 3, 6 - softmax
    // 2, 4 - discrete

    const int numOfNds = 7;
    int numOfNbrs[numOfNds] = { 2, 1, 1, 5, 2, 1, 2 };

    int nbrs0[] = { 3, 6 };
    int nbrs1[] = { 3 };
    int nbrs2[] = { 3 };
    int nbrs3[] = { 0, 1, 2, 4, 5 };
    int nbrs4[] = { 3, 6 };
    int nbrs5[] = { 3 };
    int nbrs6[] = { 0, 4 };

    ENeighborType nbrsTypes0[] = { ntChild, ntChild };
    ENeighborType nbrsTypes1[] = { ntChild };
    ENeighborType nbrsTypes2[] = { ntChild };
    ENeighborType nbrsTypes3[] = { ntParent, ntParent, ntParent, ntChild, ntChild };
    ENeighborType nbrsTypes4[] = { ntParent, ntChild };
    ENeighborType nbrsTypes5[] = { ntParent };
    ENeighborType nbrsTypes6[] = { ntParent, ntParent };

    int *nbrs[] = { nbrs0, nbrs1, nbrs2, nbrs3, nbrs4, nbrs5, nbrs6 };
    ENeighborType *nbrsTypes[] = { nbrsTypes0, nbrsTypes1, nbrsTypes2, nbrsTypes3, nbrsTypes4,
                                   nbrsTypes5, nbrsTypes6
                                 };

    CGraph* pGraph = CGraph::Create( numOfNds, numOfNbrs, nbrs, nbrsTypes );

    // 2) Creation of the Model Domain.
    CModelDomain* pMD;

    nodeTypeVector variableTypes;

    int nVariableTypes = 2;
    variableTypes.resize( nVariableTypes );

    variableTypes[0].SetType( 0, 1 ); // continuous
    variableTypes[1].SetType( 1, 2 ); // discrete, 2 states

    intVector variableAssociation;
    int nnodes = pGraph->GetNumberOfNodes();
    variableAssociation.assign(nnodes, 1);
    variableAssociation[0] = 1;
    variableAssociation[1] = 1;
    variableAssociation[2] = 1;
    variableAssociation[3] = 1;
    variableAssociation[4] = 1;
    variableAssociation[5] = 1;
    variableAssociation[6] = 1;

    pMD = CModelDomain::Create( variableTypes, variableAssociation );

    // 2) Creation base for BNet using Graph, and Model Domain

    CBNet *pBNet = CBNet::Create(pGraph, pMD);

    // 3)Allocation space for all factors of the model
    pBNet->AllocFactors();

    int nnodes0 = 1;
    int domain0[] = { 0 };
    float table0[] = { 0.3f, 0.7f};
    CTabularCPD *pCPD0 = CTabularCPD::Create( domain0, nnodes0, pMD, table0 );
    pCPD0->AllocMatrix(table0, matTable);
    pBNet->AttachParameter(pCPD0);

    int nnodes1 = 1;
    int domain1[] = { 1 };
    float table1[] = { 0.3f, 0.7f};
    CTabularCPD *pCPD1 = CTabularCPD::Create( domain1, nnodes1, pMD, table1 );
    pCPD1->AllocMatrix(table1, matTable);
    pBNet->AttachParameter(pCPD1);

    int nnodes2 = 1;
    int domain2[] = { 2 };
    float table2[] = { 0.3f, 0.7f};
    CTabularCPD *pCPD2 = CTabularCPD::Create( domain2, nnodes2, pMD, table2 );
    pCPD2->AllocMatrix(table2, matTable);
    pBNet->AttachParameter(pCPD2);

    int nnodes3 = 4;
    int domain3[] = { 0, 1, 2, 3 };
    float table3[] = { 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f};
    CTabularCPD *pCPD3 = CTabularCPD::Create( domain3, nnodes3, pMD, table3 );
    pCPD3->AllocMatrix(table3, matTable);
    pBNet->AttachParameter(pCPD3);

    int nnodes4 = 2;
    int domain4[] = { 3, 4 };
    float table4[] = { 0.3f, 0.7f, 0.5, 0.5 };
    CTabularCPD *pCPD4 = CTabularCPD::Create( domain4, nnodes4, pMD, table4 );
    pCPD4->AllocMatrix(table4, matTable);
    pBNet->AttachParameter(pCPD4);

    int nnodes5 = 2;
    int domain5[] = { 3, 5 };
    float table5[] = { 0.3f, 0.7f, 0.5f, 0.5f };
    CTabularCPD *pCPD5 = CTabularCPD::Create( domain5, nnodes5, pMD, table5 );
    pCPD5->AllocMatrix(table5, matTable);
    pBNet->AttachParameter(pCPD5);

    int nnodes6 = 3;
    int domain6[] = { 0, 4, 6 };
    float table6[] = { 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f };
    CTabularCPD *pCPD6 = CTabularCPD::Create( domain6, nnodes6, pMD, table6 );
    pCPD6->AllocMatrix(table6, matTable);
    pBNet->AttachParameter(pCPD6);

    return pBNet;
}
示例#12
0
// ----------------------------------------------------------------------------
CBNet* CreateSevenNodeEx(void)
{

    // 0  1   2
    // |\ \  /
    // | \ \ /
    // |    3
    // |   / \ 
    // |  4   5
    // |/
    // 6
    // 0, 1, 5 - continuous
    // 3, 6 - softmax
    // 2, 4 - discrete

    const int numOfNds = 7;
    int numOfNbrs[numOfNds] = { 2, 1, 1, 5, 2, 1, 2 };

    int nbrs0[] = { 3, 6 };
    int nbrs1[] = { 3 };
    int nbrs2[] = { 3 };
    int nbrs3[] = { 0, 1, 2, 4, 5 };
    int nbrs4[] = { 3, 6 };
    int nbrs5[] = { 3 };
    int nbrs6[] = { 0, 4 };

    ENeighborType nbrsTypes0[] = { ntChild, ntChild };
    ENeighborType nbrsTypes1[] = { ntChild };
    ENeighborType nbrsTypes2[] = { ntChild };
    ENeighborType nbrsTypes3[] = { ntParent, ntParent, ntParent, ntChild, ntChild };
    ENeighborType nbrsTypes4[] = { ntParent, ntChild };
    ENeighborType nbrsTypes5[] = { ntParent };
    ENeighborType nbrsTypes6[] = { ntParent, ntParent };

    int *nbrs[] = { nbrs0, nbrs1, nbrs2, nbrs3, nbrs4, nbrs5, nbrs6 };
    ENeighborType *nbrsTypes[] = { nbrsTypes0, nbrsTypes1, nbrsTypes2, nbrsTypes3, nbrsTypes4,
                                   nbrsTypes5, nbrsTypes6
                                 };

    CGraph* pGraph = CGraph::Create( numOfNds, numOfNbrs, nbrs, nbrsTypes );

    // 2) Creation of the Model Domain.
    CModelDomain* pMD;

    nodeTypeVector variableTypes;

    int nVariableTypes = 2;
    variableTypes.resize( nVariableTypes );

    variableTypes[0].SetType( 0, 1 ); // continuous
    variableTypes[1].SetType( 1, 2 ); // discrete, 2 states

    intVector variableAssociation;
    int nnodes = pGraph->GetNumberOfNodes();
    variableAssociation.assign(nnodes, 1);
    variableAssociation[0] = 0;
    variableAssociation[1] = 0;
    variableAssociation[2] = 1;
    variableAssociation[3] = 1;
    variableAssociation[4] = 1;
    variableAssociation[5] = 0;
    variableAssociation[6] = 1;

    pMD = CModelDomain::Create( variableTypes, variableAssociation );

    // 2) Creation base for BNet using Graph, and Model Domain

    CBNet *pBNet = CBNet::Create(pGraph, pMD);

    // 3)Allocation space for all factors of the model
    pBNet->AllocFactors();

    int nnodes0 = 1;
    int domain0[] = { 0 };
    float mean0 = 0.5f;
    float cov0 = 1.0f;
    CGaussianCPD *pCPD0 = CGaussianCPD::Create( domain0, nnodes0, pMD );
    pCPD0->AllocDistribution( &mean0, &cov0, 1.0f, NULL );
    pBNet->AttachFactor( pCPD0 );

    int nnodes1 = 1;
    int domain1[] = { 1 };
    float mean1 = 0.5f;
    float cov1 = 1.0f;
    CGaussianCPD *pCPD1 = CGaussianCPD::Create( domain1, nnodes1, pMD );
    pCPD1->AllocDistribution( &mean1, &cov1, 1.0f, NULL );
    pBNet->AttachFactor( pCPD1 );

    int nnodes2 = 1;
    int domain2[] = { 2 };
    float table2[] = { 0.3f, 0.7f};
    CTabularCPD *pCPD2 = CTabularCPD::Create( domain2, nnodes2, pMD, table2 );
    pCPD2->AllocMatrix(table2, matTable);
    pBNet->AttachParameter(pCPD2);

    int nnodes3 = 4;
    int domain3[] = { 0, 1, 2, 3 };
    CSoftMaxCPD *pCPD3 = CSoftMaxCPD::Create( domain3, nnodes3, pMD );

    int parInd30[] = { 0 };
//  float weight30[] = { 0.5f, 0.5f, 0.5f, 0.7f, 0.3f, 0.7f };
//  float offset30[] = { 0.3f, 0.5f, 1.2f };
    float weight30[] = { 0.5f, 0.4f, 0.5f, 0.7f };
    float offset30[] = { 0.3f, 0.5f };

    pCPD3->AllocDistribution( weight30, offset30, parInd30 );

    int parInd31[] = { 1 };
    float weight31[] = { 0.5f, 0.1f, 0.5f, 0.7f };
    float offset31[] = { 0.3f, 0.5f };
//  float weight31[] = { 0.5f, 0.5f, 0.5f, 0.7f, 0.3f, 0.7f };
//  float offset31[] = { 0.3f, 0.5f, 5.4f };

    pCPD3->AllocDistribution( weight31, offset31, parInd31 );
    pBNet->AttachFactor( pCPD3 );

    int nnodes4 = 2;
    int domain4[] = { 3, 4 };
    float table4[] = { 0.3f, 0.7f, 0.8f, 0.2f };
//  float table4[] = { 0.3f, 0.7f, 0.5, 0.5, 0.1, 0.9 };

    CTabularCPD *pCPD4 = CTabularCPD::Create( domain4, nnodes4, pMD, table4 );
    pCPD4->AllocMatrix(table4, matTable);
    pBNet->AttachParameter(pCPD4);

    int nnodes5 = 2;
    int domain5[] = { 3, 5 };
    CGaussianCPD *pCPD5 = CGaussianCPD::Create( domain5, nnodes5, pMD );

    float mean50 = 1.0f;
    float cov50 = 1.0f;
    int parInd50[] = { 0 };
    pCPD5->AllocDistribution( &mean50, &cov50, 1.0f, NULL, parInd50 );

    float mean51 = 0.5f;
    float cov51 = 0.5f;
    int parInd51[] = { 1 };
    pCPD5->AllocDistribution( &mean51, &cov51, 1.0f, NULL, parInd51 );

    /*  float mean52 = 0.0f;
      float cov52 = 1.f;
      int parInd52[] = { 2 };
      pCPD5->AllocDistribution( &mean52, &cov52, 1.0f, NULL, parInd52 );
    */
    pBNet->AttachFactor(pCPD5);

    int nnodes6 = 3;
    int domain6[] = { 0, 4, 6 };
    CSoftMaxCPD *pCPD6 = CSoftMaxCPD::Create( domain6, nnodes6, pMD );
    int parInd60[] = { 0 };

    float weight60[] = { 0.5f, 0.9f, 3.2f };
    float offset60[] = { 0.7f, 0.3f, 0.1f };

    pCPD6->AllocDistribution( weight60, offset60, parInd60 );

    int parInd61[] = { 1 };

//  float weight61[] = { 0.8f, 0.2f, 0.5f };
//  float offset61[] = { 0.1f, 0.9f, 1.9f };
    float weight61[] = { 0.8f, 0.2f };
    float offset61[] = { 0.1f, 0.9f };

    pCPD6->AllocDistribution( weight61, offset61, parInd61 );

    pBNet->AttachFactor( pCPD6 );

    return pBNet;
}
示例#13
0
CBNet* CreateSixNodeEx(void)
{
    int i;
    const int numOfNds = 6;
    int numOfNbrs[numOfNds] = { 1, 1, 1, 1, 1, 5 };

    int nbrs0[] = { 5 };
    int nbrs1[] = { 5 };
    int nbrs2[] = { 5 };
    int nbrs3[] = { 5 };
    int nbrs4[] = { 5 };
    int nbrs5[] = { 0, 1, 2, 3, 4 };

    ENeighborType nbrsTypes0[] = { ntChild };
    ENeighborType nbrsTypes1[] = { ntChild };
    ENeighborType nbrsTypes2[] = { ntChild };
    ENeighborType nbrsTypes3[] = { ntChild };
    ENeighborType nbrsTypes4[] = { ntChild };
    ENeighborType nbrsTypes5[] = { ntParent, ntParent, ntParent, ntParent,
                                   ntParent
                                 };

    int *nbrs[] = { nbrs0, nbrs1, nbrs2, nbrs3, nbrs4, nbrs5};
    ENeighborType *nbrsTypes[] = { nbrsTypes0, nbrsTypes1, nbrsTypes2,
                                   nbrsTypes3, nbrsTypes4, nbrsTypes5
                                 };

    CGraph* pGraph = CGraph::Create(numOfNds, numOfNbrs, nbrs, nbrsTypes);

    CModelDomain* pMD;

    nodeTypeVector variableTypes;

    int nVariableTypes = 2;
    variableTypes.resize(nVariableTypes);

    variableTypes[0].SetType(0, 1);
//  variableTypes[0].SetType(1, 4);
    variableTypes[1].SetType(1, 2);

    intVector variableAssociation;
    int nnodes = pGraph->GetNumberOfNodes();
    variableAssociation.assign(nnodes, 1);
    variableAssociation[0] = 0;
    variableAssociation[1] = 0;
    variableAssociation[2] = 0;
    variableAssociation[3] = 0;
    variableAssociation[4] = 0;
    variableAssociation[5] = 1;

    pMD = CModelDomain::Create(variableTypes, variableAssociation);

    CBNet *pBNet = CBNet::Create(pGraph, pMD);

    pBNet->AllocFactors();

    int nnodes0 = 1;
    int domain0[] = { 0 };
    float mean0 = 0.0f;
    float cov0 = 1.0f;

    CGaussianCPD *pCPD0 = CGaussianCPD::Create(domain0, nnodes0, pMD);
    pCPD0->AllocDistribution(&mean0, &cov0, 1.0f, NULL);
    pBNet->AttachFactor(pCPD0);

    int nnodes1 = 1;
    int domain1[] = { 1 };
    float mean1 = 2.0f;
    float cov1 = 1.0f;

    CGaussianCPD *pCPD1 = CGaussianCPD::Create(domain1, nnodes1, pMD);
    pCPD1->AllocDistribution(&mean1, &cov1, 1.0f, NULL);
    pBNet->AttachFactor(pCPD1);

    int nnodes2 = 1;
    int domain2[] = { 2 };
    float mean2 = 1.0f;
    float cov2 = 1.0f;

    CGaussianCPD *pCPD2 = CGaussianCPD::Create(domain2, nnodes2, pMD);
    pCPD2->AllocDistribution(&mean2, &cov2, 1.0f, NULL);
    pBNet->AttachFactor(pCPD2);

    int nnodes3 = 1;
    int domain3[] = { 3 };
    float mean3 = 5.0f;
    float cov3 = 1.0f;

    CGaussianCPD *pCPD3 = CGaussianCPD::Create(domain3, nnodes3, pMD);
    pCPD3->AllocDistribution(&mean3, &cov3, 1.0f, NULL);
    pBNet->AttachFactor(pCPD3);

    int nnodes4 = 1;
    int domain4[] = { 4 };
    float mean4 = 5.0f;
    float cov4 = 1.0f;

    CGaussianCPD *pCPD4 = CGaussianCPD::Create(domain4, nnodes4, pMD);
    pCPD4->AllocDistribution(&mean4, &cov4, 1.0f, NULL);
    pBNet->AttachFactor(pCPD4);

    int nnodes5 = 6;
    int domain5[] = { 0, 1, 2, 3, 4, 5 };

    CSoftMaxCPD *pCPD5 = CSoftMaxCPD::Create(domain5, nnodes5, pMD);

    int parInd0[] = { 0 };

    float *weight30;
    int SizeOfWeight = (variableTypes[1].GetNodeSize()) * (numOfNds - 1);
    weight30 = GenerateFloatArray((variableTypes[1].GetNodeSize()) *
                                  (numOfNds - 1), 1.0f, 5.0f);

#ifdef SM_TEST
    printf("\nweight30\n");
    for (i = 0; i < SizeOfWeight; i++)
    {
        printf("%f\t", weight30[i]);
    }
#endif

    float *offset30;
    int SizeOfOffset = variableTypes[1].GetNodeSize();
    offset30 = GenerateFloatArray(variableTypes[1].GetNodeSize(), 1.0f, 5.0f);

#ifdef SM_TEST
    printf("\noffset30\n");
    for (i = 0; i < SizeOfOffset; i++)
    {
        printf("%f\t", offset30[i] );
    }
    printf("\n\n");
#endif

    pCPD5->AllocDistribution(weight30, offset30, parInd0);

    pBNet->AttachFactor(pCPD5);

    return pBNet;
}
示例#14
0
PNL_USING
CBNet* CreateAlarmBNet()
{
    const int nnodes = 37;
    const int numberOfNodeTypes = 37;
    
    int i;
    
    CGraph *pGraph = CGraph::Create(0, NULL, NULL, NULL);
    pGraph->AddNodes(37);
    pGraph->AddEdge(0,1,1);
    pGraph->AddEdge(0,3,1);
    pGraph->AddEdge(2,3,1);
    pGraph->AddEdge(3,4,1);
    pGraph->AddEdge(3,5,1);
    pGraph->AddEdge(0,6,1);
    pGraph->AddEdge(2,6,1);
    pGraph->AddEdge(11,12,1);
    pGraph->AddEdge(10,13,1);
    pGraph->AddEdge(12,13,1);
    pGraph->AddEdge(8,14,1);
    pGraph->AddEdge(9,14,1);
    pGraph->AddEdge(13,14,1);
    pGraph->AddEdge(8,15,1);
    pGraph->AddEdge(14,15,1);
    pGraph->AddEdge(15,16,1);
    pGraph->AddEdge(15,19,1);
    pGraph->AddEdge(18,19,1);
    pGraph->AddEdge(8,21,1);
    pGraph->AddEdge(20,21,1);
    pGraph->AddEdge(19,22,1);
    pGraph->AddEdge(21,22,1);
    pGraph->AddEdge(23,24,1);
    pGraph->AddEdge(16,25,1);
    pGraph->AddEdge(17,25,1);
    pGraph->AddEdge(22,25,1);
    pGraph->AddEdge(24,25,1);
    pGraph->AddEdge(25,26,1);
    pGraph->AddEdge(7,27,1);
    pGraph->AddEdge(26,27,1);
    pGraph->AddEdge(26,29,1);
    pGraph->AddEdge(28,29,1);
    pGraph->AddEdge(26,30,1);
    pGraph->AddEdge(28,30,1);
    pGraph->AddEdge(14,31,1);
    pGraph->AddEdge(16,31,1);
    pGraph->AddEdge(8,32,1);
    pGraph->AddEdge(14,32,1);
    pGraph->AddEdge(20,33,1);
    pGraph->AddEdge(8,34,1);
    pGraph->AddEdge(9,34,1);
    pGraph->AddEdge(13,34,1);
    pGraph->AddEdge(6,35,1);
    pGraph->AddEdge(26,35,1);
    pGraph->AddEdge(24,36,1);
    pGraph->AddEdge(35,36,1);
    
    CNodeType *nodeTypes = new CNodeType [37];
    
    nodeTypes[0].SetType(1, 2);
    nodeTypes[1].SetType(1, 2);
    nodeTypes[2].SetType(1, 2);
    nodeTypes[3].SetType(1, 3);
    nodeTypes[4].SetType(1, 3);
    nodeTypes[5].SetType(1, 3);
    nodeTypes[6].SetType(1, 3);
    nodeTypes[7].SetType(1, 2);
    nodeTypes[8].SetType(1, 3);
    nodeTypes[9].SetType(1, 2);
    nodeTypes[10].SetType(1, 2);
    nodeTypes[11].SetType(1, 3);
    nodeTypes[12].SetType(1, 4);
    nodeTypes[13].SetType(1, 4);
    nodeTypes[14].SetType(1, 4);
    nodeTypes[15].SetType(1, 4);
    nodeTypes[16].SetType(1, 3);
    nodeTypes[17].SetType(1, 2);
    nodeTypes[18].SetType(1, 2);
    nodeTypes[19].SetType(1, 3);
    nodeTypes[20].SetType(1, 2);
    nodeTypes[21].SetType(1, 2);
    nodeTypes[22].SetType(1, 3);
    nodeTypes[23].SetType(1, 2);
    nodeTypes[24].SetType(1, 3);
    nodeTypes[25].SetType(1, 2);
    nodeTypes[26].SetType(1, 3);
    nodeTypes[27].SetType(1, 3);
    nodeTypes[28].SetType(1, 2);
    nodeTypes[29].SetType(1, 3);
    nodeTypes[30].SetType(1, 3);
    nodeTypes[31].SetType(1, 4);
    nodeTypes[32].SetType(1, 4);
    nodeTypes[33].SetType(1, 3);
    nodeTypes[34].SetType(1, 4);
    nodeTypes[35].SetType(1, 3);
    nodeTypes[36].SetType(1, 3);
    
    int *nodeAssociation = new int[nnodes];
    
    for ( i = 0; i < nnodes; i++ )
    {
	nodeAssociation[i] = i;
    }
    CBNet *pBNet = CBNet::Create( nnodes, numberOfNodeTypes, nodeTypes,
	nodeAssociation, pGraph );
    
    CModelDomain* pMD = pBNet->GetModelDomain();
    
    //number of factors is the same as number of nodes - one CPD per node
    CFactor **myParams = new CFactor*[nnodes];
    int *nodeNumbers = new int [nnodes];
    
    int domain0[] = { 0 };
    nodeNumbers[0] =  1;
    int domain1[] = { 0, 1 };
    nodeNumbers[1] =  2;
    int domain2[] = { 2 };
    nodeNumbers[2] =  1;
    int domain3[] = { 0, 2, 3 };
    nodeNumbers[3] =  3;
    int domain4[] = { 3, 4 };
    nodeNumbers[4] =  2;
    int domain5[] = { 3, 5 };
    nodeNumbers[5] =  2;
    int domain6[] = { 0, 2, 6 };
    nodeNumbers[6] =  3;
    int domain7[] = { 7 };
    nodeNumbers[7] =  1;
    int domain8[] = { 8 };
    nodeNumbers[8] =  1;
    int domain9[] = { 9 };
    nodeNumbers[9] =  1;
    int domain10[] = { 10 };
    nodeNumbers[10] =  1;
    int domain11[] = { 11 };
    nodeNumbers[11] =  1;
    int domain12[] = { 11, 12 };
    nodeNumbers[12] =  2;
    int domain13[] = { 10, 12, 13 };
    nodeNumbers[13] =  3;
    int domain14[] = { 8, 9, 13, 14 };
    nodeNumbers[14] =  4;
    int domain15[] = { 8, 14, 15 };
    nodeNumbers[15] =  3;
    int domain16[] = { 15, 16 };
    nodeNumbers[16] =  2;
    int domain17[] = { 17 };
    nodeNumbers[17] =  1;
    int domain18[] = { 18 };
    nodeNumbers[18] =  1;
    int domain19[] = { 15, 18, 19 };
    nodeNumbers[19] =  3;
    int domain20[] = { 20 };
    nodeNumbers[20] =  1;
    int domain21[] = { 8, 20, 21 };
    nodeNumbers[21] =  3;
    int domain22[] = { 19, 21, 22 };
    nodeNumbers[22] =  3;
    int domain23[] = { 23 };
    nodeNumbers[23] =  1;
    int domain24[] = { 23, 24 };
    nodeNumbers[24] =  2;
    int domain25[] = { 16, 17, 22, 24, 25 };
    nodeNumbers[25] =  5;
    int domain26[] = { 25, 26 };
    nodeNumbers[26] =  2;
    int domain27[] = { 7, 26, 27 };
    nodeNumbers[27] =  3;
    int domain28[] = { 28 };
    nodeNumbers[28] =  1;
    int domain29[] = { 26, 28, 29 };
    nodeNumbers[29] =  3;
    int domain30[] = { 26, 28, 30 };
    nodeNumbers[30] =  3;
    int domain31[] = { 14, 16, 31 };
    nodeNumbers[31] =  3;
    int domain32[] = { 8, 14, 32 };
    nodeNumbers[32] =  3;
    int domain33[] = { 20, 33 };
    nodeNumbers[33] =  2;
    int domain34[] = { 8, 9, 13, 34 };
    nodeNumbers[34] =  4;
    int domain35[] = { 6, 26, 35 };
    nodeNumbers[35] =  3;
    int domain36[] = { 24, 35, 36 };
    nodeNumbers[36] =  3;
    
    int *domains[] = { domain0, domain1, domain2, domain3, domain4,
	domain5, domain6, domain7, domain8, domain9,
	domain10, domain11, domain12, domain13, domain14,
	domain15, domain16, domain17, domain18, domain19,
	domain20, domain21, domain22, domain23, domain24,
	domain25, domain26, domain27, domain28, domain29,
	domain30, domain31, domain32, domain33, domain34,
	domain35, domain36};
    
    pBNet->AllocFactors();
    
    for( i = 0; i < nnodes; i++ )
    {
	myParams[i] = CTabularCPD::Create( domains[i], nodeNumbers[i], pMD);
    }
    
    // data creation for all CPDs of the model
    float data0[] = {0.050000f, 0.950000f};
    float data1[] = {0.900000f, 0.100000f, 0.010000f, 0.990000f};
    float data2[] = {0.200000f, 0.800000f};
    float data3[] = {0.950000f, 0.040000f, 0.010000f, 0.980000f, 0.010000f, 0.010000f, 0.010000f, 0.090000f, 0.900000f, 0.050000f, 0.900000f, 0.050000f};
    float data4[] = {0.950000f, 0.040000f, 0.010000f, 0.040000f, 0.950000f, 0.010000f, 0.010000f, 0.290000f, 0.700000f};
    float data5[] = {0.950000f, 0.040000f, 0.010000f, 0.040000f, 0.950000f, 0.010000f, 0.010000f, 0.040000f, 0.950000f};
    float data6[] = {0.980000f, 0.010000f, 0.010000f, 0.950000f, 0.040000f, 0.010000f, 0.500000f, 0.490000f, 0.010000f, 0.050000f, 0.900000f, 0.050000f};
    float data7[] = {0.050000f, 0.950000f};
    float data8[] = {0.920000f, 0.030000f, 0.050000f};
    float data9[] = {0.040000f, 0.960000f};
    float data10[] = {0.100000f, 0.900000f};
    float data11[] = {0.050000f, 0.900000f, 0.050000f};
    float data12[] = {0.050000f, 0.930000f, 0.010000f, 0.010000f, 0.050000f, 0.010000f, 0.930000f, 0.010000f, 0.050000f, 0.010000f, 0.010000f, 0.930000f};
    float data13[] = {0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f};
    float data14[] = {0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.300000f, 0.680000f, 0.010000f, 0.010000f, 0.950000f, 0.030000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.950000f, 0.030000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.500000f, 0.480000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.400000f, 0.580000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.300000f, 0.680000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f};
    float data15[] = {0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.030000f, 0.950000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.940000f, 0.040000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.880000f, 0.100000f, 0.010000f};
    float data16[] = {0.010000f, 0.010000f, 0.980000f, 0.010000f, 0.010000f, 0.980000f, 0.040000f, 0.920000f, 0.040000f, 0.900000f, 0.090000f, 0.010000f};
    float data17[] = {0.100000f, 0.900000f};
    float data18[] = {0.050000f, 0.950000f};
    float data19[] = {1.000000f, 0.000000f, 0.000000f, 0.950000f, 0.040000f, 0.010000f, 1.000000f, 0.000000f, 0.000000f, 0.010000f, 0.950000f, 0.040000f, 0.990000f, 0.010000f, 0.000000f, 0.950000f, 0.040000f, 0.010000f, 0.950000f, 0.040000f, 0.010000f, 0.010000f, 0.010000f, 0.980000f};
    float data20[] = {0.010000f, 0.990000f};
    float data21[] = {0.100000f, 0.900000f, 0.950000f, 0.050000f, 0.100000f, 0.900000f, 0.950000f, 0.050000f, 0.010000f, 0.990000f, 0.050000f, 0.950000f};
    float data22[] = {0.980000f, 0.010000f, 0.010000f, 0.980000f, 0.010000f, 0.010000f, 0.010000f, 0.980000f, 0.010000f, 0.980000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.980000f, 0.690000f, 0.300000f, 0.010000f};
    float data23[] = {0.010000f, 0.990000f};
    float data24[] = {0.980000f, 0.010000f, 0.010000f, 0.300000f, 0.400000f, 0.300000f};
    float data25[] = {0.010000f, 0.990000f, 0.010000f, 0.990000f, 0.700000f, 0.300000f, 0.010000f, 0.990000f, 0.050000f, 0.950000f, 0.700000f, 0.300000f, 0.010000f, 0.990000f, 0.050000f, 0.950000f, 0.950000f, 0.050000f, 0.010000f, 0.990000f, 0.050000f, 0.950000f, 0.700000f, 0.300000f, 0.010000f, 0.990000f, 0.050000f, 0.950000f, 0.950000f, 0.050000f, 0.050000f, 0.950000f, 0.050000f, 0.950000f, 0.950000f, 0.050000f, 0.010000f, 0.990000f, 0.010000f, 0.990000f, 0.700000f, 0.300000f, 0.010000f, 0.990000f, 0.050000f, 0.950000f, 0.700000f, 0.300000f, 0.010000f, 0.990000f, 0.050000f, 0.950000f, 0.990000f, 0.010000f, 0.010000f, 0.990000f, 0.050000f, 0.950000f, 0.700000f, 0.300000f, 0.010000f, 0.990000f, 0.050000f, 0.950000f, 0.990000f, 0.010000f, 0.050000f, 0.950000f, 0.050000f, 0.950000f, 0.990000f, 0.010000f, 0.010000f, 0.990000f, 0.010000f, 0.990000f, 0.100000f, 0.900000f, 0.010000f, 0.990000f, 0.010000f, 0.990000f, 0.100000f, 0.900000f, 0.010000f, 0.990000f, 0.010000f, 0.990000f, 0.300000f, 0.700000f, 0.010000f, 0.990000f, 0.010000f, 0.990000f, 0.100000f, 0.900000f, 0.010000f, 0.990000f, 0.010000f, 0.990000f, 0.300000f, 0.700000f, 0.010000f, 0.990000f, 0.010000f, 0.990000f, 0.300000f, 0.700000f};
    float data26[] = {0.050000f, 0.900000f, 0.050000f, 0.010000f, 0.090000f, 0.900000f};
    float data27[] = {0.980000f, 0.010000f, 0.010000f, 0.300000f, 0.400000f, 0.300000f, 0.010000f, 0.980000f, 0.010000f, 0.400000f, 0.590000f, 0.010000f, 0.980000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.980000f};
    float data28[] = {0.100000f, 0.900000f};
    float data29[] = {0.333333f, 0.333333f, 0.333333f, 0.010000f, 0.980000f, 0.010000f, 0.980000f, 0.010000f, 0.010000f, 0.333333f, 0.333333f, 0.333333f, 0.333333f, 0.333333f, 0.333333f, 0.010000f, 0.010000f, 0.980000f};
    float data30[] = {0.333333f, 0.333333f, 0.333333f, 0.010000f, 0.980000f, 0.010000f, 0.980000f, 0.010000f, 0.010000f, 0.333333f, 0.333333f, 0.333333f, 0.333333f, 0.333333f, 0.333333f, 0.010000f, 0.010000f, 0.980000f};
    float data31[] = {0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f};
    float data32[] = {0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.500000f, 0.480000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.500000f, 0.480000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.600000f, 0.380000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f};
    float data33[] = {0.010000f, 0.190000f, 0.800000f, 0.050000f, 0.900000f, 0.050000f};
    float data34[] = {0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.050000f, 0.250000f, 0.250000f, 0.450000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.200000f, 0.750000f, 0.040000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.290000f, 0.300000f, 0.400000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.900000f, 0.080000f, 0.010000f, 0.010000f, 0.300000f, 0.490000f, 0.200000f, 0.010000f, 0.150000f, 0.250000f, 0.590000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.200000f, 0.700000f, 0.090000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.080000f, 0.900000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.380000f, 0.600000f, 0.010000f, 0.010000f, 0.080000f, 0.900000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.010000f, 0.970000f, 0.010000f, 0.010000f, 0.010000f, 0.100000f, 0.840000f, 0.050000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f, 0.400000f, 0.580000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.010000f, 0.970000f};
    float data35[] = {0.980000f, 0.010000f, 0.010000f, 0.950000f, 0.040000f, 0.010000f, 0.800000f, 0.190000f, 0.010000f, 0.950000f, 0.040000f, 0.010000f, 0.040000f, 0.950000f, 0.010000f, 0.010000f, 0.040000f, 0.950000f, 0.300000f, 0.690000f, 0.010000f, 0.010000f, 0.300000f, 0.690000f, 0.010000f, 0.010000f, 0.980000f};
    float data36[] = {0.980000f, 0.010000f, 0.010000f, 0.980000f, 0.010000f, 0.010000f, 0.900000f, 0.090000f, 0.010000f, 0.980000f, 0.010000f, 0.010000f, 0.100000f, 0.850000f, 0.050000f, 0.050000f, 0.200000f, 0.750000f, 0.300000f, 0.600000f, 0.100000f, 0.050000f, 0.400000f, 0.550000f, 0.010000f, 0.090000f, 0.900000f};
    float *data[] = { data0, data1, data2, data3, data4,
	data5, data6, data7, data8, data9,
	data10, data11, data12, data13, data14,
	data15, data16, data17, data18, data19,
	data20, data21, data22, data23, data24,
	data25, data26, data27, data28, data29,
	data30, data31, data32, data33, data34,
	data35, data36};
    
    for( i = 0; i < nnodes; i++ )
    {
	myParams[i]->AllocMatrix(data[i], matTable);
	pBNet->AttachFactor(myParams[i]);
    }
    
    delete [] nodeTypes;
    delete[] nodeAssociation;

    CContextPersistence xmlContext;
    xmlContext.Put(pBNet, "MyModel");
    if(!xmlContext.SaveAsXML("myFavoriteObjects.xml"))
    {
	fprintf(stderr, "Persistence: error!\n");
	// something goes wrong – can’t create
    }
    else
    {
	fprintf(stderr, "Persistence: good!\n");
    }
    
    return pBNet;
}