Add input initialization values to benchmark

petewarden · tensorflower-gardener · commit 053087ff366b · 2017-01-06T12:32:16.000-08:00
Change: 143800723
diff --git a/tensorflow/core/lib/strings/str_util.cc b/tensorflow/core/lib/strings/str_util.cc
@@ -355,5 +355,15 @@ bool SplitAndParseAsInts(StringPiece text, char delim,
   return SplitAndParseAsInts<int64>(text, delim, strings::safe_strto64, result);
 }
 
+bool SplitAndParseAsFloats(StringPiece text, char delim,
+                           std::vector<float>* result) {
+  return SplitAndParseAsInts<float>(text, delim,
+                                    [](StringPiece str, float* value) {
+                                      return strings::safe_strtof(
+                                          str.ToString().c_str(), value);
+                                    },
+                                    result);
+}
+
 }  // namespace str_util
 }  // namespace tensorflow
diff --git a/tensorflow/core/lib/strings/str_util.h b/tensorflow/core/lib/strings/str_util.h
@@ -122,6 +122,8 @@ bool SplitAndParseAsInts(StringPiece text, char delim,
                          std::vector<int32>* result);
 bool SplitAndParseAsInts(StringPiece text, char delim,
                          std::vector<int64>* result);
+bool SplitAndParseAsFloats(StringPiece text, char delim,
+                           std::vector<float>* result);
 
 // ------------------------------------------------------------------
 // Implementation details below
diff --git a/tensorflow/core/lib/strings/str_util_test.cc b/tensorflow/core/lib/strings/str_util_test.cc
@@ -301,6 +301,31 @@ TEST(SplitAndParseAsInts, Int64) {
   EXPECT_FALSE(str_util::SplitAndParseAsInts("13,abc,5", ',', &nums));
 }
 
+TEST(SplitAndParseAsFloats, Float) {
+  std::vector<float> nums;
+  EXPECT_TRUE(str_util::SplitAndParseAsFloats("", ',', &nums));
+  EXPECT_EQ(nums.size(), 0);
+
+  EXPECT_TRUE(str_util::SplitAndParseAsFloats("134.2323", ',', &nums));
+  ASSERT_EQ(nums.size(), 1);
+  EXPECT_NEAR(nums[0], 134.2323f, 1e-5f);
+
+  EXPECT_TRUE(str_util::SplitAndParseAsFloats("134.9,2.123,13.0000,-5.999,1e6",
+                                              ',', &nums));
+  ASSERT_EQ(nums.size(), 5);
+  EXPECT_NEAR(nums[0], 134.9f, 1e-5f);
+  EXPECT_NEAR(nums[1], 2.123f, 1e-5f);
+  EXPECT_NEAR(nums[2], 13.0f, 1e-5f);
+  EXPECT_NEAR(nums[3], -5.999f, 1e-5f);
+  EXPECT_NEAR(nums[4], 1e6f, 1e1f);
+
+  EXPECT_FALSE(str_util::SplitAndParseAsFloats("abc", ',', &nums));
+
+  EXPECT_FALSE(str_util::SplitAndParseAsFloats("-13.0,abc", ',', &nums));
+
+  EXPECT_FALSE(str_util::SplitAndParseAsFloats("13.0,abc,-5.999", ',', &nums));
+}
+
 TEST(Lowercase, Basic) {
   EXPECT_EQ("", str_util::Lowercase(""));
   EXPECT_EQ("hello", str_util::Lowercase("hello"));
diff --git a/tensorflow/tools/benchmark/benchmark_model.cc b/tensorflow/tools/benchmark/benchmark_model.cc
@@ -75,30 +75,38 @@ Status InitializeSession(int num_threads, const string& graph,
   return Status::OK();
 }
 
+template <class T>
+void InitializeTensor(const std::vector<float>& initialization_values,
+                      Tensor* input_tensor) {
+  auto type_tensor = input_tensor->flat<T>();
+  type_tensor = type_tensor.constant(0);
+  if (!initialization_values.empty()) {
+    for (int i = 0; i < initialization_values.size(); ++i) {
+      type_tensor(i) = static_cast<T>(initialization_values[i]);
+    }
+  }
+}
+
 void CreateTensorsFromInputInfo(
     const std::vector<InputLayerInfo>& inputs,
     std::vector<std::pair<string, tensorflow::Tensor> >* input_tensors) {
   for (const InputLayerInfo& input : inputs) {
     Tensor input_tensor(input.data_type, input.shape);
     switch (input.data_type) {
       case DT_INT32: {
-        auto int_tensor = input_tensor.flat<int32>();
-        int_tensor = int_tensor.constant(0.0);
+        InitializeTensor<int32>(input.initialization_values, &input_tensor);
         break;
       }
       case DT_FLOAT: {
-        auto float_tensor = input_tensor.flat<float>();
-        float_tensor = float_tensor.constant(0.0);
+        InitializeTensor<float>(input.initialization_values, &input_tensor);
         break;
       }
       case DT_QUINT8: {
-        auto int_tensor = input_tensor.flat<quint8>();
-        int_tensor = int_tensor.constant(0.0);
+        InitializeTensor<quint8>(input.initialization_values, &input_tensor);
         break;
       }
       case DT_UINT8: {
-        auto int_tensor = input_tensor.flat<uint8>();
-        int_tensor = int_tensor.constant(0.0);
+        InitializeTensor<uint8>(input.initialization_values, &input_tensor);
         break;
       }
       default:
@@ -248,6 +256,7 @@ int Main(int argc, char** argv) {
   string input_layer_string = "input:0";
   string input_layer_shape_string = "1,224,224,3";
   string input_layer_type_string = "float";
+  string input_layer_values_string = "";
   string output_layer_string = "output:0";
   int num_runs = 50;
   string run_delay = "-1.0";
@@ -270,6 +279,8 @@ int Main(int argc, char** argv) {
       Flag("input_layer", &input_layer_string, "input layer names"),
       Flag("input_layer_shape", &input_layer_shape_string, "input layer shape"),
       Flag("input_layer_type", &input_layer_type_string, "input layer type"),
+      Flag("input_layer_values", &input_layer_values_string,
+           "values to initialize the inputs with"),
       Flag("output_layer", &output_layer_string, "output layer name"),
       Flag("num_runs", &num_runs, "number of runs"),
       Flag("run_delay", &run_delay, "delay between runs in seconds"),
@@ -304,6 +315,8 @@ int Main(int argc, char** argv) {
       str_util::Split(input_layer_shape_string, ':');
   std::vector<string> input_layer_types =
       str_util::Split(input_layer_type_string, ',');
+  std::vector<string> input_layer_values =
+      str_util::Split(input_layer_values_string, ':');
   std::vector<string> output_layers = str_util::Split(output_layer_string, ',');
   if ((input_layers.size() != input_layer_shapes.size()) ||
       (input_layers.size() != input_layer_types.size())) {
@@ -374,6 +387,12 @@ int Main(int argc, char** argv) {
       input.shape.AddDim(sizes[i]);
     }
     input.name = input_layers[n];
+    if (n < input_layer_values.size()) {
+      CHECK(str_util::SplitAndParseAsFloats(input_layer_values[n], ',',
+                                            &input.initialization_values))
+          << "Incorrect initialization values string specified: "
+          << input_layer_values[n];
+    }
     inputs.push_back(input);
   }
 
diff --git a/tensorflow/tools/benchmark/benchmark_model.h b/tensorflow/tools/benchmark/benchmark_model.h
@@ -27,6 +27,7 @@ struct InputLayerInfo {
   string name;
   DataType data_type;
   TensorShape shape;
+  std::vector<float> initialization_values;
 };
 
 // Loads a model from disk into a new session.
