Adding knob pruning as an option to install time tuner

llvm/projects/hpvm-tensor-rt/autotuner/tuner_driver_src/knob_pruning.py

@@ -50,6 +50,11 @@ def getPrunedKnobs(binary_path, layer_file, global_knobs_file, \
           acc_loss = baseline_acc - accuracy
           if acc_loss <= acc_slack:
               pruned_layer_knobs.append(l_knob)
+              print ("\n + l_knob = ", l_knob, " - layer_ind = ", layer_ind)
+              print ("- acc_loss = ", acc_loss, " **** SELECTED *** ")
+          else:
+              print ("\n -- l_knob = ", l_knob, " - layer_ind = ", layer_ind)
+              print ("- acc_loss = ", acc_loss, " --- REJECTED --- ")
 
       pruned_knobs.append(pruned_layer_knobs)
           
@@ -65,8 +70,17 @@ def getPrunedKnobs(binary_path, layer_file, global_knobs_file, \
 if __name__ == "__main__":
 
     
-  pruned_knobs = getPrunedKnobs("alexnet2_promise",  "../autotuner/data/alexnet2/alexnet2_layers.txt", \
-                                "../autotuner/data/global_knobs.txt", 84.5, 3)
+  #pruned_knobs = getPrunedKnobs("alexnet2_promise",  "../autotuner/data/alexnet2/alexnet2_layers.txt", \
+  #                              "../autotuner/data/global_knobs.txt", 84.5, 3)
 
+  pruned_knobs = getPrunedKnobs("lenet_promise",  "../autotuner/data/lenet/lenet_layers.txt", \
+                                "../autotuner/data/global_knobs.txt", 99.7, 1)
+
+
+    
   print ("*** pruned_knobs = ", pruned_knobs)
   
+
+  utils.dumpKnobsFile(pruned_knobs, "install_knobs.txt")
+  
+  

llvm/projects/hpvm-tensor-rt/autotuner/tuner_driver_src/run_install_tuner.py

@@ -13,17 +13,19 @@ import buildRtConfig
 import genPlots
 from run_devtime_tuner import DevTimeTuner
 import validation
+import knob_pruning
 
 
 class InstallTimeTuner(DevTimeTuner):
 
   def __init__(self, Bench):
 
+    self.knob_pruning = True
     self.piped_execution = True
-    self.autotuner_runs = 10000
-    self.validation_runs = 30
+    self.autotuner_runs = 10000      #  Bench.autotuner_runs
+    self.validation_runs = 15
     self.abort_after = 3
-    self.conf_threshold = 95
+    self.conf_threshold = 100
 
     self.promise_binary = Bench.promise_binary
     
@@ -33,13 +35,30 @@ class InstallTimeTuner(DevTimeTuner):
       self.binary_path = Bench.promise_binary
 
     self.num_layers = Bench.num_layers
-    self.gold_accuracy = Bench.promise_accuracy
+    #self.gold_accuracy = Bench.promise_accuracy
+    self.setBaselineAccuracy()
+
+    
     self.cost_file = global_paths.tensorRT_dir + "/" + Bench.cost_file
     self.layer_file = global_paths.tensorRT_dir + "/" + Bench.layer_file
 
+    
     global_knobs_file = global_paths.tensorRT_dir + "/autotuner/data/global_knobs.txt"
     buildRtConfig.initializeApproxMap(global_knobs_file) # Initialize knobs - configfile gen
-    utils.createInstallAndDevKnobs(self.layer_file, global_knobs_file, "install_knobs.txt")
+
+
+    if self.knob_pruning == False:     
+      utils.createInstallAndDevKnobs(self.layer_file, global_knobs_file, "install_knobs.txt")
+
+    elif self.knob_pruning == True:
+       pruned_knobs = knob_pruning.getPrunedKnobs(self.promise_binary, self.layer_file, \
+                                     global_knobs_file, self.gold_accuracy, 3)
+       
+       print ("*** pruned_knobs = ", pruned_knobs)
+       utils.dumpKnobsFile(pruned_knobs, "install_knobs.txt")
+  
+ 
+    
     self.layer_knobs = "install_knobs.txt"
     
     self.result_dir = global_paths.tensorRT_dir + "/" + Bench.base_dir + \
@@ -62,7 +81,10 @@ class InstallTimeTuner(DevTimeTuner):
                                                                 accuracy_slack, self.validation_runs, \
                                                                 self.abort_after)
 
-      if confidence > self.conf_threshold:
+      print ("avg_acc, confidence = ", avg_acc, confidence)
+      
+      
+      if confidence >= self.conf_threshold:
         config.avg_accuracy = avg_acc
         filtered_configs.append(config)
 
@@ -73,9 +95,19 @@ class InstallTimeTuner(DevTimeTuner):
     
   def dumpValidatedConfigs(self, accuracy_slack):
 
+    #input_dir = self.result_dir + "/high_confidence/"
     input_dir = self.result_dir + "/high_confidence/"
-    
-    configurations = buildRtConfig.loadConfigsFromDir(input_dir, self.gold_accuracy)
+    output_dir = self.result_dir + "/pareto/"
+    utils.createDir(output_dir)
+
+    # Get Pareto Points with a "BAND" -- enable_band below is 'True'
+    configurations = pareto_utils.dumpParetoConfigsToDir(input_dir, \
+                                                         output_dir, self.gold_accuracy, True)   
+
+    print ("**** pareto config count = ", len(configurations), "\n")
+    time.sleep(10)
+           
+    #configurations = buildRtConfig.loadConfigsFromDir(input_dir, self.gold_accuracy)
     bench_layer_composition = utils.getLayerComposition(self.layer_file)
 
     
@@ -110,10 +142,15 @@ class InstallTimeTuner(DevTimeTuner):
 
     self.setBaselineAccuracy()
     
-    self.invokeDevTunerScript(0.8, 2.1, self.autotuner_runs)
-    self.invokeDevTunerScript(1.5, 2.1, self.autotuner_runs)
+    #self.invokeDevTunerScript(0.8, 2.1, self.autotuner_runs)
+    #self.invokeDevTunerScript(1.5, 2.1, self.autotuner_runs)
+    #self.invokeDevTunerScript(2.1, 2.1, self.autotuner_runs)
+    #self.invokeDevTunerScript(0.9, 2.1, self.autotuner_runs)
+
+    # NOTE: for purposes of comparison with fedtuning
     self.invokeDevTunerScript(2.1, 2.1, self.autotuner_runs)
-  
+
+    
     #--- self.dumpParetoFiles()
     self.dumpValidatedConfigs(2.1)
 

llvm/projects/hpvm-tensor-rt/autotuner/tuner_driver_src/utils.py

@@ -219,6 +219,66 @@ def createInstallAndDevKnobs(layer_file, global_knobs_file, out_file):
   f_out.close()
   
 
+
+
+  
+def getInstallAndDevKnobs(layer_file, global_knobs_file):
+
+  f = open(layer_file, "r")
+
+  conv_knobs_dev = readConvKnobs(global_knobs_file, "dev")
+  fc_knobs_dev = readFCKnobs(global_knobs_file, "dev")
+  red_knobs_dev = readRedKnobs(global_knobs_file, "dev")
+
+  conv_knobs_install = readConvKnobs(global_knobs_file, "install")
+  fc_knobs_install = readFCKnobs(global_knobs_file, "install")
+  red_knobs_install = readRedKnobs(global_knobs_file, "install")
+
+  
+  conv_knobs = conv_knobs_dev + conv_knobs_install 
+  fc_knobs = fc_knobs_dev + fc_knobs_install 
+  red_knobs = red_knobs_dev + red_knobs_install 
+  
+  print (conv_knobs, fc_knobs, red_knobs)
+
+
+  bench_knobs = []
+  
+  ind = 0
+  for x in f:
+    if "conv" in x:
+      layer_conv_knobs = conv_knobs
+      if ind == 0:
+        layer_conv_knobs = removePromiseKnobs(conv_knobs)
+      bench_knobs.append(layer_conv_knobs)  
+    if "dense" in x:
+      bench_knobs.append(fc_knobs)    
+    if "red" in x:
+      bench_knobs.append(red_knobs)    
+
+    ind += 1
+
+
+  return bench_knobs
+  
+
+
+
+
+
+def dumpKnobsFile(knobs, out_file):
+
+
+  f_out = open(out_file, "w+")
+
+  for layer_knobs in knobs:
+      f_out.write(",".join(layer_knobs) + "\n")
+      
+  f_out.close()
+
+  
+
+
   
 
 
@@ -226,5 +286,11 @@ def createInstallAndDevKnobs(layer_file, global_knobs_file, out_file):
 if __name__ == "__main__":
 
 
-  createDevKnobs("../data/alexnet2/alexnet2_layers.txt", \
-                 "../data/global_knobs.txt", "dev_knobs.txt")
+  #createDevKnobs("../data/alexnet2/alexnet2_layers.txt", \
+  #               "../data/global_knobs.txt", "dev_knobs.txt")
+
+
+  knobs = getInstallAndDevKnobs("../data/alexnet2/alexnet2_layers.txt", \
+                                "../data/global_knobs.txt")
+
+  print ("*** knobs = ", knobs)