Add a graph transform utility for hexagon

Change: 147385554

Author: tensorflower-gardener

tensorflow/contrib/makefile/build_all_android.sh

@@ -90,7 +90,7 @@ if [[ "${DOWNLOAD_AND_USE_HEXAGON}" == "true" ]]; then
 fi
 
 if [[ ! -z "${HEXAGON_LIB_PATH}" ]]; then
- echo "Copy hexagon libraries"
+ echo "Copy hexagon libraries from ${HEXAGON_LIB_PATH}"
 
  mkdir -p "${HEXAGON_DOWNLOAD_PATH}/libs"
  cp -fv "${HEXAGON_LIB_PATH}/libhexagon_controller.so" \

tensorflow/core/kernels/hexagon/BUILD

@@ -50,6 +50,7 @@ tf_cc_test(
  "graph_transferer_test.cc",
  "hexagon_graph_execution_test.cc",
  ],
+ data = ["//tensorflow/core:example_parser_configuration_testdata"],
  deps = [
  ":graph_transferer",
  "//tensorflow/cc:cc_ops",
@@ -87,7 +88,6 @@ tf_kernel_library(
  "i_graph_transfer_ops_definitions.h",
  "i_soc_control_wrapper.h",
  ],
- data = ["//tensorflow/core:example_parser_configuration_testdata"],
  deps = [
  "//tensorflow/cc:cc_ops",
  "//tensorflow/cc:remote_fused_graph_ops",
@@ -99,3 +99,40 @@ tf_kernel_library(
  "//third_party/eigen3",
  ],
 )
+
+cc_library(
+ name = "hexagon_rewriter_transform",
+ srcs = [
+ "hexagon_rewriter_transform.cc",
+ ],
+ deps = [
+ ":graph_transferer",
+ "//tensorflow/cc:cc_ops",
+ "//tensorflow/cc:remote_fused_graph_ops",
+ "//tensorflow/cc:scope",
+ "//tensorflow/core",
+ "//tensorflow/core:core_cpu",
+ "//tensorflow/core:framework",
+ "//tensorflow/core:lib",
+ "//tensorflow/tools/graph_transforms:transform_utils",
+ "//third_party/eigen3",
+ ],
+ alwayslink = 1,
+)
+
+tf_cc_test(
+ name = "hexagon_rewriter_transform_test",
+ size = "small",
+ srcs = ["hexagon_rewriter_transform_test.cc"],
+ deps = [
+ ":hexagon_rewriter_transform",
+ "//tensorflow/cc:cc_ops",
+ "//tensorflow/core:core_cpu",
+ "//tensorflow/core:core_cpu_internal",
+ "//tensorflow/core:framework",
+ "//tensorflow/core:test",
+ "//tensorflow/core:test_main",
+ "//tensorflow/core:testlib",
+ "//tensorflow/tools/graph_transforms:transform_utils",
+ ],
+)

tensorflow/core/kernels/hexagon/graph_transfer_utils.cc

@@ -58,7 +58,7 @@ GraphTransferUtils::GetTopNFloatResults(const float* const data,
  CHECK(gt != nullptr);
  GraphTransferer::OutputTensorInfo output_tensor_info;
  Status status = gt->DryRunInferenceForAllNode(
- def, inputs, false /* initialize_by_zero */, &output_tensor_info);
+ def, inputs, true /* initialize_by_zero */, &output_tensor_info);
  CHECK(status.ok());
  status = gt->LoadGraphFromProto(ops_definitions, def, inputs, outputs, false,
  output_tensor_info.output_tensor_map);

tensorflow/core/kernels/hexagon/hexagon_graph_execution_test.cc

@@ -12,15 +12,17 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 ==============================================================================*/
-// Before calling this test program, download a model as follows.
-// $ curl https://storage.googleapis.com/download.tensorflow.org/models/tensorflow_inception_v3_stripped_optimized_quantized.pb \
-// -o /tmp/tensorflow_inception_v3_stripped_optimized_quantized.pb
-// adb push /tmp/tensorflow_inception_v3_stripped_optimized_quantized.pb \
-// /data/local/tmp
-// $ curl
-// https://storage.googleapis.com/download.tensorflow.org/models/imagenet_comp_graph_label_strings.txt
-// -o /tmp/imagenet_comp_graph_label_strings.txt
-// adb push /tmp/imagenet_comp_graph_label_strings.txt /data/local/tmp
+/* Before calling this test program, download a model as follows.
+$ curl
+https://storage.googleapis.com/download.tensorflow.org/models/tensorflow_inception_v3_stripped_optimized_quantized.pb
+\ -o /tmp/tensorflow_inception_v3_stripped_optimized_quantized.pb
+$ adb push /tmp/tensorflow_inception_v3_stripped_optimized_quantized.pb \
+/data/local/tmp
+$ curl
+https://storage.googleapis.com/download.tensorflow.org/models/imagenet_comp_graph_label_strings.txt
+-o /tmp/imagenet_comp_graph_label_strings.txt
+adb push /tmp/imagenet_comp_graph_label_strings.txt /data/local/tmp
+*/
 
 #include <memory>
 
@@ -49,15 +51,26 @@ using ConstByteArray = ISocControlWrapper::ConstByteArray;
 constexpr const char* const IMAGE_FILENAME = "/data/local/tmp/img_299x299.bmp";
 constexpr const char* const MODEL_FILENAME =
  "/data/local/tmp/tensorflow_inception_v3_stripped_optimized_quantized.pb";
+constexpr const char* const FUSED_MODEL_FILENAME =
+ "/data/local/tmp/"
+ "tensorflow_inception_v3_stripped_optimized_quantized_fused_hexagon.pb";
+constexpr const char* const REMOTE_FUSED_GRAPH_EXECUTE_NODE_NAME =
+ "remote_fused_graph_execute_node";
 
-const bool USE_TF_RUNTIME = true;
 const bool DBG_DUMP_FLOAT_DATA = false;
 const int WIDTH = 299;
 const int HEIGHT = 299;
 const int DEPTH = 3;
 const int EXPECTED_FIRST_RESULT_ID = 59;
 const int EXECUTION_REPEAT_COUNT = 3;
 
+static void CheckHexagonControllerVersion() {
+ HexagonControlWrapper hexagon_control_wrapper;
+ const int version = hexagon_control_wrapper.GetVersion();
+ ASSERT_GE(version, 1);
+ LOG(INFO) << "Hexagon controller version is " << version;
+}
+
 static void DumpTop10Results(const int byte_size,
  const float* const float_array) {
  const int element_count = byte_size / sizeof(float);
@@ -159,9 +172,6 @@ static void RunInferenceByHexagonControlWrapper(
  img_floats.size() * sizeof(float), DT_FLOAT);
 
  HexagonControlWrapper hexagon_control_wrapper;
- const int version = hexagon_control_wrapper.GetVersion();
- ASSERT_GE(version, 1);
- LOG(INFO) << "Hexagon controller version is " << version;
  // 1. Initialize hexagon
  hexagon_control_wrapper.Init();
 
@@ -196,13 +206,61 @@ static void RunInferenceByHexagonControlWrapper(
  hexagon_control_wrapper.Finalize();
 }
 
+static void RunFusedGraph(const GraphDef& fused_graph_def) {
+ // Setup input tensor
+ std::vector<float> img_floats;
+ LoadImage(&img_floats);
+
+ LOG(INFO) << "Ioading image finished.";
+ Tensor img_tensor(DT_FLOAT, {1, WIDTH, HEIGHT, DEPTH});
+ ASSERT_EQ(WIDTH * HEIGHT * DEPTH, img_floats.size());
+ ASSERT_EQ(img_tensor.TotalBytes(), img_floats.size() * sizeof(float));
+
+ LOG(INFO) << "Copy data to tensor.";
+ std::memcpy(img_tensor.flat<float>().data(), img_floats.data(),
+ img_tensor.TotalBytes());
+
+ // Setup session
+ std::vector<Tensor> output_tensors;
+ SessionOptions session_options;
+ session_options.env = Env::Default();
+ std::unique_ptr<Session> session =
+ std::unique_ptr<Session>(NewSession(session_options));
+ Status status = session->Create(fused_graph_def);
+ ASSERT_TRUE(status.ok());
+
+ // Setup session arguments
+ RunOptions run_options;
+ run_options.set_trace_level(RunOptions::FULL_TRACE);
+ RunMetadata run_metadata;
+
+ std::vector<std::pair<string, tensorflow::Tensor>> input_tensors;
+ input_tensors.emplace_back("Mul", img_tensor);
+ std::vector<string> output_node_names;
+ output_node_names.emplace_back(REMOTE_FUSED_GRAPH_EXECUTE_NODE_NAME);
+
+ LOG(INFO) << "Run graph";
+ // Run inference with all node as output
+ status = session->Run(run_options, input_tensors, output_node_names, {},
+ &output_tensors, &run_metadata);
+ ASSERT_TRUE(status.ok());
+ ASSERT_EQ(1, output_tensors.size());
+ const Tensor& output_tensor = output_tensors.at(0);
+ LOG(INFO) << "Output byte size = " << output_tensor.TotalBytes();
+ LOG(INFO) << "Output shape = " << output_tensor.shape().DebugString();
+ DumpTop10Results(output_tensor.TotalBytes(),
+ output_tensor.flat<float>().data());
+}
+
 // CAVEAT: This test only runs when you specify hexagon library using
 // makefile.
 // TODO(satok): Make this generic so that this can run without any
 // additional steps.
 #ifdef USE_HEXAGON_LIBS
 TEST(GraphTransferer, RunInceptionV3OnHexagonExample) {
- if (USE_TF_RUNTIME) return;
+ LOG(INFO) << "Run inception v3 on hexagon with hexagon controller";
+ CheckHexagonControllerVersion();
+
  const IGraphTransferOpsDefinitions* ops_definitions =
  &HexagonOpsDefinitions::getInstance();
  std::vector<GraphTransferer::InputNodeInfo> input_node_info_list = {
@@ -226,31 +284,22 @@ TEST(GraphTransferer, RunInceptionV3OnHexagonExample) {
 }
 
 TEST(GraphTransferer, RunInceptionV3OnHexagonExampleWithTfRuntime) {
- if (!USE_TF_RUNTIME) return;
+ LOG(INFO) << "Fuse and run inception v3 on hexagon with tf runtime";
+ CheckHexagonControllerVersion();
+
  const IGraphTransferOpsDefinitions* ops_definitions =
  &HexagonOpsDefinitions::getInstance();
  std::vector<GraphTransferer::InputNodeInfo> inputs = {
  GraphTransferer::InputNodeInfo{
  "Mul", Tensor{DT_FLOAT, {1, WIDTH, HEIGHT, DEPTH}}}};
  std::vector<string> outputs = {"softmax"};
- const bool is_text_proto = false;
 
  std::vector<float> img_floats;
  LoadImage(&img_floats);
 
  LOG(INFO) << "Ioading image finished.";
 
- Tensor img_tensor(DT_FLOAT, {1, WIDTH, HEIGHT, DEPTH});
- ASSERT_EQ(WIDTH * HEIGHT * DEPTH, img_floats.size());
- ASSERT_EQ(img_tensor.TotalBytes(), img_floats.size() * sizeof(float));
-
- LOG(INFO) << "Copy data to tensor.";
-
- std::memcpy(img_tensor.flat<float>().data(), img_floats.data(),
- img_tensor.TotalBytes());
-
  GraphDef graph_def;
-
  Status status = ReadBinaryProto(Env::Default(), MODEL_FILENAME, &graph_def);
 
  ASSERT_TRUE(status.ok());
@@ -259,40 +308,22 @@ TEST(GraphTransferer, RunInceptionV3OnHexagonExampleWithTfRuntime) {
  GraphTransferer gt;
  gt.EnableStrictCheckMode(false);
  GraphDef fused_graph_def = GraphTransferUtils::BuildFusedGraphDef(
- HexagonOpsDefinitions::getInstance(), "remote_fused_graph_execute_node",
- inputs, outputs, graph_def, &gt);
-
- // Setup session
- std::vector<Tensor> output_tensors;
- SessionOptions session_options;
- session_options.env = Env::Default();
- std::unique_ptr<Session> session =
- std::unique_ptr<Session>(NewSession(session_options));
- status = session->Create(fused_graph_def);
- ASSERT_TRUE(status.ok());
+ HexagonOpsDefinitions::getInstance(),
+ REMOTE_FUSED_GRAPH_EXECUTE_NODE_NAME, inputs, outputs, graph_def, &gt);
 
- // Setup session arguments
- RunOptions run_options;
- run_options.set_trace_level(RunOptions::FULL_TRACE);
- RunMetadata run_metadata;
+ RunFusedGraph(fused_graph_def);
+}
 
- std::vector<std::pair<string, tensorflow::Tensor>> input_tensors;
- input_tensors.emplace_back("Mul", img_tensor);
- std::vector<string> output_node_names;
- output_node_names.emplace_back("remote_fused_graph_execute_node");
+TEST(GraphTransferer, RunInceptionV3OnHexagonExampleWithFusedGraph) {
+ LOG(INFO) << "Run inception v3 with fused graph";
+ CheckHexagonControllerVersion();
 
- LOG(INFO) << "Run graph";
- // Run inference with all node as output
- status = session->Run(run_options, input_tensors, output_node_names, {},
- &output_tensors, &run_metadata);
- ASSERT_TRUE(status.ok());
- ASSERT_EQ(1, output_tensors.size());
- const Tensor& output_tensor = output_tensors.at(0);
- LOG(INFO) << "Output byte size = " << output_tensor.TotalBytes();
- LOG(INFO) << "Output shape = " << output_tensor.shape().DebugString();
- DumpTop10Results(output_tensor.TotalBytes(),
- output_tensor.flat<float>().data());
+ GraphDef fused_graph_def;
+ Status status =
+ ReadBinaryProto(Env::Default(), FUSED_MODEL_FILENAME, &fused_graph_def);
+ RunFusedGraph(fused_graph_def);
 }
+
 #endif
 
 } // namespace tensorflow

tensorflow/core/kernels/hexagon/hexagon_rewriter_transform.cc

@@ -0,0 +1,91 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Wraps the hexagon rewriter in a transform so it can be used as part of the
+// graph transform tool.
+// A usage example, based on the Image Understanding pipeline:
+/*
+bazel build tensorflow/tools/graph_transforms:transform_graph
+bazel-bin/tensorflow/tools/graph_transforms/transform_graph \
+--in_graph=/tmp/tensorflow_inception_v3_stripped_optimized_quantized.pb \
+--out_graph=\
+/tmp/tensorflow_inception_v3_stripped_optimized_quantized_fused_hexagon.pb \
+--inputs='Mul' \
+--outputs='softmax' \
+--transforms='\
+rewrite_quantized_stripped_model_for_hexagon(
+input_shape0="1,299,299,3" \
+input_type0="float" \
+)'
+*/
+
+#include "tensorflow/core/kernels/hexagon/graph_transfer_utils.h"
+#include "tensorflow/core/kernels/hexagon/hexagon_ops_definitions.h"
+#include "tensorflow/tools/graph_transforms/transform_utils.h"
+
+namespace tensorflow {
+namespace graph_transforms {
+constexpr const char* const INPUT_SHAPE_PREFIX = "input_shape";
+constexpr const char* const INPUT_TYPE_PREFIX = "input_type";
+
+Status RewriteQuantizedStrippedModelForHexagon(
+ const GraphDef& input_graph_def, const TransformFuncContext& context,
+ GraphDef* output_graph_def) {
+ LOG(INFO) << "Transforming quantized stripped model to a remote fused "
+ "graph execute op...";
+ std::vector<GraphTransferer::InputNodeInfo> inputs;
+ std::vector<string> outputs;
+ for (int i = 0; i < context.input_names.size(); ++i) {
+ const string& input_name = context.input_names.at(i);
+
+ // Get input shape
+ string shape_string;
+ TF_RETURN_IF_ERROR(context.GetOneStringParameter(
+ INPUT_SHAPE_PREFIX + std::to_string(i), "", &shape_string));
+ std::vector<int64> dims;
+ CHECK(str_util::SplitAndParseAsInts(shape_string, ',', &dims));
+
+ // Get input data type
+ string data_type_string;
+ TF_RETURN_IF_ERROR(context.GetOneStringParameter(
+ INPUT_TYPE_PREFIX + std::to_string(i), "", &data_type_string));
+ DataType data_type;
+ CHECK(DataTypeFromString(data_type_string, &data_type))
+ << "\"" << data_type_string << "\" was an invalid type";
+
+ LOG(INFO) << "Input(" << i << "): name = " << input_name
+ << ", shape = " << shape_string
+ << ", type = " << data_type_string;
+
+ inputs.emplace_back(GraphTransferer::InputNodeInfo{
+ input_name, {data_type, TensorShape(dims)}});
+ }
+
+ for (const string& output_name : context.output_names) {
+ outputs.emplace_back(output_name);
+ }
+ GraphTransferer gt;
+ gt.EnableStrictCheckMode(false);
+ *output_graph_def = GraphTransferUtils::BuildFusedGraphDef(
+ HexagonOpsDefinitions::getInstance(), "remote_fused_graph_execute_node",
+ inputs, outputs, input_graph_def, &gt);
+ return Status::OK();
+}
+
+REGISTER_GRAPH_TRANSFORM("rewrite_quantized_stripped_model_for_hexagon",
+ RewriteQuantizedStrippedModelForHexagon);
+
+} // namespace graph_transforms
+} // namespace tensorflow