paddlex 3.0.0b2__py3-none-any.whl → 3.0.0rc0__py3-none-any.whl

paddlex/inference/models/semantic_segmentation/processors.py

@@ -0,0 +1,114 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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 List, Tuple, Union
+import os
+import sys
+import cv2
+import copy
+import math
+import pyclipper
+import numpy as np
+from ..common.vision.processors import _BaseResize
+
+from ..common.vision import funcs as F
+
+
+class Resize(_BaseResize):
+    """Resize the image."""
+
+    def __init__(
+        self, target_size=-1, keep_ratio=False, size_divisor=None, interp="LINEAR"
+    ):
+        """
+        Initialize the instance.
+
+        Args:
+            target_size (list|tuple|int, optional): Target width and height. -1 will return the images directly without resizing.
+            keep_ratio (bool, optional): Whether to keep the aspect ratio of resized
+                image. Default: False.
+            size_divisor (int|None, optional): Divisor of resized image size.
+                Default: None.
+            interp (str, optional): Interpolation method. Choices are 'NEAREST',
+                'LINEAR', 'CUBIC', 'AREA', and 'LANCZOS4'. Default: 'LINEAR'.
+        """
+        super().__init__(size_divisor=size_divisor, interp=interp)
+
+        if isinstance(target_size, int):
+            target_size = (target_size, target_size)
+        F.check_image_size(target_size)
+        self.target_size = target_size
+
+        self.keep_ratio = keep_ratio
+
+    def __call__(self, imgs, target_size=None):
+        """apply"""
+        target_size = self.target_size if target_size is None else target_size
+        if isinstance(target_size, int):
+            target_size = (target_size, target_size)
+        F.check_image_size(target_size)
+        return [self.resize(img, target_size) for img in imgs]
+
+    def resize(self, img, target_size):
+
+        if target_size == (-1, -1):
+            # If the final target_size == (-1, -1), it means use the source input image directly.
+            return img
+        original_size = img.shape[:2][::-1]
+        assert target_size[0] > 0 and target_size[1] > 0
+
+        if self.keep_ratio:
+            h, w = img.shape[0:2]
+            target_size, _ = self._rescale_size((w, h), target_size)
+
+        if self.size_divisor:
+            target_size = [
+                math.ceil(i / self.size_divisor) * self.size_divisor
+                for i in target_size
+            ]
+        img = F.resize(img, target_size, interp=self.interp)
+        return img
+
+
+class SegPostProcess:
+    """Semantic Segmentation PostProcess
+
+    This class is responsible for post-processing detection results, only including
+    restoring the prediction segmentation map to the original image size for now.
+    """
+
+    def __call__(self, imgs, src_images):
+        assert len(imgs) == len(src_images)
+
+        src_sizes = [src_image.shape[:2][::-1] for src_image in src_images]
+        return [
+            self.reverse_resize(img, src_size) for img, src_size in zip(imgs, src_sizes)
+        ]
+
+    def reverse_resize(self, img, src_size):
+        """Restore the prediction map to source image size using nearest interpolation.
+
+        Args:
+             img (np.ndarray): prediction map with shape of (1, width, height)
+             src_size (Tuple[int, int]): source size of the input image, with format of (width, height).
+        """
+        assert isinstance(src_size, (tuple, list)) and len(src_size) == 2
+        assert src_size[0] > 0 and src_size[1] > 0
+        assert img.ndim == 3
+
+        reversed_img = cv2.resize(
+            img[0], dsize=src_size, interpolation=cv2.INTER_NEAREST
+        )
+        reversed_img = np.expand_dims(reversed_img, axis=0)
+        return reversed_img

paddlex/inference/models/semantic_segmentation/result.py

@@ -0,0 +1,72 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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 numpy as np
+from PIL import Image
+import copy
+
+from ...common.result import BaseCVResult, StrMixin, JsonMixin
+
+
+class SegResult(BaseCVResult):
+    """Save Result Transform"""
+
+    def _to_img(self):
+        """apply"""
+        seg_map = self["pred"]
+        pc_map = self.get_pseudo_color_map(seg_map[0])
+        if pc_map.mode == "P":
+            pc_map = pc_map.convert("RGB")
+        return {"res": pc_map}
+
+    def get_pseudo_color_map(self, pred):
+        """get_pseudo_color_map"""
+        if pred.min() < 0 or pred.max() > 255:
+            raise ValueError("`pred` cannot be cast to uint8.")
+        pred = pred.astype(np.uint8)
+        pred_mask = Image.fromarray(pred, mode="P")
+        color_map = self._get_color_map_list(256)
+        pred_mask.putpalette(color_map)
+        return pred_mask
+
+    @staticmethod
+    def _get_color_map_list(num_classes, custom_color=None):
+        """_get_color_map_list"""
+        num_classes += 1
+        color_map = num_classes * [0, 0, 0]
+        for i in range(0, num_classes):
+            j = 0
+            lab = i
+            while lab:
+                color_map[i * 3] |= ((lab >> 0) & 1) << (7 - j)
+                color_map[i * 3 + 1] |= ((lab >> 1) & 1) << (7 - j)
+                color_map[i * 3 + 2] |= ((lab >> 2) & 1) << (7 - j)
+                j += 1
+                lab >>= 3
+        color_map = color_map[3:]
+
+        if custom_color:
+            color_map[: len(custom_color)] = custom_color
+        return color_map
+
+    def _to_str(self, *args, **kwargs):
+        data = copy.deepcopy(self)
+        data.pop("input_img")
+        data["pred"] = "..."
+        return JsonMixin._to_str(data, *args, **kwargs)
+
+    def _to_json(self, *args, **kwargs):
+        data = copy.deepcopy(self)
+        data.pop("input_img")
+        return JsonMixin._to_json(data, *args, **kwargs)

paddlex/inference/models/table_structure_recognition/__init__.py

@@ -0,0 +1,15 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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 .predictor import TablePredictor

paddlex/inference/models/table_structure_recognition/predictor.py

@@ -0,0 +1,171 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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 Any, Union, Dict, List, Tuple
+import numpy as np
+
+from ....utils.func_register import FuncRegister
+from ....modules.table_recognition.model_list import MODELS
+from ...common.batch_sampler import ImageBatchSampler
+from ...common.reader import ReadImage
+from ..common import (
+    Resize,
+    ResizeByLong,
+    Normalize,
+    ToCHWImage,
+    ToBatch,
+    StaticInfer,
+)
+from ..base import BasicPredictor
+from .processors import Pad, TableLabelDecode
+from .result import TableRecResult
+
+
+class TablePredictor(BasicPredictor):
+    entities = MODELS
+
+    _FUNC_MAP = {}
+    register = FuncRegister(_FUNC_MAP)
+
+    def __init__(self, *args: List, **kwargs: Dict) -> None:
+        super().__init__(*args, **kwargs)
+        self.preprocessors, self.infer, self.postprocessors = self._build()
+
+    def _build_batch_sampler(self) -> ImageBatchSampler:
+        return ImageBatchSampler()
+
+    def _get_result_class(self) -> type:
+        return TableRecResult
+
+    def _build(self) -> Tuple:
+        preprocessors = []
+        for cfg in self.config["PreProcess"]["transform_ops"]:
+            tf_key = list(cfg.keys())[0]
+            func = self._FUNC_MAP[tf_key]
+            args = cfg.get(tf_key, {})
+            op = func(self, **args) if args else func(self)
+            if op:
+                preprocessors.append(op)
+        preprocessors.append(ToBatch())
+
+        infer = StaticInfer(
+            model_dir=self.model_dir,
+            model_prefix=self.MODEL_FILE_PREFIX,
+            option=self.pp_option,
+        )
+
+        postprocessors = TableLabelDecode(
+            model_name=self.config["Global"]["model_name"],
+            merge_no_span_structure=self.config["PreProcess"]["transform_ops"][1][
+                "TableLabelEncode"
+            ]["merge_no_span_structure"],
+            dict_character=self.config["PostProcess"]["character_dict"],
+        )
+        return preprocessors, infer, postprocessors
+
+    def process(self, batch_data: List[Union[str, np.ndarray]]) -> Dict[str, Any]:
+        """
+        Process a batch of data through the preprocessing, inference, and postprocessing.
+
+        Args:
+            batch_data (List[Union[str, np.ndarray], ...]): A batch of input data (e.g., image file paths).
+
+        Returns:
+            dict: A dictionary containing the input path, raw image, class IDs, scores, and label names for every instance of the batch. Keys include 'input_path', 'input_img', 'class_ids', 'scores', and 'label_names'.
+        """
+        batch_raw_imgs = self.preprocessors[0](imgs=batch_data.instances)  # ReadImage
+        ori_shapes = []
+        for s in range(len(batch_raw_imgs)):
+            ori_shapes.append([batch_raw_imgs[s].shape[1], batch_raw_imgs[s].shape[0]])
+        batch_imgs = self.preprocessors[1](imgs=batch_raw_imgs)  # ResizeByLong
+        batch_imgs = self.preprocessors[2](imgs=batch_imgs)  # Normalize
+        pad_results = self.preprocessors[3](imgs=batch_imgs)  # Pad
+        pad_imgs = []
+        padding_sizes = []
+        for pad_img, padding_size in pad_results:
+            pad_imgs.append(pad_img)
+            padding_sizes.append(padding_size)
+        batch_imgs = self.preprocessors[4](imgs=pad_imgs)  # ToCHWImage
+        x = self.preprocessors[5](imgs=batch_imgs)  # ToBatch
+
+        batch_preds = self.infer(x=x)
+
+        table_result = self.postprocessors(
+            pred=batch_preds,
+            img_size=padding_sizes,
+            ori_img_size=ori_shapes,
+        )
+
+        table_result_bbox = []
+        table_result_structure = []
+        table_result_structure_score = []
+        for i in range(len(table_result)):
+            table_result_bbox.append(table_result[i]["bbox"])
+            table_result_structure.append(table_result[i]["structure"])
+            table_result_structure_score.append(table_result[i]["structure_score"])
+
+        final_result = {
+            "input_path": batch_data.input_paths,
+            "page_index": batch_data.page_indexes,
+            "input_img": batch_raw_imgs,
+            "bbox": table_result_bbox,
+            "structure": table_result_structure,
+            "structure_score": table_result_structure_score,
+        }
+
+        return final_result
+
+    @register("DecodeImage")
+    def build_readimg(self, channel_first=False, img_mode="BGR"):
+        assert channel_first is False
+        assert img_mode == "BGR"
+        return ReadImage(format=img_mode)
+
+    @register("TableLabelEncode")
+    def foo(self, *args, **kwargs):
+        return None
+
+    @register("TableBoxEncode")
+    def foo(self, *args, **kwargs):
+        return None
+
+    @register("ResizeTableImage")
+    def build_resize_table(self, max_len=488, resize_bboxes=True):
+        return ResizeByLong(target_long_edge=max_len)
+
+    @register("NormalizeImage")
+    def build_normalize(
+        self,
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225],
+        scale=1 / 255,
+        order="hwc",
+    ):
+        return Normalize(mean=mean, std=std)
+
+    @register("PaddingTableImage")
+    def build_padding(self, size=[488, 448], pad_value=0):
+        return Pad(target_size=size[0], val=pad_value)
+
+    @register("ToCHWImage")
+    def build_to_chw(self):
+        return ToCHWImage()
+
+    @register("KeepKeys")
+    def foo(self, *args, **kwargs):
+        return None
+
+    def _pack_res(self, single):
+        keys = ["input_path", "bbox", "structure"]
+        return TableRecResult({key: single[key] for key in keys})

paddlex/inference/models/table_structure_recognition/processors.py

@@ -0,0 +1,235 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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 cv2
+import numpy as np
+from numpy import ndarray
+from ..common.vision import funcs as F
+
+
+class Pad:
+    """Pad the image."""
+
+    def __init__(self, target_size, val=127.5):
+        """
+        Initialize the instance.
+
+        Args:
+            target_size (list|tuple|int): Target width and height of the image after
+                padding.
+            val (float, optional): Value to fill the padded area. Default: 127.5.
+        """
+        super().__init__()
+
+        if isinstance(target_size, int):
+            target_size = [target_size, target_size]
+        self.target_size = target_size
+
+        self.val = val
+
+    def apply(self, img):
+        """apply"""
+        h, w = img.shape[:2]
+        tw, th = self.target_size
+        ph = th - h
+        pw = tw - w
+
+        if ph < 0 or pw < 0:
+            raise ValueError(
+                f"Input image ({w}, {h}) smaller than the target size ({tw}, {th})."
+            )
+        else:
+            img = F.pad(img, pad=(0, ph, 0, pw), val=self.val)
+
+        return [img, [img.shape[1], img.shape[0]]]
+
+    def __call__(self, imgs):
+        """apply"""
+        return [self.apply(img) for img in imgs]
+
+
+class TableLabelDecode:
+    """decode the table model outputs(probs) to character str"""
+
+    ENABLE_BATCH = True
+
+    INPUT_KEYS = ["pred", "img_size", "ori_img_size"]
+    OUTPUT_KEYS = ["bbox", "structure", "structure_score"]
+    DEAULT_INPUTS = {
+        "pred": "pred",
+        "img_size": "img_size",
+        "ori_img_size": "ori_img_size",
+    }
+    DEAULT_OUTPUTS = {
+        "bbox": "bbox",
+        "structure": "structure",
+        "structure_score": "structure_score",
+    }
+
+    def __init__(self, model_name, merge_no_span_structure=True, dict_character=[]):
+        super().__init__()
+
+        if merge_no_span_structure:
+            if "<td></td>" not in dict_character:
+                dict_character.append("<td></td>")
+            if "<td>" in dict_character:
+                dict_character.remove("<td>")
+        self.model_name = model_name
+
+        dict_character = self.add_special_char(dict_character)
+        self.dict = {}
+        for i, char in enumerate(dict_character):
+            self.dict[char] = i
+        self.character = dict_character
+        self.td_token = ["<td>", "<td", "<td></td>"]
+
+    def add_special_char(self, dict_character):
+        """add_special_char"""
+        self.beg_str = "sos"
+        self.end_str = "eos"
+        dict_character = dict_character
+        dict_character = [self.beg_str] + dict_character + [self.end_str]
+        return dict_character
+
+    def get_ignored_tokens(self):
+        """get_ignored_tokens"""
+        beg_idx = self.get_beg_end_flag_idx("beg")
+        end_idx = self.get_beg_end_flag_idx("end")
+        return [beg_idx, end_idx]
+
+    def get_beg_end_flag_idx(self, beg_or_end):
+        """get_beg_end_flag_idx"""
+        if beg_or_end == "beg":
+            idx = np.array(self.dict[self.beg_str])
+        elif beg_or_end == "end":
+            idx = np.array(self.dict[self.end_str])
+        else:
+            assert False, "unsupported type %s in get_beg_end_flag_idx" % beg_or_end
+        return idx
+
+    def __call__(self, pred, img_size, ori_img_size):
+        """apply"""
+        bbox_preds, structure_probs = [], []
+
+        for i in range(len(pred[0][0])):
+            bbox_preds.append(pred[0][0][i])
+            structure_probs.append(pred[1][0][i])
+        bbox_preds = [bbox_preds]
+        structure_probs = [structure_probs]
+
+        bbox_preds = np.array(bbox_preds)
+        structure_probs = np.array(structure_probs)
+
+        bbox_list, structure_str_list, structure_score = self.decode(
+            structure_probs, bbox_preds, img_size, ori_img_size
+        )
+        structure_str_list = [
+            (
+                ["<html>", "<body>", "<table>"]
+                + structure
+                + ["</table>", "</body>", "</html>"]
+            )
+            for structure in structure_str_list
+        ]
+        return [
+            {"bbox": bbox, "structure": structure, "structure_score": structure_score}
+            for bbox, structure in zip(bbox_list, structure_str_list)
+        ]
+
+    def decode(self, structure_probs, bbox_preds, padding_size, ori_img_size):
+        """convert text-label into text-index."""
+        ignored_tokens = self.get_ignored_tokens()
+        end_idx = self.dict[self.end_str]
+
+        structure_idx = structure_probs.argmax(axis=2)
+        structure_probs = structure_probs.max(axis=2)
+
+        structure_batch_list = []
+        bbox_batch_list = []
+        batch_size = len(structure_idx)
+        for batch_idx in range(batch_size):
+            structure_list = []
+            bbox_list = []
+            score_list = []
+            for idx in range(len(structure_idx[batch_idx])):
+                char_idx = int(structure_idx[batch_idx][idx])
+                if idx > 0 and char_idx == end_idx:
+                    break
+                if char_idx in ignored_tokens:
+                    continue
+                text = self.character[char_idx]
+                if text in self.td_token:
+                    bbox = bbox_preds[batch_idx, idx]
+                    bbox = self._bbox_decode(
+                        bbox, padding_size[batch_idx], ori_img_size[batch_idx]
+                    )
+                    bbox_list.append(bbox.astype(int))
+                structure_list.append(text)
+                score_list.append(structure_probs[batch_idx, idx])
+            structure_batch_list.append(structure_list)
+            structure_score = np.mean(score_list)
+            bbox_batch_list.append(bbox_list)
+
+        return bbox_batch_list, structure_batch_list, structure_score
+
+    def decode_label(self, batch):
+        """convert text-label into text-index."""
+        structure_idx = batch[1]
+        gt_bbox_list = batch[2]
+        shape_list = batch[-1]
+        ignored_tokens = self.get_ignored_tokens()
+        end_idx = self.dict[self.end_str]
+
+        structure_batch_list = []
+        bbox_batch_list = []
+        batch_size = len(structure_idx)
+        for batch_idx in range(batch_size):
+            structure_list = []
+            bbox_list = []
+            for idx in range(len(structure_idx[batch_idx])):
+                char_idx = int(structure_idx[batch_idx][idx])
+                if idx > 0 and char_idx == end_idx:
+                    break
+                if char_idx in ignored_tokens:
+                    continue
+                structure_list.append(self.character[char_idx])
+
+                bbox = gt_bbox_list[batch_idx][idx]
+                if bbox.sum() != 0:
+                    bbox = self._bbox_decode(bbox, shape_list[batch_idx])
+                    bbox_list.append(bbox.astype(int))
+            structure_batch_list.append(structure_list)
+            bbox_batch_list.append(bbox_list)
+        return bbox_batch_list, structure_batch_list
+
+    def _bbox_decode(self, bbox, padding_shape, ori_shape):
+
+        if self.model_name == "SLANet":
+            w, h = ori_shape
+            bbox[0::2] *= w
+            bbox[1::2] *= h
+        else:
+            w, h = padding_shape
+            ori_w, ori_h = ori_shape
+            ratio_w = w / ori_w
+            ratio_h = h / ori_h
+            ratio = min(ratio_w, ratio_h)
+
+            bbox[0::2] *= w
+            bbox[1::2] *= h
+            bbox[0::2] /= ratio
+            bbox[1::2] /= ratio
+
+        return bbox

paddlex/inference/models/table_structure_recognition/result.py

@@ -0,0 +1,70 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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 copy
+import cv2
+import numpy as np
+from pathlib import Path
+import PIL
+from PIL import Image, ImageDraw, ImageFont
+
+from ...common.result import BaseCVResult, StrMixin, JsonMixin
+
+
+class TableRecResult(BaseCVResult):
+    """SaveTableResults"""
+
+    def _get_input_fn(self):
+        fn = super()._get_input_fn()
+        if (page_idx := self["page_index"]) is not None:
+            fp = Path(fn)
+            stem, suffix = fp.stem, fp.suffix
+            return f"{stem}_{page_idx}{suffix}"
+        else:
+            return fn
+
+    def _to_img(self):
+        image = self["input_img"]
+        bbox_res = self["bbox"]
+        if len(bbox_res) > 0 and len(bbox_res[0]) == 4:
+            vis_img = self.draw_rectangle(image, bbox_res)
+        else:
+            vis_img = self.draw_bbox(image, bbox_res)
+        return {"res": vis_img}
+
+    def draw_rectangle(self, image, boxes):
+        """draw_rectangle"""
+        boxes = np.array(boxes)
+        img_show = image.copy()
+        for box in boxes.astype(int):
+            x1, y1, x2, y2 = box
+            cv2.rectangle(img_show, (x1, y1), (x2, y2), (255, 0, 0), 2)
+        return img_show
+
+    def draw_bbox(self, image, boxes):
+        """draw_bbox"""
+        for box in boxes:
+            box = np.reshape(np.array(box), [-1, 1, 2]).astype(np.int64)
+            image = cv2.polylines(np.array(image), [box], True, (255, 0, 0), 2)
+        return image
+
+    def _to_str(self, *args, **kwargs):
+        data = copy.deepcopy(self)
+        data.pop("input_img")
+        return JsonMixin._to_str(data, *args, **kwargs)
+
+    def _to_json(self, *args, **kwargs):
+        data = copy.deepcopy(self)
+        data.pop("input_img")
+        return JsonMixin._to_json(data, *args, **kwargs)

paddlex/inference/models/text_detection/__init__.py

@@ -0,0 +1,15 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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 .predictor import TextDetPredictor