Merge branches 'master' and 'master' of https://github.com/apache/incubator-tvm

Author: Mikael Sevenier

docs/deploy/arm_compute_lib.rst

@@ -232,6 +232,8 @@ Operator support
 +----------------------+-------------------------------------------------------------------------+
 | reshape              | fp32, uint8                                                             |
 +----------------------+-------------------------------------------------------------------------+
+| maximum              | fp32                                                                    |
++----------------------+-------------------------------------------------------------------------+
 
 .. note::
     A composite operator is a series of operators that map to a single Arm Compute Library operator. You can view this

python/tvm/relay/op/contrib/arm_compute_lib.py

@@ -337,3 +337,11 @@ def global_avg_pool2d(attrs, args):
     if attrs.layout != "NHWC":
         return False
     return True
+
+
+@tvm.ir.register_op_attr("maximum", "target.arm_compute_lib")
+def maximum(attrs, args):
+    """Check if the external ACL codegen for maximum should be used."""
+    type_a = args[0].checked_type
+    type_b = args[0].checked_type
+    return (type_a.dtype == "float32") and (type_b.dtype == "float32")

python/tvm/relay/testing/yolo_detection.py

@@ -196,41 +196,91 @@ def do_nms_sort(dets, classes, thresh):
                     dets[j]["prob"][k] = 0
 
 
+def get_detections(im, det, thresh, names, classes):
+    "Draw the markings around the detected region"
+    labelstr = []
+    category = -1
+    detection = None
+    valid = False
+    for j in range(classes):
+        if det["prob"][j] > thresh:
+            if category == -1:
+                category = j
+            labelstr.append(names[j] + " " + str(round(det["prob"][j], 4)))
+
+    if category > -1:
+        valid = True
+        imc, imh, imw = im.shape
+        width = int(imh * 0.006)
+        offset = category * 123457 % classes
+        red = _get_color(2, offset, classes)
+        green = _get_color(1, offset, classes)
+        blue = _get_color(0, offset, classes)
+        rgb = [red, green, blue]
+        b = det["bbox"]
+        left = int((b.x - b.w / 2.0) * imw)
+        right = int((b.x + b.w / 2.0) * imw)
+        top = int((b.y - b.h / 2.0) * imh)
+        bot = int((b.y + b.h / 2.0) * imh)
+
+        if left < 0:
+            left = 0
+        if right > imw - 1:
+            right = imw - 1
+        if top < 0:
+            top = 0
+        if bot > imh - 1:
+            bot = imh - 1
+
+        detection = {
+            "category": category,
+            "labelstr": labelstr,
+            "left": left,
+            "top": top,
+            "right": right,
+            "bot": bot,
+            "width": width,
+            "rgb": rgb,
+        }
+
+    return valid, detection
+
+
 def draw_detections(font_path, im, dets, thresh, names, classes):
     "Draw the markings around the detected region"
     for det in dets:
-        labelstr = []
-        category = -1
-        for j in range(classes):
-            if det["prob"][j] > thresh:
-                if category == -1:
-                    category = j
-                labelstr.append(names[j] + " " + str(round(det["prob"][j], 4)))
-        if category > -1:
-            imc, imh, imw = im.shape
-            width = int(imh * 0.006)
-            offset = category * 123457 % classes
-            red = _get_color(2, offset, classes)
-            green = _get_color(1, offset, classes)
-            blue = _get_color(0, offset, classes)
-            rgb = [red, green, blue]
-            b = det["bbox"]
-            left = int((b.x - b.w / 2.0) * imw)
-            right = int((b.x + b.w / 2.0) * imw)
-            top = int((b.y - b.h / 2.0) * imh)
-            bot = int((b.y + b.h / 2.0) * imh)
-
-            if left < 0:
-                left = 0
-            if right > imw - 1:
-                right = imw - 1
-            if top < 0:
-                top = 0
-            if bot > imh - 1:
-                bot = imh - 1
-            _draw_box_width(im, left, top, right, bot, width, red, green, blue)
-            label = _get_label(font_path, "".join(labelstr), rgb)
-            _draw_label(im, top + width, left, label, rgb)
+        valid, detection = get_detections(im, det, thresh, names, classes)
+        if valid:
+            rgb = detection["rgb"]
+            label = _get_label(font_path, "".join(detection["labelstr"]), rgb)
+            _draw_box_width(
+                im,
+                detection["left"],
+                detection["top"],
+                detection["right"],
+                detection["bot"],
+                detection["width"],
+                rgb[0],
+                rgb[1],
+                rgb[2],
+            )
+            _draw_label(im, detection["top"] + detection["width"], detection["left"], label, rgb)
+
+
+def show_detections(im, dets, thresh, names, classes):
+    "Print the markings and the detected region"
+    for det in dets:
+        valid, detection = get_detections(im, det, thresh, names, classes)
+        if valid:
+            print(
+                "class:{} left:{} right:{} top:{} bottom:{}".format(
+                    detection["labelstr"],
+                    detection["left"],
+                    detection["top"],
+                    detection["right"],
+                    detection["bot"],
+                )
+            )
 
 
 def _get_pixel(im, x, y, c):

rust/tvm/examples/resnet/src/build_resnet.py

@@ -74,8 +74,9 @@ def build(target_dir):
         block = get_model("resnet18_v1", pretrained=True)
         net, params = relay.frontend.from_mxnet(block, {"data": data_shape})
         # we want a probability so add a softmax operator
+        func = net["main"]
         net = relay.Function(
-            net.params, relay.nn.softmax(net.body), None, net.type_params, net.attrs
+            func.params, relay.nn.softmax(func.body), None, func.type_params, func.attrs
         )
     else:
         # use random weights from relay.testing

src/auto_scheduler/search_policy/sketch_policy.cc

@@ -27,6 +27,7 @@
 #include "sketch_policy.h"
 
 #include <tvm/runtime/registry.h>
+#include <tvm/support/parallel_for.h>
 
 #include <algorithm>
 #include <iomanip>
@@ -334,28 +335,44 @@ Array<State> SketchPolicyNode::GenerateSketches() {
 Array<State> SketchPolicyNode::SampleInitPopulation(const Array<State>& sketches, int out_size) {
   int fail_ct = 0;
   Array<State> out_states;
+  std::vector<std::mt19937> rand_gens;
+  rand_gens.reserve(out_size);
+  for (int i = 0; i < out_size; i++) {
+    rand_gens.push_back(std::mt19937(rand_gen()));
+  }
   auto tic_begin = std::chrono::high_resolution_clock::now();
 
   while (static_cast<int>(out_states.size()) < out_size && fail_ct < out_size) {
-    // Random choose a starting sketch
-    // TODO(jcf94, merrymercy): Maybe choose sketches in different possibility for they may have
-    // different potential on generating state with better performance
-    State tmp_s = sketches[(rand_gen)() % sketches.size()];
-
-    // Derivation rule based enumeration
-    bool valid = true;
-    for (const auto& rule : init_rules) {
-      if (rule->Apply(this, &tmp_s) == PopulationGenerationRule::ResultKind::kInvalid) {
-        valid = false;
-        break;
+    std::vector<State> temp_states(out_size);
+
+    support::parallel_for(0, out_size - out_states.size(),
+                          [this, &temp_states, &sketches, &rand_gens](int index) {
+                            // Random choose a starting sketch
+                            // TODO(jcf94, merrymercy): Maybe choose sketches in different
+                            // possibility for they may have different potential on generating state
+                            // with better performance
+                            State tmp_s = sketches[(rand_gens[index])() % sketches.size()];
+                            // Derivation rule based enumeration
+                            bool valid = true;
+                            for (const auto& rule : init_rules) {
+                              if (rule->Apply(this, &tmp_s, &rand_gens[index]) ==
+                                  PopulationGenerationRule::ResultKind::kInvalid) {
+                                valid = false;
+                                break;
+                              }
+                            }
+                            if (valid) {
+                              temp_states[index] = std::move(tmp_s);
+                            }
+                          });
+
+    for (int i = 0; i < out_size; i++) {
+      if (temp_states[i].defined()) {
+        out_states.push_back(std::move(temp_states[i]));
+      } else {
+        fail_ct++;
       }
     }
-
-    if (valid) {
-      out_states.push_back(std::move(tmp_s));
-    } else {
-      fail_ct++;
-    }
   }
 
   double duration = std::chrono::duration_cast<std::chrono::duration<double>>(
@@ -461,7 +478,7 @@ Array<State> SketchPolicyNode::EvolutionarySearch(const Array<State>& init_popul
 
       if (dis(rand_gen) < mutation_prob) {
         const auto& rule = mutation_rules[RandomChoose(rule_selection_probs, &rand_gen)];
-        if (rule->Apply(this, &tmp_s) == PopulationGenerationRule::ResultKind::kValid) {
+        if (rule->Apply(this, &tmp_s, &rand_gen) == PopulationGenerationRule::ResultKind::kValid) {
           pnext->push_back(std::move(tmp_s));
           mutation_success_ct++;
         } else {