void CSpecPearlInfEngine::ParallelProtocol()
{
    if( m_maxNumberOfIterations == 0 )
    {
        SetMaxNumberOfIterations(m_numOfNdsInModel);
    }
    int i, j;
    int converged = 0;
    int changed = 0;
    int iter = 0;
    const CGraph *pGraph = m_pGraphicalModel->GetGraph();
    int nNodes = m_connNodes.size();

    //set current state
    m_curState = 0;
    m_nextState = 1;
    while ((!converged)&&( iter<m_maxNumberOfIterations ))
    {
        //work with new data
        int                    numOfNeighb;
        const int              *neighbors;
        const ENeighborType *orientation;
        
        for( i = 0; i < nNodes; i++ )
        {
            pGraph->GetNeighbors( m_connNodes[i], &numOfNeighb, 
                &neighbors, &orientation );
            for( j = 0; j < numOfNeighb; j++)
            {
                //delete m_newMessages[m_connNodes[i]][j];
                ComputeMessage( m_connNodes[i], neighbors[j], orientation[j],
                    m_curMessages[m_nextState][m_connNodes[i]][j] );
            }
        }
        //need to replace all old messages with new
        m_curState = m_nextState;
        m_nextState = 1 - m_curState;
        //compute beliefs
        changed = 0;
        for( i = 0; i < nNodes; i++ )
        {
            if( !m_areReallyObserved[m_connNodes[i]])
            {
                ComputeBelief( m_connNodes[i] );
                changed += !m_beliefs[m_curState][m_connNodes[i]]->IsFactorsDistribFunEqual(
                    m_beliefs[m_nextState][m_connNodes[i]], m_tolerance);
            }
        }
        converged = !(changed);
        iter++;
    }//while ((!converged)&&(iter<m_numberOfIterations))
    m_IterationCounter = iter;
    //need to set both states to valid state
    m_curState = m_nextState;
}
Пример #2
0
// Modified Belief Propagation for complete-graph MRF
void MatchMRFGraph::BeliefProp()
{
	int iter = 0, max_iter = 7;
	// max_iter is typically from 3 to 7
	int i,k,ni,nj,j;
	int neighbor_n[10000];   // neighborhood nodes
	int neighb_n_num;
	double sum,b,a,c;

// init all messages
	for(i=0;i<edge_num;i++)
	{
		for(j=0;j<m_state_num;j++)
		{
			IEDGE_PTR(i)->mij[j] = 1;
			IEDGE_PTR(i)->mji[j] = 1;
		}
	}

	m_M = (double *) MYMalloc(node_num*m_state_num*sizeof(double));
	for(i=0;i<node_num*m_state_num;i++)  m_M[i] = 1.0;

	do
	{
// compute all messages
		for(k=0;k<edge_num;k++)
		{
// mij
			ni = IEDGE_PTR(k)->ni;
			nj = IEDGE_PTR(k)->nj;

			ComputeMessage(k,ni,nj);  // calculate mij
			ComputeMessage(k,nj,ni);  // calculate mji
		}

		iter ++;

// update all messages
		for(k=0;k<edge_num;k++)
		{
			for(i=0;i<m_state_num;i++)
			{
				a = IEDGE_PTR(k)->mij[i];
				c = IEDGE_PTR(k)->mij_p[i];
				IEDGE_PTR(k)->mij[i] = IEDGE_PTR(k)->mij_p[i];  
				IEDGE_PTR(k)->mji[i] = IEDGE_PTR(k)->mji_p[i];
			}
		}

// update M
		for(i=0;i<node_num*m_state_num;i++)  
			m_M[i] = 0;

		for(k=0;k<edge_num;k++)
		{
			ni = IEDGE_PTR(k)->ni;
			nj = IEDGE_PTR(k)->nj;

			for(i=0;i<m_state_num;i++)
			{
				// to nj
				m_M[nj*m_state_num+i] += log(IEDGE_PTR(k)->mij[i]);
				// to ni
				m_M[ni*m_state_num+i] += log(IEDGE_PTR(k)->mji[i]);
			}
		}

		for(i=0;i<node_num*m_state_num;i++)  
			m_M[i] = exp(m_M[i]);
	} while(iter < max_iter);

// compute all 1-node belief
	for(k=0;k<node_num;k++)
	{
		neighb_n_num = GetNeighborNode(k,neighbor_n);

		sum = 0;
		for(i=0;i<m_state_num;i++)
		{
			INODE_PTR(k)->b1[i] = INODE_PTR(k)->phi[i]*m_M[k*m_state_num+i];
			sum+= INODE_PTR(k)->b1[i];
		}

		assert(sum>0);
		for(i=0;i<m_state_num;i++)
		{
			INODE_PTR(k)->b1[i] /= sum;
		}
		
		b= INODE_PTR(k)->b1[1];
		INODE_PTR(k)->color = (int)(INODE_PTR(k)->b1[1]*255);
	}

// Disable 2Node belief
	Compute2NodeBelief();
	MYFree(m_M);
}