def main(argv, current_directory):
options = parse_command_line(argv)
size = options['size']
createModel(options)
coef = getCoef(size)
g = createGraph(size)
#mu is the thresold
mu = options['value_max']
regret_min = mu
(borne_sup, borne_inf) = (mu, 0)
count = 0
iteration_number = 2 * log2(size * size) + 1
while count < iteration_number:
regret_min = mu
#print("regret_min :", mu)
caps = getCapacity(size, coef, mu)
(flow, cut) = maximum_flow(g, "s", "t", caps)
if isValid(size, flow):
borne_sup = mu
mu = (borne_sup + borne_inf) / 2.
else:
borne_inf = mu
mu = (borne_sup + borne_inf) / 2.
count += 1
print(regret_min)
def main(argv, current_directory):
options=parse_command_line(argv)
size=options['size']
createModel(options)
coef=getCoef(size)
g=createGraph(size)
#mu is the thresold
mu=0
sat_max=0
(borne_inf,borne_sup)=(0,options['value_max'])
count=0
iteration_number=2*log2(size*size)+1
while count<iteration_number:
sat_max=mu
#print("satisfaction_max", mu)
caps=getCapacity(size,coef,mu)
(flow,cut)=maximum_flow(g,"s","t",caps)
if isValid(size,flow):
borne_inf=mu
mu=(borne_sup+borne_inf)/2.
else:
borne_sup=mu
mu=(borne_sup+borne_inf)/2.
count+=1
print(sat_max)
def strength_of_vote_management(self, voter_profile):
# Initialize the graph weights
for pattern in self.pattern_nodes:
self.vote_management_graph.set_edge_weight(("source", pattern),
voter_profile[pattern])
for i in range(self.required_winners):
if pattern[i] == 1:
self.vote_management_graph.set_edge_weight(
(pattern, i), voter_profile[pattern])
# Iterate towards the limit
r = [(float(sum(voter_profile.values())) -
voter_profile[tuple([PREFERRED_MORE] * self.required_winners)]) /
self.required_winners]
while len(r) < 2 or r[-2] - r[-1] > STRENGTH_TOLERANCE:
for i in range(self.required_winners):
self.vote_management_graph.set_edge_weight((i, "sink"), r[-1])
max_flow = maximum_flow(self.vote_management_graph, "source",
"sink")
sink_sum = sum(v for k, v in max_flow[0].iteritems()
if k[1] == "sink")
r.append(sink_sum / self.required_winners)
# We expect strengths to be above a specified threshold
if sink_sum < STRENGTH_THRESHOLD:
return 0
# Return the final max flow
return round(r[-1], 9)
def perform_min_cut(self):
''' Remove the source and sink from their current location
in the graph.
'''
self.add_source_and_sink(((0,0),(0,100)), Compass.EAST)
o = minmax.maximum_flow(self.graph, self.source, self.sink)
self.remove_source_and_sink()
return o;
def test_trivial_maxflow(self):
gr = digraph()
gr.add_nodes([0, 1, 2, 3])
gr.add_edge((0, 1), wt=5)
gr.add_edge((1, 2), wt=3)
gr.add_edge((2, 3), wt=7)
flows, cuts = maximum_flow(gr, 0, 3)
assert flows[(0, 1)] == 3
assert flows[(1, 2)] == 3
assert flows[(2, 3)] == 3
def test_trivial_maxflow(self):
gr = digraph()
gr.add_nodes([0,1,2,3])
gr.add_edge((0,1), wt=5)
gr.add_edge((1,2), wt=3)
gr.add_edge((2,3), wt=7)
flows, cuts = maximum_flow(gr, 0, 3)
assert flows[(0,1)] == 3
assert flows[(1,2)] == 3
assert flows[(2,3)] == 3
def cut_graph(gr,imsize):
""" Solve max flow of graph gr and return binary
labels of the resulting segmentation."""
m,n = imsize
source = m*n # second to last is source
sink = m*n+1 # last is sink
# cut the graph
flows,cuts = maximum_flow(gr,source,sink)
# convert graph to image with labels
res = zeros(m*n)
for pos,label in cuts.items()[:-2]: #don"t add source/sink
print label
res[pos] = label
return res.reshape((m,n))
def cut_graph(gr, imsize):
###""" 用最大流对图 gr 进行分割，并返回分割结果的二值标记 """
m, n = imsize
source = m * n # 倒数第二个节点是源点
sink = m * n + 1 # 倒数第一个是汇点
# 对图进行分割
flows, cuts = maximum_flow(gr, source, sink)
# 将图转为带有标记的图像
res = zeros(m * n)
for pos, label in list(cuts.items())[:-2]: # 不要添加源点 / 汇点
res[pos] = label
return res.reshape((m, n))
def const_graph(text):
nVertices = 1
#print text
for sent in splitSentences(text):
#print sent
score = class_1(sent)
alltext[nVertices] = (score, sent)
allscores[nVertices] = score
nVertices = nVertices + 1
src = 0
dst = nVertices
gr.add_nodes(xrange(0, nVertices + 1))
for i in xrange(1, nVertices):
#print i
w = alltext[i][0]
gr.add_edge((0, i), wt=w)
gr.add_edge((i, nVertices), wt=1 - w)
for i in xrange(1, nVertices):
for j in xrange(i, nVertices):
if (i == j):
continue
s = 1.0 / abs(j - i)
s = s * s
gr.add_edge((i, j), wt=s)
#print gr
#print alltext
flows, cuts = maximum_flow(gr, 0, nVertices)
# print flows
#print cuts
subjsents = [x for x in xrange(1, nVertices) if cuts[x] is 0]
subjsents.sort(key=allscores.get, reverse=True)
budget = 200
avail = 200
summary = ''
for x in subjsents:
sent = alltext[x][1]
wc = len(sent.split())
wc = len(nltk.word_tokenize(sent.strip()))
if (wc <= avail):
summary = summary + sent + '.'
avail = avail - wc
#print subjsents
return summary
def const_graph(text):
nVertices=1;
#print text
for sent in splitSentences(text):
#print sent
score=class_1(sent)
alltext[nVertices]=(score, sent)
allscores[nVertices]=score
nVertices=nVertices+1;
src=0;
dst=nVertices;
gr.add_nodes(xrange(0,nVertices+1))
for i in xrange(1,nVertices):
#print i
w=alltext[i][0]
gr.add_edge((0, i), wt=w )
gr.add_edge((i, nVertices), wt=1-w)
for i in xrange(1,nVertices):
for j in xrange(i,nVertices):
if(i==j):
continue;
s = 1.0/abs(j-i)
s = s*s
gr.add_edge((i, j), wt=s)
#print gr
#print alltext
flows, cuts = maximum_flow(gr, 0, nVertices)
# print flows
#print cuts
subjsents=[x for x in xrange(1,nVertices) if cuts[x] is 0 ]
subjsents.sort(key=allscores.get, reverse=True)
budget=200;
avail= 200;
summary='';
for x in subjsents:
sent=alltext[x][1]
wc=len(sent.split());
wc=len(nltk.word_tokenize(sent.strip()))
if(wc <= avail):
summary = summary + sent + '.'
avail = avail - wc;
#print subjsents
return summary
def cut_graph(gr, imsize):
"""Solve for max flow of graph gr and return binary
labels of resulting segmentation.
"""
m, n = imsize
source = m * n
sink = m * n + 1
# cut graph
flows, cuts = maximum_flow(gr, source, sink)
# convert graph to image with labels
res = np.zeros(m * n)
for pos, labels in np.cuts.items()[:-2]:
res[pos] = label
return res.reshape((m, n))
def cut_graph(gr,imsize):
""" グラフgrの最大フローを求め、領域分割結果の２値ラベルを返す """
m,n = imsize
source = m*n # 最後から2つ目がソース
sink = m*n+1 # 最後がシンク
# グラフをカットする
flows,cuts = maximum_flow(gr,source,sink)
# グラフをラベル画像に変換する
res = np.zeros(m*n)
for pos,label in cuts.items()[:-2]: # ソースとシンクを除く
res[pos] = label
return res.reshape((m,n))
def cut_graph(gr,imsize):
""" Solve max flow of graph gr and return binary
labels of the resulting segmentation."""
m,n = imsize
source = m*n # second to last is source
sink = m*n+1 # last is sink
# cut the graph
flows,cuts = maximum_flow(gr,source,sink)
# convert graph to image with labels
res = zeros(m*n)
for pos,label in cuts.items()[:-2]: #don't add source/sink
res[pos] = label
return res.reshape((m,n))
def cut_graph(gr, imsize):
""" グラフgrの最大フローを求め、
領域分割結果の2値ラベルを返す """
m, n = imsize
source = m * n # 最後から2つ目がソース
sink = m * n + 1 # 最後がシンク
# グラフをカットする
flows, cuts = maximum_flow(gr, source, sink)
# グラフをラベル画像に変換する
res = zeros(m * n)
for pos, label in cuts.items()[:-2]: # ソースとシンクを除く
res[pos] = label
return res.reshape((m, n))
def classify(gr,numSource,numSink):
"""Classify using the built graph by the max_flow algorithm
Parameters
----------
gr:
The graph model
numSource: integer
The number of positive data points
numSink: integer
The number of negative data points
"""
flows, cuts = maximum_flow(gr, 0, numSource)
return cuts
def cuts(adj, source, sink, k, prettyprint=False):
"""
cuts returns an oracle that terminates at all cuts between source and sink
with capacity less than or equal to k.
"""
# Convert adj to a cut-able pygraph.
graph = digraph()
for nid in adj:
graph.add_node(nid)
for cid in adj:
for pid in adj[cid]:
graph.add_edge((cid, pid))
ret = set()
while True:
(flow, asgn) = maximum_flow(graph, source, sink)
# Find the minimum cut.
mincut = set()
for (u, v) in flow:
if flow[(u, v)] > 0 and asgn[u] != asgn[v]:
mincut.add((u, v))
# If it's too large, we're done; break.
maxflow = 0
for edge in mincut:
maxflow += flow[edge]
if 0 < maxflow and maxflow <= k:
ret.update(mincut)
else:
break
# Reweight one edge in the cut so that it will no longer be min.
edge = max([(int(u), int(v)) for (u, v) in mincut])
edge = (str(edge[0]), str(edge[1]))
graph.del_edge(edge)
graph.add_edge(edge, wt=len(adj))
if not prettyprint:
return lambda query, cid, nid: (cid, nid) in ret
else:
return set([nid for (cid, nid) in ret])
def cuts(adj, source, sink, k, prettyprint=False):
"""
cuts returns an oracle that terminates at all cuts between source and sink
with capacity less than or equal to k.
"""
# Convert adj to a cut-able pygraph.
graph = digraph()
for nid in adj:
graph.add_node(nid)
for cid in adj:
for pid in adj[cid]:
graph.add_edge((cid, pid))
ret = set()
while True:
(flow, asgn) = maximum_flow(graph, source, sink)
# Find the minimum cut.
mincut = set()
for (u, v) in flow:
if flow[(u, v)] > 0 and asgn[u] != asgn[v]:
mincut.add((u, v))
# If it's too large, we're done; break.
maxflow = 0
for edge in mincut:
maxflow += flow[edge]
if 0 < maxflow and maxflow <= k:
ret.update(mincut)
else:
break
# Reweight one edge in the cut so that it will no longer be min.
edge = max([(int(u), int(v)) for (u,v) in mincut])
edge = (str(edge[0]), str(edge[1]))
graph.del_edge(edge)
graph.add_edge(edge, wt=len(adj))
if not prettyprint:
return lambda query, cid, nid: (cid, nid) in ret
else:
return set([nid for (cid, nid) in ret])
def strength_of_vote_management(self, voter_profile):
"""
This method converts the voter profile into a capacity graph and
iterates on the maximum flow using the Edmonds Karp algorithm. The end
result is the limit of the strength of the voter management as per
Markus Schulze's Calcul02.pdf (draft, 28 March 2008, abstract: "In this
paper we illustrate the calculation of the strengths of the vote
managements.").
"""
# Initialize the graph weights
for pattern in self.pattern_nodes:
self.vote_management_graph.set_edge_weight(("source", pattern),
voter_profile[pattern])
for i in range(self.required_winners):
if pattern[i] == 1:
self.vote_management_graph.set_edge_weight(
(pattern, i), voter_profile[pattern]
)
# Iterate towards the limit
r = [(
float(sum(voter_profile.values())) -
voter_profile[tuple([PREFERRED_MORE] * self.required_winners)]
) / self.required_winners]
while len(r) < 2 or r[-2] - r[-1] > STRENGTH_TOLERANCE:
for i in range(self.required_winners):
self.vote_management_graph.set_edge_weight((i, "sink"), r[-1])
max_flow = maximum_flow(self.vote_management_graph, "source",
"sink")
sink_sum = sum(v for k, v in six.iteritems(max_flow[0])
if k[1] == "sink")
r.append(sink_sum / self.required_winners)
# We expect strengths to be above a specified threshold
if sink_sum < STRENGTH_THRESHOLD:
return 0
# Return the final max flow
return round(r[-1], 9)
def solveMaxFlow(self):
instance = self.instance
flow, _ = maximum_flow(self.graph, sourceID, sinkID, self.capacities)
# form the reduced network in which only arcs with flow are present
reducedNetwork = digraph()
reducedNetwork.add_graph(self.graph) # does not add node attributes
for arc in self.graph.edges():
if flow[arc] == 0:
reducedNetwork.del_edge(arc)
for node in self.graph.nodes():
if reducedNetwork.neighbors(node) == []:
reducedNetwork.del_node(node)
# form paths for agents
solution = []
for i in range(instance.nAgents):
nodeID = self._getNetworkID(instance.agents[i], time = 0, stage = 1)
layoutNode = self.nodeToLayout[nodeID]
stage = 1
solution.append([])
while (True):
if (stage == 1):
solution[i].append(layoutNode)
if layoutNode in instance.exits:
break
try:
neighbors = reducedNetwork.neighbors(nodeID)
except:
break # nodeID is not in the network: the agent is too far from exit
if (neighbors == []):
break
if (len(neighbors) > 1):
print("More than one possibility in the solution!")
exit()
nodeID = neighbors[0]
layoutNode = self.nodeToLayout[nodeID]
stage = self.nodeToStage[nodeID]
return solution
def strength_of_vote_management(self, voter_profile):
# Initialize the graph weights
for pattern in self.pattern_nodes:
self.vote_management_graph.set_edge_weight(("source", pattern), voter_profile[pattern])
for i in range(self.required_winners):
if pattern[i] == 1:
self.vote_management_graph.set_edge_weight((pattern, i), voter_profile[pattern])
# Iterate towards the limit
r = [(float(sum(voter_profile.values())) - voter_profile[tuple([PREFERRED_MORE] * self.required_winners)]) / self.required_winners]
while len(r) < 2 or r[-2] - r[-1] > STRENGTH_TOLERANCE:
for i in range(self.required_winners):
self.vote_management_graph.set_edge_weight((i, "sink"), r[-1])
max_flow = maximum_flow(self.vote_management_graph, "source", "sink")
sink_sum = sum(v for k, v in max_flow[0].iteritems() if k[1] == "sink")
r.append(sink_sum / self.required_winners)
# We expect strengths to be above a specified threshold
if sink_sum < STRENGTH_THRESHOLD:
return 0
# Return the final max flow
return round(r[-1], 9)
Created on Fri May 16 09:22:20 2014
@author: admin
"""
from pygraph.classes.digraph import digraph
from pygraph.algorithms.minmax import maximum_flow
gr=digraph()
gr.add_nodes([0,1,2,3])
gr.add_edge((0,1), wt=4)
gr.add_edge((1,2), wt=3)
gr.add_edge((2,3), wt=5)
gr.add_edge((0,2), wt=3)
gr.add_edge((1,3), wt=4)
flows,cuts=maximum_flow(gr,0,3)
print 'flowis:',flows
print 'cutis:',cuts
print
from scipy.misc import imresize
import graphcut
from pylab import *
from PIL import Image
im=array(Image.open('empire.jpg'))
im=imresize(im,0.07,interp='bilinear')
size=im.shape[:2]
#addtworectangulartrainingregions
labels=zeros(size)
labels[3:18,3:18]=-1
def test_random_maxflow(self):
gr = testlib.new_digraph(wt_range=(1,20))
flows, cuts = maximum_flow(gr, 0, 1)
# Sanity test
for each in flows:
assert gr.edge_weight(each) >= flows[each]
def test_random_maxflow(self):
gr = testlib.new_digraph(wt_range=(1, 20))
flows, cuts = maximum_flow(gr, 0, 1)
# Sanity test
for each in flows:
assert gr.edge_weight(each) >= flows[each]
from pygraph.classes.digraph import digraph
from pygraph.algorithms.minmax import maximum_flow
gr = digraph()
gr.add_nodes([0, 1, 2, 3])
gr.add_edge((0, 1), wt=4)
gr.add_edge((1, 2), wt=3)
gr.add_edge((2, 3), wt=5)
gr.add_edge((0, 2), wt=3)
gr.add_edge((1, 3), wt=4)
flows, cuts = maximum_flow(gr, 0, 3) # 0为源点，3为汇点
print("flow is:", flows)
print("cuts is:", cuts)
# -*- coding: utf-8 -*- """ Created on Sun Sep 18 20:52:07 2016 @author: user """ from pygraph.classes.digraph import digraph from pygraph.algorithms.minmax import maximum_flow gr = digraph() gr.add_nodes([0,1,2,3]) gr.add_edge((0,1), wt=4) gr.add_edge((1,2), wt=3) gr.add_edge((2,3), wt=5) gr.add_edge((0,2), wt=3) gr.add_edge((1,3), wt=4) flows,cuts = maximum_flow(gr,0,3) print 'flow is:', flows print 'cut is:', cuts
for i in range(N):
gr.add_nodes([i+1])
gr.add_edge((0,i+1), wt=1)
for i in range(M):
gr.add_nodes([N+i+1])
gr.add_edge((N+i+1,N+M+1), wt=1)
for i in range(N):
for j in range(M):
if(u[i][j]>=lmb):
gr.add_edge((i+1,N+j+1), wt=1)
else:
gr.add_edge((i+1,N+j+1), wt=0)
flows, cuts = maximum_flow(gr, 0, N+M+1)
for i in range(N):
k=0
for j in range(M):
if(flows[(i+1,N+j+1)]==0):
k+=1
if(k==N):
sortie = 0
if(sortie == 1):
oldflow = flows
lmb += 1
