Retour à la bibliothèque
arXiv 2019AAAI 2020Détection de texteNotes de lecture

DBNet

Une binarisation différentiable

Article original

Real-time Scene Text Detection with Differentiable Binarization

Auteurs de l’article

Minghui Liao · Zhaoyi Wan · Cong Yao · Kai Chen · Xiang Bai

Publication
AAAI 2020Conférence
Premier dépôt sur arXiv
arXiv:1911.08947
Citer cet article · BibTeX

La référence correspond à la version liée et cite les auteurs de l’article original.

@misc{textdetectiondbnet2019,
  title = {{Real-time Scene Text Detection with Differentiable Binarization}},
  author = {Minghui Liao and Zhaoyi Wan and Cong Yao and Kai Chen and Xiang Bai},
  year = {2019},
  eprint = {1911.08947},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/1911.08947}
}
Sur cette page

Après plusieurs articles, nous savons que les méthodes de segmentation occupent une place importante dans la détection de texte.

En bref, elles prédisent directement les pixels des régions textuelles. Une difficulté apparaît alors :

  • séparer deux textes qui se touchent ou se chevauchent.

Dans une segmentation à plusieurs classes, attribuer un canal à chaque classe peut aider à distinguer des régions de classes différentes. Mais les textes A et B appartiennent tous deux à la classe « texte » : une simple séparation par classe ne suffit pas à distinguer leurs instances.

On pourrait, en théorie, prévoir mille canaux et laisser le réseau attribuer un canal à chaque région de texte. Ce serait bien trop coûteux pour des sorties de segmentation à haute résolution. Et combien faudrait-il de canaux au juste ?

Cette voie gaspillerait des ressources de calcul et serait peu pratique.

Définir le problème

Plusieurs travaux commencent par trouver le cœur du texte, puis reconstruisent la région complète : c'est la voie bleue de la figure.

PSENet étend ce cœur vers l'extérieur ; PAN regroupe les pixels autour de lui ; TextSnake prédit sa ligne centrale et ses attributs géométriques pour en reconstruire la forme.

Les auteurs voient un défaut commun à ces méthodes : elles sont trop lentes !

Et si le réseau apprenait lui-même à séparer les instances voisines, au lieu de s'appuyer sur un post-traitement compliqué ?

Résoudre le problème

Architecture du modèle

L'architecture en elle-même n'est pas le point le plus original de l'article.

Dans notre figure annotée, le bloc rouge est le réseau principal, ResNet-18 ou ResNet-50 dans l'article. Le bloc vert est une pyramide de caractéristiques (FPN) qui extrait plusieurs échelles.

Les cartes obtenues sont amenées à la même échelle, puis concaténées pour alimenter les têtes de prédiction.


Ces têtes ont deux branches.

La première prédit, pixel par pixel, la probabilité d'appartenir au texte, comme dans d'autres détecteurs.

La seconde est la nouveauté ici : elle prédit une carte de seuils.

Cette carte fournit à chaque pixel son propre seuil de binarisation. Pendant l'entraînement, elle est combinée à la carte de probabilités dans une fonction de binarisation différentiable, qui donne une carte presque binaire et aide à séparer les textes voisins. À l'inférence, la carte de probabilités peut suffire ; la branche des seuils peut être omise.


L'article ne détaille pas forcément ces opérations de la même façon. Regardons l'implémentation MhLiao/DB.

Voici d'abord la branche qui prédit les régions textuelles :

python
self.binarize = nn.Sequential(
    nn.Conv2d(inner_channels, inner_channels //
                4, 3, padding=1, bias=bias),
    BatchNorm2d(inner_channels//4),
    nn.ReLU(inplace=True),
    nn.ConvTranspose2d(inner_channels//4, inner_channels//4, 2, 2),
    BatchNorm2d(inner_channels//4),
    nn.ReLU(inplace=True),
    nn.ConvTranspose2d(inner_channels//4, 1, 2, 2),
    nn.Sigmoid())

Elle reçoit les caractéristiques fusionnées de FPN, applique convolutions et déconvolutions, puis un Sigmoid qui renvoie une valeur entre 0 et 1 : la probabilité du texte.

Voici la branche qui prédit les seuils :

python
self.thresh = nn.Sequential(
    nn.Conv2d(in_channels, inner_channels //
                4, 3, padding=1, bias=bias),
    BatchNorm2d(inner_channels//4),
    nn.ReLU(inplace=True),
    self._init_upsample(inner_channels // 4, inner_channels//4, smooth=smooth, bias=bias),
    BatchNorm2d(inner_channels//4),
    nn.ReLU(inplace=True),
    self._init_upsample(inner_channels // 4, 1, smooth=smooth, bias=bias),
    nn.Sigmoid())

Elle part elle aussi des caractéristiques fusionnées, mais utilise des opérations de suréchantillonnage. Son Sigmoid fournit un seuil adaptatif entre 0 et 1 pour chaque pixel.

Pendant l'entraînement, on soustrait la carte des seuils à la carte de probabilités, puis on applique une fonction différentiable pour obtenir une approximation binaire.

python
def forward(self, features, gt=None, masks=None, training=False):

    # ...省略 FPN 特徵融合程式碼...

    # 計算文字區域圖
    binary = self.binarize(fuse)


    if self.training:
        result = OrderedDict(binary=binary)
    else:

        # 如果是推論模式,直接用文字區域圖回傳
        return binary

    # 如果是訓練模式
    if self.adaptive and self.training:
        if self.serial:
            fuse = torch.cat(
                    (fuse, nn.functional.interpolate(
                        binary, fuse.shape[2:])), 1)

        # 計算閾值圖
        thresh = self.thresh(fuse)

        # 計算近似二值圖
        thresh_binary = self.step_function(binary, thresh)

        # 加上閾值圖與近似二值圖,供訓練監督
        result.update(thresh=thresh, thresh_binary=thresh_binary)

    return result

# 二值化函數
def step_function(self, x, y):
    return torch.reciprocal(1 + torch.exp(-self.k * (x - y)))

Le titre « réseau à binarisation différentiable » devient plus clair !

Dans le code, step_function est cette opération : elle reçoit les cartes de probabilités et de seuils, calcule leur différence et produit une carte proche de 0 ou de 1, tout en restant continue et différentiable.

La formule torch.reciprocal(1 + torch.exp(-self.k * (x - y))) vous dit peut-être quelque chose…

Mais oui, c'est une fonction sigmoïde !

Ici, le coefficient kk règle la pente et la carte des seuils fournit la valeur propre à chaque pixel. Les auteurs fixent kk à 50.

La fonction devient donc :

σ(x)=11+e−50(x−y)\sigma(x) = \frac{1}{1 + e^{-50(x - y)}}

Avec ce coefficient, sa courbe devient une marche très raide : elle se comporte presque comme une binarisation dure, mais conserve des gradients pour l'apprentissage.

Génération des étiquettes

Cette étape s'inspire de PSENet :

Dans une image, le polygone de chaque région textuelle peut être décrit par des segments :

G={Sk}k=1nG = \{S_k\}_{k=1}^{n}

nn est le nombre de sommets. L'article DBNet cite quatre sommets pour ICDAR 2015 et seize pour CTW1500 à cet endroit ; l'article original du jeu CTW1500 décrit pourtant une annotation à quatorze sommets. Ces deux sources ne concordent pas sur ce point.

La région positive est construite en rétrécissant GG en GsG_s avec l'algorithme de découpage de Vatti.

La distance de rétrécissement DD dépend du périmètre LL et de l'aire AA du polygone initial :

D=A(1−r2)LD = \frac{A(1 - r^2)}{L}

Le rapport de rétrécissement rr vaut empiriquement 0,4.


Un procédé similaire produit la cible de la carte des seuils.

On agrandit d'abord le polygone GG en GdG_d avec le même décalage DD. La bande comprise entre GsG_s et GdG_d sert de frontière textuelle ; en chaque point de cette bande, l'étiquette de seuil dépend de la distance au segment de GG le plus proche.

Fonction de perte

La perte LL pondère celles de la carte de probabilités LsL_s, de la carte binaire approchée LbL_b et de la carte des seuils LtL_t :

L=Ls+α×Lb+β×LtL = L_s + \alpha \times L_b + \beta \times L_t

α\alpha et ββ valent respectivement 1,0 et 10. LsL_s et LbL_b portent sur les deux cartes indiquées.

L'article présente une même forme d'entropie croisée binaire (BCE) pour LsL_s et LbL_b. Pour compenser le déséquilibre entre pixels positifs et négatifs, il sélectionne des négatifs difficiles.

Cette perte s'écrit :

LBCE=−∑i∈Sl[yilog⁡xi+(1−yi)log⁡(1−xi)]L_{\mathrm{BCE}} = -\sum_{i \in S_l} \left[ y_i \log x_i + (1 - y_i) \log (1 - x_i) \right]

SlS_l est l'ensemble échantillonné, avec un positif pour trois négatifs. Le signe négatif, nécessaire à la BCE, manque dans l'équation (8) de l'article ; la note le rétablit. Le code public des auteurs utilise quant à lui une BCE pour la carte de probabilités et une perte Dice pour la carte binaire approchée.


La perte LtL_t est la somme des distances L1L_1 entre prédiction et étiquette des seuils, dans le polygone dilaté GdG_d :

Lt=∑i∈Rd∣yi∗−xi∗∣L_t = \sum_{i \in R_d} | y_i^* - x_i^* |

RdR_d désigne les pixels de GdG_d, et yi∗y_i^* la cible de la carte des seuils.


À l'inférence, les auteurs peuvent générer les boîtes à partir de la seule carte de probabilités et supprimer la branche des seuils pour gagner du temps.

Trois étapes suffisent :

  1. Binariser la carte de probabilités, ou la carte binaire approchée, avec un seuil fixe de 0,2.

  2. Extraire ses composantes connexes, correspondant aux régions de texte rétrécies.

  3. Dilater ces régions avec le découpage de Vatti, selon le décalage D0D_0 :

    D0=A0×r0L0D_0 = \frac{A_0 \times r_0}{L_0}

    A0A_0 et L0L_0 sont l'aire et le périmètre de la région rétrécie ; r0r_0 vaut empiriquement 1,5.

Jeux de données d'entraînement

  • SynthText

    Ce grand jeu sert au préentraînement : environ 800 000 images synthétiques combinent des scènes naturelles et du texte aux polices, tailles, couleurs et orientations variées.

  • CTW1500

    Créé par Yuliang et ses collègues pour les longs textes courbes, CTW1500 contient 1 000 images d'entraînement et 500 de test. Son article original décrit les instances par des polygones de 14 points, malgré les 16 points cités plus haut par l'article DBNet.

  • Total-Text

    Ce jeu de textes horizontaux, orientés et courbes contient 1 255 images d'entraînement et 300 de test.

  • ICDAR 2015

    ICDAR 2015 réunit 1 500 images, dont 1 000 pour l'entraînement et 500 pour le test. Les régions de texte sont annotées par des quadrilatères.

  • MSRA-TD500

    Ce jeu multilingue de longues lignes librement orientées contient 300 images d'entraînement et 200 de test, annotées au niveau des lignes. Les auteurs ajoutent les images de HUST-TR400 à l'entraînement, car le jeu initial est petit.

  • ICDAR 2017 MLT

    IC17-MLT rassemble des scènes dans neuf langues : 7 200 images d'entraînement, 1 800 de validation et 9 000 de test.

Discussion

Études d'ablation

Le tableau montre que la binarisation différentiable améliore sensiblement les résultats sur MSRA-TD500 et CTW1500. Avec ResNet-18 sans convolution déformable, la mesure F augmente respectivement de 3,7 et 4,9 points. Après suppression de la branche des seuils à l'inférence, le débit indiqué reste inchangé.

À réseau principal identique et sans DB, les convolutions déformables apportent de 1,5 à 5,0 points de mesure F en élargissant souplement le champ récepteur, pour un surcoût modéré. Sur CTW1500 sans DB, les gains sont de 3,6 points avec ResNet-18 et de 4,9 avec ResNet-50.


Les cartes des seuils avec et sans supervision se ressemblent visuellement, mais la supervision améliore les résultats. Sur MLT-2017, elle apporte 0,7 point avec ResNet-18 et 2,6 points avec ResNet-50.

ResNet-50 donne généralement de meilleurs scores que ResNet-18, au prix d'une inférence plus lente.

Résultats sur les textes courbes

Résultats Total-Text

Résultats CTW1500


Les tableaux donnent à DB de bons résultats en précision comme en vitesse, tout en montrant son aptitude aux textes courbes sur Total-Text et CTW1500.

La mesure F de DB-ResNet-50 dépasse celle du meilleur résultat antérieur cité de 1,1 point sur Total-Text et de 1,2 point sur CTW1500. Son débit est supérieur à celui des méthodes comparées qui en publient un ; passer à ResNet-18 accélère encore l'inférence, avec une légère baisse de la mesure F.

Résultats sur ICDAR 2015

Résultats ICDAR 2015


ICDAR 2015 contient de nombreux textes petits et peu résolus, orientés dans plusieurs directions.

Dans le tableau, DB-ResNet-50 avec un grand côté de 1152 pixels obtient la meilleure précision citée. Comparé à EAST, méthode antérieure la plus rapide du tableau, DB-ResNet-50 à 736 pixels gagne 7,2 points de mesure F et tourne environ deux fois plus vite.

Avec ResNet-18 à 736 pixels, DB atteint 48 images/s et 82,3 % de mesure F.

Résultats visuels

À droite de chaque groupe, la carte du haut représente les seuils prédits et celle du bas les probabilités. Les contours verts montrent les résultats après post-traitement.

Conclusion

DB apporte une binarisation différentiable que l'on peut apprendre avec le réseau de segmentation. À l'inférence, la carte de probabilités permet ensuite de former les régions détectées avec un post-traitement simple. Les résultats rapportés sur plusieurs jeux montrent une bonne combinaison de précision et de vitesse.

En pratique, DB est souvent utilisé pour le déploiement, surtout grâce à sa vitesse. Son architecture est aussi simple à entraîner. On retrouve des implémentations de cette approche dans des systèmes d'OCR tels que PaddleOCR ou MMOCR.

Comme nous venons de le voir, le passage le plus difficile de l'article est finalement la fonction de binarisation. (Vraiment ?)

L'architecture atténue surtout le problème des textes voisins qui se touchent : elle rend leurs régions plus faciles à séparer. Elle ne résout pas tous les cas où des textes se chevauchent réellement. La suite des recherches reste donc intéressante à suivre.