Merge branch 'main' of https://github.com/tensor-compiler/array-programming-benchmarks into main

Author: stephenchouca

.gitignore

@@ -1,3 +1,6 @@
 *__pycache__*
 *CMakeFiles/
 *.idea/*
+.DS_Store
+*.swo
+*.swp

Makefile

@@ -1,11 +1,15 @@
 BENCHES := ""
-BENCHFLAGS :=
+BENCHFLAGS := #"--benchmark-group-by=func"
+
+#IGNORE := numpy/image.py
+IGNORE += taco
+IGNORE_FLAGS := $(addprefix --ignore=, $(IGNORE)) 
 
 # To group benchmark output by benchmark, use BENCHFLAGS=--benchmark-group-by=func.
 # To additionally group by a parameterized value, add on ",param:<paramname>" to the
 # command above.
 python-bench: numpy/*.py
-	pytest --ignore=taco $(BENCHFLAGS) $(BENCHES)
+	pytest $(IGNORE_FLAGS) $(BENCHFLAGS) $(BENCHES)
 
 taco-bench: taco/build/taco-bench
 ifeq ($(BENCHES),"")

numpy/conftest.py

@@ -7,3 +7,10 @@ def f(func):
         # How do i set please use 10 rounds...
         # benchmark(func)
     return f
+
+def pytest_addoption(parser):
+    parser.addoption("--plot", action="store_true", dest="plot", default=False, help="Enable plotting for image.py")
+
+@pytest.fixture
+def plot(request):
+    return request.config.getoption("--plot") 

numpy/image.py

@@ -0,0 +1,80 @@
+import numpy as np
+import cv2
+import os
+import pytest
+import matplotlib.pyplot as plt 
+
+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)
+    if plot:
+        print(images.shape)
+    
+    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()
+

numpy/images/AFW_3929640120_1_0.jpg

@@ -11,7 +11,7 @@ def myfunc(x, y):
 
 # @pytest.mark.parametrize("dim", [5000, 10000, 20000])
 @pytest.mark.parametrize("dim", [250, 500, 750, 1000, 2500, 5000, 7500, 8000])
-@pytest.mark.parametrize("ufunc", [numpy.logical_xor, numpy.logical_or, numpy.right_shift])
+@pytest.mark.parametrize("ufunc", [numpy.logical_xor, numpy.logical_or, numpy.right_shift, numpy.ldexp])
 def bench_ufunc_dense(tacoBench, dim, ufunc):
     A = numpy.random.randint(2, size=(dim, dim)).astype(numpy.uint32)
     B = numpy.random.randint(2, size=(dim, dim)).astype(numpy.uint32)
@@ -22,7 +22,7 @@ def bench():
 # TODO (rohany): We can parametrize this over the sparsity as well.
 # @pytest.mark.parametrize("dim", [5000, 10000, 20000])
 @pytest.mark.parametrize("dim", [250, 500, 750, 1000, 2500, 5000, 7500, 8000])
-@pytest.mark.parametrize("ufunc", [numpy.logical_xor, numpy.logical_or, numpy.right_shift])
+@pytest.mark.parametrize("ufunc", [numpy.logical_xor, numpy.logical_or, numpy.right_shift, numpy.ldexp])
 def bench_pydata_ufunc_sparse(tacoBench, dim, ufunc):
     A = sparse.random((dim, dim), data_rvs=numpy.ones).astype(numpy.uint32)
     B = sparse.random((dim, dim), data_rvs=numpy.ones).astype(numpy.uint32)

numpy/images/AFW_3944399031_1_0.jpg

@@ -13,3 +13,4 @@ pytest-benchmark==3.2.3
 scipy==1.6.0
 sparse==0.11.2
 toml==0.10.2
+opencv-python==4.5.1.48

numpy/images/AFW_397921011_1_0.jpg

@@ -20,12 +20,21 @@
 // of an arbitrarily typed argument to the benchmark function.
 // TODO (rohany): Make this take in only 1 argument.
 // TODO (rohany): Don't specify the time here, but do it at the command line.
-#define TACO_BENCH_ARG(bench, name, arg) \
-  BENCHMARK_CAPTURE(bench, name, arg)    \
-  ->Unit(benchmark::kMicrosecond)        \
-  ->Repetitions(10)                      \
-  ->Iterations(5)                        \
-  ->ReportAggregatesOnly(true)           \
+
+#define TACO_BENCH_ARG(bench, name, arg)  \
+  BENCHMARK_CAPTURE(bench, name, arg)     \
+  ->Unit(benchmark::kMicrosecond)         \
+  ->Repetitions(10)                       \
+  ->Iterations(5)                         \
+  ->ReportAggregatesOnly(true)            \
+  ->UseRealTime()
+
+#define TACO_BENCH_ARGS(bench, name, ...)       \
+  BENCHMARK_CAPTURE(bench, name, __VA_ARGS__)   \
+  ->Unit(benchmark::kMicrosecond)               \
+  ->Repetitions(10)                             \
+  ->Iterations(5)                               \
+  ->ReportAggregatesOnly(true)                  \
   ->UseRealTime()
 
 #endif //TACO_BENCH_BENCH_H

numpy/images/AFW_397921011_2_0.jpg

@@ -10,7 +10,9 @@ using namespace taco;
 
 struct GeneralAdd {
   ir::Expr operator()(const std::vector<ir::Expr> &v) {
-    taco_iassert(v.size() >= 2) << "Add operator needs at least two operands";
+    taco_iassert(v.size() >= 1) << "Add operator needs at least one operand";
+    if (v.size() == 1)
+        return ir::Add::make(v[0], ir::Literal::zero(v[0].type()));
     ir::Expr add = ir::Add::make(v[0], v[1]);
     for (size_t idx = 2; idx < v.size(); ++idx) {
       add = ir::Add::make(add, v[idx]);
@@ -26,12 +28,48 @@ struct xorAlgebra {
   }
 };
 
+struct RightShift{
+  ir::Expr operator()(const std::vector<ir::Expr> &v) {
+    if (v.size() == 1)
+      return v[0];
+
+    ir::Expr shift = ir::BinOp::make(v[0], v[1], " >> ");
+    for (size_t idx = 2; idx < v.size(); ++idx) {
+      shift = ir::BinOp::make(shift, v[idx], " >> ");
+    }
+    return shift;
+  }
+};
+
+struct rightShiftAlgebra {
+  IterationAlgebra operator()(const std::vector<IndexExpr>& regions) {
+    return Union(regions[0], Intersect(regions[0], regions[1]));
+  }
+};
+
 // TODO (rohany): We can extract most of the logic out of here and parametrize the test by
 //  a particular Func.
-static void bench_xor_sparse(benchmark::State& state, float sparsity) {
+template <int I, class...Ts>
+decltype(auto) get(Ts&&... ts) {
+  return std::get<I>(std::forward_as_tuple(ts...));
+}
+
+template <class ...ExtraArgs>
+static void bench_ufunc_sparse(benchmark::State& state, ExtraArgs&&... extra_args) {
   int dim = state.range(0);
 
+  auto& sparsity = get<0>(extra_args...);
+  auto opType = get<1>(extra_args...);
+
   Func xorOp("xor", GeneralAdd(), xorAlgebra());
+  Func rightShiftOp(">>", RightShift(), rightShiftAlgebra());
+
+  Func op = xorOp;
+  if (opType == "xor")
+    op = xorOp;
+  else if (opType == ">>")
+    op = rightShiftOp;
+
 
   // TODO (rohany): We can parametrize over the sparsities here.
   Tensor<int> A("A", {dim, dim}, CSR);
@@ -58,7 +96,7 @@ static void bench_xor_sparse(benchmark::State& state, float sparsity) {
     state.PauseTiming();
     Tensor<float> result("C", {dim, dim}, CSR);
     IndexVar i, j;
-    result(i, j) = xorOp(A(i, j), B(i, j));
+    result(i, j) = op(A(i, j), B(i, j));
     result.compile();
     result.assemble();
     state.ResumeTiming();
@@ -70,4 +108,6 @@ static void bench_xor_sparse(benchmark::State& state, float sparsity) {
 static void applyBenchSizes(benchmark::internal::Benchmark* b) {
   b->ArgsProduct({{250, 500, 750, 1000, 2500, 5000, 7500, 8000}});
 }
-TACO_BENCH_ARG(bench_xor_sparse, 0.01, 0.01)->Apply(applyBenchSizes);
+
+TACO_BENCH_ARGS(bench_ufunc_sparse, xor_0.01, 0.01, "xor")->Apply(applyBenchSizes);
+TACO_BENCH_ARGS(bench_ufunc_sparse, rightShift_0.01, 0.01, ">>")->Apply(applyBenchSizes);