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
