onnxtr 0.1.0__py3-none-any.whl

onnxtr/models/classification/zoo.py

@@ -0,0 +1,76 @@
+# Copyright (C) 2021-2024, Mindee | Felix Dittrich.
+
+# This program is licensed under the Apache License 2.0.
+# See LICENSE or go to <https://opensource.org/licenses/Apache-2.0> for full license details.
+
+from typing import Any, List
+
+from .. import classification
+from ..preprocessor import PreProcessor
+from .predictor import OrientationPredictor
+
+__all__ = ["crop_orientation_predictor", "page_orientation_predictor"]
+
+ORIENTATION_ARCHS: List[str] = ["mobilenet_v3_small_crop_orientation", "mobilenet_v3_small_page_orientation"]
+
+
+def _orientation_predictor(arch: str, **kwargs: Any) -> OrientationPredictor:
+    if arch not in ORIENTATION_ARCHS:
+        raise ValueError(f"unknown architecture '{arch}'")
+
+    # Load directly classifier from backbone
+    _model = classification.__dict__[arch]()
+    kwargs["mean"] = kwargs.get("mean", _model.cfg["mean"])
+    kwargs["std"] = kwargs.get("std", _model.cfg["std"])
+    kwargs["batch_size"] = kwargs.get("batch_size", 128 if "crop" in arch else 4)
+    input_shape = _model.cfg["input_shape"][1:]
+    predictor = OrientationPredictor(
+        PreProcessor(input_shape, preserve_aspect_ratio=True, symmetric_pad=True, **kwargs), _model
+    )
+    return predictor
+
+
+def crop_orientation_predictor(
+    arch: Any = "mobilenet_v3_small_crop_orientation", **kwargs: Any
+) -> OrientationPredictor:
+    """Crop orientation classification architecture.
+
+    >>> import numpy as np
+    >>> from onnxtr.models import crop_orientation_predictor
+    >>> model = crop_orientation_predictor(arch='mobilenet_v3_small_crop_orientation')
+    >>> input_crop = (255 * np.random.rand(256, 256, 3)).astype(np.uint8)
+    >>> out = model([input_crop])
+
+    Args:
+    ----
+        arch: name of the architecture to use (e.g. 'mobilenet_v3_small_crop_orientation')
+        **kwargs: keyword arguments to be passed to the OrientationPredictor
+
+    Returns:
+    -------
+        OrientationPredictor
+    """
+    return _orientation_predictor(arch, **kwargs)
+
+
+def page_orientation_predictor(
+    arch: Any = "mobilenet_v3_small_page_orientation", **kwargs: Any
+) -> OrientationPredictor:
+    """Page orientation classification architecture.
+
+    >>> import numpy as np
+    >>> from onnxtr.models import page_orientation_predictor
+    >>> model = page_orientation_predictor(arch='mobilenet_v3_small_page_orientation')
+    >>> input_page = (255 * np.random.rand(512, 512, 3)).astype(np.uint8)
+    >>> out = model([input_page])
+
+    Args:
+    ----
+        arch: name of the architecture to use (e.g. 'mobilenet_v3_small_page_orientation')
+        **kwargs: keyword arguments to be passed to the OrientationPredictor
+
+    Returns:
+    -------
+        OrientationPredictor
+    """
+    return _orientation_predictor(arch, **kwargs)

onnxtr/models/detection/__init__.py

@@ -0,0 +1,2 @@
+from .models import *
+from .zoo import *

onnxtr/models/detection/core.py

@@ -0,0 +1,101 @@
+# Copyright (C) 2021-2024, Mindee | Felix Dittrich.
+
+# This program is licensed under the Apache License 2.0.
+# See LICENSE or go to <https://opensource.org/licenses/Apache-2.0> for full license details.
+
+from typing import List
+
+import cv2
+import numpy as np
+
+from onnxtr.utils.repr import NestedObject
+
+__all__ = ["DetectionPostProcessor"]
+
+
+class DetectionPostProcessor(NestedObject):
+    """Abstract class to postprocess the raw output of the model
+
+    Args:
+    ----
+        box_thresh (float): minimal objectness score to consider a box
+        bin_thresh (float): threshold to apply to segmentation raw heatmap
+        assume straight_pages (bool): if True, fit straight boxes only
+    """
+
+    def __init__(self, box_thresh: float = 0.5, bin_thresh: float = 0.5, assume_straight_pages: bool = True) -> None:
+        self.box_thresh = box_thresh
+        self.bin_thresh = bin_thresh
+        self.assume_straight_pages = assume_straight_pages
+        self._opening_kernel: np.ndarray = np.ones((3, 3), dtype=np.uint8)
+
+    def extra_repr(self) -> str:
+        return f"bin_thresh={self.bin_thresh}, box_thresh={self.box_thresh}"
+
+    @staticmethod
+    def box_score(pred: np.ndarray, points: np.ndarray, assume_straight_pages: bool = True) -> float:
+        """Compute the confidence score for a polygon : mean of the p values on the polygon
+
+        Args:
+        ----
+            pred (np.ndarray): p map returned by the model
+            points: coordinates of the polygon
+            assume_straight_pages: if True, fit straight boxes only
+
+        Returns:
+        -------
+            polygon objectness
+        """
+        h, w = pred.shape[:2]
+
+        if assume_straight_pages:
+            xmin = np.clip(np.floor(points[:, 0].min()).astype(np.int32), 0, w - 1)
+            xmax = np.clip(np.ceil(points[:, 0].max()).astype(np.int32), 0, w - 1)
+            ymin = np.clip(np.floor(points[:, 1].min()).astype(np.int32), 0, h - 1)
+            ymax = np.clip(np.ceil(points[:, 1].max()).astype(np.int32), 0, h - 1)
+            return pred[ymin : ymax + 1, xmin : xmax + 1].mean()
+
+        else:
+            mask: np.ndarray = np.zeros((h, w), np.int32)
+            cv2.fillPoly(mask, [points.astype(np.int32)], 1.0)  # type: ignore[call-overload]
+            product = pred * mask
+            return np.sum(product) / np.count_nonzero(product)
+
+    def bitmap_to_boxes(
+        self,
+        pred: np.ndarray,
+        bitmap: np.ndarray,
+    ) -> np.ndarray:
+        raise NotImplementedError
+
+    def __call__(
+        self,
+        proba_map,
+    ) -> List[List[np.ndarray]]:
+        """Performs postprocessing for a list of model outputs
+
+        Args:
+        ----
+            proba_map: probability map of shape (N, H, W, C)
+
+        Returns:
+        -------
+            list of N class predictions (for each input sample), where each class predictions is a list of C tensors
+        of shape (*, 5) or (*, 6)
+        """
+        if proba_map.ndim != 4:
+            raise AssertionError(f"arg `proba_map` is expected to be 4-dimensional, got {proba_map.ndim}.")
+
+        # Erosion + dilation on the binary map
+        bin_map = [
+            [
+                cv2.morphologyEx(bmap[..., idx], cv2.MORPH_OPEN, self._opening_kernel)
+                for idx in range(proba_map.shape[-1])
+            ]
+            for bmap in (proba_map >= self.bin_thresh).astype(np.uint8)
+        ]
+
+        return [
+            [self.bitmap_to_boxes(pmaps[..., idx], bmaps[idx]) for idx in range(proba_map.shape[-1])]
+            for pmaps, bmaps in zip(proba_map, bin_map)
+        ]

onnxtr/models/detection/models/__init__.py

@@ -0,0 +1,3 @@
+from .fast import *
+from .differentiable_binarization import *
+from .linknet import *

onnxtr/models/detection/models/differentiable_binarization.py

@@ -0,0 +1,159 @@
+# Copyright (C) 2021-2024, Mindee | Felix Dittrich.
+
+# This program is licensed under the Apache License 2.0.
+# See LICENSE or go to <https://opensource.org/licenses/Apache-2.0> for full license details.
+
+from typing import Any, Dict, Optional
+
+import numpy as np
+from scipy.special import expit
+
+from ...engine import Engine
+from ..postprocessor.base import GeneralDetectionPostProcessor
+
+__all__ = ["DBNet", "db_resnet50", "db_resnet34", "db_mobilenet_v3_large"]
+
+
+default_cfgs: Dict[str, Dict[str, Any]] = {
+    "db_resnet50": {
+        "input_shape": (3, 1024, 1024),
+        "mean": (0.798, 0.785, 0.772),
+        "std": (0.264, 0.2749, 0.287),
+        "url": "https://github.com/felixdittrich92/OnnxTR/releases/download/v0.0.1/db_resnet50-69ba0015.onnx",
+    },
+    "db_resnet34": {
+        "input_shape": (3, 1024, 1024),
+        "mean": (0.798, 0.785, 0.772),
+        "std": (0.264, 0.2749, 0.287),
+        "url": "https://github.com/felixdittrich92/OnnxTR/releases/download/v0.0.1/db_resnet34-b4873198.onnx",
+    },
+    "db_mobilenet_v3_large": {
+        "input_shape": (3, 1024, 1024),
+        "mean": (0.798, 0.785, 0.772),
+        "std": (0.264, 0.2749, 0.287),
+        "url": "https://github.com/felixdittrich92/OnnxTR/releases/download/v0.0.1/db_mobilenet_v3_large-1866973f.onnx",
+    },
+}
+
+
+class DBNet(Engine):
+    """DBNet Onnx loader
+
+    Args:
+    ----
+        model_path: path or url to onnx model file
+        bin_thresh: threshold for binarization of the output feature map
+        box_thresh: minimal objectness score to consider a box
+        assume_straight_pages: if True, fit straight bounding boxes only
+        cfg: the configuration dict of the model
+        **kwargs: additional arguments to be passed to `Engine`
+    """
+
+    def __init__(
+        self,
+        model_path,
+        bin_thresh: float = 0.3,
+        box_thresh: float = 0.1,
+        assume_straight_pages: bool = True,
+        cfg: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(url=model_path, **kwargs)
+        self.cfg = cfg
+        self.assume_straight_pages = assume_straight_pages
+        self.postprocessor = GeneralDetectionPostProcessor(
+            assume_straight_pages=self.assume_straight_pages, bin_thresh=bin_thresh, box_thresh=box_thresh
+        )
+
+    def __call__(
+        self,
+        x: np.ndarray,
+        return_model_output: bool = False,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        logits = self.run(x)
+
+        out: Dict[str, Any] = {}
+
+        prob_map = expit(logits)
+        if return_model_output:
+            out["out_map"] = prob_map
+
+        out["preds"] = self.postprocessor(prob_map)
+
+        return out
+
+
+def _dbnet(
+    arch: str,
+    model_path: str,
+    **kwargs: Any,
+) -> DBNet:
+    # Build the model
+    return DBNet(model_path, cfg=default_cfgs[arch], **kwargs)
+
+
+def db_resnet34(model_path: str = default_cfgs["db_resnet34"]["url"], **kwargs: Any) -> DBNet:
+    """DBNet as described in `"Real-time Scene Text Detection with Differentiable Binarization"
+    <https://arxiv.org/pdf/1911.08947.pdf>`_, using a ResNet-34 backbone.
+
+    >>> import numpy as np
+    >>> from onnxtr.models import db_resnet34
+    >>> model = db_resnet34()
+    >>> input_tensor = np.random.rand(1, 3, 1024, 1024)
+    >>> out = model(input_tensor)
+
+    Args:
+    ----
+        model_path: path to onnx model file, defaults to url in default_cfgs
+        **kwargs: keyword arguments of the DBNet architecture
+
+    Returns:
+    -------
+        text detection architecture
+    """
+    return _dbnet("db_resnet34", model_path, **kwargs)
+
+
+def db_resnet50(model_path: str = default_cfgs["db_resnet50"]["url"], **kwargs: Any) -> DBNet:
+    """DBNet as described in `"Real-time Scene Text Detection with Differentiable Binarization"
+    <https://arxiv.org/pdf/1911.08947.pdf>`_, using a ResNet-50 backbone.
+
+    >>> import numpy as np
+    >>> from onnxtr.models import db_resnet50
+    >>> model = db_resnet50()
+    >>> input_tensor = np.random.rand(1, 3, 1024, 1024)
+    >>> out = model(input_tensor)
+
+    Args:
+    ----
+        model_path: path to onnx model file, defaults to url in default_cfgs
+        **kwargs: keyword arguments of the DBNet architecture
+
+    Returns:
+    -------
+        text detection architecture
+    """
+    return _dbnet("db_resnet50", model_path, **kwargs)
+
+
+def db_mobilenet_v3_large(model_path: str = default_cfgs["db_mobilenet_v3_large"]["url"], **kwargs: Any) -> DBNet:
+    """DBNet as described in `"Real-time Scene Text Detection with Differentiable Binarization"
+    <https://arxiv.org/pdf/1911.08947.pdf>`_, using a MobileNet V3 Large backbone.
+
+    >>> import numpy as np
+    >>> from onnxtr.models import db_mobilenet_v3_large
+    >>> model = db_mobilenet_v3_large()
+    >>> input_tensor = np.random.rand(1, 3, 1024, 1024)
+    >>> out = model(input_tensor)
+
+    Args:
+    ----
+        model_path: path to onnx model file, defaults to url in default_cfgs
+        **kwargs: keyword arguments of the DBNet architecture
+
+    Returns:
+    -------
+        text detection architecture
+    """
+    return _dbnet("db_mobilenet_v3_large", model_path, **kwargs)

onnxtr/models/detection/models/fast.py

@@ -0,0 +1,160 @@
+# Copyright (C) 2021-2024, Mindee | Felix Dittrich.
+
+# This program is licensed under the Apache License 2.0.
+# See LICENSE or go to <https://opensource.org/licenses/Apache-2.0> for full license details.
+
+from typing import Any, Dict, Optional
+
+import numpy as np
+from scipy.special import expit
+
+from ...engine import Engine
+from ..postprocessor.base import GeneralDetectionPostProcessor
+
+__all__ = ["FAST", "fast_tiny", "fast_small", "fast_base"]
+
+
+default_cfgs: Dict[str, Dict[str, Any]] = {
+    "fast_tiny": {
+        "input_shape": (3, 1024, 1024),
+        "mean": (0.798, 0.785, 0.772),
+        "std": (0.264, 0.2749, 0.287),
+        "url": "https://github.com/felixdittrich92/OnnxTR/releases/download/v0.0.1/rep_fast_tiny-28867779.onnx",
+    },
+    "fast_small": {
+        "input_shape": (3, 1024, 1024),
+        "mean": (0.798, 0.785, 0.772),
+        "std": (0.264, 0.2749, 0.287),
+        "url": "https://github.com/felixdittrich92/OnnxTR/releases/download/v0.0.1/rep_fast_small-10428b70.onnx",
+    },
+    "fast_base": {
+        "input_shape": (3, 1024, 1024),
+        "mean": (0.798, 0.785, 0.772),
+        "std": (0.264, 0.2749, 0.287),
+        "url": "https://github.com/felixdittrich92/OnnxTR/releases/download/v0.0.1/rep_fast_base-1b89ebf9.onnx",
+    },
+}
+
+
+class FAST(Engine):
+    """FAST Onnx loader
+
+    Args:
+    ----
+        model_path: path or url to onnx model file
+        bin_thresh: threshold for binarization of the output feature map
+        box_thresh: minimal objectness score to consider a box
+        assume_straight_pages: if True, fit straight bounding boxes only
+        cfg: the configuration dict of the model
+        **kwargs: additional arguments to be passed to `Engine`
+    """
+
+    def __init__(
+        self,
+        model_path: str,
+        bin_thresh: float = 0.1,
+        box_thresh: float = 0.1,
+        assume_straight_pages: bool = True,
+        cfg: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(url=model_path, **kwargs)
+        self.cfg = cfg
+        self.assume_straight_pages = assume_straight_pages
+
+        self.postprocessor = GeneralDetectionPostProcessor(
+            assume_straight_pages=self.assume_straight_pages, bin_thresh=bin_thresh, box_thresh=box_thresh
+        )
+
+    def __call__(
+        self,
+        x: np.ndarray,
+        return_model_output: bool = False,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        logits = self.run(x)
+
+        out: Dict[str, Any] = {}
+
+        prob_map = expit(logits)
+        if return_model_output:
+            out["out_map"] = prob_map
+
+        out["preds"] = self.postprocessor(prob_map)
+
+        return out
+
+
+def _fast(
+    arch: str,
+    model_path: str,
+    **kwargs: Any,
+) -> FAST:
+    # Build the model
+    return FAST(model_path, cfg=default_cfgs[arch], **kwargs)
+
+
+def fast_tiny(model_path: str = default_cfgs["fast_tiny"]["url"], **kwargs: Any) -> FAST:
+    """FAST as described in `"FAST: Faster Arbitrarily-Shaped Text Detector with Minimalist Kernel Representation"
+    <https://arxiv.org/pdf/2111.02394.pdf>`_, using a tiny TextNet backbone.
+
+    >>> import numpy as np
+    >>> from onnxtr.models import fast_tiny
+    >>> model = fast_tiny()
+    >>> input_tensor = np.random.rand(1, 3, 1024, 1024)
+    >>> out = model(input_tensor)
+
+    Args:
+    ----
+        model_path: path to onnx model file, defaults to url in default_cfgs
+        **kwargs: keyword arguments of the DBNet architecture
+
+    Returns:
+    -------
+        text detection architecture
+    """
+    return _fast("fast_tiny", model_path, **kwargs)
+
+
+def fast_small(model_path: str = default_cfgs["fast_small"]["url"], **kwargs: Any) -> FAST:
+    """FAST as described in `"FAST: Faster Arbitrarily-Shaped Text Detector with Minimalist Kernel Representation"
+    <https://arxiv.org/pdf/2111.02394.pdf>`_, using a small TextNet backbone.
+
+    >>> import numpy as np
+    >>> from onnxtr.models import fast_small
+    >>> model = fast_small()
+    >>> input_tensor = np.random.rand(1, 3, 1024, 1024)
+    >>> out = model(input_tensor)
+
+    Args:
+    ----
+        model_path: path to onnx model file, defaults to url in default_cfgs
+        **kwargs: keyword arguments of the DBNet architecture
+
+    Returns:
+    -------
+        text detection architecture
+    """
+    return _fast("fast_small", model_path, **kwargs)
+
+
+def fast_base(model_path: str = default_cfgs["fast_base"]["url"], **kwargs: Any) -> FAST:
+    """FAST as described in `"FAST: Faster Arbitrarily-Shaped Text Detector with Minimalist Kernel Representation"
+    <https://arxiv.org/pdf/2111.02394.pdf>`_, using a base TextNet backbone.
+
+    >>> import numpy as np
+    >>> from onnxtr.models import fast_base
+    >>> model = fast_base()
+    >>> input_tensor = np.random.rand(1, 3, 1024, 1024)
+    >>> out = model(input_tensor)
+
+    Args:
+    ----
+        model_path: path to onnx model file, defaults to url in default_cfgs
+        **kwargs: keyword arguments of the DBNet architecture
+
+    Returns:
+    -------
+        text detection architecture
+    """
+    return _fast("fast_base", model_path, **kwargs)

onnxtr/models/detection/models/linknet.py

@@ -0,0 +1,160 @@
+# Copyright (C) 2021-2024, Mindee | Felix Dittrich.
+
+# This program is licensed under the Apache License 2.0.
+# See LICENSE or go to <https://opensource.org/licenses/Apache-2.0> for full license details.
+
+from typing import Any, Dict, Optional
+
+import numpy as np
+from scipy.special import expit
+
+from ...engine import Engine
+from ..postprocessor.base import GeneralDetectionPostProcessor
+
+__all__ = ["LinkNet", "linknet_resnet18", "linknet_resnet34", "linknet_resnet50"]
+
+
+default_cfgs: Dict[str, Dict[str, Any]] = {
+    "linknet_resnet18": {
+        "input_shape": (3, 1024, 1024),
+        "mean": (0.798, 0.785, 0.772),
+        "std": (0.264, 0.2749, 0.287),
+        "url": "https://github.com/felixdittrich92/OnnxTR/releases/download/v0.0.1/linknet_resnet18-e0e0b9dc.onnx",
+    },
+    "linknet_resnet34": {
+        "input_shape": (3, 1024, 1024),
+        "mean": (0.798, 0.785, 0.772),
+        "std": (0.264, 0.2749, 0.287),
+        "url": "https://github.com/felixdittrich92/OnnxTR/releases/download/v0.0.1/linknet_resnet34-93e39a39.onnx",
+    },
+    "linknet_resnet50": {
+        "input_shape": (3, 1024, 1024),
+        "mean": (0.798, 0.785, 0.772),
+        "std": (0.264, 0.2749, 0.287),
+        "url": "https://github.com/felixdittrich92/OnnxTR/releases/download/v0.0.1/linknet_resnet50-15d8c4ec.onnx",
+    },
+}
+
+
+class LinkNet(Engine):
+    """LinkNet Onnx loader
+
+    Args:
+    ----
+        model_path: path or url to onnx model file
+        bin_thresh: threshold for binarization of the output feature map
+        box_thresh: minimal objectness score to consider a box
+        assume_straight_pages: if True, fit straight bounding boxes only
+        cfg: the configuration dict of the model
+        **kwargs: additional arguments to be passed to `Engine`
+    """
+
+    def __init__(
+        self,
+        model_path: str,
+        bin_thresh: float = 0.1,
+        box_thresh: float = 0.1,
+        assume_straight_pages: bool = True,
+        cfg: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(url=model_path, **kwargs)
+        self.cfg = cfg
+        self.assume_straight_pages = assume_straight_pages
+
+        self.postprocessor = GeneralDetectionPostProcessor(
+            assume_straight_pages=self.assume_straight_pages, bin_thresh=bin_thresh, box_thresh=box_thresh
+        )
+
+    def __call__(
+        self,
+        x: np.ndarray,
+        return_model_output: bool = False,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        logits = self.run(x)
+
+        out: Dict[str, Any] = {}
+
+        prob_map = expit(logits)
+        if return_model_output:
+            out["out_map"] = prob_map
+
+        out["preds"] = self.postprocessor(prob_map)
+
+        return out
+
+
+def _linknet(
+    arch: str,
+    model_path: str,
+    **kwargs: Any,
+) -> LinkNet:
+    # Build the model
+    return LinkNet(model_path, cfg=default_cfgs[arch], **kwargs)
+
+
+def linknet_resnet18(model_path: str = default_cfgs["linknet_resnet18"]["url"], **kwargs: Any) -> LinkNet:
+    """LinkNet as described in `"LinkNet: Exploiting Encoder Representations for Efficient Semantic Segmentation"
+    <https://arxiv.org/pdf/1707.03718.pdf>`_.
+
+    >>> import numpy as np
+    >>> from onnxtr.models import linknet_resnet18
+    >>> model = linknet_resnet18()
+    >>> input_tensor = np.random.rand(1, 3, 1024, 1024)
+    >>> out = model(input_tensor)
+
+    Args:
+    ----
+        model_path: path to onnx model file, defaults to url in default_cfgs
+        **kwargs: keyword arguments of the LinkNet architecture
+
+    Returns:
+    -------
+        text detection architecture
+    """
+    return _linknet("linknet_resnet18", model_path, **kwargs)
+
+
+def linknet_resnet34(model_path: str = default_cfgs["linknet_resnet34"]["url"], **kwargs: Any) -> LinkNet:
+    """LinkNet as described in `"LinkNet: Exploiting Encoder Representations for Efficient Semantic Segmentation"
+    <https://arxiv.org/pdf/1707.03718.pdf>`_.
+
+    >>> import numpy as np
+    >>> from onnxtr.models import linknet_resnet34
+    >>> model = linknet_resnet34()
+    >>> input_tensor = np.random.rand(1, 3, 1024, 1024)
+    >>> out = model(input_tensor)
+
+    Args:
+    ----
+        model_path: path to onnx model file, defaults to url in default_cfgs
+        **kwargs: keyword arguments of the LinkNet architecture
+
+    Returns:
+    -------
+        text detection architecture
+    """
+    return _linknet("linknet_resnet34", model_path, **kwargs)
+
+
+def linknet_resnet50(model_path: str = default_cfgs["linknet_resnet50"]["url"], **kwargs: Any) -> LinkNet:
+    """LinkNet as described in `"LinkNet: Exploiting Encoder Representations for Efficient Semantic Segmentation"
+    <https://arxiv.org/pdf/1707.03718.pdf>`_.
+
+    >>> import numpy as np
+    >>> from onnxtr.models import linknet_resnet50
+    >>> model = linknet_resnet50()
+    >>> input_tensor = np.random.rand(1, 3, 1024, 1024)
+    >>> out = model(input_tensor)
+
+    Args:
+    ----
+        model_path: path to onnx model file, defaults to url in default_cfgs
+        **kwargs: keyword arguments of the LinkNet architecture
+
+    Returns:
+    -------
+        text detection architecture
+    """
+    return _linknet("linknet_resnet50", model_path, **kwargs)