Merge pull request #71 from jcrozum/stubs

Lazy succession diagram

.github/workflows/test.yml

@@ -4,10 +4,30 @@ on:
   pull_request:
 
 jobs:
-  linux:
+  # First, check if the types/formatting is correct.
+  types:
     # TODO: Later we can add more python versions but for now one should be enough.
     runs-on: ubuntu-latest
     timeout-minutes: 30
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Install Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: 3.11
+          architecture: x64
+      - name: Install repo dependencies
+        run: pip install -r requirements.txt
+      - name: Install mypy
+        run: pip install mypy
+      - name: Run mypy check
+        run: mypy nfvsmotifs
+  # Then do a "small" test run with code coverage.
+  coverage:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    needs: types
     steps:
       - name: Checkout
         uses: actions/checkout@v3
@@ -30,23 +50,43 @@ jobs:
           (cd ./mole-140428 && pwd >> $GITHUB_PATH)
       - name: Install repo dependencies
         run: pip install -r requirements.txt
-      - name: Install mypy
-        run: pip install mypy
-      - name: Run mypy check
-        run: mypy nfvsmotifs
       - name: Install pytest
         run: pip install pytest pytest-cov      
-      # Correctness is tested on larger networks, while for coverage, we use
-      # a smaller subset, since it should not have a significant impact on it.
-      - name: Run pytest (without coverage)
-        run: python3 -m pytest --networksize 50 tests/
-      # The reason why we have to run pytest twice is that saving the coverage report will erase
-      # the exit code and so the workflow would succeed even if there are failing tests.
-      # (this could be of course solved using the magic of unix, but for now, this is simpler)
-      - name: Run pytest again with coverage
+      - name: Run pytest with coverage
         run: python3 -m pytest --networksize 20 --junitxml=pytest.xml --cov-report=term-missing:skip-covered --cov=nfvsmotifs tests/ | tee pytest-coverage.txt
       - name: Pytest coverage comment
         uses: MishaKav/pytest-coverage-comment@main
         with:
           pytest-coverage-path: ./pytest-coverage.txt
           junitxml-path: ./pytest.xml
+  # Then do a full test for correctness using larger networks.
+  tests:
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    needs: [types, coverage]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Install clingo
+        run: sudo apt-get -y install gringo
+      - name: Install Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: 3.11
+          architecture: x64
+      - name: Fetch and install native Pint
+        run: | 
+          wget https://github.com/pauleve/pint/releases/download//2019-05-24/pint_2019-05-24_amd64.deb
+          sudo apt install ./pint_2019-05-24_amd64.deb
+      - name: Fetch and install Mole
+        run: | 
+          wget http://www.lsv.fr/~schwoon/tools/mole/mole-140428.tar.gz
+          tar -xvf mole-140428.tar.gz
+          (cd ./mole-140428 && make)
+          (cd ./mole-140428 && pwd >> $GITHUB_PATH)
+      - name: Install repo dependencies
+        run: pip install -r requirements.txt
+      - name: Install pytest
+        run: pip install pytest
+      - name: Run pytest (without coverage)
+        run: python3 -m pytest --networksize 50 tests/

benchmark/README.md

@@ -0,0 +1,31 @@
+# Benchmarking
+
+This folder contains several scripts useful for benchmarking. 
+All `bench_*` scripts solve one "benchmark problem" for a single given network file.
+The last line of output of such computation is always a comma-separated list of values with relevant results.
+You can then use `run_bench.py` to execute such benchmark script for all networks in a folder.
+This will collect the full output of each script, as well as create an agggregate result table.
+Each row of such table contains the network name, runtime of the whole script, and its output.
+
+## Install `nfvsmotifs`
+
+The benchmark scripts assume `nfvsmotifs` is installed as a package. 
+To do this, go to the repository root and run `pip install .` 
+(this step reqires at least `pip` version `23`).
+
+## Example
+
+For example, to test how long it takes to generate the succession diagram for minimal trap spaces,
+you can use the following:
+
+```
+# 1h - timeout
+# ../bbm-bnet-inputs-true - folder with networks
+# bench_sd_expand_min.py - benchmark script
+python3 run_bench.py 1h ../bbm-bnet-inputs-true bench_sd_expand_min.py
+```
+
+You can optionally add `-p X` or `-i` flag at the end of the argument list. 
+The `-p` flag causes the benchmark to run in parallel in `X` processes.
+The `-i` flag causes the benchmark to run in "interactive" mode where the user can skip
+individual benchmarks.

benchmark/bench_aeon_attractors.py

@@ -0,0 +1,24 @@
+from biodivine_aeon import BooleanNetwork, SymbolicAsyncGraph, find_attractors
+import sys
+
+# This is a very basic script for running attractor detection usin AEON.
+# The results should be comparable to `bench_attractor_search`.
+#
+# The script only takes one argument: a path to the network file.
+
+bn = BooleanNetwork.from_file(sys.argv[1])
+bn = bn.infer_regulatory_graph()
+
+stg = SymbolicAsyncGraph(bn)
+
+attr = find_attractors(stg)
+
+print("Attractors:", len(attr))
+
+attr_states = stg.empty_colored_vertices()
+
+for a in attr:
+    attr_states = attr_states.union(a)
+
+print("attractors, attractor-states")
+print(f"{len(attr)},{attr_states.cardinality()}")

benchmark/bench_sd_attractors_full.py

@@ -0,0 +1,33 @@
+from biodivine_aeon import BooleanNetwork
+from nfvsmotifs.SuccessionDiagram import SuccessionDiagram
+import sys
+import nfvsmotifs
+
+# Print progress and succession diagram size.
+nfvsmotifs.SuccessionDiagram.DEBUG = True
+
+NODE_LIMIT = 1_000_000
+DEPTH_LIMIT = 10_000
+
+# This is unfortunately necessary for PyEDA Boolean expression parser (for now).
+sys.setrecursionlimit(150000)
+
+bn = BooleanNetwork.from_file(sys.argv[1])
+bn = bn.infer_regulatory_graph()
+
+# Compute the succession diagram.
+sd = SuccessionDiagram(bn)
+fully_expanded = sd.expand_bfs(bfs_level_limit=DEPTH_LIMIT, size_limit=NODE_LIMIT)
+assert fully_expanded
+
+attractor_count = 0
+motif_avoidant_count = 0
+
+for node in sd.node_ids():
+    attr = sd.node_attractor_seeds(node, compute=True)
+    attractor_count += len(attr)
+    if not sd.node_is_minimal(node):
+        motif_avoidant_count += len(attr)
+
+print("nodes, attractors, motif-avoidant")
+print(f"{len(sd)}, {attractor_count}, {motif_avoidant_count}")

benchmark/bench_sd_attractors_minimal.py

@@ -0,0 +1,35 @@
+from biodivine_aeon import BooleanNetwork
+from nfvsmotifs.SuccessionDiagram import SuccessionDiagram
+import sys
+import nfvsmotifs
+
+# Print progress and succession diagram size.
+nfvsmotifs.SuccessionDiagram.DEBUG = True
+
+NODE_LIMIT = 1_000_000
+
+# This is unfortunately necessary for PyEDA Boolean expression parser (for now).
+sys.setrecursionlimit(150000)
+
+bn = BooleanNetwork.from_file(sys.argv[1])
+bn = bn.infer_regulatory_graph()
+
+# Compute the succession diagram.
+sd = SuccessionDiagram(bn)
+fully_expanded = sd.expand_minimal_spaces(size_limit=NODE_LIMIT)
+assert fully_expanded
+
+attractor_count = 0
+motif_avoidant_count = 0
+
+# Note that this can contain some motif-avoidant attractors
+# multiple times. But we haven't seen motif-avoidant attractors
+# in real-world networks so far...
+for node in sd.node_ids():
+    attr = sd.node_attractor_seeds(node, compute=True)
+    attractor_count += len(attr)
+    if not sd.node_is_minimal(node):
+        motif_avoidant_count += len(attr)
+
+print("nodes, expanded, attractors, motif-avoidant")
+print(f"{len(sd)}, {len(list(sd.expanded_ids()))}, {attractor_count}, {motif_avoidant_count}")

benchmark/bench_sd_attractors_simplified.py

@@ -0,0 +1,32 @@
+from biodivine_aeon import BooleanNetwork
+from nfvsmotifs.SuccessionDiagram import SuccessionDiagram
+import sys
+import nfvsmotifs
+
+# Print progress and succession diagram size.
+nfvsmotifs.SuccessionDiagram.DEBUG = True
+
+NODE_LIMIT = 1_000_000
+
+# This is unfortunately necessary for PyEDA Boolean expression parser (for now).
+sys.setrecursionlimit(150000)
+
+bn = BooleanNetwork.from_file(sys.argv[1])
+bn = bn.infer_regulatory_graph()
+
+# Compute the succession diagram.
+sd = SuccessionDiagram(bn)
+fully_expanded = sd.expand_attractor_seeds(size_limit=NODE_LIMIT)
+assert fully_expanded
+
+attractor_count = 0
+motif_avoidant_count = 0
+
+for node in sd.expanded_ids():
+    attr = sd.node_attractor_seeds(node, compute=True)
+    attractor_count += len(attr)
+    if not sd.node_is_minimal(node):
+        motif_avoidant_count += len(attr)
+
+print("nodes, expanded, attractors, motif-avoidant")
+print(f"{len(sd)}, {len(list(sd.expanded_ids()))}, {attractor_count}, {motif_avoidant_count}")

benchmark/bench_sd_expand_bfs.py

@@ -0,0 +1,27 @@
+from biodivine_aeon import BooleanNetwork
+from nfvsmotifs.SuccessionDiagram import SuccessionDiagram
+import sys
+import nfvsmotifs
+
+# Print progress and succession diagram size.
+nfvsmotifs.SuccessionDiagram.DEBUG = True
+
+NODE_LIMIT = 1_000_000
+DEPTH_LIMIT = 10_000
+
+# This is unfortunately necessary for PyEDA Boolean expression parser (for now).
+sys.setrecursionlimit(150000)
+
+bn = BooleanNetwork.from_file(sys.argv[1])
+bn = bn.infer_regulatory_graph()
+
+# Compute the succession diagram.
+sd = SuccessionDiagram(bn)
+fully_expanded = sd.expand_bfs(bfs_level_limit=DEPTH_LIMIT, size_limit=NODE_LIMIT)
+assert fully_expanded
+
+print(f"Succession diagram size:", len(sd))
+print(f"Minimal traps:", len(sd.minimal_trap_spaces()))
+
+print("size, expanded, minimal")
+print(f"{len(sd)},{len(list(sd.expanded_ids()))},{len(sd.minimal_trap_spaces())}")

benchmark/bench_sd_expand_dfs.py

@@ -0,0 +1,27 @@
+from biodivine_aeon import BooleanNetwork
+from nfvsmotifs.SuccessionDiagram import SuccessionDiagram
+import sys
+import nfvsmotifs
+
+# Print progress and succession diagram size.
+nfvsmotifs.SuccessionDiagram.DEBUG = True
+
+NODE_LIMIT = 1_000_000
+DEPTH_LIMIT = 10_000
+
+# This is unfortunately necessary for PyEDA Boolean expression parser (for now).
+sys.setrecursionlimit(150000)
+
+bn = BooleanNetwork.from_file(sys.argv[1])
+bn = bn.infer_regulatory_graph()
+
+# Compute the succession diagram.
+sd = SuccessionDiagram(bn)
+fully_expanded = sd.expand_dfs(dfs_stack_limit=DEPTH_LIMIT, size_limit=NODE_LIMIT)
+assert fully_expanded
+
+print(f"Succession diagram size:", len(sd))
+print(f"Minimal traps:", len(sd.minimal_trap_spaces()))
+
+print("size, expanded, minimal")
+print(f"{len(sd)},{len(list(sd.expanded_ids()))},{len(sd.minimal_trap_spaces())}")

bench_sd_construction.py → benchmark/bench_sd_expand_min.py

@@ -17,6 +17,10 @@
 
 # Compute the succession diagram.
 sd = SuccessionDiagram(bn)
-expanded = sd.expand_node(sd.root(), depth_limit=DEPTH_LIMIT, node_limit=NODE_LIMIT)
+sd.expand_minimal_spaces()
 
-print(f"Succession diagram size:", expanded)
+print(f"Succession diagram size:", len(sd))
+print(f"Minimal traps:", len(sd.minimal_trap_spaces()))
+
+print("size, expanded, minimal")
+print(f"{len(sd)}, {len(list(sd.expanded_ids()))}, {len(sd.minimal_trap_spaces())}")

benchmark/bench_trappist_min.py

@@ -0,0 +1,28 @@
+from biodivine_aeon import BooleanNetwork
+from nfvsmotifs.trappist_core import trappist_async
+import sys
+
+# A simple script to benchmark minimal trap space detection using trappist.
+# The output should be comparable to the output of `bench_sd_construction.py`
+# in terms of minimal trap spaces.
+#
+# There is only one command line argument: a path to the network file.
+
+sys.setrecursionlimit(150000)
+
+bn = BooleanNetwork.from_file(sys.argv[1])
+bn = bn.infer_regulatory_graph()
+
+COUNT = 0
+
+def count_all(x):
+    global COUNT
+    COUNT += 1
+    return True
+
+trappist_async(bn, on_solution=count_all, problem="min")
+
+print("Minimal traps:", COUNT)
+
+print("traps")
+print(f"{COUNT}")