[Clojure] package infer tweaks (apache#13864)

* change object detection prediction to be a map

* change predictions to a map for image-classifiers

* change return types of the classifiers to be a map
- add tests for base classifier and with-ndarray as well

* tweak return types and inputs for predict
- add test for plain predict

* updated infer-classify examples

* adjust the infer/object detections tests

* tweak predictor test

* Feedback from @kedarbellare review

* put scaling back in

* put back predict so it can handle multiple inputs

* restore original functions signatures (remove first)

contrib/clojure-package/examples/infer/imageclassifier/src/infer/imageclassifier_example.clj

@@ -55,17 +55,17 @@
   "Print image classifier predictions for the given input file"
   [predictions]
   (println (apply str (repeat 80 "=")))
-  (doseq [[label probability] predictions]
-    (println (format "Class: %s Probability=%.8f" label probability)))
+  (doseq [p predictions]
+    (println p))
   (println (apply str (repeat 80 "="))))
 
 (defn classify-single-image
   "Classify a single image and print top-5 predictions"
   [classifier input-image]
   (let [image (infer/load-image-from-file input-image)
         topk 5
-        [predictions] (infer/classify-image classifier image topk)]
-    predictions))
+        predictions (infer/classify-image classifier image topk)]
+    [predictions]))
 
 (defn classify-images-in-dir
   "Classify all jpg images in the directory"
@@ -78,12 +78,10 @@
                                 (filter #(re-matches #".*\.jpg$" (.getPath %)))
                                 (mapv #(.getPath %))
                                 (partition-all batch-size))]
-    (apply
-     concat
-     (for [image-files image-file-batches]
-       (let [image-batch (infer/load-image-paths image-files)
-             topk 5]
-         (infer/classify-image-batch classifier image-batch topk))))))
+    (apply concat (for [image-files image-file-batches]
+                    (let [image-batch (infer/load-image-paths image-files)
+                          topk 5]
+                      (infer/classify-image-batch classifier image-batch topk))))))
 
 (defn run-classifier
   "Runs an image classifier based on options provided"
@@ -98,6 +96,7 @@
                     factory {:contexts [(context/default-context)]})]
     (println "Classifying a single image")
     (print-predictions (classify-single-image classifier input-image))
+    (println "\n")
     (println "Classifying images in a directory")
     (doseq [predictions (classify-images-in-dir classifier input-dir)]
       (print-predictions predictions))))

contrib/clojure-package/examples/infer/imageclassifier/test/infer/imageclassifier_example_test.clj

@@ -43,27 +43,16 @@
 
 (deftest test-single-classification
   (let [classifier (create-classifier)
-        predictions (classify-single-image classifier image-file)]
+        [[predictions]] (classify-single-image classifier image-file)]
     (is (some? predictions))
     (is (= 5 (count predictions)))
-    (is (every? #(= 2 (count %)) predictions))
-    (is (every? #(string? (first %)) predictions))
-    (is (every? #(float? (second %)) predictions))
-    (is (every? #(< 0 (second %) 1) predictions))
-    (is (= ["n02123159 tiger cat"
-            "n02124075 Egyptian cat"
-            "n02123045 tabby, tabby cat"
-            "n02127052 lynx, catamount"
-            "n02128757 snow leopard, ounce, Panthera uncia"]
-           (map first predictions)))))
+    (is (= "n02123159 tiger cat" (:class (first predictions))))
+    (is (= (< 0 (:prob (first predictions)) 1)))))
 
 (deftest test-batch-classification
   (let [classifier (create-classifier)
-        batch-predictions (classify-images-in-dir classifier image-dir)
-        predictions (first batch-predictions)]
-    (is (some? batch-predictions))
+        predictions (first (classify-images-in-dir classifier image-dir))]
+    (is (some? predictions))
     (is (= 5 (count predictions)))
-    (is (every? #(= 2 (count %)) predictions))
-    (is (every? #(string? (first %)) predictions))
-    (is (every? #(float? (second %)) predictions))
-    (is (every? #(< 0 (second %) 1) predictions))))
+    (is (= "n02123159 tiger cat" (:class (first predictions))))
+    (is (= (< 0 (:prob (first predictions)) 1)))))

contrib/clojure-package/examples/infer/objectdetector/src/infer/objectdetector_example.clj

@@ -54,15 +54,15 @@
   "Print image detector predictions for the given input file"
   [predictions width height]
   (println (apply str (repeat 80 "=")))
-  (doseq [[label prob-and-bounds] predictions]
+  (doseq [{:keys [class prob x-min y-min x-max y-max]} predictions]
     (println (format
               "Class: %s Prob=%.5f Coords=(%.3f, %.3f, %.3f, %.3f)"
-              label
-              (aget prob-and-bounds 0)
-              (* (aget prob-and-bounds 1) width)
-              (* (aget prob-and-bounds 2) height)
-              (* (aget prob-and-bounds 3) width)
-              (* (aget prob-and-bounds 4) height))))
+              class
+              prob
+              (* x-min width)
+              (* y-min height)
+              (* x-max width)
+              (* y-max height))))
   (println (apply str (repeat 80 "="))))
 
 (defn detect-single-image
@@ -84,12 +84,10 @@
                                 (filter #(re-matches #".*\.jpg$" (.getPath %)))
                                 (mapv #(.getPath %))
                                 (partition-all batch-size))]
-    (apply
-     concat
-     (for [image-files image-file-batches]
-       (let [image-batch (infer/load-image-paths image-files)
-             topk 5]
-         (infer/detect-objects-batch detector image-batch topk))))))
+    (apply concat (for [image-files image-file-batches]
+                    (let [image-batch (infer/load-image-paths image-files)
+                          topk 5]
+                      (infer/detect-objects-batch detector image-batch topk))))))
 
 (defn run-detector
   "Runs an image detector based on options provided"
@@ -107,6 +105,7 @@
                   {:contexts [(context/default-context)]})]
     (println "Object detection on a single image")
     (print-predictions (detect-single-image detector input-image) width height)
+    (println "\n")
     (println "Object detection on images in a directory")
     (doseq [predictions (detect-images-in-dir detector input-dir)]
       (print-predictions predictions width height))))

contrib/clojure-package/examples/infer/objectdetector/test/infer/objectdetector_example_test.clj

@@ -43,23 +43,23 @@
 
 (deftest test-single-detection
   (let [detector (create-detector)
-        predictions (detect-single-image detector image-file)]
+        predictions (detect-single-image detector image-file)
+        {:keys [class prob x-min x-max y-min y-max] :as pred} (first predictions)]
     (is (some? predictions))
     (is (= 5 (count predictions)))
-    (is (every? #(= 2 (count %)) predictions))
-    (is (every? #(string? (first %)) predictions))
-    (is (every? #(= 5 (count (second %))) predictions))
-    (is (every? #(< 0 (first (second %)) 1) predictions))
-    (is (= ["car" "bicycle" "dog" "bicycle" "person"]
-           (map first predictions)))))
+    (is (string? class))
+    (is (< 0.8 prob))
+    (is (every? #(< 0 % 1) [x-min x-max y-min y-max]))
+    (is (= #{"dog" "person" "bicycle" "car"} (set (mapv :class predictions))))))
 
 (deftest test-batch-detection
   (let [detector (create-detector)
         batch-predictions (detect-images-in-dir detector image-dir)
-        predictions (first batch-predictions)]
+        predictions (first batch-predictions)
+        {:keys [class prob x-min x-max y-min y-max] :as pred} (first predictions)]
     (is (some? batch-predictions))
     (is (= 5 (count predictions)))
-    (is (every? #(= 2 (count %)) predictions))
-    (is (every? #(string? (first %)) predictions))
-    (is (every? #(= 5 (count (second %))) predictions))
-    (is (every? #(< 0 (first (second %)) 1) predictions))))
+    (is (string? class))
+    (is (< 0.8 prob))
+    (every? #(< 0 % 1) [x-min x-max y-min y-max])
+    (is (= #{"dog" "person" "bicycle" "car"} (set (mapv :class predictions))))))

contrib/clojure-package/examples/infer/predictor/src/infer/predictor_example.clj

@@ -59,8 +59,8 @@
 (defn do-inference
   "Run inference using given predictor"
   [predictor image]
-  (let [[predictions] (infer/predict-with-ndarray predictor [image])]
-    predictions))
+  (let [predictions (infer/predict-with-ndarray predictor [image])]
+    (first predictions)))
 
 (defn postprocess
   [model-path-prefix predictions]