From bdb2f9ff1da8937e9281f3fb619799f2a2c20168 Mon Sep 17 00:00:00 2001 From: Pete Warden Date: Sat, 11 Nov 2017 16:29:02 -0800 Subject: [PATCH 1/4] Initial implementation of Makefile build for TensorFlow Lite --- .gitignore | 2 + tensorflow/contrib/lite/Makefile | 145 + .../contrib/lite/download_dependencies.sh | 84 + .../contrib/lite/schema/schema_generated.h | 4521 +++++++++++++++++ .../contrib/lite/tools/benchmark_model.cc | 99 + .../contrib/lite/tools/mutable_op_resolver.h | 11 + 6 files changed, 4862 insertions(+) create mode 100644 tensorflow/contrib/lite/Makefile create mode 100755 tensorflow/contrib/lite/download_dependencies.sh create mode 100755 tensorflow/contrib/lite/schema/schema_generated.h create mode 100644 tensorflow/contrib/lite/tools/benchmark_model.cc diff --git a/.gitignore b/.gitignore index 9ae0d9c96f188b..021997de1689e9 100644 --- a/.gitignore +++ b/.gitignore @@ -22,3 +22,5 @@ Pods Podfile.lock *.pbxproj *.xcworkspacedata +/tensorflow/contrib/lite/downloads/** +/tensorflow/contrib/lite/gen/** diff --git a/tensorflow/contrib/lite/Makefile b/tensorflow/contrib/lite/Makefile new file mode 100644 index 00000000000000..73a6294f64a475 --- /dev/null +++ b/tensorflow/contrib/lite/Makefile @@ -0,0 +1,145 @@ + +# Find where we're running from, so we can store generated files here. +ifeq ($(origin MAKEFILE_DIR), undefined) + MAKEFILE_DIR := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST)))) +endif + +# Try to figure out the host system +HOST_OS := +ifeq ($(OS),Windows_NT) + HOST_OS = WINDOWS +else + UNAME_S := $(shell uname -s) + ifeq ($(UNAME_S),Linux) + HOST_OS := LINUX + endif + ifeq ($(UNAME_S),Darwin) + HOST_OS := OSX + endif +endif + +ARCH := $(shell if [[ $(shell uname -m) =~ i[345678]86 ]]; then echo x86_32; else echo $(shell uname -m); fi) + +# Where compiled objects are stored. +OBJDIR := $(MAKEFILE_DIR)/gen/obj/ +BINDIR := $(MAKEFILE_DIR)/gen/bin/ +LIBDIR := $(MAKEFILE_DIR)/gen/lib/ +GENDIR := $(MAKEFILE_DIR)/gen/obj/ + +# Settings for the host compiler. +CXX := $(CC_PREFIX) gcc +CXXFLAGS := --std=c++11 +CC := $(CC_PREFIX) gcc +CFLAGS := +LDOPTS := +LDOPTS += -L/usr/local/lib +ARFLAGS := -r + +INCLUDES := \ +-I. \ +-I$(MAKEFILE_DIR)/../../../ \ +-I$(MAKEFILE_DIR)/downloads/ \ +-I$(MAKEFILE_DIR)/downloads/eigen \ +-I$(MAKEFILE_DIR)/downloads/gemmlowp \ +-I$(MAKEFILE_DIR)/downloads/neon_2_sse \ +-I$(MAKEFILE_DIR)/downloads/farmhash/src \ +-I$(MAKEFILE_DIR)/downloads/flatbuffers/include \ +-I$(GENDIR) +# This is at the end so any globally-installed frameworks like protobuf don't +# override local versions in the source tree. +INCLUDES += -I/usr/local/include + +LIBS := \ +-lstdc++ \ +-lpthread \ +-lm \ +-lz + +# If we're on Linux, also link in the dl library. +ifeq ($(OS),LINUX) + LIBS += -ldl -lpthread +endif + +# This library is the main target for this makefile. It will contain a minimal +# runtime that can be linked in to other programs. +LIB_NAME := libtensorflow-lite.a +LIB_PATH := $(LIBDIR)$(LIB_NAME) + +# A small example program that shows how to link against the library. +BENCHMARK_PATH := $(BINDIR)benchmark_model + +BENCHMARK_SRCS := \ +tensorflow/contrib/lite/tools/benchmark_model.cc +BENCHMARK_OBJS := $(addprefix $(OBJDIR), \ +$(patsubst %.cc,%.o,$(patsubst %.c,%.o,$(BENCHMARK_SRCS)))) + +# What sources we want to compile, must be kept in sync with the main Bazel +# build files. + +CORE_CC_ALL_SRCS := \ +$(wildcard tensorflow/contrib/lite/*.cc) \ +$(wildcard tensorflow/contrib/lite/kernels/*.cc) \ +$(wildcard tensorflow/contrib/lite/kernels/internal/*.cc) \ +$(wildcard tensorflow/contrib/lite/kernels/internal/optimized/*.cc) \ +$(wildcard tensorflow/contrib/lite/kernels/internal/reference/*.cc) \ +$(wildcard tensorflow/contrib/lite/*.c) \ +$(wildcard tensorflow/contrib/lite/kernels/*.c) \ +$(wildcard tensorflow/contrib/lite/kernels/internal/*.c) \ +$(wildcard tensorflow/contrib/lite/kernels/internal/optimized/*.c) \ +$(wildcard tensorflow/contrib/lite/kernels/internal/reference/*.c) \ +$(wildcard tensorflow/contrib/lite/downloads/farmhash/src/farmhash.cc) +# Remove any duplicates. +CORE_CC_ALL_SRCS := $(sort $(CORE_CC_ALL_SRCS)) +CORE_CC_EXCLUDE_SRCS := \ +$(wildcard tensorflow/contrib/lite/*test.cc) \ +$(wildcard tensorflow/contrib/lite/*/*test.cc) \ +$(wildcard tensorflow/contrib/lite/*/*/*test.cc) \ +$(wildcard tensorflow/contrib/lite/*/*/*/*test.cc) \ +$(wildcard tensorflow/contrib/lite/kernels/test_util.cc) \ +$(BENCHMARK_SRCS) +# Filter out all the excluded files. +TF_LITE_CC_SRCS := $(filter-out $(CORE_CC_EXCLUDE_SRCS), $(CORE_CC_ALL_SRCS)) +# File names of the intermediate files target compilation generates. +TF_LITE_CC_OBJS := $(addprefix $(OBJDIR), \ +$(patsubst %.cc,%.o,$(patsubst %.c,%.o,$(TF_LITE_CC_SRCS)))) +LIB_OBJS := $(TF_LITE_CC_OBJS) + +# For normal manually-created TensorFlow C++ source files. +$(OBJDIR)%.o: %.cc + @mkdir -p $(dir $@) + $(CXX) $(CXXFLAGS) $(INCLUDES) -c $< -o $@ + +# For normal manually-created TensorFlow C++ source files. +$(OBJDIR)%.o: %.c + @mkdir -p $(dir $@) + $(CC) $(CCFLAGS) $(INCLUDES) -c $< -o $@ + +# The target that's compiled if there's no command-line arguments. +all: $(LIB_PATH) $(BENCHMARK_PATH) + +# Gathers together all the objects we've compiled into a single '.a' archive. +$(LIB_PATH): $(LIB_OBJS) + @mkdir -p $(dir $@) + $(AR) $(ARFLAGS) $(LIB_PATH) $(LIB_OBJS) + +$(BENCHMARK_PATH): $(BENCHMARK_OBJS) $(LIB_PATH) + @mkdir -p $(dir $@) + $(CXX) $(CXXFLAGS) $(INCLUDES) \ + -o $(BENCHMARK_PATH) $(BENCHMARK_OBJS) \ + $(LIBFLAGS) $(LIB_PATH) $(LDFLAGS) $(LIBS) + +# Gets rid of all generated files. +clean: + rm -rf $(MAKEFILE_DIR)/gen + +# Gets rid of target files only, leaving the host alone. Also leaves the lib +# directory untouched deliberately, so we can persist multiple architectures +# across builds for iOS and Android. +cleantarget: + rm -rf $(OBJDIR) + rm -rf $(BINDIR) + +$(DEPDIR)/%.d: ; +.PRECIOUS: $(DEPDIR)/%.d + +-include $(patsubst %,$(DEPDIR)/%.d,$(basename $(TF_CC_SRCS))) diff --git a/tensorflow/contrib/lite/download_dependencies.sh b/tensorflow/contrib/lite/download_dependencies.sh new file mode 100755 index 00000000000000..8c47ea2dd67362 --- /dev/null +++ b/tensorflow/contrib/lite/download_dependencies.sh @@ -0,0 +1,84 @@ +#!/bin/bash -x +# Copyright 2015 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. +# ============================================================================== + +set -e + +DOWNLOADS_DIR=tensorflow/contrib/lite/downloads +BZL_FILE_PATH=tensorflow/workspace.bzl + +EIGEN_URL="$(grep -o 'http.*bitbucket.org/eigen/eigen/get/.*tar\.gz' "${BZL_FILE_PATH}" | grep -v bazel-mirror | head -n1)" +GEMMLOWP_URL="$(grep -o 'https://mirror.bazel.build/github.com/google/gemmlowp/.*zip' "${BZL_FILE_PATH}" | head -n1)" +GOOGLETEST_URL="https://github.com/google/googletest/archive/release-1.8.0.tar.gz" +ABSL_URL="$(grep -o 'https://github.com/abseil/abseil-cpp/.*tar.gz' "${BZL_FILE_PATH}" | head -n1)" +NEON_2_SSE_URL="https://github.com/intel/ARM_NEON_2_x86_SSE/archive/master.zip" +FARMHASH_URL="https://mirror.bazel.build/github.com/google/farmhash/archive/816a4ae622e964763ca0862d9dbd19324a1eaf45.tar.gz" +FLATBUFFERS_URL="https://github.com/google/flatbuffers/archive/master.zip" + +# TODO(petewarden): Some new code in Eigen triggers a clang bug with iOS arm64, +# so work around it by patching the source. +replace_by_sed() { + local regex="${1}" + shift + # Detect the version of sed by the return value of "--version" flag. GNU-sed + # supports "--version" while BSD-sed doesn't. + if ! sed --version >/dev/null 2>&1; then + # BSD-sed. + sed -i '' -e "${regex}" "$@" + else + # GNU-sed. + sed -i -e "${regex}" "$@" + fi +} + +download_and_extract() { + local usage="Usage: download_and_extract URL DIR" + local url="${1:?${usage}}" + local dir="${2:?${usage}}" + echo "downloading ${url}" >&2 + mkdir -p "${dir}" + if [[ "${url}" == *gz ]]; then + curl -Ls "${url}" | tar -C "${dir}" --strip-components=1 -xz + elif [[ "${url}" == *zip ]]; then + tempdir=$(mktemp -d) + tempdir2=$(mktemp -d) + wget -P ${tempdir} ${url} + unzip ${tempdir}/* -d ${tempdir2} + # unzip has no strip components, so unzip to a temp dir, and move the files + # we want from the tempdir to destination. + cp -R ${tempdir2}/*/* ${dir}/ + rm -rf ${tempdir2} ${tempdir} + fi + + # Delete any potential BUILD files, which would interfere with Bazel builds. + find "${dir}" -type f -name '*BUILD' -delete +} + +download_and_extract "${EIGEN_URL}" "${DOWNLOADS_DIR}/eigen" +download_and_extract "${GEMMLOWP_URL}" "${DOWNLOADS_DIR}/gemmlowp" +download_and_extract "${GOOGLETEST_URL}" "${DOWNLOADS_DIR}/googletest" +download_and_extract "${ABSL_URL}" "${DOWNLOADS_DIR}/absl" +download_and_extract "${NEON_2_SSE_URL}" "${DOWNLOADS_DIR}/neon_2_sse" +download_and_extract "${FARMHASH_URL}" "${DOWNLOADS_DIR}/farmhash" +download_and_extract "${FLATBUFFERS_URL}" "${DOWNLOADS_DIR}/flatbuffers" + +replace_by_sed 's#static uint32x4_t p4ui_CONJ_XOR = vld1q_u32( conj_XOR_DATA );#static uint32x4_t p4ui_CONJ_XOR; // = vld1q_u32( conj_XOR_DATA ); - Removed by script#' \ + "${DOWNLOADS_DIR}/eigen/Eigen/src/Core/arch/NEON/Complex.h" +replace_by_sed 's#static uint32x2_t p2ui_CONJ_XOR = vld1_u32( conj_XOR_DATA );#static uint32x2_t p2ui_CONJ_XOR;// = vld1_u32( conj_XOR_DATA ); - Removed by scripts#' \ + "${DOWNLOADS_DIR}/eigen/Eigen/src/Core/arch/NEON/Complex.h" +replace_by_sed 's#static uint64x2_t p2ul_CONJ_XOR = vld1q_u64( p2ul_conj_XOR_DATA );#static uint64x2_t p2ul_CONJ_XOR;// = vld1q_u64( p2ul_conj_XOR_DATA ); - Removed by script#' \ + "${DOWNLOADS_DIR}/eigen/Eigen/src/Core/arch/NEON/Complex.h" + +echo "download_dependencies.sh completed successfully." >&2 diff --git a/tensorflow/contrib/lite/schema/schema_generated.h b/tensorflow/contrib/lite/schema/schema_generated.h new file mode 100755 index 00000000000000..df460ab9a32f1d --- /dev/null +++ b/tensorflow/contrib/lite/schema/schema_generated.h @@ -0,0 +1,4521 @@ +// automatically generated by the FlatBuffers compiler, do not modify + + +#ifndef FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_ +#define FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_ + +#include "flatbuffers/flatbuffers.h" + +namespace tflite { + +struct QuantizationParameters; +struct QuantizationParametersT; + +struct Tensor; +struct TensorT; + +struct Conv2DOptions; +struct Conv2DOptionsT; + +struct Pool2DOptions; +struct Pool2DOptionsT; + +struct DepthwiseConv2DOptions; +struct DepthwiseConv2DOptionsT; + +struct ConcatEmbeddingsOptions; +struct ConcatEmbeddingsOptionsT; + +struct LSHProjectionOptions; +struct LSHProjectionOptionsT; + +struct SVDFOptions; +struct SVDFOptionsT; + +struct RNNOptions; +struct RNNOptionsT; + +struct FullyConnectedOptions; +struct FullyConnectedOptionsT; + +struct SoftmaxOptions; +struct SoftmaxOptionsT; + +struct ConcatenationOptions; +struct ConcatenationOptionsT; + +struct AddOptions; +struct AddOptionsT; + +struct MulOptions; +struct MulOptionsT; + +struct L2NormOptions; +struct L2NormOptionsT; + +struct LocalResponseNormalizationOptions; +struct LocalResponseNormalizationOptionsT; + +struct LSTMOptions; +struct LSTMOptionsT; + +struct ResizeBilinearOptions; +struct ResizeBilinearOptionsT; + +struct CallOptions; +struct CallOptionsT; + +struct ReshapeOptions; +struct ReshapeOptionsT; + +struct SkipGramOptions; +struct SkipGramOptionsT; + +struct SpaceToDepthOptions; +struct SpaceToDepthOptionsT; + +struct EmbeddingLookupSparseOptions; +struct EmbeddingLookupSparseOptionsT; + +struct OperatorCode; +struct OperatorCodeT; + +struct Operator; +struct OperatorT; + +struct SubGraph; +struct SubGraphT; + +struct Buffer; +struct BufferT; + +struct Model; +struct ModelT; + +enum TensorType { + TensorType_FLOAT32 = 0, + TensorType_FLOAT16 = 1, + TensorType_INT32 = 2, + TensorType_UINT8 = 3, + TensorType_INT64 = 4, + TensorType_STRING = 5, + TensorType_MIN = TensorType_FLOAT32, + TensorType_MAX = TensorType_STRING +}; + +inline TensorType (&EnumValuesTensorType())[6] { + static TensorType values[] = { + TensorType_FLOAT32, + TensorType_FLOAT16, + TensorType_INT32, + TensorType_UINT8, + TensorType_INT64, + TensorType_STRING + }; + return values; +} + +inline const char **EnumNamesTensorType() { + static const char *names[] = { + "FLOAT32", + "FLOAT16", + "INT32", + "UINT8", + "INT64", + "STRING", + nullptr + }; + return names; +} + +inline const char *EnumNameTensorType(TensorType e) { + const size_t index = static_cast(e); + return EnumNamesTensorType()[index]; +} + +enum BuiltinOperator { + BuiltinOperator_ADD = 0, + BuiltinOperator_AVERAGE_POOL_2D = 1, + BuiltinOperator_CONCATENATION = 2, + BuiltinOperator_CONV_2D = 3, + BuiltinOperator_DEPTHWISE_CONV_2D = 4, + BuiltinOperator_EMBEDDING_LOOKUP = 7, + BuiltinOperator_FULLY_CONNECTED = 9, + BuiltinOperator_HASHTABLE_LOOKUP = 10, + BuiltinOperator_L2_NORMALIZATION = 11, + BuiltinOperator_L2_POOL_2D = 12, + BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION = 13, + BuiltinOperator_LOGISTIC = 14, + BuiltinOperator_LSH_PROJECTION = 15, + BuiltinOperator_LSTM = 16, + BuiltinOperator_MAX_POOL_2D = 17, + BuiltinOperator_MUL = 18, + BuiltinOperator_RELU = 19, + BuiltinOperator_RELU1 = 20, + BuiltinOperator_RELU6 = 21, + BuiltinOperator_RESHAPE = 22, + BuiltinOperator_RESIZE_BILINEAR = 23, + BuiltinOperator_RNN = 24, + BuiltinOperator_SOFTMAX = 25, + BuiltinOperator_SPACE_TO_DEPTH = 26, + BuiltinOperator_SVDF = 27, + BuiltinOperator_TANH = 28, + BuiltinOperator_CONCAT_EMBEDDINGS = 29, + BuiltinOperator_SKIP_GRAM = 30, + BuiltinOperator_CALL = 31, + BuiltinOperator_CUSTOM = 32, + BuiltinOperator_EMBEDDING_LOOKUP_SPARSE = 33, + BuiltinOperator_MIN = BuiltinOperator_ADD, + BuiltinOperator_MAX = BuiltinOperator_EMBEDDING_LOOKUP_SPARSE +}; + +inline BuiltinOperator (&EnumValuesBuiltinOperator())[31] { + static BuiltinOperator values[] = { + BuiltinOperator_ADD, + BuiltinOperator_AVERAGE_POOL_2D, + BuiltinOperator_CONCATENATION, + BuiltinOperator_CONV_2D, + BuiltinOperator_DEPTHWISE_CONV_2D, + BuiltinOperator_EMBEDDING_LOOKUP, + BuiltinOperator_FULLY_CONNECTED, + BuiltinOperator_HASHTABLE_LOOKUP, + BuiltinOperator_L2_NORMALIZATION, + BuiltinOperator_L2_POOL_2D, + BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION, + BuiltinOperator_LOGISTIC, + BuiltinOperator_LSH_PROJECTION, + BuiltinOperator_LSTM, + BuiltinOperator_MAX_POOL_2D, + BuiltinOperator_MUL, + BuiltinOperator_RELU, + BuiltinOperator_RELU1, + BuiltinOperator_RELU6, + BuiltinOperator_RESHAPE, + BuiltinOperator_RESIZE_BILINEAR, + BuiltinOperator_RNN, + BuiltinOperator_SOFTMAX, + BuiltinOperator_SPACE_TO_DEPTH, + BuiltinOperator_SVDF, + BuiltinOperator_TANH, + BuiltinOperator_CONCAT_EMBEDDINGS, + BuiltinOperator_SKIP_GRAM, + BuiltinOperator_CALL, + BuiltinOperator_CUSTOM, + BuiltinOperator_EMBEDDING_LOOKUP_SPARSE + }; + return values; +} + +inline const char **EnumNamesBuiltinOperator() { + static const char *names[] = { + "ADD", + "AVERAGE_POOL_2D", + "CONCATENATION", + "CONV_2D", + "DEPTHWISE_CONV_2D", + "", + "", + "EMBEDDING_LOOKUP", + "", + "FULLY_CONNECTED", + "HASHTABLE_LOOKUP", + "L2_NORMALIZATION", + "L2_POOL_2D", + "LOCAL_RESPONSE_NORMALIZATION", + "LOGISTIC", + "LSH_PROJECTION", + "LSTM", + "MAX_POOL_2D", + "MUL", + "RELU", + "RELU1", + "RELU6", + "RESHAPE", + "RESIZE_BILINEAR", + "RNN", + "SOFTMAX", + "SPACE_TO_DEPTH", + "SVDF", + "TANH", + "CONCAT_EMBEDDINGS", + "SKIP_GRAM", + "CALL", + "CUSTOM", + "EMBEDDING_LOOKUP_SPARSE", + nullptr + }; + return names; +} + +inline const char *EnumNameBuiltinOperator(BuiltinOperator e) { + const size_t index = static_cast(e); + return EnumNamesBuiltinOperator()[index]; +} + +enum BuiltinOptions { + BuiltinOptions_NONE = 0, + BuiltinOptions_Conv2DOptions = 1, + BuiltinOptions_DepthwiseConv2DOptions = 2, + BuiltinOptions_ConcatEmbeddingsOptions = 3, + BuiltinOptions_LSHProjectionOptions = 4, + BuiltinOptions_Pool2DOptions = 5, + BuiltinOptions_SVDFOptions = 6, + BuiltinOptions_RNNOptions = 7, + BuiltinOptions_FullyConnectedOptions = 8, + BuiltinOptions_SoftmaxOptions = 9, + BuiltinOptions_ConcatenationOptions = 10, + BuiltinOptions_AddOptions = 11, + BuiltinOptions_L2NormOptions = 12, + BuiltinOptions_LocalResponseNormalizationOptions = 13, + BuiltinOptions_LSTMOptions = 14, + BuiltinOptions_ResizeBilinearOptions = 15, + BuiltinOptions_CallOptions = 16, + BuiltinOptions_ReshapeOptions = 17, + BuiltinOptions_SkipGramOptions = 18, + BuiltinOptions_SpaceToDepthOptions = 19, + BuiltinOptions_EmbeddingLookupSparseOptions = 20, + BuiltinOptions_MulOptions = 21, + BuiltinOptions_MIN = BuiltinOptions_NONE, + BuiltinOptions_MAX = BuiltinOptions_MulOptions +}; + +inline BuiltinOptions (&EnumValuesBuiltinOptions())[22] { + static BuiltinOptions values[] = { + BuiltinOptions_NONE, + BuiltinOptions_Conv2DOptions, + BuiltinOptions_DepthwiseConv2DOptions, + BuiltinOptions_ConcatEmbeddingsOptions, + BuiltinOptions_LSHProjectionOptions, + BuiltinOptions_Pool2DOptions, + BuiltinOptions_SVDFOptions, + BuiltinOptions_RNNOptions, + BuiltinOptions_FullyConnectedOptions, + BuiltinOptions_SoftmaxOptions, + BuiltinOptions_ConcatenationOptions, + BuiltinOptions_AddOptions, + BuiltinOptions_L2NormOptions, + BuiltinOptions_LocalResponseNormalizationOptions, + BuiltinOptions_LSTMOptions, + BuiltinOptions_ResizeBilinearOptions, + BuiltinOptions_CallOptions, + BuiltinOptions_ReshapeOptions, + BuiltinOptions_SkipGramOptions, + BuiltinOptions_SpaceToDepthOptions, + BuiltinOptions_EmbeddingLookupSparseOptions, + BuiltinOptions_MulOptions + }; + return values; +} + +inline const char **EnumNamesBuiltinOptions() { + static const char *names[] = { + "NONE", + "Conv2DOptions", + "DepthwiseConv2DOptions", + "ConcatEmbeddingsOptions", + "LSHProjectionOptions", + "Pool2DOptions", + "SVDFOptions", + "RNNOptions", + "FullyConnectedOptions", + "SoftmaxOptions", + "ConcatenationOptions", + "AddOptions", + "L2NormOptions", + "LocalResponseNormalizationOptions", + "LSTMOptions", + "ResizeBilinearOptions", + "CallOptions", + "ReshapeOptions", + "SkipGramOptions", + "SpaceToDepthOptions", + "EmbeddingLookupSparseOptions", + "MulOptions", + nullptr + }; + return names; +} + +inline const char *EnumNameBuiltinOptions(BuiltinOptions e) { + const size_t index = static_cast(e); + return EnumNamesBuiltinOptions()[index]; +} + +template struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_NONE; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_Conv2DOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_DepthwiseConv2DOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_ConcatEmbeddingsOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_LSHProjectionOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_Pool2DOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_SVDFOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_RNNOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_FullyConnectedOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_SoftmaxOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_ConcatenationOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_AddOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_L2NormOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_LocalResponseNormalizationOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_LSTMOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_ResizeBilinearOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_CallOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_ReshapeOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_SkipGramOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_SpaceToDepthOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_EmbeddingLookupSparseOptions; +}; + +template<> struct BuiltinOptionsTraits { + static const BuiltinOptions enum_value = BuiltinOptions_MulOptions; +}; + +struct BuiltinOptionsUnion { + BuiltinOptions type; + void *value; + + BuiltinOptionsUnion() : type(BuiltinOptions_NONE), value(nullptr) {} + BuiltinOptionsUnion(BuiltinOptionsUnion&& u) FLATBUFFERS_NOEXCEPT : + type(BuiltinOptions_NONE), value(nullptr) + { std::swap(type, u.type); std::swap(value, u.value); } + BuiltinOptionsUnion(const BuiltinOptionsUnion &) FLATBUFFERS_NOEXCEPT; + BuiltinOptionsUnion &operator=(const BuiltinOptionsUnion &u) FLATBUFFERS_NOEXCEPT + { BuiltinOptionsUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } + BuiltinOptionsUnion &operator=(BuiltinOptionsUnion &&u) FLATBUFFERS_NOEXCEPT + { std::swap(type, u.type); std::swap(value, u.value); return *this; } + ~BuiltinOptionsUnion() { Reset(); } + + void Reset(); + +#ifndef FLATBUFFERS_CPP98_STL + template + void Set(T&& val) { + Reset(); + type = BuiltinOptionsTraits::enum_value; + if (type != BuiltinOptions_NONE) { + value = new T(std::forward(val)); + } + } +#endif // FLATBUFFERS_CPP98_STL + + static void *UnPack(const void *obj, BuiltinOptions type, const flatbuffers::resolver_function_t *resolver); + flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; + + Conv2DOptionsT *AsConv2DOptions() { + return type == BuiltinOptions_Conv2DOptions ? + reinterpret_cast(value) : nullptr; + } + const Conv2DOptionsT *AsConv2DOptions() const { + return type == BuiltinOptions_Conv2DOptions ? + reinterpret_cast(value) : nullptr; + } + DepthwiseConv2DOptionsT *AsDepthwiseConv2DOptions() { + return type == BuiltinOptions_DepthwiseConv2DOptions ? + reinterpret_cast(value) : nullptr; + } + const DepthwiseConv2DOptionsT *AsDepthwiseConv2DOptions() const { + return type == BuiltinOptions_DepthwiseConv2DOptions ? + reinterpret_cast(value) : nullptr; + } + ConcatEmbeddingsOptionsT *AsConcatEmbeddingsOptions() { + return type == BuiltinOptions_ConcatEmbeddingsOptions ? + reinterpret_cast(value) : nullptr; + } + const ConcatEmbeddingsOptionsT *AsConcatEmbeddingsOptions() const { + return type == BuiltinOptions_ConcatEmbeddingsOptions ? + reinterpret_cast(value) : nullptr; + } + LSHProjectionOptionsT *AsLSHProjectionOptions() { + return type == BuiltinOptions_LSHProjectionOptions ? + reinterpret_cast(value) : nullptr; + } + const LSHProjectionOptionsT *AsLSHProjectionOptions() const { + return type == BuiltinOptions_LSHProjectionOptions ? + reinterpret_cast(value) : nullptr; + } + Pool2DOptionsT *AsPool2DOptions() { + return type == BuiltinOptions_Pool2DOptions ? + reinterpret_cast(value) : nullptr; + } + const Pool2DOptionsT *AsPool2DOptions() const { + return type == BuiltinOptions_Pool2DOptions ? + reinterpret_cast(value) : nullptr; + } + SVDFOptionsT *AsSVDFOptions() { + return type == BuiltinOptions_SVDFOptions ? + reinterpret_cast(value) : nullptr; + } + const SVDFOptionsT *AsSVDFOptions() const { + return type == BuiltinOptions_SVDFOptions ? + reinterpret_cast(value) : nullptr; + } + RNNOptionsT *AsRNNOptions() { + return type == BuiltinOptions_RNNOptions ? + reinterpret_cast(value) : nullptr; + } + const RNNOptionsT *AsRNNOptions() const { + return type == BuiltinOptions_RNNOptions ? + reinterpret_cast(value) : nullptr; + } + FullyConnectedOptionsT *AsFullyConnectedOptions() { + return type == BuiltinOptions_FullyConnectedOptions ? + reinterpret_cast(value) : nullptr; + } + const FullyConnectedOptionsT *AsFullyConnectedOptions() const { + return type == BuiltinOptions_FullyConnectedOptions ? + reinterpret_cast(value) : nullptr; + } + SoftmaxOptionsT *AsSoftmaxOptions() { + return type == BuiltinOptions_SoftmaxOptions ? + reinterpret_cast(value) : nullptr; + } + const SoftmaxOptionsT *AsSoftmaxOptions() const { + return type == BuiltinOptions_SoftmaxOptions ? + reinterpret_cast(value) : nullptr; + } + ConcatenationOptionsT *AsConcatenationOptions() { + return type == BuiltinOptions_ConcatenationOptions ? + reinterpret_cast(value) : nullptr; + } + const ConcatenationOptionsT *AsConcatenationOptions() const { + return type == BuiltinOptions_ConcatenationOptions ? + reinterpret_cast(value) : nullptr; + } + AddOptionsT *AsAddOptions() { + return type == BuiltinOptions_AddOptions ? + reinterpret_cast(value) : nullptr; + } + const AddOptionsT *AsAddOptions() const { + return type == BuiltinOptions_AddOptions ? + reinterpret_cast(value) : nullptr; + } + L2NormOptionsT *AsL2NormOptions() { + return type == BuiltinOptions_L2NormOptions ? + reinterpret_cast(value) : nullptr; + } + const L2NormOptionsT *AsL2NormOptions() const { + return type == BuiltinOptions_L2NormOptions ? + reinterpret_cast(value) : nullptr; + } + LocalResponseNormalizationOptionsT *AsLocalResponseNormalizationOptions() { + return type == BuiltinOptions_LocalResponseNormalizationOptions ? + reinterpret_cast(value) : nullptr; + } + const LocalResponseNormalizationOptionsT *AsLocalResponseNormalizationOptions() const { + return type == BuiltinOptions_LocalResponseNormalizationOptions ? + reinterpret_cast(value) : nullptr; + } + LSTMOptionsT *AsLSTMOptions() { + return type == BuiltinOptions_LSTMOptions ? + reinterpret_cast(value) : nullptr; + } + const LSTMOptionsT *AsLSTMOptions() const { + return type == BuiltinOptions_LSTMOptions ? + reinterpret_cast(value) : nullptr; + } + ResizeBilinearOptionsT *AsResizeBilinearOptions() { + return type == BuiltinOptions_ResizeBilinearOptions ? + reinterpret_cast(value) : nullptr; + } + const ResizeBilinearOptionsT *AsResizeBilinearOptions() const { + return type == BuiltinOptions_ResizeBilinearOptions ? + reinterpret_cast(value) : nullptr; + } + CallOptionsT *AsCallOptions() { + return type == BuiltinOptions_CallOptions ? + reinterpret_cast(value) : nullptr; + } + const CallOptionsT *AsCallOptions() const { + return type == BuiltinOptions_CallOptions ? + reinterpret_cast(value) : nullptr; + } + ReshapeOptionsT *AsReshapeOptions() { + return type == BuiltinOptions_ReshapeOptions ? + reinterpret_cast(value) : nullptr; + } + const ReshapeOptionsT *AsReshapeOptions() const { + return type == BuiltinOptions_ReshapeOptions ? + reinterpret_cast(value) : nullptr; + } + SkipGramOptionsT *AsSkipGramOptions() { + return type == BuiltinOptions_SkipGramOptions ? + reinterpret_cast(value) : nullptr; + } + const SkipGramOptionsT *AsSkipGramOptions() const { + return type == BuiltinOptions_SkipGramOptions ? + reinterpret_cast(value) : nullptr; + } + SpaceToDepthOptionsT *AsSpaceToDepthOptions() { + return type == BuiltinOptions_SpaceToDepthOptions ? + reinterpret_cast(value) : nullptr; + } + const SpaceToDepthOptionsT *AsSpaceToDepthOptions() const { + return type == BuiltinOptions_SpaceToDepthOptions ? + reinterpret_cast(value) : nullptr; + } + EmbeddingLookupSparseOptionsT *AsEmbeddingLookupSparseOptions() { + return type == BuiltinOptions_EmbeddingLookupSparseOptions ? + reinterpret_cast(value) : nullptr; + } + const EmbeddingLookupSparseOptionsT *AsEmbeddingLookupSparseOptions() const { + return type == BuiltinOptions_EmbeddingLookupSparseOptions ? + reinterpret_cast(value) : nullptr; + } + MulOptionsT *AsMulOptions() { + return type == BuiltinOptions_MulOptions ? + reinterpret_cast(value) : nullptr; + } + const MulOptionsT *AsMulOptions() const { + return type == BuiltinOptions_MulOptions ? + reinterpret_cast(value) : nullptr; + } +}; + +bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type); +bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +enum Padding { + Padding_SAME = 0, + Padding_VALID = 1, + Padding_MIN = Padding_SAME, + Padding_MAX = Padding_VALID +}; + +inline Padding (&EnumValuesPadding())[2] { + static Padding values[] = { + Padding_SAME, + Padding_VALID + }; + return values; +} + +inline const char **EnumNamesPadding() { + static const char *names[] = { + "SAME", + "VALID", + nullptr + }; + return names; +} + +inline const char *EnumNamePadding(Padding e) { + const size_t index = static_cast(e); + return EnumNamesPadding()[index]; +} + +enum ActivationFunctionType { + ActivationFunctionType_NONE = 0, + ActivationFunctionType_RELU = 1, + ActivationFunctionType_RELU1 = 2, + ActivationFunctionType_RELU6 = 3, + ActivationFunctionType_TANH = 4, + ActivationFunctionType_SIGN_BIT = 5, + ActivationFunctionType_MIN = ActivationFunctionType_NONE, + ActivationFunctionType_MAX = ActivationFunctionType_SIGN_BIT +}; + +inline ActivationFunctionType (&EnumValuesActivationFunctionType())[6] { + static ActivationFunctionType values[] = { + ActivationFunctionType_NONE, + ActivationFunctionType_RELU, + ActivationFunctionType_RELU1, + ActivationFunctionType_RELU6, + ActivationFunctionType_TANH, + ActivationFunctionType_SIGN_BIT + }; + return values; +} + +inline const char **EnumNamesActivationFunctionType() { + static const char *names[] = { + "NONE", + "RELU", + "RELU1", + "RELU6", + "TANH", + "SIGN_BIT", + nullptr + }; + return names; +} + +inline const char *EnumNameActivationFunctionType(ActivationFunctionType e) { + const size_t index = static_cast(e); + return EnumNamesActivationFunctionType()[index]; +} + +enum LSHProjectionType { + LSHProjectionType_UNKNOWN = 0, + LSHProjectionType_SPARSE = 1, + LSHProjectionType_DENSE = 2, + LSHProjectionType_MIN = LSHProjectionType_UNKNOWN, + LSHProjectionType_MAX = LSHProjectionType_DENSE +}; + +inline LSHProjectionType (&EnumValuesLSHProjectionType())[3] { + static LSHProjectionType values[] = { + LSHProjectionType_UNKNOWN, + LSHProjectionType_SPARSE, + LSHProjectionType_DENSE + }; + return values; +} + +inline const char **EnumNamesLSHProjectionType() { + static const char *names[] = { + "UNKNOWN", + "SPARSE", + "DENSE", + nullptr + }; + return names; +} + +inline const char *EnumNameLSHProjectionType(LSHProjectionType e) { + const size_t index = static_cast(e); + return EnumNamesLSHProjectionType()[index]; +} + +enum CombinerType { + CombinerType_SUM = 0, + CombinerType_MEAN = 1, + CombinerType_SQRTN = 2, + CombinerType_MIN = CombinerType_SUM, + CombinerType_MAX = CombinerType_SQRTN +}; + +inline CombinerType (&EnumValuesCombinerType())[3] { + static CombinerType values[] = { + CombinerType_SUM, + CombinerType_MEAN, + CombinerType_SQRTN + }; + return values; +} + +inline const char **EnumNamesCombinerType() { + static const char *names[] = { + "SUM", + "MEAN", + "SQRTN", + nullptr + }; + return names; +} + +inline const char *EnumNameCombinerType(CombinerType e) { + const size_t index = static_cast(e); + return EnumNamesCombinerType()[index]; +} + +enum CustomOptionsFormat { + CustomOptionsFormat_FLEXBUFFERS = 0, + CustomOptionsFormat_MIN = CustomOptionsFormat_FLEXBUFFERS, + CustomOptionsFormat_MAX = CustomOptionsFormat_FLEXBUFFERS +}; + +inline CustomOptionsFormat (&EnumValuesCustomOptionsFormat())[1] { + static CustomOptionsFormat values[] = { + CustomOptionsFormat_FLEXBUFFERS + }; + return values; +} + +inline const char **EnumNamesCustomOptionsFormat() { + static const char *names[] = { + "FLEXBUFFERS", + nullptr + }; + return names; +} + +inline const char *EnumNameCustomOptionsFormat(CustomOptionsFormat e) { + const size_t index = static_cast(e); + return EnumNamesCustomOptionsFormat()[index]; +} + +struct QuantizationParametersT : public flatbuffers::NativeTable { + typedef QuantizationParameters TableType; + std::vector min; + std::vector max; + std::vector scale; + std::vector zero_point; + QuantizationParametersT() { + } +}; + +struct QuantizationParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef QuantizationParametersT NativeTableType; + enum { + VT_MIN = 4, + VT_MAX = 6, + VT_SCALE = 8, + VT_ZERO_POINT = 10 + }; + const flatbuffers::Vector *min() const { + return GetPointer *>(VT_MIN); + } + const flatbuffers::Vector *max() const { + return GetPointer *>(VT_MAX); + } + const flatbuffers::Vector *scale() const { + return GetPointer *>(VT_SCALE); + } + const flatbuffers::Vector *zero_point() const { + return GetPointer *>(VT_ZERO_POINT); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_MIN) && + verifier.Verify(min()) && + VerifyOffset(verifier, VT_MAX) && + verifier.Verify(max()) && + VerifyOffset(verifier, VT_SCALE) && + verifier.Verify(scale()) && + VerifyOffset(verifier, VT_ZERO_POINT) && + verifier.Verify(zero_point()) && + verifier.EndTable(); + } + QuantizationParametersT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(QuantizationParametersT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct QuantizationParametersBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_min(flatbuffers::Offset> min) { + fbb_.AddOffset(QuantizationParameters::VT_MIN, min); + } + void add_max(flatbuffers::Offset> max) { + fbb_.AddOffset(QuantizationParameters::VT_MAX, max); + } + void add_scale(flatbuffers::Offset> scale) { + fbb_.AddOffset(QuantizationParameters::VT_SCALE, scale); + } + void add_zero_point(flatbuffers::Offset> zero_point) { + fbb_.AddOffset(QuantizationParameters::VT_ZERO_POINT, zero_point); + } + explicit QuantizationParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + QuantizationParametersBuilder &operator=(const QuantizationParametersBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateQuantizationParameters( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> min = 0, + flatbuffers::Offset> max = 0, + flatbuffers::Offset> scale = 0, + flatbuffers::Offset> zero_point = 0) { + QuantizationParametersBuilder builder_(_fbb); + builder_.add_zero_point(zero_point); + builder_.add_scale(scale); + builder_.add_max(max); + builder_.add_min(min); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateQuantizationParametersDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *min = nullptr, + const std::vector *max = nullptr, + const std::vector *scale = nullptr, + const std::vector *zero_point = nullptr) { + return tflite::CreateQuantizationParameters( + _fbb, + min ? _fbb.CreateVector(*min) : 0, + max ? _fbb.CreateVector(*max) : 0, + scale ? _fbb.CreateVector(*scale) : 0, + zero_point ? _fbb.CreateVector(*zero_point) : 0); +} + +flatbuffers::Offset CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct TensorT : public flatbuffers::NativeTable { + typedef Tensor TableType; + std::vector shape; + TensorType type; + uint32_t buffer; + std::string name; + std::unique_ptr quantization; + TensorT() + : type(TensorType_FLOAT32), + buffer(0) { + } +}; + +struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TensorT NativeTableType; + enum { + VT_SHAPE = 4, + VT_TYPE = 6, + VT_BUFFER = 8, + VT_NAME = 10, + VT_QUANTIZATION = 12 + }; + const flatbuffers::Vector *shape() const { + return GetPointer *>(VT_SHAPE); + } + TensorType type() const { + return static_cast(GetField(VT_TYPE, 0)); + } + uint32_t buffer() const { + return GetField(VT_BUFFER, 0); + } + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + const QuantizationParameters *quantization() const { + return GetPointer(VT_QUANTIZATION); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_SHAPE) && + verifier.Verify(shape()) && + VerifyField(verifier, VT_TYPE) && + VerifyField(verifier, VT_BUFFER) && + VerifyOffset(verifier, VT_NAME) && + verifier.Verify(name()) && + VerifyOffset(verifier, VT_QUANTIZATION) && + verifier.VerifyTable(quantization()) && + verifier.EndTable(); + } + TensorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(TensorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct TensorBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_shape(flatbuffers::Offset> shape) { + fbb_.AddOffset(Tensor::VT_SHAPE, shape); + } + void add_type(TensorType type) { + fbb_.AddElement(Tensor::VT_TYPE, static_cast(type), 0); + } + void add_buffer(uint32_t buffer) { + fbb_.AddElement(Tensor::VT_BUFFER, buffer, 0); + } + void add_name(flatbuffers::Offset name) { + fbb_.AddOffset(Tensor::VT_NAME, name); + } + void add_quantization(flatbuffers::Offset quantization) { + fbb_.AddOffset(Tensor::VT_QUANTIZATION, quantization); + } + explicit TensorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TensorBuilder &operator=(const TensorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTensor( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> shape = 0, + TensorType type = TensorType_FLOAT32, + uint32_t buffer = 0, + flatbuffers::Offset name = 0, + flatbuffers::Offset quantization = 0) { + TensorBuilder builder_(_fbb); + builder_.add_quantization(quantization); + builder_.add_name(name); + builder_.add_buffer(buffer); + builder_.add_shape(shape); + builder_.add_type(type); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateTensorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *shape = nullptr, + TensorType type = TensorType_FLOAT32, + uint32_t buffer = 0, + const char *name = nullptr, + flatbuffers::Offset quantization = 0) { + return tflite::CreateTensor( + _fbb, + shape ? _fbb.CreateVector(*shape) : 0, + type, + buffer, + name ? _fbb.CreateString(name) : 0, + quantization); +} + +flatbuffers::Offset CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct Conv2DOptionsT : public flatbuffers::NativeTable { + typedef Conv2DOptions TableType; + Padding padding; + int32_t stride_w; + int32_t stride_h; + ActivationFunctionType fused_activation_function; + Conv2DOptionsT() + : padding(Padding_SAME), + stride_w(0), + stride_h(0), + fused_activation_function(ActivationFunctionType_NONE) { + } +}; + +struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef Conv2DOptionsT NativeTableType; + enum { + VT_PADDING = 4, + VT_STRIDE_W = 6, + VT_STRIDE_H = 8, + VT_FUSED_ACTIVATION_FUNCTION = 10 + }; + Padding padding() const { + return static_cast(GetField(VT_PADDING, 0)); + } + int32_t stride_w() const { + return GetField(VT_STRIDE_W, 0); + } + int32_t stride_h() const { + return GetField(VT_STRIDE_H, 0); + } + ActivationFunctionType fused_activation_function() const { + return static_cast(GetField(VT_FUSED_ACTIVATION_FUNCTION, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_PADDING) && + VerifyField(verifier, VT_STRIDE_W) && + VerifyField(verifier, VT_STRIDE_H) && + VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION) && + verifier.EndTable(); + } + Conv2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(Conv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct Conv2DOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_padding(Padding padding) { + fbb_.AddElement(Conv2DOptions::VT_PADDING, static_cast(padding), 0); + } + void add_stride_w(int32_t stride_w) { + fbb_.AddElement(Conv2DOptions::VT_STRIDE_W, stride_w, 0); + } + void add_stride_h(int32_t stride_h) { + fbb_.AddElement(Conv2DOptions::VT_STRIDE_H, stride_h, 0); + } + void add_fused_activation_function(ActivationFunctionType fused_activation_function) { + fbb_.AddElement(Conv2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); + } + explicit Conv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + Conv2DOptionsBuilder &operator=(const Conv2DOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateConv2DOptions( + flatbuffers::FlatBufferBuilder &_fbb, + Padding padding = Padding_SAME, + int32_t stride_w = 0, + int32_t stride_h = 0, + ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { + Conv2DOptionsBuilder builder_(_fbb); + builder_.add_stride_h(stride_h); + builder_.add_stride_w(stride_w); + builder_.add_fused_activation_function(fused_activation_function); + builder_.add_padding(padding); + return builder_.Finish(); +} + +flatbuffers::Offset CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct Pool2DOptionsT : public flatbuffers::NativeTable { + typedef Pool2DOptions TableType; + Padding padding; + int32_t stride_w; + int32_t stride_h; + int32_t filter_width; + int32_t filter_height; + ActivationFunctionType fused_activation_function; + Pool2DOptionsT() + : padding(Padding_SAME), + stride_w(0), + stride_h(0), + filter_width(0), + filter_height(0), + fused_activation_function(ActivationFunctionType_NONE) { + } +}; + +struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef Pool2DOptionsT NativeTableType; + enum { + VT_PADDING = 4, + VT_STRIDE_W = 6, + VT_STRIDE_H = 8, + VT_FILTER_WIDTH = 10, + VT_FILTER_HEIGHT = 12, + VT_FUSED_ACTIVATION_FUNCTION = 14 + }; + Padding padding() const { + return static_cast(GetField(VT_PADDING, 0)); + } + int32_t stride_w() const { + return GetField(VT_STRIDE_W, 0); + } + int32_t stride_h() const { + return GetField(VT_STRIDE_H, 0); + } + int32_t filter_width() const { + return GetField(VT_FILTER_WIDTH, 0); + } + int32_t filter_height() const { + return GetField(VT_FILTER_HEIGHT, 0); + } + ActivationFunctionType fused_activation_function() const { + return static_cast(GetField(VT_FUSED_ACTIVATION_FUNCTION, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_PADDING) && + VerifyField(verifier, VT_STRIDE_W) && + VerifyField(verifier, VT_STRIDE_H) && + VerifyField(verifier, VT_FILTER_WIDTH) && + VerifyField(verifier, VT_FILTER_HEIGHT) && + VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION) && + verifier.EndTable(); + } + Pool2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(Pool2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct Pool2DOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_padding(Padding padding) { + fbb_.AddElement(Pool2DOptions::VT_PADDING, static_cast(padding), 0); + } + void add_stride_w(int32_t stride_w) { + fbb_.AddElement(Pool2DOptions::VT_STRIDE_W, stride_w, 0); + } + void add_stride_h(int32_t stride_h) { + fbb_.AddElement(Pool2DOptions::VT_STRIDE_H, stride_h, 0); + } + void add_filter_width(int32_t filter_width) { + fbb_.AddElement(Pool2DOptions::VT_FILTER_WIDTH, filter_width, 0); + } + void add_filter_height(int32_t filter_height) { + fbb_.AddElement(Pool2DOptions::VT_FILTER_HEIGHT, filter_height, 0); + } + void add_fused_activation_function(ActivationFunctionType fused_activation_function) { + fbb_.AddElement(Pool2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); + } + explicit Pool2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + Pool2DOptionsBuilder &operator=(const Pool2DOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreatePool2DOptions( + flatbuffers::FlatBufferBuilder &_fbb, + Padding padding = Padding_SAME, + int32_t stride_w = 0, + int32_t stride_h = 0, + int32_t filter_width = 0, + int32_t filter_height = 0, + ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { + Pool2DOptionsBuilder builder_(_fbb); + builder_.add_filter_height(filter_height); + builder_.add_filter_width(filter_width); + builder_.add_stride_h(stride_h); + builder_.add_stride_w(stride_w); + builder_.add_fused_activation_function(fused_activation_function); + builder_.add_padding(padding); + return builder_.Finish(); +} + +flatbuffers::Offset CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct DepthwiseConv2DOptionsT : public flatbuffers::NativeTable { + typedef DepthwiseConv2DOptions TableType; + Padding padding; + int32_t stride_w; + int32_t stride_h; + int32_t depth_multiplier; + ActivationFunctionType fused_activation_function; + DepthwiseConv2DOptionsT() + : padding(Padding_SAME), + stride_w(0), + stride_h(0), + depth_multiplier(0), + fused_activation_function(ActivationFunctionType_NONE) { + } +}; + +struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef DepthwiseConv2DOptionsT NativeTableType; + enum { + VT_PADDING = 4, + VT_STRIDE_W = 6, + VT_STRIDE_H = 8, + VT_DEPTH_MULTIPLIER = 10, + VT_FUSED_ACTIVATION_FUNCTION = 12 + }; + Padding padding() const { + return static_cast(GetField(VT_PADDING, 0)); + } + int32_t stride_w() const { + return GetField(VT_STRIDE_W, 0); + } + int32_t stride_h() const { + return GetField(VT_STRIDE_H, 0); + } + int32_t depth_multiplier() const { + return GetField(VT_DEPTH_MULTIPLIER, 0); + } + ActivationFunctionType fused_activation_function() const { + return static_cast(GetField(VT_FUSED_ACTIVATION_FUNCTION, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_PADDING) && + VerifyField(verifier, VT_STRIDE_W) && + VerifyField(verifier, VT_STRIDE_H) && + VerifyField(verifier, VT_DEPTH_MULTIPLIER) && + VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION) && + verifier.EndTable(); + } + DepthwiseConv2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(DepthwiseConv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct DepthwiseConv2DOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_padding(Padding padding) { + fbb_.AddElement(DepthwiseConv2DOptions::VT_PADDING, static_cast(padding), 0); + } + void add_stride_w(int32_t stride_w) { + fbb_.AddElement(DepthwiseConv2DOptions::VT_STRIDE_W, stride_w, 0); + } + void add_stride_h(int32_t stride_h) { + fbb_.AddElement(DepthwiseConv2DOptions::VT_STRIDE_H, stride_h, 0); + } + void add_depth_multiplier(int32_t depth_multiplier) { + fbb_.AddElement(DepthwiseConv2DOptions::VT_DEPTH_MULTIPLIER, depth_multiplier, 0); + } + void add_fused_activation_function(ActivationFunctionType fused_activation_function) { + fbb_.AddElement(DepthwiseConv2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); + } + explicit DepthwiseConv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + DepthwiseConv2DOptionsBuilder &operator=(const DepthwiseConv2DOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateDepthwiseConv2DOptions( + flatbuffers::FlatBufferBuilder &_fbb, + Padding padding = Padding_SAME, + int32_t stride_w = 0, + int32_t stride_h = 0, + int32_t depth_multiplier = 0, + ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { + DepthwiseConv2DOptionsBuilder builder_(_fbb); + builder_.add_depth_multiplier(depth_multiplier); + builder_.add_stride_h(stride_h); + builder_.add_stride_w(stride_w); + builder_.add_fused_activation_function(fused_activation_function); + builder_.add_padding(padding); + return builder_.Finish(); +} + +flatbuffers::Offset CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct ConcatEmbeddingsOptionsT : public flatbuffers::NativeTable { + typedef ConcatEmbeddingsOptions TableType; + int32_t num_channels; + std::vector num_columns_per_channel; + std::vector embedding_dim_per_channel; + ConcatEmbeddingsOptionsT() + : num_channels(0) { + } +}; + +struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ConcatEmbeddingsOptionsT NativeTableType; + enum { + VT_NUM_CHANNELS = 4, + VT_NUM_COLUMNS_PER_CHANNEL = 6, + VT_EMBEDDING_DIM_PER_CHANNEL = 8 + }; + int32_t num_channels() const { + return GetField(VT_NUM_CHANNELS, 0); + } + const flatbuffers::Vector *num_columns_per_channel() const { + return GetPointer *>(VT_NUM_COLUMNS_PER_CHANNEL); + } + const flatbuffers::Vector *embedding_dim_per_channel() const { + return GetPointer *>(VT_EMBEDDING_DIM_PER_CHANNEL); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_NUM_CHANNELS) && + VerifyOffset(verifier, VT_NUM_COLUMNS_PER_CHANNEL) && + verifier.Verify(num_columns_per_channel()) && + VerifyOffset(verifier, VT_EMBEDDING_DIM_PER_CHANNEL) && + verifier.Verify(embedding_dim_per_channel()) && + verifier.EndTable(); + } + ConcatEmbeddingsOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ConcatEmbeddingsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ConcatEmbeddingsOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_num_channels(int32_t num_channels) { + fbb_.AddElement(ConcatEmbeddingsOptions::VT_NUM_CHANNELS, num_channels, 0); + } + void add_num_columns_per_channel(flatbuffers::Offset> num_columns_per_channel) { + fbb_.AddOffset(ConcatEmbeddingsOptions::VT_NUM_COLUMNS_PER_CHANNEL, num_columns_per_channel); + } + void add_embedding_dim_per_channel(flatbuffers::Offset> embedding_dim_per_channel) { + fbb_.AddOffset(ConcatEmbeddingsOptions::VT_EMBEDDING_DIM_PER_CHANNEL, embedding_dim_per_channel); + } + explicit ConcatEmbeddingsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ConcatEmbeddingsOptionsBuilder &operator=(const ConcatEmbeddingsOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateConcatEmbeddingsOptions( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t num_channels = 0, + flatbuffers::Offset> num_columns_per_channel = 0, + flatbuffers::Offset> embedding_dim_per_channel = 0) { + ConcatEmbeddingsOptionsBuilder builder_(_fbb); + builder_.add_embedding_dim_per_channel(embedding_dim_per_channel); + builder_.add_num_columns_per_channel(num_columns_per_channel); + builder_.add_num_channels(num_channels); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateConcatEmbeddingsOptionsDirect( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t num_channels = 0, + const std::vector *num_columns_per_channel = nullptr, + const std::vector *embedding_dim_per_channel = nullptr) { + return tflite::CreateConcatEmbeddingsOptions( + _fbb, + num_channels, + num_columns_per_channel ? _fbb.CreateVector(*num_columns_per_channel) : 0, + embedding_dim_per_channel ? _fbb.CreateVector(*embedding_dim_per_channel) : 0); +} + +flatbuffers::Offset CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct LSHProjectionOptionsT : public flatbuffers::NativeTable { + typedef LSHProjectionOptions TableType; + LSHProjectionType type; + LSHProjectionOptionsT() + : type(LSHProjectionType_UNKNOWN) { + } +}; + +struct LSHProjectionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LSHProjectionOptionsT NativeTableType; + enum { + VT_TYPE = 4 + }; + LSHProjectionType type() const { + return static_cast(GetField(VT_TYPE, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_TYPE) && + verifier.EndTable(); + } + LSHProjectionOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(LSHProjectionOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct LSHProjectionOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_type(LSHProjectionType type) { + fbb_.AddElement(LSHProjectionOptions::VT_TYPE, static_cast(type), 0); + } + explicit LSHProjectionOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + LSHProjectionOptionsBuilder &operator=(const LSHProjectionOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateLSHProjectionOptions( + flatbuffers::FlatBufferBuilder &_fbb, + LSHProjectionType type = LSHProjectionType_UNKNOWN) { + LSHProjectionOptionsBuilder builder_(_fbb); + builder_.add_type(type); + return builder_.Finish(); +} + +flatbuffers::Offset CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct SVDFOptionsT : public flatbuffers::NativeTable { + typedef SVDFOptions TableType; + int32_t rank; + ActivationFunctionType fused_activation_function; + SVDFOptionsT() + : rank(0), + fused_activation_function(ActivationFunctionType_NONE) { + } +}; + +struct SVDFOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SVDFOptionsT NativeTableType; + enum { + VT_RANK = 4, + VT_FUSED_ACTIVATION_FUNCTION = 6 + }; + int32_t rank() const { + return GetField(VT_RANK, 0); + } + ActivationFunctionType fused_activation_function() const { + return static_cast(GetField(VT_FUSED_ACTIVATION_FUNCTION, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_RANK) && + VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION) && + verifier.EndTable(); + } + SVDFOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SVDFOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct SVDFOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_rank(int32_t rank) { + fbb_.AddElement(SVDFOptions::VT_RANK, rank, 0); + } + void add_fused_activation_function(ActivationFunctionType fused_activation_function) { + fbb_.AddElement(SVDFOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); + } + explicit SVDFOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SVDFOptionsBuilder &operator=(const SVDFOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSVDFOptions( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t rank = 0, + ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { + SVDFOptionsBuilder builder_(_fbb); + builder_.add_rank(rank); + builder_.add_fused_activation_function(fused_activation_function); + return builder_.Finish(); +} + +flatbuffers::Offset CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct RNNOptionsT : public flatbuffers::NativeTable { + typedef RNNOptions TableType; + ActivationFunctionType fused_activation_function; + RNNOptionsT() + : fused_activation_function(ActivationFunctionType_NONE) { + } +}; + +struct RNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef RNNOptionsT NativeTableType; + enum { + VT_FUSED_ACTIVATION_FUNCTION = 4 + }; + ActivationFunctionType fused_activation_function() const { + return static_cast(GetField(VT_FUSED_ACTIVATION_FUNCTION, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION) && + verifier.EndTable(); + } + RNNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(RNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct RNNOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_fused_activation_function(ActivationFunctionType fused_activation_function) { + fbb_.AddElement(RNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); + } + explicit RNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + RNNOptionsBuilder &operator=(const RNNOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateRNNOptions( + flatbuffers::FlatBufferBuilder &_fbb, + ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { + RNNOptionsBuilder builder_(_fbb); + builder_.add_fused_activation_function(fused_activation_function); + return builder_.Finish(); +} + +flatbuffers::Offset CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct FullyConnectedOptionsT : public flatbuffers::NativeTable { + typedef FullyConnectedOptions TableType; + ActivationFunctionType fused_activation_function; + FullyConnectedOptionsT() + : fused_activation_function(ActivationFunctionType_NONE) { + } +}; + +struct FullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FullyConnectedOptionsT NativeTableType; + enum { + VT_FUSED_ACTIVATION_FUNCTION = 4 + }; + ActivationFunctionType fused_activation_function() const { + return static_cast(GetField(VT_FUSED_ACTIVATION_FUNCTION, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION) && + verifier.EndTable(); + } + FullyConnectedOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(FullyConnectedOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct FullyConnectedOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_fused_activation_function(ActivationFunctionType fused_activation_function) { + fbb_.AddElement(FullyConnectedOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); + } + explicit FullyConnectedOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + FullyConnectedOptionsBuilder &operator=(const FullyConnectedOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateFullyConnectedOptions( + flatbuffers::FlatBufferBuilder &_fbb, + ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { + FullyConnectedOptionsBuilder builder_(_fbb); + builder_.add_fused_activation_function(fused_activation_function); + return builder_.Finish(); +} + +flatbuffers::Offset CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct SoftmaxOptionsT : public flatbuffers::NativeTable { + typedef SoftmaxOptions TableType; + float beta; + SoftmaxOptionsT() + : beta(0.0f) { + } +}; + +struct SoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SoftmaxOptionsT NativeTableType; + enum { + VT_BETA = 4 + }; + float beta() const { + return GetField(VT_BETA, 0.0f); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_BETA) && + verifier.EndTable(); + } + SoftmaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct SoftmaxOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_beta(float beta) { + fbb_.AddElement(SoftmaxOptions::VT_BETA, beta, 0.0f); + } + explicit SoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SoftmaxOptionsBuilder &operator=(const SoftmaxOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSoftmaxOptions( + flatbuffers::FlatBufferBuilder &_fbb, + float beta = 0.0f) { + SoftmaxOptionsBuilder builder_(_fbb); + builder_.add_beta(beta); + return builder_.Finish(); +} + +flatbuffers::Offset CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct ConcatenationOptionsT : public flatbuffers::NativeTable { + typedef ConcatenationOptions TableType; + int32_t axis; + ActivationFunctionType fused_activation_function; + ConcatenationOptionsT() + : axis(0), + fused_activation_function(ActivationFunctionType_NONE) { + } +}; + +struct ConcatenationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ConcatenationOptionsT NativeTableType; + enum { + VT_AXIS = 4, + VT_FUSED_ACTIVATION_FUNCTION = 6 + }; + int32_t axis() const { + return GetField(VT_AXIS, 0); + } + ActivationFunctionType fused_activation_function() const { + return static_cast(GetField(VT_FUSED_ACTIVATION_FUNCTION, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_AXIS) && + VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION) && + verifier.EndTable(); + } + ConcatenationOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ConcatenationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ConcatenationOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_axis(int32_t axis) { + fbb_.AddElement(ConcatenationOptions::VT_AXIS, axis, 0); + } + void add_fused_activation_function(ActivationFunctionType fused_activation_function) { + fbb_.AddElement(ConcatenationOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); + } + explicit ConcatenationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ConcatenationOptionsBuilder &operator=(const ConcatenationOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateConcatenationOptions( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t axis = 0, + ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { + ConcatenationOptionsBuilder builder_(_fbb); + builder_.add_axis(axis); + builder_.add_fused_activation_function(fused_activation_function); + return builder_.Finish(); +} + +flatbuffers::Offset CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct AddOptionsT : public flatbuffers::NativeTable { + typedef AddOptions TableType; + ActivationFunctionType fused_activation_function; + AddOptionsT() + : fused_activation_function(ActivationFunctionType_NONE) { + } +}; + +struct AddOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef AddOptionsT NativeTableType; + enum { + VT_FUSED_ACTIVATION_FUNCTION = 4 + }; + ActivationFunctionType fused_activation_function() const { + return static_cast(GetField(VT_FUSED_ACTIVATION_FUNCTION, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION) && + verifier.EndTable(); + } + AddOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(AddOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct AddOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_fused_activation_function(ActivationFunctionType fused_activation_function) { + fbb_.AddElement(AddOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); + } + explicit AddOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + AddOptionsBuilder &operator=(const AddOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateAddOptions( + flatbuffers::FlatBufferBuilder &_fbb, + ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { + AddOptionsBuilder builder_(_fbb); + builder_.add_fused_activation_function(fused_activation_function); + return builder_.Finish(); +} + +flatbuffers::Offset CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct MulOptionsT : public flatbuffers::NativeTable { + typedef MulOptions TableType; + ActivationFunctionType fused_activation_function; + MulOptionsT() + : fused_activation_function(ActivationFunctionType_NONE) { + } +}; + +struct MulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MulOptionsT NativeTableType; + enum { + VT_FUSED_ACTIVATION_FUNCTION = 4 + }; + ActivationFunctionType fused_activation_function() const { + return static_cast(GetField(VT_FUSED_ACTIVATION_FUNCTION, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION) && + verifier.EndTable(); + } + MulOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(MulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct MulOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_fused_activation_function(ActivationFunctionType fused_activation_function) { + fbb_.AddElement(MulOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); + } + explicit MulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + MulOptionsBuilder &operator=(const MulOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateMulOptions( + flatbuffers::FlatBufferBuilder &_fbb, + ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { + MulOptionsBuilder builder_(_fbb); + builder_.add_fused_activation_function(fused_activation_function); + return builder_.Finish(); +} + +flatbuffers::Offset CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct L2NormOptionsT : public flatbuffers::NativeTable { + typedef L2NormOptions TableType; + ActivationFunctionType fused_activation_function; + L2NormOptionsT() + : fused_activation_function(ActivationFunctionType_NONE) { + } +}; + +struct L2NormOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef L2NormOptionsT NativeTableType; + enum { + VT_FUSED_ACTIVATION_FUNCTION = 4 + }; + ActivationFunctionType fused_activation_function() const { + return static_cast(GetField(VT_FUSED_ACTIVATION_FUNCTION, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION) && + verifier.EndTable(); + } + L2NormOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(L2NormOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct L2NormOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_fused_activation_function(ActivationFunctionType fused_activation_function) { + fbb_.AddElement(L2NormOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); + } + explicit L2NormOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + L2NormOptionsBuilder &operator=(const L2NormOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateL2NormOptions( + flatbuffers::FlatBufferBuilder &_fbb, + ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { + L2NormOptionsBuilder builder_(_fbb); + builder_.add_fused_activation_function(fused_activation_function); + return builder_.Finish(); +} + +flatbuffers::Offset CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct LocalResponseNormalizationOptionsT : public flatbuffers::NativeTable { + typedef LocalResponseNormalizationOptions TableType; + int32_t radius; + float bias; + float alpha; + float beta; + LocalResponseNormalizationOptionsT() + : radius(0), + bias(0.0f), + alpha(0.0f), + beta(0.0f) { + } +}; + +struct LocalResponseNormalizationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LocalResponseNormalizationOptionsT NativeTableType; + enum { + VT_RADIUS = 4, + VT_BIAS = 6, + VT_ALPHA = 8, + VT_BETA = 10 + }; + int32_t radius() const { + return GetField(VT_RADIUS, 0); + } + float bias() const { + return GetField(VT_BIAS, 0.0f); + } + float alpha() const { + return GetField(VT_ALPHA, 0.0f); + } + float beta() const { + return GetField(VT_BETA, 0.0f); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_RADIUS) && + VerifyField(verifier, VT_BIAS) && + VerifyField(verifier, VT_ALPHA) && + VerifyField(verifier, VT_BETA) && + verifier.EndTable(); + } + LocalResponseNormalizationOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(LocalResponseNormalizationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct LocalResponseNormalizationOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_radius(int32_t radius) { + fbb_.AddElement(LocalResponseNormalizationOptions::VT_RADIUS, radius, 0); + } + void add_bias(float bias) { + fbb_.AddElement(LocalResponseNormalizationOptions::VT_BIAS, bias, 0.0f); + } + void add_alpha(float alpha) { + fbb_.AddElement(LocalResponseNormalizationOptions::VT_ALPHA, alpha, 0.0f); + } + void add_beta(float beta) { + fbb_.AddElement(LocalResponseNormalizationOptions::VT_BETA, beta, 0.0f); + } + explicit LocalResponseNormalizationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + LocalResponseNormalizationOptionsBuilder &operator=(const LocalResponseNormalizationOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateLocalResponseNormalizationOptions( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t radius = 0, + float bias = 0.0f, + float alpha = 0.0f, + float beta = 0.0f) { + LocalResponseNormalizationOptionsBuilder builder_(_fbb); + builder_.add_beta(beta); + builder_.add_alpha(alpha); + builder_.add_bias(bias); + builder_.add_radius(radius); + return builder_.Finish(); +} + +flatbuffers::Offset CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct LSTMOptionsT : public flatbuffers::NativeTable { + typedef LSTMOptions TableType; + ActivationFunctionType fused_activation_function; + float cell_clip; + float proj_clip; + LSTMOptionsT() + : fused_activation_function(ActivationFunctionType_NONE), + cell_clip(0.0f), + proj_clip(0.0f) { + } +}; + +struct LSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LSTMOptionsT NativeTableType; + enum { + VT_FUSED_ACTIVATION_FUNCTION = 4, + VT_CELL_CLIP = 6, + VT_PROJ_CLIP = 8 + }; + ActivationFunctionType fused_activation_function() const { + return static_cast(GetField(VT_FUSED_ACTIVATION_FUNCTION, 0)); + } + float cell_clip() const { + return GetField(VT_CELL_CLIP, 0.0f); + } + float proj_clip() const { + return GetField(VT_PROJ_CLIP, 0.0f); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_FUSED_ACTIVATION_FUNCTION) && + VerifyField(verifier, VT_CELL_CLIP) && + VerifyField(verifier, VT_PROJ_CLIP) && + verifier.EndTable(); + } + LSTMOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(LSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct LSTMOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_fused_activation_function(ActivationFunctionType fused_activation_function) { + fbb_.AddElement(LSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast(fused_activation_function), 0); + } + void add_cell_clip(float cell_clip) { + fbb_.AddElement(LSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f); + } + void add_proj_clip(float proj_clip) { + fbb_.AddElement(LSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f); + } + explicit LSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + LSTMOptionsBuilder &operator=(const LSTMOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateLSTMOptions( + flatbuffers::FlatBufferBuilder &_fbb, + ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE, + float cell_clip = 0.0f, + float proj_clip = 0.0f) { + LSTMOptionsBuilder builder_(_fbb); + builder_.add_proj_clip(proj_clip); + builder_.add_cell_clip(cell_clip); + builder_.add_fused_activation_function(fused_activation_function); + return builder_.Finish(); +} + +flatbuffers::Offset CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct ResizeBilinearOptionsT : public flatbuffers::NativeTable { + typedef ResizeBilinearOptions TableType; + int32_t new_height; + int32_t new_width; + ResizeBilinearOptionsT() + : new_height(0), + new_width(0) { + } +}; + +struct ResizeBilinearOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ResizeBilinearOptionsT NativeTableType; + enum { + VT_NEW_HEIGHT = 4, + VT_NEW_WIDTH = 6 + }; + int32_t new_height() const { + return GetField(VT_NEW_HEIGHT, 0); + } + int32_t new_width() const { + return GetField(VT_NEW_WIDTH, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_NEW_HEIGHT) && + VerifyField(verifier, VT_NEW_WIDTH) && + verifier.EndTable(); + } + ResizeBilinearOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ResizeBilinearOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ResizeBilinearOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_new_height(int32_t new_height) { + fbb_.AddElement(ResizeBilinearOptions::VT_NEW_HEIGHT, new_height, 0); + } + void add_new_width(int32_t new_width) { + fbb_.AddElement(ResizeBilinearOptions::VT_NEW_WIDTH, new_width, 0); + } + explicit ResizeBilinearOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ResizeBilinearOptionsBuilder &operator=(const ResizeBilinearOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateResizeBilinearOptions( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t new_height = 0, + int32_t new_width = 0) { + ResizeBilinearOptionsBuilder builder_(_fbb); + builder_.add_new_width(new_width); + builder_.add_new_height(new_height); + return builder_.Finish(); +} + +flatbuffers::Offset CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct CallOptionsT : public flatbuffers::NativeTable { + typedef CallOptions TableType; + uint32_t subgraph; + CallOptionsT() + : subgraph(0) { + } +}; + +struct CallOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef CallOptionsT NativeTableType; + enum { + VT_SUBGRAPH = 4 + }; + uint32_t subgraph() const { + return GetField(VT_SUBGRAPH, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_SUBGRAPH) && + verifier.EndTable(); + } + CallOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(CallOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct CallOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_subgraph(uint32_t subgraph) { + fbb_.AddElement(CallOptions::VT_SUBGRAPH, subgraph, 0); + } + explicit CallOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + CallOptionsBuilder &operator=(const CallOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateCallOptions( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t subgraph = 0) { + CallOptionsBuilder builder_(_fbb); + builder_.add_subgraph(subgraph); + return builder_.Finish(); +} + +flatbuffers::Offset CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct ReshapeOptionsT : public flatbuffers::NativeTable { + typedef ReshapeOptions TableType; + std::vector new_shape; + ReshapeOptionsT() { + } +}; + +struct ReshapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ReshapeOptionsT NativeTableType; + enum { + VT_NEW_SHAPE = 4 + }; + const flatbuffers::Vector *new_shape() const { + return GetPointer *>(VT_NEW_SHAPE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_NEW_SHAPE) && + verifier.Verify(new_shape()) && + verifier.EndTable(); + } + ReshapeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ReshapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ReshapeOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_new_shape(flatbuffers::Offset> new_shape) { + fbb_.AddOffset(ReshapeOptions::VT_NEW_SHAPE, new_shape); + } + explicit ReshapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ReshapeOptionsBuilder &operator=(const ReshapeOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateReshapeOptions( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> new_shape = 0) { + ReshapeOptionsBuilder builder_(_fbb); + builder_.add_new_shape(new_shape); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateReshapeOptionsDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *new_shape = nullptr) { + return tflite::CreateReshapeOptions( + _fbb, + new_shape ? _fbb.CreateVector(*new_shape) : 0); +} + +flatbuffers::Offset CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct SkipGramOptionsT : public flatbuffers::NativeTable { + typedef SkipGramOptions TableType; + int32_t ngram_size; + int32_t max_skip_size; + bool include_all_ngrams; + SkipGramOptionsT() + : ngram_size(0), + max_skip_size(0), + include_all_ngrams(false) { + } +}; + +struct SkipGramOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SkipGramOptionsT NativeTableType; + enum { + VT_NGRAM_SIZE = 4, + VT_MAX_SKIP_SIZE = 6, + VT_INCLUDE_ALL_NGRAMS = 8 + }; + int32_t ngram_size() const { + return GetField(VT_NGRAM_SIZE, 0); + } + int32_t max_skip_size() const { + return GetField(VT_MAX_SKIP_SIZE, 0); + } + bool include_all_ngrams() const { + return GetField(VT_INCLUDE_ALL_NGRAMS, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_NGRAM_SIZE) && + VerifyField(verifier, VT_MAX_SKIP_SIZE) && + VerifyField(verifier, VT_INCLUDE_ALL_NGRAMS) && + verifier.EndTable(); + } + SkipGramOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SkipGramOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct SkipGramOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_ngram_size(int32_t ngram_size) { + fbb_.AddElement(SkipGramOptions::VT_NGRAM_SIZE, ngram_size, 0); + } + void add_max_skip_size(int32_t max_skip_size) { + fbb_.AddElement(SkipGramOptions::VT_MAX_SKIP_SIZE, max_skip_size, 0); + } + void add_include_all_ngrams(bool include_all_ngrams) { + fbb_.AddElement(SkipGramOptions::VT_INCLUDE_ALL_NGRAMS, static_cast(include_all_ngrams), 0); + } + explicit SkipGramOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SkipGramOptionsBuilder &operator=(const SkipGramOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSkipGramOptions( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t ngram_size = 0, + int32_t max_skip_size = 0, + bool include_all_ngrams = false) { + SkipGramOptionsBuilder builder_(_fbb); + builder_.add_max_skip_size(max_skip_size); + builder_.add_ngram_size(ngram_size); + builder_.add_include_all_ngrams(include_all_ngrams); + return builder_.Finish(); +} + +flatbuffers::Offset CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct SpaceToDepthOptionsT : public flatbuffers::NativeTable { + typedef SpaceToDepthOptions TableType; + int32_t block_size; + SpaceToDepthOptionsT() + : block_size(0) { + } +}; + +struct SpaceToDepthOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SpaceToDepthOptionsT NativeTableType; + enum { + VT_BLOCK_SIZE = 4 + }; + int32_t block_size() const { + return GetField(VT_BLOCK_SIZE, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_BLOCK_SIZE) && + verifier.EndTable(); + } + SpaceToDepthOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SpaceToDepthOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct SpaceToDepthOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_block_size(int32_t block_size) { + fbb_.AddElement(SpaceToDepthOptions::VT_BLOCK_SIZE, block_size, 0); + } + explicit SpaceToDepthOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SpaceToDepthOptionsBuilder &operator=(const SpaceToDepthOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSpaceToDepthOptions( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t block_size = 0) { + SpaceToDepthOptionsBuilder builder_(_fbb); + builder_.add_block_size(block_size); + return builder_.Finish(); +} + +flatbuffers::Offset CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct EmbeddingLookupSparseOptionsT : public flatbuffers::NativeTable { + typedef EmbeddingLookupSparseOptions TableType; + CombinerType combiner; + EmbeddingLookupSparseOptionsT() + : combiner(CombinerType_SUM) { + } +}; + +struct EmbeddingLookupSparseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef EmbeddingLookupSparseOptionsT NativeTableType; + enum { + VT_COMBINER = 4 + }; + CombinerType combiner() const { + return static_cast(GetField(VT_COMBINER, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_COMBINER) && + verifier.EndTable(); + } + EmbeddingLookupSparseOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(EmbeddingLookupSparseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct EmbeddingLookupSparseOptionsBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_combiner(CombinerType combiner) { + fbb_.AddElement(EmbeddingLookupSparseOptions::VT_COMBINER, static_cast(combiner), 0); + } + explicit EmbeddingLookupSparseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + EmbeddingLookupSparseOptionsBuilder &operator=(const EmbeddingLookupSparseOptionsBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateEmbeddingLookupSparseOptions( + flatbuffers::FlatBufferBuilder &_fbb, + CombinerType combiner = CombinerType_SUM) { + EmbeddingLookupSparseOptionsBuilder builder_(_fbb); + builder_.add_combiner(combiner); + return builder_.Finish(); +} + +flatbuffers::Offset CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct OperatorCodeT : public flatbuffers::NativeTable { + typedef OperatorCode TableType; + BuiltinOperator builtin_code; + std::string custom_code; + OperatorCodeT() + : builtin_code(BuiltinOperator_ADD) { + } +}; + +struct OperatorCode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef OperatorCodeT NativeTableType; + enum { + VT_BUILTIN_CODE = 4, + VT_CUSTOM_CODE = 6 + }; + BuiltinOperator builtin_code() const { + return static_cast(GetField(VT_BUILTIN_CODE, 0)); + } + const flatbuffers::String *custom_code() const { + return GetPointer(VT_CUSTOM_CODE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_BUILTIN_CODE) && + VerifyOffset(verifier, VT_CUSTOM_CODE) && + verifier.Verify(custom_code()) && + verifier.EndTable(); + } + OperatorCodeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(OperatorCodeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct OperatorCodeBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_builtin_code(BuiltinOperator builtin_code) { + fbb_.AddElement(OperatorCode::VT_BUILTIN_CODE, static_cast(builtin_code), 0); + } + void add_custom_code(flatbuffers::Offset custom_code) { + fbb_.AddOffset(OperatorCode::VT_CUSTOM_CODE, custom_code); + } + explicit OperatorCodeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + OperatorCodeBuilder &operator=(const OperatorCodeBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateOperatorCode( + flatbuffers::FlatBufferBuilder &_fbb, + BuiltinOperator builtin_code = BuiltinOperator_ADD, + flatbuffers::Offset custom_code = 0) { + OperatorCodeBuilder builder_(_fbb); + builder_.add_custom_code(custom_code); + builder_.add_builtin_code(builtin_code); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateOperatorCodeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + BuiltinOperator builtin_code = BuiltinOperator_ADD, + const char *custom_code = nullptr) { + return tflite::CreateOperatorCode( + _fbb, + builtin_code, + custom_code ? _fbb.CreateString(custom_code) : 0); +} + +flatbuffers::Offset CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct OperatorT : public flatbuffers::NativeTable { + typedef Operator TableType; + uint32_t opcode_index; + std::vector inputs; + std::vector outputs; + BuiltinOptionsUnion builtin_options; + std::vector custom_options; + CustomOptionsFormat custom_options_format; + OperatorT() + : opcode_index(0), + custom_options_format(CustomOptionsFormat_FLEXBUFFERS) { + } +}; + +struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef OperatorT NativeTableType; + enum { + VT_OPCODE_INDEX = 4, + VT_INPUTS = 6, + VT_OUTPUTS = 8, + VT_BUILTIN_OPTIONS_TYPE = 10, + VT_BUILTIN_OPTIONS = 12, + VT_CUSTOM_OPTIONS = 14, + VT_CUSTOM_OPTIONS_FORMAT = 16 + }; + uint32_t opcode_index() const { + return GetField(VT_OPCODE_INDEX, 0); + } + const flatbuffers::Vector *inputs() const { + return GetPointer *>(VT_INPUTS); + } + const flatbuffers::Vector *outputs() const { + return GetPointer *>(VT_OUTPUTS); + } + BuiltinOptions builtin_options_type() const { + return static_cast(GetField(VT_BUILTIN_OPTIONS_TYPE, 0)); + } + const void *builtin_options() const { + return GetPointer(VT_BUILTIN_OPTIONS); + } + template const T *builtin_options_as() const; + const Conv2DOptions *builtin_options_as_Conv2DOptions() const { + return builtin_options_type() == BuiltinOptions_Conv2DOptions ? static_cast(builtin_options()) : nullptr; + } + const DepthwiseConv2DOptions *builtin_options_as_DepthwiseConv2DOptions() const { + return builtin_options_type() == BuiltinOptions_DepthwiseConv2DOptions ? static_cast(builtin_options()) : nullptr; + } + const ConcatEmbeddingsOptions *builtin_options_as_ConcatEmbeddingsOptions() const { + return builtin_options_type() == BuiltinOptions_ConcatEmbeddingsOptions ? static_cast(builtin_options()) : nullptr; + } + const LSHProjectionOptions *builtin_options_as_LSHProjectionOptions() const { + return builtin_options_type() == BuiltinOptions_LSHProjectionOptions ? static_cast(builtin_options()) : nullptr; + } + const Pool2DOptions *builtin_options_as_Pool2DOptions() const { + return builtin_options_type() == BuiltinOptions_Pool2DOptions ? static_cast(builtin_options()) : nullptr; + } + const SVDFOptions *builtin_options_as_SVDFOptions() const { + return builtin_options_type() == BuiltinOptions_SVDFOptions ? static_cast(builtin_options()) : nullptr; + } + const RNNOptions *builtin_options_as_RNNOptions() const { + return builtin_options_type() == BuiltinOptions_RNNOptions ? static_cast(builtin_options()) : nullptr; + } + const FullyConnectedOptions *builtin_options_as_FullyConnectedOptions() const { + return builtin_options_type() == BuiltinOptions_FullyConnectedOptions ? static_cast(builtin_options()) : nullptr; + } + const SoftmaxOptions *builtin_options_as_SoftmaxOptions() const { + return builtin_options_type() == BuiltinOptions_SoftmaxOptions ? static_cast(builtin_options()) : nullptr; + } + const ConcatenationOptions *builtin_options_as_ConcatenationOptions() const { + return builtin_options_type() == BuiltinOptions_ConcatenationOptions ? static_cast(builtin_options()) : nullptr; + } + const AddOptions *builtin_options_as_AddOptions() const { + return builtin_options_type() == BuiltinOptions_AddOptions ? static_cast(builtin_options()) : nullptr; + } + const L2NormOptions *builtin_options_as_L2NormOptions() const { + return builtin_options_type() == BuiltinOptions_L2NormOptions ? static_cast(builtin_options()) : nullptr; + } + const LocalResponseNormalizationOptions *builtin_options_as_LocalResponseNormalizationOptions() const { + return builtin_options_type() == BuiltinOptions_LocalResponseNormalizationOptions ? static_cast(builtin_options()) : nullptr; + } + const LSTMOptions *builtin_options_as_LSTMOptions() const { + return builtin_options_type() == BuiltinOptions_LSTMOptions ? static_cast(builtin_options()) : nullptr; + } + const ResizeBilinearOptions *builtin_options_as_ResizeBilinearOptions() const { + return builtin_options_type() == BuiltinOptions_ResizeBilinearOptions ? static_cast(builtin_options()) : nullptr; + } + const CallOptions *builtin_options_as_CallOptions() const { + return builtin_options_type() == BuiltinOptions_CallOptions ? static_cast(builtin_options()) : nullptr; + } + const ReshapeOptions *builtin_options_as_ReshapeOptions() const { + return builtin_options_type() == BuiltinOptions_ReshapeOptions ? static_cast(builtin_options()) : nullptr; + } + const SkipGramOptions *builtin_options_as_SkipGramOptions() const { + return builtin_options_type() == BuiltinOptions_SkipGramOptions ? static_cast(builtin_options()) : nullptr; + } + const SpaceToDepthOptions *builtin_options_as_SpaceToDepthOptions() const { + return builtin_options_type() == BuiltinOptions_SpaceToDepthOptions ? static_cast(builtin_options()) : nullptr; + } + const EmbeddingLookupSparseOptions *builtin_options_as_EmbeddingLookupSparseOptions() const { + return builtin_options_type() == BuiltinOptions_EmbeddingLookupSparseOptions ? static_cast(builtin_options()) : nullptr; + } + const MulOptions *builtin_options_as_MulOptions() const { + return builtin_options_type() == BuiltinOptions_MulOptions ? static_cast(builtin_options()) : nullptr; + } + const flatbuffers::Vector *custom_options() const { + return GetPointer *>(VT_CUSTOM_OPTIONS); + } + CustomOptionsFormat custom_options_format() const { + return static_cast(GetField(VT_CUSTOM_OPTIONS_FORMAT, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_OPCODE_INDEX) && + VerifyOffset(verifier, VT_INPUTS) && + verifier.Verify(inputs()) && + VerifyOffset(verifier, VT_OUTPUTS) && + verifier.Verify(outputs()) && + VerifyField(verifier, VT_BUILTIN_OPTIONS_TYPE) && + VerifyOffset(verifier, VT_BUILTIN_OPTIONS) && + VerifyBuiltinOptions(verifier, builtin_options(), builtin_options_type()) && + VerifyOffset(verifier, VT_CUSTOM_OPTIONS) && + verifier.Verify(custom_options()) && + VerifyField(verifier, VT_CUSTOM_OPTIONS_FORMAT) && + verifier.EndTable(); + } + OperatorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(OperatorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +template<> inline const Conv2DOptions *Operator::builtin_options_as() const { + return builtin_options_as_Conv2DOptions(); +} + +template<> inline const DepthwiseConv2DOptions *Operator::builtin_options_as() const { + return builtin_options_as_DepthwiseConv2DOptions(); +} + +template<> inline const ConcatEmbeddingsOptions *Operator::builtin_options_as() const { + return builtin_options_as_ConcatEmbeddingsOptions(); +} + +template<> inline const LSHProjectionOptions *Operator::builtin_options_as() const { + return builtin_options_as_LSHProjectionOptions(); +} + +template<> inline const Pool2DOptions *Operator::builtin_options_as() const { + return builtin_options_as_Pool2DOptions(); +} + +template<> inline const SVDFOptions *Operator::builtin_options_as() const { + return builtin_options_as_SVDFOptions(); +} + +template<> inline const RNNOptions *Operator::builtin_options_as() const { + return builtin_options_as_RNNOptions(); +} + +template<> inline const FullyConnectedOptions *Operator::builtin_options_as() const { + return builtin_options_as_FullyConnectedOptions(); +} + +template<> inline const SoftmaxOptions *Operator::builtin_options_as() const { + return builtin_options_as_SoftmaxOptions(); +} + +template<> inline const ConcatenationOptions *Operator::builtin_options_as() const { + return builtin_options_as_ConcatenationOptions(); +} + +template<> inline const AddOptions *Operator::builtin_options_as() const { + return builtin_options_as_AddOptions(); +} + +template<> inline const L2NormOptions *Operator::builtin_options_as() const { + return builtin_options_as_L2NormOptions(); +} + +template<> inline const LocalResponseNormalizationOptions *Operator::builtin_options_as() const { + return builtin_options_as_LocalResponseNormalizationOptions(); +} + +template<> inline const LSTMOptions *Operator::builtin_options_as() const { + return builtin_options_as_LSTMOptions(); +} + +template<> inline const ResizeBilinearOptions *Operator::builtin_options_as() const { + return builtin_options_as_ResizeBilinearOptions(); +} + +template<> inline const CallOptions *Operator::builtin_options_as() const { + return builtin_options_as_CallOptions(); +} + +template<> inline const ReshapeOptions *Operator::builtin_options_as() const { + return builtin_options_as_ReshapeOptions(); +} + +template<> inline const SkipGramOptions *Operator::builtin_options_as() const { + return builtin_options_as_SkipGramOptions(); +} + +template<> inline const SpaceToDepthOptions *Operator::builtin_options_as() const { + return builtin_options_as_SpaceToDepthOptions(); +} + +template<> inline const EmbeddingLookupSparseOptions *Operator::builtin_options_as() const { + return builtin_options_as_EmbeddingLookupSparseOptions(); +} + +template<> inline const MulOptions *Operator::builtin_options_as() const { + return builtin_options_as_MulOptions(); +} + +struct OperatorBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_opcode_index(uint32_t opcode_index) { + fbb_.AddElement(Operator::VT_OPCODE_INDEX, opcode_index, 0); + } + void add_inputs(flatbuffers::Offset> inputs) { + fbb_.AddOffset(Operator::VT_INPUTS, inputs); + } + void add_outputs(flatbuffers::Offset> outputs) { + fbb_.AddOffset(Operator::VT_OUTPUTS, outputs); + } + void add_builtin_options_type(BuiltinOptions builtin_options_type) { + fbb_.AddElement(Operator::VT_BUILTIN_OPTIONS_TYPE, static_cast(builtin_options_type), 0); + } + void add_builtin_options(flatbuffers::Offset builtin_options) { + fbb_.AddOffset(Operator::VT_BUILTIN_OPTIONS, builtin_options); + } + void add_custom_options(flatbuffers::Offset> custom_options) { + fbb_.AddOffset(Operator::VT_CUSTOM_OPTIONS, custom_options); + } + void add_custom_options_format(CustomOptionsFormat custom_options_format) { + fbb_.AddElement(Operator::VT_CUSTOM_OPTIONS_FORMAT, static_cast(custom_options_format), 0); + } + explicit OperatorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + OperatorBuilder &operator=(const OperatorBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateOperator( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t opcode_index = 0, + flatbuffers::Offset> inputs = 0, + flatbuffers::Offset> outputs = 0, + BuiltinOptions builtin_options_type = BuiltinOptions_NONE, + flatbuffers::Offset builtin_options = 0, + flatbuffers::Offset> custom_options = 0, + CustomOptionsFormat custom_options_format = CustomOptionsFormat_FLEXBUFFERS) { + OperatorBuilder builder_(_fbb); + builder_.add_custom_options(custom_options); + builder_.add_builtin_options(builtin_options); + builder_.add_outputs(outputs); + builder_.add_inputs(inputs); + builder_.add_opcode_index(opcode_index); + builder_.add_custom_options_format(custom_options_format); + builder_.add_builtin_options_type(builtin_options_type); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateOperatorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t opcode_index = 0, + const std::vector *inputs = nullptr, + const std::vector *outputs = nullptr, + BuiltinOptions builtin_options_type = BuiltinOptions_NONE, + flatbuffers::Offset builtin_options = 0, + const std::vector *custom_options = nullptr, + CustomOptionsFormat custom_options_format = CustomOptionsFormat_FLEXBUFFERS) { + return tflite::CreateOperator( + _fbb, + opcode_index, + inputs ? _fbb.CreateVector(*inputs) : 0, + outputs ? _fbb.CreateVector(*outputs) : 0, + builtin_options_type, + builtin_options, + custom_options ? _fbb.CreateVector(*custom_options) : 0, + custom_options_format); +} + +flatbuffers::Offset CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct SubGraphT : public flatbuffers::NativeTable { + typedef SubGraph TableType; + std::vector> tensors; + std::vector inputs; + std::vector outputs; + std::vector> operators; + std::string name; + SubGraphT() { + } +}; + +struct SubGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SubGraphT NativeTableType; + enum { + VT_TENSORS = 4, + VT_INPUTS = 6, + VT_OUTPUTS = 8, + VT_OPERATORS = 10, + VT_NAME = 12 + }; + const flatbuffers::Vector> *tensors() const { + return GetPointer> *>(VT_TENSORS); + } + const flatbuffers::Vector *inputs() const { + return GetPointer *>(VT_INPUTS); + } + const flatbuffers::Vector *outputs() const { + return GetPointer *>(VT_OUTPUTS); + } + const flatbuffers::Vector> *operators() const { + return GetPointer> *>(VT_OPERATORS); + } + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_TENSORS) && + verifier.Verify(tensors()) && + verifier.VerifyVectorOfTables(tensors()) && + VerifyOffset(verifier, VT_INPUTS) && + verifier.Verify(inputs()) && + VerifyOffset(verifier, VT_OUTPUTS) && + verifier.Verify(outputs()) && + VerifyOffset(verifier, VT_OPERATORS) && + verifier.Verify(operators()) && + verifier.VerifyVectorOfTables(operators()) && + VerifyOffset(verifier, VT_NAME) && + verifier.Verify(name()) && + verifier.EndTable(); + } + SubGraphT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SubGraphT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct SubGraphBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_tensors(flatbuffers::Offset>> tensors) { + fbb_.AddOffset(SubGraph::VT_TENSORS, tensors); + } + void add_inputs(flatbuffers::Offset> inputs) { + fbb_.AddOffset(SubGraph::VT_INPUTS, inputs); + } + void add_outputs(flatbuffers::Offset> outputs) { + fbb_.AddOffset(SubGraph::VT_OUTPUTS, outputs); + } + void add_operators(flatbuffers::Offset>> operators) { + fbb_.AddOffset(SubGraph::VT_OPERATORS, operators); + } + void add_name(flatbuffers::Offset name) { + fbb_.AddOffset(SubGraph::VT_NAME, name); + } + explicit SubGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SubGraphBuilder &operator=(const SubGraphBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSubGraph( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> tensors = 0, + flatbuffers::Offset> inputs = 0, + flatbuffers::Offset> outputs = 0, + flatbuffers::Offset>> operators = 0, + flatbuffers::Offset name = 0) { + SubGraphBuilder builder_(_fbb); + builder_.add_name(name); + builder_.add_operators(operators); + builder_.add_outputs(outputs); + builder_.add_inputs(inputs); + builder_.add_tensors(tensors); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateSubGraphDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *tensors = nullptr, + const std::vector *inputs = nullptr, + const std::vector *outputs = nullptr, + const std::vector> *operators = nullptr, + const char *name = nullptr) { + return tflite::CreateSubGraph( + _fbb, + tensors ? _fbb.CreateVector>(*tensors) : 0, + inputs ? _fbb.CreateVector(*inputs) : 0, + outputs ? _fbb.CreateVector(*outputs) : 0, + operators ? _fbb.CreateVector>(*operators) : 0, + name ? _fbb.CreateString(name) : 0); +} + +flatbuffers::Offset CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct BufferT : public flatbuffers::NativeTable { + typedef Buffer TableType; + std::vector data; + BufferT() { + } +}; + +struct Buffer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef BufferT NativeTableType; + enum { + VT_DATA = 4 + }; + const flatbuffers::Vector *data() const { + return GetPointer *>(VT_DATA); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_DATA) && + verifier.Verify(data()) && + verifier.EndTable(); + } + BufferT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(BufferT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct BufferBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_data(flatbuffers::Offset> data) { + fbb_.AddOffset(Buffer::VT_DATA, data); + } + explicit BufferBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + BufferBuilder &operator=(const BufferBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateBuffer( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> data = 0) { + BufferBuilder builder_(_fbb); + builder_.add_data(data); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateBufferDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *data = nullptr) { + return tflite::CreateBuffer( + _fbb, + data ? _fbb.CreateVector(*data) : 0); +} + +flatbuffers::Offset CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct ModelT : public flatbuffers::NativeTable { + typedef Model TableType; + uint32_t version; + std::vector> operator_codes; + std::vector> subgraphs; + std::string description; + std::vector> buffers; + ModelT() + : version(0) { + } +}; + +struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ModelT NativeTableType; + enum { + VT_VERSION = 4, + VT_OPERATOR_CODES = 6, + VT_SUBGRAPHS = 8, + VT_DESCRIPTION = 10, + VT_BUFFERS = 12 + }; + uint32_t version() const { + return GetField(VT_VERSION, 0); + } + const flatbuffers::Vector> *operator_codes() const { + return GetPointer> *>(VT_OPERATOR_CODES); + } + const flatbuffers::Vector> *subgraphs() const { + return GetPointer> *>(VT_SUBGRAPHS); + } + const flatbuffers::String *description() const { + return GetPointer(VT_DESCRIPTION); + } + const flatbuffers::Vector> *buffers() const { + return GetPointer> *>(VT_BUFFERS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_VERSION) && + VerifyOffset(verifier, VT_OPERATOR_CODES) && + verifier.Verify(operator_codes()) && + verifier.VerifyVectorOfTables(operator_codes()) && + VerifyOffset(verifier, VT_SUBGRAPHS) && + verifier.Verify(subgraphs()) && + verifier.VerifyVectorOfTables(subgraphs()) && + VerifyOffset(verifier, VT_DESCRIPTION) && + verifier.Verify(description()) && + VerifyOffset(verifier, VT_BUFFERS) && + verifier.Verify(buffers()) && + verifier.VerifyVectorOfTables(buffers()) && + verifier.EndTable(); + } + ModelT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ModelT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ModelBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_version(uint32_t version) { + fbb_.AddElement(Model::VT_VERSION, version, 0); + } + void add_operator_codes(flatbuffers::Offset>> operator_codes) { + fbb_.AddOffset(Model::VT_OPERATOR_CODES, operator_codes); + } + void add_subgraphs(flatbuffers::Offset>> subgraphs) { + fbb_.AddOffset(Model::VT_SUBGRAPHS, subgraphs); + } + void add_description(flatbuffers::Offset description) { + fbb_.AddOffset(Model::VT_DESCRIPTION, description); + } + void add_buffers(flatbuffers::Offset>> buffers) { + fbb_.AddOffset(Model::VT_BUFFERS, buffers); + } + explicit ModelBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ModelBuilder &operator=(const ModelBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateModel( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t version = 0, + flatbuffers::Offset>> operator_codes = 0, + flatbuffers::Offset>> subgraphs = 0, + flatbuffers::Offset description = 0, + flatbuffers::Offset>> buffers = 0) { + ModelBuilder builder_(_fbb); + builder_.add_buffers(buffers); + builder_.add_description(description); + builder_.add_subgraphs(subgraphs); + builder_.add_operator_codes(operator_codes); + builder_.add_version(version); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateModelDirect( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t version = 0, + const std::vector> *operator_codes = nullptr, + const std::vector> *subgraphs = nullptr, + const char *description = nullptr, + const std::vector> *buffers = nullptr) { + return tflite::CreateModel( + _fbb, + version, + operator_codes ? _fbb.CreateVector>(*operator_codes) : 0, + subgraphs ? _fbb.CreateVector>(*subgraphs) : 0, + description ? _fbb.CreateString(description) : 0, + buffers ? _fbb.CreateVector>(*buffers) : 0); +} + +flatbuffers::Offset CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +inline QuantizationParametersT *QuantizationParameters::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new QuantizationParametersT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void QuantizationParameters::UnPackTo(QuantizationParametersT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = min(); if (_e) { _o->min.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->min[_i] = _e->Get(_i); } } }; + { auto _e = max(); if (_e) { _o->max.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->max[_i] = _e->Get(_i); } } }; + { auto _e = scale(); if (_e) { _o->scale.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->scale[_i] = _e->Get(_i); } } }; + { auto _e = zero_point(); if (_e) { _o->zero_point.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->zero_point[_i] = _e->Get(_i); } } }; +} + +inline flatbuffers::Offset QuantizationParameters::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateQuantizationParameters(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizationParametersT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _min = _o->min.size() ? _fbb.CreateVector(_o->min) : 0; + auto _max = _o->max.size() ? _fbb.CreateVector(_o->max) : 0; + auto _scale = _o->scale.size() ? _fbb.CreateVector(_o->scale) : 0; + auto _zero_point = _o->zero_point.size() ? _fbb.CreateVector(_o->zero_point) : 0; + return tflite::CreateQuantizationParameters( + _fbb, + _min, + _max, + _scale, + _zero_point); +} + +inline TensorT *Tensor::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new TensorT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void Tensor::UnPackTo(TensorT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = shape(); if (_e) { _o->shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->shape[_i] = _e->Get(_i); } } }; + { auto _e = type(); _o->type = _e; }; + { auto _e = buffer(); _o->buffer = _e; }; + { auto _e = name(); if (_e) _o->name = _e->str(); }; + { auto _e = quantization(); if (_e) _o->quantization = std::unique_ptr(_e->UnPack(_resolver)); }; +} + +inline flatbuffers::Offset Tensor::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateTensor(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TensorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _shape = _o->shape.size() ? _fbb.CreateVector(_o->shape) : 0; + auto _type = _o->type; + auto _buffer = _o->buffer; + auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name); + auto _quantization = _o->quantization ? CreateQuantizationParameters(_fbb, _o->quantization.get(), _rehasher) : 0; + return tflite::CreateTensor( + _fbb, + _shape, + _type, + _buffer, + _name, + _quantization); +} + +inline Conv2DOptionsT *Conv2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new Conv2DOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void Conv2DOptions::UnPackTo(Conv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = padding(); _o->padding = _e; }; + { auto _e = stride_w(); _o->stride_w = _e; }; + { auto _e = stride_h(); _o->stride_h = _e; }; + { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; +} + +inline flatbuffers::Offset Conv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateConv2DOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Conv2DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _padding = _o->padding; + auto _stride_w = _o->stride_w; + auto _stride_h = _o->stride_h; + auto _fused_activation_function = _o->fused_activation_function; + return tflite::CreateConv2DOptions( + _fbb, + _padding, + _stride_w, + _stride_h, + _fused_activation_function); +} + +inline Pool2DOptionsT *Pool2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new Pool2DOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void Pool2DOptions::UnPackTo(Pool2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = padding(); _o->padding = _e; }; + { auto _e = stride_w(); _o->stride_w = _e; }; + { auto _e = stride_h(); _o->stride_h = _e; }; + { auto _e = filter_width(); _o->filter_width = _e; }; + { auto _e = filter_height(); _o->filter_height = _e; }; + { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; +} + +inline flatbuffers::Offset Pool2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreatePool2DOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Pool2DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _padding = _o->padding; + auto _stride_w = _o->stride_w; + auto _stride_h = _o->stride_h; + auto _filter_width = _o->filter_width; + auto _filter_height = _o->filter_height; + auto _fused_activation_function = _o->fused_activation_function; + return tflite::CreatePool2DOptions( + _fbb, + _padding, + _stride_w, + _stride_h, + _filter_width, + _filter_height, + _fused_activation_function); +} + +inline DepthwiseConv2DOptionsT *DepthwiseConv2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new DepthwiseConv2DOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void DepthwiseConv2DOptions::UnPackTo(DepthwiseConv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = padding(); _o->padding = _e; }; + { auto _e = stride_w(); _o->stride_w = _e; }; + { auto _e = stride_h(); _o->stride_h = _e; }; + { auto _e = depth_multiplier(); _o->depth_multiplier = _e; }; + { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; +} + +inline flatbuffers::Offset DepthwiseConv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateDepthwiseConv2DOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DepthwiseConv2DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _padding = _o->padding; + auto _stride_w = _o->stride_w; + auto _stride_h = _o->stride_h; + auto _depth_multiplier = _o->depth_multiplier; + auto _fused_activation_function = _o->fused_activation_function; + return tflite::CreateDepthwiseConv2DOptions( + _fbb, + _padding, + _stride_w, + _stride_h, + _depth_multiplier, + _fused_activation_function); +} + +inline ConcatEmbeddingsOptionsT *ConcatEmbeddingsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new ConcatEmbeddingsOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void ConcatEmbeddingsOptions::UnPackTo(ConcatEmbeddingsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = num_channels(); _o->num_channels = _e; }; + { auto _e = num_columns_per_channel(); if (_e) { _o->num_columns_per_channel.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->num_columns_per_channel[_i] = _e->Get(_i); } } }; + { auto _e = embedding_dim_per_channel(); if (_e) { _o->embedding_dim_per_channel.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->embedding_dim_per_channel[_i] = _e->Get(_i); } } }; +} + +inline flatbuffers::Offset ConcatEmbeddingsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateConcatEmbeddingsOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ConcatEmbeddingsOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _num_channels = _o->num_channels; + auto _num_columns_per_channel = _o->num_columns_per_channel.size() ? _fbb.CreateVector(_o->num_columns_per_channel) : 0; + auto _embedding_dim_per_channel = _o->embedding_dim_per_channel.size() ? _fbb.CreateVector(_o->embedding_dim_per_channel) : 0; + return tflite::CreateConcatEmbeddingsOptions( + _fbb, + _num_channels, + _num_columns_per_channel, + _embedding_dim_per_channel); +} + +inline LSHProjectionOptionsT *LSHProjectionOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new LSHProjectionOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void LSHProjectionOptions::UnPackTo(LSHProjectionOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = type(); _o->type = _e; }; +} + +inline flatbuffers::Offset LSHProjectionOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateLSHProjectionOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LSHProjectionOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _type = _o->type; + return tflite::CreateLSHProjectionOptions( + _fbb, + _type); +} + +inline SVDFOptionsT *SVDFOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new SVDFOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void SVDFOptions::UnPackTo(SVDFOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = rank(); _o->rank = _e; }; + { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; +} + +inline flatbuffers::Offset SVDFOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateSVDFOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SVDFOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _rank = _o->rank; + auto _fused_activation_function = _o->fused_activation_function; + return tflite::CreateSVDFOptions( + _fbb, + _rank, + _fused_activation_function); +} + +inline RNNOptionsT *RNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new RNNOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void RNNOptions::UnPackTo(RNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; +} + +inline flatbuffers::Offset RNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateRNNOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RNNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _fused_activation_function = _o->fused_activation_function; + return tflite::CreateRNNOptions( + _fbb, + _fused_activation_function); +} + +inline FullyConnectedOptionsT *FullyConnectedOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new FullyConnectedOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void FullyConnectedOptions::UnPackTo(FullyConnectedOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; +} + +inline flatbuffers::Offset FullyConnectedOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateFullyConnectedOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FullyConnectedOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _fused_activation_function = _o->fused_activation_function; + return tflite::CreateFullyConnectedOptions( + _fbb, + _fused_activation_function); +} + +inline SoftmaxOptionsT *SoftmaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new SoftmaxOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void SoftmaxOptions::UnPackTo(SoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = beta(); _o->beta = _e; }; +} + +inline flatbuffers::Offset SoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateSoftmaxOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SoftmaxOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _beta = _o->beta; + return tflite::CreateSoftmaxOptions( + _fbb, + _beta); +} + +inline ConcatenationOptionsT *ConcatenationOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new ConcatenationOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void ConcatenationOptions::UnPackTo(ConcatenationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = axis(); _o->axis = _e; }; + { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; +} + +inline flatbuffers::Offset ConcatenationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateConcatenationOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ConcatenationOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _axis = _o->axis; + auto _fused_activation_function = _o->fused_activation_function; + return tflite::CreateConcatenationOptions( + _fbb, + _axis, + _fused_activation_function); +} + +inline AddOptionsT *AddOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new AddOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void AddOptions::UnPackTo(AddOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; +} + +inline flatbuffers::Offset AddOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateAddOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AddOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _fused_activation_function = _o->fused_activation_function; + return tflite::CreateAddOptions( + _fbb, + _fused_activation_function); +} + +inline MulOptionsT *MulOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new MulOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void MulOptions::UnPackTo(MulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; +} + +inline flatbuffers::Offset MulOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateMulOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MulOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _fused_activation_function = _o->fused_activation_function; + return tflite::CreateMulOptions( + _fbb, + _fused_activation_function); +} + +inline L2NormOptionsT *L2NormOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new L2NormOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void L2NormOptions::UnPackTo(L2NormOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; +} + +inline flatbuffers::Offset L2NormOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateL2NormOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const L2NormOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _fused_activation_function = _o->fused_activation_function; + return tflite::CreateL2NormOptions( + _fbb, + _fused_activation_function); +} + +inline LocalResponseNormalizationOptionsT *LocalResponseNormalizationOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new LocalResponseNormalizationOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void LocalResponseNormalizationOptions::UnPackTo(LocalResponseNormalizationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = radius(); _o->radius = _e; }; + { auto _e = bias(); _o->bias = _e; }; + { auto _e = alpha(); _o->alpha = _e; }; + { auto _e = beta(); _o->beta = _e; }; +} + +inline flatbuffers::Offset LocalResponseNormalizationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateLocalResponseNormalizationOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LocalResponseNormalizationOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _radius = _o->radius; + auto _bias = _o->bias; + auto _alpha = _o->alpha; + auto _beta = _o->beta; + return tflite::CreateLocalResponseNormalizationOptions( + _fbb, + _radius, + _bias, + _alpha, + _beta); +} + +inline LSTMOptionsT *LSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new LSTMOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void LSTMOptions::UnPackTo(LSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; + { auto _e = cell_clip(); _o->cell_clip = _e; }; + { auto _e = proj_clip(); _o->proj_clip = _e; }; +} + +inline flatbuffers::Offset LSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateLSTMOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LSTMOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _fused_activation_function = _o->fused_activation_function; + auto _cell_clip = _o->cell_clip; + auto _proj_clip = _o->proj_clip; + return tflite::CreateLSTMOptions( + _fbb, + _fused_activation_function, + _cell_clip, + _proj_clip); +} + +inline ResizeBilinearOptionsT *ResizeBilinearOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new ResizeBilinearOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void ResizeBilinearOptions::UnPackTo(ResizeBilinearOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = new_height(); _o->new_height = _e; }; + { auto _e = new_width(); _o->new_width = _e; }; +} + +inline flatbuffers::Offset ResizeBilinearOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateResizeBilinearOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ResizeBilinearOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _new_height = _o->new_height; + auto _new_width = _o->new_width; + return tflite::CreateResizeBilinearOptions( + _fbb, + _new_height, + _new_width); +} + +inline CallOptionsT *CallOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new CallOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void CallOptions::UnPackTo(CallOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = subgraph(); _o->subgraph = _e; }; +} + +inline flatbuffers::Offset CallOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateCallOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CallOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _subgraph = _o->subgraph; + return tflite::CreateCallOptions( + _fbb, + _subgraph); +} + +inline ReshapeOptionsT *ReshapeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new ReshapeOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void ReshapeOptions::UnPackTo(ReshapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = new_shape(); if (_e) { _o->new_shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->new_shape[_i] = _e->Get(_i); } } }; +} + +inline flatbuffers::Offset ReshapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateReshapeOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReshapeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _new_shape = _o->new_shape.size() ? _fbb.CreateVector(_o->new_shape) : 0; + return tflite::CreateReshapeOptions( + _fbb, + _new_shape); +} + +inline SkipGramOptionsT *SkipGramOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new SkipGramOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void SkipGramOptions::UnPackTo(SkipGramOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = ngram_size(); _o->ngram_size = _e; }; + { auto _e = max_skip_size(); _o->max_skip_size = _e; }; + { auto _e = include_all_ngrams(); _o->include_all_ngrams = _e; }; +} + +inline flatbuffers::Offset SkipGramOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateSkipGramOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SkipGramOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _ngram_size = _o->ngram_size; + auto _max_skip_size = _o->max_skip_size; + auto _include_all_ngrams = _o->include_all_ngrams; + return tflite::CreateSkipGramOptions( + _fbb, + _ngram_size, + _max_skip_size, + _include_all_ngrams); +} + +inline SpaceToDepthOptionsT *SpaceToDepthOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new SpaceToDepthOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void SpaceToDepthOptions::UnPackTo(SpaceToDepthOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = block_size(); _o->block_size = _e; }; +} + +inline flatbuffers::Offset SpaceToDepthOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateSpaceToDepthOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SpaceToDepthOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _block_size = _o->block_size; + return tflite::CreateSpaceToDepthOptions( + _fbb, + _block_size); +} + +inline EmbeddingLookupSparseOptionsT *EmbeddingLookupSparseOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new EmbeddingLookupSparseOptionsT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void EmbeddingLookupSparseOptions::UnPackTo(EmbeddingLookupSparseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = combiner(); _o->combiner = _e; }; +} + +inline flatbuffers::Offset EmbeddingLookupSparseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateEmbeddingLookupSparseOptions(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EmbeddingLookupSparseOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _combiner = _o->combiner; + return tflite::CreateEmbeddingLookupSparseOptions( + _fbb, + _combiner); +} + +inline OperatorCodeT *OperatorCode::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new OperatorCodeT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void OperatorCode::UnPackTo(OperatorCodeT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = builtin_code(); _o->builtin_code = _e; }; + { auto _e = custom_code(); if (_e) _o->custom_code = _e->str(); }; +} + +inline flatbuffers::Offset OperatorCode::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateOperatorCode(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OperatorCodeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _builtin_code = _o->builtin_code; + auto _custom_code = _o->custom_code.empty() ? 0 : _fbb.CreateString(_o->custom_code); + return tflite::CreateOperatorCode( + _fbb, + _builtin_code, + _custom_code); +} + +inline OperatorT *Operator::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new OperatorT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void Operator::UnPackTo(OperatorT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = opcode_index(); _o->opcode_index = _e; }; + { auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inputs[_i] = _e->Get(_i); } } }; + { auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->outputs[_i] = _e->Get(_i); } } }; + { auto _e = builtin_options_type(); _o->builtin_options.type = _e; }; + { auto _e = builtin_options(); if (_e) _o->builtin_options.value = BuiltinOptionsUnion::UnPack(_e, builtin_options_type(), _resolver); }; + { auto _e = custom_options(); if (_e) { _o->custom_options.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->custom_options[_i] = _e->Get(_i); } } }; + { auto _e = custom_options_format(); _o->custom_options_format = _e; }; +} + +inline flatbuffers::Offset Operator::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateOperator(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OperatorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _opcode_index = _o->opcode_index; + auto _inputs = _o->inputs.size() ? _fbb.CreateVector(_o->inputs) : 0; + auto _outputs = _o->outputs.size() ? _fbb.CreateVector(_o->outputs) : 0; + auto _builtin_options_type = _o->builtin_options.type; + auto _builtin_options = _o->builtin_options.Pack(_fbb); + auto _custom_options = _o->custom_options.size() ? _fbb.CreateVector(_o->custom_options) : 0; + auto _custom_options_format = _o->custom_options_format; + return tflite::CreateOperator( + _fbb, + _opcode_index, + _inputs, + _outputs, + _builtin_options_type, + _builtin_options, + _custom_options, + _custom_options_format); +} + +inline SubGraphT *SubGraph::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new SubGraphT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void SubGraph::UnPackTo(SubGraphT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = tensors(); if (_e) { _o->tensors.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->tensors[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); } } }; + { auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inputs[_i] = _e->Get(_i); } } }; + { auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->outputs[_i] = _e->Get(_i); } } }; + { auto _e = operators(); if (_e) { _o->operators.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->operators[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); } } }; + { auto _e = name(); if (_e) _o->name = _e->str(); }; +} + +inline flatbuffers::Offset SubGraph::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateSubGraph(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SubGraphT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _tensors = _o->tensors.size() ? _fbb.CreateVector> (_o->tensors.size(), [](size_t i, _VectorArgs *__va) { return CreateTensor(*__va->__fbb, __va->__o->tensors[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _inputs = _o->inputs.size() ? _fbb.CreateVector(_o->inputs) : 0; + auto _outputs = _o->outputs.size() ? _fbb.CreateVector(_o->outputs) : 0; + auto _operators = _o->operators.size() ? _fbb.CreateVector> (_o->operators.size(), [](size_t i, _VectorArgs *__va) { return CreateOperator(*__va->__fbb, __va->__o->operators[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name); + return tflite::CreateSubGraph( + _fbb, + _tensors, + _inputs, + _outputs, + _operators, + _name); +} + +inline BufferT *Buffer::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new BufferT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void Buffer::UnPackTo(BufferT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = data(); if (_e) { _o->data.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->data[_i] = _e->Get(_i); } } }; +} + +inline flatbuffers::Offset Buffer::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateBuffer(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BufferT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0; + return tflite::CreateBuffer( + _fbb, + _data); +} + +inline ModelT *Model::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new ModelT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void Model::UnPackTo(ModelT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = version(); _o->version = _e; }; + { auto _e = operator_codes(); if (_e) { _o->operator_codes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->operator_codes[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); } } }; + { auto _e = subgraphs(); if (_e) { _o->subgraphs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->subgraphs[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); } } }; + { auto _e = description(); if (_e) _o->description = _e->str(); }; + { auto _e = buffers(); if (_e) { _o->buffers.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->buffers[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); } } }; +} + +inline flatbuffers::Offset Model::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateModel(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ModelT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _version = _o->version; + auto _operator_codes = _o->operator_codes.size() ? _fbb.CreateVector> (_o->operator_codes.size(), [](size_t i, _VectorArgs *__va) { return CreateOperatorCode(*__va->__fbb, __va->__o->operator_codes[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _subgraphs = _o->subgraphs.size() ? _fbb.CreateVector> (_o->subgraphs.size(), [](size_t i, _VectorArgs *__va) { return CreateSubGraph(*__va->__fbb, __va->__o->subgraphs[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _description = _o->description.empty() ? 0 : _fbb.CreateString(_o->description); + auto _buffers = _o->buffers.size() ? _fbb.CreateVector> (_o->buffers.size(), [](size_t i, _VectorArgs *__va) { return CreateBuffer(*__va->__fbb, __va->__o->buffers[i].get(), __va->__rehasher); }, &_va ) : 0; + return tflite::CreateModel( + _fbb, + _version, + _operator_codes, + _subgraphs, + _description, + _buffers); +} + +inline bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type) { + switch (type) { + case BuiltinOptions_NONE: { + return true; + } + case BuiltinOptions_Conv2DOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_DepthwiseConv2DOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_ConcatEmbeddingsOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_LSHProjectionOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_Pool2DOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_SVDFOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_RNNOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_FullyConnectedOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_SoftmaxOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_ConcatenationOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_AddOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_L2NormOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_LocalResponseNormalizationOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_LSTMOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_ResizeBilinearOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_CallOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_ReshapeOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_SkipGramOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_SpaceToDepthOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_EmbeddingLookupSparseOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case BuiltinOptions_MulOptions: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return false; + } +} + +inline bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyBuiltinOptions( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline void *BuiltinOptionsUnion::UnPack(const void *obj, BuiltinOptions type, const flatbuffers::resolver_function_t *resolver) { + switch (type) { + case BuiltinOptions_Conv2DOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_DepthwiseConv2DOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_ConcatEmbeddingsOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_LSHProjectionOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_Pool2DOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_SVDFOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_RNNOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_FullyConnectedOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_SoftmaxOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_ConcatenationOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_AddOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_L2NormOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_LocalResponseNormalizationOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_LSTMOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_ResizeBilinearOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_CallOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_ReshapeOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_SkipGramOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_SpaceToDepthOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_EmbeddingLookupSparseOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case BuiltinOptions_MulOptions: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + default: return nullptr; + } +} + +inline flatbuffers::Offset BuiltinOptionsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { + switch (type) { + case BuiltinOptions_Conv2DOptions: { + auto ptr = reinterpret_cast(value); + return CreateConv2DOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_DepthwiseConv2DOptions: { + auto ptr = reinterpret_cast(value); + return CreateDepthwiseConv2DOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_ConcatEmbeddingsOptions: { + auto ptr = reinterpret_cast(value); + return CreateConcatEmbeddingsOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_LSHProjectionOptions: { + auto ptr = reinterpret_cast(value); + return CreateLSHProjectionOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_Pool2DOptions: { + auto ptr = reinterpret_cast(value); + return CreatePool2DOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_SVDFOptions: { + auto ptr = reinterpret_cast(value); + return CreateSVDFOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_RNNOptions: { + auto ptr = reinterpret_cast(value); + return CreateRNNOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_FullyConnectedOptions: { + auto ptr = reinterpret_cast(value); + return CreateFullyConnectedOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_SoftmaxOptions: { + auto ptr = reinterpret_cast(value); + return CreateSoftmaxOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_ConcatenationOptions: { + auto ptr = reinterpret_cast(value); + return CreateConcatenationOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_AddOptions: { + auto ptr = reinterpret_cast(value); + return CreateAddOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_L2NormOptions: { + auto ptr = reinterpret_cast(value); + return CreateL2NormOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_LocalResponseNormalizationOptions: { + auto ptr = reinterpret_cast(value); + return CreateLocalResponseNormalizationOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_LSTMOptions: { + auto ptr = reinterpret_cast(value); + return CreateLSTMOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_ResizeBilinearOptions: { + auto ptr = reinterpret_cast(value); + return CreateResizeBilinearOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_CallOptions: { + auto ptr = reinterpret_cast(value); + return CreateCallOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_ReshapeOptions: { + auto ptr = reinterpret_cast(value); + return CreateReshapeOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_SkipGramOptions: { + auto ptr = reinterpret_cast(value); + return CreateSkipGramOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_SpaceToDepthOptions: { + auto ptr = reinterpret_cast(value); + return CreateSpaceToDepthOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_EmbeddingLookupSparseOptions: { + auto ptr = reinterpret_cast(value); + return CreateEmbeddingLookupSparseOptions(_fbb, ptr, _rehasher).Union(); + } + case BuiltinOptions_MulOptions: { + auto ptr = reinterpret_cast(value); + return CreateMulOptions(_fbb, ptr, _rehasher).Union(); + } + default: return 0; + } +} + +inline BuiltinOptionsUnion::BuiltinOptionsUnion(const BuiltinOptionsUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) { + switch (type) { + case BuiltinOptions_Conv2DOptions: { + value = new Conv2DOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_DepthwiseConv2DOptions: { + value = new DepthwiseConv2DOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_ConcatEmbeddingsOptions: { + value = new ConcatEmbeddingsOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_LSHProjectionOptions: { + value = new LSHProjectionOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_Pool2DOptions: { + value = new Pool2DOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_SVDFOptions: { + value = new SVDFOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_RNNOptions: { + value = new RNNOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_FullyConnectedOptions: { + value = new FullyConnectedOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_SoftmaxOptions: { + value = new SoftmaxOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_ConcatenationOptions: { + value = new ConcatenationOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_AddOptions: { + value = new AddOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_L2NormOptions: { + value = new L2NormOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_LocalResponseNormalizationOptions: { + value = new LocalResponseNormalizationOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_LSTMOptions: { + value = new LSTMOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_ResizeBilinearOptions: { + value = new ResizeBilinearOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_CallOptions: { + value = new CallOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_ReshapeOptions: { + value = new ReshapeOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_SkipGramOptions: { + value = new SkipGramOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_SpaceToDepthOptions: { + value = new SpaceToDepthOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_EmbeddingLookupSparseOptions: { + value = new EmbeddingLookupSparseOptionsT(*reinterpret_cast(u.value)); + break; + } + case BuiltinOptions_MulOptions: { + value = new MulOptionsT(*reinterpret_cast(u.value)); + break; + } + default: + break; + } +} + +inline void BuiltinOptionsUnion::Reset() { + switch (type) { + case BuiltinOptions_Conv2DOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_DepthwiseConv2DOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_ConcatEmbeddingsOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_LSHProjectionOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_Pool2DOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_SVDFOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_RNNOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_FullyConnectedOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_SoftmaxOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_ConcatenationOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_AddOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_L2NormOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_LocalResponseNormalizationOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_LSTMOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_ResizeBilinearOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_CallOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_ReshapeOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_SkipGramOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_SpaceToDepthOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_EmbeddingLookupSparseOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case BuiltinOptions_MulOptions: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + default: break; + } + value = nullptr; + type = BuiltinOptions_NONE; +} + +inline const tflite::Model *GetModel(const void *buf) { + return flatbuffers::GetRoot(buf); +} + +inline const char *ModelIdentifier() { + return "TFL3"; +} + +inline bool ModelBufferHasIdentifier(const void *buf) { + return flatbuffers::BufferHasIdentifier( + buf, ModelIdentifier()); +} + +inline bool VerifyModelBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifyBuffer(ModelIdentifier()); +} + +inline const char *ModelExtension() { + return "tflite"; +} + +inline void FinishModelBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.Finish(root, ModelIdentifier()); +} + +inline std::unique_ptr UnPackModel( + const void *buf, + const flatbuffers::resolver_function_t *res = nullptr) { + return std::unique_ptr(GetModel(buf)->UnPack(res)); +} + +} // namespace tflite + +#endif // FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_ diff --git a/tensorflow/contrib/lite/tools/benchmark_model.cc b/tensorflow/contrib/lite/tools/benchmark_model.cc new file mode 100644 index 00000000000000..5f0c2f46876a11 --- /dev/null +++ b/tensorflow/contrib/lite/tools/benchmark_model.cc @@ -0,0 +1,99 @@ + +#include +#include +#include +#include +#include +#include +#include + +#include "tensorflow/contrib/lite/kernels/register.h" +#include "tensorflow/contrib/lite/model.h" +#include "tensorflow/contrib/lite/string_util.h" +#include "tensorflow/contrib/lite/tools/mutable_op_resolver.h" + +#ifdef TFLITE_CUSTOM_OPS_HEADER +void RegisterSelectedOps(::tflite::MutableOpResolver* resolver); +#endif + +#define LOG(x) std::cerr +#define CHECK(x) if (!(x)) { LOG(ERROR) << #x << "failed"; exit(1); } + +namespace tensorflow { +namespace benchmark_tflite_model { + +std::unique_ptr model; +std::unique_ptr interpreter; + +void InitImpl(const std::string& graph, const std::vector& sizes, + const std::string& input_layer_type, int num_threads) { + CHECK(graph.c_str()); + + model = tflite::FlatBufferModel::BuildFromFile(graph.c_str()); + if (!model) { + LOG(FATAL) << "Failed to mmap model " << graph; + } + LOG(INFO) << "Loaded model " << graph; + model->error_reporter(); + LOG(INFO) << "resolved reporter"; + +#ifdef TFLITE_CUSTOM_OPS_HEADER + tflite::MutableOpResolver resolver; + RegisterSelectedOps(&resolver); +#else + tflite::ops::builtin::BuiltinOpResolver resolver; +#endif + + tflite::InterpreterBuilder(*model, resolver)(&interpreter); + if (!interpreter) { + LOG(FATAL) << "Failed to construct interpreter"; + } + + if (num_threads != -1) { + interpreter->SetNumThreads(num_threads); + } + + int input = interpreter->inputs()[0]; + + if (input_layer_type != "string") { + interpreter->ResizeInputTensor(input, sizes); + } + + if (interpreter->AllocateTensors() != kTfLiteOk) { + LOG(FATAL) << "Failed to allocate tensors!"; + } + + if (input_layer_type == "float") { + // 0-th dimension is batch. + // FillRandomValue( + // interpreter->typed_tensor(input), + // std::vector(sizes.begin() + 1, sizes.end()), + // []() { return static_cast(rand()) / RAND_MAX - 0.5f; }); + } else if (input_layer_type == "uint8") { + // 0-th dimension is batch. + // FillRandomValue( + // interpreter->typed_tensor(input), + // std::vector(sizes.begin() + 1, sizes.end()), + // []() { return static_cast(rand()) % 255; }); + } else if (input_layer_type == "string") { + tflite::DynamicBuffer buffer; + // FillRandomString(&buffer, sizes, []() { + // return "we're have some friends over saturday to hang out in the yard"; + // }); + buffer.WriteToTensor(interpreter->tensor(input)); + } else { + LOG(FATAL) << "Unknown input type: " << input_layer_type; + } +} + +int Main(int argc, char** argv) { + InitImpl("", {}, "", 1); + return 0; +} + +} // namespace benchmark_tflite_model +} // namespace tensorflow + +int main(int argc, char** argv) { + return tensorflow::benchmark_tflite_model::Main(argc, argv); +} diff --git a/tensorflow/contrib/lite/tools/mutable_op_resolver.h b/tensorflow/contrib/lite/tools/mutable_op_resolver.h index 9546c32427b3e6..a51fdaee19d5e4 100644 --- a/tensorflow/contrib/lite/tools/mutable_op_resolver.h +++ b/tensorflow/contrib/lite/tools/mutable_op_resolver.h @@ -19,6 +19,17 @@ limitations under the License. #include "tensorflow/contrib/lite/context.h" #include "tensorflow/contrib/lite/model.h" +// Needed to resolve unordered_set hash on older compilers. +namespace std +{ +template<> + struct hash { + size_t operator()(const tflite::BuiltinOperator &op) const { + return std::hash()(op); + } + }; +} + namespace tflite { // An OpResolver that is mutable, also used as the op in gen_op_registration. From 599d7fcb5490d8254883ee7995344839ec925f62 Mon Sep 17 00:00:00 2001 From: Pete Warden Date: Sat, 11 Nov 2017 17:02:47 -0800 Subject: [PATCH 2/4] Added support to TF Lite makefile build --- tensorflow/contrib/lite/Makefile | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tensorflow/contrib/lite/Makefile b/tensorflow/contrib/lite/Makefile index 73a6294f64a475..8c65a0cc344aad 100644 --- a/tensorflow/contrib/lite/Makefile +++ b/tensorflow/contrib/lite/Makefile @@ -60,6 +60,8 @@ ifeq ($(OS),LINUX) LIBS += -ldl -lpthread endif +include $(MAKEFILE_DIR)/ios_makefile.inc + # This library is the main target for this makefile. It will contain a minimal # runtime that can be linked in to other programs. LIB_NAME := libtensorflow-lite.a From 5bcd715357be87235033639a1e8766ccb44bcd00 Mon Sep 17 00:00:00 2001 From: Pete Warden Date: Sat, 11 Nov 2017 17:05:01 -0800 Subject: [PATCH 3/4] Added iOS support to TF Lite makefile build --- tensorflow/contrib/lite/ios_makefile.inc | 45 ++++++++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 tensorflow/contrib/lite/ios_makefile.inc diff --git a/tensorflow/contrib/lite/ios_makefile.inc b/tensorflow/contrib/lite/ios_makefile.inc new file mode 100644 index 00000000000000..f3c0a228413b07 --- /dev/null +++ b/tensorflow/contrib/lite/ios_makefile.inc @@ -0,0 +1,45 @@ +# Settings for iOS. +ifeq ($(TARGET), IOS) + BUILD_FOR_IOS_SIMULATOR := false + ifeq ($(IOS_ARCH), x86_64) + BUILD_FOR_IOS_SIMULATOR := true + endif + ifeq ($(IOS_ARCH), i386) + BUILD_FOR_IOS_SIMULATOR := true + endif + ifeq ($(BUILD_FOR_IOS_SIMULATOR), true) + IPHONEOS_PLATFORM := $(shell xcrun --sdk iphonesimulator \ + --show-sdk-platform-path) + IPHONEOS_SYSROOT := $(shell xcrun --sdk iphonesimulator \ + --show-sdk-path) + else + IPHONEOS_PLATFORM := $(shell xcrun --sdk iphoneos --show-sdk-platform-path) + IPHONEOS_SYSROOT := $(shell xcrun --sdk iphoneos --show-sdk-path) + endif + IOS_SDK_VERSION := $(shell xcrun --sdk iphoneos --show-sdk-version) + MIN_SDK_VERSION := 9.0 + # Override IOS_ARCH with armv7, armv7s, arm64, i386, or x86_64. + IOS_ARCH := x86_64 + CXXFLAGS += -miphoneos-version-min=$(MIN_SDK_VERSION) \ + -DGEMMLOWP_ALLOW_SLOW_SCALAR_FALLBACK \ + -fembed-bitcode \ + -Wno-c++11-narrowing \ + -mno-thumb \ + -fno-exceptions \ + -isysroot \ + ${IPHONEOS_SYSROOT} \ + -arch $(IOS_ARCH) + CCFLAGS += -miphoneos-version-min=$(MIN_SDK_VERSION) \ + -fembed-bitcode \ + -mno-thumb \ + -isysroot \ + ${IPHONEOS_SYSROOT} \ + -arch $(IOS_ARCH) + LDFLAGS := -fembed-bitcode \ + -miphoneos-version-min=${MIN_SDK_VERSION} \ + -arch $(IOS_ARCH) + OBJDIR := $(OBJDIR)ios_$(IOS_ARCH)/ + LIBDIR := $(LIBDIR)ios_$(IOS_ARCH)/ + BINDIR := $(BINDIR)ios_$(IOS_ARCH)/ + DEPDIR := $(DEPDIR)ios_$(IOS_ARCH)/ +endif From 6fbc9a863fd3c51125faeb0ca764009107a05a6f Mon Sep 17 00:00:00 2001 From: Pete Warden Date: Sun, 12 Nov 2017 15:17:49 -0800 Subject: [PATCH 4/4] Added simple iOS example application for TF Lite --- .gitignore | 3 + .../contrib/lite/build_ios_universal_lib.sh | 16 + .../contrib/lite/download_dependencies.sh | 6 +- .../lite/examples/ios/simple/AppDelegate.h | 21 + .../lite/examples/ios/simple/AppDelegate.mm | 44 +++ .../contrib/lite/examples/ios/simple/Podfile | 5 + .../examples/ios/simple/RunModel-Info.plist | 47 +++ .../ios/simple/RunModelViewController.h | 24 ++ .../ios/simple/RunModelViewController.mm | 219 +++++++++++ .../ios/simple/RunModelViewController.xib | 46 +++ .../examples/ios/simple/data/grace_hopper.jpg | Bin 0 -> 73746 bytes .../lite/examples/ios/simple/ios_image_load.h | 25 ++ .../examples/ios/simple/ios_image_load.mm | 85 +++++ .../contrib/lite/examples/ios/simple/main.mm | 22 ++ .../simple/simple.xcodeproj/project.pbxproj | 359 ++++++++++++++++++ 15 files changed, 921 insertions(+), 1 deletion(-) create mode 100755 tensorflow/contrib/lite/build_ios_universal_lib.sh create mode 100644 tensorflow/contrib/lite/examples/ios/simple/AppDelegate.h create mode 100644 tensorflow/contrib/lite/examples/ios/simple/AppDelegate.mm create mode 100644 tensorflow/contrib/lite/examples/ios/simple/Podfile create mode 100644 tensorflow/contrib/lite/examples/ios/simple/RunModel-Info.plist create mode 100644 tensorflow/contrib/lite/examples/ios/simple/RunModelViewController.h create mode 100644 tensorflow/contrib/lite/examples/ios/simple/RunModelViewController.mm create mode 100644 tensorflow/contrib/lite/examples/ios/simple/RunModelViewController.xib create mode 100644 tensorflow/contrib/lite/examples/ios/simple/data/grace_hopper.jpg create mode 100644 tensorflow/contrib/lite/examples/ios/simple/ios_image_load.h create mode 100644 tensorflow/contrib/lite/examples/ios/simple/ios_image_load.mm create mode 100644 tensorflow/contrib/lite/examples/ios/simple/main.mm create mode 100644 tensorflow/contrib/lite/examples/ios/simple/simple.xcodeproj/project.pbxproj diff --git a/.gitignore b/.gitignore index 021997de1689e9..d11a504bdc56ee 100644 --- a/.gitignore +++ b/.gitignore @@ -24,3 +24,6 @@ Podfile.lock *.xcworkspacedata /tensorflow/contrib/lite/downloads/** /tensorflow/contrib/lite/gen/** +/tensorflow/contrib/lite/examples/ios/simple/data/*.txt +/tensorflow/contrib/lite/examples/ios/simple/data/*.tflite +xcuserdata/** \ No newline at end of file diff --git a/tensorflow/contrib/lite/build_ios_universal_lib.sh b/tensorflow/contrib/lite/build_ios_universal_lib.sh new file mode 100755 index 00000000000000..e0f2ef768bfed5 --- /dev/null +++ b/tensorflow/contrib/lite/build_ios_universal_lib.sh @@ -0,0 +1,16 @@ +#!/bin/bash -x +set -e +make -f tensorflow/contrib/lite/Makefile TARGET=IOS IOS_ARCH=x86_64 -j 8 +make -f tensorflow/contrib/lite/Makefile TARGET=IOS IOS_ARCH=i386 -j 8 +make -f tensorflow/contrib/lite/Makefile TARGET=IOS IOS_ARCH=armv7 -j 8 +make -f tensorflow/contrib/lite/Makefile TARGET=IOS IOS_ARCH=armv7s -j 8 +make -f tensorflow/contrib/lite/Makefile TARGET=IOS IOS_ARCH=arm64 -j 8 + +lipo \ +tensorflow/contrib/lite/gen/lib/ios_x86_64/libtensorflow-lite.a \ +tensorflow/contrib/lite/gen/lib/ios_i386/libtensorflow-lite.a \ +tensorflow/contrib/lite/gen/lib/ios_armv7/libtensorflow-lite.a \ +tensorflow/contrib/lite/gen/lib/ios_armv7s/libtensorflow-lite.a \ +tensorflow/contrib/lite/gen/lib/ios_arm64/libtensorflow-lite.a \ +-create \ +-output tensorflow/contrib/lite/gen/lib/libtensorflow-lite.a diff --git a/tensorflow/contrib/lite/download_dependencies.sh b/tensorflow/contrib/lite/download_dependencies.sh index 8c47ea2dd67362..0d9842fefa4e51 100755 --- a/tensorflow/contrib/lite/download_dependencies.sh +++ b/tensorflow/contrib/lite/download_dependencies.sh @@ -1,4 +1,4 @@ -#!/bin/bash -x +#!/bin/bash # Copyright 2015 The TensorFlow Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -26,6 +26,7 @@ ABSL_URL="$(grep -o 'https://github.com/abseil/abseil-cpp/.*tar.gz' "${BZL_FILE_ NEON_2_SSE_URL="https://github.com/intel/ARM_NEON_2_x86_SSE/archive/master.zip" FARMHASH_URL="https://mirror.bazel.build/github.com/google/farmhash/archive/816a4ae622e964763ca0862d9dbd19324a1eaf45.tar.gz" FLATBUFFERS_URL="https://github.com/google/flatbuffers/archive/master.zip" +MODELS_URL="https://storage.googleapis.com/download.tensorflow.org/models/tflite/mobilenet_v1_1.0_224_ios_lite_float_2017_11_08.zip" # TODO(petewarden): Some new code in Eigen triggers a clang bug with iOS arm64, # so work around it by patching the source. @@ -73,6 +74,7 @@ download_and_extract "${ABSL_URL}" "${DOWNLOADS_DIR}/absl" download_and_extract "${NEON_2_SSE_URL}" "${DOWNLOADS_DIR}/neon_2_sse" download_and_extract "${FARMHASH_URL}" "${DOWNLOADS_DIR}/farmhash" download_and_extract "${FLATBUFFERS_URL}" "${DOWNLOADS_DIR}/flatbuffers" +download_and_extract "${MODELS_URL}" "${DOWNLOADS_DIR}/models" replace_by_sed 's#static uint32x4_t p4ui_CONJ_XOR = vld1q_u32( conj_XOR_DATA );#static uint32x4_t p4ui_CONJ_XOR; // = vld1q_u32( conj_XOR_DATA ); - Removed by script#' \ "${DOWNLOADS_DIR}/eigen/Eigen/src/Core/arch/NEON/Complex.h" @@ -81,4 +83,6 @@ replace_by_sed 's#static uint32x2_t p2ui_CONJ_XOR = vld1_u32( conj_XOR_DATA );#s replace_by_sed 's#static uint64x2_t p2ul_CONJ_XOR = vld1q_u64( p2ul_conj_XOR_DATA );#static uint64x2_t p2ul_CONJ_XOR;// = vld1q_u64( p2ul_conj_XOR_DATA ); - Removed by script#' \ "${DOWNLOADS_DIR}/eigen/Eigen/src/Core/arch/NEON/Complex.h" +cp ${DOWNLOADS_DIR}/models/models/* tensorflow/contrib/lite/examples/ios/simple/data/ + echo "download_dependencies.sh completed successfully." >&2 diff --git a/tensorflow/contrib/lite/examples/ios/simple/AppDelegate.h b/tensorflow/contrib/lite/examples/ios/simple/AppDelegate.h new file mode 100644 index 00000000000000..75b1f1da384b52 --- /dev/null +++ b/tensorflow/contrib/lite/examples/ios/simple/AppDelegate.h @@ -0,0 +1,21 @@ +// Copyright 2015 Google Inc. 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. + +#import + +@interface AppDelegate : UIResponder + +@property (strong, nonatomic) UIWindow *window; + +@end diff --git a/tensorflow/contrib/lite/examples/ios/simple/AppDelegate.mm b/tensorflow/contrib/lite/examples/ios/simple/AppDelegate.mm new file mode 100644 index 00000000000000..1e808eb976ff3e --- /dev/null +++ b/tensorflow/contrib/lite/examples/ios/simple/AppDelegate.mm @@ -0,0 +1,44 @@ +// Copyright 2015 Google Inc. 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. + +#import "AppDelegate.h" + +#import "RunModelViewController.h" + +@implementation AppDelegate + +- (BOOL)application:(UIApplication *)application + didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { + + UITabBarController *bar = [[UITabBarController alloc] init]; + [bar setViewControllers: + @[[[RunModelViewController alloc] init]]]; + bar.selectedIndex = 0; + self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]]; + self.window.rootViewController = bar; + [self.window makeKeyAndVisible]; + return YES; +} + +- (void)applicationWillResignActive:(UIApplication *)application {} + +- (void)applicationDidEnterBackground:(UIApplication *)application {} + +- (void)applicationWillEnterForeground:(UIApplication *)application {} + +- (void)applicationDidBecomeActive:(UIApplication *)application {} + +- (void)applicationWillTerminate:(UIApplication *)application {} + +@end diff --git a/tensorflow/contrib/lite/examples/ios/simple/Podfile b/tensorflow/contrib/lite/examples/ios/simple/Podfile new file mode 100644 index 00000000000000..1740ad64573a84 --- /dev/null +++ b/tensorflow/contrib/lite/examples/ios/simple/Podfile @@ -0,0 +1,5 @@ +platform :ios, '8.0' +inhibit_all_warnings! + +target 'tf_simple_example' + pod 'TensorFlow-experimental' diff --git a/tensorflow/contrib/lite/examples/ios/simple/RunModel-Info.plist b/tensorflow/contrib/lite/examples/ios/simple/RunModel-Info.plist new file mode 100644 index 00000000000000..1a3eaa8a2c18d1 --- /dev/null +++ b/tensorflow/contrib/lite/examples/ios/simple/RunModel-Info.plist @@ -0,0 +1,47 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleDisplayName + tflite-simple-example + CFBundleExecutable + tf_simple_example + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + ios-app + CFBundlePackageType + APPL + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + 1.0 + LSRequiresIPhoneOS + + UILaunchStoryboardName + RunModelViewController + UIRequiredDeviceCapabilities + + armv7 + + UISupportedInterfaceOrientations + + UIInterfaceOrientationPortrait + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + UISupportedInterfaceOrientations~ipad + + UIInterfaceOrientationPortrait + UIInterfaceOrientationPortraitUpsideDown + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + + diff --git a/tensorflow/contrib/lite/examples/ios/simple/RunModelViewController.h b/tensorflow/contrib/lite/examples/ios/simple/RunModelViewController.h new file mode 100644 index 00000000000000..4e1a83ccf5a12c --- /dev/null +++ b/tensorflow/contrib/lite/examples/ios/simple/RunModelViewController.h @@ -0,0 +1,24 @@ +// Copyright 2015 Google Inc. 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. + +#import + +@interface RunModelViewController : UIViewController + +- (IBAction)getUrl:(id)sender; + +@property (weak, nonatomic) IBOutlet UITextView *urlContentTextView; +@property (weak, nonatomic) IBOutlet UITextField *urlTextField; + +@end diff --git a/tensorflow/contrib/lite/examples/ios/simple/RunModelViewController.mm b/tensorflow/contrib/lite/examples/ios/simple/RunModelViewController.mm new file mode 100644 index 00000000000000..965d83010516c6 --- /dev/null +++ b/tensorflow/contrib/lite/examples/ios/simple/RunModelViewController.mm @@ -0,0 +1,219 @@ +// Copyright 2015 Google Inc. 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. + +#import "RunModelViewController.h" + +#include +#include +#include +#include +#include +#include +#include + +#include "tensorflow/contrib/lite/kernels/register.h" +#include "tensorflow/contrib/lite/model.h" +#include "tensorflow/contrib/lite/string_util.h" +#include "tensorflow/contrib/lite/tools/mutable_op_resolver.h" + +#include "ios_image_load.h" + +#define LOG(x) std::cerr +#define CHECK(x) if (!(x)) { LOG(ERROR) << #x << "failed"; exit(1); } + +NSString* RunInferenceOnImage(); + +@interface RunModelViewController () +@end + +@implementation RunModelViewController { +} + +- (IBAction)getUrl:(id)sender { + NSString* inference_result = RunInferenceOnImage(); + self.urlContentTextView.text = inference_result; +} + +@end + +// Returns the top N confidence values over threshold in the provided vector, +// sorted by confidence in descending order. +static void GetTopN( + const float* prediction, + const int prediction_size, + const int num_results, const float threshold, + std::vector >* top_results) { + // Will contain top N results in ascending order. + std::priority_queue, + std::vector >, + std::greater > > top_result_pq; + + const long count = prediction_size; + for (int i = 0; i < count; ++i) { + const float value = prediction[i]; + + // 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(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()); +} + +NSString* FilePathForResourceName(NSString* name, NSString* extension) { + NSString* file_path = [[NSBundle mainBundle] pathForResource:name ofType:extension]; + if (file_path == NULL) { + LOG(FATAL) << "Couldn't find '" << [name UTF8String] << "." + << [extension UTF8String] << "' in bundle."; + } + return file_path; +} + +NSString* RunInferenceOnImage() { + std::string graph; + const int num_threads = 1; + std::string input_layer_type = "float"; + std::vector sizes = {1, 224, 224, 3}; + + NSString* graph_path = FilePathForResourceName(@"mobilenet_v1_1.0_224", @"tflite"); + + std::unique_ptr model(tflite::FlatBufferModel::BuildFromFile([graph_path UTF8String])); + if (!model) { + LOG(FATAL) << "Failed to mmap model " << graph; + } + LOG(INFO) << "Loaded model " << graph; + model->error_reporter(); + LOG(INFO) << "resolved reporter"; + +#ifdef TFLITE_CUSTOM_OPS_HEADER + tflite::MutableOpResolver resolver; + RegisterSelectedOps(&resolver); +#else + tflite::ops::builtin::BuiltinOpResolver resolver; +#endif + + std::unique_ptr interpreter; + tflite::InterpreterBuilder(*model, resolver)(&interpreter); + if (!interpreter) { + LOG(FATAL) << "Failed to construct interpreter"; + } + + if (num_threads != -1) { + interpreter->SetNumThreads(num_threads); + } + + int input = interpreter->inputs()[0]; + + if (input_layer_type != "string") { + interpreter->ResizeInputTensor(input, sizes); + } + + if (interpreter->AllocateTensors() != kTfLiteOk) { + LOG(FATAL) << "Failed to allocate tensors!"; + } + + // Read the label list + NSString* labels_path = FilePathForResourceName(@"labels", @"txt"); + std::vector label_strings; + std::ifstream t; + t.open([labels_path UTF8String]); + std::string line; + while(t){ + std::getline(t, line); + label_strings.push_back(line); + } + t.close(); + + // Read the Grace Hopper image. + NSString* image_path = FilePathForResourceName(@"grace_hopper", @"jpg"); + int image_width; + int image_height; + int image_channels; + std::vector image_data = LoadImageFromFile([image_path UTF8String], &image_width, &image_height, &image_channels); + const int wanted_width = 224; + const int wanted_height = 224; + const int wanted_channels = 3; + const float input_mean = 127.5f; + const float input_std = 127.5f; + assert(image_channels >= wanted_channels); + uint8_t* in = image_data.data(); + float* out = interpreter->typed_tensor(input); + for (int y = 0; y < wanted_height; ++y) { + const int in_y = (y * image_height) / wanted_height; + uint8_t* in_row = in + (in_y * image_width * image_channels); + float* out_row = out + (y * wanted_width * wanted_channels); + for (int x = 0; x < wanted_width; ++x) { + const int in_x = (x * image_width) / wanted_width; + uint8_t* in_pixel = in_row + (in_x * image_channels); + float* out_pixel = out_row + (x * wanted_channels); + for (int c = 0; c < wanted_channels; ++c) { + out_pixel[c] = (in_pixel[c] - input_mean) / input_std; + } + } + } + + if (interpreter->Invoke() != kTfLiteOk) { + LOG(FATAL) << "Failed to invoke!"; + } + + float* output = interpreter->typed_output_tensor(0); + const int output_size = 1000; + const int kNumResults = 5; + const float kThreshold = 0.1f; + std::vector > top_results; + GetTopN(output, output_size, kNumResults, kThreshold, &top_results); + + std::stringstream ss; + ss.precision(3); + for (const auto& result : top_results) { + const float confidence = result.first; + const int index = result.second; + + ss << index << " " << confidence << " "; + + // Write out the result as a string + if (index < label_strings.size()) { + // just for safety: theoretically, the output is under 1000 unless there + // is some numerical issues leading to a wrong prediction. + ss << label_strings[index]; + } else { + ss << "Prediction: " << index; + } + + ss << "\n"; + } + + LOG(INFO) << "Predictions: " << ss.str(); + + std::string predictions = ss.str(); + NSString* result = @""; + result = [NSString stringWithFormat: @"%@ - %s", result, + predictions.c_str()]; + + return result; +} diff --git a/tensorflow/contrib/lite/examples/ios/simple/RunModelViewController.xib b/tensorflow/contrib/lite/examples/ios/simple/RunModelViewController.xib new file mode 100644 index 00000000000000..93f334b9850c6f --- /dev/null +++ b/tensorflow/contrib/lite/examples/ios/simple/RunModelViewController.xib @@ -0,0 +1,46 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tensorflow/contrib/lite/examples/ios/simple/data/grace_hopper.jpg b/tensorflow/contrib/lite/examples/ios/simple/data/grace_hopper.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d2a427810f679db537236c5430873a81a62ef412 GIT binary patch literal 73746 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 + +std::vector LoadImageFromFile(const char* file_name, + int* out_width, + int* out_height, + int* out_channels); + +#endif // TENSORFLOW_EXAMPLES_IOS_IOS_IMAGE_LOAD_H_ diff --git a/tensorflow/contrib/lite/examples/ios/simple/ios_image_load.mm b/tensorflow/contrib/lite/examples/ios/simple/ios_image_load.mm new file mode 100644 index 00000000000000..789522d2a9900b --- /dev/null +++ b/tensorflow/contrib/lite/examples/ios/simple/ios_image_load.mm @@ -0,0 +1,85 @@ +// Copyright 2015 Google Inc. 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 "ios_image_load.h" + +#include +#include +#include +#include + +#import +#import + +std::vector LoadImageFromFile(const char* file_name, + int* out_width, int* out_height, + int* out_channels) { + FILE* file_handle = fopen(file_name, "rb"); + fseek(file_handle, 0, SEEK_END); + const size_t bytes_in_file = ftell(file_handle); + fseek(file_handle, 0, SEEK_SET); + std::vector file_data(bytes_in_file); + fread(file_data.data(), 1, bytes_in_file, file_handle); + fclose(file_handle); + CFDataRef file_data_ref = CFDataCreateWithBytesNoCopy(NULL, file_data.data(), + bytes_in_file, + kCFAllocatorNull); + CGDataProviderRef image_provider = + CGDataProviderCreateWithCFData(file_data_ref); + + const char* suffix = strrchr(file_name, '.'); + if (!suffix || suffix == file_name) { + suffix = ""; + } + CGImageRef image; + if (strcasecmp(suffix, ".png") == 0) { + image = CGImageCreateWithPNGDataProvider(image_provider, NULL, true, + kCGRenderingIntentDefault); + } else if ((strcasecmp(suffix, ".jpg") == 0) || + (strcasecmp(suffix, ".jpeg") == 0)) { + image = CGImageCreateWithJPEGDataProvider(image_provider, NULL, true, + kCGRenderingIntentDefault); + } else { + CFRelease(image_provider); + CFRelease(file_data_ref); + fprintf(stderr, "Unknown suffix for file '%s'\n", file_name); + *out_width = 0; + *out_height = 0; + *out_channels = 0; + return std::vector(); + } + + const int width = (int)CGImageGetWidth(image); + const int height = (int)CGImageGetHeight(image); + const int channels = 4; + CGColorSpaceRef color_space = CGColorSpaceCreateDeviceRGB(); + const int bytes_per_row = (width * channels); + const int bytes_in_image = (bytes_per_row * height); + std::vector result(bytes_in_image); + const int bits_per_component = 8; + CGContextRef context = CGBitmapContextCreate(result.data(), width, height, + bits_per_component, bytes_per_row, color_space, + kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big); + CGColorSpaceRelease(color_space); + CGContextDrawImage(context, CGRectMake(0, 0, width, height), image); + CGContextRelease(context); + CFRelease(image); + CFRelease(image_provider); + CFRelease(file_data_ref); + + *out_width = width; + *out_height = height; + *out_channels = channels; + return result; +} diff --git a/tensorflow/contrib/lite/examples/ios/simple/main.mm b/tensorflow/contrib/lite/examples/ios/simple/main.mm new file mode 100644 index 00000000000000..d70550a730720e --- /dev/null +++ b/tensorflow/contrib/lite/examples/ios/simple/main.mm @@ -0,0 +1,22 @@ +// Copyright 2015 Google Inc. 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. + +#import + +int main(int argc, char * argv[]) { + @autoreleasepool { + NSString *delegateClassName = @"AppDelegate"; + return UIApplicationMain(argc, argv, nil, delegateClassName); + } +} diff --git a/tensorflow/contrib/lite/examples/ios/simple/simple.xcodeproj/project.pbxproj b/tensorflow/contrib/lite/examples/ios/simple/simple.xcodeproj/project.pbxproj new file mode 100644 index 00000000000000..9277c230b8cce1 --- /dev/null +++ b/tensorflow/contrib/lite/examples/ios/simple/simple.xcodeproj/project.pbxproj @@ -0,0 +1,359 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 46; + objects = { + +/* Begin PBXBuildFile section */ + 1C0D734B1ECCC460008C1DAB /* CoreGraphics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1C0D734A1ECCC460008C1DAB /* CoreGraphics.framework */; }; + 1CA45FFF1ECCC356002FA6A4 /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1CA45FFE1ECCC356002FA6A4 /* UIKit.framework */; }; + 594C14AE1FB8F9B500EE8BFE /* libtensorflow-lite.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 594C14AD1FB8F9B500EE8BFE /* libtensorflow-lite.a */; }; + 594C14B11FB9037100EE8BFE /* labels.txt in Resources */ = {isa = PBXBuildFile; fileRef = 594C14AF1FB9037100EE8BFE /* labels.txt */; }; + 594C14B21FB9037100EE8BFE /* mobilenet_v1_1.0_224.tflite in Resources */ = {isa = PBXBuildFile; fileRef = 594C14B01FB9037100EE8BFE /* mobilenet_v1_1.0_224.tflite */; }; + 59A3D0011CF4E68100C4259F /* AppDelegate.mm in Sources */ = {isa = PBXBuildFile; fileRef = 59A3CFF21CF4E68100C4259F /* AppDelegate.mm */; }; + 59A3D0031CF4E68100C4259F /* grace_hopper.jpg in Resources */ = {isa = PBXBuildFile; fileRef = 59A3CFF51CF4E68100C4259F /* grace_hopper.jpg */; }; + 59A3D0081CF4E68100C4259F /* ios_image_load.mm in Sources */ = {isa = PBXBuildFile; fileRef = 59A3CFFB1CF4E68100C4259F /* ios_image_load.mm */; }; + 59A3D0091CF4E68100C4259F /* main.mm in Sources */ = {isa = PBXBuildFile; fileRef = 59A3CFFC1CF4E68100C4259F /* main.mm */; }; + 59A3D00B1CF4E68100C4259F /* RunModelViewController.mm in Sources */ = {isa = PBXBuildFile; fileRef = 59A3CFFF1CF4E68100C4259F /* RunModelViewController.mm */; }; + 59A3D00C1CF4E68100C4259F /* RunModelViewController.xib in Resources */ = {isa = PBXBuildFile; fileRef = 59A3D0001CF4E68100C4259F /* RunModelViewController.xib */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 1C0D73481ECCC41B008C1DAB /* CoreImage.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreImage.framework; path = System/Library/Frameworks/CoreImage.framework; sourceTree = SDKROOT; }; + 1C0D734A1ECCC460008C1DAB /* CoreGraphics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreGraphics.framework; path = System/Library/Frameworks/CoreGraphics.framework; sourceTree = SDKROOT; }; + 1CA45FFE1ECCC356002FA6A4 /* UIKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = UIKit.framework; path = System/Library/Frameworks/UIKit.framework; sourceTree = SDKROOT; }; + 5911579B1CF4011C00C31E3A /* tf_simple_example.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = tf_simple_example.app; sourceTree = BUILT_PRODUCTS_DIR; }; + 594C14AD1FB8F9B500EE8BFE /* libtensorflow-lite.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = "libtensorflow-lite.a"; path = "../../../gen/lib/libtensorflow-lite.a"; sourceTree = ""; }; + 594C14AF1FB9037100EE8BFE /* labels.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = labels.txt; sourceTree = ""; }; + 594C14B01FB9037100EE8BFE /* mobilenet_v1_1.0_224.tflite */ = {isa = PBXFileReference; lastKnownFileType = file; path = mobilenet_v1_1.0_224.tflite; sourceTree = ""; }; + 59A3CFF11CF4E68100C4259F /* AppDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AppDelegate.h; sourceTree = ""; }; + 59A3CFF21CF4E68100C4259F /* AppDelegate.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = AppDelegate.mm; sourceTree = ""; }; + 59A3CFF51CF4E68100C4259F /* grace_hopper.jpg */ = {isa = PBXFileReference; lastKnownFileType = image.jpeg; path = grace_hopper.jpg; sourceTree = ""; }; + 59A3CFFA1CF4E68100C4259F /* ios_image_load.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ios_image_load.h; sourceTree = ""; }; + 59A3CFFB1CF4E68100C4259F /* ios_image_load.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ios_image_load.mm; sourceTree = ""; }; + 59A3CFFC1CF4E68100C4259F /* main.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = main.mm; sourceTree = ""; }; + 59A3CFFD1CF4E68100C4259F /* RunModel-Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = "RunModel-Info.plist"; sourceTree = ""; }; + 59A3CFFE1CF4E68100C4259F /* RunModelViewController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RunModelViewController.h; sourceTree = ""; }; + 59A3CFFF1CF4E68100C4259F /* RunModelViewController.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = RunModelViewController.mm; sourceTree = ""; }; + 59A3D0001CF4E68100C4259F /* RunModelViewController.xib */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = file.xib; path = RunModelViewController.xib; sourceTree = ""; }; + 73DBC33C5DD9A526EE6D1EF2 /* libPods-tf_simple_example.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libPods-tf_simple_example.a"; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 591157981CF4011C00C31E3A /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 594C14AE1FB8F9B500EE8BFE /* libtensorflow-lite.a in Frameworks */, + 1C0D734B1ECCC460008C1DAB /* CoreGraphics.framework in Frameworks */, + 1CA45FFF1ECCC356002FA6A4 /* UIKit.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 24D7686C331131624F4454A0 /* Frameworks */ = { + isa = PBXGroup; + children = ( + 594C14AD1FB8F9B500EE8BFE /* libtensorflow-lite.a */, + 1C0D734A1ECCC460008C1DAB /* CoreGraphics.framework */, + 1C0D73481ECCC41B008C1DAB /* CoreImage.framework */, + 1CA45FFE1ECCC356002FA6A4 /* UIKit.framework */, + 73DBC33C5DD9A526EE6D1EF2 /* libPods-tf_simple_example.a */, + ); + name = Frameworks; + sourceTree = ""; + }; + 591157921CF4011C00C31E3A = { + isa = PBXGroup; + children = ( + 59A3CFF11CF4E68100C4259F /* AppDelegate.h */, + 59A3CFF21CF4E68100C4259F /* AppDelegate.mm */, + 59A3CFF31CF4E68100C4259F /* data */, + 59A3CFFA1CF4E68100C4259F /* ios_image_load.h */, + 59A3CFFB1CF4E68100C4259F /* ios_image_load.mm */, + 59A3CFFC1CF4E68100C4259F /* main.mm */, + 59A3CFFD1CF4E68100C4259F /* RunModel-Info.plist */, + 59A3CFFE1CF4E68100C4259F /* RunModelViewController.h */, + 59A3CFFF1CF4E68100C4259F /* RunModelViewController.mm */, + 59A3D0001CF4E68100C4259F /* RunModelViewController.xib */, + 5911579C1CF4011C00C31E3A /* Products */, + 24D7686C331131624F4454A0 /* Frameworks */, + ); + sourceTree = ""; + }; + 5911579C1CF4011C00C31E3A /* Products */ = { + isa = PBXGroup; + children = ( + 5911579B1CF4011C00C31E3A /* tf_simple_example.app */, + ); + name = Products; + sourceTree = ""; + }; + 59A3CFF31CF4E68100C4259F /* data */ = { + isa = PBXGroup; + children = ( + 59A3CFF51CF4E68100C4259F /* grace_hopper.jpg */, + 594C14AF1FB9037100EE8BFE /* labels.txt */, + 594C14B01FB9037100EE8BFE /* mobilenet_v1_1.0_224.tflite */, + ); + path = data; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 5911579A1CF4011C00C31E3A /* tf_simple_example */ = { + isa = PBXNativeTarget; + buildConfigurationList = 591157B21CF4011D00C31E3A /* Build configuration list for PBXNativeTarget "tf_simple_example" */; + buildPhases = ( + 591157971CF4011C00C31E3A /* Sources */, + 591157981CF4011C00C31E3A /* Frameworks */, + 591157991CF4011C00C31E3A /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = tf_simple_example; + productName = tf_ios_makefile_example; + productReference = 5911579B1CF4011C00C31E3A /* tf_simple_example.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 591157931CF4011C00C31E3A /* Project object */ = { + isa = PBXProject; + attributes = { + LastUpgradeCheck = 0830; + ORGANIZATIONNAME = Google; + TargetAttributes = { + 5911579A1CF4011C00C31E3A = { + CreatedOnToolsVersion = 7.2; + DevelopmentTeam = EQHXZ8M8AV; + ProvisioningStyle = Manual; + }; + }; + }; + buildConfigurationList = 591157961CF4011C00C31E3A /* Build configuration list for PBXProject "simple" */; + compatibilityVersion = "Xcode 3.2"; + developmentRegion = English; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = 591157921CF4011C00C31E3A; + productRefGroup = 5911579C1CF4011C00C31E3A /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 5911579A1CF4011C00C31E3A /* tf_simple_example */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 591157991CF4011C00C31E3A /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 59A3D00C1CF4E68100C4259F /* RunModelViewController.xib in Resources */, + 594C14B11FB9037100EE8BFE /* labels.txt in Resources */, + 59A3D0031CF4E68100C4259F /* grace_hopper.jpg in Resources */, + 594C14B21FB9037100EE8BFE /* mobilenet_v1_1.0_224.tflite in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 591157971CF4011C00C31E3A /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 59A3D0091CF4E68100C4259F /* main.mm in Sources */, + 59A3D0011CF4E68100C4259F /* AppDelegate.mm in Sources */, + 59A3D00B1CF4E68100C4259F /* RunModelViewController.mm in Sources */, + 59A3D0081CF4E68100C4259F /* ios_image_load.mm in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 591157B01CF4011D00C31E3A /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_DYNAMIC_NO_PIC = NO; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 8.0; + MTL_ENABLE_DEBUG_INFO = YES; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = iphoneos; + TARGETED_DEVICE_FAMILY = "1,2"; + }; + name = Debug; + }; + 591157B11CF4011D00C31E3A /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 8.0; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = iphoneos; + TARGETED_DEVICE_FAMILY = "1,2"; + VALIDATE_PRODUCT = YES; + }; + name = Release; + }; + 591157B31CF4011D00C31E3A /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CLANG_DEBUG_INFORMATION_LEVEL = default; + CODE_SIGN_IDENTITY = "iPhone Developer"; + DEVELOPMENT_TEAM = EQHXZ8M8AV; + ENABLE_BITCODE = NO; + GCC_ENABLE_CPP_EXCEPTIONS = YES; + GCC_ENABLE_CPP_RTTI = YES; + HEADER_SEARCH_PATHS = ( + "$(inherited)", + ../../../../../../, + ../../../downloads/flatbuffers/include/, + ../../../downloads/eigen/, + ../../../downloads/, + ); + INFOPLIST_FILE = "$(SRCROOT)/RunModel-Info.plist"; + IPHONEOS_DEPLOYMENT_TARGET = 9.2; + LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks"; + LIBRARY_SEARCH_PATHS = ../../../gen/lib/; + OTHER_CPLUSPLUSFLAGS = "$(OTHER_CFLAGS)"; + OTHER_LDFLAGS = "$(inherited)"; + PRODUCT_BUNDLE_IDENTIFIER = "com.google.tflite-simple-example"; + PRODUCT_NAME = "$(TARGET_NAME)"; + PROVISIONING_PROFILE = "1072bd47-ff19-4e5f-8107-d912748f83f1"; + PROVISIONING_PROFILE_SPECIFIER = "Google Development"; + SEPARATE_STRIP = NO; + }; + name = Debug; + }; + 591157B41CF4011D00C31E3A /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CLANG_DEBUG_INFORMATION_LEVEL = default; + CODE_SIGN_IDENTITY = "iPhone Developer"; + DEVELOPMENT_TEAM = ""; + ENABLE_BITCODE = NO; + GCC_ENABLE_CPP_EXCEPTIONS = YES; + GCC_ENABLE_CPP_RTTI = YES; + HEADER_SEARCH_PATHS = ( + "$(inherited)", + ../../../../../../, + ../../../downloads/flatbuffers/include/, + ../../../downloads/eigen/, + ../../../downloads/, + ); + INFOPLIST_FILE = "$(SRCROOT)/RunModel-Info.plist"; + IPHONEOS_DEPLOYMENT_TARGET = 9.2; + LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks"; + LIBRARY_SEARCH_PATHS = ../../../gen/lib/; + ONLY_ACTIVE_ARCH = YES; + OTHER_CPLUSPLUSFLAGS = "$(OTHER_CFLAGS)"; + OTHER_LDFLAGS = "$(inherited)"; + PRODUCT_BUNDLE_IDENTIFIER = "com.google.tflite-simple-example"; + PRODUCT_NAME = "$(TARGET_NAME)"; + PROVISIONING_PROFILE_SPECIFIER = ""; + SEPARATE_STRIP = NO; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 591157961CF4011C00C31E3A /* Build configuration list for PBXProject "simple" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 591157B01CF4011D00C31E3A /* Debug */, + 591157B11CF4011D00C31E3A /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 591157B21CF4011D00C31E3A /* Build configuration list for PBXNativeTarget "tf_simple_example" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 591157B31CF4011D00C31E3A /* Debug */, + 591157B41CF4011D00C31E3A /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 591157931CF4011C00C31E3A /* Project object */; +}