def segment(self,weights,warmStart=None,verbose=False): #try : # self.cgc.changeWeights(weights) #except : nVar = self.cgp.numCells(2) nFac = self.cgp.numCells(1) cell1Bounds = self.cgp.cell1BoundsArray()-1 self.gm2 = opengm.gm(numpy.ones(nVar,dtype=opengm.label_type)*nVar) assert self.gm2.numberOfVariables == nVar # init with zero potts functions #print weights pf = opengm.pottsFunctions([nVar,nVar],numpy.zeros(nFac),weights ) fids = self.gm2.addFunctions(pf) # add factors self.gm2.addFactors(fids,cell1Bounds) self.cgc2 = opengm.inference.Cgc(gm=self.gm2,parameter=opengm.InfParam(planar=True)) if verbose : self.cgc2.infer(self.cgc.verboseVisitor()) else : self.cgc2.infer() self.labels[:]=self.cgc2.arg()
def __init__(self,cgp,beta=0.5): self.cgp=cgp self.probability = numpy.ones(cgp.numCells(1),dtype=numpy.float64) self.weights = numpy.ones(cgp.numCells(1),dtype=numpy.float64) self.mean = numpy.ones(cgp.numCells(1),dtype=numpy.float64) self.std = numpy.ones(cgp.numCells(1),dtype=numpy.float64) # generate graphical model self.cgc = None self.beta=beta boundArray = self.cgp.cell1BoundsArray()-1 nVar = cgp.numCells(2) nFac = cgp.numCells(1) space = numpy.ones(nVar,dtype=opengm.label_type)*nVar self.gm = opengm.gm(space) wZero = numpy.zeros(nFac,dtype=opengm.value_type) pf=opengm.pottsFunctions([nVar,nVar],wZero,wZero) fids = self.gm.addFunctions(pf) self.gm.addFactors(fids,boundArray) self.cgc = opengm.inference.Cgc(gm=self.gm,parameter=opengm.InfParam(planar=True))
def onClickedMulticut(self): p1 = self.probs.copy() p1 = numpy.clip(p1, 0.005, 1.0-0.005) p0 = 1.0 - p1 weights = numpy.log(p0/p1) nVar = self.rag.maxNodeId + 1 nos = numpy.ones(nVar)*nVar gm = opengm.gm(nos) uv = self.rag.uvIds() uv = numpy.sort(uv,axis=1) pf = opengm.pottsFunctions([nVar,nVar], numpy.array([0]),weights) fid = gm.addFunctions(pf) gm.addFactors(fid,uv) pparam = opengm.InfParam(seedFraction=0.05) parameter = opengm.InfParam(generator='randomizedWatershed',proposalParam=pparam,numStopIt=10,numIt=3000) inf = opengm.inference.IntersectionBased(gm, parameter=parameter) inf = opengm.inference.Multicut(gm) inf.infer(inf.verboseVisitor()) arg = inf.arg() self.eArg = arg[uv[:,0]]!=arg[uv[:,1]] self.ctrlWidget.modeSelectorComboBox.setCurrentIndex(6)
def multicutFromCgp(cgp,weights=None,parameter=None): boundArray = cgp.cell1BoundsArray()-1 nVar = cgp.numCells(2) nFac = cgp.numCells(1) space = numpy.ones(nVar,dtype=opengm.label_type)*nVar gm = opengm.gm(space) wZero = numpy.zeros(nFac,dtype=opengm.value_type) if weights is None: pf=opengm.pottsFunctions([nVar,nVar],wZero,wZero) else : w = numpy.require(weights,dtype=opengm.value_type) pf=opengm.pottsFunctions([nVar,nVar],wZero,w) fids = gm.addFunctions(pf) gm.addFactors(fids,boundArray) cgc = opengm.inference.Cgc(gm=gm,parameter=parameter) return cgc,gm
def predict(): global features,rag, sp,arg trainingInstances = numpy.array(userLabels.keys(),dtype='uint64') labels = numpy.array([userLabels[k] for k in trainingInstances],dtype='uint32')[:,None] trainingInstances = numpy.clip(trainingInstances, 0, rag.maxEdgeId-2) assert trainingInstances.max() <= rag.maxEdgeId if len(labels)>10 and labels.min()==0 and labels.max()==1: feat = features[trainingInstances,:] rf = vigra.learning.RandomForest(treeCount=255) oob = rf.learnRF(feat, labels) print "oob", oob probs = rf.predictProbabilities(features)[:,1] p1 = probs.copy() p1 = numpy.clip(p1, 0.005, 1.0-0.005) p0 = 1.0 - p1 weights = numpy.log(p0/p1) nVar = rag.maxNodeId + 1 nos = numpy.ones(nVar)*nVar gm = opengm.gm(nos) uv = rag.uvIds() if weights.shape[0] < uv.shape[1]: diff = uv.shape[1] - weights.shape[0] val = numpy.zeros(diff) weights = numpy.concatenate([weights,val]) uv = numpy.sort(uv,axis=1) pf = opengm.pottsFunctions([nVar,nVar], numpy.array([0]),weights) fid = gm.addFunctions(pf) gm.addFactors(fid,uv) param = opengm.InfParam(planar=False) inf = opengm.inference.Cgc(gm,parameter=param) if arg is not None: inf.setStartingPoint(arg) visitor = inf.timingVisitor(timeLimit=60.0) inf.infer(visitor) arg = inf.arg() eArg = arg[uv[:,0]]!=arg[uv[:,1]] return arg else: return None
def __init__(self,cgp): super(MulticutClustering, self).__init__(cgp) # build a graphical model nVar = cgp.numCells(2) nFac = cgp.numCells(1) cell1Bounds = cgp.cell1BoundsArray()-1 self.gm = opengm.gm(numpy.ones(nVar,dtype=opengm.label_type)*nVar) # init with zero potts functions fids = self.gm.addFunctions(opengm.pottsFunctions([nVar,nVar],numpy.zeros(nFac),numpy.zeros(nFac) )) # add factors self.gm.addFactors(fids,cell1Bounds) self.cgc = opengm.inference.Cgc(gm=self.gm,parameter=opengm.InfParam(planar=True))
def run_mc_opengm(segmentation, edges, energies): n_seg = np.max(segmentation) states = np.ones(n_seg) gm = opengm.gm(states) print "AAA" "pairwise" potts_shape = [ 2, 2] potts = opengm.pottsFunctions(potts_shape, np.array([0.0]), np.array(energies) ) print "AAA" fids_p = gm.addFunctions(potts) gm.addFactors(fids_p, edges) gm_path = "/tmp/gm.h5" opengm.saveGm(gm, gm_path) print "AAA" "parameters" # wf = "(TTC)(MTC)(IC)(CC-IFD,TTC-I)" # default workflow #wf = "(IC)(TTC-I,CC-I)" # propper workflow # wf = "(TTC)(TTC,CC)" # lp relaxation param = opengm.InfParam()#workflow=wf) print "---inference---" print " starting time:", time.strftime("%H:%M:%S"), ";", time.strftime("%d/%m/%Y") print "..." inf = opengm.inference.Multicut(gm, parameter=param) inf.infer() print " end time:", time.strftime("%H:%M:%S"), ";", time.strftime("%d/%m/%Y") res_node = inf.arg() res_edge = inf.getEdgeLabeling() res_seg = inf.getSegmentation() print res_node.shape, np.unique(res_node) print res_edge.shape, np.unique(res_edge) print res_seg.shape, np.unique(res_seg) quit()
def onClickedMulticut(self): p1 = self.probs.copy() p1 = numpy.clip(p1, 0.005, 1.0-0.005) p0 = 1.0 - p1 weights = numpy.log(p0/p1) nVar = self.rag.maxNodeId + 1 nos = numpy.ones(nVar)*nVar gm = opengm.gm(nos) uv = self.rag.uvIds() uv = numpy.sort(uv,axis=1) pf = opengm.pottsFunctions([nVar,nVar], numpy.array([0]),weights) fid = gm.addFunctions(pf) gm.addFactors(fid,uv) inf = opengm.inference.Multicut(gm) inf.infer(inf.verboseVisitor()) arg = inf.arg() self.eArg = arg[uv[:,0]]!=arg[uv[:,1]] self.ctrlWidget.modeSelectorComboBox.setCurrentIndex(6)
def onClickedMulticut(self): p1 = self.probs.copy() p1 = numpy.clip(p1, 0.005, 1.0 - 0.005) p0 = 1.0 - p1 weights = numpy.log(p0 / p1) nVar = self.rag.maxNodeId + 1 nos = numpy.ones(nVar) * nVar gm = opengm.gm(nos) uv = self.rag.uvIds() uv = numpy.sort(uv, axis=1) pf = opengm.pottsFunctions([nVar, nVar], numpy.array([0]), weights) fid = gm.addFunctions(pf) gm.addFactors(fid, uv) inf = opengm.inference.Multicut(gm) inf.infer(inf.verboseVisitor()) arg = inf.arg() self.eArg = arg[uv[:, 0]] != arg[uv[:, 1]] self.ctrlWidget.modeSelectorComboBox.setCurrentIndex(6)
cgp = cgp2d.Cgp(tgrid) imgTopo = vigra.sampling.resize(imgLab,cgp.shape) imgRGBTopo = vigra.colors.transform_Lab2RGB(imgTopo) gradTopo = vigra.filters.gaussianGradientMagnitude(imgTopo,1.0) labelsTopo = vigra.sampling.resize(seg.astype(numpy.float32),cgp.shape,0) nVar = cgp.numCells(2) nFac = cgp.numCells(1) space = numpy.ones(nVar,dtype=opengm.label_type)*nVar gm = opengm.gm(space) wZero = numpy.zeros(nFac,dtype=opengm.value_type) pf = opengm.pottsFunctions([nVar,nVar],wZero,wZero) fids = gm.addFunctions(pf) gm.addFactors(fids,cgp.cell1BoundsArray()-1) cgc = opengm.inference.Cgc(gm=gm,parameter=opengm.InfParam(planar=True)) # visualize segmetation #cgp2d.visualize(img_rgb=imgRGBTopo,cgp=cgp)#,edge_data_in=bestState.astype(numpy.float32)) argDual = numpy.zeros(cgp.numCells(1),dtype=numpy.uint64) sigmas = [1.0 , 2.0, 4.0 ,6.0] features = numpy.zeros([len(sigmas),cgp.numCells(1)],dtype=numpy.float32)
g.insertEdge(u, v) uvs.append((u,v)) if y + 1 < shape[1]: v = f(x, y + 1) g.insertEdge(u, v) uvs.append((u,v)) weights = numpy.random.rand(g.numberOfEdges)-0.5 weights[numpy.abs(weights)<0.00001] = 0.0001 uvs = numpy.array(uvs) nFac = weights.shape[0] gm2 = opengm.gm(numpy.ones(nNodes)*nNodes) pf = opengm.pottsFunctions([nNodes,nNodes],numpy.zeros(nFac),weights) fid = gm2.addFunctions(pf) gm2.addFactors(fid,uvs) g = nifty.graph.UndirectedGraph(int(nNodes)) g.insertEdges(uvs) assert g.numberOfEdges == weights.shape[0] assert g.numberOfEdges == uvs.shape[0] obj = nifty.graph.multicut.multicutObjective(g, weights) with vigra.Timer("ilp-cplex"): solver = nifty.multicutIlpFactory(ilpSolver='cplex',verbose=1, addThreeCyclesConstraints=False ).create(obj)
def getGraphicalModel( nLabels, nVariables, nEdges, edgeVis, unaryValues, edgeValues, gmOperator='adder' ): """ get opengm graphical model !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!! USE OPENGM FORK https://github.com/DerThorsten/opengm !!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! kwargs : nLabels : number of labels / classes of the gm nVariables : number of variables / superpixels of the gm nEdges : number of edges / 2.-order factors edgeVis : a 2d numpy array of the variable indices of an edge / 2.-order factor with shape=[nEdges,2]. The variable indices must be sorted: Therefore edgeVis[:,0]<edgeVis[:,1] must be true unaryValues : unaries in a 2d numpy array with shape=[nVariables,nLabels] edgeValues : 2d numpy array for values edges / 2.-order factors. For each 2.-order factor one needs only 2 values. gmOperator : operator of the graphical model 'adder' or 'multiplier' (default: 'adder') """ ##################################################################################### # assertions to check that the input is valid ##################################################################################### def raiseIfNot(cond,msg): if(cond==False): raise RuntimeError(msg+" is NOT true") raiseIfNot(unaryValues.ndim==2,"unaryValues.ndim== 2") raiseIfNot(unaryValues.shape[0]==nVariables,"unaryValues.shape[0]== nVariables") raiseIfNot(unaryValues.shape[1]==nLabels,"unaryValues.shape[1]==nLabels") raiseIfNot(edgeVis.ndim==2,"edgeVis.ndim== 2") raiseIfNot(edgeVis.shape[0]==nEdges,"edgeVis.shape[0]==nEdges") raiseIfNot(edgeVis.shape[1]==2,"edgeVis.shape[1]==2") raiseIfNot ( len(numpy.where(edgeVis[:,0]>=edgeVis[:,1])[0] )==0 , "edgeVis[:,0]<edgeVis[:,1]" ) raiseIfNot(edgeValues.ndim==2,"edgeValues.ndim== 2") raiseIfNot(edgeValues.shape[0]==nEdges,"edgeValues.shape[1]==nEdges") raiseIfNot(edgeValues.shape[1]==2,"edgeValues.shape[1]==2") ##################################################################################### # set up space of graphical model and construct a opengm.gm ##################################################################################### numberOfLabels = numpy.ones(nVariables,dtype=opengm.label_type)*nLabels gm = opengm.gm(numberOfLabels,operator=gmOperator) ##################################################################################### # reserve space for factors and functions ##################################################################################### gm.reserveFactors(nVariables + nEdges) # reserve explicit functions for unaries gm.reserveFunctions(nVariables,'explicit') # reserve potts functions for 2-order factors gm.reserveFunctions(nEdges,'potts') ##################################################################################### # add unary functions and factors to graphical model ##################################################################################### # add unary functions (and check for consistency) fidUnaries = gm.addFunctions(unaryValues) raiseIfNot(len(fidUnaries)==nVariables,"internal error, blame thorsten") # add unary factors (and check for consistency) unaryVis = numpy.arange(nVariables,dtype=opengm.index_type) gm.addFactors(fidUnaries,unaryVis) raiseIfNot(gm.numberOfFactors==nVariables,"internal error, blame thorsten") ##################################################################################### # add 2-order functions and factors ##################################################################################### # create a vector of potts functions (and check for consistency) valueAA = edgeValues[:,0] # F(L_1 == L_2) valueAB = edgeValues[:,1] # F(L_1 != L_2) pottsFunctions = opengm.pottsFunctions( shape=[nLabels,nLabels], valueEqual=valueAA,valueNotEqual=valueAB) raiseIfNot(len(pottsFunctions)==nEdges,"internal error, blame thorsten") # add second order potts functions (and check for consistency) fid2Order = gm.addFunctions(pottsFunctions) raiseIfNot(len(fid2Order)==nEdges,"internal error, blame thorsten") # add second order factors (and check for consistency) gm.addFactors(fid2Order,edgeVis) raiseIfNot(gm.numberOfFactors==nVariables+nEdges,"internal error, blame thorsten") return gm