Added new option elements_to_ignore_percentile to kMPE

Author: alexandrutomescu

docs/abstract-path-model.md

@@ -1,4 +1,4 @@
-# Abstract Path Model in DAGs
+# Abstract Path Model in DAGs 
 
 A general approach in developing a model to decompose a weighted graph into weighted paths is to:
 

examples/cycles_demo.py

@@ -5,18 +5,18 @@ def test_min_flow_decomp(filename: str):
     graph = fp.graphutils.read_graphs(filename)[0]
     print("graph id", graph.graph["id"])
     # print("subset_constraints", graph.graph["constraints"])
-    fp.utils.draw(
-            G=graph,
-            filename=filename + ".pdf",
-            flow_attr="flow",
-            subpath_constraints=graph.graph["constraints"],
-            draw_options={
-            "show_graph_edges": True,
-            "show_edge_weights": True,
-            "show_path_weights": False,
-            "show_path_weight_on_first_edge": True,
-            "pathwidth": 2,
-        })
+    # fp.utils.draw(
+    #         G=graph,
+    #         filename=filename + ".pdf",
+    #         flow_attr="flow",
+    #         subpath_constraints=graph.graph["constraints"],
+    #         draw_options={
+    #         "show_graph_edges": True,
+    #         "show_edge_weights": True,
+    #         "show_path_weights": False,
+    #         "show_path_weight_on_first_edge": True,
+    #         "pathwidth": 2,
+    #     })
 
     print(graph.graph["n"], graph.graph["m"], graph.graph["w"])
 
@@ -28,11 +28,11 @@ def test_min_flow_decomp(filename: str):
         optimization_options={
             "optimize_with_safe_sequences": True, # set to false to deactivate the safe sequences optimization
             "optimize_with_safe_sequences_allow_geq_constraints": True,
-            "optimize_with_safe_sequences_fix_via_bounds": False,
+            "optimize_with_safe_sequences_fix_via_bounds": True,
             "optimize_with_safe_sequences_fix_zero_edges": True,
         },
         solver_options={
-            "external_solver": "highs", # we can try also "highs" at some point
+            "external_solver": "gurobi", # we can try also "highs" at some point
             "time_limit": 300, # 300s = 5min, is it ok?
         },
     )
@@ -125,6 +125,26 @@ def test_min_path_error(filename):
     kmpe_percentile_model.solve()
     process_solution(kmpe_percentile_model)
 
+    # here, we use percentile to determine which edges we ignore
+    kmpe_percentile_ignore_model = fp.kMinPathErrorCycles(
+        G=graph,
+        flow_attr="flow",
+        weight_type=int,
+        elements_to_ignore_percentile=25, # we ignore edges whose weight is < 25 percentile
+        subset_constraints=graph.graph["constraints"], # try with and without
+        optimization_options={
+            "optimize_with_safe_sequences": True, # set to false to deactivate the safe sequences optimization
+            "optimize_with_safe_sequences_allow_geq_constraints": False,
+            "optimize_with_safe_sequences_fix_via_bounds": True,
+        },
+        solver_options={
+            "external_solver": "gurobi", # we can try also "highs" at some point
+            "time_limit": 300, # 300s = 5min, is it ok?
+        },
+    )
+    kmpe_percentile_ignore_model.solve()
+    process_solution(kmpe_percentile_ignore_model)
+
 def process_solution(model):
     if model.is_solved():
         solution = model.get_solution()
@@ -154,6 +174,7 @@ def process_solution(model):
 def main():
     test_min_flow_decomp(filename = "tests/cyclic_graphs/gt3.kmer15.(130000.132000).V23.E32.cyc100.graph")
     test_min_flow_decomp(filename = "tests/cyclic_graphs/gt5.kmer27.(1300000.1400000).V809.E1091.mincyc1000.graph")
+    # test_min_flow_decomp(filename = "tests/cyclic_graphs/gt4.kmer15.(0.10000).V1096.E1622.mincyc100.e1.0.graph")
     test_least_abs_errors(filename = "tests/cyclic_graphs/gt5.kmer27.(655000.660000).V18.E27.mincyc4.e0.75.graph")
     test_min_path_error(filename = "tests/cyclic_graphs/gt5.kmer27.(655000.660000).V18.E27.mincyc4.e0.75.graph")
 

flowpaths/kminpatherrorcycles.py

@@ -18,6 +18,7 @@ def __init__(
         subset_constraints: list = [],
         subset_constraints_coverage: float = 1.0,
         elements_to_ignore: list = [],
+        elements_to_ignore_percentile: float = None,
         error_scaling: dict = {},
         additional_starts: list = [],
         additional_ends: list = [],
@@ -77,6 +78,14 @@ def __init__(
             List of edges (or nodes, if `flow_attr_origin` is `"node"`) to ignore when adding constrains on flow explanation by the weighted walks. 
             Default is an empty list. See [ignoring edges documentation](ignoring-edges.md)
 
+        - `elements_to_ignore_percentile: float`, optional
+
+            If provided, ignores elements automatically based on a percentile threshold of their flow values (`flow_attr`).
+            Elements (edges, or nodes if `flow_attr_origin` is `"node"`) whose flow is below this percentile
+            are ignored when enforcing the error constraints. Must be in the range `[0, 100]`.
+            This is mutually exclusive with `elements_to_ignore` (setting both raises a `ValueError`).
+            See [ignoring edges documentation](ignoring-edges.md).
+
         - `error_scaling: dict`, optional
 
             Dictionary `edge: factor` (or `node: factor`, if `flow_attr_origin` is `"node"`)) storing the error scale factor (in [0,1]) of every edge, which scale the allowed difference between edge/node weight and walk weights.
@@ -114,6 +123,8 @@ def __init__(
             - If the flow attribute `flow_attr` is not specified in some edge.
             - If the graph contains edges with negative flow values.
             - ValueError: If `flow_attr_origin` is not "node" or "edge".
+            - If `elements_to_ignore_percentile` is set and is not in `[0, 100]`.
+            - If `elements_to_ignore_percentile` is set together with `elements_to_ignore`.
         """
 
         # Handling node-weighted graphs
@@ -155,6 +166,20 @@ def __init__(
 
         self.G = stdigraph.stDiGraph(self.G_internal, additional_starts=additional_starts_internal, additional_ends=additional_ends_internal)
         self.subset_constraints = subset_constraints_internal
+
+        if elements_to_ignore_percentile is not None:
+            if elements_to_ignore_percentile < 0 or elements_to_ignore_percentile > 100:
+                utils.logger.error(f"{__name__}: elements_to_ignore_percentile must be between 0 and 100, not {elements_to_ignore_percentile}")
+                raise ValueError(f"elements_to_ignore_percentile must be between 0 and 100, not {elements_to_ignore_percentile}")
+            if len(elements_to_ignore) > 0:
+                utils.logger.critical(f"{__name__}: you cannot set elements_to_ignore when elements_to_ignore_percentile is set.")
+                raise ValueError(f"you cannot set elements_to_ignore when elements_to_ignore_percentile is set.")
+
+            # Select edges where the flow_attr value is >= elements_to_ignore_percentile (using self.G)
+            flow_values = [self.G.edges[edge][flow_attr] for edge in self.G.edges() if flow_attr in self.G.edges[edge]]
+            percentile = np.percentile(flow_values, elements_to_ignore_percentile) if flow_values else 0
+            edges_to_ignore_internal = [edge for edge in edges_to_ignore_internal if self.G.edges[edge][flow_attr] < percentile]
+
         self.edges_to_ignore = self.G.source_sink_edges.union(edges_to_ignore_internal)
         self.edge_error_scaling = error_scaling_internal
         # If the error scaling factor is 0, we ignore the edge
@@ -200,6 +225,10 @@ def __init__(
         self.solve_time_start = time.perf_counter()
 
         if trusted_edges_for_safety_percentile is not None:
+            if trusted_edges_for_safety_percentile < 0 or trusted_edges_for_safety_percentile > 100:
+                utils.logger.error(f"{__name__}: trusted_edges_for_safety_percentile must be between 0 and 100.")
+                raise ValueError(f"trusted_edges_for_safety_percentile must be between 0 and 100.")
+
             # Select edges where the flow_attr value is >= trusted_edges_for_safety_percentile (using self.G)
             flow_values = [self.G.edges[edge][flow_attr] for edge in self.G.edges() if flow_attr in self.G.edges[edge]]
             percentile = np.percentile(flow_values, trusted_edges_for_safety_percentile) if flow_values else 0