def test_digraph2(self):
# Example from ticket #430 from mfrasca. Original source:
# http://www.cs.princeton.edu/courses/archive/spr03/cs226/lectures/mincost.4up.pdf, slide 11.
G = nx.DiGraph()
G.add_edge('s', 1, capacity=12)
G.add_edge('s', 2, capacity=6)
G.add_edge('s', 3, capacity=14)
G.add_edge(1, 2, capacity=11)
G.add_edge(2, 3, capacity=9)
G.add_edge(1, 4, capacity=5)
G.add_edge(1, 5, capacity=2)
G.add_edge(2, 5, capacity=4)
G.add_edge(2, 6, capacity=2)
G.add_edge(3, 6, capacity=31)
G.add_edge(4, 5, capacity=18)
G.add_edge(5, 5, capacity=9)
G.add_edge(4, 't', capacity=3)
G.add_edge(5, 't', capacity=7)
G.add_edge(6, 't', capacity=22)
flow = nx.max_flow_min_cost(G, 's', 't')
soln = {1: {2: 5, 4: 5, 5: 2},
2: {3: 6, 5: 3, 6: 2},
3: {6: 20},
4: {5: 2, 't': 3},
5: {5: 0, 't': 7},
6: {'t': 22},
's': {1: 12, 2: 6, 3: 14},
't': {}}
assert_equal(flow, soln)
def max_flow(bandwidth, src_dict, dst_dict):
""" 最小费用最大流：给定多源点和多汇点及其流量，返回最大流矩阵 """
# 转换为networkx格式的图，边权均为1
G = nx.DiGraph()
for i in range(len(bandwidth)):
for j in range(len(bandwidth)):
if bandwidth[i][j] > 0:
G.add_edge(i, j, capacity=bandwidth[i][j], weight=1)
# 添加虚拟源点-1和汇点-2
for (s, value) in src_dict.items():
G.add_edge(-1, s, capacity=value, weight=1)
for (d, value) in dst_dict.items():
G.add_edge(d, -2, capacity=value, weight=1)
# 最小费用最大流
flow = nx.max_flow_min_cost(G, -1, -2)
flow_matrix = [[0 for col in range(len(bandwidth))] for row in range(len(bandwidth))]
for i in range(len(bandwidth)):
for (j, f) in flow[i].items():
if j >= 0:
flow_matrix[i][j] = f
# 返回流矩阵
return flow_matrix
def test_max_flow_min_cost(self):
G = nx.DiGraph()
G.add_edge('s', 'a', bandwidth=6)
G.add_edge('s', 'c', bandwidth=10, cost=10)
G.add_edge('a', 'b', cost=6)
G.add_edge('b', 'd', bandwidth=8, cost=7)
G.add_edge('c', 'd', cost=10)
G.add_edge('d', 't', bandwidth=5, cost=5)
soln = {'s': {'a': 5, 'c': 0},
'a': {'b': 5},
'b': {'d': 5},
'c': {'d': 0},
'd': {'t': 5},
't': {}}
flow = nx.max_flow_min_cost(G, 's', 't', capacity='bandwidth',
weight='cost')
assert_equal(flow, soln)
assert_equal(nx.cost_of_flow(G, flow, weight='cost'), 90)
G.add_edge('t', 's', cost=-100)
flowCost, flow = nx.capacity_scaling(G, capacity='bandwidth',
weight='cost')
G.remove_edge('t', 's')
assert_equal(flowCost, -410)
assert_equal(flow['t']['s'], 5)
del flow['t']['s']
assert_equal(flow, soln)
assert_equal(nx.cost_of_flow(G, flow, weight='cost'), 90)
def tst():
G = nx.DiGraph()
edges = [(0, 1, {
'capacity': 5,
'weight': 1
}), (0, 2, {
'capacity': 3,
'weight': 0.5
}), (0, 3, {
'capacity': 1,
'weight': 1
}), (4, 6, {
'capacity': 4,
'weight': 1
}), (5, 6, {
'capacity': 5,
'weight': 1
}), (1, 4, {
'capacity': np.inf,
'weight': 1
}), (2, 4, {
'capacity': np.inf,
'weight': 1
}), (3, 5, {
'capacity': np.inf,
'weight': 1
})]
G.add_edges_from(edges)
mincostflow = nx.max_flow_min_cost(G, 0, 6)
mincost = nx.cost_of_flow(G, mincostflow)
max_flow = nx.maximum_flow_value(G, 0, 6)
def solve():
n = int(sys.stdin.readline())
topics = []
for i in xrange(n):
topics.append(sys.stdin.readline().split())
left = set()
right = set()
for a, b in topics:
left.add(a)
right.add(b)
G = nx.DiGraph()
for a, b in topics:
G.add_edges_from([((a, 0), (b, 1), {'capacity': 1, 'weight': 1})])
for a in left:
G.add_edges_from([(0, (a, 0), {'capacity': 1, 'weight': 0})])
for b in right:
G.add_edges_from([((b, 1), 1, {'capacity': 1, 'weight': 0})])
mincostFlow = nx.max_flow_min_cost(G, 0, 1)
mincost = nx.cost_of_flow(G, mincostFlow)
# print mincost
needed_arcs = len(left) + len(right) - mincost
faked = len(topics) - needed_arcs
print faked
def test_max_flow_min_cost(self):
G = nx.DiGraph()
G.add_edge('s', 'a', bandwidth=6)
G.add_edge('s', 'c', bandwidth=10, cost=10)
G.add_edge('a', 'b', cost=6)
G.add_edge('b', 'd', bandwidth=8, cost=7)
G.add_edge('c', 'd', cost=10)
G.add_edge('d', 't', bandwidth=5, cost=5)
soln = {'s': {'a': 5, 'c': 0},
'a': {'b': 5},
'b': {'d': 5},
'c': {'d': 0},
'd': {'t': 5},
't': {}}
flow = nx.max_flow_min_cost(G, 's', 't', capacity='bandwidth',
weight='cost')
assert flow == soln
assert nx.cost_of_flow(G, flow, weight='cost') == 90
G.add_edge('t', 's', cost=-100)
flowCost, flow = nx.capacity_scaling(G, capacity='bandwidth',
weight='cost')
G.remove_edge('t', 's')
assert flowCost == -410
assert flow['t']['s'] == 5
del flow['t']['s']
assert flow == soln
assert nx.cost_of_flow(G, flow, weight='cost') == 90
def test_max_flow_min_cost(self):
G = nx.DiGraph()
G.add_edge('s', 'a', bandwidth=6)
G.add_edge('s', 'c', bandwidth=10, cost=10)
G.add_edge('a', 'b', cost=6)
G.add_edge('b', 'd', bandwidth=8, cost=7)
G.add_edge('c', 'd', cost=10)
G.add_edge('d', 't', bandwidth=5, cost=5)
soln = {
's': {
'a': 5,
'c': 0
},
'a': {
'b': 5
},
'b': {
'd': 5
},
'c': {
'd': 0
},
'd': {
't': 5
},
't': {}
}
flow = nx.max_flow_min_cost(G,
's',
't',
capacity='bandwidth',
weight='cost')
assert_equal(flow, soln)
assert_equal(nx.cost_of_flow(G, flow, weight='cost'), 90)
def optimal_procurement(supply_cost, x_max, demand_quantity, holding_cost, backlogging_cost, xh_0=0, xh_n=0):
"""Calculates optimal procurement planning.
Arguments:
supply_cost -- Supply cost at each time period
x_max -- Maximum supply quantity at each time period.
demand_quantity -- Demand quantity at each time period
holding_cost -- Holding cost.
backlogging_cost -- Backlogging cost.
xh_0 -- Initial inventory.
x_hn -- Final inventory target.
"""
G = nx.DiGraph()
n = len(supply_cost)
for t in range(n):
G.add_edge("source", t, {'capacity': x_max[t], 'weight': supply_cost[t]})
G.add_edge(t, "sink", {'capacity': demand_quantity[t], 'weight': 0})
G.add_edge(t, t + 1, {'capacity': np.inf, 'weight': holding_cost})
G.add_edge(t + 1, t, {'capacity': np.inf, 'weight': backlogging_cost})
G.add_edge("source", -1, {'capacity': xh_0, 'weight': 0})
G.add_edge(-1, 0, {'capacity': xh_0, 'weight': 0})
G.add_edge(n, "sink", {'capacity': xh_n, 'weight': 0})
mincost_flow = nx.max_flow_min_cost(G, "source", "sink")
cost = nx.cost_of_flow(G, mincost_flow)
return cost, np.array([mincost_flow['source'][t] for t in range(n)])
def test_digraph2(self):
# Example from ticket #430 from mfrasca. Original source:
# http://www.cs.princeton.edu/courses/archive/spr03/cs226/lectures/mincost.4up.pdf, slide 11.
G = nx.DiGraph()
G.add_edge('s', 1, capacity=12)
G.add_edge('s', 2, capacity=6)
G.add_edge('s', 3, capacity=14)
G.add_edge(1, 2, capacity=11)
G.add_edge(2, 3, capacity=9)
G.add_edge(1, 4, capacity=5)
G.add_edge(1, 5, capacity=2)
G.add_edge(2, 5, capacity=4)
G.add_edge(2, 6, capacity=2)
G.add_edge(3, 6, capacity=31)
G.add_edge(4, 5, capacity=18)
G.add_edge(5, 5, capacity=9)
G.add_edge(4, 't', capacity=3)
G.add_edge(5, 't', capacity=7)
G.add_edge(6, 't', capacity=22)
flow = nx.max_flow_min_cost(G, 's', 't')
soln = {1: {2: 5, 4: 5, 5: 2},
2: {3: 6, 5: 3, 6: 2},
3: {6: 20},
4: {5: 2, 't': 3},
5: {5: 0, 't': 7},
6: {'t': 22},
's': {1: 12, 2: 6, 3: 14},
't': {}}
assert_equal(flow, soln)
def compute_mcf(self, servers):
# Add super source and sink
n = self.G.number_of_nodes()
source, sink = n, n+1
self.G.add_node(source, demand=-self.total_demand)
self.G.add_node(sink, demand=self.total_demand)
# super source --> servers
for i in servers:
self.G.add_edge(source, i, cost=0, capacity=self.output_cap[servers[i]])
# cus --> super sink
for i in self.cus_list:
self.G.add_edge(i, sink, cost=0, capacity=self.cus_list[i])
for i in range(n):
self.G.node[i]['demand'] = 0
min_cost_flow = nx.max_flow_min_cost(self.G, source, sink, weight='cost')
min_cost = nx.cost_of_flow(self.G, min_cost_flow, weight='cost')
max_flow = nx.maximum_flow(self.G, source, sink)[0]
is_feasible = (max_flow == self.total_demand)
print min_cost, max_flow, is_feasible
# Delete edges
for i in servers:
self.G.remove_edge(source, i)
for i in self.cus_list:
self.G.remove_edge(i, sink)
# Delete nodes
self.G.remove_node(source)
self.G.remove_node(sink)
return min_cost, max_flow, is_feasible
def make_f_flow(edges, l_caps, r_caps, f):
"""
See tst2 for sample usage.
Note: this is sub-optimal and unnecessarily complex.
"""
n_edges = np.max(edges)
g = create_bipartite_graph(edges, l_caps, r_caps)
flow_value, flow_dict = nx.maximum_flow(g, 0, n_edges + 1)
while flow_value < f:
for i in range(len(l_caps) + len(r_caps)):
if i <= len(l_caps) - 1:
edge = g[0][i + 1]
flow_val = flow_dict[0][i + 1]
else:
edge = g[i + 1][n_edges + 1]
flow_val = flow_dict[i + 1][n_edges + 1]
if edge['capacity'] == flow_val:
edge['capacity'] += 1
## If we knew the upwards critical edges, we wouldn't have to run
# max flow in a loop.
# See: http://people.csail.mit.edu/moitra/docs/6854hw4.pdf
nu_flow_value, nu_flow_dict = nx.maximum_flow(
g, 0, n_edges + 1)
if nu_flow_value == flow_value:
edge['capacity'] -= 1
else:
flow_value, flow_dict = nu_flow_value, nu_flow_dict
if nu_flow_value == f:
break
flow_dict = nx.max_flow_min_cost(g, 0, n_edges + 1)
return flow_dict
def test_max_flow_min_cost(self):
G = nx.DiGraph()
G.add_edge("s", "a", bandwidth=6)
G.add_edge("s", "c", bandwidth=10, cost=10)
G.add_edge("a", "b", cost=6)
G.add_edge("b", "d", bandwidth=8, cost=7)
G.add_edge("c", "d", cost=10)
G.add_edge("d", "t", bandwidth=5, cost=5)
soln = {
"s": {"a": 5, "c": 0},
"a": {"b": 5},
"b": {"d": 5},
"c": {"d": 0},
"d": {"t": 5},
"t": {},
}
flow = nx.max_flow_min_cost(G, "s", "t", capacity="bandwidth", weight="cost")
assert flow == soln
assert nx.cost_of_flow(G, flow, weight="cost") == 90
G.add_edge("t", "s", cost=-100)
flowCost, flow = nx.capacity_scaling(G, capacity="bandwidth", weight="cost")
G.remove_edge("t", "s")
assert flowCost == -410
assert flow["t"]["s"] == 5
del flow["t"]["s"]
assert flow == soln
assert nx.cost_of_flow(G, flow, weight="cost") == 90
def findMaxFlowMinCost(self, is_plot_graph: bool = True):
""" 寻找最小费用最大流 """
self.flow_cost_graph = nx.DiGraph()
for edge in self.edge_list:
self.flow_cost_graph.add_edge(edge[0],
edge[1],
capacity=edge[2],
weight=edge[3])
# 计算最小费用最大流
self.max_flow_min_cost_dict = nx.max_flow_min_cost(
self.flow_cost_graph, self.start_node, self.end_node)
self.min_cost_value = nx.cost_of_flow(
self.flow_cost_graph, self.max_flow_min_cost_dict) # type:float
print('最小费用为：', self.min_cost_value)
# 将最大流字典转换为列表
self.max_flow_min_cost_edges = [] # type:List[Tuple[int,int,int]]
for node, nodes in self.max_flow_min_cost_dict.items():
for node_, flow in nodes.items():
if flow > 0:
self.max_flow_min_cost_edges.append((node, node_, flow))
# 绘制图像
if is_plot_graph:
# 原始图
fig = plt.figure() # type:plt.Figure
ax = fig.add_subplot(121)
_, pos = drawFlow(self.edge_list, ax)
# 最大流图
ax_ = fig.add_subplot(122)
self.max_flow_graph, _ = drawFlow(self.max_flow_min_cost_edges,
ax_, pos)
ax_.set_title('Max Flow Min Cost Graph')
def repair(self, DG): #new_feature = repair_feature(feature, create_graph(feature))
mincostFlow = nx.max_flow_min_cost(DG, 's', 't') #max_flow_min_cost returns Dictionary of dictionaries. Keyed by nodes such that mincostFlow[u][v] is the flow edge (u,v)
bin_dict = self.bin_fulldata
index_dict = self.bin_index_dict_reverse
size_data = len(self.data)
repair_bin_dict = {}
repair_data = [0]*size_data #initialize repaired data to be 0. If there are zero's after we fill it in the those observations belong in the overflow, "no category"
k = self.num_bins
overflow = 0
for i in range(0,k): #for each lefthand side node i
overflow += mincostFlow[i][2*k]
for j in range(k, 2*k): #for each righthand side node j
edgeflow = mincostFlow[i][j] #get the int (edgeflow) representing the amount of observations going from node i to j
group = random.sample(bin_dict[i], int(edgeflow)) #randomly sample x (edgeflow) unique elements from the list of observations in that category.
q=j-k #q is the category index for a righhand side node
for elem in group: #for each element in the randomly selected group list
bin_dict[i].remove(elem) #remove the element from the list of observation in that category
repair_data[elem] = index_dict[q] #Mutate repair data at the index of the observation (elem) with its new category (it was 0) which is the category index for the righthand side node it flows to
if q in repair_bin_dict: #if the category index is already keyed
repair_bin_dict[q].extend(group) #extend the list of observations with a new list of observations in that category
else:
repair_bin_dict[q] = group #otherwise key that category index and set it's value as the group list in that category
new_feature = CategoricalFeature(repair_data) #initialize our new_feature (repaired feature)
new_feature.bin_fulldata = repair_bin_dict
return [new_feature,overflow]
def gen_test_cases(n_iter=100, seed=123):
random.seed(seed)
n = 8
for _ in range(n_iter):
while True:
m = random.randint(n, 50)
DG = nx.gnm_random_graph(n, m, seed=random.randint(1000, 10000), directed=True)
WG = nx.DiGraph()
WG.add_nodes_from(DG.nodes())
for (u, v) in DG.edges():
WG.add_edge(u, v, capacity=random.randint(
1, 8), weight=random.randint(1, 3))
inp = io.StringIO()
inp.write(f"{n} {m}\n")
for u, v in WG.edges():
edge = WG[u][v]
inp.write(f"{u + 1} {v + 1} {edge['capacity']} {edge['weight']}\n")
flow = nx.max_flow_min_cost(WG, 0, n - 1)
cost = nx.cost_of_flow(WG, flow)
if cost:
break
yield inp.getvalue(), cost, flow
def hungarian_matching(left_nodes, right_nodes, threshold, dist_fn):
"""
node shoud be [id, features]
"""
if len(right_nodes) == 0 or left_nodes is None or len(left_nodes) == 0:
return []
G = nx.DiGraph()
edges = []
for left_node in left_nodes:
if isinstance(left_node, Iterable):
left_id = int(left_node[0])
else:
left_id = int(left_node)
costs = dist_fn(left_node, right_nodes)
valid_idxs = np.where(costs < threshold)[0]
for valid_idx in valid_idxs:
edges.append((
f"p{left_id}",
f"c{valid_idx}",
{
"capacity": 1,
"weight": int(costs[valid_idx] * 100)
},
))
edges.append(("s", f"p{left_id}", {"capacity": 1, "weight": 0}))
for i in range(len(right_nodes)):
right_node = right_nodes[i]
if isinstance(right_node, Iterable):
right_id = right_node[0]
else:
right_id = right_node
if right_id == -1:
edges.append((f"c{i}", "t", {"capacity": np.inf, "weight": 0}))
else:
edges.append((f"c{i}", "t", {"capacity": 1, "weight": 0}))
G.add_edges_from(edges)
mincostFlow = nx.max_flow_min_cost(G, "s", "t")
result = []
for start_point, sflow in mincostFlow["s"].items():
if sflow == 1:
for end_point, eflow in mincostFlow[start_point].items():
if eflow == 1:
left_id = int(start_point[1:])
right_idx = int(end_point[1:])
right_node = right_nodes[right_idx]
if isinstance(right_node, Iterable):
right_id = right_node[0]
else:
right_id = right_node
result.append((left_id, right_id))
break
return result
def computeSchedule():
_logger.info('Scheduling AWS now')
test_graph(g_)
_logger.info('Computing max-flow, min-cost')
res = nx.max_flow_min_cost(g_, 'source', 'sink')
_logger.info('\t Computed. Getting schedules now ...')
sch = getMatches(res)
return sch
def run_max_flow(G):
'''Return edges in max flow analysis.
G is a bipartite graph created from create_bipartite_graph().
'''
edges = nx.max_flow_min_cost(G, 'S', 'T')
return edges
def compute_flow(self):
flow = nx.max_flow_min_cost(self._graph, 's', 't')
total_flow = 0
for site in self.sites:
total_flow += flow.get(site)['t']
total_flow = sum(flow['s'].values())
return flow, total_flow
def update_plan(self, G, t):
#if 's' in nodes and 't' in nodes:
nodes = G.nodes()
if len(nodes) != 0:
M = nx.max_flow_min_cost(G, 's', 't')
else:
M = False
#print(M)
return M
def compute_solution():
global g_
flow = nx.max_flow_min_cost(g_, 'source', 'sink')
scheduled, notScheduled = flow_to_solution(flow)
daysToAWS = print_solution(scheduled)
cost = nx.cost_of_flow(g_, flow)
print('Cost of solution = %d' % cost)
print('Mean gap=%d, Min gap=%d, Max Gap=%d' %
(np.mean(daysToAWS), min(daysToAWS), max(daysToAWS)))
return scheduled
def update_plan(self, G,t): #if 's' in nodes and 't' in nodes: nodes=G.nodes() if len(nodes)!=0: M = nx.max_flow_min_cost(G, 's', 't') #print(M) else: M=False #print(M) #M = MinCost_MaxFlow(s,t) # dict of dict form return M
def pr345():
G = nx.DiGraph()
n = len(data)
for i in range(n):
G.add_edge('s', 'A'+str(i), weight=0, capacity=1)
G.add_edge('B'+str(i), 't', weight=0, capacity=1)
for i in range(n):
for j in range(n):
G.add_edge('A'+str(i), 'B'+str(j), weight=-data[i][j], capacity=1)
flow = nx.max_flow_min_cost(G, 's', 't')
return -nx.cost_of_flow(G, flow)
def __round_fractional_topology_giant_switch(self, fractional_adj_matrix):
integer_adj_matrix = np.zeros((self.num_groups, self.num_groups))
nnodes = 2 + (2 * self.num_groups)
G = nx.DiGraph()
edges = []
num_interblock_link_per_group = self.num_switches_per_group * self.h
# add edges from src to first layer nodes and between second layer nodes to sink
for i in range(self.num_groups):
egress_sum = 0.
ingress_sum = 0.
for j in range(self.num_groups):
if i != j:
egress_sum += math.floor(fractional_adj_matrix[i][j])
ingress_sum += math.floor(fractional_adj_matrix[j][i])
edges.append((0, i + 1, {
'capacity': num_interblock_link_per_group - egress_sum,
'weight': 0
}))
edges.append((self.num_groups + i + 1, nnodes - 1, {
'capacity': num_interblock_link_per_group - ingress_sum,
'weight': 0
}))
# next, add edges between first layer nodes and second layer nodes
for i in range(self.num_groups):
for j in range(self.num_groups):
if i != j:
score = int((math.ceil(fractional_adj_matrix[i][j]) -
fractional_adj_matrix[i][j]) * 1E6)
edges.append((i + 1, self.num_groups + j + 1, {
'capacity': 1,
'weight': score
}))
# next, add the edges set into the graph
G.add_edges_from(edges)
mincostFlow = nx.max_flow_min_cost(G, 0, nnodes - 1)
for i in range(self.num_groups):
for j in range(self.num_groups):
if i != j:
assert (mincostFlow[i + 1][self.num_groups + j + 1] <= 1)
integer_adj_matrix[i][j] = int(
math.floor(fractional_adj_matrix[i][j]) +
mincostFlow[i + 1][self.num_groups + j + 1])
## Finally, check to see if some links are 0
for i in range(self.num_groups):
for j in range(self.num_groups):
if i != j and integer_adj_matrix[i][j] < 1:
assert (False)
return integer_adj_matrix
def maxFlowMinCost(self, diNet):
''' graph must have one node s and one node t '''
w = {}
flow = {}
residual_capacity = {}
mfmc = nx.max_flow_min_cost(diNet, s='s', t='t', capacity='capacity', weight='weight')
for k, v in mfmc.items():
if isinstance(v, dict):
for k2, v2 in v.items():
w[(k, k2)] = (diNet[k][k2]['capacity'], v2)
flow[(k, k2)] = v2
residual_capacity[(k, k2)] = diNet.get_edge_data(k, k2)['capacity'] - v2
else:
print("oops")
return w, flow, residual_capacity
def test_max_flow_min_cost(self):
G = nx.DiGraph()
G.add_edge('s', 'a', bandwidth = 6)
G.add_edge('s', 'c', bandwidth = 10, cost = 10)
G.add_edge('a', 'b', cost = 6)
G.add_edge('b', 'd', bandwidth = 8, cost = 7)
G.add_edge('c', 'd', cost = 10)
G.add_edge('d', 't', bandwidth = 5, cost = 5)
soln = {'s': {'a': 5, 'c': 0},
'a': {'b': 5},
'b': {'d': 5},
'c': {'d': 0},
'd': {'t': 5},
't': {}}
flow = nx.max_flow_min_cost(G, 's', 't', capacity = 'bandwidth',
weight = 'cost')
assert_equal(flow, soln)
assert_equal(nx.cost_of_flow(G, flow, weight = 'cost'), 90)
def test_digraph3(self):
"""Combinatorial Optimization: Algorithms and Complexity,
Papadimitriou Steiglitz at page 140 has an example, 7.1, but that
admits multiple solutions, so I alter it a bit. From ticket #430
by mfrasca."""
G = nx.DiGraph()
G.add_edge('s', 'a')
G['s']['a'].update({0: 2, 1: 4})
G.add_edge('s', 'b')
G['s']['b'].update({0: 2, 1: 1})
G.add_edge('a', 'b')
G['a']['b'].update({0: 5, 1: 2})
G.add_edge('a', 't')
G['a']['t'].update({0: 1, 1: 5})
G.add_edge('b', 'a')
G['b']['a'].update({0: 1, 1: 3})
G.add_edge('b', 't')
G['b']['t'].update({0: 3, 1: 2})
"PS.ex.7.1: testing main function"
sol = nx.max_flow_min_cost(G, 's', 't', capacity=0, weight=1)
flow = sum(v for v in sol['s'].values())
assert_equal(4, flow)
assert_equal(23, nx.cost_of_flow(G, sol, weight=1))
assert_equal(sol['s'], {'a': 2, 'b': 2})
assert_equal(sol['a'], {'b': 1, 't': 1})
assert_equal(sol['b'], {'a': 0, 't': 3})
assert_equal(sol['t'], {})
G.add_edge('t', 's')
G['t']['s'].update({1: -100})
flowCost, sol = nx.capacity_scaling(G, capacity=0, weight=1)
G.remove_edge('t', 's')
flow = sum(v for v in sol['s'].values())
assert_equal(4, flow)
assert_equal(sol['t']['s'], 4)
assert_equal(flowCost, -377)
del sol['t']['s']
assert_equal(sol['s'], {'a': 2, 'b': 2})
assert_equal(sol['a'], {'b': 1, 't': 1})
assert_equal(sol['b'], {'a': 0, 't': 3})
assert_equal(sol['t'], {})
assert_equal(nx.cost_of_flow(G, sol, weight=1), 23)
def test_digraph3(self):
"""Combinatorial Optimization: Algorithms and Complexity,
Papadimitriou Steiglitz at page 140 has an example, 7.1, but that
admits multiple solutions, so I alter it a bit. From ticket #430
by mfrasca."""
G = nx.DiGraph()
G.add_edge("s", "a")
G["s"]["a"].update({0: 2, 1: 4})
G.add_edge("s", "b")
G["s"]["b"].update({0: 2, 1: 1})
G.add_edge("a", "b")
G["a"]["b"].update({0: 5, 1: 2})
G.add_edge("a", "t")
G["a"]["t"].update({0: 1, 1: 5})
G.add_edge("b", "a")
G["b"]["a"].update({0: 1, 1: 3})
G.add_edge("b", "t")
G["b"]["t"].update({0: 3, 1: 2})
"PS.ex.7.1: testing main function"
sol = nx.max_flow_min_cost(G, "s", "t", capacity=0, weight=1)
flow = sum(v for v in sol["s"].values())
assert 4 == flow
assert 23 == nx.cost_of_flow(G, sol, weight=1)
assert sol["s"] == {"a": 2, "b": 2}
assert sol["a"] == {"b": 1, "t": 1}
assert sol["b"] == {"a": 0, "t": 3}
assert sol["t"] == {}
G.add_edge("t", "s")
G["t"]["s"].update({1: -100})
flowCost, sol = nx.capacity_scaling(G, capacity=0, weight=1)
G.remove_edge("t", "s")
flow = sum(v for v in sol["s"].values())
assert 4 == flow
assert sol["t"]["s"] == 4
assert flowCost == -377
del sol["t"]["s"]
assert sol["s"] == {"a": 2, "b": 2}
assert sol["a"] == {"b": 1, "t": 1}
assert sol["b"] == {"a": 0, "t": 3}
assert sol["t"] == {}
assert nx.cost_of_flow(G, sol, weight=1) == 23
def test_digraph3(self):
"""Combinatorial Optimization: Algorithms and Complexity,
Papadimitriou Steiglitz at page 140 has an example, 7.1, but that
admits multiple solutions, so I alter it a bit. From ticket #430
by mfrasca."""
G = nx.DiGraph()
G.add_edge('s', 'a')
G['s']['a'].update({0: 2, 1: 4})
G.add_edge('s', 'b')
G['s']['b'].update({0: 2, 1: 1})
G.add_edge('a', 'b')
G['a']['b'].update({0: 5, 1: 2})
G.add_edge('a', 't')
G['a']['t'].update({0: 1, 1: 5})
G.add_edge('b', 'a')
G['b']['a'].update({0: 1, 1: 3})
G.add_edge('b', 't')
G['b']['t'].update({0: 3, 1: 2})
"PS.ex.7.1: testing main function"
sol = nx.max_flow_min_cost(G, 's', 't', capacity=0, weight=1)
flow = sum(v for v in sol['s'].values())
assert_equal(4, flow)
assert_equal(23, nx.cost_of_flow(G, sol, weight=1))
assert_equal(sol['s'], {'a': 2, 'b': 2})
assert_equal(sol['a'], {'b': 1, 't': 1})
assert_equal(sol['b'], {'a': 0, 't': 3})
assert_equal(sol['t'], {})
G.add_edge('t', 's')
G['t']['s'].update({1: -100})
flowCost, sol = nx.capacity_scaling(G, capacity=0, weight=1)
G.remove_edge('t', 's')
flow = sum(v for v in sol['s'].values())
assert_equal(4, flow)
assert_equal(sol['t']['s'], 4)
assert_equal(flowCost, -377)
del sol['t']['s']
assert_equal(sol['s'], {'a': 2, 'b': 2})
assert_equal(sol['a'], {'b': 1, 't': 1})
assert_equal(sol['b'], {'a': 0, 't': 3})
assert_equal(sol['t'], {})
assert_equal(nx.cost_of_flow(G, sol, weight=1), 23)
def buildGraph(inputData):
"""
:param inputData:
"""
sellerArray, customerArray, costMatrix = inputData
G = nx.Graph()
for i in range(1, len(sellerArray) + 1):
for j in range(1, 1 + len(customerArray)):
G.add_edge(i, j + len(sellerArray), capacity=inf, weight=int(costMatrix[i - 1][j - 1]))
G.add_edge(0, i, {'capacity': sellerArray[i - 1], 'weight': int(0)})
sum = len(sellerArray) + len(customerArray) + 1
for j in range(len(customerArray)):
G.add_edge(len(sellerArray) + j + 1, sum, capacity=customerArray[j - 1], weight=0)
#minCostFlow = nx.max_flow_min_cost(G)
c1 = 25000 / len(sellerArray)
c2 = 25000 / len(customerArray)
pos = {0: (15000.0, -12000.0), len(sellerArray) + len(customerArray) + 1: (15000.0, 12000.0)}
for i in range(0, len(sellerArray)):
pos[i + 1] = (i * c1, -7500.0)
for n in range(len(sellerArray), len(sellerArray) + len(customerArray)):
pos[n + 1] = ((n - len(sellerArray)) * c2, 7500.0)
colors = [d['weight'] for (u, v, d) in G.edges(data=True)]
flow = nx.max_flow_min_cost(G, 0, len(sellerArray) + len(customerArray) + 1)
costOfFlow = nx.cost_of_flow(G, flow)
print("Cost: " + str(costOfFlow))
newEdgeList = []
for k, v in flow.items():
for i, j in v.items():
if G.has_edge(k, i) and j > 0:
newEdgeList.append([k, i])
edge_labels = {}
for u, v, d in G.edges(data=True):
if flow[u][v] > 0:
edge_labels[(u, v,)] = str(flow[u][v]) + "/" + str(d['weight'])
print(costOfFlow, flow)
nx.draw_networkx(G, pos, edgelist=newEdgeList, node_shape='o', node_color='#A0CBE2', edge_labels=edge_labels,
width=1.5, alpha=1,
edge_cmap=P.cm.ma,
with_labels=True)
nx.draw_networkx_edge_labels(G, pos, edge_labels, label_pos=0.7, font_size=8)
P.show()
def set_flow(self):
try:
self.flow = nx.max_flow_min_cost(self, self.source, self.sink)
self.flow_cost = nx.cost_of_flow(self, self.flow)
self.max_flow = nx.maximum_flow(self, self.source, self.sink)[0]
except nx.NetworkXUnfeasible:
print 'Allocation satisfying the lower bounds is not possible.'
print 'Try reducing lower bounds.'
sys.exit(1)
except nx.NetworkXError:
print "The input graph is not directed or not connected."
print "Please check the data:"
print "e.g. if all the choices on the level 1 list are" \
" included in the level 2 list and same for levels 2, 3."
sys.exit(1)
except nx.NetworkXUnbounded:
print "Allocation is not possible because some upper capacity" \
"bounds at level 1 have not been set up. Please check " \
"the data."
sys.exit(1)
def test_digraph2(self):
# Example from ticket #430 from mfrasca. Original source:
# http://www.cs.princeton.edu/courses/archive/spr03/cs226/lectures/mincost.4up.pdf, slide 11.
G = nx.DiGraph()
G.add_edge("s", 1, capacity=12)
G.add_edge("s", 2, capacity=6)
G.add_edge("s", 3, capacity=14)
G.add_edge(1, 2, capacity=11, weight=4)
G.add_edge(2, 3, capacity=9, weight=6)
G.add_edge(1, 4, capacity=5, weight=5)
G.add_edge(1, 5, capacity=2, weight=12)
G.add_edge(2, 5, capacity=4, weight=4)
G.add_edge(2, 6, capacity=2, weight=6)
G.add_edge(3, 6, capacity=31, weight=3)
G.add_edge(4, 5, capacity=18, weight=4)
G.add_edge(5, 6, capacity=9, weight=5)
G.add_edge(4, "t", capacity=3)
G.add_edge(5, "t", capacity=7)
G.add_edge(6, "t", capacity=22)
flow = nx.max_flow_min_cost(G, "s", "t")
soln = {
1: {2: 6, 4: 5, 5: 1},
2: {3: 6, 5: 4, 6: 2},
3: {6: 20},
4: {5: 2, "t": 3},
5: {6: 0, "t": 7},
6: {"t": 22},
"s": {1: 12, 2: 6, 3: 14},
"t": {},
}
assert flow == soln
G.add_edge("t", "s", weight=-100)
flowCost, flow = nx.capacity_scaling(G)
G.remove_edge("t", "s")
assert flow["t"]["s"] == 32
assert flowCost == -3007
del flow["t"]["s"]
assert flow == soln
assert nx.cost_of_flow(G, flow) == 193
def optimal_procurement(supply_cost,
x_max,
demand_quantity,
holding_cost,
backlogging_cost,
xh_0=0,
xh_n=0):
"""Calculates optimal procurement planning.
Arguments:
supply_cost -- Supply cost at each time period
x_max -- Maximum supply quantity at each time period.
demand_quantity -- Demand quantity at each time period
holding_cost -- Holding cost.
backlogging_cost -- Backlogging cost.
xh_0 -- Initial inventory.
x_hn -- Final inventory target.
"""
G = nx.DiGraph()
n = len(supply_cost)
for t in range(n):
G.add_edge("source", t, {
'capacity': x_max[t],
'weight': supply_cost[t]
})
G.add_edge(t, "sink", {'capacity': demand_quantity[t], 'weight': 0})
G.add_edge(t, t + 1, {'capacity': np.inf, 'weight': holding_cost})
G.add_edge(t + 1, t, {'capacity': np.inf, 'weight': backlogging_cost})
G.add_edge("source", -1, {'capacity': xh_0, 'weight': 0})
G.add_edge(-1, 0, {'capacity': xh_0, 'weight': 0})
G.add_edge(n, "sink", {'capacity': xh_n, 'weight': 0})
mincost_flow = nx.max_flow_min_cost(G, "source", "sink")
cost = nx.cost_of_flow(G, mincost_flow)
return cost, np.array([mincost_flow['source'][t] for t in range(n)])
def test_digraph2(self):
# Example from ticket #430 from mfrasca. Original source:
# http://www.cs.princeton.edu/courses/archive/spr03/cs226/lectures/mincost.4up.pdf, slide 11.
G = nx.DiGraph()
G.add_edge('s', 1, capacity=12)
G.add_edge('s', 2, capacity=6)
G.add_edge('s', 3, capacity=14)
G.add_edge(1, 2, capacity=11, weight=4)
G.add_edge(2, 3, capacity=9, weight=6)
G.add_edge(1, 4, capacity=5, weight=5)
G.add_edge(1, 5, capacity=2, weight=12)
G.add_edge(2, 5, capacity=4, weight=4)
G.add_edge(2, 6, capacity=2, weight=6)
G.add_edge(3, 6, capacity=31, weight=3)
G.add_edge(4, 5, capacity=18, weight=4)
G.add_edge(5, 6, capacity=9, weight=5)
G.add_edge(4, 't', capacity=3)
G.add_edge(5, 't', capacity=7)
G.add_edge(6, 't', capacity=22)
flow = nx.max_flow_min_cost(G, 's', 't')
soln = {1: {2: 6, 4: 5, 5: 1},
2: {3: 6, 5: 4, 6: 2},
3: {6: 20},
4: {5: 2, 't': 3},
5: {6: 0, 't': 7},
6: {'t': 22},
's': {1: 12, 2: 6, 3: 14},
't': {}}
assert_equal(flow, soln)
G.add_edge('t', 's', weight=-100)
flowCost, flow = nx.capacity_scaling(G)
G.remove_edge('t', 's')
assert_equal(flow['t']['s'], 32)
assert_equal(flowCost, -3007)
del flow['t']['s']
assert_equal(flow, soln)
assert_equal(nx.cost_of_flow(G, flow), 193)
def test_digraph2(self):
# Example from ticket #430 from mfrasca. Original source:
# http://www.cs.princeton.edu/courses/archive/spr03/cs226/lectures/mincost.4up.pdf, slide 11.
G = nx.DiGraph()
G.add_edge('s', 1, capacity=12)
G.add_edge('s', 2, capacity=6)
G.add_edge('s', 3, capacity=14)
G.add_edge(1, 2, capacity=11, weight=4)
G.add_edge(2, 3, capacity=9, weight=6)
G.add_edge(1, 4, capacity=5, weight=5)
G.add_edge(1, 5, capacity=2, weight=12)
G.add_edge(2, 5, capacity=4, weight=4)
G.add_edge(2, 6, capacity=2, weight=6)
G.add_edge(3, 6, capacity=31, weight=3)
G.add_edge(4, 5, capacity=18, weight=4)
G.add_edge(5, 6, capacity=9, weight=5)
G.add_edge(4, 't', capacity=3)
G.add_edge(5, 't', capacity=7)
G.add_edge(6, 't', capacity=22)
flow = nx.max_flow_min_cost(G, 's', 't')
soln = {1: {2: 6, 4: 5, 5: 1},
2: {3: 6, 5: 4, 6: 2},
3: {6: 20},
4: {5: 2, 't': 3},
5: {6: 0, 't': 7},
6: {'t': 22},
's': {1: 12, 2: 6, 3: 14},
't': {}}
assert_equal(flow, soln)
G.add_edge('t', 's', weight=-100)
flowCost, flow = nx.capacity_scaling(G)
G.remove_edge('t', 's')
assert_equal(flow['t']['s'], 32)
assert_equal(flowCost, -3007)
del flow['t']['s']
assert_equal(flow, soln)
assert_equal(nx.cost_of_flow(G, flow), 193)
def main(departure_locations, meeting_options, departure_date):
G = nx.DiGraph()
G = create_graph(departure_locations, meeting_options, departure_date)
flow_dict = nx.max_flow_min_cost(G, 'SOURCE', 'DEST')
print(flow_dict)
mincost = nx.cost_of_flow(G, flow_dict)
print(mincost)
pairs = []
for u in flow_dict.keys():
for v in (flow_dict[u]).keys():
if int(flow_dict[u][v]) > 0:
print(u, v, flow_dict[u][v])
pairs.append((u, v))
max_people = 0
best_loc = ''
for pair in pairs:
if pair[1] == 'DEST':
if int(flow_dict[pair[0]][pair[1]]) > max_people:
best_loc = pair[0]
max_people = int(flow_dict[pair[0]][pair[1]])
print('Best location is ', best_loc)
response = amadeus.reference_data.locations.get(subType='AIRPORT',
keyword=best_loc)
city_name = response.data[0]["address"]["cityName"]
state_name = response.data[0]["address"]["stateCode"]
location = city_name + ', ' + state_name
print('My location is ', location)
return location, mincost
sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
plt.colorbar(sm, ax=ax, alpha=.8)
def draw_flow(graph, flow_dict, pos):
flow_labels = {(k, v1): 'flow: ' + str(v2)
for k, v in flow_dict.items() for v1, v2 in v.items()}
nx.draw_networkx(graph, pos=pos)
nx.draw_networkx_edge_labels(graph, pos, edge_labels=flow_labels)
plt.show()
#%% Solve max flow without constraints
draw_graph_with_edges(g, gpos)
unconstrained = nx.max_flow_min_cost(g, s=1, t=4)
draw_flow(g, unconstrained, gpos)
#%% Augment with source and sink
aug_g = g.copy()
aug_gpos = gpos.copy()
aug_gpos['super_source'] = (min([x for x, y in gpos.values()]) - 1,
max([y for x, y in gpos.values()]) + 1)
aug_gpos['super_sink'] = (max([x for x, y in gpos.values()]) + 1,
max([y for x, y in gpos.values()]) + 1)
sum_demand = sum([d for n, d in g.nodes(data='demand') if d > 0])
max_weight = max([w for u, v, w in g.edges(data='weight')])
# Add edge with 0 weight from super source to nodes with negative demand (demand nodes)
aug_g.add_weighted_edges_from([('super_source', n, 0) for n in g.nodes()
if g.nodes[n]['demand'] < 0])
aug_g.nodes['super_source']['demand'] = -sum_demand
vector = buildNetwork(devices)
# print(vector)
paths, SchematicGraph, ImpactGraph, ExploitabilityGraph, edge_labels, schematic_dotstr, impact_dotstr, exploitability_dotstr, targets = buildCircuit(
devices, vector)
print(nx.get_edge_attributes(ExploitabilityGraph, "weight"))
print(nx.get_edge_attributes(ExploitabilityGraph, "demand"))
print(nx.get_edge_attributes(ExploitabilityGraph, "capacity"))
### find max flow values ###
max_impact = max_exploitability = 0
for target in targets:
max_impact += nx.maximum_flow_value(ImpactGraph,
"Non-CVE info: Router", target)
try:
min_cost = nx.max_flow_min_cost(ExploitabilityGraph, "Attacker",
target)
print("Min cost flow, " + target + ": ", min_cost)
except:
print("Min cost flow, " + target + ": no path")
print("Max Impact: ", max_impact)
print("Time: " + str(time.time() - timestamp))
### save ###
# snap.DrawGViz(home_network, snap.gvlDot, "deliverables/home_network.png", "Home Network", network_labels)
schematic_dotfile = open("deliverables/schematic_circuit.dot", "w")
schematic_dotfile.write(schematic_dotstr)
schematic_dotfile.close()
impact_dotfile = open("deliverables/impact_circuit.dot", "w")
impact_dotfile.write(impact_dotstr)
def active_colloids_tracking_pipeline(frames, segmentation_method,
simple_threshold):
G = nx.DiGraph()
num_frames = len(frames)
num_cores = multiprocessing.cpu_count()
if segmentation_method == 'two_cc':
segments = Parallel(n_jobs=num_cores)(
delayed(two_cc.two_connected_components)(
frames[i], channel="red", thresh=86)
for i in range(len(frames)))
elif segmentation_method == 'watershed':
segments = Parallel(n_jobs=num_cores)(
delayed(simple_segmentation.simple_segmentation)(frames[i])
for i in range(len(frames)))
elif segmentation_method == 'rag_merging':
segments = Parallel(n_jobs=num_cores)(
delayed(simple_segmentation.rag_merging_segmentation)(frames[i])
for i in range(len(frames)))
elif segmentation_method == 'simple_threshold':
segments = Parallel(n_jobs=num_cores)(delayed(
simple_segmentation.simple_threshold)(frames[i], simple_threshold)
for i in range(len(frames)))
all_mass_centers = []
all_mass_centers = Parallel(n_jobs=num_cores)(
delayed(get_frame_mass_centers)(segments[i])
for i in range(num_frames))
# adding nodes
for i in range(len(segments)):
frame_mass_centers = all_mass_centers[i]
for j in range(len(frame_mass_centers)):
pos_x = frame_mass_centers[j][0]
pos_y = frame_mass_centers[j][1]
frame_number = i
G.add_node((pos_x, pos_y, frame_number), pos=(pos_x, pos_y))
end = time.time()
# adding edges (arcs)
d_max = 20 # TODO generalize
for frame_number in range(num_frames - 1): # we set attributes for FF
for vertex1 in vertices_from_ith_frame(G, frame_number):
for vertex2 in vertices_from_ith_frame(G, frame_number + 1):
if get_distance(vertex1, vertex2) < d_max:
weight = int(10 * get_distance(vertex1, vertex2) / d_max)
G.add_edge(vertex1, vertex2, capacity=10, weight=weight)
dist_border = 100000 #### TODO generalize
print('Number of edges before the refinement', len(G.edges))
initial_graph_refinement(G, d_max, dist_border)
print('Number of edges before the refinement', len(G.edges))
# new nodes
source = (-1, -1, -1)
G.add_node(source, pos=(-1, 1)) # source
sink = (-2, -2, -2)
G.add_node(sink, pos=(700, 1)) # sink
# new edges
for vertex in vertices_from_ith_frame(G, 0):
G.add_edge(source, vertex, capacity=10, weight=0)
for vertex in vertices_from_ith_frame(G, get_num_frames(G) - 1):
G.add_edge(vertex, sink, capacity=10, weight=0)
# weights should not be floats! We use only integers, otherwise calculations will last forever!
resultFlowDict = nx.max_flow_min_cost(G,
source,
sink,
capacity='capacity',
weight='weight')
detected_objects = []
visited = {}
for node in G.nodes:
visited[node] = False
results = [np.array(f) for f in segments]
radius = 20
for node in G.nodes:
if not visited[node]:
detected_objects.append(node)
color = (int(random() * 255), int(random() * 255),
int(random() * 255))
while node != (-2, -2, -2):
center = (node[1], node[0])
frame = node[2]
results[frame] = cv2.circle(results[frame],
center,
radius,
color,
thickness=3)
if resultFlowDict[node] == {}:
break
visited[node] = True
node = list(resultFlowDict[node].keys())[0]
results = [Image.fromarray(r) for r in results]
return results, G, resultFlowDict
def buildGraph(inputData):
"""
:param inputData:
"""
sellerArray, customerArray, costMatrix = inputData
G = nx.Graph()
for i in range(1, len(sellerArray) + 1):
for j in range(1, 1 + len(customerArray)):
G.add_edge(i,
j + len(sellerArray),
capacity=inf,
weight=int(costMatrix[i - 1][j - 1]))
G.add_edge(0, i, {'capacity': sellerArray[i - 1], 'weight': int(0)})
sum = len(sellerArray) + len(customerArray) + 1
for j in range(len(customerArray)):
G.add_edge(len(sellerArray) + j + 1,
sum,
capacity=customerArray[j - 1],
weight=0)
#minCostFlow = nx.max_flow_min_cost(G)
c1 = 25000 / len(sellerArray)
c2 = 25000 / len(customerArray)
pos = {
0: (15000.0, -12000.0),
len(sellerArray) + len(customerArray) + 1: (15000.0, 12000.0)
}
for i in range(0, len(sellerArray)):
pos[i + 1] = (i * c1, -7500.0)
for n in range(len(sellerArray), len(sellerArray) + len(customerArray)):
pos[n + 1] = ((n - len(sellerArray)) * c2, 7500.0)
colors = [d['weight'] for (u, v, d) in G.edges(data=True)]
flow = nx.max_flow_min_cost(G, 0,
len(sellerArray) + len(customerArray) + 1)
costOfFlow = nx.cost_of_flow(G, flow)
print("Cost: " + str(costOfFlow))
newEdgeList = []
for k, v in flow.items():
for i, j in v.items():
if G.has_edge(k, i) and j > 0:
newEdgeList.append([k, i])
edge_labels = {}
for u, v, d in G.edges(data=True):
if flow[u][v] > 0:
edge_labels[(
u,
v,
)] = str(flow[u][v]) + "/" + str(d['weight'])
print(costOfFlow, flow)
nx.draw_networkx(G,
pos,
edgelist=newEdgeList,
node_shape='o',
node_color='#A0CBE2',
edge_labels=edge_labels,
width=1.5,
alpha=1,
edge_cmap=P.cm.ma,
with_labels=True)
nx.draw_networkx_edge_labels(G,
pos,
edge_labels,
label_pos=0.7,
font_size=8)
P.show()
