chore: import upstream snapshot with attribution

tensorflow/lite/examples/label_image/BUILD

@@ -0,0 +1,100 @@
+# Description:
+# TensorFlow Lite Example Label Image.
+
+load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
+load("@rules_cc//cc:cc_library.bzl", "cc_library")
+load("@rules_cc//cc:cc_test.bzl", "cc_test")
+load("//tensorflow/lite:build_def.bzl", "tflite_linkopts")
+
+package(
+    # copybara:uncomment default_applicable_licenses = ["//tensorflow:LICENSE"],
+    default_visibility = ["//visibility:public"],
+    licenses = ["notice"],
+)
+
+exports_files(glob([
+    "testdata/*.bmp",
+]))
+
+cc_binary(
+    name = "label_image",
+    srcs = [
+        "get_top_n.h",
+        "get_top_n_impl.h",
+        "label_image.cc",
+    ],
+    linkopts = tflite_linkopts() + select({
+        "//tensorflow:android": [
+            "-pie",  # Android 5.0 and later supports only PIE
+            "-lm",  # some builtin ops, e.g., tanh, need -lm
+            "-Wl,-rpath=/data/local/tmp",  # for hexagon delegate
+        ],
+        "//conditions:default": [],
+    }),
+    deps = [
+        ":bitmap_helpers",
+        "//tensorflow/lite:framework",
+        "//tensorflow/lite:string",
+        "//tensorflow/lite/c:c_api_types",
+        "//tensorflow/lite/c:common",
+        "//tensorflow/lite/core:cc_api_stable",
+        "//tensorflow/lite/kernels:builtin_ops",
+        "//tensorflow/lite/profiling:profile_buffer",
+        "//tensorflow/lite/profiling:profiler",
+        "//tensorflow/lite/schema:schema_fbs",
+        "//tensorflow/lite/tools:command_line_flags",
+        "//tensorflow/lite/tools:tool_params",
+        "//tensorflow/lite/tools/delegates:delegate_provider_hdr",
+        "//tensorflow/lite/tools/delegates:tflite_execution_providers",
+    ],
+)
+
+cc_library(
+    name = "bitmap_helpers",
+    srcs = ["bitmap_helpers.cc"],
+    hdrs = [
+        "bitmap_helpers.h",
+        "bitmap_helpers_impl.h",
+        "label_image.h",
+        "log.h",
+    ],
+    deps = [
+        "//tensorflow/core/platform:tstring",
+        "//tensorflow/lite:builtin_op_data",
+        "//tensorflow/lite:framework",
+        "//tensorflow/lite:string",
+        "//tensorflow/lite:string_util",
+        "//tensorflow/lite/c:c_api_types",
+        "//tensorflow/lite/kernels:builtin_ops",
+        "//tensorflow/lite/schema:schema_fbs",
+        "@tsl//tsl/platform:tstring",
+    ] + select({
+        "//tensorflow:android": [
+            "//tensorflow/lite/delegates/gpu:delegate",
+            "//tensorflow/lite/delegates/hexagon:hexagon_delegate",
+        ],
+        "//tensorflow:android_arm64": [
+            "//tensorflow/lite/delegates/gpu:delegate",
+            "//tensorflow/lite/delegates/hexagon:hexagon_delegate",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+cc_test(
+    name = "label_image_test",
+    srcs = [
+        "get_top_n.h",
+        "get_top_n_impl.h",
+        "label_image_test.cc",
+    ],
+    data = [
+        "testdata/grace_hopper.bmp",
+    ],
+    deps = [
+        ":bitmap_helpers",
+        "//tensorflow/lite/c:c_api_types",
+        "//tensorflow/lite/c:common",
+        "@com_google_googletest//:gtest_main",
+    ],
+)

tensorflow/lite/examples/label_image/CMakeLists.txt

@@ -0,0 +1,89 @@
+#
+# Copyright 2021 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
+#
+#      https://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.
+
+
+# The label_image example for Tensorflow Lite.
+
+populate_source_vars("${TFLITE_SOURCE_DIR}/examples/label_image"
+  TFLITE_LABEL_IMAGE_SRCS
+  FILTER "_test\\.cc$"
+)
+list(APPEND TFLITE_LABEL_IMAGE_SRCS
+  ${XLA_SOURCE_DIR}/xla/tsl/util/stats_calculator.cc
+  ${TFLITE_SOURCE_DIR}/profiling/memory_info.cc
+  ${TFLITE_SOURCE_DIR}/profiling/profile_buffer.cc
+  ${TFLITE_SOURCE_DIR}/profiling/profile_summarizer.cc
+  ${TFLITE_SOURCE_DIR}/profiling/profile_summary_formatter.cc
+  ${TFLITE_SOURCE_DIR}/profiling/time.cc
+  ${TFLITE_SOURCE_DIR}/tools/command_line_flags.cc
+  ${TFLITE_SOURCE_DIR}/tools/delegates/default_execution_provider.cc
+  ${TFLITE_SOURCE_DIR}/tools/delegates/delegate_provider.cc
+  ${TFLITE_SOURCE_DIR}/tools/evaluation/utils.cc
+  ${TFLITE_SOURCE_DIR}/tools/tool_params.cc
+)
+
+if(TFLITE_ENABLE_XNNPACK)
+  list(APPEND TFLITE_LABEL_IMAGE_SRCS
+    ${TFLITE_SOURCE_DIR}/tools/delegates/xnnpack_delegate_provider.cc
+    ${TFLITE_SOURCE_DIR}/core/acceleration/configuration/c/xnnpack_plugin.cc
+  )
+else()
+  set(TFLITE_LABEL_IMAGE_CC_OPTIONS "-DTFLITE_WITHOUT_XNNPACK")
+endif()  # TFLITE_ENABLE_XNNPACK
+
+if(CMAKE_SYSTEM_NAME MATCHES "Android")
+  if(_TFLITE_ENABLE_NNAPI)
+    list(APPEND TFLITE_LABEL_IMAGE_SRCS
+      ${TFLITE_SOURCE_DIR}/tools/delegates/nnapi_delegate_provider.cc
+    )
+  endif()  # _TFLITE_ENABLE_NNAPI
+endif()  # Android
+
+if(TFLITE_ENABLE_GPU)
+  list(APPEND TFLITE_LABEL_IMAGE_SRCS
+    ${TFLITE_SOURCE_DIR}/tools/delegates/gpu_delegate_provider.cc
+  )
+endif()  # TFLITE_ENABLE_GPU
+
+if(TFLITE_ENABLE_EXTERNAL_DELEGATE)
+  list(APPEND TFLITE_LABEL_IMAGE_SRCS
+          ${TFLITE_SOURCE_DIR}/tools/delegates/external_delegate_provider.cc)
+endif()
+
+include_directories(label_image
+  PUBLIC
+  ${CMAKE_BINARY_DIR}
+)
+
+add_executable(label_image
+  ${TFLITE_LABEL_IMAGE_SRCS}
+)
+if(TFLITE_ENABLE_LABEL_IMAGE)
+  set_target_properties(label_image PROPERTIES EXCLUDE_FROM_ALL FALSE)
+  if(TFLITE_ENABLE_INSTALL)
+    install(TARGETS label_image)
+  endif()  # TFLITE_ENABLE_INSTALL
+else()
+  set_target_properties(label_image PROPERTIES EXCLUDE_FROM_ALL TRUE)
+endif()  # TFLITE_ENABLE_LABEL_IMAGE
+target_compile_options(label_image
+  PRIVATE
+    ${TFLITE_LABEL_IMAGE_CC_OPTIONS}
+)
+target_link_libraries(label_image
+  tensorflow-lite
+  profiling_info_proto
+  libprotobuf
+)

tensorflow/lite/examples/label_image/README.md

@@ -0,0 +1,241 @@
+# TensorFlow Lite C++ image classification demo
+
+This example shows how you can load a pre-trained and converted
+TensorFlow Lite model and use it to recognize objects in images.
+
+Before you begin,
+make sure you [have TensorFlow installed](https://www.tensorflow.org/install).
+
+You also need to
+[install Bazel](https://docs.bazel.build/versions/master/install.html) in order
+to build this example code. And be sure you have the Python `future` module
+installed:
+
+```
+pip install future --user
+```
+
+## Build the example
+
+First run `$TENSORFLOW_ROOT/configure`. To build for Android, set
+Android NDK or configure NDK setting in
+`$TENSORFLOW_ROOT/WORKSPACE` first.
+
+Build it for desktop machines (tested on Ubuntu and OS X):
+
+```
+bazel build -c opt //tensorflow/lite/examples/label_image:label_image
+```
+
+Build it for Android ARMv8:
+
+```
+bazel build -c opt --config=android_arm64 \
+  //tensorflow/lite/examples/label_image:label_image
+```
+
+Build it for Android arm-v7a:
+
+```
+bazel build -c opt --config=android_arm \
+  //tensorflow/lite/examples/label_image:label_image
+```
+
+## Download sample model and image
+
+You can use any compatible model, but the following MobileNet v1 model offers
+a good demonstration of a model trained to recognize 1,000 different objects.
+
+```
+# Get model
+curl https://storage.googleapis.com/download.tensorflow.org/models/mobilenet_v1_2018_02_22/mobilenet_v1_1.0_224.tgz | tar xzv -C /tmp
+
+# Get labels
+curl https://storage.googleapis.com/download.tensorflow.org/models/mobilenet_v1_1.0_224_frozen.tgz  | tar xzv -C /tmp  mobilenet_v1_1.0_224/labels.txt
+
+mv /tmp/mobilenet_v1_1.0_224/labels.txt /tmp/
+```
+
+## Run the sample on a desktop
+
+```
+bazel-bin/tensorflow/lite/examples/label_image/label_image \
+  --tflite_model /tmp/mobilenet_v1_1.0_224.tflite \
+  --labels /tmp/labels.txt \
+  --image tensorflow/lite/examples/label_image/testdata/grace_hopper.bmp
+```
+
+You should see results like this:
+
+```
+Loaded model /tmp/mobilenet_v1_1.0_224.tflite
+resolved reporter
+invoked
+average time: 68.12 ms
+0.860174: 653 653:military uniform
+0.0481017: 907 907:Windsor tie
+0.00786704: 466 466:bulletproof vest
+0.00644932: 514 514:cornet, horn, trumpet, trump
+0.00608029: 543 543:drumstick
+```
+
+## Run the sample on an Android device
+
+Prepare data on devices, e.g.,
+
+```
+adb push bazel-bin/tensorflow/lite/examples/label_image/label_image  /data/local/tmp
+adb push /tmp/mobilenet_v1_1.0_224.tflite  /data/local/tmp
+adb push tensorflow/lite/examples/label_image/testdata/grace_hopper.bmp  /data/local/tmp
+adb push /tmp/labels.txt /data/local/tmp
+```
+
+Run it,
+
+```
+adb shell "/data/local/tmp/label_image \
+    -m /data/local/tmp/mobilenet_v1_1.0_224.tflite \
+    -i /data/local/tmp/grace_hopper.bmp \
+    -l /data/local/tmp/labels.txt"
+```
+
+then you should see something like the following:
+
+```
+Loaded model /data/local/tmp/mobilenet_v1_1.0_224.tflite
+resolved reporter
+INFO: Initialized TensorFlow Lite runtime.
+invoked
+average time: 25.03 ms
+0.907071: 653 military uniform
+0.0372416: 907 Windsor tie
+0.00733753: 466 bulletproof vest
+0.00592852: 458 bow tie
+0.00414091: 514 cornet
+```
+
+Run the model with NNAPI delegate (`-a 1`),
+
+```
+adb shell "/data/local/tmp/label_image \
+    -m /data/local/tmp/mobilenet_v1_1.0_224.tflite \
+    -i /data/local/tmp/grace_hopper.bmp \
+    -l /data/local/tmp/labels.txt -a 1 -f 1"
+```
+
+then you should see something like the following:
+
+```
+Loaded model /data/local/tmp/mobilenet_v1_1.0_224.tflite
+resolved reporter
+INFO: Initialized TensorFlow Lite runtime.
+INFO: Created TensorFlow Lite delegate for NNAPI. Applied NNAPI delegate.
+invoked
+average time:10.348 ms
+0.905401: 653 military uniform
+0.0379589: 907 Windsor tie
+0.00735866: 466 bulletproof vest
+0.00605307: 458 bow tie
+0.00422573: 514 cornet
+```
+
+To run a model with the Hexagon Delegate, assuming we have followed the
+[Hexagon Delegate Guide](https://www.tensorflow.org/lite/android/delegates/hexagon)
+and installed Hexagon libraries in `/data/local/tmp`. Run it with (`-j 1`)
+
+```
+adb shell \
+    "/data/local/tmp/label_image \
+    -m /data/local/tmp/mobilenet_v1_1.0_224_quant.tflite \
+    -i /data/local/tmp/grace_hopper.bmp \
+    -l /data/local/tmp/labels.txt -j 1"
+```
+
+then you should see something like the followings:
+
+```
+Loaded model /data/local/tmp/mobilenet_v1_1.0_224_quant.tflite
+resolved reporter
+INFO: Initialized TensorFlow Lite runtime.
+loaded libcdsprpc.so
+INFO: Created TensorFlow Lite delegate for Hexagon.
+INFO: Hexagon delegate: 31 nodes delegated out of 31 nodes with 1 partitions.
+Applied Hexagon delegate.
+invoked
+average time: 4.231 ms
+0.639216: 458 bow tie
+0.329412: 653 military uniform
+0.00784314: 835 suit
+0.00784314: 611 jersey
+0.00392157: 514 cornet
+```
+
+Run the model with the XNNPACK delegate (`-x 1`),
+
+```shell
+adb shell \
+    "/data/local/tmp/label_image \
+    -m /data/local/tmp/mobilenet_v1_1.0_224.tflite \
+    -i /data/local/tmp/grace_hopper.bmp \
+    -l /data/local/tmp/labels.txt -x 1"
+```
+
+then you should see something like the following:
+
+```
+Loaded model /data/local/tmp/mobilenet_v1_1.0_224.tflite
+resolved reporter
+INFO: Initialized TensorFlow Lite runtime. Applied XNNPACK delegate.
+invoked
+average time: 17.33 ms
+0.90707: 653 military uniform
+0.0372418: 907 Windsor tie
+0.0073376: 466 bulletproof vest
+0.00592857: 458 bow tie
+0.00414093: 514 cornet
+```
+
+With `-h` or any other unsupported flags, `label_image` will list supported
+options:
+
+```shell
+sargo:/data/local/tmp $ ./label_image -h
+./label_image: invalid option -- h
+label_image
+--accelerated, -a: [0|1], use Android NNAPI or not
+--old_accelerated, -d: [0|1], use old Android NNAPI delegate or not
+--allow_fp16, -f: [0|1], allow running fp32 models with fp16 or not
+--count, -c: loop interpreter->Invoke() for certain times
+--gl_backend, -g: [0|1]: use GPU Delegate on Android
+--hexagon_delegate, -j: [0|1]: use Hexagon Delegate on Android
+--input_mean, -b: input mean
+--input_std, -s: input standard deviation
+--image, -i: image_name.bmp
+--labels, -l: labels for the model
+--tflite_model, -m: model_name.tflite
+--profiling, -p: [0|1], profiling or not
+--num_results, -r: number of results to show
+--threads, -t: number of threads
+--verbose, -v: [0|1] print more information
+--warmup_runs, -w: number of warmup runs
+--xnnpack_delegate, -x [0:1]: xnnpack delegate`
+```
+
+See the `label_image.cc` source code for other command line options.
+
+Note that this binary also supports more runtime/delegate arguments introduced
+by the [delegate registrar](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/tools/delegates).
+If there is any conflict, the arguments mentioned earlier are given precedence.
+For example, you can run the binary with additional command line options
+such as `--use_nnapi=true --nnapi_accelerator_name=google-edgetpu` to utilize
+the EdgeTPU in a 4th-gen Pixel phone. Please be aware that the "=" in the option
+should not be omitted.
+
+```
+adb shell \
+    "/data/local/tmp/label_image \
+    -m /data/local/tmp/mobilenet_v1_1.0_224_quant.tflite \
+    -i /data/local/tmp/grace_hopper.bmp \
+    -l /data/local/tmp/labels.txt -j 1 \
+    --use_nnapi=true --nnapi_accelerator_name=google-edgetpu"
+```

tensorflow/lite/examples/label_image/bitmap_helpers.cc

@@ -0,0 +1,126 @@
+/* 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.
+==============================================================================*/
+
+#include "tensorflow/lite/examples/label_image/bitmap_helpers.h"
+
+#include <unistd.h>  // NOLINT(build/include_order)
+
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include "tensorflow/lite/examples/label_image/label_image.h"
+#include "tensorflow/lite/examples/label_image/log.h"
+#include "tsl/platform/ctstring_internal.h"
+
+namespace tflite {
+namespace label_image {
+
+std::vector<uint8_t> decode_bmp(const uint8_t* input, int row_size, int width,
+                                int height, int channels, bool top_down) {
+  std::vector<uint8_t> output(height * width * channels);
+  for (int i = 0; i < height; i++) {
+    int src_pos;
+    int dst_pos;
+
+    for (int j = 0; j < width; j++) {
+      if (!top_down) {
+        src_pos = ((height - 1 - i) * row_size) + j * channels;
+      } else {
+        src_pos = i * row_size + j * channels;
+      }
+
+      dst_pos = (i * width + j) * channels;
+
+      switch (channels) {
+        case 1:
+          output[dst_pos] = input[src_pos];
+          break;
+        case 3:
+          // BGR -> RGB
+          output[dst_pos] = input[src_pos + 2];
+          output[dst_pos + 1] = input[src_pos + 1];
+          output[dst_pos + 2] = input[src_pos];
+          break;
+        case 4:
+          // BGRA -> RGBA
+          output[dst_pos] = input[src_pos + 2];
+          output[dst_pos + 1] = input[src_pos + 1];
+          output[dst_pos + 2] = input[src_pos];
+          output[dst_pos + 3] = input[src_pos + 3];
+          break;
+        default:
+          LOG(FATAL) << "Unexpected number of channels: " << channels;
+          break;
+      }
+    }
+  }
+  return output;
+}
+
+std::vector<uint8_t> read_bmp(const std::string& input_bmp_name, int* width,
+                              int* height, int* channels, Settings* s) {
+  int begin, end;
+
+  std::ifstream file(input_bmp_name, std::ios::in | std::ios::binary);
+  if (!file) {
+    LOG(FATAL) << "input file " << input_bmp_name << " not found";
+    exit(-1);
+  }
+
+  begin = file.tellg();
+  file.seekg(0, std::ios::end);
+  end = file.tellg();
+  size_t len = end - begin;
+
+  if (s->verbose) LOG(INFO) << "len: " << len;
+
+  std::vector<uint8_t> img_bytes(len);
+  file.seekg(0, std::ios::beg);
+  file.read(reinterpret_cast<char*>(img_bytes.data()), len);
+  const int32_t header_size =
+      TF_le32toh(*(reinterpret_cast<const int32_t*>(img_bytes.data() + 10)));
+  *width =
+      TF_le32toh(*(reinterpret_cast<const int32_t*>(img_bytes.data() + 18)));
+  *height =
+      TF_le32toh(*(reinterpret_cast<const int32_t*>(img_bytes.data() + 22)));
+  const int32_t bpp =
+      TF_le32toh(*(reinterpret_cast<const int32_t*>(img_bytes.data() + 28)));
+  *channels = bpp / 8;
+
+  if (s->verbose)
+    LOG(INFO) << "width, height, channels: " << *width << ", " << *height
+              << ", " << *channels;
+
+  // there may be padding bytes when the width is not a multiple of 4 bytes
+  // 8 * channels == bits per pixel
+  const int row_size = (8 * *channels * *width + 31) / 32 * 4;
+
+  // if height is negative, data layout is top down
+  // otherwise, it's bottom up
+  bool top_down = (*height < 0);
+
+  // Decode image, allocating tensor once the image size is known
+  const uint8_t* bmp_pixels = &img_bytes[header_size];
+  return decode_bmp(bmp_pixels, row_size, *width, abs(*height), *channels,
+                    top_down);
+}
+
+}  // namespace label_image
+}  // namespace tflite

tensorflow/lite/examples/label_image/bitmap_helpers.h

@@ -0,0 +1,46 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_LITE_EXAMPLES_LABEL_IMAGE_BITMAP_HELPERS_H_
+#define TENSORFLOW_LITE_EXAMPLES_LABEL_IMAGE_BITMAP_HELPERS_H_
+
+#include <string>
+
+#include "tensorflow/lite/examples/label_image/bitmap_helpers_impl.h"  // IWYU pragma: export
+#include "tensorflow/lite/examples/label_image/label_image.h"
+
+namespace tflite {
+namespace label_image {
+
+std::vector<uint8_t> read_bmp(const std::string& input_bmp_name, int* width,
+                              int* height, int* channels, Settings* s);
+
+template <class T>
+void resize(T* out, uint8_t* in, int image_height, int image_width,
+            int image_channels, int wanted_height, int wanted_width,
+            int wanted_channels, Settings* s);
+
+// explicit instantiation
+template void resize<float>(float*, unsigned char*, int, int, int, int, int,
+                            int, Settings*);
+template void resize<int8_t>(int8_t*, unsigned char*, int, int, int, int, int,
+                             int, Settings*);
+template void resize<uint8_t>(uint8_t*, unsigned char*, int, int, int, int, int,
+                              int, Settings*);
+
+}  // namespace label_image
+}  // namespace tflite
+
+#endif  // TENSORFLOW_LITE_EXAMPLES_LABEL_IMAGE_BITMAP_HELPERS_H_

tensorflow/lite/examples/label_image/bitmap_helpers_impl.h

@@ -0,0 +1,105 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_LITE_EXAMPLES_LABEL_IMAGE_BITMAP_HELPERS_IMPL_H_
+#define TENSORFLOW_LITE_EXAMPLES_LABEL_IMAGE_BITMAP_HELPERS_IMPL_H_
+
+#include "tensorflow/lite/examples/label_image/label_image.h"
+
+#include "tensorflow/lite/builtin_op_data.h"
+#include "tensorflow/lite/interpreter.h"
+#include "tensorflow/lite/kernels/register.h"
+#include "tensorflow/lite/string_util.h"
+
+namespace tflite {
+namespace label_image {
+
+template <class T>
+void resize(T* out, uint8_t* in, int image_height, int image_width,
+            int image_channels, int wanted_height, int wanted_width,
+            int wanted_channels, Settings* s) {
+  int number_of_pixels = image_height * image_width * image_channels;
+  std::unique_ptr<Interpreter> interpreter(new Interpreter);
+
+  int base_index = 0;
+
+  // two inputs: input and new_sizes
+  interpreter->AddTensors(2, &base_index);
+  // one output
+  interpreter->AddTensors(1, &base_index);
+  // set input and output tensors
+  interpreter->SetInputs({0, 1});
+  interpreter->SetOutputs({2});
+
+  // set parameters of tensors
+  TfLiteQuantizationParams quant;
+  interpreter->SetTensorParametersReadWrite(
+      0, kTfLiteFloat32, "input",
+      {1, image_height, image_width, image_channels}, quant);
+  interpreter->SetTensorParametersReadWrite(1, kTfLiteInt32, "new_size", {2},
+                                            quant);
+  interpreter->SetTensorParametersReadWrite(
+      2, kTfLiteFloat32, "output",
+      {1, wanted_height, wanted_width, wanted_channels}, quant);
+
+  ops::builtin::BuiltinOpResolver resolver;
+  const TfLiteRegistration* resize_op =
+      resolver.FindOp(BuiltinOperator_RESIZE_BILINEAR, 1);
+  auto* params = reinterpret_cast<TfLiteResizeBilinearParams*>(
+      malloc(sizeof(TfLiteResizeBilinearParams)));
+  params->align_corners = false;
+  params->half_pixel_centers = false;
+  interpreter->AddNodeWithParameters({0, 1}, {2}, nullptr, 0, params, resize_op,
+                                     nullptr);
+
+  interpreter->AllocateTensors();
+
+  // fill input image
+  // in[] are integers, cannot do memcpy() directly
+  auto input = interpreter->typed_tensor<float>(0);
+  for (int i = 0; i < number_of_pixels; i++) {
+    input[i] = in[i];
+  }
+
+  // fill new_sizes
+  interpreter->typed_tensor<int>(1)[0] = wanted_height;
+  interpreter->typed_tensor<int>(1)[1] = wanted_width;
+
+  interpreter->Invoke();
+
+  auto output = interpreter->typed_tensor<float>(2);
+  auto output_number_of_pixels = wanted_height * wanted_width * wanted_channels;
+
+  for (int i = 0; i < output_number_of_pixels; i++) {
+    switch (s->input_type) {
+      case kTfLiteFloat32:
+        out[i] = (output[i] - s->input_mean) / s->input_std;
+        break;
+      case kTfLiteInt8:
+        out[i] = static_cast<int8_t>(output[i] - 128);
+        break;
+      case kTfLiteUInt8:
+        out[i] = static_cast<uint8_t>(output[i]);
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+}  // namespace label_image
+}  // namespace tflite
+
+#endif  // TENSORFLOW_LITE_EXAMPLES_LABEL_IMAGE_BITMAP_HELPERS_IMPL_H_

tensorflow/lite/examples/label_image/get_top_n.h

@@ -0,0 +1,47 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_LITE_EXAMPLES_LABEL_IMAGE_GET_TOP_N_H_
+#define TENSORFLOW_LITE_EXAMPLES_LABEL_IMAGE_GET_TOP_N_H_
+
+#include <cstddef>
+#include <utility>
+#include <vector>
+
+#include "tensorflow/lite/c/c_api_types.h"
+#include "tensorflow/lite/examples/label_image/get_top_n_impl.h"  // IWYU pragma: export
+
+namespace tflite {
+namespace label_image {
+
+template <class T>
+void get_top_n(T* prediction, int prediction_size, size_t num_results,
+               float threshold, std::vector<std::pair<float, int>>* top_results,
+               TfLiteType input_type);
+
+// explicit instantiation so that we can use them otherwhere
+template void get_top_n<float>(float*, int, size_t, float,
+                               std::vector<std::pair<float, int>>*, TfLiteType);
+template void get_top_n<int8_t>(int8_t*, int, size_t, float,
+                                std::vector<std::pair<float, int>>*,
+                                TfLiteType);
+template void get_top_n<uint8_t>(uint8_t*, int, size_t, float,
+                                 std::vector<std::pair<float, int>>*,
+                                 TfLiteType);
+
+}  // namespace label_image
+}  // namespace tflite
+
+#endif  // TENSORFLOW_LITE_EXAMPLES_LABEL_IMAGE_GET_TOP_N_H_

tensorflow/lite/examples/label_image/get_top_n_impl.h

@@ -0,0 +1,83 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_LITE_EXAMPLES_LABEL_IMAGE_GET_TOP_N_IMPL_H_
+#define TENSORFLOW_LITE_EXAMPLES_LABEL_IMAGE_GET_TOP_N_IMPL_H_
+
+#include <algorithm>
+#include <functional>
+#include <queue>
+
+#include "tensorflow/lite/c/common.h"
+
+namespace tflite {
+namespace label_image {
+
+extern bool input_floating;
+
+// Returns the top N confidence values over threshold in the provided vector,
+// sorted by confidence in descending order.
+template <class T>
+void get_top_n(T* prediction, int prediction_size, size_t num_results,
+               float threshold, std::vector<std::pair<float, int>>* top_results,
+               TfLiteType input_type) {
+  // Will contain top N results in ascending order.
+  std::priority_queue<std::pair<float, int>, std::vector<std::pair<float, int>>,
+                      std::greater<std::pair<float, int>>>
+      top_result_pq;
+
+  const long count = prediction_size;  // NOLINT(runtime/int)
+  float value = 0.0;
+
+  for (int i = 0; i < count; ++i) {
+    switch (input_type) {
+      case kTfLiteFloat32:
+        value = prediction[i];
+        break;
+      case kTfLiteInt8:
+        value = (prediction[i] + 128) / 256.0;
+        break;
+      case kTfLiteUInt8:
+        value = prediction[i] / 255.0;
+        break;
+      default:
+        break;
+    }
+    // Only add it if it beats the threshold and has a chance at being in
+    // the top N.
+    if (value < threshold) {
+      continue;
+    }
+
+    top_result_pq.push(std::pair<float, int>(value, i));
+
+    // If at capacity, kick the smallest value out.
+    if (top_result_pq.size() > num_results) {
+      top_result_pq.pop();
+    }
+  }
+
+  // Copy to output vector and reverse into descending order.
+  while (!top_result_pq.empty()) {
+    top_results->push_back(top_result_pq.top());
+    top_result_pq.pop();
+  }
+  std::reverse(top_results->begin(), top_results->end());
+}
+
+}  // namespace label_image
+}  // namespace tflite
+
+#endif  // TENSORFLOW_LITE_EXAMPLES_LABEL_IMAGE_GET_TOP_N_IMPL_H_

tensorflow/lite/examples/label_image/label_image.cc

@@ -0,0 +1,557 @@
+/* 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.
+==============================================================================*/
+
+#include "tensorflow/lite/examples/label_image/label_image.h"
+
+#include <fcntl.h>      // NOLINT(build/include_order)
+#include <getopt.h>     // NOLINT(build/include_order)
+#include <sys/time.h>   // NOLINT(build/include_order)
+#include <sys/types.h>  // NOLINT(build/include_order)
+#include <sys/uio.h>    // NOLINT(build/include_order)
+#include <unistd.h>     // NOLINT(build/include_order)
+
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "tensorflow/lite/c/c_api_types.h"
+#include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/core/interpreter_builder.h"
+#include "tensorflow/lite/examples/label_image/bitmap_helpers.h"
+#include "tensorflow/lite/examples/label_image/get_top_n.h"
+#include "tensorflow/lite/examples/label_image/log.h"
+#include "tensorflow/lite/interpreter.h"
+#include "tensorflow/lite/kernels/register.h"
+#include "tensorflow/lite/model_builder.h"
+#include "tensorflow/lite/optional_debug_tools.h"
+#include "tensorflow/lite/profiling/profile_buffer.h"
+#include "tensorflow/lite/profiling/profiler.h"
+#include "tensorflow/lite/schema/schema_generated.h"
+#include "tensorflow/lite/string_type.h"
+#include "tensorflow/lite/tools/command_line_flags.h"
+#include "tensorflow/lite/tools/delegates/delegate_provider.h"
+#include "tensorflow/lite/tools/tool_params.h"
+
+namespace tflite {
+namespace label_image {
+
+double get_us(struct timeval t) { return (t.tv_sec * 1000000 + t.tv_usec); }
+
+using TfLiteDelegatePtr = tflite::Interpreter::TfLiteDelegatePtr;
+using ProvidedDelegateList = tflite::tools::ProvidedDelegateList;
+
+class DelegateProviders {
+ public:
+  DelegateProviders() : delegate_list_util_(&params_) {
+    delegate_list_util_.AddAllDelegateParams();
+    delegate_list_util_.AppendCmdlineFlags(flags_);
+
+    // Remove the "help" flag to avoid printing "--help=false"
+    params_.RemoveParam("help");
+    delegate_list_util_.RemoveCmdlineFlag(flags_, "help");
+  }
+
+  // Initialize delegate-related parameters from parsing command line arguments,
+  // and remove the matching arguments from (*argc, argv). Returns true if all
+  // recognized arg values are parsed correctly.
+  bool InitFromCmdlineArgs(int* argc, const char** argv) {
+    // Note if '--help' is in argv, the Flags::Parse return false,
+    // see the return expression in Flags::Parse.
+    return Flags::Parse(argc, argv, flags_);
+  }
+
+  // According to passed-in settings `s`, this function sets corresponding
+  // parameters that are defined by various delegate execution providers. See
+  // lite/tools/delegates/README.md for the full list of parameters defined.
+  void MergeSettingsIntoParams(const Settings& s) {
+    // Parse settings related to GPU delegate.
+    // Note that GPU delegate does support OpenCL. 'gl_backend' was introduced
+    // when the GPU delegate only supports OpenGL. Therefore, we consider
+    // setting 'gl_backend' to true means using the GPU delegate.
+    if (s.gl_backend) {
+      if (!params_.HasParam("use_gpu")) {
+        LOG(WARN) << "GPU delegate execution provider isn't linked or GPU "
+                     "delegate isn't supported on the platform!";
+      } else {
+        params_.Set<bool>("use_gpu", true);
+        // The parameter "gpu_inference_for_sustained_speed" isn't available for
+        // iOS devices.
+        if (params_.HasParam("gpu_inference_for_sustained_speed")) {
+          params_.Set<bool>("gpu_inference_for_sustained_speed", true);
+        }
+        params_.Set<bool>("gpu_precision_loss_allowed", s.allow_fp16);
+      }
+    }
+
+    // Parse settings related to NNAPI delegate.
+    if (s.accel) {
+      if (!params_.HasParam("use_nnapi")) {
+        LOG(WARN) << "NNAPI delegate execution provider isn't linked or NNAPI "
+                     "delegate isn't supported on the platform!";
+      } else {
+        params_.Set<bool>("use_nnapi", true);
+        params_.Set<bool>("nnapi_allow_fp16", s.allow_fp16);
+      }
+    }
+
+    // Parse settings related to Hexagon delegate.
+    if (s.hexagon_delegate) {
+      if (!params_.HasParam("use_hexagon")) {
+        LOG(WARN) << "Hexagon delegate execution provider isn't linked or "
+                     "Hexagon delegate isn't supported on the platform!";
+      } else {
+        params_.Set<bool>("use_hexagon", true);
+        params_.Set<bool>("hexagon_profiling", s.profiling);
+      }
+    }
+
+    // Parse settings related to XNNPACK delegate.
+    if (s.xnnpack_delegate) {
+      if (!params_.HasParam("use_xnnpack")) {
+        LOG(WARN) << "XNNPACK delegate execution provider isn't linked or "
+                     "XNNPACK delegate isn't supported on the platform!";
+      } else {
+        params_.Set<bool>("use_xnnpack", true);
+        params_.Set<int32_t>("num_threads", s.number_of_threads);
+      }
+    }
+  }
+
+  // Create a list of TfLite delegates based on what have been initialized (i.e.
+  // 'params_').
+  std::vector<ProvidedDelegateList::ProvidedDelegate> CreateAllDelegates()
+      const {
+    return delegate_list_util_.CreateAllRankedDelegates();
+  }
+
+  std::string GetHelpMessage(const std::string& cmdline) const {
+    return Flags::Usage(cmdline, flags_);
+  }
+
+ private:
+  // Contain delegate-related parameters that are initialized from command-line
+  // flags.
+  tflite::tools::ToolParams params_;
+
+  // A helper to create TfLite delegates.
+  ProvidedDelegateList delegate_list_util_;
+
+  // Contains valid flags
+  std::vector<tflite::Flag> flags_;
+};
+
+// Takes a file name, and loads a list of labels from it, one per line, and
+// returns a vector of the strings. It pads with empty strings so the length
+// of the result is a multiple of 16, because our model expects that.
+TfLiteStatus ReadLabelsFile(const string& file_name,
+                            std::vector<string>* result,
+                            size_t* found_label_count) {
+  std::ifstream file(file_name);
+  if (!file) {
+    LOG(ERROR) << "Labels file " << file_name << " not found";
+    return kTfLiteError;
+  }
+  result->clear();
+  string line;
+  while (std::getline(file, line)) {
+    result->push_back(line);
+  }
+  *found_label_count = result->size();
+  const int padding = 16;
+  while (result->size() % padding) {
+    result->emplace_back();
+  }
+  return kTfLiteOk;
+}
+
+void PrintProfilingInfo(const profiling::ProfileEvent* e,
+                        uint32_t subgraph_index, uint32_t op_index,
+                        TfLiteRegistration registration) {
+  // output something like
+  // time (ms) , Node xxx, OpCode xxx, symbolic name
+  //      5.352, Node   5, OpCode   4, DEPTHWISE_CONV_2D
+
+  LOG(INFO) << std::fixed << std::setw(10) << std::setprecision(3)
+            << (e->elapsed_time) / 1000.0 << ", Subgraph " << std::setw(3)
+            << std::setprecision(3) << subgraph_index << ", Node "
+            << std::setw(3) << std::setprecision(3) << op_index << ", OpCode "
+            << std::setw(3) << std::setprecision(3) << registration.builtin_code
+            << ", "
+            << EnumNameBuiltinOperator(
+                   static_cast<BuiltinOperator>(registration.builtin_code));
+}
+
+void RunInference(Settings* settings,
+                  const DelegateProviders& delegate_providers) {
+  if (!settings->model_name.c_str()) {
+    LOG(ERROR) << "no model file name";
+    exit(-1);
+  }
+
+  std::unique_ptr<tflite::FlatBufferModel> model;
+  std::unique_ptr<tflite::Interpreter> interpreter;
+  model = tflite::FlatBufferModel::BuildFromFile(settings->model_name.c_str());
+  if (!model) {
+    LOG(ERROR) << "Failed to mmap model " << settings->model_name;
+    exit(-1);
+  }
+  settings->model = model.get();
+  LOG(INFO) << "Loaded model " << settings->model_name;
+  model->error_reporter();
+  LOG(INFO) << "resolved reporter";
+
+  tflite::ops::builtin::BuiltinOpResolver resolver;
+
+  tflite::InterpreterBuilder(*model, resolver)(&interpreter);
+  if (!interpreter) {
+    LOG(ERROR) << "Failed to construct interpreter";
+    exit(-1);
+  }
+
+  interpreter->SetAllowFp16PrecisionForFp32(settings->allow_fp16);
+
+  if (settings->verbose) {
+    LOG(INFO) << "tensors size: " << interpreter->tensors_size();
+    LOG(INFO) << "nodes size: " << interpreter->nodes_size();
+    LOG(INFO) << "inputs: " << interpreter->inputs().size();
+    LOG(INFO) << "input(0) name: " << interpreter->GetInputName(0);
+
+    int t_size = interpreter->tensors_size();
+    for (int i = 0; i < t_size; i++) {
+      if (interpreter->tensor(i)->name)
+        LOG(INFO) << i << ": " << interpreter->tensor(i)->name << ", "
+                  << interpreter->tensor(i)->bytes << ", "
+                  << interpreter->tensor(i)->type << ", "
+                  << interpreter->tensor(i)->params.scale << ", "
+                  << interpreter->tensor(i)->params.zero_point;
+    }
+  }
+
+  if (settings->number_of_threads != -1) {
+    interpreter->SetNumThreads(settings->number_of_threads);
+  }
+
+  int image_width = 224;
+  int image_height = 224;
+  int image_channels = 3;
+  std::vector<uint8_t> in = read_bmp(settings->input_bmp_name, &image_width,
+                                     &image_height, &image_channels, settings);
+
+  int input = interpreter->inputs()[0];
+  if (settings->verbose) LOG(INFO) << "input: " << input;
+
+  const std::vector<int> inputs = interpreter->inputs();
+  const std::vector<int> outputs = interpreter->outputs();
+
+  if (settings->verbose) {
+    LOG(INFO) << "number of inputs: " << inputs.size();
+    LOG(INFO) << "number of outputs: " << outputs.size();
+  }
+
+  auto profiler = std::make_unique<profiling::Profiler>(
+      settings->max_profiling_buffer_entries);
+  interpreter->SetProfiler(profiler.get());
+
+  auto delegates = delegate_providers.CreateAllDelegates();
+  for (auto& delegate : delegates) {
+    const auto delegate_name = delegate.provider->GetName();
+    if (interpreter->ModifyGraphWithDelegate(std::move(delegate.delegate)) !=
+        kTfLiteOk) {
+      LOG(ERROR) << "Failed to apply " << delegate_name << " delegate.";
+      exit(-1);
+    } else {
+      LOG(INFO) << "Applied " << delegate_name << " delegate.";
+    }
+  }
+
+  if (interpreter->AllocateTensors() != kTfLiteOk) {
+    LOG(ERROR) << "Failed to allocate tensors!";
+    exit(-1);
+  }
+
+  if (settings->verbose) PrintInterpreterState(interpreter.get());
+
+  // get input dimension from the input tensor metadata
+  // assuming one input only
+  TfLiteIntArray* dims = interpreter->tensor(input)->dims;
+  int wanted_height = dims->data[1];
+  int wanted_width = dims->data[2];
+  int wanted_channels = dims->data[3];
+
+  settings->input_type = interpreter->tensor(input)->type;
+  switch (settings->input_type) {
+    case kTfLiteFloat32:
+      resize<float>(interpreter->typed_tensor<float>(input), in.data(),
+                    image_height, image_width, image_channels, wanted_height,
+                    wanted_width, wanted_channels, settings);
+      break;
+    case kTfLiteInt8:
+      resize<int8_t>(interpreter->typed_tensor<int8_t>(input), in.data(),
+                     image_height, image_width, image_channels, wanted_height,
+                     wanted_width, wanted_channels, settings);
+      break;
+    case kTfLiteUInt8:
+      resize<uint8_t>(interpreter->typed_tensor<uint8_t>(input), in.data(),
+                      image_height, image_width, image_channels, wanted_height,
+                      wanted_width, wanted_channels, settings);
+      break;
+    default:
+      LOG(ERROR) << "cannot handle input type "
+                 << interpreter->tensor(input)->type << " yet";
+      exit(-1);
+  }
+
+  if (settings->profiling) profiler->StartProfiling();
+  for (int i = 0; i < settings->number_of_warmup_runs; i++) {
+    if (interpreter->Invoke() != kTfLiteOk) {
+      LOG(ERROR) << "Failed to invoke tflite!";
+      exit(-1);
+    }
+  }
+
+  struct timeval start_time, stop_time;
+  gettimeofday(&start_time, nullptr);
+  for (int i = 0; i < settings->loop_count; i++) {
+    if (interpreter->Invoke() != kTfLiteOk) {
+      LOG(ERROR) << "Failed to invoke tflite!";
+      exit(-1);
+    }
+  }
+  gettimeofday(&stop_time, nullptr);
+  LOG(INFO) << "invoked";
+  LOG(INFO) << "average time: "
+            << (get_us(stop_time) - get_us(start_time)) /
+                   (settings->loop_count * 1000)
+            << " ms";
+
+  if (settings->profiling) {
+    profiler->StopProfiling();
+    auto profile_events = profiler->GetProfileEvents();
+    for (int i = 0; i < profile_events.size(); i++) {
+      auto subgraph_index = profile_events[i]->extra_event_metadata;
+      auto op_index = profile_events[i]->event_metadata;
+      const auto subgraph = interpreter->subgraph(subgraph_index);
+      const auto node_and_registration =
+          subgraph->node_and_registration(op_index);
+      const TfLiteRegistration registration = node_and_registration->second;
+      PrintProfilingInfo(profile_events[i], subgraph_index, op_index,
+                         registration);
+    }
+  }
+
+  const float threshold = 0.001f;
+
+  std::vector<std::pair<float, int>> top_results;
+
+  int output = interpreter->outputs()[0];
+  TfLiteIntArray* output_dims = interpreter->tensor(output)->dims;
+  // assume output dims to be something like (1, 1, ... ,size)
+  auto output_size = output_dims->data[output_dims->size - 1];
+  switch (interpreter->tensor(output)->type) {
+    case kTfLiteFloat32:
+      get_top_n<float>(interpreter->typed_output_tensor<float>(0), output_size,
+                       settings->number_of_results, threshold, &top_results,
+                       settings->input_type);
+      break;
+    case kTfLiteInt8:
+      get_top_n<int8_t>(interpreter->typed_output_tensor<int8_t>(0),
+                        output_size, settings->number_of_results, threshold,
+                        &top_results, settings->input_type);
+      break;
+    case kTfLiteUInt8:
+      get_top_n<uint8_t>(interpreter->typed_output_tensor<uint8_t>(0),
+                         output_size, settings->number_of_results, threshold,
+                         &top_results, settings->input_type);
+      break;
+    default:
+      LOG(ERROR) << "cannot handle output type "
+                 << interpreter->tensor(output)->type << " yet";
+      exit(-1);
+  }
+
+  std::vector<string> labels;
+  size_t label_count;
+
+  if (ReadLabelsFile(settings->labels_file_name, &labels, &label_count) !=
+      kTfLiteOk)
+    exit(-1);
+
+  for (const auto& result : top_results) {
+    const float confidence = result.first;
+    const int index = result.second;
+    LOG(INFO) << confidence << ": " << index << " " << labels[index];
+  }
+
+  // Destory the interpreter earlier than delegates objects.
+  interpreter.reset();
+}
+
+void display_usage(const DelegateProviders& delegate_providers) {
+  LOG(INFO)
+      << "\n"
+      << delegate_providers.GetHelpMessage("label_image")
+      << "\t--accelerated, -a: [0|1] use Android NNAPI or not\n"
+      << "\t--allow_fp16, -f: [0|1], allow running fp32 models with fp16 or "
+         "not\n"
+      << "\t--count, -c: loop interpreter->Invoke() for certain times\n"
+      << "\t--gl_backend, -g: [0|1]: use GL GPU Delegate on Android\n"
+      << "\t--hexagon_delegate, -j: [0|1]: use Hexagon Delegate on Android\n"
+      << "\t--input_mean, -b: input mean\n"
+      << "\t--input_std, -s: input standard deviation\n"
+      << "\t--image, -i: image_name.bmp\n"
+      << "\t--labels, -l: labels for the model\n"
+      << "\t--tflite_model, -m: model_name.tflite\n"
+      << "\t--profiling, -p: [0|1], profiling or not\n"
+      << "\t--num_results, -r: number of results to show\n"
+      << "\t--threads, -t: number of threads\n"
+      << "\t--verbose, -v: [0|1] print more information\n"
+      << "\t--warmup_runs, -w: number of warmup runs\n"
+      << "\t--xnnpack_delegate, -x [0:1]: xnnpack delegate\n"
+      << "\t--help, -h: Print this help message\n";
+}
+
+int Main(int argc, char** argv) {
+  DelegateProviders delegate_providers;
+  bool parse_result = delegate_providers.InitFromCmdlineArgs(
+      &argc, const_cast<const char**>(argv));
+  if (!parse_result) {
+    display_usage(delegate_providers);
+    return EXIT_FAILURE;
+  }
+
+  Settings s;
+
+  int c;
+  while (true) {
+    static struct option long_options[] = {
+        {"accelerated", required_argument, nullptr, 'a'},
+        {"allow_fp16", required_argument, nullptr, 'f'},
+        {"count", required_argument, nullptr, 'c'},
+        {"verbose", required_argument, nullptr, 'v'},
+        {"image", required_argument, nullptr, 'i'},
+        {"labels", required_argument, nullptr, 'l'},
+        {"tflite_model", required_argument, nullptr, 'm'},
+        {"profiling", required_argument, nullptr, 'p'},
+        {"threads", required_argument, nullptr, 't'},
+        {"input_mean", required_argument, nullptr, 'b'},
+        {"input_std", required_argument, nullptr, 's'},
+        {"num_results", required_argument, nullptr, 'r'},
+        {"max_profiling_buffer_entries", required_argument, nullptr, 'e'},
+        {"warmup_runs", required_argument, nullptr, 'w'},
+        {"gl_backend", required_argument, nullptr, 'g'},
+        {"hexagon_delegate", required_argument, nullptr, 'j'},
+        {"xnnpack_delegate", required_argument, nullptr, 'x'},
+        {"help", no_argument, nullptr, 'h'},
+        {nullptr, 0, nullptr, 0}};
+
+    /* getopt_long stores the option index here. */
+    int option_index = 0;
+
+    c = getopt_long(argc, argv, "a:b:c:d:e:f:g:i:j:l:m:p:r:s:t:v:w:x:h",
+                    long_options, &option_index);
+
+    /* Detect the end of the options. */
+    if (c == -1) break;
+
+    switch (c) {
+      case 'a':
+        s.accel = strtol(optarg, nullptr, 10);  // NOLINT(runtime/deprecated_fn)
+        break;
+      case 'b':
+        s.input_mean = strtod(optarg, nullptr);
+        break;
+      case 'c':
+        s.loop_count =
+            strtol(optarg, nullptr, 10);  // NOLINT(runtime/deprecated_fn)
+        break;
+      case 'e':
+        s.max_profiling_buffer_entries =
+            strtol(optarg, nullptr, 10);  // NOLINT(runtime/deprecated_fn)
+        break;
+      case 'f':
+        s.allow_fp16 =
+            strtol(optarg, nullptr, 10);  // NOLINT(runtime/deprecated_fn)
+        break;
+      case 'g':
+        s.gl_backend =
+            strtol(optarg, nullptr, 10);  // NOLINT(runtime/deprecated_fn)
+        break;
+      case 'i':
+        s.input_bmp_name = optarg;
+        break;
+      case 'j':
+        s.hexagon_delegate = optarg;
+        break;
+      case 'l':
+        s.labels_file_name = optarg;
+        break;
+      case 'm':
+        s.model_name = optarg;
+        break;
+      case 'p':
+        s.profiling =
+            strtol(optarg, nullptr, 10);  // NOLINT(runtime/deprecated_fn)
+        break;
+      case 'r':
+        s.number_of_results =
+            strtol(optarg, nullptr, 10);  // NOLINT(runtime/deprecated_fn)
+        break;
+      case 's':
+        s.input_std = strtod(optarg, nullptr);
+        break;
+      case 't':
+        s.number_of_threads = strtol(  // NOLINT(runtime/deprecated_fn)
+            optarg, nullptr, 10);
+        break;
+      case 'v':
+        s.verbose =
+            strtol(optarg, nullptr, 10);  // NOLINT(runtime/deprecated_fn)
+        break;
+      case 'w':
+        s.number_of_warmup_runs =
+            strtol(optarg, nullptr, 10);  // NOLINT(runtime/deprecated_fn)
+        break;
+      case 'x':
+        s.xnnpack_delegate =
+            strtol(optarg, nullptr, 10);  // NOLINT(runtime/deprecated_fn)
+        break;
+      case 'h':
+      case '?':
+        /* getopt_long already printed an error message. */
+        display_usage(delegate_providers);
+        exit(-1);
+      default:
+        exit(-1);
+    }
+  }
+
+  delegate_providers.MergeSettingsIntoParams(s);
+  RunInference(&s, delegate_providers);
+  return 0;
+}
+
+}  // namespace label_image
+}  // namespace tflite
+
+int main(int argc, char** argv) {
+  return tflite::label_image::Main(argc, argv);
+}

tensorflow/lite/examples/label_image/label_image.h

@@ -0,0 +1,52 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_LITE_EXAMPLES_LABEL_IMAGE_LABEL_IMAGE_H_
+#define TENSORFLOW_LITE_EXAMPLES_LABEL_IMAGE_LABEL_IMAGE_H_
+
+#include "tensorflow/lite/c/c_api_types.h"
+#include "tensorflow/lite/model.h"
+#include "tensorflow/lite/model_builder.h"
+#include "tensorflow/lite/string_type.h"
+
+namespace tflite {
+namespace label_image {
+
+struct Settings {
+  bool verbose = false;
+  bool accel = false;
+  TfLiteType input_type = kTfLiteFloat32;
+  bool profiling = false;
+  bool allow_fp16 = false;
+  bool gl_backend = false;
+  bool hexagon_delegate = false;
+  bool xnnpack_delegate = false;
+  int loop_count = 1;
+  float input_mean = 127.5f;
+  float input_std = 127.5f;
+  string model_name = "./mobilenet_quant_v1_224.tflite";
+  tflite::FlatBufferModel* model;
+  string input_bmp_name = "./grace_hopper.bmp";
+  string labels_file_name = "./labels.txt";
+  int number_of_threads = 4;
+  int number_of_results = 5;
+  int max_profiling_buffer_entries = 1024;
+  int number_of_warmup_runs = 2;
+};
+
+}  // namespace label_image
+}  // namespace tflite
+
+#endif  // TENSORFLOW_LITE_EXAMPLES_LABEL_IMAGE_LABEL_IMAGE_H_

tensorflow/lite/examples/label_image/label_image_test.cc

@@ -0,0 +1,60 @@
+/* Copyright 2016 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.
+==============================================================================*/
+
+#include "tensorflow/lite/examples/label_image/label_image.h"
+
+#include <cstdint>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <gtest/gtest.h>
+#include "tensorflow/lite/c/c_api_types.h"
+#include "tensorflow/lite/examples/label_image/bitmap_helpers.h"
+#include "tensorflow/lite/examples/label_image/get_top_n.h"
+
+namespace tflite {
+namespace label_image {
+
+TEST(LabelImageTest, GraceHopper) {
+  std::string lena_file =
+      "tensorflow/lite/examples/label_image/testdata/"
+      "grace_hopper.bmp";
+  int height, width, channels;
+  Settings s;
+  s.input_type = kTfLiteUInt8;
+  std::vector<uint8_t> input =
+      read_bmp(lena_file, &width, &height, &channels, &s);
+  ASSERT_EQ(height, 606);
+  ASSERT_EQ(width, 517);
+  ASSERT_EQ(channels, 3);
+
+  std::vector<uint8_t> output(606 * 517 * 3);
+  resize<uint8_t>(output.data(), input.data(), 606, 517, 3, 214, 214, 3, &s);
+  ASSERT_EQ(output[0], 0x15);
+  ASSERT_EQ(output[214 * 214 * 3 - 1], 0x11);
+}
+
+TEST(LabelImageTest, GetTopN) {
+  uint8_t in[] = {1, 1, 2, 2, 4, 4, 16, 32, 128, 64};
+
+  std::vector<std::pair<float, int>> top_results;
+  get_top_n<uint8_t>(in, 10, 5, 0.025, &top_results, kTfLiteUInt8);
+  ASSERT_EQ(top_results.size(), 4);
+  ASSERT_EQ(top_results[0].second, 8);
+}
+
+}  // namespace label_image
+}  // namespace tflite

tensorflow/lite/examples/label_image/log.h

@@ -0,0 +1,39 @@
+/* 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_LITE_EXAMPLES_LABEL_IMAGE_LOG_H_
+#define TENSORFLOW_LITE_EXAMPLES_LABEL_IMAGE_LOG_H_
+
+#include <iostream>
+#include <sstream>
+
+namespace tflite {
+namespace label_image {
+
+class Log {
+  std::stringstream stream_;
+
+ public:
+  explicit Log(const char* severity) { stream_ << severity << ": "; }
+  std::stringstream& Stream() { return stream_; }
+  ~Log() { std::cerr << stream_.str() << std::endl; }
+};
+
+#define LOG(severity) tflite::label_image::Log(#severity).Stream()
+
+}  // namespace label_image
+}  // namespace tflite
+
+#endif  // TENSORFLOW_LITE_EXAMPLES_LABEL_IMAGE_LOG_H_