remove opt-out for fbcode/deeplearning/trt in lint engine (#68)

Summary:
Pull Request resolved: https://github.com/pytorch/fx2trt/pull/68

fbcode/deeplearning/trt/ is opted out of Black lint engine, removing opt-out (opting in) will show Black lint suggestions when running `arc lint`.

Applies Black lint suggestions/formatting to fbcode/deeplearning/trt/*

Reviewed By: yuhc

Differential Revision: D36128102

fbshipit-source-id: a34014dbf4465ac9a0e86d281a0dcbde097584aa

Author: alexbeloi

fx/converter_registry.py

@@ -12,7 +12,7 @@ def tensorrt_converter(
     key: Target,
     no_implicit_batch_dim: bool = False,
     no_explicit_batch_dim: bool = False,
-    enabled: bool = True
+    enabled: bool = True,
 ) -> Callable[[Any], Any]:
     def register_converter(converter):
         CONVERTERS[key] = converter

fx/converters/acc_ops_converters.py

@@ -7,9 +7,11 @@
 
 from .converter_utils import mark_as_int8_layer
 
-def common_activation(network, mod, input_val, activation_type, activation_dyn_range_fn, layer_name):
-    layer = network.add_activation(
-        input=input_val, type=activation_type)
+
+def common_activation(
+    network, mod, input_val, activation_type, activation_dyn_range_fn, layer_name
+):
+    layer = network.add_activation(input=input_val, type=activation_type)
     layer.name = layer_name
 
     if input_val.dynamic_range:
@@ -27,28 +29,47 @@ def relu(network, submod, args, kwargs, layer_name):
     input_val = kwargs["input"]
 
     if not isinstance(input_val, trt.tensorrt.ITensor):
-        raise RuntimeError(f"ReLU received input {input_val} that is not part "
-                           "of the TensorRT region!")
+        raise RuntimeError(
+            f"ReLU received input {input_val} that is not part "
+            "of the TensorRT region!"
+        )
 
     def activation_dyn_range_fn(dyn_range):
         return max(0, dyn_range[0]), max(0, dyn_range[1])
 
-    return common_activation(network, submod, input_val, trt.ActivationType.RELU, activation_dyn_range_fn, layer_name)
+    return common_activation(
+        network,
+        submod,
+        input_val,
+        trt.ActivationType.RELU,
+        activation_dyn_range_fn,
+        layer_name,
+    )
 
 
 @tensorrt_converter(torch.nn.modules.activation.Sigmoid)
 def sigmoid(network, submod, args, kwargs, layer_name):
     # args/kwargs should have already been normalized to kwargs
     assert len(args) == 0
-    input_val = kwargs['input']
+    input_val = kwargs["input"]
 
     if not isinstance(input_val, trt.tensorrt.ITensor):
-        raise RuntimeError(f'Sigmoid received input {input_val} that is not part '
-                           'of the TensorRT region!')
+        raise RuntimeError(
+            f"Sigmoid received input {input_val} that is not part "
+            "of the TensorRT region!"
+        )
 
     def activation_dyn_range_fn(dyn_range):
         def sigmoid_fn(x):
             return 1 / (1 + np.exp(-x))
+
         return sigmoid_fn(dyn_range[0]), sigmoid_fn(dyn_range[1])
 
-    return common_activation(network, submod, input_val, trt.ActivationType.SIGMOID, activation_dyn_range_fn, layer_name)
+    return common_activation(
+        network,
+        submod,
+        input_val,
+        trt.ActivationType.SIGMOID,
+        activation_dyn_range_fn,
+        layer_name,
+    )

fx/converters/activation.py

@@ -8,21 +8,28 @@
     extend_mod_attr_to_tuple,
 )
 
+
 @tensorrt_converter(torch.nn.modules.pooling.AdaptiveAvgPool2d)
 def adaptive_avgpool2d(network, submod, args, kwargs, name):
     # args/kwargs should have already been normalized to kwargs
     assert len(args) == 0
     input_val = kwargs["input"]
 
     if not isinstance(input_val, trt.tensorrt.ITensor):
-        raise RuntimeError(f"AdaptiveAvgPool2d received input {input_val} that is not part "
-                           "of the TensorRT region!")
+        raise RuntimeError(
+            f"AdaptiveAvgPool2d received input {input_val} that is not part "
+            "of the TensorRT region!"
+        )
 
     output_size = extend_mod_attr_to_tuple(submod, "output_size", 2)
-    stride = (input_val.shape[-2] // output_size[-2], input_val.shape[-1] // output_size[-1])
+    stride = (
+        input_val.shape[-2] // output_size[-2],
+        input_val.shape[-1] // output_size[-1],
+    )
     kernel_size = stride
     layer = network.add_pooling(
-        input=input_val, type=trt.PoolingType.AVERAGE, window_size=kernel_size)
+        input=input_val, type=trt.PoolingType.AVERAGE, window_size=kernel_size
+    )
     layer.stride = stride
     layer.name = name
 

fx/converters/adaptive_avgpool.py

@@ -7,6 +7,7 @@
 
 from .converter_utils import get_dyn_range, mark_as_int8_layer
 
+
 @tensorrt_converter(operator.add)
 @tensorrt_converter(torch.add)
 def add(network, target, args, kwargs, layer_name):
@@ -20,7 +21,9 @@ def add(network, target, args, kwargs, layer_name):
         assert kwargs["alpha"] == 1
 
     if not all(isinstance(arg, trt.tensorrt.ITensor) for arg in [lhs_val, rhs_val]):
-        raise RuntimeError("add() received an input that is not part of the TensorRT region!")
+        raise RuntimeError(
+            "add() received an input that is not part of the TensorRT region!"
+        )
 
     layer = network.add_elementwise(lhs_val, rhs_val, trt.ElementWiseOperation.SUM)
     layer.name = layer_name
@@ -33,7 +36,9 @@ def quantized_add(network, target, args, kwargs, layer_name):
     lhs_val, rhs_val = kwargs["qa"], kwargs["qb"]
 
     if not all(isinstance(i, trt.tensorrt.ITensor) for i in [lhs_val, rhs_val]):
-        raise RuntimeError('Quantized add received an input that is not part of the TensorRT region!')
+        raise RuntimeError(
+            "Quantized add received an input that is not part of the TensorRT region!"
+        )
 
     layer = network.add_elementwise(lhs_val, rhs_val, trt.ElementWiseOperation.SUM)
     layer.name = layer_name
@@ -48,15 +53,18 @@ def quantized_add_relu(network, submod, args, kwargs, layer_name):
     lhs_val, rhs_val = kwargs["qa"], kwargs["qb"]
 
     if not all(isinstance(i, trt.tensorrt.ITensor) for i in [lhs_val, rhs_val]):
-        raise RuntimeError('Quantized add_relu received an input that is not part of the TensorRT region!')
+        raise RuntimeError(
+            "Quantized add_relu received an input that is not part of the TensorRT region!"
+        )
 
     layer = network.add_elementwise(lhs_val, rhs_val, trt.ElementWiseOperation.SUM)
     layer.name = f"{layer_name}_add"
     dyn_range = get_dyn_range(kwargs["scale"], kwargs["zero_point"], torch.quint8)
     mark_as_int8_layer(layer, dyn_range)
 
     layer = network.add_activation(
-        input=layer.get_output(0), type=trt.ActivationType.RELU)
+        input=layer.get_output(0), type=trt.ActivationType.RELU
+    )
     layer.name = f"{layer_name}_relu"
     mark_as_int8_layer(layer, dyn_range)
 

fx/converters/add.py

@@ -11,33 +11,34 @@
     get_dyn_range,
 )
 
+
 def common_batchnorm(network, mod, input_val, layer_name, is_quantized):
-    scale = to_numpy(mod.weight) / np.sqrt(
-        to_numpy(mod.running_var) + mod.eps
-    )
-    bias = (
-        to_numpy(mod.bias)
-        - to_numpy(mod.running_mean) * scale
-    )
+    scale = to_numpy(mod.weight) / np.sqrt(to_numpy(mod.running_var) + mod.eps)
+    bias = to_numpy(mod.bias) - to_numpy(mod.running_mean) * scale
     power = np.ones_like(scale)
 
     layer = network.add_scale(input_val, trt.ScaleMode.CHANNEL, bias, scale, power)
     layer.name = layer_name
 
     if is_quantized:
-        mark_as_int8_layer(layer, get_dyn_range(mod.scale, mod.zero_point, torch.quint8))
+        mark_as_int8_layer(
+            layer, get_dyn_range(mod.scale, mod.zero_point, torch.quint8)
+        )
 
     return layer.get_output(0)
 
+
 @tensorrt_converter(torch.nn.modules.batchnorm.BatchNorm2d)
 def batchnorm2d(network, submod, args, kwargs, layer_name):
     # args/kwargs should have already been normalized to kwargs
     assert len(args) == 0
     input_val = kwargs["input"]
 
     if not isinstance(input_val, trt.tensorrt.ITensor):
-        raise RuntimeError(f"BatchNorm2d received input {input_val} that is not part "
-                           "of the TensorRT region!")
+        raise RuntimeError(
+            f"BatchNorm2d received input {input_val} that is not part "
+            "of the TensorRT region!"
+        )
 
     return common_batchnorm(network, submod, input_val, layer_name, is_quantized=False)
 
@@ -47,7 +48,9 @@ def quantized_batchnorm2d(network, submod, args, kwargs, layer_name):
     input_val = args[0]
 
     if not isinstance(input_val, trt.tensorrt.ITensor):
-        raise RuntimeError(f'Quantized BatchNorm2d received input {input_val} that is not part '
-                           'of the TensorRT region!')
+        raise RuntimeError(
+            f"Quantized BatchNorm2d received input {input_val} that is not part "
+            "of the TensorRT region!"
+        )
 
     return common_batchnorm(network, submod, input_val, layer_name, is_quantized=True)