From 6574fc4e08e71ba76694002ca70e344b7f0b8d3c Mon Sep 17 00:00:00 2001 From: Jaesung Chung Date: Fri, 29 Jan 2021 17:02:50 -0800 Subject: [PATCH] Resource & variant type additions to TFLite schema PiperOrigin-RevId: 354638976 Change-Id: I104c4de542b68e2660887a4e3ec45631a056dd74 --- .../lite/python/tf_tfl_flatbuffer_helpers.cc | 4 ++++ .../compiler/mlir/lite/utils/convert_type.cc | 18 ++++++++++++++++++ tensorflow/lite/c/c_api_types.h | 2 ++ tensorflow/lite/c/common.c | 4 ++++ tensorflow/lite/c/common_test.cc | 2 ++ .../lite/core/api/flatbuffer_conversions.cc | 6 ++++++ tensorflow/lite/core/subgraph.cc | 12 ++++++++---- tensorflow/lite/delegates/flex/util.cc | 8 ++++++++ tensorflow/lite/delegates/flex/util_test.cc | 6 ++++-- tensorflow/lite/micro/memory_helpers.cc | 6 ++++++ tensorflow/lite/micro/memory_helpers_test.cc | 8 ++++++++ tensorflow/lite/objc/sources/TFLInterpreter.mm | 7 +++++-- tensorflow/lite/optional_debug_tools.cc | 4 ++++ .../interpreter_wrapper/interpreter_wrapper.cc | 3 ++- .../lite/python/interpreter_wrapper/numpy.cc | 3 +++ .../python/optimize/calibration_wrapper.cc | 4 ++++ tensorflow/lite/python/util.py | 2 ++ tensorflow/lite/schema/schema.fbs | 2 ++ tensorflow/lite/schema/schema_generated.h | 16 +++++++++++----- tensorflow/lite/toco/tooling_util.cc | 2 ++ tensorflow/lite/toco/types.proto | 6 ++++++ .../lite/tools/serialization/enum_mapping.h | 4 ++++ tensorflow/lite/tools/verifier_test.cc | 4 +++- tensorflow/lite/util.cc | 5 +++-- 24 files changed, 121 insertions(+), 17 deletions(-) diff --git a/tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc b/tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc index c5562c1f871..735e8be269f 100644 --- a/tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc +++ b/tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc @@ -131,6 +131,10 @@ DataType ConvertIODataTypeToDataType(toco::IODataType dtype) { return DT_COMPLEX64; case toco::IODataType::COMPLEX128: return DT_COMPLEX128; + case toco::IODataType::RESOURCE: + return DT_RESOURCE; + case toco::IODataType::VARIANT: + return DT_VARIANT; default: return DT_INVALID; } diff --git a/tensorflow/compiler/mlir/lite/utils/convert_type.cc b/tensorflow/compiler/mlir/lite/utils/convert_type.cc index 489b0f32f8d..811796bcbcd 100644 --- a/tensorflow/compiler/mlir/lite/utils/convert_type.cc +++ b/tensorflow/compiler/mlir/lite/utils/convert_type.cc @@ -59,6 +59,10 @@ mlir::Type ConvertElementType(tflite::TensorType type, mlir::Builder builder) { return builder.getIntegerType(8); case tflite::TensorType_UINT64: return builder.getIntegerType(64, /*isSigned=*/false); + case tflite::TensorType_RESOURCE: + return mlir::TF::ResourceType::get(builder.getContext()); + case tflite::TensorType_VARIANT: + return mlir::TF::VariantType::get(builder.getContext()); } } @@ -90,6 +94,10 @@ tensorflow::DataType TflTypeToTfType(tflite::TensorType type) { return tensorflow::DT_UINT8; case tflite::TensorType_UINT64: return tensorflow::DT_UINT64; + case tflite::TensorType_RESOURCE: + return tensorflow::DT_RESOURCE; + case tflite::TensorType_VARIANT: + return tensorflow::DT_VARIANT; } } @@ -99,10 +107,14 @@ StatusOr TfTypeToTflType(tensorflow::DataType type) { return tflite::TensorType_BOOL; case tensorflow::DT_COMPLEX64: return tflite::TensorType_COMPLEX64; + case tensorflow::DT_COMPLEX128: + return tflite::TensorType_COMPLEX128; case tensorflow::DT_HALF: return tflite::TensorType_FLOAT16; case tensorflow::DT_FLOAT: return tflite::TensorType_FLOAT32; + case tensorflow::DT_DOUBLE: + return tflite::TensorType_FLOAT64; case tensorflow::DT_INT8: return tflite::TensorType_INT8; case tensorflow::DT_INT16: @@ -111,10 +123,16 @@ StatusOr TfTypeToTflType(tensorflow::DataType type) { return tflite::TensorType_INT32; case tensorflow::DT_INT64: return tflite::TensorType_INT64; + case tensorflow::DT_UINT64: + return tflite::TensorType_UINT64; case tensorflow::DT_STRING: return tflite::TensorType_STRING; case tensorflow::DT_UINT8: return tflite::TensorType_UINT8; + case tensorflow::DT_RESOURCE: + return tflite::TensorType_RESOURCE; + case tensorflow::DT_VARIANT: + return tflite::TensorType_VARIANT; default: return errors::InvalidArgument("unsupported tensor data type", type); } diff --git a/tensorflow/lite/c/c_api_types.h b/tensorflow/lite/c/c_api_types.h index e066e5424de..d6dc5141aa9 100644 --- a/tensorflow/lite/c/c_api_types.h +++ b/tensorflow/lite/c/c_api_types.h @@ -73,6 +73,8 @@ typedef enum { kTfLiteFloat64 = 11, kTfLiteComplex128 = 12, kTfLiteUInt64 = 13, + kTfLiteResource = 14, + kTfLiteVariant = 15, } TfLiteType; // Legacy. Will be deprecated in favor of TfLiteAffineQuantization. diff --git a/tensorflow/lite/c/common.c b/tensorflow/lite/c/common.c index 0b54fdac5ce..d47ec4e4bb2 100644 --- a/tensorflow/lite/c/common.c +++ b/tensorflow/lite/c/common.c @@ -219,6 +219,10 @@ const char* TfLiteTypeGetName(TfLiteType type) { return "FLOAT16"; case kTfLiteFloat64: return "FLOAT64"; + case kTfLiteResource: + return "RESOURCE"; + case kTfLiteVariant: + return "VARIANT"; } return "Unknown type"; } diff --git a/tensorflow/lite/c/common_test.cc b/tensorflow/lite/c/common_test.cc index 6b910f3d714..e8425f110a9 100644 --- a/tensorflow/lite/c/common_test.cc +++ b/tensorflow/lite/c/common_test.cc @@ -91,6 +91,8 @@ TEST(Types, TestTypeNames) { EXPECT_EQ(type_name(kTfLiteComplex64), "COMPLEX64"); EXPECT_EQ(type_name(kTfLiteComplex128), "COMPLEX128"); EXPECT_EQ(type_name(kTfLiteString), "STRING"); + EXPECT_EQ(type_name(kTfLiteResource), "RESOURCE"); + EXPECT_EQ(type_name(kTfLiteVariant), "VARIANT"); } TEST(Quantization, TestQuantizationFree) { diff --git a/tensorflow/lite/core/api/flatbuffer_conversions.cc b/tensorflow/lite/core/api/flatbuffer_conversions.cc index e1467f2a07e..16a3dab81ec 100644 --- a/tensorflow/lite/core/api/flatbuffer_conversions.cc +++ b/tensorflow/lite/core/api/flatbuffer_conversions.cc @@ -872,6 +872,12 @@ TfLiteStatus ConvertTensorType(TensorType tensor_type, TfLiteType* type, case TensorType_COMPLEX128: *type = kTfLiteComplex128; return kTfLiteOk; + case TensorType_RESOURCE: + *type = kTfLiteResource; + return kTfLiteOk; + case TensorType_VARIANT: + *type = kTfLiteVariant; + return kTfLiteOk; default: *type = kTfLiteNoType; TF_LITE_REPORT_ERROR(error_reporter, diff --git a/tensorflow/lite/core/subgraph.cc b/tensorflow/lite/core/subgraph.cc index fb68693b1bf..7f604823324 100644 --- a/tensorflow/lite/core/subgraph.cc +++ b/tensorflow/lite/core/subgraph.cc @@ -1210,7 +1210,8 @@ TfLiteStatus Subgraph::SetTensorParametersReadOnly( // ensure the buffer is large enough. However, we need to skip string tensors // and sparse tensors because their sizes change with the contents. // TODO(b/145615516): Extend BytesRequired to check sparse tensors. - if (type != kTfLiteString && sparsity == nullptr) { + if (type != kTfLiteString && type != kTfLiteResource && + type != kTfLiteVariant && sparsity == nullptr) { size_t required_bytes; TF_LITE_ENSURE_OK(&context_, BytesRequired(type, dims, rank, &required_bytes)); @@ -1262,7 +1263,8 @@ TfLiteStatus Subgraph::SetTensorParametersReadWrite( TF_LITE_ENSURE(&context_, tensor_index < context_.tensors_size && tensor_index >= 0); size_t required_bytes = 0; - if (type != kTfLiteString) { + if (type != kTfLiteString && type != kTfLiteResource && + type != kTfLiteVariant) { // These types will be allocated in our arena so we need to record how // many bytes we will need based on the dimensions. String tensors are // allocated dynamically and we can't know ahead of time how much space @@ -1272,7 +1274,8 @@ TfLiteStatus Subgraph::SetTensorParametersReadWrite( } TfLiteAllocationType allocation_type = kTfLiteArenaRw; - if (type == kTfLiteString) { + if (type == kTfLiteString || type == kTfLiteResource || + type == kTfLiteVariant) { if (is_variable) { // We don't have a real use case for string variable tensor. ReportError("String variable tensor isn't supported."); @@ -1315,7 +1318,8 @@ TfLiteStatus Subgraph::ResizeTensorImpl(TfLiteTensor* tensor, tensor->allocation_type == kTfLiteCustom) { tensor_resized_since_op_invoke_ |= TfLiteIntArrayEqual(tensor->dims, new_size) == 0; - if (tensor->type != kTfLiteString) { + if (tensor->type != kTfLiteString && tensor->type != kTfLiteResource && + tensor->type != kTfLiteVariant) { size_t bytesRequired; TfLiteStatus status = BytesRequired(tensor->type, new_size->data, new_size->size, &bytesRequired); diff --git a/tensorflow/lite/delegates/flex/util.cc b/tensorflow/lite/delegates/flex/util.cc index 1a965c64232..2ba9161bb30 100644 --- a/tensorflow/lite/delegates/flex/util.cc +++ b/tensorflow/lite/delegates/flex/util.cc @@ -84,6 +84,10 @@ TF_DataType GetTensorFlowDataType(TfLiteType type) { return TF_STRING; case kTfLiteBool: return TF_BOOL; + case kTfLiteResource: + return TF_RESOURCE; + case kTfLiteVariant: + return TF_VARIANT; } } @@ -115,6 +119,10 @@ TfLiteType GetTensorFlowLiteType(TF_DataType type) { return kTfLiteString; case TF_BOOL: return kTfLiteBool; + case TF_RESOURCE: + return kTfLiteResource; + case TF_VARIANT: + return kTfLiteVariant; default: return kTfLiteNoType; } diff --git a/tensorflow/lite/delegates/flex/util_test.cc b/tensorflow/lite/delegates/flex/util_test.cc index 7539a0c073f..ef93d219c63 100644 --- a/tensorflow/lite/delegates/flex/util_test.cc +++ b/tensorflow/lite/delegates/flex/util_test.cc @@ -120,6 +120,8 @@ TEST(UtilTest, TypeConversionsFromTFLite) { EXPECT_EQ(TF_COMPLEX128, GetTensorFlowDataType(kTfLiteComplex128)); EXPECT_EQ(TF_STRING, GetTensorFlowDataType(kTfLiteString)); EXPECT_EQ(TF_BOOL, GetTensorFlowDataType(kTfLiteBool)); + EXPECT_EQ(TF_RESOURCE, GetTensorFlowDataType(kTfLiteResource)); + EXPECT_EQ(TF_VARIANT, GetTensorFlowDataType(kTfLiteVariant)); } TEST(UtilTest, TypeConversionsFromTensorFlow) { @@ -135,8 +137,8 @@ TEST(UtilTest, TypeConversionsFromTensorFlow) { EXPECT_EQ(kTfLiteComplex128, GetTensorFlowLiteType(TF_COMPLEX128)); EXPECT_EQ(kTfLiteString, GetTensorFlowLiteType(TF_STRING)); EXPECT_EQ(kTfLiteBool, GetTensorFlowLiteType(TF_BOOL)); - EXPECT_EQ(kTfLiteNoType, GetTensorFlowLiteType(TF_RESOURCE)); - EXPECT_EQ(kTfLiteNoType, GetTensorFlowLiteType(TF_VARIANT)); + EXPECT_EQ(kTfLiteResource, GetTensorFlowLiteType(TF_RESOURCE)); + EXPECT_EQ(kTfLiteVariant, GetTensorFlowLiteType(TF_VARIANT)); } } // namespace diff --git a/tensorflow/lite/micro/memory_helpers.cc b/tensorflow/lite/micro/memory_helpers.cc index c515c5eeeab..08bd9a893aa 100644 --- a/tensorflow/lite/micro/memory_helpers.cc +++ b/tensorflow/lite/micro/memory_helpers.cc @@ -48,9 +48,15 @@ size_t AlignSizeUp(size_t size, size_t alignment) { TfLiteStatus TfLiteTypeSizeOf(TfLiteType type, size_t* size) { switch (type) { + case kTfLiteFloat16: + *size = sizeof(int16_t); + break; case kTfLiteFloat32: *size = sizeof(float); break; + case kTfLiteFloat64: + *size = sizeof(double); + break; case kTfLiteInt16: *size = sizeof(int16_t); break; diff --git a/tensorflow/lite/micro/memory_helpers_test.cc b/tensorflow/lite/micro/memory_helpers_test.cc index 60682c18ce8..8da02d7b2da 100644 --- a/tensorflow/lite/micro/memory_helpers_test.cc +++ b/tensorflow/lite/micro/memory_helpers_test.cc @@ -115,10 +115,18 @@ TF_LITE_MICRO_TEST(TestAlignSizeUp) { TF_LITE_MICRO_TEST(TestTypeSizeOf) { size_t size; + TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, + tflite::TfLiteTypeSizeOf(kTfLiteFloat16, &size)); + TF_LITE_MICRO_EXPECT_EQ(sizeof(int16_t), size); + TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, tflite::TfLiteTypeSizeOf(kTfLiteFloat32, &size)); TF_LITE_MICRO_EXPECT_EQ(sizeof(float), size); + TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, + tflite::TfLiteTypeSizeOf(kTfLiteFloat64, &size)); + TF_LITE_MICRO_EXPECT_EQ(sizeof(double), size); + TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, tflite::TfLiteTypeSizeOf(kTfLiteInt16, &size)); TF_LITE_MICRO_EXPECT_EQ(sizeof(int16_t), size); diff --git a/tensorflow/lite/objc/sources/TFLInterpreter.mm b/tensorflow/lite/objc/sources/TFLInterpreter.mm index 862942edb82..03a20f01d67 100644 --- a/tensorflow/lite/objc/sources/TFLInterpreter.mm +++ b/tensorflow/lite/objc/sources/TFLInterpreter.mm @@ -422,8 +422,11 @@ static void TFLInterpreterErrorReporter(void *user_data, const char *format, va_ case kTfLiteComplex64: case kTfLiteComplex128: case kTfLiteUInt64: - // kTfLiteString, kTfLiteUInt64, kTfLiteComplex64 and kTfLiteComplex128 are not supported in - // TensorFlow Lite Objc API. + case kTfLiteResource: + case kTfLiteVariant: + // kTfLiteString, kTfLiteUInt64, kTfLiteComplex64, kTfLiteComplex128, + // kTfLiteResource and kTfLiteVariant are not supported in TensorFlow Lite + // Objc API. return TFLTensorDataTypeNoType; } } diff --git a/tensorflow/lite/optional_debug_tools.cc b/tensorflow/lite/optional_debug_tools.cc index a4ba246d6ee..1ec0d1ad523 100644 --- a/tensorflow/lite/optional_debug_tools.cc +++ b/tensorflow/lite/optional_debug_tools.cc @@ -73,6 +73,10 @@ const char* TensorTypeName(TfLiteType type) { return "kTfLiteFloat16"; case kTfLiteFloat64: return "kTfLiteFloat64"; + case kTfLiteResource: + return "kTfLiteResource"; + case kTfLiteVariant: + return "kTfLiteVariant"; } return "(invalid)"; } diff --git a/tensorflow/lite/python/interpreter_wrapper/interpreter_wrapper.cc b/tensorflow/lite/python/interpreter_wrapper/interpreter_wrapper.cc index 1fdf9bed213..b3057bd033a 100644 --- a/tensorflow/lite/python/interpreter_wrapper/interpreter_wrapper.cc +++ b/tensorflow/lite/python/interpreter_wrapper/interpreter_wrapper.cc @@ -619,7 +619,8 @@ PyObject* InterpreterWrapper::GetTensor(int i) const { std::vector dims(tensor->dims->data, tensor->dims->data + tensor->dims->size); - if (tensor->type != kTfLiteString) { + if (tensor->type != kTfLiteString && tensor->type != kTfLiteResource && + tensor->type != kTfLiteVariant) { // Make a buffer copy but we must tell Numpy It owns that data or else // it will leak. void* data = malloc(tensor->bytes); diff --git a/tensorflow/lite/python/interpreter_wrapper/numpy.cc b/tensorflow/lite/python/interpreter_wrapper/numpy.cc index c75a3180161..1785aa02c4b 100644 --- a/tensorflow/lite/python/interpreter_wrapper/numpy.cc +++ b/tensorflow/lite/python/interpreter_wrapper/numpy.cc @@ -60,6 +60,9 @@ int TfLiteTypeToPyArrayType(TfLiteType tf_lite_type) { return NPY_COMPLEX64; case kTfLiteComplex128: return NPY_COMPLEX128; + case kTfLiteResource: + case kTfLiteVariant: + return NPY_OBJECT; case kTfLiteNoType: return NPY_NOTYPE; // Avoid default so compiler errors created when new types are made. diff --git a/tensorflow/lite/python/optimize/calibration_wrapper.cc b/tensorflow/lite/python/optimize/calibration_wrapper.cc index e2124a5c425..a70ea5bb932 100644 --- a/tensorflow/lite/python/optimize/calibration_wrapper.cc +++ b/tensorflow/lite/python/optimize/calibration_wrapper.cc @@ -91,6 +91,10 @@ inline TensorType TfLiteTypeToSchemaType(TfLiteType type) { return TensorType_COMPLEX64; case kTfLiteComplex128: return TensorType_COMPLEX128; + case kTfLiteResource: + return TensorType_RESOURCE; + case kTfLiteVariant: + return TensorType_VARIANT; } // No default to get compiler error when new type is introduced. } diff --git a/tensorflow/lite/python/util.py b/tensorflow/lite/python/util.py index e642b9d12bd..f69bd326ff0 100644 --- a/tensorflow/lite/python/util.py +++ b/tensorflow/lite/python/util.py @@ -64,6 +64,8 @@ _MAP_TF_TO_TFLITE_TYPES = { dtypes.int8: _types_pb2.INT8, dtypes.float64: _types_pb2.FLOAT64, dtypes.complex128: _types_pb2.COMPLEX128, + dtypes.resource: _types_pb2.RESOURCE, + dtypes.variant: _types_pb2.VARIANT, } _MAP_TFLITE_ENUM_TO_TF_TYPES = { diff --git a/tensorflow/lite/schema/schema.fbs b/tensorflow/lite/schema/schema.fbs index 3d225dc5b52..2eb3a0409be 100644 --- a/tensorflow/lite/schema/schema.fbs +++ b/tensorflow/lite/schema/schema.fbs @@ -45,6 +45,8 @@ enum TensorType : byte { FLOAT64 = 10, COMPLEX128 = 11, UINT64 = 12, + RESOURCE = 13, + VARIANT = 14, } // Custom quantization parameters for experimenting with new quantization diff --git a/tensorflow/lite/schema/schema_generated.h b/tensorflow/lite/schema/schema_generated.h index 61272dce0d2..447c8336a1a 100755 --- a/tensorflow/lite/schema/schema_generated.h +++ b/tensorflow/lite/schema/schema_generated.h @@ -402,11 +402,13 @@ enum TensorType { TensorType_FLOAT64 = 10, TensorType_COMPLEX128 = 11, TensorType_UINT64 = 12, + TensorType_RESOURCE = 13, + TensorType_VARIANT = 14, TensorType_MIN = TensorType_FLOAT32, - TensorType_MAX = TensorType_UINT64 + TensorType_MAX = TensorType_VARIANT }; -inline const TensorType (&EnumValuesTensorType())[13] { +inline const TensorType (&EnumValuesTensorType())[15] { static const TensorType values[] = { TensorType_FLOAT32, TensorType_FLOAT16, @@ -420,13 +422,15 @@ inline const TensorType (&EnumValuesTensorType())[13] { TensorType_INT8, TensorType_FLOAT64, TensorType_COMPLEX128, - TensorType_UINT64 + TensorType_UINT64, + TensorType_RESOURCE, + TensorType_VARIANT }; return values; } inline const char * const *EnumNamesTensorType() { - static const char * const names[14] = { + static const char * const names[16] = { "FLOAT32", "FLOAT16", "INT32", @@ -440,13 +444,15 @@ inline const char * const *EnumNamesTensorType() { "FLOAT64", "COMPLEX128", "UINT64", + "RESOURCE", + "VARIANT", nullptr }; return names; } inline const char *EnumNameTensorType(TensorType e) { - if (flatbuffers::IsOutRange(e, TensorType_FLOAT32, TensorType_UINT64)) return ""; + if (flatbuffers::IsOutRange(e, TensorType_FLOAT32, TensorType_VARIANT)) return ""; const size_t index = static_cast(e); return EnumNamesTensorType()[index]; } diff --git a/tensorflow/lite/toco/tooling_util.cc b/tensorflow/lite/toco/tooling_util.cc index eb19a7e8659..b34f4922154 100644 --- a/tensorflow/lite/toco/tooling_util.cc +++ b/tensorflow/lite/toco/tooling_util.cc @@ -2323,6 +2323,8 @@ ArrayDataType ConvertIODataTypeToArrayDataType(IODataType type) { return ArrayDataType::kFloat16; case FLOAT64: return ArrayDataType::kFloat64; + case RESOURCE: + case VARIANT: default: return ArrayDataType::kNone; } diff --git a/tensorflow/lite/toco/types.proto b/tensorflow/lite/toco/types.proto index 6fc8ff49ba9..45489984f14 100644 --- a/tensorflow/lite/toco/types.proto +++ b/tensorflow/lite/toco/types.proto @@ -58,4 +58,10 @@ enum IODataType { // Uint64, not quantized UINT64 = 13; + + // Resource type + RESOURCE = 14; + + // Variant type + VARIANT = 15; } diff --git a/tensorflow/lite/tools/serialization/enum_mapping.h b/tensorflow/lite/tools/serialization/enum_mapping.h index a79e25d844e..721ce3b3c32 100644 --- a/tensorflow/lite/tools/serialization/enum_mapping.h +++ b/tensorflow/lite/tools/serialization/enum_mapping.h @@ -86,6 +86,10 @@ inline TensorType TfLiteTypeToSchemaType(TfLiteType type) { return TensorType_COMPLEX64; case kTfLiteComplex128: return TensorType_COMPLEX128; + case kTfLiteResource: + return TensorType_RESOURCE; + case kTfLiteVariant: + return TensorType_VARIANT; } // TODO(aselle): consider an error } diff --git a/tensorflow/lite/tools/verifier_test.cc b/tensorflow/lite/tools/verifier_test.cc index c4eac26049e..9a892f58ea0 100644 --- a/tensorflow/lite/tools/verifier_test.cc +++ b/tensorflow/lite/tools/verifier_test.cc @@ -558,7 +558,9 @@ TEST(VerifyModel, TypedTensorShapeMatchesTensorBufferSize) { TfLiteFlatbufferModelBuilder builder; for (int tensor_type = TensorType_MIN; tensor_type <= TensorType_MAX; ++tensor_type) { - if (tensor_type == TensorType_STRING) continue; + if (tensor_type == TensorType_STRING || + tensor_type == TensorType_RESOURCE || tensor_type == TensorType_VARIANT) + continue; TfLiteType lite_type = kTfLiteNoType; ASSERT_EQ(ConvertTensorType(static_cast(tensor_type), &lite_type, /*error_reporter=*/nullptr), diff --git a/tensorflow/lite/util.cc b/tensorflow/lite/util.cc index c168ca21df3..1395a4ea239 100644 --- a/tensorflow/lite/util.cc +++ b/tensorflow/lite/util.cc @@ -132,8 +132,9 @@ TfLiteStatus GetSizeOfType(TfLiteContext* context, const TfLiteType type, if (context) { context->ReportError( context, - "Type %d is unsupported. Only float32, int8, int16, int32, int64, " - "uint8, bool, complex64 supported currently.", + "Type %d is unsupported. Only float16, float32, float64, int8, " + "int16, int32, int64, uint8, uint64, bool, complex64 and " + "complex128 supported currently.", type); } return kTfLiteError;