Flow correction now works also for graphs with cycles

Author: alexandrutomescu

examples/min_error_flow_cycles.py

@@ -0,0 +1,47 @@
+import flowpaths as fp
+import networkx as nx
+
+def process_solution(graph: nx.DiGraph, model: fp.MinErrorFlow):
+    if model.is_solved():
+        solution = model.get_solution()
+        print(solution["graph"].edges(data=True))
+        print("error", solution["error"])
+        print("objective_value", solution["objective_value"])
+        fp.utils.draw_solution(graph, filename=f"uncorrected_graph_{id(model.get_corrected_graph())}.pdf", flow_attr="flow", draw_options={"show_edge_weights": True})
+        fp.utils.draw_solution(solution["graph"], filename=f"corrected_graph_{id(model.get_corrected_graph())}.pdf", flow_attr="flow", draw_options={"show_edge_weights": True})
+    else:
+        print("Model could not be solved.")
+
+graph = nx.DiGraph()
+graph.add_edge("s", "a", flow=7)
+graph.add_edge("s", "b", flow=7)
+graph.add_edge("a", "b", flow=2)
+graph.add_edge("a", "c", flow=4)
+graph.add_edge("b", "c", flow=9)
+graph.add_edge("c", "d", flow=7)
+graph.add_edge("c", "t", flow=7)
+graph.add_edge("d", "t", flow=6)
+graph.add_edge("t", "s", flow=15)
+
+# We create a the Minimum Error Flow solver with default settings
+correction_model = fp.MinErrorFlow(graph, flow_attr="flow")
+correction_model.solve()
+
+if correction_model.is_solved():
+    corrected_graph = correction_model.get_corrected_graph()
+    process_solution(graph, correction_model)
+
+# We create a the Minimum Error Flow solver, by also requiring that 
+# the number of different flow values used in the correction is small
+# (parameter different_flow_values_epsilon)
+correction_model_diff_flow_values = fp.MinErrorFlow(
+    graph, 
+    flow_attr="flow",
+    weight_type=int,
+    few_flow_values_epsilon = 0.25,
+    )
+correction_model_diff_flow_values.solve()
+
+# We process its solution
+process_solution(graph, correction_model_diff_flow_values)
+

flowpaths/minerrorflow.py

@@ -81,16 +81,27 @@ def __init__(
         """
 
         self.original_graph_copy = deepcopy(G)
-        self.G = stdigraph.stDiGraph(G, additional_starts=additional_starts, additional_ends=additional_ends)
+        self.sparsity_lambda = sparsity_lambda
+        
+        if nx.is_directed_acyclic_graph(G):
+            self.is_acyclic = True
+            self.G = stdigraph.stDiGraph(G, additional_starts=additional_starts, additional_ends=additional_ends)
+            self.edges_to_ignore = set(edges_to_ignore).union(self.G.source_sink_edges)
+        else:
+            self.G = G
+            self.is_acyclic = False
+            self.edges_to_ignore = set(edges_to_ignore)
+            if self.sparsity_lambda != 0:
+                utils.logger.error(f"{__name__}: You cannot set sparsity_lambda != 0 for a graph with cycles.")
+                raise ValueError(f"You cannot set sparsity_lambda != 0 for a graph with cycles.")
+
         self.flow_attr = flow_attr
         if weight_type not in [int, float]:
             utils.logger.error(f"{__name__}: weight_type must be either int or float, not {weight_type}")
             raise ValueError(f"weight_type must be either int or float, not {weight_type}")
         self.weight_type = weight_type
         self.solver_options = solver_options
-
-        self.sparsity_lambda = sparsity_lambda
-        self.edges_to_ignore = set(edges_to_ignore).union(self.G.source_sink_edges)
+        
         self.edge_error_scaling = edge_error_scaling
         # Checking that every entry in self.edge_error_scaling is between 0 and 1
         for key, value in self.edge_error_scaling.items():
@@ -156,7 +167,7 @@ def __encode_flow(self):
 
         # Adding flow conservation constraints
         for node in self.G.nodes():
-            if node in [self.G.source, self.G.sink]:
+            if self.G.in_degree(node) == 0 or self.G.out_degree(node) == 0:
                 continue
             # Flow conservation constraint
             self.solver.add_constraint(
@@ -212,9 +223,9 @@ def __encode_min_sum_errors_objective(self):
                 self.edge_error_vars[(u, v)] * self.edge_error_scaling.get((u, v), 1)
                 for (u, v) in self.G.edges()
                 if (u, v) not in self.edges_to_ignore
-            ) + self.sparsity_lambda * self.solver.quicksum(
+            ) + (self.sparsity_lambda * self.solver.quicksum(
                 self.edge_vars[(u, v)]
-                for (u, v) in self.G.out_edges(self.G.source)
+                for (u, v) in self.G.out_edges(self.G.source)) if self.sparsity_lambda > 0 else 0
             ),
             sense="minimize",
         )
@@ -286,9 +297,9 @@ def __encode_different_flow_values_and_objective(
                 self.edge_error_vars[(u, v)] * self.edge_error_scaling.get((u, v), 1)
                 for (u, v) in self.G.edges()
                 if (u, v) not in self.edges_to_ignore
-            ) + self.sparsity_lambda * self.solver.quicksum(
+            ) + (self.sparsity_lambda * self.solver.quicksum(
                 self.edge_vars[(u, v)]
-                for (u, v) in self.G.out_edges(self.G.source)
+                for (u, v) in self.G.out_edges(self.G.source)) if self.sparsity_lambda > 0 else 0
             ) <= (1 + self.different_flow_values_epsilon) * objective_value,
             name="epsilon_constraint",
         )

mkdocs.yml

@@ -39,23 +39,23 @@ theme:
     - media: "(prefers-color-scheme)"
       primary: black
       toggle:
-        icon: material/brightness-auto
+        icon: material/lightbulb-auto
         name: Switch to light mode
 
     # Palette toggle for light mode
     - media: "(prefers-color-scheme: light)"
       primary: black
       scheme: default 
       toggle:
-        icon: material/brightness-7
+        icon: material/lightbulb
         name: Switch to dark mode
 
     # Palette toggle for dark mode
     - media: "(prefers-color-scheme: dark)"
       primary: black
       scheme: slate
       toggle:
-        icon: material/brightness-4
+        icon: material/lightbulb-outline
         name: Switch to system preference
 
   features: