chore: import upstream snapshot with attribution

tensorflow/lite/examples/python/BUILD

@@ -0,0 +1,22 @@
+load("@xla//third_party/rules_python/python:py_binary.bzl", "py_binary")
+
+package(
+    # copybara:uncomment default_applicable_licenses = ["//tensorflow:LICENSE"],
+    licenses = ["notice"],
+)
+
+# Commented out under the (b/279852433) because caused an error in the OSS
+# TODO(zhurakovskyi): Uncomment when fixed.
+# copybara:uncomment_begin
+# py_binary(
+#     name = "label_image",
+#     srcs = ["label_image.py"],
+#     main = "label_image.py",
+#     strict_deps = True,
+#     deps = [
+#         "//third_party/py/PIL:pil",
+#         "//third_party/py/numpy",
+#         "//tensorflow/lite/python:lite",
+#     ],
+# )
+# copybara:uncomment_end

tensorflow/lite/examples/python/README.md

@@ -0,0 +1,47 @@
+# TensorFlow Lite Python image classification demo
+
+This `label_image.py` script shows how you can load a pre-trained and converted
+TensorFlow Lite model and use it to recognize objects in images. The Python
+script accepts arguments specifying the model to use, the corresponding labels
+file, and the image to process.
+
+**Tip:** If you're using a Raspberry Pi, instead try the
+[classify_picamera.py example](https://github.com/tensorflow/examples/tree/master/lite/examples/image_classification/raspberry_pi).
+
+Before you begin, make sure you
+[have TensorFlow installed](https://www.tensorflow.org/install).
+
+## 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.
+
+```sh
+# Get photo
+curl https://raw.githubusercontent.com/tensorflow/tensorflow/master/tensorflow/lite/examples/label_image/testdata/grace_hopper.bmp > /tmp/grace_hopper.bmp
+# 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
+
+```sh
+python3 label_image.py \
+  --model_file /tmp/mobilenet_v1_1.0_224.tflite \
+  --label_file /tmp/labels.txt \
+  --image /tmp/grace_hopper.bmp
+```
+
+You should see results like this:
+
+```
+0.728693: military uniform
+0.116163: Windsor tie
+0.035517: bow tie
+0.014874: mortarboard
+0.011758: bolo tie
+```

tensorflow/lite/examples/python/label_image.py

@@ -0,0 +1,128 @@
+# 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.
+# ==============================================================================
+"""label_image for tflite."""
+
+import argparse
+import time
+
+import numpy as np
+from PIL import Image
+from tensorflow.lite.python import lite
+
+
+def load_labels(filename):
+  with open(filename, 'r') as f:
+    return [line.strip() for line in f.readlines()]
+
+
+if __name__ == '__main__':
+  parser = argparse.ArgumentParser()
+  parser.add_argument(
+      '-i',
+      '--image',
+      default='/tmp/grace_hopper.bmp',
+      help='image to be classified')
+  parser.add_argument(
+      '-m',
+      '--model_file',
+      default='/tmp/mobilenet_v1_1.0_224_quant.tflite',
+      help='.tflite model to be executed')
+  parser.add_argument(
+      '-l',
+      '--label_file',
+      default='/tmp/labels.txt',
+      help='name of file containing labels')
+  parser.add_argument(
+      '--input_mean',
+      default=127.5, type=float,
+      help='input_mean')
+  parser.add_argument(
+      '--input_std',
+      default=127.5, type=float,
+      help='input standard deviation')
+  parser.add_argument(
+      '--num_threads', default=None, type=int, help='number of threads')
+  parser.add_argument(
+      '-e', '--ext_delegate', help='external_delegate_library path')
+  parser.add_argument(
+      '-o',
+      '--ext_delegate_options',
+      help='external delegate options, \
+            format: "option1: value1; option2: value2"')
+
+  args = parser.parse_args()
+
+  ext_delegate = None
+  ext_delegate_options = {}
+
+  # parse extenal delegate options
+  if args.ext_delegate_options is not None:
+    options = args.ext_delegate_options.split(';')
+    for o in options:
+      kv = o.split(':')
+      if (len(kv) == 2):
+        ext_delegate_options[kv[0].strip()] = kv[1].strip()
+      else:
+        raise RuntimeError('Error parsing delegate option: ' + o)
+
+  # load external delegate
+  if args.ext_delegate is not None:
+    print('Loading external delegate from {} with args: {}'.format(
+        args.ext_delegate, ext_delegate_options))
+    ext_delegate = [
+        tflite.load_delegate(args.ext_delegate, ext_delegate_options)
+    ]
+
+  interpreter = lite.Interpreter(
+      model_path=args.model_file,
+      experimental_delegates=ext_delegate,
+      num_threads=args.num_threads)
+  interpreter.allocate_tensors()
+
+  input_details = interpreter.get_input_details()
+  output_details = interpreter.get_output_details()
+
+  # check the type of the input tensor
+  floating_model = input_details[0]['dtype'] == np.float32
+
+  # NxHxWxC, H:1, W:2
+  height = input_details[0]['shape'][1]
+  width = input_details[0]['shape'][2]
+  img = Image.open(args.image).resize((width, height))
+
+  # add N dim
+  input_data = np.expand_dims(img, axis=0)
+
+  if floating_model:
+    input_data = (np.float32(input_data) - args.input_mean) / args.input_std
+
+  interpreter.set_tensor(input_details[0]['index'], input_data)
+
+  start_time = time.time()
+  interpreter.invoke()
+  stop_time = time.time()
+
+  output_data = interpreter.get_tensor(output_details[0]['index'])
+  results = np.squeeze(output_data)
+
+  top_k = results.argsort()[-5:][::-1]
+  labels = load_labels(args.label_file)
+  for i in top_k:
+    if floating_model:
+      print('{:08.6f}: {}'.format(float(results[i]), labels[i]))
+    else:
+      print('{:08.6f}: {}'.format(float(results[i] / 255.0), labels[i]))
+
+  print('time: {:.3f}ms'.format((stop_time - start_time) * 1000))