fix: added heapsort implementation

Author: jjordanoc

experiment.py

@@ -0,0 +1,41 @@
+import os
+import random
+
+from rtree_query_manager import RTreeQueryManager
+from sequential_query_manager import *
+from highd_query_manager import *
+import pickle
+
+
+def print_result(result):
+    for i in result:
+        for j in i:
+            print(j)
+    print("\n\n")
+
+
+def main() -> None:
+    with open("out.embeds", mode="rb") as collection_file:
+        collection = pickle.load(collection_file)
+    k = 8
+    for n in [100*(2**p) for p in range(0, 1)]:
+        print("=" * 60)
+        print(f"Extracting random sample of size {n}")
+        sample = random.sample(collection, n)
+        print("Building managers")
+        sequential_query_manager = SequentialQueryManager(collection=sample)
+        rtree_query_manager = RTreeQueryManager(collection=sample, m=3)
+        high_d_query_manager = HighDQueryManager(collection=sample, num_bits=2000)
+        print()
+        query = os.path.join(os.getcwd(), "lfw/Adam_Sandler/Adam_Sandler_0002.jpg")
+        print("Sequential query")
+        print_result(sequential_query_manager.knn_query(q=query, k=k))
+        print("RTree query")
+        print_result(rtree_query_manager.knn_query(q=query, k=k))
+        print("LSH query")
+        print_result(high_d_query_manager.knn_query(q=query, k=k))
+        print()
+
+
+if __name__ == "__main__":
+    main()

heap.py

@@ -16,6 +16,9 @@ def __lt__(self, other) -> bool:
     def __eq__(self, other) -> bool:
         return self.val == other.val
 
+    def __repr__(self) -> str:
+        return str(self.val)
+
 
 class MaxHeap(Generic[T]):
 
@@ -38,5 +41,11 @@ def empty(self):
     def size(self) -> int:
         return len(self.heap)
 
-    def top(self):
+    def top(self) -> T:
         return self.heap[0].val
+
+    def heapsort(self) -> List[T]:
+
+        result = [self.pop() for i in range(len(self.heap))]
+        result.reverse()
+        return result

highd_query_manager.py

@@ -6,6 +6,7 @@
 
 
 class HighDQueryManager:
+    @measure_execution_time
     def __init__(self, num_bits: int, collection: List[Tuple[str, np.ndarray]]) -> None:
         self.collection = collection
 

sequential_query_manager.py

@@ -8,6 +8,7 @@
 
 class SequentialQueryManager:
 
+    @measure_execution_time
     def __init__(self, collection: List[Tuple[str, np.ndarray]]) -> None:
         self.collection = collection
 
@@ -47,27 +48,23 @@ def __gt__(self, other):
             def __eq__(self, other):
                 return self.dist == other.dist
 
+            def __repr__(self) -> str:
+                return str((self.file_name, self.dist))
+
         # process face of query path file
         image = face_recognition.load_image_file(q)
         query = face_recognition.face_encodings(image)
 
         result: List[List[Tuple[str, float]]] = []
 
         for face_embed in query:
-            result_tmp = MaxHeap[DistWrapper]()
+            result_heap = MaxHeap[DistWrapper]()
             for c in self.collection:
                 dist: float = np.linalg.norm(c[1] - face_embed)
-                if result_tmp.size() < k:
-                    result_tmp.push(DistWrapper(d=dist, embed=c[1], file_name=c[0]))
-                elif result_tmp.top().dist > dist:
-                    result_tmp.pop()
-                    result_tmp.push(DistWrapper(d=dist, embed=c[1], file_name=c[0]))
-            result_tmp2: List[Tuple[str, float]] = []
-
-            while result_tmp.size() != 0:
-                result_tmp2.append((result_tmp.top().file_name, result_tmp.top().dist))
-                result_tmp.pop()
-            result_tmp2 = sorted(result_tmp2, key=lambda x: x[1], reverse=False)
-            result.append(result_tmp2)
-
+                if result_heap.size() < k:
+                    result_heap.push(DistWrapper(d=dist, embed=c[1], file_name=c[0]))
+                elif result_heap.top().dist > dist:
+                    result_heap.pop()
+                    result_heap.push(DistWrapper(d=dist, embed=c[1], file_name=c[0]))
+            result.append([(wrapper.file_name, wrapper.dist) for wrapper in result_heap.heapsort()])
         return result