chore: import upstream snapshot with attribution

tensorflow/lite/examples/minimal/BUILD

@@ -0,0 +1,30 @@
+# Description:
+#   TensorFlow Lite minimal example.
+
+load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
+load("//tensorflow/lite:build_def.bzl", "tflite_linkopts")
+
+package(
+    # copybara:uncomment default_applicable_licenses = ["//tensorflow:LICENSE"],
+    default_visibility = ["//visibility:public"],
+    licenses = ["notice"],
+)
+
+cc_binary(
+    name = "minimal",
+    srcs = [
+        "minimal.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
+        ],
+        "//conditions:default": [],
+    }),
+    deps = [
+        "//tensorflow/lite:framework",
+        "//tensorflow/lite/core:cc_api_stable",
+        "//tensorflow/lite/kernels:builtin_ops",
+    ],
+)

tensorflow/lite/examples/minimal/CMakeLists.txt

@@ -0,0 +1,60 @@
+#
+# Copyright 2020 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.
+
+
+# Builds the minimal Tensorflow Lite example.
+
+cmake_minimum_required(VERSION 3.16)
+project(minimal C CXX)
+
+option(LINK_TFLITE_FLEX "Enable tensorflowlite_flex library linkage" OFF)
+
+set(TENSORFLOW_SOURCE_DIR "" CACHE PATH
+  "Directory that contains the TensorFlow project"
+)
+if(NOT TENSORFLOW_SOURCE_DIR)
+  get_filename_component(TENSORFLOW_SOURCE_DIR
+    "${CMAKE_CURRENT_LIST_DIR}/../../../../"
+    ABSOLUTE
+  )
+endif()
+
+add_subdirectory(
+  "${TENSORFLOW_SOURCE_DIR}/tensorflow/lite"
+  "${CMAKE_CURRENT_BINARY_DIR}/tensorflow-lite"
+  EXCLUDE_FROM_ALL
+)
+
+set(CMAKE_CXX_STANDARD 17)
+add_executable(minimal
+  minimal.cc
+)
+
+if(LINK_TFLITE_FLEX)
+  find_library(TF_LIB_FLEX tensorflowlite_flex HINTS "${TENSORFLOW_SOURCE_DIR}/bazel-bin/tensorflow/lite/delegates/flex/")
+  if(NOT TF_LIB_FLEX)
+    message(FATAL_ERROR "tensorflowlite_flex library not found")
+  endif()
+
+  target_link_libraries(minimal
+    tensorflow-lite
+    -Wl,--no-as-needed # Add --no-as-needed since for some toolchains (e.g. Ubuntu) --as-needed is added by default.
+    ${TF_LIB_FLEX}
+  )
+else()
+  target_link_libraries(minimal
+    tensorflow-lite
+  )
+endif()

tensorflow/lite/examples/minimal/README.md

@@ -0,0 +1,74 @@
+# TensorFlow Lite C++ minimal example
+
+This example shows how you can build a simple TensorFlow Lite application.
+
+#### Step 1. Install CMake tool
+
+It requires CMake 3.16 or higher. On Ubuntu, you can simply run the following
+command.
+
+```sh
+sudo apt-get install cmake
+```
+
+Or you can follow
+[the official cmake installation guide](https://cmake.org/install/)
+
+#### Step 2. Install libffi7 package(Optional)
+
+It requires libffi7. On Ubuntu 20.10 or later, you can simply run the following
+command.
+
+```sh
+wget http://es.archive.ubuntu.com/ubuntu/pool/main/libf/libffi/libffi7_3.3-4_amd64.deb
+sudo dpkg -i libffi7_3.3-4_amd64.deb
+```
+
+#### Step 3. Clone TensorFlow repository
+
+```sh
+git clone https://github.com/tensorflow/tensorflow.git tensorflow_src
+```
+
+#### Step 4. Create CMake build directory and run CMake tool
+
+```sh
+mkdir minimal_build
+cd minimal_build
+cmake ../tensorflow_src/tensorflow/lite/examples/minimal
+```
+
+#### Step 5. Build TensorFlow Lite
+
+In the minimal_build directory,
+
+```sh
+cmake --build . -j
+```
+
+#### Step 5. Run the executable
+
+In the minimal_build directory,
+
+```sh
+./minimal <path/to/tflite/model>
+```
+
+#### Optional: Link with tensorflowlite_flex library
+
+You may want to link with tensorflowlite_flex library to use TF select Ops in
+your model.
+
+First tensorflowlite_flex needs to be compiled using bazel in tensorflow_src
+directory: `sh bazel build -c opt --cxxopt='--std=c++17' --config=monolithic
+tensorflow/lite/delegates/flex:tensorflowlite_flex`
+
+Then when configuring cmake build
+([Step 4](#step-4-create-cmake-build-directory-and-run-cmake-tool)), add the
+following option:
+
+```sh
+cmake ../tensorflow_src/tensorflow/lite/examples/minimal -DLINK_TFLITE_FLEX="ON"
+```
+
+And build: `sh cmake --build . -j`

tensorflow/lite/examples/minimal/minimal.cc

@@ -0,0 +1,84 @@
+/* Copyright 2018 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 <cstdio>
+#include <cstdlib>
+#include <memory>
+
+#include "tensorflow/lite/core/interpreter_builder.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"
+
+// This is an example that is minimal to read a model
+// from disk and perform inference. There is no data being loaded
+// that is up to you to add as a user.
+//
+// NOTE: Do not add any dependencies to this that cannot be built with
+// the minimal makefile. This example must remain trivial to build with
+// the minimal build tool.
+//
+// Usage: minimal <tflite model>
+
+#define TFLITE_MINIMAL_CHECK(x)                              \
+  if (!(x)) {                                                \
+    fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); \
+    exit(1);                                                 \
+  }
+
+int main(int argc, char* argv[]) {
+  if (argc != 2) {
+    fprintf(stderr, "minimal <tflite model>\n");
+    return 1;
+  }
+  const char* filename = argv[1];
+
+  // Load model
+  std::unique_ptr<tflite::FlatBufferModel> model =
+      tflite::FlatBufferModel::BuildFromFile(filename);
+  TFLITE_MINIMAL_CHECK(model != nullptr);
+
+  // Build the interpreter with the InterpreterBuilder.
+  // Note: all Interpreters should be built with the InterpreterBuilder,
+  // which allocates memory for the Interpreter and does various set up
+  // tasks so that the Interpreter can read the provided model.
+  tflite::ops::builtin::BuiltinOpResolver resolver;
+  tflite::InterpreterBuilder builder(*model, resolver);
+  std::unique_ptr<tflite::Interpreter> interpreter;
+  builder(&interpreter);
+  TFLITE_MINIMAL_CHECK(interpreter != nullptr);
+
+  // Allocate tensor buffers.
+  TFLITE_MINIMAL_CHECK(interpreter->AllocateTensors() == kTfLiteOk);
+  printf("=== Pre-invoke Interpreter State ===\n");
+  tflite::PrintInterpreterState(interpreter.get());
+
+  // Fill input buffers
+  // TODO(user): Insert code to fill input tensors.
+  // Note: The buffer of the input tensor with index `i` of type T can
+  // be accessed with `T* input = interpreter->typed_input_tensor<T>(i);`
+
+  // Run inference
+  TFLITE_MINIMAL_CHECK(interpreter->Invoke() == kTfLiteOk);
+  printf("\n\n=== Post-invoke Interpreter State ===\n");
+  tflite::PrintInterpreterState(interpreter.get());
+
+  // Read output buffers
+  // TODO(user): Insert getting data out code.
+  // Note: The buffer of the output tensor with index `i` of type T can
+  // be accessed with `T* output = interpreter->typed_output_tensor<T>(i);`
+
+  return 0;
+}