This is an automated email from the ASF dual-hosted git repository.
zhaowu pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-tvm.git
The following commit(s) were added to refs/heads/master by this push:
new 3e3ccce Factor out import of common tflite.Operator in tflite
frontend. (#5355)
3e3ccce is described below
commit 3e3ccce1135c25dd1d99dc7c2b8ff589c93ee7ea
Author: Ramana Radhakrishnan <ramana.radhakrish...@arm.com>
AuthorDate: Wed Apr 22 07:09:11 2020 +0100
Factor out import of common tflite.Operator in tflite frontend. (#5355)
* Restructure imports in tflite frontend.
These python modules are needed for every tflite file parsed.
Factorize out imports of the common most ones.
Now that the import of operator is common, asserts can be commonized.
Loses 473 lines of duplication.
* Only restrict to tflite.Operator
---
python/tvm/relay/frontend/tflite.py | 156 ++----------------------------------
1 file changed, 5 insertions(+), 151 deletions(-)
diff --git a/python/tvm/relay/frontend/tflite.py
b/python/tvm/relay/frontend/tflite.py
index d489bd3..a2e0904 100644
--- a/python/tvm/relay/frontend/tflite.py
+++ b/python/tvm/relay/frontend/tflite.py
@@ -159,7 +159,12 @@ class OperatorConverter(object):
op = self.subgraph.Operators(op_idx)
op_code_str = self.get_op_code_str(op)
output_tensors = self.get_output_tensors(op)
+ try:
+ from tflite.Operator import Operator
+ except ImportError:
+ raise ImportError("The tflite package must be installed")
+ assert isinstance(op, Operator)
ret = self.convert_map[op_code_str](op)
if len(output_tensors) == 1:
@@ -288,12 +293,6 @@ class OperatorConverter(object):
def is_quantized(self, op):
"""Check if an input tensor is quantized."""
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
-
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
first_tensor = input_tensors[0]
return first_tensor.qnn_params is not None
@@ -335,12 +334,10 @@ class OperatorConverter(object):
"""Convert TFLite reshape"""
try:
from tflite.BuiltinOptions import BuiltinOptions
- from tflite.Operator import Operator
from tflite.ReshapeOptions import ReshapeOptions
except ImportError:
raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert input_tensors, "input tensors should not be empty"
input_tensor = input_tensors[0]
@@ -368,7 +365,6 @@ class OperatorConverter(object):
"""Generic method to Convert TFLite RESIZE operators"""
try:
from tflite.BuiltinOptions import BuiltinOptions
- from tflite.Operator import Operator
from tflite.ResizeBilinearOptions import ResizeBilinearOptions
# ResizeNearestNeighborOptions was added in tflite v1.13
tflite_ver = 1120
@@ -378,7 +374,6 @@ class OperatorConverter(object):
except ImportError:
raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 2, "input tensors length should be 2"
@@ -421,14 +416,12 @@ class OperatorConverter(object):
def convert_l2_normalization(self, op):
"""Convert TFLite L2_NORMALIZATION """
try:
- from tflite.Operator import Operator
from tflite.BuiltinOptions import BuiltinOptions
from tflite.L2NormOptions import L2NormOptions
from tflite.ActivationFunctionType import ActivationFunctionType
except ImportError:
raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 1, "input tensors length should be 1"
input_tensor = input_tensors[0]
@@ -467,13 +460,11 @@ class OperatorConverter(object):
def convert_lrn(self, op):
"""Convert TFLite LOCAL_RESPONSE_NORMALIZATION """
try:
- from tflite.Operator import Operator
from tflite.BuiltinOptions import BuiltinOptions
from tflite.LocalResponseNormalizationOptions import
LocalResponseNormalizationOptions
except ImportError:
raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
if self.is_quantized(op):
raise tvm.error.OpNotImplemented(
'TFlite quantized LRN operator is not supported yet.')
@@ -503,12 +494,6 @@ class OperatorConverter(object):
def convert_logistic(self, op):
"""Convert TFLite LOGISTIC"""
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
-
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 1, "input tensors length should be 1"
@@ -529,12 +514,6 @@ class OperatorConverter(object):
def convert_softmax(self, op):
"""Convert TFLite softmax"""
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
-
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 1, "input tensors length should be 1"
@@ -564,12 +543,6 @@ class OperatorConverter(object):
def convert_tanh(self, op):
"""Convert TFLite TANH"""
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
-
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 1, "input tensors length should be 1"
@@ -581,12 +554,6 @@ class OperatorConverter(object):
def convert_relu(self, op):
"""Convert TFLite ReLU"""
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
-
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 1, "input tensors length should be 1"
@@ -598,12 +565,6 @@ class OperatorConverter(object):
def convert_hard_swish(self, op):
"""Convert TFLite Hard swish"""
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
-
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 1, "input tensors length should be 1"
input_tensor = input_tensors[0]
@@ -635,14 +596,12 @@ class OperatorConverter(object):
def convert_concatenation(self, op):
"""Convert TFLite concatenation"""
try:
- from tflite.Operator import Operator
from tflite.ConcatenationOptions import ConcatenationOptions
from tflite.BuiltinOptions import BuiltinOptions
from tflite.ActivationFunctionType import ActivationFunctionType
except ImportError:
raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) >= 1, "input tensors should greater than 1"
in_exprs = [self.get_expr(input_tensor.tensor_idx) for input_tensor in
input_tensors]
@@ -683,12 +642,6 @@ class OperatorConverter(object):
def _convert_unary_elemwise(self, relay_op, op):
"""Generic method to convert TFLite unary elemwise functions"""
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
-
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 1, "input tensors length should be 1"
@@ -784,12 +737,6 @@ class OperatorConverter(object):
def convert_elu(self, op):
"""Convert TFLite ELU"""
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
-
if self.is_quantized(op):
raise tvm.error.OpNotImplemented(
'TFlite quantized ELU operator is not supported yet.')
@@ -807,12 +754,6 @@ class OperatorConverter(object):
def convert_square(self, op):
"""Convert TFLite SQUARE"""
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
-
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 1, "input tensors length should be 1"
input_tensor = input_tensors[0]
@@ -834,7 +775,6 @@ class OperatorConverter(object):
def _convert_elemwise(self, relay_op, op):
"""Generic method to Convert TFLite elemwise"""
try:
- from tflite.Operator import Operator
from tflite.AddOptions import AddOptions
from tflite.SubOptions import SubOptions
from tflite.MulOptions import MulOptions
@@ -844,7 +784,6 @@ class OperatorConverter(object):
except ImportError:
raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 2, "input tensors length should be 2"
@@ -1025,12 +964,6 @@ class OperatorConverter(object):
def _convert_logical_binary(self, relay_op, op):
"""Generic method to convert logical binary ops"""
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
-
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 2, "input tensors length should be 2"
@@ -1052,12 +985,6 @@ class OperatorConverter(object):
def convert_zeros_like(self, op):
"""Convert TFLite ZEROS LIKE"""
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
-
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 1, "input tensors length should be 1"
@@ -1071,12 +998,10 @@ class OperatorConverter(object):
"""Generic method to Convert TFLite MEAN operators"""
try:
from tflite.BuiltinOptions import BuiltinOptions
- from tflite.Operator import Operator
from tflite.ReducerOptions import ReducerOptions
except ImportError:
raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 2, "input tensors length should be 2"
@@ -1135,7 +1060,6 @@ class OperatorConverter(object):
def convert_fully_connected(self, op):
"""Convert TFLite fully connected"""
try:
- from tflite.Operator import Operator
from tflite.FullyConnectedOptions import FullyConnectedOptions
from tflite.BuiltinOptions import BuiltinOptions
from tflite.TensorType import TensorType
@@ -1143,7 +1067,6 @@ class OperatorConverter(object):
except ImportError:
raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) >= 2, "input tensors length should be >= 2"
@@ -1238,12 +1161,10 @@ class OperatorConverter(object):
"""Convert TFLite squeeze"""
try:
from tflite.BuiltinOptions import BuiltinOptions
- from tflite.Operator import Operator
from tflite.SqueezeOptions import SqueezeOptions
except ImportError:
raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
output_tensors = self.get_output_tensors(op)
assert len(input_tensors) == 1, "input tensors length should be 1"
@@ -1287,14 +1208,12 @@ class OperatorConverter(object):
from tflite.BuiltinOptions import BuiltinOptions
from tflite.ActivationFunctionType import ActivationFunctionType
from tflite.TensorType import TensorType
- from tflite.Operator import Operator
from tflite.Conv2DOptions import Conv2DOptions
from tflite.DepthwiseConv2DOptions import DepthwiseConv2DOptions
from tflite.Padding import Padding
except ImportError:
raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) >= 2, "input tensors length should be >= 2"
@@ -1455,12 +1374,10 @@ class OperatorConverter(object):
"""split implementation."""
try:
from tflite.BuiltinOptions import BuiltinOptions
- from tflite.Operator import Operator
from tflite.SplitOptions import SplitOptions
except ImportError:
raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 2, "input tensors length should be == 2"
@@ -1490,12 +1407,6 @@ class OperatorConverter(object):
def convert_slice(self, op):
"""Convert TFLite SLICE"""
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
-
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 3, "input tensors length should be == 3"
input_tensor = input_tensors[0]
@@ -1519,12 +1430,6 @@ class OperatorConverter(object):
def convert_transpose(self, op):
"""transpose implementation."""
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
-
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 2, "input tensors length should be 2"
input_tensor = input_tensors[0]
@@ -1545,13 +1450,11 @@ class OperatorConverter(object):
def convert_cast(self, op):
"""Convert TFLite CAST"""
try:
- from tflite.Operator import Operator
from tflite.BuiltinOptions import BuiltinOptions
from tflite.CastOptions import CastOptions
except ImportError:
raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 1, "input tensors length should be 1"
input_tensor = input_tensors[0]
@@ -1569,12 +1472,6 @@ class OperatorConverter(object):
def convert_tile(self, op):
"""tile implementation."""
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
-
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 2, "input tensors length should be 2"
input_tensor = input_tensors[0]
@@ -1591,12 +1488,6 @@ class OperatorConverter(object):
def convert_topk_v2(self, op):
""" Convert TFLite TOPK_v2 """
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
-
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 2, "input tensors length should be 2"
input_tensor = input_tensors[0]
@@ -1612,13 +1503,11 @@ class OperatorConverter(object):
try:
from tflite.BuiltinOptions import BuiltinOptions
from tflite.ActivationFunctionType import ActivationFunctionType
- from tflite.Operator import Operator
from tflite.Pool2DOptions import Pool2DOptions
from tflite.Padding import Padding
except ImportError:
raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 1, "input tensors length should be 1"
input_tensor = input_tensors[0]
@@ -1689,12 +1578,6 @@ class OperatorConverter(object):
def convert_pad(self, op):
"""Convert TFLite PAD"""
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
-
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 2, "input tensors length should be 2"
@@ -1740,7 +1623,6 @@ class OperatorConverter(object):
def convert_mirror_pad(self, op):
"""Convert TFLite MIRROR_PAD"""
try:
- from tflite.Operator import Operator
from tflite.BuiltinOptions import BuiltinOptions
from tflite.MirrorPadOptions import MirrorPadOptions
except ImportError:
@@ -1751,7 +1633,6 @@ class OperatorConverter(object):
raise tvm.error.OpNotImplemented(
'TFlite quantized MIRROR_PAD operator is not supported yet.')
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 2, "input tensors length should be 2"
@@ -1779,12 +1660,10 @@ class OperatorConverter(object):
"""Convert TFLite pack"""
try:
from tflite.BuiltinOptions import BuiltinOptions
- from tflite.Operator import Operator
from tflite.PackOptions import PackOptions
except ImportError:
raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) >= 1, "input tensors should greater than 1"
in_exprs = [self.get_expr(input_tensor.tensor_idx) for input_tensor in
input_tensors]
@@ -1806,12 +1685,10 @@ class OperatorConverter(object):
"""Convert TFLite unpack"""
try:
from tflite.BuiltinOptions import BuiltinOptions
- from tflite.Operator import Operator
from tflite.UnpackOptions import UnpackOptions
except ImportError:
raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 1, "input tensors length should be 1"
input_tensor = input_tensors[0]
@@ -1848,12 +1725,7 @@ class OperatorConverter(object):
def convert_batch_to_space_nd(self, op):
"""batch_to_space_nd implementation."""
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 3, "input tensors length should be 3"
@@ -1901,12 +1773,6 @@ class OperatorConverter(object):
def convert_space_to_batch_nd(self, op):
"""space_to_batch_nd implementation."""
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
-
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 3, "input tensors length should be 3"
@@ -1960,12 +1826,10 @@ class OperatorConverter(object):
"""Convert TFLite DEPTH_TO_SPACE"""
try:
from tflite.BuiltinOptions import BuiltinOptions
- from tflite.Operator import Operator
from tflite.DepthToSpaceOptions import DepthToSpaceOptions
except ImportError:
raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 1, "input tensors length should be 1"
@@ -1985,12 +1849,10 @@ class OperatorConverter(object):
"""Convert TFLite SPACE_TO_DEPTH"""
try:
from tflite.BuiltinOptions import BuiltinOptions
- from tflite.Operator import Operator
from tflite.SpaceToDepthOptions import SpaceToDepthOptions
except ImportError:
raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 1, "input tensors length should be 1"
@@ -2008,12 +1870,6 @@ class OperatorConverter(object):
def convert_prelu(self, op):
"""Convert TFLite PReLU"""
- try:
- from tflite.Operator import Operator
- except ImportError:
- raise ImportError("The tflite package must be installed")
-
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 2, "input tensors length should be 2"
@@ -2033,13 +1889,11 @@ class OperatorConverter(object):
try:
from tflite.BuiltinOptions import BuiltinOptions
from tflite.TensorType import TensorType
- from tflite.Operator import Operator
from tflite.TransposeConvOptions import TransposeConvOptions
from tflite.Padding import Padding
except ImportError:
raise ImportError("The tflite package must be installed")
- assert isinstance(op, Operator)
input_tensors = self.get_input_tensors(op)
assert len(input_tensors) == 3, "input tensors length should be 3"
