ai-edge-torch-nightly 0.1.dev202405131930__py3-none-any.whl

ai_edge_torch/convert/fx_passes/optimize_layout_transposes_pass/utils.py

@@ -0,0 +1,62 @@
+# Copyright 2024 The AI Edge Torch Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+from typing import Callable
+
+import torch
+import torch.ao.quantization.quantize_pt2e
+
+
+def tensor_to_nhwc(t: torch.Tensor):
+  return torch.ops.aten.permute(t.contiguous(), [0, 2, 3, 1]).contiguous()
+
+
+def tensor_to_nchw(t: torch.Tensor):
+  return torch.ops.aten.permute(t.contiguous(), [0, 3, 1, 2]).contiguous()
+
+
+def flatten_torch_op_overloads(op):
+  if isinstance(op, torch._ops.OpOverloadPacket):
+    return [getattr(op, overload) for overload in op.overloads()]
+  return [op]
+
+
+_TORCH_Q_OPS = [
+    torch.ops.quantized_decomposed.quantize_per_tensor.default,
+    torch.ops.quantized_decomposed.quantize_per_tensor.tensor,
+    torch.ops.quantized_decomposed.quantize_per_tensor.tensor2,
+    torch.ops.quantized_decomposed.quantize_per_channel.default,
+]
+
+_TORCH_DQ_OPS = [
+    torch.ops.quantized_decomposed.dequantize_per_tensor.default,
+    torch.ops.quantized_decomposed.dequantize_per_tensor.tensor,
+    torch.ops.quantized_decomposed.dequantize_per_tensor.tensor2,
+    torch.ops.quantized_decomposed.dequantize_per_channel.default,
+]
+
+
+def is_q_node(node: torch.fx.Node):
+  return node.target in _TORCH_Q_OPS
+
+
+def is_dq_node(node: torch.fx.Node):
+  return node.target in _TORCH_DQ_OPS
+
+
+def get_paired_q_dq_ops(op: Callable) -> tuple[Callable, Callable]:
+  for q, dq in zip(_TORCH_Q_OPS, _TORCH_DQ_OPS):
+    if op in (q, dq):
+      return q, dq
+  raise AssertionError(f"{op} is not a Q/DQ op.")

ai_edge_torch/convert/test/__init__.py

@@ -0,0 +1,14 @@
+# Copyright 2024 The AI Edge Torch Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================

ai_edge_torch/convert/test/test_convert.py

@@ -0,0 +1,273 @@
+# Copyright 2024 The AI Edge Torch Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+
+import os
+import tempfile
+import unittest
+
+import torch
+import torchvision
+
+import ai_edge_torch
+from ai_edge_torch.convert import conversion_utils as cutils
+from ai_edge_torch.testing import model_coverage
+
+
+class TestConvert(unittest.TestCase):
+  """Tests conversion of various modules."""
+
+  def setUp(self):
+    torch.manual_seed(0)
+
+  def test_convert_add(self):
+    """Tests conversion of a simple Add module."""
+
+    class Add(torch.nn.Module):
+
+      def forward(self, a, b):
+        return a + b
+
+    args = (
+        torch.randn((5, 10)),
+        torch.randn((5, 10)),
+    )
+    torch_module = Add().eval()
+    edge_model = ai_edge_torch.convert(torch_module, args)
+
+    self.assertTrue(model_coverage.compare_tflite_torch(edge_model, torch_module, args))
+
+  def test_convert_dot_add(self):
+    class DotAdd(torch.nn.Module):
+      """Tests conversion of a matrix multiplication followed by an add."""
+
+      def forward(self, a, b, c):
+        return a @ b + c
+
+    args = (
+        torch.randn((5, 10)),
+        torch.randn((10, 5)),
+        torch.randn((5, 5)),
+    )
+    torch_module = DotAdd().eval()
+    edge_model = ai_edge_torch.convert(torch_module, args)
+
+    self.assertTrue(model_coverage.compare_tflite_torch(edge_model, torch_module, args))
+
+  def test_convert_resnet18(self):
+    args = (torch.randn(4, 3, 224, 224),)
+    torch_module = torchvision.models.resnet18().eval()
+    edge_model = ai_edge_torch.convert(torch_module, args)
+
+    self.assertTrue(model_coverage.compare_tflite_torch(edge_model, torch_module, args))
+
+  def test_signature_args_ordering(self):
+    """Tests conversion of a model with more than 10 arguments."""
+
+    class AddChainWith11Args(torch.nn.Module):
+
+      def forward(
+          self,
+          arg0: "f32[64]",
+          arg1: "f32[64]",
+          arg2: "f32[64]",
+          arg3: "f32[64]",
+          arg4: "f32[64]",
+          arg5: "f32[64]",
+          arg6: "f32[64]",
+          arg7: "f32[64]",
+          arg8: "f32[64]",
+          arg9: "f32[64]",
+          arg10: "f32[64]",
+      ):
+        add0 = torch.add(arg0, arg1)
+        add1 = torch.add(add0, arg2)
+        add2 = torch.add(add1, arg3)
+        add3 = torch.add(add2, arg4)
+        add4 = torch.add(add3, arg5)
+        add5 = torch.add(add4, arg6)
+        add6 = torch.add(add5, arg7)
+        add7 = torch.add(add6, arg8)
+        add8 = torch.add(add7, arg9)
+        add9 = torch.add(add8, arg10)
+        return add9
+
+    sample_input = lambda: (
+        torch.rand((64,), dtype=torch.float32),
+        torch.rand((64,), dtype=torch.float32),
+        torch.rand((64,), dtype=torch.float32),
+        torch.rand((64,), dtype=torch.float32),
+        torch.rand((64,), dtype=torch.float32),
+        torch.rand((64,), dtype=torch.float32),
+        torch.rand((64,), dtype=torch.float32),
+        torch.rand((64,), dtype=torch.float32),
+        torch.rand((64,), dtype=torch.float32),
+        torch.rand((64,), dtype=torch.float32),
+        torch.rand((64,), dtype=torch.float32),
+    )
+    torch_model = AddChainWith11Args().eval()
+    edge_model = ai_edge_torch.convert(torch_model, sample_input())
+
+    result = model_coverage.compare_tflite_torch(
+        edge_model, torch_model, sample_input, num_valid_inputs=10
+    )
+    self.assertTrue(result)
+
+  def test_multi_output_model(self):
+    """Tests conversion of a model that returns multiple outputs."""
+
+    class BasicAddModelWithMultipleOutputs(torch.nn.Module):
+
+      def forward(self, arg0, arg1):
+        add0 = arg0 + arg1
+        mul0 = arg0 * arg1
+        return add0, mul0
+
+    sample_input = (
+        torch.rand((64,), dtype=torch.float32),
+        torch.rand((64,), dtype=torch.float32),
+    )
+
+    torch_model = BasicAddModelWithMultipleOutputs().eval()
+    edge_model = ai_edge_torch.convert(torch_model, sample_input)
+
+    result = model_coverage.compare_tflite_torch(edge_model, torch_model, sample_input)
+    self.assertTrue(result)
+
+  def test_12_outputs_model(self):
+    """Tests conversion of a model that returns multiple outputs."""
+
+    class BasicAddModelWithMultipleOutputs(torch.nn.Module):
+
+      def forward(self, arg0, arg1):
+        add0 = arg0 + arg1
+        mul0 = arg0 * arg1
+        add1 = add0 + mul0
+        mul1 = add0 * mul0
+        add2 = add1 + mul1
+        mul2 = add1 * mul1
+        add3 = add2 + mul2
+        mul3 = add2 * mul2
+        add4 = add3 + mul3
+        mul4 = add3 * mul3
+        add5 = add4 + mul4
+        mul5 = add4 * mul4
+
+        return (
+            add0,
+            mul0,
+            add1,
+            mul1,
+            add2,
+            mul2,
+            add3,
+            mul3,
+            add4,
+            mul4,
+            add5,
+            mul5,
+        )
+
+    sample_input = (
+        torch.rand((64,), dtype=torch.float32),
+        torch.rand((64,), dtype=torch.float32),
+    )
+
+    torch_model = BasicAddModelWithMultipleOutputs().eval()
+    edge_model = ai_edge_torch.convert(torch_model, sample_input)
+
+    result = model_coverage.compare_tflite_torch(edge_model, torch_model, sample_input)
+    self.assertTrue(result)
+
+  def test_apply_tfl_backdoor_flags(self):
+    """Tests if _apply_tfl_backdoor_flags correctly sets the values in a Converter object."""
+
+    class MockConverterInternalObject:
+
+      def __init__(self):
+        self.subkey2 = "original_subvalue2"
+
+    class MockConverter:
+
+      def __init__(self):
+        self.key1 = "original_value1"
+        self.key2 = MockConverterInternalObject()
+
+    mock_converter = MockConverter()
+    flags = {"key1": "new_value1", "key2": {"subkey2": "new_subvalue2"}}
+    cutils._apply_tfl_backdoor_flags(mock_converter, flags)
+
+    self.assertTrue(flags["key1"], "new_value1")
+    self.assertTrue(flags["key2"]["subkey2"], "new_subvalue2")
+
+  @unittest.skip("https://b.corp.google.com/issues/331463544")
+  def test_convert_add_backdoor_flags(self):
+    """Tests conversion of an add module setting a tflite converter flag."""
+
+    class Add(torch.nn.Module):
+
+      def forward(self, a, b):
+        return a + b
+
+    args = (
+        torch.randn((5, 10)),
+        torch.randn((5, 10)),
+    )
+    torch_module = Add().eval()
+
+    with tempfile.TemporaryDirectory() as tmp_dir_path:
+      mlir_dump_path = os.path.join(
+          tmp_dir_path, "test_convert_add_backdoor_flags_mlir_dump"
+      )
+      ai_edge_torch.convert(
+          torch_module, args, _ai_edge_converter_flags={"mlir_dump_dir": mlir_dump_path}
+      )
+      self.assertTrue(os.path.isdir(mlir_dump_path))
+
+  def test_convert_model_with_dynamic_batch(self):
+    """
+    Test converting a simple model with dynamic batch size.
+    """
+
+    class SampleModel(torch.nn.Module):
+
+      def __init__(self):
+        super().__init__()
+        self.w = torch.ones((10, 10)) * 2.7
+
+      def forward(self, x, y):
+        return x + y + self.w
+
+    sample_input = (torch.randn(4, 3, 10, 10), torch.randn(4, 3, 10, 10))
+    batch = torch.export.Dim("batch")
+    dynamic_shapes = ({0: batch}, {0: batch})
+
+    model = SampleModel().eval()
+    edge_model = ai_edge_torch.convert(
+        model, sample_input, dynamic_shapes=dynamic_shapes
+    )
+
+    for batch_size in [2, 4, 10]:
+      validate_input = (
+          torch.randn(batch_size, 3, 10, 10),
+          torch.randn(batch_size, 3, 10, 10),
+      )
+      self.assertTrue(
+          model_coverage.compare_tflite_torch(edge_model, model, validate_input)
+      )
+
+
+if __name__ == "__main__":
+  unittest.main()

ai_edge_torch/convert/test/test_convert_composites.py

@@ -0,0 +1,171 @@
+# Copyright 2024 The AI Edge Torch Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+
+from typing import Callable
+import unittest
+
+import parameterized
+import torch
+
+import ai_edge_torch
+from ai_edge_torch.testing import model_coverage
+
+
+def _func_to_torch_module(func: Callable):
+  class TestModule(torch.nn.Module):
+
+    def __init__(self, func):
+      super().__init__()
+      self._func = func
+
+    def forward(self, *args, **kwargs):
+      return self._func(*args, **kwargs)
+
+  return TestModule(func).eval()
+
+
+class TestConvertComposites(unittest.TestCase):
+  """Tests conversion modules that are meant to be wrapped as composites."""
+
+  def test_convert_hardswish(self):
+    """Tests conversion of a HardSwish module."""
+
+    args = (torch.randn((5, 10)),)
+    torch_module = torch.nn.Hardswish().eval()
+    edge_model = ai_edge_torch.convert(torch_module, args)
+
+    self.assertTrue(model_coverage.compare_tflite_torch(edge_model, torch_module, args))
+
+  @parameterized.parameterized.expand(
+      [
+          # no padding, stride = 1
+          ([1, 3, 6, 6], [3, 3], [1, 1], [0, 0], False, True, None),
+          # add stride
+          ([1, 3, 6, 6], [3, 3], [2, 2], [0, 0], False, True, None),
+          # default values
+          ([1, 3, 6, 6], [3, 3]),
+          # add padding
+          ([1, 3, 6, 6], [3, 3], [1, 1], [1, 1], False, True, None),
+          # add different padding for different dims
+          ([1, 3, 6, 6], [3, 3], [1, 1], [0, 1], False, True, None),
+          # add both stride and padding
+          ([1, 3, 6, 6], [3, 3], [2, 2], [1, 1], False, True, None),
+          # count_include_pad = False
+          ([1, 3, 6, 6], [3, 3], [1, 1], [1, 1], False, False, None),
+          # ceil_mode = True
+          ([1, 3, 6, 6], [3, 3], [1, 1], [1, 1], True, True, None),
+          # set divisor_override
+          ([1, 3, 6, 6], [3, 3], [1, 1], 0, False, True, 6),
+          # padding set to one number
+          ([1, 3, 6, 6], [3, 3], [1, 1], 1, False, True, None),
+      ]
+  )
+  def test_convert_avg_pool2d(self, input_size, *args):
+    """Tests conversion of a module containing an avg_pool2d aten."""
+    torch_module = _func_to_torch_module(
+        lambda input_tensor: torch.ops.aten.avg_pool2d(input_tensor, *args)
+    )
+    tracing_args = (torch.randn(*input_size),)
+    edge_model = ai_edge_torch.convert(torch_module, tracing_args)
+
+    self.assertTrue(
+        model_coverage.compare_tflite_torch(edge_model, torch_module, tracing_args)
+    )
+
+  @parameterized.parameterized.expand(
+      [
+          # use scale_factor with align_corners=False
+          (
+              [1, 3, 10, 10],
+              dict(scale_factor=3.0, mode='bilinear', align_corners=False),
+          ),
+          # use scale_factor with align_corners=true
+          ([1, 3, 10, 10], dict(scale_factor=3.0, mode='bilinear', align_corners=True)),
+          # use size
+          ([1, 3, 10, 10], dict(size=[15, 20], mode='bilinear')),
+          # use size with align_corners=true
+          ([1, 3, 10, 10], dict(size=[15, 20], mode='bilinear', align_corners=True)),
+      ]
+  )
+  def test_convert_upsample_bilinear_functional(self, input_size, kwargs):
+    """Tests conversion of a torch.nn.functional.upsample module."""
+    torch_module = _func_to_torch_module(
+        lambda input_tensor: torch.nn.functional.upsample(input_tensor, **kwargs)
+    )
+    tracing_args = (torch.randn(*input_size),)
+    edge_model = ai_edge_torch.convert(torch_module, tracing_args)
+
+    self.assertTrue(
+        model_coverage.compare_tflite_torch(edge_model, torch_module, tracing_args)
+    )
+
+  @parameterized.parameterized.expand(
+      [
+          # use scale_factor with align_corners=False
+          (
+              [1, 3, 10, 10],
+              dict(scale_factor=3.0, mode='bilinear', align_corners=False),
+          ),
+          # use scale_factor with align_corners=true
+          ([1, 3, 10, 10], dict(scale_factor=3.0, mode='bilinear', align_corners=True)),
+          # use size
+          ([1, 3, 10, 10], dict(size=[15, 20], mode='bilinear')),
+          # use size with align_corners=true
+          ([1, 3, 10, 10], dict(size=[15, 20], mode='bilinear', align_corners=True)),
+      ]
+  )
+  def test_convert_upsample_bilinear(self, input_size, kwargs):
+    """Tests conversion of a torch.nn.Upsample module."""
+    torch_module = _func_to_torch_module(
+        lambda input_tensor: torch.nn.Upsample(**kwargs)(input_tensor)
+    )
+    tracing_args = (torch.randn(*input_size),)
+    edge_model = ai_edge_torch.convert(torch_module, tracing_args)
+
+    self.assertTrue(
+        model_coverage.compare_tflite_torch(edge_model, torch_module, tracing_args)
+    )
+
+  @parameterized.parameterized.expand(
+      [
+          # use scale_factor with align_corners=False
+          (
+              [1, 3, 10, 10],
+              dict(scale_factor=3.0, mode='bilinear', align_corners=False),
+          ),
+          # use scale_factor with align_corners=true
+          ([1, 3, 10, 10], dict(scale_factor=3.0, mode='bilinear', align_corners=True)),
+          # use size
+          ([1, 3, 10, 10], dict(size=[15, 20], mode='bilinear')),
+          # use size with align_corners=true
+          ([1, 3, 10, 10], dict(size=[15, 20], mode='bilinear', align_corners=True)),
+      ]
+  )
+  def test_convert_interpolate_bilinear_functional(self, input_size, kwargs):
+    """Tests conversion of a torch.nn.functional.interpolate module."""
+    torch_module = _func_to_torch_module(
+        lambda input_tensor: torch.nn.functional.interpolate(input_tensor, **kwargs)
+    )
+    tracing_args = (torch.randn(*input_size),)
+    edge_model = ai_edge_torch.convert(torch_module, tracing_args)
+
+    self.assertTrue(
+        model_coverage.compare_tflite_torch(edge_model, torch_module, tracing_args)
+    )
+
+
+if __name__ == '__main__':
+  unittest.main()

ai_edge_torch/convert/test/test_convert_multisig.py

@@ -0,0 +1,139 @@
+# Copyright 2024 The AI Edge Torch Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+import unittest
+
+import torch
+import torchvision
+
+import ai_edge_torch
+from ai_edge_torch.testing import model_coverage
+
+
+class TestConvertMultiSignature(unittest.TestCase):
+  """Tests conversion of various modules through multi-signature conversion."""
+
+  def setUp(self):
+    torch.manual_seed(0)
+
+  def test_convert_mobilenet_v2_with_default(self):
+    """Tests conversion of a model with two signatures one of which is the default."""
+    torch_module = torchvision.models.mobilenet_v2().eval()
+
+    args = (torch.randn(4, 3, 224, 224),)
+    large_args = (torch.randn(4, 3, 336, 336),)
+
+    signature_name = "large_input"
+
+    edge_model = ai_edge_torch.signature(
+        signature_name, torch_module, large_args
+    ).convert(torch_module, args)
+
+    self.assertTrue(model_coverage.compare_tflite_torch(edge_model, torch_module, args))
+    self.assertTrue(
+        model_coverage.compare_tflite_torch(
+            edge_model, torch_module, large_args, signature_name=signature_name
+        )
+    )
+
+  def test_convert_mobilenet_v2_no_default(self):
+    """Tests conversion of a model with two signatures none of which is the default."""
+    torch_module = torchvision.models.mobilenet_v2().eval()
+
+    args = (torch.randn(4, 3, 224, 224),)
+    large_args = (torch.randn(4, 3, 336, 336),)
+
+    signature_name_1 = "input"
+    signature_name_2 = "large_input"
+
+    edge_model = (
+        ai_edge_torch.signature(signature_name_1, torch_module, args)
+        .signature(signature_name_2, torch_module, large_args)
+        .convert()
+    )
+
+    with self.assertRaises(ValueError):
+      edge_model(*args)
+
+    self.assertTrue(
+        model_coverage.compare_tflite_torch(
+            edge_model, torch_module, args, signature_name=signature_name_1
+        )
+    )
+    self.assertTrue(
+        model_coverage.compare_tflite_torch(
+            edge_model, torch_module, large_args, signature_name=signature_name_2
+        )
+    )
+
+  def test_convert_mobilenet_v2_signature_helper(self):
+    """Tests the ai_edge_torch.signature helper function works."""
+    torch_module = torchvision.models.mobilenet_v2().eval()
+
+    args = (torch.randn(4, 3, 224, 224),)
+    large_args = (torch.randn(4, 3, 336, 336),)
+
+    signature_name = "large_input"
+
+    edge_model = ai_edge_torch.signature(signature_name, torch_module, args).convert(
+        torch_module, large_args
+    )
+
+    self.assertTrue(model_coverage.compare_tflite_torch(edge_model, torch_module, args))
+    self.assertTrue(
+        model_coverage.compare_tflite_torch(
+            edge_model, torch_module, large_args, signature_name=signature_name
+        )
+    )
+
+  def test_convert_separate_modules(self):
+    """Tests conversion of two completely different modules as separate signatures."""
+    mobilentv2 = torchvision.models.mobilenet_v2().eval()
+    resnet18 = torchvision.models.resnet18().eval()
+
+    mobilenet_args = (torch.randn(4, 3, 224, 224),)
+    resnet_args = (torch.randn(4, 3, 224, 224),)
+
+    mobilenet_signature_name = "mobilentv2"
+    resnet_signature_name = "resnet18"
+
+    edge_model = (
+        ai_edge_torch.signature(mobilenet_signature_name, mobilentv2, mobilenet_args)
+        .signature(resnet_signature_name, resnet18, resnet_args)
+        .convert(resnet18, resnet_args)
+    )
+
+    mobilenet_inference_args = (torch.randn(4, 3, 224, 224),)
+    resnet_inference_args = (torch.randn(4, 3, 224, 224),)
+    self.assertTrue(
+        model_coverage.compare_tflite_torch(
+            edge_model,
+            mobilentv2,
+            mobilenet_inference_args,
+            signature_name=mobilenet_signature_name,
+        )
+    )
+    self.assertTrue(
+        model_coverage.compare_tflite_torch(
+            edge_model,
+            resnet18,
+            resnet_inference_args,
+            signature_name=resnet_signature_name,
+        )
+    )
+
+
+if __name__ == "__main__":
+  unittest.main()

ai_edge_torch/debug/__init__.py

@@ -0,0 +1,16 @@
+# Copyright 2024 The AI Edge Torch Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from .culprit import find_culprits