Get numpy imaging application working

weiya711 · weiya711 · commit 8e35bcf60e51 · 2021-04-01T15:57:44.000-07:00
diff --git a/numpy/image.py b/numpy/image.py
@@ -3,76 +3,119 @@
 import os
 import pytest
 import matplotlib.pyplot as plt 
+import sparse
+from util import ImagePydataSparseTensorLoader, safeCastPydataTensorToInts, plot_image
+
+
+
+@pytest.mark.parametrize("num", list(range(1, 99))) 
+@pytest.mark.parametrize("pt1", [0.5])
+def bench_edge_detection_pydata(tacoBench, num, pt1, plot):
+        loader = ImagePydataSparseTensorLoader()
+        sparse_bin_img1 = safeCastPydataTensorToInts(loader.sparse_image(num, pt1, 1))
+        sparse_bin_img2 = safeCastPydataTensorToInts(loader.sparse_image(num, pt1+0.05, 2))
+        bin_img1 = loader.dense_image(num, pt1, 1) 
+        bin_img2 = loader.dense_image(num, pt1 + 0.05, 2)
+        if plot:
+            print(sparse_bin_img1.shape)
+            print(sparse_bin_img2.shape)
+
+        def sparse_bench():
+            sparse_xor_img = np.logical_xor(sparse_bin_img1, sparse_bin_img2).astype('int')
+            return sparse_xor_img
+
+        def dense_bench():
+            xor_img = np.logical_xor(bin_img1, bin_img2).astype('int')
+            return xor_img
+        ret = tacoBench(sparse_bench)
+        sparse_xor_img = sparse_bench()
+        xor_img = dense_bench()
+        
+        assert(sparse_xor_img.nnz == np.sum(xor_img != 0))
+
+        if plot:
+            num_elements = float(np.prod(bin_img1.shape))
+            print("Sparse xor NNZ = ", sparse_xor_img.nnz, "\t", "Dense xor NNZ = ", np.sum(xor_img != 0))
+            print("Sparsity img 1 ", np.sum(bin_img1 != 0) / num_elements)
+            print("Sparsity img 2 ", np.sum(bin_img2 != 0) / num_elements)
+            print("Sparsity xor ", np.sum(xor_img != 0) / num_elements)
+            sparse_xor_img = sparse_xor_img.todense()
+            t1 = round(loader.max[num]*pt1, 2)
+            t2 = round(loader.max[num]*(pt1 + 0.05), 2)
+            plot_image(loader.img[num], bin_img1, bin_img2, xor_img, sparse_xor_img, t1, t2)
+
+@pytest.mark.parametrize("num", list(range(1, 99))) 
+@pytest.mark.parametrize("pt1", [0.5])
+def bench_edge_detection_dense(tacoBench, num, pt1):
+        loader = ImagePydataSparseTensorLoader()
+        bin_img1 = loader.dense_image(num, pt1, 1) 
+        bin_img2 = loader.dense_image(num, pt1 + 0.05, 2)
+
+        def dense_bench():
+            xor_img = np.logical_xor(bin_img1, bin_img2).astype('int')
+            return xor_img
+        tacoBench(dense_bench)
+
+@pytest.mark.parametrize("num", list(range(1, 99))) 
+@pytest.mark.parametrize("pt1", [0.5])
+def bench_edge_detection_fused_pydata(tacoBench, num, pt1, plot):
+        loader = ImagePydataSparseTensorLoader()
+        sparse_bin_img1 = safeCastPydataTensorToInts(loader.sparse_image(num, pt1, 1))
+        sparse_bin_img2 = safeCastPydataTensorToInts(loader.sparse_image(num, pt1+0.05, 2))
+        sparse_bin_window = loader.sparse_window(num, 3)
+        bin_img1 = loader.dense_image(num, pt1, 1) 
+        bin_img2 = loader.dense_image(num, pt1 + 0.05, 2)
+        bin_window = loader.dense_window(num)
+
+        if plot:
+            print(sparse_bin_img1.shape)
+            print(sparse_bin_img2.shape)
+
+        def sparse_bench():
+            sbi1 = np.logical_and(sparse_bin_img1, sparse_bin_window)
+            sbi2 = np.logical_and(sparse_bin_img2, sparse_bin_window)
+            sparse_xor_img = np.logical_xor(sbi1, sbi2).astype('int')
+            return sparse_xor_img
+
+        def dense_bench():
+            bi1 = np.logical_and(bin_img1, bin_window).astype('int')
+            bi2 = np.logical_and(bin_img2, bin_window).astype('int')
+            xor_img = np.logical_xor(bi1, bi2).astype('int')
+            return xor_img
+        ret = tacoBench(sparse_bench)
+        sparse_xor_img = sparse_bench()
+        xor_img = dense_bench()
+        
+        if plot:
+            num_elements = float(np.prod(bin_img1.shape))
+            print("Sparse xor NNZ = ", sparse_xor_img.nnz, "\t", "Dense xor NNZ = ", np.sum(xor_img != 0))
+            print("Sparsity img 1 ", np.sum(bin_img1 != 0) / num_elements)
+            print("Sparsity img 2 ", np.sum(bin_img2 != 0) / num_elements)
+            print("Sparsity xor ", np.sum(xor_img != 0) / num_elements)
+            sparse_xor_img = sparse_xor_img.todense()
+            t1 = round(loader.max[num]*pt1, 2)
+            t2 = round(loader.max[num]*(pt1 + 0.05), 2)
+            plot_image(loader.img[num], bin_img1, bin_img2, xor_img, sparse_xor_img, t1, t2, bin_window)
+
+        assert(sparse_xor_img.nnz == np.sum(xor_img != 0))
+
+@pytest.mark.parametrize("num", list(range(1, 99))) 
+@pytest.mark.parametrize("pt1", [0.5])
+def bench_edge_detection_fused_dense(tacoBench, num, pt1):
+        loader = ImagePydataSparseTensorLoader()
+        bin_img1 = loader.dense_image(num, pt1, 1) 
+        bin_img2 = loader.dense_image(num, pt1 + 0.05, 2)
+        bin_window = loader.dense_window(num)
+
+        def dense_bench():
+            bi1 = np.logical_and(bin_img1, bin_window).astype('int')
+            bi2 = np.logical_and(bin_img2, bin_window).astype('int')
+            xor_img = np.logical_xor(bin_img1, bin_img2).astype('int')
+            return xor_img
+        tacoBench(dense_bench)
+
+#TODO: Add in a benchmark that uses windowing for medical imaging as well. 
 
-images_path = "./numpy/images"
-
-def load_dataset(image_folder):
-    files = sorted(os.listdir(image_folder))
-    images = []
-    for f in files:
-        path = os.path.join(image_folder, f)
-        img = cv2.imread(path)
-        img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
-        images.append(img)
-    
-    images =  np.stack(images, axis=0)
-    return images
-
-def thresh(images, t=85):
-    if len(images.shape) < 3:
-        images = np.expand_dims(images, axis=0)
-    thresh_imgs = []
-    for i in range(images.shape[0]):
-        img = images[i]
-        ret, thresh_img = cv2.threshold(img, t, 255, cv2.THRESH_BINARY)
-        thresh_imgs.append(thresh_img)
-
-    thresh_imgs =  np.stack(thresh_imgs, axis=0)        
-    return thresh_imgs 
-
-def plot_image(img, img1, img2, xor_img, t1, t2):
-    f, ax = plt.subplots(2, 2)
-    ax[0, 0].imshow(img1, 'gray')
-    ax[0, 0].title.set_text("Binned Image 1. t1 = " + str(t1))
-
-    ax[0, 1].imshow(img2, 'gray')
-    ax[0, 1].title.set_text("Binned Image 2. t2 = " + str(t2))
-
-    ax[1, 0].imshow(img, 'gray')
-    ax[1, 0].title.set_text("Saturdated Image")
-
-    ax[1, 1].imshow(xor_img, 'gray')
-    ax[1, 1].title.set_text("XOR Image")
-    
-    f.tight_layout()
-    plt.show()
-
-@pytest.mark.parametrize("t1", [100, 150, 200, 250])
-def bench_edge_detection(tacoBench, t1, plot):
-    images = load_dataset(images_path)
-    
-    sat_images = images[:,:,:,1]
-    
-    img = sat_images[0]
-    
-    t2 = t1 - 50
- 
-    bin_img1 = thresh(img, t1)
-    bin_img2 = thresh(img, t2)
-    num_elements = float(np.prod(bin_img1.shape))
-
-    def bench():
-        xor_img = np.logical_xor(bin_img1[0], bin_img2[0]).astype('int')
-        return xor_img
-    ret = tacoBench(bench)
-    xor_img = bench()
-    if plot:
-        plot_image(img, bin_img1[0], bin_img2[0], xor_img, t1, t2)
-
-    print("Sparsity img 1 ", np.sum(bin_img1 != 0) / num_elements)
-    print("Sparsity img 2 ", np.sum(bin_img2 != 0) / num_elements)
-    print("Sparsity xor ", np.sum(xor_img != 0) / num_elements)
-    
 if __name__=="__main__":
     main()
 
diff --git a/numpy/util.py b/numpy/util.py
@@ -4,6 +4,8 @@
 import os
 import glob
 import numpy
+import cv2
+import matplotlib.pyplot as plt
 
 # Get the path to the directory holding random tensors. Error out
 # if this isn't set.
@@ -52,6 +54,9 @@ def dump_dict_to_file(self, shape, data, path):
                 strings = coords + [str(line[-1])]
                 f.write(" ".join(strings))
                 f.write("\n")
+            shape_strings = [str(elem) for elem in shape] + ['0']
+            f.write(" ".join(shape_strings))
+            f.write("\n")
 
 # ScipySparseTensorLoader loads a sparse tensor from a file into a
 # scipy.sparse CSR matrix.
@@ -284,3 +289,145 @@ def safeCastPydataTensorToInts(tensor):
         else:
             data[i] = int(tensor.data[i])
     return sparse.COO(tensor.coords, data, tensor.shape)
+
+
+###########################
+# Imaging Benchmark Utils #
+###########################
+
+# load_image loads an image with the correct color format for the numpy/image.py 
+# benchmark
+def load_image(image_folder, num):
+    if image_folder == 'no':
+        image_folder = "./data/image/no"
+    else:
+        image_folder = "./data/image/yes"
+
+    name = "image" + str(num) + '.'  
+    file_names = [fn for fn in os.listdir(image_folder)
+                  if fn.startswith(name)]
+    path = os.path.join(image_folder, file_names[0])
+    img = cv2.imread(path)
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    return img
+
+# plot_image plots the given original, binned, xor, and sparse xor images
+# for the numpy/image.py. Used for debugging only with the --plot flag
+def plot_image(img, img1, img2, xor_img, sparse_xor_img, t1, t2, window=None):
+    f, ax = plt.subplots(2, 3)
+    ax[0, 0].imshow(img1, 'gray')
+    ax[0, 0].title.set_text("Binned Image 1. t1 = " + str(t1))
+
+    ax[0, 1].imshow(img2, 'gray')
+    ax[0, 1].title.set_text("Binned Image 2. t2 = " + str(t2))
+
+    ax[1, 0].imshow(img, 'gray')
+    ax[1, 0].title.set_text("Saturdated Image")
+
+    ax[1, 1].imshow(xor_img, 'gray')
+    ax[1, 1].title.set_text("XOR Image")
+
+    ax[1, 2].imshow(sparse_xor_img, 'gray')
+    ax[1, 2].title.set_text("Sparse XOR Image")
+
+    if window is not None:
+        ax[0, 2].imshow(window, 'gray')
+        ax[0, 2].title.set_text("Fused Window Image")
+
+    f.tight_layout()
+    plt.show()
+
+# thresh thresholdes the given image by a threshold
+def thresh(images, t=85):
+    if len(images.shape) < 3:
+        images = numpy.expand_dims(images, axis=0)
+    thresh_imgs = []
+    for i in range(images.shape[0]):
+        img = images[i]
+        ret, thresh_img = cv2.threshold(img, t, 255, cv2.THRESH_BINARY)
+        thresh_imgs.append(thresh_img)
+
+    thresh_imgs = numpy.stack(thresh_imgs, axis=0)        
+    return thresh_imgs 
+
+# construct_image_tensor_key constructs a unique key that represents
+# an image tensor parameterized by the image number and threshold.
+# The key itself is formatted by the image number, followed by the
+# threshold. For example, image1.* image with threshold of 0.5
+# would have a key of image1-0.05.tns.
+def construct_image_tensor_key(num, pt, variant):
+    path = TENSOR_PATH
+    name = "image" + str(num)
+    if variant is None:
+        key = "{}-{}.tns".format(dims, pt)
+    else:
+        key = "{}-{}-{}.tns".format(name, pt, variant)
+    return os.path.join(path, "image", "tensors", key)
+
+# ImagePydataSparseTensorLoader is the same as RandomPydataSparseTensorLoader
+# but for images loaded from memory and converted to sparse.COO tensors
+class ImagePydataSparseTensorLoader:
+    def __init__(self):
+        self.loader = PydataSparseTensorLoader()
+        self.img = dict()
+        self.max = dict()
+        self.shape = dict()
+
+    def dense_image(self, num, pt, variant=None, path='no'):
+        # Used for verification and baseline only.
+        # Do not need to write to output file 
+        if num not in self.img.keys():
+            self.img[num] = load_image(path, num)
+            self.max[num] = numpy.max(self.img[num])
+
+        img = self.img[num]
+        t = self.max[num]*pt
+        bin_img = thresh(img, t)[0]
+        self.shape[num] = bin_img.shape 
+        return bin_img 
+
+    def sparse_image(self, num, pt, variant=None, path='no'):
+        key = construct_image_tensor_key(num, pt, variant)
+        # If an image with these properties exists already, then load it.
+        if os.path.exists(key):
+            result = self.loader.load(key)
+            self.shape[num] = result.shape
+            return result
+        else:
+            # Otherwise, we must create load the image and preprocess it with the desired properties.
+            # dump it to the output file, then return it. 
+            bin_img = self.dense_image(num, pt, variant, path)
+            result = sparse.COO.from_numpy(bin_img)
+            dok = sparse.DOK(result)
+            TnsFileDumper().dump_dict_to_file(self.shape[num], dok.data, key)
+            return result
+
+    # sparse_window and dense_window must be called after the image calls
+    def sparse_window(self, num, variant=3):
+        path = TENSOR_PATH
+        key = "image"+str(num) + "-" + str(variant) + ".tns"
+        key = os.path.join(path, "image", "tensors", key)
+
+        shape = self.shape[num]
+
+        if os.path.exists(key):
+            return self.loader.load(key)
+        else:
+            result_np = self.dense_window(num)
+            result = sparse.COO.from_numpy(result_np)
+            dok = sparse.DOK(result)
+            TnsFileDumper().dump_dict_to_file(shape, dok.data, key)
+            return result
+
+    def dense_window(self, num):
+        shape = self.shape[num]
+        result_np = numpy.zeros(shape)
+        m0 = int(shape[0] / 2)
+        m1 = int(shape[1] / 2)
+        dm0 = int(0.2*m0)
+        dm1 = int(0.2*m1)
+        result_np[m0+dm0:m0+3*dm0, m1+dm1:m1+3*dm1] = 1
+        result_np[m0-3*dm0:m0-dm0, m1+dm1:m1+3*dm1] = 1
+        result_np[m0-3*dm0:m0-dm0, m1-3*dm1:m1-dm1] = 1
+        result_np[m0+dm0:m0+3*dm0, m1-3*dm1:m1-dm1] = 1
+        return result_np 
diff --git a/requirements.txt b/requirements.txt
@@ -1,4 +1,5 @@
 attrs==20.3.0
+matplotlib==3.1.1
 importlib-metadata==3.7.3
 iniconfig==1.1.1
 llvmlite==0.36.0

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`attrs==20.3.0`
	`2`	`+matplotlib==3.1.1`
`2`	`3`	`importlib-metadata==3.7.3`
`3`	`4`	`iniconfig==1.1.1`
`4`	`5`	`llvmlite==0.36.0`