Lint

Author: srkreddy1238

python/tvm/relax/frontend/tflite/tflite_frontend.py

@@ -57,9 +57,6 @@ def new_const(self, value, shape=None, dtype="float32", source_name=None):
         self.const_ctr += 1
         self.exprs[name] = relax.const(value, dtype)
         self.params[name] = (self.exprs[name], value)
-        #self.exprs[name] = relax.Var(
-        #    name_hint=name, struct_info=relax.TensorStructInfo(shape=shape, dtype=dtype)
-        #)
 
         return self.exprs[name]
 
@@ -610,7 +607,9 @@ def convert_qnn_fused_activation_function(
         if fused_activation_fn == ActivationFunctionType.RELU6:
             return relax.op.clip(expr, a_min=max(qmin, quantize(0)), a_max=min(qmax, quantize(6.0)))
         if fused_activation_fn == ActivationFunctionType.RELU_N1_TO_1:
-            return relax.op.clip(expr, a_min=max(qmin, quantize(-1.0)), a_max=min(qmax, quantize(1.0)))
+            return relax.op.clip(
+                expr, a_min=max(qmin, quantize(-1.0)), a_max=min(qmax, quantize(1.0))
+            )
         if fused_activation_fn == ActivationFunctionType.RELU:
             return relax.op.clip(expr, a_min=max(qmin, quantize(0.0)), a_max=qmax)
 
@@ -662,7 +661,10 @@ def convert_reshape(self, op):
                 target_expr = self.get_expr(shape_tensor.tensor_idx)
                 target_value, success = try_infer_value(
                     target_expr,
-                    parameters={k: tvm.runtime.tensor(np.array(v)) for k, v in self.exp_tab.params.items()},
+                    parameters={
+                        k: tvm.runtime.tensor(np.array(v)) for k, v in self.exp_tab.params.items()
+                    },
+
                 )
                 if success:
                     # convert to flattened list
@@ -1155,7 +1157,9 @@ def convert_relu_n1_to_1(self, op):
             qmin = float(tvm.tir.op.min_value(input_tensor_type_str).value)
             qmax = float(tvm.tir.op.max_value(input_tensor_type_str).value)
 
-            out = relax.op.clip(in_expr, a_min=max(qmin, quantize(-1.0)), a_max=min(qmax, quantize(1.0)))
+            out = relax.op.clip(
+                in_expr, a_min=max(qmin, quantize(-1.0)), a_max=min(qmax, quantize(1.0))
+            )
         else:
             out = relax.op.clip(in_expr, a_min=-1, a_max=1)
 
@@ -2910,7 +2914,9 @@ def convert_unidirectional_sequence_lstm(self, op):
             relax.op.const(input_forget_weights_default_values.tolist()), 1
         )
         input_cell_weights_default_values = self.get_tensor_value(input_cell_weights)
-        input_cell_weights_op = relax.op.split(_op.const(input_cell_weights_default_values.tolist()), 1)
+        input_cell_weights_op = relax.op.split(
+            _op.const(input_cell_weights_default_values.tolist()), 1
+        )
         weights_dict["w_inp"] = relax.op.concat(
             [
                 relax.op.squeeze(input_input_weights_op[0]),
@@ -2936,7 +2942,9 @@ def convert_unidirectional_sequence_lstm(self, op):
             relax.op.const(recurrent_forget_weights_values.tolist()), 1
         )
         recurrent_cell_weights_values = self.get_tensor_value(recurrent_cell_weights)
-        recurrent_cell_weights_op = relax.op.split(_op.const(recurrent_cell_weights_values.tolist()), 1)
+        recurrent_cell_weights_op = relax.op.split(
+            _op.const(recurrent_cell_weights_values.tolist()), 1
+        )
         weights_dict["w_hid"] = relax.op.concat(
             [
                 recurrent_input_weights_op[0],
@@ -3063,10 +3071,14 @@ def convert_batch_matmul(self, op):
             )
 
             a_broadcasted_shape = _fold_constant(
-                relax.op.concat([out_batch, relax.op.strided_slice(shape_a, [rank_a - 2], [rank_a])], 0)
+                relax.op.concat(
+                    [out_batch, relax.op.strided_slice(shape_a, [rank_a - 2], [rank_a])], 0
+                )
             )
             b_broadcasted_shape = _fold_constant(
-                relax.op.concat([out_batch, relax.op.strided_slice(shape_b, [rank_b - 2], [rank_b])], 0)
+                relax.op.concat(
+                    [out_batch, relax.op.strided_slice(shape_b, [rank_b - 2], [rank_b])], 0
+                )
             )
             if not tvm.ir.structural_equal(shape_a, a_broadcasted_shape):
                 input_a = relax.op.transform.broadcast_to(input_a, a_broadcasted_shape)
@@ -3574,7 +3586,9 @@ def convert_detection_postprocess(self, op):
         non_max_suppression_attrs["max_output_size"] = custom_options["max_detections"]
         non_max_suppression_attrs["invalid_to_bottom"] = False
 
-        ret = relax.op.vision.non_max_suppression(ret[0], ret[1], ret[1], **non_max_suppression_attrs)
+        ret = relax.op.vision.non_max_suppression(
+            ret[0], ret[1], ret[1], **non_max_suppression_attrs
+        )
         ret = relax.op.vision.get_valid_counts(ret, 0)
         valid_count = ret[0]
         # keep only the top 'max_detections' rows
@@ -4246,9 +4260,12 @@ def from_tflite(model, shape_dict=None, dtype_dict=None, op_converter=OperatorCo
             for model_input in model_inputs:
                 model_input_name = get_tensor_name(subgraph, model_input)
                 shape = _shape_dict[model_input_name] if model_input_name in _shape_dict else None
-                dtype = _dtype_dict[model_input_name] if model_input_name in _dtype_dict else "float32"
+                dtype = (
+                    _dtype_dict[model_input_name] if model_input_name in _dtype_dict else "float32"
+                )
                 input_var = relax.Var(
-                    name_hint=model_input_name, struct_info=relax.TensorStructInfo(shape=shape, dtype=dtype)
+                    name_hint=model_input_name,
+                    struct_info=relax.TensorStructInfo(shape=shape, dtype=dtype),
                 )
                 exp_tab.set_expr(model_input_name, input_var)
                 input_list.append(input_var)
@@ -4270,7 +4287,7 @@ def from_tflite(model, shape_dict=None, dtype_dict=None, op_converter=OperatorCo
         _, param_value_list = map(list, zip(*exp_tab.params.values()))
         func_attrs = {}
         func_attrs["num_input"] = len(input_list)
-        func_attrs["params"] = [ tvm.runtime.tensor(arr) for arr in param_value_list]
+        func_attrs["params"] = [tvm.runtime.tensor(arr) for arr in param_value_list]
         relax_mod["main"] = relax_mod["main"].with_attrs(func_attrs)
 
         return relax_mod

tests/python/relax/test_frontend_tflite.py

@@ -54,10 +54,9 @@ def _get_tflite_model(tflite_model_path, inputs_dict):
 
 
 def test_squeezenet():
-
     def get_model():
         inputs = {"Placeholder": ((1, 224, 224, 3), "float32")}
-        mod = _get_tflite_model("./squeezenet.tflite", inputs_dict=inputs)
+        mod = _get_tflite_model(os.environ["CI_TEST_INVENTORY"] + "/squeezenet.tflite", inputs_dict=inputs)
         return mod
 
     mod = get_model()
@@ -77,6 +76,5 @@ def get_model():
     print(tvm_output.shape)
 
 
-
 if __name__ == "__main__":
     test_squeezenet()