Merge branch 'python-better-embeddings' into develop

(This also adds the "selection chances" result script)

Author: Splines

.gitignore

@@ -7,6 +7,8 @@ external/lemon.tar.gz
 
 # Python
 __pycache__
+out/
+logs/
 
 # Prerequisites
 *.d

python/src/drawing/draw.py

@@ -7,6 +7,12 @@
 
 class DrawEmbedding():
 
+    def init_figure(self):
+        self.fig = plt.figure()
+        plt.subplots_adjust(left=0.0, right=1.0,
+                            bottom=0.0, top=1.0,
+                            wspace=0.1, hspace=0.1)
+
     def __init__(self, m, n, t):
         self.total_steps = 0
 
@@ -22,13 +28,9 @@ def __init__(self, m, n, t):
         self.px = 1/plt.rcParams['figure.dpi']  # pixel in inches
         plt.rcParams.update({'axes.titlesize': 24})
 
-        # Init figure
-        self.fig = plt.figure()
-        plt.subplots_adjust(left=0.0, right=1.0,
-                            bottom=0.0, top=1.0,
-                            wspace=0.1, hspace=0.1)
-
         self.col = 0
+        self.m = m
+        self.n = n
 
         self.init_chimera_graph(m, n, t)
 
@@ -49,7 +51,7 @@ def draw_chimera_graph(self):
 
         # Labels
         # Shift labels
-        pos_labels = {node: [pos[0] - 0.025, pos[1]]
+        pos_labels = {node: [pos[0] - 0.020, pos[1]]
                       for (node, pos) in self.pos_chimera.items()}
         nx.draw_networkx_labels(self.chimera_G,
                                 pos=pos_labels,
@@ -143,31 +145,31 @@ def show_embedding(self):
 
     def draw_whole_embedding_step(self, nodes: set[int], edges: set[tuple[int, int, int]],
                                   mapping_G_to_H, title=''):
-        ax = self.construct_subplot_to_the_right()
-        ax.set_title(title)
+        self.init_figure()
+        self.fig.suptitle(title, fontsize=20)
         self.draw_chimera_and_embedding(nodes, edges, mapping_G_to_H)
         self.total_steps += 1
 
-    def construct_subplot_to_the_right(self) -> Axes:
-        """Constructs a new subplot to the right."""
-        self.col += 1
-        gs = gridspec.GridSpec(1, self.col)
+    # def construct_subplot_to_the_right(self) -> Axes:
+    #     """Constructs a new subplot to the right."""
+    #     self.col += 1
+    #     gs = gridspec.GridSpec(1, self.col)
 
-        # Reposition subplots
-        for i, ax in enumerate(self.fig.axes):
-            # ax.set_position(gs[i, 0].get_position(self.fig))
-            ax.set_subplotspec(gs[0, i])
+    #     # Reposition subplots
+    #     for i, ax in enumerate(self.fig.axes):
+    #         # ax.set_position(gs[i, 0].get_position(self.fig))
+    #         ax.set_subplotspec(gs[0, i])
 
-        # Add new subplot
-        ax = self.fig.add_subplot(gs[0, self.col-1])
-        ax.set_position(gs[0, self.col-1].get_position(self.fig))
+    #     # Add new subplot
+    #     ax = self.fig.add_subplot(gs[0, self.col-1])
+    #     ax.set_position(gs[0, self.col-1].get_position(self.fig))
 
-        return ax
+    #     return ax
 
     def save_and_clear(self, path):
-        self.fig.set_size_inches(self.total_steps*1000*self.px, 800*self.px)
+        self.fig.set_size_inches(self.m*3, self.n*3)
         self.fig.savefig(path, bbox_inches='tight')
-        plt.clf()
+        plt.close(self.fig)
 
 
 def change_brightness(color, amount=1):

python/src/embedding/embedding.py

@@ -39,7 +39,10 @@ def get_embedded_nodes(self) -> set[int]:
         Returns:
             set[int]: The embedded nodes.
         """
-        return self.G_embedding.get_embedded_nodes()
+        embedded_nodes = self.G_embedding.get_embedded_nodes()
+        if not embedded_nodes:
+            raise Exception('No nodes embedded yet')
+        return embedded_nodes
 
     def get_reachable_neighbors(self, source):
         return self.G_layout.get_neighbor_nodes(source)
@@ -153,6 +156,36 @@ def get_mapping_G_to_H(self):
     def get_nodes_G(self, node_H: int) -> set[int]:
         return self.mapping.get_nodes_G(node_H)
 
+    def get_nodes_H(self) -> set[int]:
+        return self.H.get_nodes()
+
+    def get_supernode_degree_percentages(self) -> dict[int, float]:
+        """Returns a dictionary of percentages for each supernode indicating
+        how many edges between supernodes are currently embedded in G compared
+        to how many should be as specified in the input graph H."""
+        degree_percentages = {}
+        for source_H in self.H.get_nodes():
+            expected_degree = len(self.H.get_neighbor_nodes(source_H))
+            actual_degree = len(self.G_embedding_view.get_neighbor_nodes(source_H))
+            degree_percentages[source_H] = actual_degree / expected_degree
+        return degree_percentages
+
+    def _get_supernode_sizes(self) -> dict[int, int]:
+        supernode_sizes = {}
+        for source_H in self.H.get_nodes():
+            supernode_nodes = self.get_nodes_in_supernode(source_H)
+            supernode_sizes[source_H] = len(supernode_nodes)
+        return supernode_sizes
+
+    def get_sorted_supernodes_by_size(self) -> list[int]:
+        """Returns a list of sorted supernode keys according to their size
+        (how many nodes in the hardware graph they map onto).
+        """
+        supernode_sizes = self._get_supernode_sizes()
+        # sort according to value (supernode size)
+        sorted_entries = sorted(supernode_sizes.items(), key=lambda item: item[1])
+        return [entry[0] for entry in sorted_entries]
+
     def try_embed_missing_edges(self) -> int:
         """Tries to embed missing edges if possible.
 
@@ -191,10 +224,15 @@ def try_embed_missing_edges(self) -> int:
 
         return len(missing_edges_added)
 
+    def remove_redundancy(self) -> None:
+        self.remove_redundant_supernode_nodes()
+        self.remove_unnecessary_edges_between_supernodes()
+
     def remove_unnecessary_edges_between_supernodes(self) -> None:
         """Tries to remove unnecessary edges, e.g. multiple edges between
         two supernodes.
         """
+        logger.info('Remove unnecessary edges between supernodes')
         # For every supernode (chain)
         for supernode in self.H.get_nodes():
             considered_supernodes = []
@@ -221,6 +259,7 @@ def remove_unnecessary_edges_between_supernodes(self) -> None:
                         # this must be preserved by this method
 
     def remove_redundant_supernode_nodes(self):
+        logger.info('Removing redundant supernode nodes')
         for supernode in self.H.get_nodes():
             self.remove_redundant_nodes_in_supernode(supernode)
 
@@ -231,7 +270,6 @@ def remove_redundant_nodes_in_supernode(self, supernode) -> None:
             return
 
         removed_nodes = set()
-
         while True:
             removed_in_this_iteration = False
 

python/src/results/chances.txt

@@ -0,0 +1,5 @@
+[0.04 0.   0.04 0.25 0.   0.25 0.04 0.08 0.08 0.04 0.08 0.08]
+[0.07 0.08 0.08 0.11 0.1  0.12 0.05 0.03 0.08 0.02 0.14 0.12]
+
+[0.5 0.  0.  0.  0.  0.5 0.  0.  0.  0.  0.  0. ]
+[0.06 0.01 0.1  0.07 0.   0.08 0.13 0.16 0.15 0.03 0.12 0.09]

python/src/results/selection_chances.py

@@ -0,0 +1,36 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+with open('./chances.txt', 'r') as f:
+    line1 = f.readline()
+    line2 = f.readline()
+    p1 = np.fromstring(line1[1:-1], sep=' ')
+    p2 = np.fromstring(line2[1:-1], sep=' ')
+    x = np.arange(len(p1))
+
+
+width = 0.35  # the width of the bars
+fig, ax = plt.subplots(figsize=(14, 11))
+rects1 = ax.bar(x - width/2, p1, width, label='without increase')
+rects2 = ax.bar(x + width/2, p2, width, label='with increase for small supernodes')
+
+ax.set_xticks(x, x)
+ax.legend()
+ax.set_ylim(0, 0.2)
+
+ax.bar_label(rects1, padding=3)
+ax.bar_label(rects2, padding=3)
+# fig.tight_layout()
+plt.xlabel('Supernode')
+plt.ylabel('Chance of selecting the supernode')
+plt.title('Selection chances')
+plt.show()
+
+# plt.ylim(0, 0.2)
+# plt.plot(x, p1, marker='o', linestyle='--', label='without increase')
+# plt.plot(x, p2, marker='o', linestyle='--', label='with increase for small supernodes')
+# plt.xlabel('Supernodes')
+# plt.ylabel('Chance of selecting a supernode')
+# plt.title('Selection chances')
+# plt.legend()
+# plt.show()