Retour à la bibliothèque
arXiv 2018CVPR 2018Reconnaissance facialeNotes de lecture

CosFace

Une grande marge cosinus

Article original

CosFace: Large Margin Cosine Loss for Deep Face Recognition

Auteurs de l’article

Hao Wang · Yitong Wang · Zheng Zhou …

Afficher les 8 auteurs

Hao Wang · Yitong Wang · Zheng Zhou · Xing Ji · Dihong Gong · Jingchao Zhou · Zhifeng Li · Wei Liu

Publication
CVPR 2018Conférence
Premier dépôt sur arXiv
arXiv:1801.09414
Citer cet article · BibTeX

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

@misc{facerecognitioncosface2018,
  title = {{CosFace: Large Margin Cosine Loss for Deep Face Recognition}},
  author = {Hao Wang and Yitong Wang and Zheng Zhou and Xing Ji and Dihong Gong and Jingchao Zhou and Zhifeng Li and Wei Liu},
  year = {2018},
  eprint = {1801.09414},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/1801.09414}
}
Sur cette page

La reconnaissance faciale intéressait les chercheurs bien avant que l'apprentissage profond ne devienne courant. Ses nombreuses applications concrètes en ont fait un sujet très étudié ces dernières années.

Définir le problème

Reconnaître un visage n'est pas tout à fait une classification ordinaire :

  • Les visages se ressemblent beaucoup !

À la différence d'une classification sur ImageNet, deux photos de la même personne peuvent varier fortement avec la lumière, l'angle, l'expression ou même la caméra.

On décrit souvent le problème avec deux propriétés :

  1. Une grande variabilité intra-classe : les photos d'une même personne peuvent différer par la lumière, la pose, l'expression ou l'âge.
  2. Une faible variabilité inter-classes : tous les visages partagent une structure générale ; les différences entre personnes peuvent donc être fines.

Un système de reconnaissance faciale

Un système de reconnaissance faciale comprend généralement :

  1. Un extracteur de caractéristiques : souvent un réseau convolutif qui transforme le visage en un vecteur de longueur fixe.
  2. Un objectif discriminant à l'entraînement : la perte pousse les vecteurs d'identités différentes à se séparer. Au déploiement, on extrait les vecteurs et on calcule leur similarité.

Nous n'allons pas nous attarder sur l'extracteur de caractéristiques : il évolue avec les nouvelles architectures de réseau.

Il produit un vecteur ff, souvent à 512 dimensions dans les configurations étudiées ici.

C'est ce vecteur qui nous intéresse. Les modèles entraînés uniquement avec la perte softmax ordinaire peuvent manquer de pouvoir discriminant près des frontières entre identités.

C'est le problème auquel s'attaque cet article.

Résoudre le problème

La fonction de perte

Suivons les auteurs pour voir comment ils modifient progressivement la perte softmax.

  1. Perte softmax :

    LSoftmax=1N∑i=1N−log⁡(efyi∑j=1Cefj)L_{\text{Softmax}} = \frac{1}{N}\sum_{i=1}^{N}-\log\left(\frac{e^{f_{y_i}}}{\sum_{j=1}^{C}e^{f_j}}\right)

    fjf_j est le logit de la classe jj, yiy_i la classe de la ii-ième image, CC le nombre de classes et NN la taille du lot.

    Le logit est la sortie d'une couche entièrement connectée : fj=WjTx+Bjf_j = W_j^Tx+B_j, avec un vecteur de poids WjW_j et un biais BjB_j.

    Pour simplifier, les auteurs fixent Bj=0B_j = 0, donc fj=WjTxf_j = W_j^Tx. Le produit scalaire peut alors s'écrire :

    fj=∥Wj∥∥x∥cos⁡θjf_j = \|W_j\|\|x\|\cos\theta_j

    θj\theta_j est l'angle entre WjW_j et xx.

    Jusqu'ici, nous n'avons rien changé : nous avons seulement décrit la perte softmax.

  2. Softmax normalisé (Normalized Softmax Loss, NSL) :

    Les auteurs prennent ensuite NSL comme point de comparaison.

    Ils normalisent WjW_j en norme L2 pour fixer ∥Wj∥=1\|W_j\|=1, et donnent à xx la norme constante ss. On obtient fj=scos⁡θjf_j = s\cos\theta_j.

    En fixant ces normes, les variations radiales disparaissent du logit. La perte dépend alors de l'angle :

    LNSL=1N∑i−log⁡(escos⁡(θyi)∑jescos⁡(θj))L_{\text{NSL}} = \frac{1}{N}\sum_{i}-\log\left(\frac{e^{s \cos(\theta_{y_i})}}{\sum_{j} e^{s \cos(\theta_j)}}\right)

    L'apprentissage se concentre ainsi sur l'espace angulaire et peut produire des caractéristiques plus discriminantes.

  3. Perte cosinus à grande marge (Large Margin Cosine Loss, LMCL) :

    NSL ne sépare cependant pas assez fortement les caractéristiques. Les auteurs ajoutent donc une marge dans la formulation cosinus de la perte softmax.

    Prenons deux classes : θi\theta_i est l'angle entre le vecteur de caractéristiques et le poids de la classe CiC_i.

    NSL distingue C1C_1 de C2C_2 en exigeant cos⁡(θ1)>cos⁡(θ2)\cos(\theta_1)>\cos(\theta_2) pour un exemple de C1C_1.

    Pour imposer une marge plus grande, on demande :

    • cos⁡(θ1)−m>cos⁡(θ2)\cos(\theta_1) - m > \cos(\theta_2)
    • cos⁡(θ2)−m>cos⁡(θ1)\cos(\theta_2) - m > \cos(\theta_1)

    m≥0m \geq 0 règle la marge cosinus. La première condition concerne un exemple dont la vraie classe est C1C_1, la seconde un exemple de C2C_2 ; un même exemple ne doit pas satisfaire les deux à la fois.

    La perte LMCL s'écrit alors :

    LLMCL=1N∑i−log⁡(es(cos⁡(θyi)−m)es(cos⁡(θyi)−m)+∑j≠yiescos⁡(θj))L_{\text{LMCL}} = \frac{1}{N}\sum_{i}-\log\left(\frac{e^{s(\cos(\theta_{y_i}) - m)}}{e^{s(\cos(\theta_{y_i}) - m)} + \sum_{j \neq y_i} e^{s \cos(\theta_j)}}\right)

    Avec les contraintes de normalisation suivantes :

    W=W∗∥W∗∥,x=x∗∥x∗∥,cos⁡(θj,i)=WjTxiW = \frac{W^*}{\|W^*\|}, \quad x = \frac{x^*}{\|x^*\|}, \quad \cos(\theta_j, i) = W_j^T x_i

    Ici, NN compte les exemples d'entraînement, xix_i est le vecteur du ii-ième exemple de vraie classe yiy_i, WjW_j le poids de la classe jj et θj\theta_j leur angle.

Les formules en tête, regardons maintenant le dessin :

Le softmax initial ne fixe pas les normes des poids et des caractéristiques. Dans l'espace de similarité cosinus, les régions de décision des deux classes peuvent se chevaucher.

NSL normalise ces vecteurs et crée une frontière entre classes, mais sans intervalle de marge : les exemples proches de la frontière restent difficiles à distinguer.

LMCL impose un écart plus visible entre les régions de décision et incite le modèle à mieux séparer les caractéristiques dans l'espace angulaire.

A-Softmax est une autre méthode antérieure. Ses contraintes sont :

  • cos⁡(mθ1)≥cos⁡(θ2)\cos(m\theta_1) \geq \cos(\theta_2)
  • cos⁡(mθ2)≥cos⁡(θ1)\cos(m\theta_2) \geq \cos(\theta_1)

Sa marge dépend de θ\theta : elle diminue avec l'angle et disparaît quand θ=0\theta=0. Le modèle peut alors moins bien distinguer les exemples dont l'angle est très faible.

Le paramètre ss

Pour apprendre des caractéristiques discriminantes sur l'hypersphère, la marge cosinus joue un rôle important.

Pour LMCL, les auteurs dérivent une borne inférieure de l'échelle ss sous une condition de probabilité a posteriori minimale :

s≥C−1Clog⁡(C−1)PW1−PWs \geq \frac{C - 1}{C} \log \frac{(C - 1)P_W}{1 - P_W}

CC est le nombre de classes et PWP_W la probabilité a posteriori minimale visée au centre d'une classe.

À PWP_W fixé, augmenter le nombre de classes accroît la valeur nécessaire de ss.

Une valeur ss suffisante donne aux caractéristiques de norme fixe une échelle de logits adaptée à l'entraînement. La manière dont le nombre de classes et la dimension des caractéristiques bornent mm est le sujet suivant.

Le paramètre mm

Le graphique illustre huit identités dans un espace à deux dimensions, avec m=0m=0, 0.10.1 et 0.20.2.

Dans cet exemple schématique, les classes semblent mieux séparées quand mm augmente. Ces points en deux dimensions ne mesurent pas directement la précision d'une vérification faciale réelle.


Considérons deux classes et un vecteur de caractéristiques normalisé xx.

WiW_i est le poids normalisé de la classe ii, et θi\theta_i l'angle entre xx et WiW_i.

Avec NSL, la frontière est cos⁡θ1−cos⁡θ2=0\cos\theta_1-\cos\theta_2=0 : elle coïncide avec la bissectrice de W1W_1 et W2W_2. Les caractéristiques près de cette frontière sont difficiles à attribuer à une classe.

Avec LMCL, la frontière d'un exemple de la première classe satisfait cos⁡θ1−cos⁡θ2=m\cos\theta_1-\cos\theta_2=m. Il faut donc réduire davantage θ1\theta_1 par rapport à θ2\theta_2. L'objectif augmente la séparation entre classes et réduit leur dispersion interne ; la marge angulaire possible dépend de l'angle entre W1W_1 et W2W_2.

Dans le cas extrême où toutes les caractéristiques d'une classe coïncident exactement avec leur centre WiW_i, la marge atteint sa limite théorique en espace cosinus.

Plus généralement, avec CC classes distinctes, la plage théorique de la marge est :

0≤m≤(1−max⁡(WiTWj)),i,j≤C, i≠j0 \leq m \leq (1 - \max(W_i^T W_j)), \quad i, j \leq C, \, i \neq j

Dans une analyse idéalisée, écarter les poids de classes différentes aide à mieux séparer leurs caractéristiques.

Une répartition uniforme sur l'hypersphère unitaire constitue le cas idéal envisagé, et non un optimum garanti du softmax ordinaire.

Les bornes suivantes reposent sur cette hypothèse de centres aussi régulièrement répartis que possible :

0≤m≤1−cos⁡(2πC),(K=2)0 \leq m \leq 1 - \cos\left(\frac{2\pi}{C}\right), \quad (K = 2) 0≤m≤CC−1,(C≤K+1)0 \leq m \leq \frac{C}{C - 1}, \quad (C \leq K + 1) 0≤m≪CC−1,(C>K+1)0 \leq m \ll \frac{C}{C - 1}, \quad (C > K + 1)

CC est le nombre de classes et KK la dimension des caractéristiques apprises.

Ces inégalités reposent sur une dispersion idéale des centres. Lorsque C>K+1C>K+1, le texte original exige expressément que mm reste bien plus petit que C/(C−1)C/(C-1), plutôt que de reprendre la borne du cas précédent.

En pratique, on ne peut généralement pas atteindre la borne théorique. Une marge trop grande rend la contrainte cosinus difficile à satisfaire, empêche la convergence et augmente la sensibilité aux étiquettes bruitées.

Mise en œuvre

La théorie sert à vérifier que l'idée tient debout.

En pratique, CosFace est assez simple à coder :

python
import torch
import torch.nn as nn

class CosFace(nn.Module):

    def __init__(self, s=64.0, m=0.35):
        super(CosFace, self).__init__()
        self.s = s
        self.m = m

    def forward(self, logits: torch.Tensor, labels: torch.Tensor):
        index = torch.where(labels != -1)[0]
        target_logit = logits[index, labels[index].view(-1)]
        final_target_logit = target_logit - self.m
        logits[index, labels[index].view(-1)] = final_target_logit
        logits = logits * self.s
        return logits

Le code soustrait mm uniquement au logit cosinus de la bonne classe, puis multiplie tous les logits par ss. Il attend en entrée les cosinus calculés à partir des caractéristiques et des poids normalisés, avant tout softmax.

On peut ensuite appliquer une perte CrossEntropyLoss ordinaire aux logits modifiés.

Discussion

Effet de mm

  1. Protocole :

    • Les auteurs font varier mm de 0 à 0,45.
    • Ils entraînent CosFace sur le petit jeu CASIA-WebFace.
    • Ils l'évaluent sur LFW et YTF.
  2. Résultats :

    • Sans marge (m=0m=0), les performances sont les plus faibles.
    • De m=0m=0 à m=0.35m=0.35, la précision augmente sur les deux jeux ; à m=0.45m=0.45, elle redescend sous celle obtenue à 0,35.
    • Dans ce protocole, m=0.35m=0.35 donne les meilleurs scores sur LFW et YTF.
    • Au-delà de 0,45, le modèle ne converge plus.
  3. Conclusion :

    • La marge améliore le pouvoir discriminant des caractéristiques apprises.
    • Les expériences suivantes fixent mm à 0,35.

Effet de la normalisation des caractéristiques

  1. Protocole :

    • Les auteurs comparent CosFace avec et sans normalisation des caractéristiques.
    • L'entraînement utilise CASIA-WebFace avec m=0.35m=0.35.
    • Les évaluations portent sur LFW, YTF et MegaFace Challenge 1 (MF1).
  2. Résultats :

    • Le modèle sans normalisation est d'abord initialisé avec une perte softmax, puis entraîné sous LMCL.
    • Le modèle avec normalisation obtient de meilleurs résultats sur les trois jeux.
  3. Conclusion :

    • Fixer la norme radiale concentre l'apprentissage sur les différences angulaires.
    • L'expérience confirme l'intérêt de la normalisation dans ce protocole.

Comparaison avec d'autres pertes

  1. Protocole :

    • Les auteurs entraînent le modèle sur CASIA-WebFace.
    • Ils utilisent le même CNN à 64 couches que SphereFace.
    • Ils comparent LFW, YTF et MF1.
  2. Conditions de comparaison :

    • La structure du modèle et les détails du protocole suivent ceux de SphereFace.
    • Les autres pertes sont évaluées dans ces mêmes conditions.
  3. Résultats :

    • LMCL obtient 99,33 % sur LFW, sous les 99,42 % d'A-Softmax et juste au-dessus des 99,32 % d'A-Softmax-NormFea.
    • Sur YTF et MF1, LMCL atteint respectivement 96,1 %, 77,11 % en Rank-1 et 89,88 % en vérification. Ces valeurs dépassent les autres pertes du tableau, entraînées sur les mêmes données avec le CNN à 64 couches.

Conclusion

Les auteurs proposent CosFace, ou Large Margin Cosine Loss (LMCL), pour apprendre des caractéristiques plus discriminantes. Ils montrent comment la normalisation et une marge cosinus appliquée à la bonne classe modifient la perte softmax et améliorent les résultats dans les évaluations étudiées.

Dans les tâches de reconnaissance faciale testées par l'article, cette méthode offre une façon simple d'améliorer la séparation des identités. Son utilité dans d'autres domaines demande une évaluation propre à chaque contexte.