Removed main.cpp; changed naming and made performance testing work with current code

Author: kierannp

genGrouper/main.cpp

@@ -2,59 +2,88 @@
 import typing as t
 from copy import deepcopy
 
-def multi_to_pair(multi: int, max_multi: int) -> t.Tuple[int, int]:
-    """
-    Convert a linear index `multi` to 2D coordinates (x, y) within a square grid.
-
-    Parameters:
-    - multi (int): Linear index to be converted.
-    - max_multi (int): Maximum allowed value for the linear index.
-
-    Returns:
-    - Tuple[int, int]: Two-dimensional coordinates (x, y) within the grid.
-    """
-    if 1 <= multi <= max_multi:
-        # Calculate x and y values based on the input multi
-        x = (multi - 1) % int(max_multi**.5) + 1
-        y = (multi - 1) // int(max_multi**.5) + 1
-
-        x, y = x-1, y-1 # convert to 0-indexed
-        return x, y
-    else:
-        raise ValueError("Input multi must be in the range 1 to max_multi.")
-    
-
 def run_performance_eval(
-        nauty_path: str = "/Users/kieran/projects/genGrouper/packages/nauty2_8_8", 
+        nauty_path: str = "/Users/kieran/projects/molGrouper/packages/nauty2_8_8", 
+        node_defs = None,
         n_runs: int = 3, 
         max_nodes: int = 6,
-        max_ports: int = 4,
-        n_colors: int = 3,
         verbose: bool = False
 ):
     """
     Run performance evaluation of the genGrouper generation featrure with growing sized graphs.
     """
     import os
     import time
-    from genGrouper.edge_coloring import process_nauty_vcolg_output
+    from genGrouper import exhaustive_generate
     import random
+    import itertools
+
+    if node_defs is None:
+        raise ValueError("node_defs must be provided.")
+    
+    # Time the performance of the generation algorithm
+    performance = {combo : { n:[] for n in range(1, max_nodes + 1)} for combo in itertools.combinations(node_defs, len(node_defs) - 1)}
+    for def_combo in performance:
+        for n_nodes in range(1, max_nodes + 1):
+            total_time = 0
+            for i in range(n_runs):
+                random.seed(0)
+                start_time = time.time()
+                space = exhaustive_generate(
+                    n_nodes, 
+                    set(def_combo), 
+                    nauty_path=nauty_path,
+                    input_file_path="",
+                    num_procs=16,
+                    verbose=verbose)
+                end_time = time.time()
+                total_time += end_time - start_time
+                performance[def_combo][n_nodes].append(total_time)
+            print(f"Number of generated graphs: {len(space)}")
+            print("")
+    # plot_performance(performance, max_nodes)
+    return performance
+    
+def plot_performance(performance, max_nodes):
+    import matplotlib.pyplot as plt
+    import numpy as np
+    import itertools
+
+    # Prepare data for the plot
+    fig, ax = plt.subplots()
+    
+    # Use a single colormap
+    cmap = plt.get_cmap('inferno')
+    norm = plt.Normalize()
+
+    # Iterate through the performance data to plot
+    for i, combo in enumerate(performance):
+        for n_nodes in performance[combo]:
+            times = performance[combo][n_nodes]
+            mean_time = np.mean(times)
+            color = cmap(norm(mean_time))
+
+            ax.scatter(
+                n_nodes, 
+                i, 
+                c=color
+            )
+
+    ax.set_xlabel("Number of nodes")
+    ax.set_ylabel("Node type combination")
+    
+    # Adjust y-axis labels to display the node combinations
+    ax.set_yticks(range(len(performance)))
+    ax.set_yticklabels([str(combo) for combo in performance])
+
+    # Add the color bar
+    sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
+    sm.set_array([])  # Only needed for the color bar
+    plt.colorbar(sm, ax=ax, label='Mean Time (s)')
+
+    plt.savefig("performance.png")
+
 
-    max_nodes = list(range(2, max_nodes))
-    generate_random_ports = lambda max_ports: [str(i) for i in range(random.randint(1, max_ports))]
-    node_types = {chr(i+65): generate_random_ports(max_ports) for i in range(n_colors)}
-
-    for n in max_nodes:
-        total_time = 0
-        for i in range(n_runs):
-            os.system(f"{nauty_path}/geng {n} -ctf > /Users/kieran/projects/genGrouper/geng_out.txt")
-            os.system(f"{nauty_path}/vcolg /Users/kieran/projects/genGrouper/geng_out.txt -T -m{n_colors} > vcolg_out.txt")
-            # time the edge_coloring.py
-            start = time.time()
-            out = process_nauty_vcolg_output('/Users/kieran/projects/genGrouper/vcolg_out.txt', node_types, verbose=False)
-            end = time.time()
-            total_time += end - start
-        print(f"Average time for {n} nodes: {total_time/n_runs}")
 
 def convert_edges_to_nodetype(G):
     new_G = deepcopy(G)
@@ -71,3 +100,26 @@ def convert_edges_to_nodetype(G):
             new_G.edges[edge]['ports'][i] = (f'{srcnode_type}.{srcport}', f'{dstnode_type}.{dstport}')
 
     return new_G
+
+
+def multi_to_pair(multi: int, max_multi: int) -> t.Tuple[int, int]:
+    """
+    Convert a linear index `multi` to 2D coordinates (x, y) within a square grid.
+
+    Parameters:
+    - multi (int): Linear index to be converted.
+    - max_multi (int): Maximum allowed value for the linear index.
+
+    Returns:
+    - Tuple[int, int]: Two-dimensional coordinates (x, y) within the grid.
+    """
+    if 1 <= multi <= max_multi:
+        # Calculate x and y values based on the input multi
+        x = (multi - 1) % int(max_multi**.5) + 1
+        y = (multi - 1) // int(max_multi**.5) + 1
+
+        x, y = x-1, y-1 # convert to 0-indexed
+        return x, y
+    else:
+        raise ValueError("Input multi must be in the range 1 to max_multi.")
+    

genGrouper/utils.py

@@ -0,0 +1,19 @@
+from genGrouper.utils import run_performance_eval
+from genGrouper import Node
+
+
+node_defs = set()
+node_defs.add(Node(0, 'benzene', 'C1=CC=CC=C1', [0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]))
+node_defs.add(Node(0, 'hydroxyl', 'O', [0], [0]))
+node_defs.add(Node(0, 'secondary_amine', 'N', [0,1], [0,0]))
+node_defs.add(Node(0, 'tertiary_amine', 'N', [0,1,2], [0,0,0]))
+node_defs.add(Node(0, 'alkene', 'C=C', [0], [0]))
+node_defs.add(Node(0, 'ester', 'C(=O)O', [0,1], [0,2]))
+
+run_performance_eval(
+    nauty_path="/raid6/homes/kierannp/projects/molGrouper/packages/nauty2_8_8",
+    node_defs=node_defs,
+    n_runs=3,
+    max_nodes=4,
+    verbose=False
+)

performance_testing.py

@@ -3,7 +3,7 @@
 #SBATCH --mail-type=end
 #SBATCH --error=error-%J.err
 #SBATCH --output=output-%J.out
-#SBATCH --job-name=cpu_gen
+#SBATCH --job-name=genGrouper
 #SBATCH --nodes=1
 #SBATCH --time=24:00:00
 #SBATCH --partition=day-long-std
@@ -13,14 +13,8 @@
 
 source /raid6/homes/kierannp/.bashrc
 module load anaconda/3.9
-conda activate molGPU
+conda activate pureGrouper
 
-cd /raid6/homes/kierannp/foo/gpufoo/genGrouper/genGrouper/cpp_code/rdkit_cpu
-
-rm -rf build
-mkdir build
-cd build
-cmake ..
-make
-./lineProcessor
+RUN_DIR=
 
+python run_exhaustive_generation.py