Resize the input image to the given size >>> import torch >>> from doctr.transforms import Resize >>> transfo = Resize((64, 64), preserve

Implements an abstract preprocessor object which performs casting, resizing, batching and normalization. Args: output_size: expected size

Position-wise Feed-Forward Network

Multi-Head Attention

Implements an object able to localize and identify text elements in a set of documents Args: det_predictor: detection module reco

r"""Implements common confusion metrics and mean IoU for localization evaluation. The aggregated metrics are computed as follows: .. math::

Implements an object able to localize and identify text elements in a set of documents Args: det_predictor: detection module reco

r"""Implements text match metric (word-level accuracy) for recognition task. The raw aggregated metric is computed as follows: .. math::

Implements a post processor for DBNet adapted from the implementation of `xuannianz <https://github.com/xuannianz/DifferentiableBinarization>`_.

Implements an object able to localize text elements in a document Args: pre_processor: transform inputs for easier batched model inferenc

DropPath (Drop Connect) layer. This is a stochastic version of the identity layer.

Convolutional layer used in the TextNet and FAST architectures

Implements a post processor for FAST model. Args: bin_thresh: threshold used to binzarized p_map at inference time box_thresh: mi

Implements a post processor for LinkNet model. Args: bin_thresh: threshold used to binzarized p_map at inference time box_thresh:

Dataset implementation for text recognition tasks >>> from doctr.datasets import RecognitionDataset >>> train_set = RecognitionDataset(img_fo

Implements an object able to identify character sequences in images Args: pre_processor: transform inputs for easier batched model infere

Unified block for Local, Global, and Mixed feature mixing in VIP architecture.

Implements a character image generation dataset >>> from doctr.datasets import CharacterGenerator >>> ds = CharacterGenerator(vocab='abdef',

Local mixing module, performing attention within cross-shaped windows. This captures local patterns by splitting the feature map into two cr

Implements a text detection dataset >>> from doctr.datasets import DetectionDataset >>> train_set = DetectionDataset(img_folder="/path/to/ima

r"""Implements an end-to-end OCR metric. The aggregated metrics are computed as follows: .. math:: \forall (B, L) \in \mathcal{B}^N

Implements a basic image dataset where targets are filled with zeros. >>> from doctr.datasets import OrientationDataset >>> train_set = Orien

Implements an object able to detect the reading direction of a text box or a page. 4 possible orientations: 0, 90, 180, 270 (-90) degrees counter

Compute positional encoding

Implements a prediction element

Randomly rotate a tensor image and its boxes .. image:: https://doctr-static.mindee.com/models?id=v0.4.0/rotation_illustration.png&src=0

Implements a ResNet-31 architecture from `"Show, Attend and Read:A Simple and Strong Baseline for Irregular Text Recognition" <https://arxiv.org/p

Implements a word element Args: value: the text string of the word confidence: the confidence associated with the text prediction

Implements a character image generation dataset >>> from doctr.datasets import WordGenerator >>> ds = WordGenerator(vocab='abdef', min_chars=

Base class for all predictors Args: batch_size: the batch size to use url: the url to use to download a model if needed

Custom AdaptiveAvgPool2d implementation which is ONNX and `torch.compile` compatible.

Standard multi-head attention module. This module applies self-attention across the input sequence using 'num_heads' heads. Args:

Implements a block element as a collection of lines and artefacts Args: lines: list of line elements artefacts: list of artefacts

Implements a CRNN architecture as described in `"An End-to-End Trainable Neural Network for Image-based Sequence Recognition and Its Application t

Postprocess raw prediction of the model (logits) to a list of words using CTC decoding Args: vocab: string containing the ordered sequenc

Randomly shuffle channel order of a given image

Implements the character embedding module Args: vocab_size: size of the vocabulary d_model: dimension of the model

Classifier head for Vision Transformer Args: in_channels: number of input channels num_classes: number of output classes

Classification head which averages the features and applies a linear layer.

Applies the following tranformation to a tensor (image or batch of images): convert to grayscale, colorize (shift 0-values randomly), and then inv

DBNet as described in `"Real-time Scene Text Detection with Differentiable Binarization" <https://arxiv.org/pdf/1911.08947.pdf>`_. Args:

Transformer Decoder

Implements a document element as a collection of pages Args: pages: list of page elements

Implements a document builder Args: resolve_lines: whether words should be automatically grouped into lines resolve_blocks: wheth

Transformer Encoder Block

FAST as described in `"FAST: Faster Arbitrarily-Shaped Text Detector with Minimalist Kernel Representation" <https://arxiv.org/pdf/2111.02394.pdf>

Head of the FAST architecture Args: in_channels: number of input channels num_classes: number of output classes out_chann

Neck of the FAST architecture, composed of a series of 3x3 convolutions and upsampling layers. Args: in_channels: number of input channel

Apply Gaussian Blur to the input tensor >>> import torch >>> from doctr.transforms import GaussianBlur >>> transfo = GaussianBlur(sigma=(

Adds Gaussian Noise to the input tensor >>> import torch >>> from doctr.transforms import GaussianNoise >>> transfo = GaussianNoise(0., 1

Implements a document element as a collection of pages Args: pages: list of page elements

Implements a KIE document builder Args: resolve_lines: whether words should be automatically grouped into lines resolve_blocks: w

Implements a KIE page element as a collection of predictions Args: predictions: Dictionary with list of block elements for each detection

Local Enhancement Positional Encoding (LePE) Attention. This is used for computing attention in cross-shaped windows (part of CrossShapedWin

Implements a line element as a collection of words Args: words: list of word elements geometry: bounding box of the word in forma

LinkNet as described in `"LinkNet: Exploiting Encoder Representations for Efficient Semantic Segmentation" <https://arxiv.org/pdf/1707.03718.pdf>`

Implements MASTER as described in paper: <https://arxiv.org/pdf/1910.02562.pdf>`_. Implementation based on the official Pytorch implementation: <h

Post processor for MASTER architectures

Multi-head Self Attention block with an MLP for feed-forward processing. This block normalizes the input, applies attention mixing, adds a r

Global token mixing block using Overlapped Spatial Reduction Attention (OSRA). Captures global dependencies by aggregating context from a wi

Overlapped Spatial Reduction Attention (OSRA). This attention mechanism downsamples the input according to 'sr_ratio' (spatial reduction rat

Implements a PARSeq architecture as described in `"Scene Text Recognition with Permuted Autoregressive Sequence Models" <https://arxiv.org/pdf/220

Implements decoder module of the PARSeq model Args: d_model: dimension of the model num_heads: number of attention heads

Post processor for PARSeq architecture Args: vocab: string containing the ordered sequence of supported characters

Implements a page element as a collection of blocks Args: page: image encoded as a numpy array in uint8 blocks: list of block ele

Patch embedding layer for Vision Permutable Extractor. This layer reduces the spatial resolution of the input tensor by a factor of 4 in tot

Compute 2D patch embeddings with cls token and positional encoding

Patch Merging Layer. Reduces the spatial dimension by half along the height. If the input has shape (b, h, w, c), the output shape becom

Custom layer to permute dimensions in a Sequential model.

Randomly crop a tensor image and its boxes Args: scale: tuple of floats, relative (min_area, max_area) of the crop ratio: tuple o

Randomly flip the input image horizontally

Randomly resize the input image and align corresponding targets >>> import torch >>> from doctr.transforms import RandomResize >>> transf

Adds random shade to the input image >>> import torch >>> from doctr.transforms import RandomShadow >>> transfo = RandomShadow((0., 1.))

Implements a SAR architecture as described in `"Show, Attend and Read:A Simple and Strong Baseline for Irregular Text Recognition" <https://arxiv.

Implements decoder module of the SAR model Args: rnn_units: number of hidden units in recurrent cells max_length: maximum length

Post processor for SAR architectures Args: vocab: string containing the ordered sequence of supported characters

Custom layer to squeeze out a dimension in a Sequential model.

Implements TextNet architecture from `"FAST: Faster Arbitrarily-Shaped Text Detector with Minimalist Kernel Representation" <https://arxiv.org/abs

VIP (Vision Permutable) encoder architecture, adapted for text recognition.