Add uint64 tensor support in TFLite

abattery · tensorflower-gardener · commit f954b2770d0c · 2020-11-17T14:01:21.000-08:00
Even though we do not support uint64 op kernels on mobile, it is inevitable to
support uint64 tensors in order to enable TF uint64 ops via flex delegate.

This CL enables the uint64 tensor type in MLIR converter only.

PiperOrigin-RevId: 342939673
Change-Id: I24f422040f82cad7affce4b921361f79e8a51730
diff --git a/tensorflow/compiler/mlir/lite/flatbuffer_export.cc b/tensorflow/compiler/mlir/lite/flatbuffer_export.cc
@@ -167,7 +167,8 @@ static StatusOr<tflite::TensorType> GetTFLiteType(Type type,
       case 32:
         return tflite::TensorType_INT32;
       case 64:
-        return tflite::TensorType_INT64;
+        return itype.isUnsigned() ? tflite::TensorType_UINT64
+                                  : tflite::TensorType_INT64;
     }
   } else if (auto q_uniform_type =
                  type.dyn_cast<mlir::quant::UniformQuantizedType>()) {
diff --git a/tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc b/tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc
@@ -119,6 +119,8 @@ DataType ConvertIODataTypeToDataType(toco::IODataType dtype) {
       return DT_INT32;
     case toco::IODataType::INT64:
       return DT_INT64;
+    case toco::IODataType::UINT64:
+      return DT_UINT64;
     case toco::IODataType::STRING:
       return DT_STRING;
     case toco::IODataType::BOOL:
diff --git a/tensorflow/compiler/mlir/lite/utils/convert_type.cc b/tensorflow/compiler/mlir/lite/utils/convert_type.cc
@@ -57,6 +57,8 @@ mlir::Type ConvertElementType(tflite::TensorType type, mlir::Builder builder) {
       return mlir::ComplexType::get(builder.getF64Type());
     case tflite::TensorType_INT8:
       return builder.getIntegerType(8);
+    case tflite::TensorType_UINT64:
+      return builder.getIntegerType(64, /*isSigned=*/false);
   }
 }
 
@@ -86,6 +88,8 @@ tensorflow::DataType TflTypeToTfType(tflite::TensorType type) {
       return tensorflow::DT_STRING;
     case tflite::TensorType_UINT8:
       return tensorflow::DT_UINT8;
+    case tflite::TensorType_UINT64:
+      return tensorflow::DT_UINT64;
   }
 }
 
diff --git a/tensorflow/lite/c/common.c b/tensorflow/lite/c/common.c
@@ -203,6 +203,8 @@ const char* TfLiteTypeGetName(TfLiteType type) {
       return "INT8";
     case kTfLiteInt64:
       return "INT64";
+    case kTfLiteUInt64:
+      return "UINT64";
     case kTfLiteBool:
       return "BOOL";
     case kTfLiteComplex64:
diff --git a/tensorflow/lite/c/common.h b/tensorflow/lite/c/common.h
@@ -300,6 +300,7 @@ typedef enum {
   kTfLiteFloat16 = 10,
   kTfLiteFloat64 = 11,
   kTfLiteComplex128 = 12,
+  kTfLiteUInt64 = 13,
 } TfLiteType;
 
 // Return the name of a given type, for error reporting purposes.
@@ -354,6 +355,7 @@ typedef union TfLitePtrUnion {
    * members are deprecated. */
   int32_t* i32;
   int64_t* i64;
+  uint64_t* u64;
   float* f;
   TfLiteFloat16* f16;
   double* f64;
diff --git a/tensorflow/lite/c/common_test.cc b/tensorflow/lite/c/common_test.cc
@@ -84,6 +84,7 @@ TEST(Types, TestTypeNames) {
   EXPECT_EQ(type_name(kTfLiteInt16), "INT16");
   EXPECT_EQ(type_name(kTfLiteInt32), "INT32");
   EXPECT_EQ(type_name(kTfLiteUInt8), "UINT8");
+  EXPECT_EQ(type_name(kTfLiteUInt64), "UINT64");
   EXPECT_EQ(type_name(kTfLiteInt8), "INT8");
   EXPECT_EQ(type_name(kTfLiteInt64), "INT64");
   EXPECT_EQ(type_name(kTfLiteBool), "BOOL");
diff --git a/tensorflow/lite/core/api/flatbuffer_conversions.cc b/tensorflow/lite/core/api/flatbuffer_conversions.cc
@@ -859,6 +859,9 @@ TfLiteStatus ConvertTensorType(TensorType tensor_type, TfLiteType* type,
     case TensorType_INT64:
       *type = kTfLiteInt64;
       return kTfLiteOk;
+    case TensorType_UINT64:
+      *type = kTfLiteUInt64;
+      return kTfLiteOk;
     case TensorType_STRING:
       *type = kTfLiteString;
       return kTfLiteOk;
diff --git a/tensorflow/lite/delegates/flex/util.cc b/tensorflow/lite/delegates/flex/util.cc
@@ -74,6 +74,8 @@ TF_DataType GetTensorFlowDataType(TfLiteType type) {
       return TF_INT8;
     case kTfLiteInt64:
       return TF_INT64;
+    case kTfLiteUInt64:
+      return TF_UINT64;
     case kTfLiteComplex64:
       return TF_COMPLEX64;
     case kTfLiteComplex128:
@@ -103,6 +105,8 @@ TfLiteType GetTensorFlowLiteType(TF_DataType type) {
       return kTfLiteInt8;
     case TF_INT64:
       return kTfLiteInt64;
+    case TF_UINT64:
+      return kTfLiteUInt64;
     case TF_COMPLEX64:
       return kTfLiteComplex64;
     case TF_COMPLEX128:
diff --git a/tensorflow/lite/delegates/flex/util_test.cc b/tensorflow/lite/delegates/flex/util_test.cc
@@ -115,6 +115,7 @@ TEST(UtilTest, TypeConversionsFromTFLite) {
   EXPECT_EQ(TF_INT32, GetTensorFlowDataType(kTfLiteInt32));
   EXPECT_EQ(TF_UINT8, GetTensorFlowDataType(kTfLiteUInt8));
   EXPECT_EQ(TF_INT64, GetTensorFlowDataType(kTfLiteInt64));
+  EXPECT_EQ(TF_UINT64, GetTensorFlowDataType(kTfLiteUInt64));
   EXPECT_EQ(TF_COMPLEX64, GetTensorFlowDataType(kTfLiteComplex64));
   EXPECT_EQ(TF_COMPLEX128, GetTensorFlowDataType(kTfLiteComplex128));
   EXPECT_EQ(TF_STRING, GetTensorFlowDataType(kTfLiteString));
@@ -129,6 +130,7 @@ TEST(UtilTest, TypeConversionsFromTensorFlow) {
   EXPECT_EQ(kTfLiteInt32, GetTensorFlowLiteType(TF_INT32));
   EXPECT_EQ(kTfLiteUInt8, GetTensorFlowLiteType(TF_UINT8));
   EXPECT_EQ(kTfLiteInt64, GetTensorFlowLiteType(TF_INT64));
+  EXPECT_EQ(kTfLiteUInt64, GetTensorFlowLiteType(TF_UINT64));
   EXPECT_EQ(kTfLiteComplex64, GetTensorFlowLiteType(TF_COMPLEX64));
   EXPECT_EQ(kTfLiteComplex128, GetTensorFlowLiteType(TF_COMPLEX128));
   EXPECT_EQ(kTfLiteString, GetTensorFlowLiteType(TF_STRING));
diff --git a/tensorflow/lite/experimental/objc/sources/TFLInterpreter.mm b/tensorflow/lite/experimental/objc/sources/TFLInterpreter.mm
@@ -421,8 +421,9 @@ - (TFLTensorDataType)tensorDataTypeFromCTensorType:(TfLiteType)cTensorType {
     case kTfLiteString:
     case kTfLiteComplex64:
     case kTfLiteComplex128:
-      // kTfLiteString, kTfLiteComplex64 and kTfLiteComplex128 are not supported in TensorFlow Lite
-      // Objc API.
+    case kTfLiteUInt64:
+      // kTfLiteString, kTfLiteUInt64, kTfLiteComplex64 and kTfLiteComplex128 are not supported in
+      // TensorFlow Lite Objc API.
       return TFLTensorDataTypeNoType;
   }
 }
diff --git a/tensorflow/lite/experimental/writer/enum_mapping.h b/tensorflow/lite/experimental/writer/enum_mapping.h
@@ -74,6 +74,8 @@ inline TensorType TfLiteTypeToSchemaType(TfLiteType type) {
       return TensorType_INT8;
     case kTfLiteInt64:
       return TensorType_INT64;
+    case kTfLiteUInt64:
+      return TensorType_UINT64;
     case kTfLiteString:
       return TensorType_STRING;
     case kTfLiteBool:
diff --git a/tensorflow/lite/kernels/kernel_util.cc b/tensorflow/lite/kernels/kernel_util.cc
@@ -460,6 +460,9 @@ int TfLiteTypeGetSize(TfLiteType type) {
     case kTfLiteInt64:
       TF_LITE_ASSERT_EQ(sizeof(int64_t), 8);
       return 8;
+    case kTfLiteUInt64:
+      TF_LITE_ASSERT_EQ(sizeof(uint64_t), 8);
+      return 8;
     case kTfLiteFloat64:
       TF_LITE_ASSERT_EQ(sizeof(double), 8);
       return 8;
diff --git a/tensorflow/lite/micro/memory_helpers.cc b/tensorflow/lite/micro/memory_helpers.cc
@@ -66,6 +66,9 @@ TfLiteStatus TfLiteTypeSizeOf(TfLiteType type, size_t* size) {
     case kTfLiteInt64:
       *size = sizeof(int64_t);
       break;
+    case kTfLiteUInt64:
+      *size = sizeof(uint64_t);
+      break;
     case kTfLiteBool:
       *size = sizeof(bool);
       break;
diff --git a/tensorflow/lite/micro/memory_helpers_test.cc b/tensorflow/lite/micro/memory_helpers_test.cc
@@ -139,6 +139,10 @@ TF_LITE_MICRO_TEST(TestTypeSizeOf) {
                           tflite::TfLiteTypeSizeOf(kTfLiteInt64, &size));
   TF_LITE_MICRO_EXPECT_EQ(sizeof(int64_t), size);
 
+  TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk,
+                          tflite::TfLiteTypeSizeOf(kTfLiteUInt64, &size));
+  TF_LITE_MICRO_EXPECT_EQ(sizeof(uint64_t), size);
+
   TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk,
                           tflite::TfLiteTypeSizeOf(kTfLiteBool, &size));
   TF_LITE_MICRO_EXPECT_EQ(sizeof(bool), size);
diff --git a/tensorflow/lite/micro/micro_interpreter.cc b/tensorflow/lite/micro/micro_interpreter.cc
@@ -192,6 +192,9 @@ void MicroInterpreter::CorrectTensorEndianness(TfLiteEvalTensor* tensorCorr) {
     case TfLiteType::kTfLiteInt64:
       CorrectTensorDataEndianness(tensorCorr->data.i64, tensorSize);
       break;
+    case TfLiteType::kTfLiteUInt64:
+      CorrectTensorDataEndianness(tensorCorr->data.u64, tensorSize);
+      break;
     case TfLiteType::kTfLiteInt32:
       CorrectTensorDataEndianness(tensorCorr->data.i32, tensorSize);
       break;
diff --git a/tensorflow/lite/optional_debug_tools.cc b/tensorflow/lite/optional_debug_tools.cc
@@ -50,6 +50,8 @@ const char* TensorTypeName(TfLiteType type) {
       return "kTfLiteInt8";
     case kTfLiteInt64:
       return "kTfLiteInt64";
+    case kTfLiteUInt64:
+      return "kTfLiteUInt64";
     case kTfLiteString:
       return "kTfLiteString";
     case kTfLiteBool:
diff --git a/tensorflow/lite/portable_type_to_tflitetype.h b/tensorflow/lite/portable_type_to_tflitetype.h
@@ -69,6 +69,7 @@ MATCH_TYPE_AND_TFLITE_TYPE(std::complex<float>, kTfLiteComplex64);
 MATCH_TYPE_AND_TFLITE_TYPE(std::complex<double>, kTfLiteComplex128);
 MATCH_TYPE_AND_TFLITE_TYPE(TfLiteFloat16, kTfLiteFloat16);
 MATCH_TYPE_AND_TFLITE_TYPE(double, kTfLiteFloat64);
+MATCH_TYPE_AND_TFLITE_TYPE(uint64_t, kTfLiteUInt64);
 
 }  // namespace tflite
 #endif  // TENSORFLOW_LITE_PORTABLE_TYPE_TO_TFLITETYPE_H_
diff --git a/tensorflow/lite/python/interpreter_wrapper/numpy.cc b/tensorflow/lite/python/interpreter_wrapper/numpy.cc
@@ -50,6 +50,8 @@ int TfLiteTypeToPyArrayType(TfLiteType tf_lite_type) {
       return NPY_INT8;
     case kTfLiteInt64:
       return NPY_INT64;
+    case kTfLiteUInt64:
+      return NPY_UINT64;
     case kTfLiteString:
       return NPY_STRING;
     case kTfLiteBool:
diff --git a/tensorflow/lite/python/optimize/calibration_wrapper.cc b/tensorflow/lite/python/optimize/calibration_wrapper.cc
@@ -79,6 +79,8 @@ inline TensorType TfLiteTypeToSchemaType(TfLiteType type) {
       return TensorType_INT8;
     case kTfLiteInt64:
       return TensorType_INT64;
+    case kTfLiteUInt64:
+      return TensorType_UINT64;
     case kTfLiteString:
       return TensorType_STRING;
     case kTfLiteBool:
diff --git a/tensorflow/lite/python/util.py b/tensorflow/lite/python/util.py
@@ -56,6 +56,7 @@
     dtypes.int32: _types_pb2.INT32,
     dtypes.uint8: _types_pb2.QUANTIZED_UINT8,
     dtypes.int64: _types_pb2.INT64,
+    dtypes.uint64: _types_pb2.UINT64,
     dtypes.string: _types_pb2.STRING,
     dtypes.bool: _types_pb2.BOOL,
     dtypes.int16: _types_pb2.QUANTIZED_INT16,
diff --git a/tensorflow/lite/schema/schema.fbs b/tensorflow/lite/schema/schema.fbs
@@ -44,6 +44,7 @@ enum TensorType : byte {
   INT8 = 9,
   FLOAT64 = 10,
   COMPLEX128 = 11,
+  UINT64 = 12,
 }
 
 // Custom quantization parameters for experimenting with new quantization
diff --git a/tensorflow/lite/schema/schema_generated.h b/tensorflow/lite/schema/schema_generated.h
@@ -395,11 +395,12 @@ enum TensorType {
   TensorType_INT8 = 9,
   TensorType_FLOAT64 = 10,
   TensorType_COMPLEX128 = 11,
+  TensorType_UINT64 = 12,
   TensorType_MIN = TensorType_FLOAT32,
-  TensorType_MAX = TensorType_COMPLEX128
+  TensorType_MAX = TensorType_UINT64
 };
 
-inline const TensorType (&EnumValuesTensorType())[12] {
+inline const TensorType (&EnumValuesTensorType())[13] {
   static const TensorType values[] = {
     TensorType_FLOAT32,
     TensorType_FLOAT16,
@@ -412,13 +413,14 @@ inline const TensorType (&EnumValuesTensorType())[12] {
     TensorType_COMPLEX64,
     TensorType_INT8,
     TensorType_FLOAT64,
-    TensorType_COMPLEX128
+    TensorType_COMPLEX128,
+    TensorType_UINT64
   };
   return values;
 }
 
 inline const char * const *EnumNamesTensorType() {
-  static const char * const names[13] = {
+  static const char * const names[14] = {
     "FLOAT32",
     "FLOAT16",
     "INT32",
@@ -431,13 +433,14 @@ inline const char * const *EnumNamesTensorType() {
     "INT8",
     "FLOAT64",
     "COMPLEX128",
+    "UINT64",
     nullptr
   };
   return names;
 }
 
 inline const char *EnumNameTensorType(TensorType e) {
-  if (flatbuffers::IsOutRange(e, TensorType_FLOAT32, TensorType_COMPLEX128)) return "";
+  if (flatbuffers::IsOutRange(e, TensorType_FLOAT32, TensorType_UINT64)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesTensorType()[index];
 }
diff --git a/tensorflow/lite/testing/split.h b/tensorflow/lite/testing/split.h
@@ -52,6 +52,7 @@ template <>
 inline std::vector<int> Split(const string& s, const string& delimiter) {
   std::vector<int> fields;
   for (const auto& p : SplitToPos(s, delimiter)) {
+    // NOLINTNEXTLINE(runtime/deprecated_fn)
     fields.push_back(strtol(s.data() + p.first, nullptr, 10));
   }
   return fields;
@@ -61,11 +62,22 @@ template <>
 inline std::vector<int64_t> Split(const string& s, const string& delimiter) {
   std::vector<int64_t> fields;
   for (const auto& p : SplitToPos(s, delimiter)) {
+    // NOLINTNEXTLINE(runtime/deprecated_fn)
     fields.push_back(strtoll(s.data() + p.first, nullptr, 10));
   }
   return fields;
 }
 
+template <>
+inline std::vector<uint64_t> Split(const string& s, const string& delimiter) {
+  std::vector<uint64_t> fields;
+  for (const auto& p : SplitToPos(s, delimiter)) {
+    // NOLINTNEXTLINE(runtime/deprecated_fn)
+    fields.push_back(strtoull(s.data() + p.first, nullptr, 10));
+  }
+  return fields;
+}
+
 template <>
 inline std::vector<float> Split(const string& s, const string& delimiter) {
   std::vector<float> fields;
@@ -79,6 +91,7 @@ template <>
 inline std::vector<uint8_t> Split(const string& s, const string& delimiter) {
   std::vector<uint8_t> fields;
   for (const auto& p : SplitToPos(s, delimiter)) {
+    // NOLINTNEXTLINE(runtime/deprecated_fn)
     fields.push_back(strtol(s.data() + p.first, nullptr, 10));
   }
   return fields;
@@ -88,6 +101,7 @@ template <>
 inline std::vector<int8_t> Split(const string& s, const string& delimiter) {
   std::vector<int8_t> fields;
   for (const auto& p : SplitToPos(s, delimiter)) {
+    // NOLINTNEXTLINE(runtime/deprecated_fn)
     fields.push_back(strtol(s.data() + p.first, nullptr, 10));
   }
   return fields;
@@ -97,6 +111,7 @@ template <>
 inline std::vector<int16_t> Split(const string& s, const string& delimiter) {
   std::vector<int16_t> fields;
   for (const auto& p : SplitToPos(s, delimiter)) {
+    // NOLINTNEXTLINE(runtime/deprecated_fn)
     fields.push_back(strtol(s.data() + p.first, nullptr, 10));
   }
   return fields;
@@ -106,8 +121,9 @@ template <>
 inline std::vector<bool> Split(const string& s, const string& delimiter) {
   std::vector<bool> fields;
   for (const auto& p : SplitToPos(s, delimiter)) {
-    fields.push_back(
-        static_cast<bool>(strtol(s.data() + p.first, nullptr, 10)));
+    // NOLINTNEXTLINE(runtime/deprecated_fn)
+    bool val = static_cast<bool>(strtol(s.data() + p.first, nullptr, 10));
+    fields.push_back(val);
   }
   return fields;
 }
diff --git a/tensorflow/lite/testing/tflite_driver.cc b/tensorflow/lite/testing/tflite_driver.cc
@@ -325,6 +325,8 @@ bool TfLiteDriver::DataExpectation::Check(bool verbose,
       return TypedCheck<int32_t, float>(verbose, tensor);
     case kTfLiteInt64:
       return TypedCheck<int64_t, float>(verbose, tensor);
+    case kTfLiteUInt64:
+      return TypedCheck<uint64_t, float>(verbose, tensor);
     case kTfLiteUInt8:
       return TypedCheck<uint8_t, float>(verbose, tensor);
     case kTfLiteInt8:
@@ -477,6 +479,12 @@ void TfLiteDriver::SetInput(int id, const string& csv_values) {
       SetTensorData(values, tensor->data.raw);
       break;
     }
+    case kTfLiteUInt64: {
+      const auto& values = testing::Split<uint64_t>(csv_values, ",");
+      if (!CheckSizes<uint64_t>(tensor->bytes, values.size())) return;
+      SetTensorData(values, tensor->data.raw);
+      break;
+    }
     case kTfLiteUInt8: {
       const auto& values = testing::Split<uint8_t>(csv_values, ",");
       if (!CheckSizes<uint8_t>(tensor->bytes, values.size())) return;
@@ -554,6 +562,9 @@ void TfLiteDriver::SetExpectation(int id, const string& csv_values) {
     case kTfLiteInt64:
       expected_output_[id]->SetData<int64_t>(csv_values);
       break;
+    case kTfLiteUInt64:
+      expected_output_[id]->SetData<uint64_t>(csv_values);
+      break;
     case kTfLiteUInt8:
       expected_output_[id]->SetData<uint8_t>(csv_values);
       break;
@@ -653,6 +664,8 @@ string TfLiteDriver::ReadOutput(int id) {
       return JoinDefault(tensor->data.i32, num_elements, ",");
     case kTfLiteInt64:
       return JoinDefault(tensor->data.i64, num_elements, ",");
+    case kTfLiteUInt64:
+      return JoinDefault(tensor->data.u64, num_elements, ",");
     case kTfLiteUInt8:
       return Join(tensor->data.uint8, num_elements, ",");
     case kTfLiteInt8:
diff --git a/tensorflow/lite/toco/tflite/operator.cc b/tensorflow/lite/toco/tflite/operator.cc
@@ -49,6 +49,7 @@ ::tflite::TensorType GetTensorType(const ArrayDataType type) {
       {ArrayDataType::kInt16, ::tflite::TensorType_INT16},
       {ArrayDataType::kInt32, ::tflite::TensorType_INT32},
       {ArrayDataType::kInt64, ::tflite::TensorType_INT64},
+      {ArrayDataType::kUint64, ::tflite::TensorType_UINT64},
       {ArrayDataType::kString, ::tflite::TensorType_STRING},
       {ArrayDataType::kComplex64, ::tflite::TensorType_COMPLEX64},
       {ArrayDataType::kComplex128, ::tflite::TensorType_COMPLEX128},
diff --git a/tensorflow/lite/toco/tooling_util.cc b/tensorflow/lite/toco/tooling_util.cc
@@ -2309,6 +2309,8 @@ ArrayDataType ConvertIODataTypeToArrayDataType(IODataType type) {
       return ArrayDataType::kInt32;
     case INT64:
       return ArrayDataType::kInt64;
+    case UINT64:
+      return ArrayDataType::kUint64;
     case BOOL:
       return ArrayDataType::kBool;
     case STRING:
diff --git a/tensorflow/lite/toco/types.proto b/tensorflow/lite/toco/types.proto
diff --git a/tensorflow/lite/tools/benchmark/experimental/c/c_api_types.h b/tensorflow/lite/tools/benchmark/experimental/c/c_api_types.h
diff --git a/tensorflow/lite/tools/verifier.cc b/tensorflow/lite/tools/verifier.cc
diff --git a/tensorflow/lite/util.cc b/tensorflow/lite/util.cc

Original file line number	Diff line number	Diff line change
`@@ -57,6 +57,8 @@ mlir::Type ConvertElementType(tflite::TensorType type, mlir::Builder builder) {`
`57`	`57`	`return mlir::ComplexType::get(builder.getF64Type());`
`58`	`58`	`case tflite::TensorType_INT8:`
`59`	`59`	`return builder.getIntegerType(8);`
	`60`	`+ case tflite::TensorType_UINT64:`
	`61`	`+ return builder.getIntegerType(64, /isSigned=/false);`
`60`	`62`	`}`
`61`	`63`	`}`
`62`	`64`
`@@ -86,6 +88,8 @@ tensorflow::DataType TflTypeToTfType(tflite::TensorType type) {`
`86`	`88`	`return tensorflow::DT_STRING;`
`87`	`89`	`case tflite::TensorType_UINT8:`
`88`	`90`	`return tensorflow::DT_UINT8;`
	`91`	`+ case tflite::TensorType_UINT64:`
	`92`	`+ return tensorflow::DT_UINT64;`
`89`	`93`	`}`
`90`	`94`	`}`
`91`	`95`
Original file line number	Diff line number	Diff line change
`@@ -421,8 +421,9 @@ - (TFLTensorDataType)tensorDataTypeFromCTensorType:(TfLiteType)cTensorType {`
`421`	`421`	`case kTfLiteString:`
`422`	`422`	`case kTfLiteComplex64:`
`423`	`423`	`case kTfLiteComplex128:`
`424`		`- // kTfLiteString, kTfLiteComplex64 and kTfLiteComplex128 are not supported in TensorFlow Lite`
`425`		`- // Objc API.`
	`424`	`+ case kTfLiteUInt64:`
	`425`	`+ // kTfLiteString, kTfLiteUInt64, kTfLiteComplex64 and kTfLiteComplex128 are not supported in`
	`426`	`+ // TensorFlow Lite Objc API.`
`426`	`427`	`return TFLTensorDataTypeNoType;`
`427`	`428`	`}`
`428`	`429`	`}`