def segmentGC(pred, beta):
    '''
       This function implements a call to the standard Graph Cut segmentation
       in the OpenGM library (http://hci.iwr.uni-heidelberg.de/opengm2/).
       Potts model is assumed, with a 4-neighborhood for 2D data and a 6-neighborhood
       for 3D data to define the pairwise terms.
       Parameters:
       -- pred - the unary terms, used directly (no Log applied, do it outside if needed)
          This input is assumed to be 3D!
       -- beta - the weight of the pairwise potentials, usually called lambda
       Return:
       -- binary volume, as produced by OpenGM

    '''
    nz, ny, nx = pred.shape

    numVar = pred.size
    numLabels = 2

    numberOfStates = np.ones(numVar, dtype=opengm.index_type) * numLabels
    gm = opengm.graphicalModel(numberOfStates, operator='adder')

    # Adding unary function and factors
    functions = np.zeros((numVar, 2))
    predflat = pred.reshape((numVar, 1))
    if (predflat.dtype == np.uint8):
        predflat = predflat.astype(np.float32)
        predflat = predflat / 256.

    functions[:, 0] = predflat[:, 0]
    functions[:, 1] = 1 - predflat[:, 0]

    unary_fids = gm.addFunctions(functions)
    gm.addFactors(unary_fids, np.arange(0, numVar))

    # add one binary function (potts fuction)
    potts = opengm.PottsFunction([2, 2], 0.0, beta)
    binary_fid = gm.addFunction(potts)

    # add binary factors
    indices = np.arange(numVar, dtype=np.uint32).reshape((nz, ny, nx))
    z_edges = np.concatenate([indices[:nz - 1, :, :], indices[1:, :, :]]
                             ).reshape((2, (nz - 1) * ny * nx)).transpose()
    y_edges = np.concatenate([indices[:, :ny - 1, :], indices[:, 1:, :]]
                             ).reshape((2, nz * (ny - 1) * nx)).transpose()
    x_edges = np.concatenate([indices[:, :, :nx - 1], indices[:, :, 1:]]
                             ).reshape((2, nz * ny * (nx - 1))).transpose()

    gm.addFactors(binary_fid, z_edges)
    gm.addFactors(binary_fid, y_edges)
    gm.addFactors(binary_fid, x_edges)

    grcut = opengm.inference.GraphCut(gm)
    grcut.infer()
    argmin = grcut.arg()

    res = argmin.reshape((nz, ny, nx))
    if hasattr(pred, 'axistags'):
        res = vigra.taggedView(res, pred.axistags)
    return res
def segment_adjacency_graph(segment_unaries,
                            segment_map,
                            segment_regularizer=None):
    """
	Creates a region adjacency graph. Each segment has a variable and adjacent segments are linked by edges
	"""
    _check_valid_segment_map(segment_map)
    _check_compatible_segment_map_unaries(segment_map, segment_unaries)

    n_vars = segment_unaries.shape[0]
    n_labels = segment_unaries.shape[-1]

    edges = segment_map_to_rag_edges(segment_map)

    n_edges = edges.shape[0]

    # allocate space for the model and all its variables
    gm = opengm.graphicalModel([n_labels] * n_vars)

    gm.reserveFunctions(
        n_vars + n_edges,
        'explicit')  # the unary functions plus the 3 types of regularizer
    gm.reserveFactors(n_vars + n_edges)

    gm = add_layer(gm, segment_unaries, edges, segment_regularizer)
    gm.finalize()
    return gm
Example #3
0
 def test_constructor_list(self):
    numberOfStates=[2,3,4]
    gm=opengm.graphicalModel(numberOfStates,operator="adder")
    assert(gm.numberOfVariables==3)
    assert(gm.numberOfLabels(0)==2)
    assert(gm.numberOfLabels(1)==3)
    assert(gm.numberOfLabels(2)==4)
Example #4
0
File: PGM.py Project: kolesman/pygm
    def _constructOpenGMModel(self):

        openGMModel = opengm.graphicalModel(self.cardinalities, operator="adder")

        for factor in self.factors:
            members = tuple(map(int, list(factor.members)))
            func = openGMModel.addFunction(factor.values)
            openGMModel.addFactor(func, members)

        return openGMModel
Example #5
0
 def test_constructor_numpy(self):
    numberOfStates=numpy.ones(3,dtype=numpy.uint64)
    numberOfStates[0]=2
    numberOfStates[1]=3
    numberOfStates[2]=4
    gm=opengm.graphicalModel(numberOfStates)
    assert(gm.numberOfVariables==3)
    assert(gm.numberOfLabels(0)==2)
    assert(gm.numberOfLabels(1)==3)
    assert(gm.numberOfLabels(2)==4)
    def fit(self, mapc, th, enc, lambda0):
        '''
        create a model for the decision fo the word
        '''
        import opengm
        N = len(mapc)
        K = self.K
        numLabel = [K + 1] * N
        self.gm = opengm.graphicalModel(numLabel)

        i0 = np.argsort(mapc, axis=0)[:, 0]
        self.indice = i0
        v = []
        unary = []
        for i in i0:
            p = mapc[i][1]
            Eu = []
            for k in range(self.K):
                Eu.append(1 - p[k])
            Eu.append(mapc[i][2])
            #Eu.append(max(p))
            v.append([mapc[i][0], Eu, mapc[i][3]])
            unary.append(Eu)
        self.vertices = v

        unary = np.array(unary)
        assert (unary.shape == (N, K + 1))
        fid = self.gm.addFunctions(unary)
        vis = np.arange(0, N, dtype=np.uint64)
        self.gm.addFactors(fid, vis)

        self.edges = []
        self.overlap = np.zeros((N, N))
        for i, v1 in enumerate(self.vertices):
            for j, v2 in enumerate(self.vertices[i + 1:]):
                dx = abs(v2[0][0] - v1[0][0])
                dy = abs(v2[0][1] - v1[0][1])
                w = min(v1[2][0], v2[2][0])
                h = min(v1[2][1], v2[2][0])
                if dx < th * w and dy < th * h:
                    intersec = (w - min(w, abs(v2[0][0] - v1[0][0])))
                    intersec *= (h - min(h, abs(v2[0][1] - v1[0][1])))
                    intersec *= 100. / (w * h)

                    v0 = lambda0 * np.exp(-(100 - intersec)**2)
                    BinaryE = np.ones((K + 1, K + 1)) * v0
                    BinaryE += self.prior
                    BinaryE[K, K] = 0

                    fid = self.gm.addFunction(BinaryE)
                    self.edges.append((i, j + i + 1, intersec))
                    self.gm.addFactor(fid, [i, j + i + 1])
def potts_lattice_graph(pixel_unaries, beta):
    n_vars = pixel_unaries.shape[0] * pixel_unaries.shape[1]
    n_labels = pixel_unaries.shape[-1]
    n_edges = calc_n_pixel_edges(pixel_unaries.shape)

    gm = opengm.graphicalModel([n_labels] * n_vars)
    gm.reserveFunctions(
        n_vars + 1,
        'explicit')  # the unary functions plus the 1 type of regularizer
    gm.reserveFactors(n_vars + n_edges)

    gm = add_potts_lattice_layer(gm, pixel_unaries, beta)

    gm.finalize()
    return gm
Example #8
0
    def makeModel(img, gt):
        shape = gt.shape[0:2]
        numVar = shape[0] * shape[1]

        # make model
        gm = graphicalModel(numpy.ones(numVar) * numberOfLabels)

        # compute features
        unaryFeat = getFeat(fUnary, img)
        unaryFeat = numpy.nan_to_num(
            numpy.concatenate(unaryFeat, axis=2).view(numpy.ndarray))
        unaryFeat = unaryFeat.reshape([numVar, -1])

        # add unaries
        lUnaries = lUnaryFunctions(
            weights=weights,
            numberOfLabels=numberOfLabels,
            features=unaryFeat,
            weightIds=uWeightIds,
            featurePolicy=FeaturePolicy.sharedBetweenLabels,
            makeFirstEntryConst=numberOfLabels == 2,
            addConstFeature=addConstFeature)
        fids = gm.addFunctions(lUnaries)
        gm.addFactors(fids, numpy.arange(numVar))

        if len(fBinary) > 0:
            binaryFeat = getFeat(fBinary, img)
            binaryFeat = numpy.nan_to_num(
                numpy.concatenate(binaryFeat, axis=2).view(numpy.ndarray))
            binaryFeat = binaryFeat.reshape([numVar, -1])

            # add second order
            vis2Order = gridVis(shape[0:2], True)

            fU = binaryFeat[vis2Order[:, 0], :]
            fV = binaryFeat[vis2Order[:, 1], :]
            fB = (fU + fV / 2.0)

            lp = lPottsFunctions(weights=weights,
                                 numberOfLabels=numberOfLabels,
                                 features=fB,
                                 weightIds=bWeightIds,
                                 addConstFeature=addConstFeature)
            gm.addFactors(gm.addFunctions(lp), vis2Order)

        return gm
Example #9
0
def buildGM(img,rag,dataImage,numLabels,boundaryPixels,regionPixels,beta,sigma,verbose=False):
   
   print "get region clustering"   
   regionFeatures=numpy.ones([rag.numberOfRegions(),3],dtype=numpy.float64)
   print "lab type in gm" ,type(img)
   print "lab type in gm shape" ,img.shape
   npimg=numpy.ones(img.shape)
   npimg[:,:,:]=img[:,:,:]
   print "npimg type in gm shape" ,npimg.shape
   for r in range(rag.numberOfRegions()):
      for c in range(3):
         regionFeatures[r,c]=numpy.mean(npimg[regionPixels[r][:,0],regionPixels[r][:,1]][c])
         
   print "do clustering"   
   code,dists=doClustering(regionFeatures,k=numLabels,steps=100)
   dists=(dists-dists.min())/(dists.max()-dists.min())      
   
   if verbose==True : print "get boundary evidence" 
   boundaryEvidence=numpy.ones(rag.numberOfBoundaries(),dtype=numpy.float64)
   be=numpy.ones([rag.numberOfBoundaries(),2],dtype=numpy.float64)
   energy=numpy.ones([rag.numberOfBoundaries(),2],dtype=numpy.float64)
   for b in range(rag.numberOfBoundaries()):
      boundaryEvidence[b]=numpy.mean(dataImage[boundaryPixels[b][:,0],boundaryPixels[b][:,1]])
      r=rag.adjacentRegions(b)

   boundaryEvidence=(boundaryEvidence-boundaryEvidence.min())/(boundaryEvidence.max()-boundaryEvidence.min())*(1.0-2.0*epsilon) + epsilon
   be[:,1]=numpy.exp(-1.0*boundaryEvidence[:]*sigma)
   be[:,0]=1.0-be[:,1]
   energy [:,0]= (-1.0*numpy.log( (1)*(1.0-beta)  ) ) +be[:,0]
   energy [:,1]= (-1.0*numpy.log( (1)*(beta)  ) )    +be[:,1]
   if verbose==True : print "build gm" 
   gm=opengm.graphicalModel(numpy.ones(rag.numberOfRegions(),dtype=numpy.uint64)*numLabels)
   shapePotts=[numLabels,numLabels]
   
   
   print "add unaries"
   for r in range(rag.numberOfRegions()):
      f=dists[r,:]*gamma
      vis=[r]
      gm.addFactor(gm.addFunction(f),vis)
   print "add 2.order"
   for b in range(rag.numberOfBoundaries()):
      f=opengm.pottsFunction(shapePotts, energy[b,0] ,energy[b,1])
      vis=rag.adjacentRegions(b)
      gm.addFactor(gm.addFunction(f),vis)
   return gm
Example #10
0
    def makeModel(img,gt):
        shape = gt.shape[0:2]
        numVar = shape[0] * shape[1]

        # make model
        gm = graphicalModel(numpy.ones(numVar)*numberOfLabels)




        # compute features
        unaryFeat = getFeat(fUnary, img)
        unaryFeat = numpy.nan_to_num(numpy.concatenate(unaryFeat,axis=2).view(numpy.ndarray))
        unaryFeat  = unaryFeat.reshape([numVar,-1])
        



        # add unaries
        lUnaries = lUnaryFunctions(weights =weights,numberOfLabels = numberOfLabels, 
                                    features=unaryFeat, weightIds = uWeightIds,
                                    featurePolicy= FeaturePolicy.sharedBetweenLabels,
                                    makeFirstEntryConst=numberOfLabels==2, addConstFeature=addConstFeature)
        fids = gm.addFunctions(lUnaries)
        gm.addFactors(fids, numpy.arange(numVar))


        if len(fBinary)>0:
            binaryFeat = getFeat(fBinary, img)
            binaryFeat = numpy.nan_to_num(numpy.concatenate(binaryFeat,axis=2).view(numpy.ndarray))
            binaryFeat  = binaryFeat.reshape([numVar,-1])

            # add second order
            vis2Order=gridVis(shape[0:2],True)

            fU = binaryFeat[vis2Order[:,0],:]
            fV = binaryFeat[vis2Order[:,1],:]
            fB  = (fU +  fV / 2.0)
            
            lp = lPottsFunctions(weights=weights, numberOfLabels=numberOfLabels,
                                          features=fB, weightIds=bWeightIds,
                                          addConstFeature=addConstFeature)
            gm.addFactors(gm.addFunctions(lp), vis2Order) 

        return gm
def getGraphicalModel(words):
    #print 1
    noNodes = sum(map(lambda x : 1 if x is not None else 0, words))
    
    word_factors_list = []
    no_of_states = []
    for word in words:
        if word is not None:
            factors = get_unary_factors(word)
            word_factors_list.append(factors)
            no_of_states.append(len(factors.keys()))
        
    #print 2
    gm = opengm.graphicalModel(no_of_states)
    
    # Add unary factor nodes for each word factor.
    for i, word_factors in enumerate(word_factors_list):
        factor_handle = gm.addFunction(np.array(word_factors.values()))
        gm.addFactor(factor_handle, i)
    
    #print 3
    # TODO: Assuming that relation exists only left to right
    for i in range(len(word_factors_list) - 1):
        # TODO: Just getting the similarity score.
        words_i = word_factors_list[i].keys()
        words_i1 = word_factors_list[i + 1].keys()
        
        binary_func = []
        for word_a in words_i:
            word_a_values = []
            for word_b in words_i1:
                word_a_values.append(cos_sim.get_sim(final_model.get_row(word_a), final_model.get_row(word_b)))
            binary_func.append(word_a_values)
        factor_handle = gm.addFunction(np.array(binary_func))
        gm.addFactor(factor_handle, [i, i+1])
    #print 4
    #opengm.visualizeGm(gm)
    inf = opengm.inference.BeliefPropagation(gm,parameter=opengm.InfParam(damping=0.05))
    inf.infer()
    #print 5
    return inf
Example #12
0
    def makeModel(img,sp,gt):
        assert sp.min() == 0
        shape = img.shape[0:2]
        gg = vigra.graphs.gridGraph(shape)
        rag = vigra.graphs.regionAdjacencyGraph(gg,sp)
        numVar = rag.nodeNum
        assert rag.nodeNum == rag.maxNodeId +1

        # make model
        gm = graphicalModel(numpy.ones(numVar)*numberOfLabels)

        assert gm.numberOfVariables == rag.nodeNum 
        assert gm.numberOfVariables == rag.maxNodeId +1

        # compute features
        unaryFeat = getFeat(fUnary, img)
        unaryFeat = numpy.nan_to_num(numpy.concatenate(unaryFeat,axis=2).view(numpy.ndarray)).astype('float32')
        unaryFeat = vigra.taggedView(unaryFeat,'xyc')
        accList = []

        #for c in range(unaryFeat.shape[-1]):
        #    cUnaryFeat = unaryFeat[:,:,c]
        #    cAccFeat = rag.accumulateNodeFeatures(cUnaryFeat)[:,None]
        #    accList.append(cAccFeat)
        #accUnaryFeat = numpy.concatenate(accList,axis=1)
        accUnaryFeat = rag.accumulateNodeFeatures(unaryFeat)#[:,None]


        #print accUnaryFeat.shape

        #accUnaryFeat = rag.accumulateNodeFeatures(unaryFeat[:,:,:])
        #accUnaryFeat = vigra.taggedView(accUnaryFeat,'nc')
        #accUnaryFeat = accUnaryFeat[1:accUnaryFeat.shape[0],:]

      



        #binaryFeat  = binaryFeat.reshape([numVar,-1])



        # add unaries
        lUnaries = lUnaryFunctions(weights =weights,numberOfLabels = numberOfLabels, 
                                            features=accUnaryFeat, weightIds = uWeightIds,
                                            featurePolicy= FeaturePolicy.sharedBetweenLabels,
                                            makeFirstEntryConst=numberOfLabels==2, addConstFeature=addConstFeature)
        fids = gm.addFunctions(lUnaries)
        gm.addFactors(fids, numpy.arange(numVar))

        
        if len(fBinary)>0:
            binaryFeat = getFeat(fBinary, img, topoShape=False)
            binaryFeat = numpy.nan_to_num(numpy.concatenate(binaryFeat,axis=2).view(numpy.ndarray)).astype('float32')
            edgeFeat = vigra.graphs.edgeFeaturesFromImage(gg, binaryFeat)
            accBinaryFeat = rag.accumulateEdgeFeatures(edgeFeat)

            uvIds =  numpy.sort(rag.uvIds(), axis=1)
            assert uvIds.min()==0
            assert uvIds.max()==gm.numberOfVariables-1



        
            lp = lPottsFunctions(weights=weights, numberOfLabels=numberOfLabels,
                                          features=accBinaryFeat, weightIds=bWeightIds,
                                          addConstFeature=addConstFeature)
            fids = gm.addFunctions(lp)
            gm.addFactors(fids, uvIds) 

        return gm
Example #13
0
    def makeModel(img, sp, gt):
        assert sp.min() == 0
        shape = img.shape[0:2]
        gg = vigra.graphs.gridGraph(shape)
        rag = vigra.graphs.regionAdjacencyGraph(gg, sp)
        numVar = rag.nodeNum
        assert rag.nodeNum == rag.maxNodeId + 1

        # make model
        gm = graphicalModel(numpy.ones(numVar) * numberOfLabels)

        assert gm.numberOfVariables == rag.nodeNum
        assert gm.numberOfVariables == rag.maxNodeId + 1

        # compute features
        unaryFeat = getFeat(fUnary, img)
        unaryFeat = numpy.nan_to_num(
            numpy.concatenate(unaryFeat,
                              axis=2).view(numpy.ndarray)).astype('float32')
        unaryFeat = vigra.taggedView(unaryFeat, 'xyc')
        accList = []

        #for c in range(unaryFeat.shape[-1]):
        #    cUnaryFeat = unaryFeat[:,:,c]
        #    cAccFeat = rag.accumulateNodeFeatures(cUnaryFeat)[:,None]
        #    accList.append(cAccFeat)
        #accUnaryFeat = numpy.concatenate(accList,axis=1)
        accUnaryFeat = rag.accumulateNodeFeatures(unaryFeat)  #[:,None]

        #print accUnaryFeat.shape

        #accUnaryFeat = rag.accumulateNodeFeatures(unaryFeat[:,:,:])
        #accUnaryFeat = vigra.taggedView(accUnaryFeat,'nc')
        #accUnaryFeat = accUnaryFeat[1:accUnaryFeat.shape[0],:]

        #binaryFeat  = binaryFeat.reshape([numVar,-1])

        # add unaries
        lUnaries = lUnaryFunctions(
            weights=weights,
            numberOfLabels=numberOfLabels,
            features=accUnaryFeat,
            weightIds=uWeightIds,
            featurePolicy=FeaturePolicy.sharedBetweenLabels,
            makeFirstEntryConst=numberOfLabels == 2,
            addConstFeature=addConstFeature)
        fids = gm.addFunctions(lUnaries)
        gm.addFactors(fids, numpy.arange(numVar))

        if len(fBinary) > 0:
            binaryFeat = getFeat(fBinary, img, topoShape=False)
            binaryFeat = numpy.nan_to_num(
                numpy.concatenate(binaryFeat, axis=2).view(
                    numpy.ndarray)).astype('float32')
            edgeFeat = vigra.graphs.edgeFeaturesFromImage(gg, binaryFeat)
            accBinaryFeat = rag.accumulateEdgeFeatures(edgeFeat)

            uvIds = numpy.sort(rag.uvIds(), axis=1)
            assert uvIds.min() == 0
            assert uvIds.max() == gm.numberOfVariables - 1

            lp = lPottsFunctions(weights=weights,
                                 numberOfLabels=numberOfLabels,
                                 features=accBinaryFeat,
                                 weightIds=bWeightIds,
                                 addConstFeature=addConstFeature)
            fids = gm.addFunctions(lp)
            gm.addFactors(fids, uvIds)

        return gm
Example #14
0
import numpy
import opengm

img = numpy.random.rand(4, 4)
dimx = img.shape[0]
dimy = img.shape[1]

numVar = dimx * dimy
numLabels = 2
beta = 0.3

numberOfStates = numpy.ones(numVar, dtype=opengm.index_type) * numLabels
gm = opengm.graphicalModel(numberOfStates, operator='adder')

#Adding unary function and factors
for y in range(dimy):
    for x in range(dimx):
        f = numpy.ones(2, dtype=numpy.float32)
        f[0] = img[x, y]
        f[1] = 1.0 - img[x, y]
        fid = gm.addFunction(f)
        gm.addFactor(fid, (x * dimy + y, ))

#Adding binary function and factors"
vis = numpy.ones(5, dtype=opengm.index_type)
#add one binary function (potts fuction)
f = numpy.ones(pow(numLabels, 2), dtype=numpy.float32).reshape(
    numLabels, numLabels) * beta
for l in range(numLabels):
    f[l, l] = 0
fid = gm.addFunction(f)
Example #15
0
dimx=100
dimy=100
numVar=dimx*dimy
numLabels=20
beta=0.8

# ---------------------------------
# reserve factors and functions can
# save a lot of time
# ---------------------------------

t=time.time()

numberOfStates=numpy.ones(numVar,dtype=opengm.index_type)*numLabels
gm=opengm.graphicalModel(numberOfStates,operator='adder')
#Adding unary function and factors
for y in range(dimy):
   for x in range(dimx):
      f1=numpy.random.random(numLabels).astype(numpy.float32)
      fid=gm.addFunction( f1)
      gm.addFactor(fid,(x+dimx*y,))
#Adding binary function and factors"
vis=numpy.ones(5,dtype=opengm.index_type)
#add one binary function (potts fuction)
f=numpy.ones(pow(numLabels,2)).reshape(numLabels,numLabels)*beta
for l in range(numLabels):
   f[l,l]=0  
fid=gm.addFunction(f)
#add binary factors
for y in range(dimy):   
def segment_overlap_graph(pixel_unaries,
                          segment_map,
                          segment_unaries,
                          pixel_regularizer=None,
                          segment_regularizer=None,
                          inter_layer_regularizer=None):
    """
	greates a graphical model comprised of two layers. 
		- The first layer is a pixel lattice
		- The second layer is a region adjacency graph over segments
		- Connections exist between pixels where they are overlapped by a segment

	Parameters:
		- pixel_unaries - a 3D array of shape (width, height, n_labels). 
		- segment_map - a 2d array of shape (width, height). Each element >= 0 is a segment id that maps the corresponding pixel to that id. -1 represents no segment and no corresponding node will be added
		- segment_unaries - a 2d arry of shape (n_segments, n_labels)
		- pixel_regularizer (optional) - a pairwise opengm function e.g. opengm.PottsFunction([2,2],0.0,beta) or list of opengm functions of length n_pixels
		- segment_regularizer (optional) - a pairwise opengm function, same requirements as pixel_regularizer
		- inter_layer_regularizer (optional) - a pairwise opengm function, same requirements as pixel_regularizer
	"""
    _check_valid_segment_map(segment_map)
    _check_compatible_segment_map_unaries(segment_map, segment_unaries)

    # calculate how many variables and factors will be required
    n_pixels = pixel_unaries.shape[0] * pixel_unaries.shape[1]
    n_segments = segment_unaries.shape[0]
    n_variables = n_pixels + n_segments

    n_labels_pixels = pixel_unaries.shape[-1]
    n_labels_segments = segment_unaries.shape[-1]

    # calculate the region adjacency graph for the segments
    rag_edges = segment_map_to_rag_edges(segment_map)
    rag_edges += n_pixels  #segment indices start at n_pixels remember!

    n_pixel_edges = (pixel_unaries.shape[0] - 1) * pixel_unaries.shape[1] + (
        pixel_unaries.shape[1] - 1) * pixel_unaries.shape[0]
    n_segment_edges = rag_edges.shape[0]  #check this is right
    n_inter_edges = n_pixels
    n_edges = n_pixel_edges + n_segment_edges + n_inter_edges

    # allocate space for the model and all its variables
    gm = opengm.graphicalModel([n_labels_pixels] * n_pixels +
                               [n_labels_segments] * n_segments)

    gm.reserveFunctions(
        n_variables + 3,
        'explicit')  # the unary functions plus the 3 types of regularizer
    gm.reserveFactors(n_variables + n_edges)

    # add unary functions and factors
    fids = gm.addFunctions(pixel_unaries.reshape([n_pixels, n_labels_pixels]))
    gm.addFactors(fids, np.arange(n_pixels), finalize=False)

    fids = gm.addFunctions(segment_unaries)
    gm.addFactors(fids, n_pixels + np.arange(n_segments), finalize=False)

    ## add pairwise functions
    # pixel lattice
    if pixel_regularizer is not None:
        fid = gm.addFunction(pixel_regularizer)
        vis = opengm.secondOrderGridVis(pixel_unaries.shape[0],
                                        pixel_unaries.shape[1])
        gm.addFactors(fid, vis, finalize=False)

    # segment rag
    if segment_regularizer is not None:
        fid = gm.addFunction(segment_regularizer)
        gm.addFactors(fid, np.sort(rag_edges, axis=1), finalize=False)

    # inter-layer
    if inter_layer_regularizer is not None:
        fid = gm.addFunction(inter_layer_regularizer)
        vis = np.dstack([
            np.arange(n_pixels).reshape(pixel_unaries.shape[:2]), segment_map
        ]).reshape((-1, 2))
        vis = _remove_rows_with_negative(vis)
        vis[:, 1] += n_pixels
        gm.addFactors(fid, vis, finalize=False)

    gm.finalize()

    return gm
Example #17
0
def build_factor_graph(G,
                       nodes,
                       edges,
                       n_annots,
                       n_names,
                       lookup_annot_idx,
                       use_unaries=True,
                       edge_probs=None,
                       operator='multiplier'):

    node_state_card = np.ones(n_annots, dtype=index_type) * n_names
    numberOfStates = node_state_card
    # n_edges = len(edges)
    # n_edge_states = 2
    # edge_state_card = np.ones(n_edges, dtype=index_type) * n_edge_states
    # numberOfStates = np.hstack([node_state_card, edge_state_card])
    # gm = opengm.graphicalModel(numberOfStates, operator='adder')
    gm = opengm.graphicalModel(numberOfStates, operator=operator)

    annot_idxs = list(range(n_annots))
    # edge_idxs = list(range(n_annots, n_annots + n_edges))
    import scipy.special

    if use_unaries:
        unaries = np.ones((n_annots, n_names)) / n_names
        # unaries[0][0] = 1
        # unaries[0][1:] = 0
        for annot_idx in annot_idxs:
            fid = gm.addFunction(unaries[annot_idx])
            gm.addFactor(fid, annot_idx)

    # Add Potts function for each edge
    pairwise_factor_idxs = []
    for count, (aid1, aid2) in enumerate(edges, start=len(list(gm.factors()))):
        varx1, varx2 = ut.take(lookup_annot_idx, [aid1, aid2])
        var_indicies = np.array([varx1, varx2])

        if edge_probs is None:
            p_same, p_diff = get_edge_id_probs(G, aid1, aid2, n_names)
        else:
            p_same, p_diff = edge_probs[count]

        use_logit = operator == 'adder'
        if use_logit:
            eps = 1E-9
            p_same = np.clip(p_same, eps, 1.0 - eps)
            same_weight = scipy.special.logit(p_same)
            # valueEqual = -same_weight
            valueEqual = 0
            valueNotEqual = same_weight
            if not np.isfinite(valueNotEqual):
                """
                python -m plottool.draw_func2 --exec-plot_func --show --range=-1,1 --func=scipy.special.logit
                """
                print('valueNotEqual = %r' % (valueNotEqual, ))
                print('p_same = %r' % (p_same, ))
                raise ValueError('valueNotEqual')
        else:
            valueEqual = p_same
            valueNotEqual = p_diff

        p_same, p_diff = get_edge_id_probs(G, aid1, aid2, n_names)
        pairwise_factor_idxs.append(count)

        potts_func = opengm.PottsFunction((n_names, n_names),
                                          valueEqual=valueEqual,
                                          valueNotEqual=valueNotEqual)
        potts_func_id = gm.addFunction(potts_func)
        gm.addFactor(potts_func_id, var_indicies)

    gm.pairwise_factor_idxs = pairwise_factor_idxs
    gm.G = G
    return gm
Example #18
0
    def infer(self):
        logging.info("Running Inference")
        ###########################
        # define binary variables #
        ###########################
        # two binary variables:
        #var 0 (stage S1): dimension is 2
        #var 1 (event E1): dimension is 2
        variables = [2, 2]

        ################################
        # # construct the Factor Graph #
        ################################
        gm = opengm.graphicalModel(variables, operator='multiplier')

        ########################################################################################
        # TODO: Fill in values in g_func, and g_var, according to the provided tables #
        ########################################################################################
        f_func = np.array([0.1, 0.9])  # priors f
        f_var = [0]  # f(S1) using S1 as variable 0
        g_func = np.array([[0, 0.2], [0, 0.5]])  # factor function g
        g_var = [0, 1]  # g(S1, S2)
        ############
        # END TODO #
        ############

        ##################################
        # connect factor functions to FG #
        ##################################

        gm.addFactor(gm.addFunction(f_func), f_var)  # add prior to event
        gm.addFactor(gm.addFunction(g_func),
                     g_var)  # add factor function to event (E1) and stage (S1)

        ##################################
        # # belief propagation inference #
        ##################################
        inf = opengm.inference.BeliefPropagation(gm, accumulator='maximizer')
        inf.infer()

        ##############
        # get argmax #
        ##############

        arg = inf.arg()
        print("Inference result: ", arg)

        ##############################
        # get marginal probabilities #
        ##############################
        marginals = inf.marginals(range(len(variables)))

        #############################################################
        # # get marginal of the state variable (variable index = 0) #
        #############################################################
        vars = [0]
        max_marg = marginals[0]
        max_val = 0
        for i in vars:
            marginals_xi = marginals[i]
            if marginals_xi > max_marg:
                max_val = i
                max_marg = marginals_xi
            marginals_xi /= np.sum(marginals_xi)
            print("x_{} marginal: {}".format(i, marginals_xi))
        pass
def classifyTissue(heatingParam):
	numLabels = 3
	dxdy, noParam = heatingParam.shape
	heatingParam = np.reshape(heatingParam, (640, 480, noParam))
	shape = heatingParam.shape
	dimx, dimy, noParam = shape[0], shape[1], shape[2]
	numVar = dimx * dimy

	dimx, dimy = shape[0], shape[1]
	numberOfStates = np.ones(numVar, dtype=opengm.index_type) * numLabels
	gm = opengm.graphicalModel(numberOfStates)

	# create unary potentials for CRF
	f = np.ones(numLabels, dtype=np.float32)
	for y in range(dimy):
		for x in range(dimx):
			f = np.ones(numLabels, dtype=np.float32)
			beta = abs(heatingParam[x, y, 2] - heatingParam[x, y, 3])
			f[0] = abs(heatingParam[x, y, 2]) # * (1/beta)
			f[1] = beta
			f[2] = abs(1 + heatingParam[x, y, 2]) # * (1/beta)
			fid = gm.addFunction(f)
			gm.addFactor(fid, (x * dimy + y,))

	# create pairwise potentials
	for y in range(dimy):
		for x in range(dimx):
			f_pw = np.ones(numLabels * numLabels, dtype=np.float32).reshape(numLabels, numLabels)
			if (x+1 < dimx):
				beta_i = abs(heatingParam[x, y, 2] - heatingParam[x, y, 3])
				beta_j = abs(heatingParam[x+1, y, 2] - heatingParam[x+1, y, 3])
				scaling_f = 1 / abs(beta_i - beta_j)
				f_pw[0, 0] = 0
				f_pw[1, 1] = 0
				f_pw[2, 2] = 0

				f_pw[0, 1] = scaling_f
				f_pw[0, 2] = scaling_f * 2
				f_pw[1, 0] = scaling_f

				f_pw[1, 2] = scaling_f
				f_pw[2, 0] = f_pw[0, 2]
				f_pw[2, 1] = f_pw[1, 2]

				fid = gm.addFunction(f_pw)
				gm.addFactor(fid, np.array([x * dimy + y, (x + 1) * dimy + y], dtype=opengm.index_type))
			if (y+1 < dimy):
				beta_i = abs(heatingParam[x, y, 2] - heatingParam[x, y, 3])
				beta_j = abs(heatingParam[x, y+1, 2] - heatingParam[x, y+1, 3])
				scaling_f = 1 / abs(beta_i - beta_j)
				f_pw[0, 0] = 0
				f_pw[1, 1] = 0
				f_pw[2, 2] = 0

				f_pw[0, 1] = scaling_f
				f_pw[0, 2] = scaling_f * 2
				f_pw[1, 0] = scaling_f

				f_pw[1, 2] = scaling_f
				f_pw[2, 0] = f_pw[0, 2]
				f_pw[2, 1] = f_pw[1, 2]

				fid = gm.addFunction(f_pw)
				gm.addFactor(fid, [x * dimy + y, x * dimy + (y + 1)])


	parameterBP = opengm.InfParam(steps=noIter,damping=0.5)
	parameter = opengm.InfParam(steps=noIter)

	# inf = opengm.inference.GraphCut(gm)
	# inf = opengm.inference.TrwsExternal(gm, parameter=parameter)
	# inf = opengm.inference.TreeReweightedBp(gm, parameter=parameter)
	inf = opengm.inference.BeliefPropagation(gm, parameter=parameterBP)
	callback = PyCallback((dimx, dimy), numLabels)
	# visitor = inf.pythonVisitor(callback, visitNth=1)
	# inf.infer(visitor)
	print "*** INFERENCE"
	startTime = time.time()
	inf.infer()
	endTime = time.time()
	labelVector = inf.arg()
	E = gm.evaluate(labelVector)
	print "FINAL E " + str(E) + " dt " + str(endTime - startTime) + "s"
	return labelVector
Example #20
0
    num_unary_feats = num_labels * X[0][0].shape[1]
    num_weights = num_unary_feats + num_edge_feats
    # create and initialize weights
    print 'num_weights =', num_weights
    print 'num_instances =', len(X)
    ogm_ds = learning.createDataset(num_weights, numInstances=len(X), loss="generalized-hamming")
    weights = ogm_ds.getWeights()

    for idx, (x, y) in enumerate(zip(X, Y)):
        y[y==-1]=0  # FIXME: introduce a void label, so long: make the void label background 
        unary_feats, edges, edge_feats = x
        num_vars = unary_feats.shape[0]

        states = np.ones(num_vars, dtype=opengm.index_type) * num_labels
        
        gm = opengm.graphicalModel(states, operator='adder')

        lossParam = learning.GeneralizedHammingLossParameter()
        lossParam.setLabelLossMultiplier(np.array(label_weights))

        # add unary factors
        weight_ids = np.arange(0, num_labels * unary_feats.shape[1]).reshape((num_labels, -1))
        for feat_idx, unary_feat in enumerate(unary_feats):
            # make that each label sees all features, but use their own weights
            unary_feat_array = np.repeat(unary_feat.reshape((-1,1)), num_labels, axis=1)
            f = learning.lUnaryFunction(weights, num_labels, unary_feat_array, weight_ids)
            var_idxs = np.array([feat_idx], dtype=np.uint64)
            fid = gm.addFunction(f)
            gm.addFactor(fid, var_idxs)
        #var_idxs = np.arange(0, num_vars, dtype=np.uint64)
        #gm.addFactors(fids, var_idxs)
# model parameter
gridSize = [3, 3]  # size of grid
beta = 0.7  # bias to choose between under- and over-segmentation
high = 100  # closedness-enforcing soft-constraint value for forbidden configurations

# size of the topological grid
tGridSize = [2 * gridSize[0] - 1, 2 * gridSize[1] - 1]
nrOfVariables = gridSize[1] * (gridSize[0] - 1) + gridSize[0] * (gridSize[1] -
                                                                 1)
cToVi = TopologicalCoordinateToIndex(gridSize)
# some random data on a grid
data = numpy.random.random(gridSize[0] * gridSize[1]).astype(
    numpy.float32).reshape(gridSize[0], gridSize[1])
# construct gm
numberOfLabels = numpy.ones(nrOfVariables, dtype=opengm.label_type) * 2
gm = opengm.graphicalModel(numberOfLabels)

# 4th closedness-function
fClosedness = numpy.zeros(pow(2, 4), dtype=numpy.float32).reshape(2, 2, 2, 2)
for x1 in range(2):
    for x2 in range(2):
        for x3 in range(2):
            for x4 in range(2):
                labelsum = x1 + x2 + x3 + x4
                if labelsum is not 2 and labelsum is not 0:
                    fClosedness[x1, x2, x3, x4] = high
fidClosedness = gm.addFunction(fClosedness)
# for each boundary in the grid, i.e. for each variable
# of the model, add one 1st order functions
# and one 1st order factor
# and for each junction of four inter-pixel edges on the grid,
   sys.stdout.write("\n")   
                 
# model parameter
gridSize=[10,10] # size of grid
beta=0.7     # bias to choose between under- and over-segmentation   
high=100       # closedness-enforcing soft-constraint value for forbidden configurations

# size of the topological grid
tGridSize=[2*gridSize[0] -1,2*gridSize[1] -1]
nrOfVariables=gridSize[1]*(gridSize[0]-1)+gridSize[0]*(gridSize[1]-1)
cToVi=TopologicalCoordinateToIndex(gridSize)
# some random data on a grid
data=numpy.random.random(gridSize[0]*gridSize[1]).astype(numpy.float32).reshape(gridSize[0],gridSize[1])
# construct gm
numberOfLabels=numpy.ones(nrOfVariables,dtype=numpy.uint64)*2
gm=opengm.graphicalModel(numberOfLabels)

# 4th closedness-function
fClosedness=numpy.zeros( pow(2,4),dtype=numpy.float32).reshape(2,2,2,2)
for x1 in range(2):
   for x2 in range(2):
      for x3 in range(2):
         for x4 in range(2):
            labelsum=x1+x2+x3+x4
            if labelsum is not 2 and labelsum is not 0 :
               fClosedness[x1,x2,x3,x4]=high          
fidClosedness=gm.addFunction(fClosedness)
# for each boundary in the grid, i.e. for each variable 
# of the model, add one 1st order functions 
# and one 1st order factor
# and for each junction of four inter-pixel edges on the grid, 
Example #23
0
    def _update_state_opengm(model,
                             weight_key='cut_prob',
                             name_label_key='name_label'):
        import opengm
        import scipy.special
        graph = model.graph
        n_annots = len(model.graph)
        n_names = n_annots

        nodes = sorted(graph.nodes())
        edges = [tuple(sorted(e)) for e in graph.edges()]
        edges = ut.sortedby2(edges, edges)

        index_type = opengm.index_type
        node_state_card = np.ones(n_annots, dtype=index_type) * n_names
        numberOfStates = node_state_card
        annot_idxs = list(range(n_annots))
        lookup_annot_idx = ut.dzip(nodes, annot_idxs)

        gm = opengm.graphicalModel(numberOfStates, operator='adder')

        # annot_idxs = list(range(n_annots))
        # edge_idxs = list(range(n_annots, n_annots + n_edges))
        # if use_unaries:
        #     unaries = np.ones((n_annots, n_names)) / n_names
        #     # unaries[0][0] = 1
        #     # unaries[0][1:] = 0
        #     for annot_idx in annot_idxs:
        #         fid = gm.addFunction(unaries[annot_idx])
        #         gm.addFactor(fid, annot_idx)

        # Add Potts function for each edge
        pairwise_factor_idxs = []
        for count, (aid1, aid2) in enumerate(edges,
                                             start=len(list(gm.factors()))):
            varx1, varx2 = ut.take(lookup_annot_idx, [aid1, aid2])
            var_indicies = np.array([varx1, varx2])

            p_same = graph.get_edge_data(aid1, aid2)['cut_prob']
            # p_diff = 1 - p_same

            eps = 1E-9
            p_same = np.clip(p_same, eps, 1.0 - eps)
            same_weight = scipy.special.logit(p_same)
            # valueEqual = -same_weight
            valueEqual = 0
            valueNotEqual = same_weight
            if not np.isfinite(valueNotEqual):
                """
                python -m plottool.draw_func2 --exec-plot_func --show --range=-1,1 --func=scipy.special.logit
                """
                print('valueNotEqual = %r' % (valueNotEqual, ))
                print('p_same = %r' % (p_same, ))
                raise ValueError('valueNotEqual')

            pairwise_factor_idxs.append(count)

            potts_func = opengm.PottsFunction((n_names, n_names),
                                              valueEqual=valueEqual,
                                              valueNotEqual=valueNotEqual)
            potts_func_id = gm.addFunction(potts_func)
            gm.addFactor(potts_func_id, var_indicies)

        model.gm = gm
Example #24
0
    matplot.subplot(2, 2, 3)
    matplot.imshow(N_spec2)
    matplot.title('speuclar theta 2')
    matplot.show()

    N_solutions = np.dstack((N_diff_solutions, N_spec_solutions))
    Diff_flag = np.hstack((Diff_flag1, Diff_flag2))
    rows, cols = mask1.shape
    # matplot.imshow(N)
    # matplot.show()

    ##=================> Optimised based on opengm

    noofNodes = np.sum(mask1)
    nodeStates = np.ones(noofNodes, dtype=opengm.index_type) * 4  # Possible answer are N or T*N
    gm = opengm.graphicalModel(nodeStates)
    # gm = opengm.adder.GraphicalModel(np.ones(noofNodes, dtype=opengm.index_type), reserveNumFactorsPerVariable=3)
    spec_threshold = 0.99
    specmask_valid = specmask[mask1 == 1]

    flip_factor = 7
    w_u = 1
    # 1. add node factor
    for i in range(noofNodes):
        nState = np.int32(nodeStates[i])
        f = np.zeros(nState, dtype=np.float32)

        Ng_i = N_guide_valid[i, :]

        if np.any(np.isnan(Ng_i)):
            for k in range(nState):
Example #25
0
numVar = dimx * dimy
numLabels = 2


numberOfStates = numpy.ones(numVar, dtype=opengm.index_type) * numLabels
vis2Order = opengm.secondOrderGridVis(dimx, dimy)
numFac = len(vis2Order)
randf = numpy.random.rand(numFac, numLabels, numLabels).astype(numpy.float64)

print randf.shape
print "numVar", numVar, "numFac", numFac


print "# METHOD A"
with opengm.Timer():
    gm = opengm.graphicalModel(numberOfStates, operator="adder", reserveNumFactorsPerVariable=4)
    gm.reserveFunctions(numFac, "explicit")
    fids = gm.addFunctions(randf)
    gm.addFactors(fids, vis2Order)


print "# METHOD B"
with opengm.Timer():
    # (reserve reserveNumFactorsPerVariable does not make sense if we not "finalize" factors directely)
    gm = opengm.graphicalModel(numberOfStates, operator="adder")
    gm.reserveFactors(numFac)
    gm.reserveFunctions(numFac, "explicit")
    fids = gm.addFunctions(randf)
    gm.addFactors(fids, vis2Order, finalize=False)
    gm.finalize()
Example #26
0
    print 'num_weights =', num_weights
    print 'num_instances =', len(X)
    ogm_ds = learning.createDataset(num_weights,
                                    numInstances=len(X),
                                    loss="generalized-hamming")
    weights = ogm_ds.getWeights()

    for idx, (x, y) in enumerate(zip(X, Y)):
        y[y ==
          -1] = 0  # FIXME: introduce a void label, so long: make the void label background
        unary_feats, edges, edge_feats = x
        num_vars = unary_feats.shape[0]

        states = np.ones(num_vars, dtype=opengm.index_type) * num_labels

        gm = opengm.graphicalModel(states, operator='adder')

        lossParam = learning.GeneralizedHammingLossParameter()
        lossParam.setLabelLossMultiplier(np.array(label_weights))

        # add unary factors
        weight_ids = np.arange(0, num_labels * unary_feats.shape[1]).reshape(
            (num_labels, -1))
        for feat_idx, unary_feat in enumerate(unary_feats):
            # make that each label sees all features, but use their own weights
            unary_feat_array = np.repeat(unary_feat.reshape((-1, 1)),
                                         num_labels,
                                         axis=1)
            f = learning.lUnaryFunction(weights, num_labels, unary_feat_array,
                                        weight_ids)
            var_idxs = np.array([feat_idx], dtype=np.uint64)