Interprétation du modèle SSD (5) Interprétation du code pièce de la fonction de perte Perte

guide

Interprétation personnelle, uniquement pour les notes d'étude
Article de référence : jardin de blog
détaillé sur la perte de SSD
 : notes d'apprentissage en profondeur (7) Les notes de lecture sur papier SSD simplifient
Pytorch Créez votre propre plate-forme de détection de cibles SSD

Le but de la fonction de perte est de faire en sorte que le résultat de la prédiction se rapproche sans fil du résultat réel, c'est-à-dire de rendre la prédiction du modèle précise, et son essence est de calculer,Une fonction de la distance entre le résultat prédit et le résultat réel. Tels que L1Loss :

Le but de l'apprentissage supervisé est de faire en sorte que les résultats de la formation se rapprochent des résultats réels, de sorte que plus la fonction de perte est petite, meilleur est l'effet d'approximation et meilleur est l'effet de formation du modèle. Avec différentes stratégies de perte, la vitesse de descente du gradient est différente, il est donc nécessaire de sélectionner une fonction de perte appropriée en fonction du contenu de la recherche.
La position du calcul de la perte dans la formation est illustrée dans la figure:

La fonction Loss calcule la différence entre la valeur prédite et la valeur réelle.La trame prédite sera générée selon le format de la trame réelle, et elle sera calculée lorsque le format de la trame prédite est cohérent avec la trame réelle, regardons le format de la boîte réelle avant de calculer, la boîte réelle est représentée par le décalage relatif de 8732 boîtes d'ancrage, 264 premiers chiffresest le décalage du repère réel par rapport au repère d'ancrage (ici le type de coordonnée du repère d'ancrageest [x, y, w, h]），5ème placeUtilisé pour juger s'il s'agit de l'arrière-plan,1 dernier chiffreIl est utilisé pour juger s'il s'agit d'une cible ou non. Les 20 chiffres du milieu sont des catégories. En fait, ce n'est que lorsque le cadre réel correspond au cadre d'ancrage que le cadre d'ancrage correspondant est traité. La valeur du cadre qui ne correspond pas est la valeur par défaut Enfin, encore un point.Une boîte d'ancrage ne peut correspondre qu'à une seule boîte de vérité au sol, et une boîte de vérité au sol peut correspondre à plusieurs boîtes d'ancrage：

[ x,y,l,h,arrière-plan,...genre...,cible ]

Les détails peuvent être vus ici : Avant que les données ne soient chargées, le cadre réel est traité pour le convertir dans un format relatif au décalage du cadre d'ancrage

Le cinquième chiffre de la trame de prédiction correspond à l'arrière-plan et le dernier chiffre correspond à la cible. La trame de prédiction dont l'étiquette est définie comme arrière-plan est un échantillon négatif, et celle dont l'étiquette n'est pas l'arrière-plan est un échantillon positif. Habituellement, le nombre d'échantillons négatifs est beaucoup plus important que celui des échantillons positifs, ce qui entraîne une perte.Lors du calcul, ne prenez pas tous les échantillons négatifs pour le calcul. Selon le ratio d'échantillons positifs et négatifs, un certain nombre d'échantillons négatifs sont sélectionnés en fonction du nombre d'échantillons positifs.
Pour la sélection d'échantillons négatifs, on l'appelle "extraction d'échantillons difficiles" dans le document. En fait, il s'agit de trier les échantillons négatifs en fonction de la taille de la perte, et de sélectionner les n premiers échantillons négatifs avec une grande perte pour la mise à jour du gradient.
En résumé, la perte finale de ssd est la perte totale des échantillons positifs et négatifs sélectionnés.

La fonction de perte se compose d'une fonction de perte de classification (conf) et d'une fonction de perte de localisation (loc)

Voici les images et les explications dans l'article de référence :

Soit chaque case précédente calculée par le coefficient de Jaccard (Est-ce que l'intersection IOU et le calcul de l'union) et la similarité de la trame réelle, seuls ceux dont le seuil est supérieur à 0,5 peuvent être inclus dans la liste des candidats (Le fond des 8732 cases est à 0 après la conversion de la vraie case par rapport à la case d'ancrage); Supposons que N cases avec un degré d'appariement supérieur à 50 % soient sélectionnées, nous laissons i représenter la i-ième trame par défaut, j représenter la j-ième trame réelle, et p représenter la p-ième classe. Alors $X_{je,j}^{}$Indique le coefficient de Jaccard faisant correspondre la i-ième case a priori (boîte d'ancrage) avec la j-ième case de vérité terrain (boîte réelle) de catégorie p, sinon, alors xi , jp x_{i,j}^{p $X_{je,j}^{}$=0. La fonction de perte objective totale est la somme pondérée de la perte de localisation (loc) et de la perte de confiance (conf) :

• N est le nombre de cases précédentes qui correspondent à la case de vérité terrain (la somme des vrais échantillons et des échantillons négatifs)
• la perte de localisation (loc) est la perte L1 lisse dans Fast R-CNN, utilisée dans les paramètres de la boîte de prédiction (l) et de la boîte de vérité au sol (g) (c'est-à-dire la position des coordonnées centrales, la largeur, la hauteur), retour à la position centrale des boîtes englobantes, et largeur, hauteur
• La perte de confiance (conf) est Softmax Loss, l'entrée est la confiance c de chaque catégorie
• Le terme de poids α est mis à 1 par défaut

Fonction de perte de classification

La fonction de perte de classification utilise softmax_loss() et le calcul d'entropie croisée après softmax. Dans la formule suivante, le softmax_loss des échantillons positifs et négatifs est sélectionné comme contenu du calcul de perte de classification, et le nombre d'échantillons négatifs est sélectionné en fonction du rapport des échantillons positifs et négatifs, de sorte qu'il y a en fait de nombreux échantillons négatifs qui ont été passés . dans le codeCalculez d'abord la perte de classification de tous les échantillons, puis choisissez la somme des pertes des échantillons positifs et négatifs。

• Calculez softmax_loss pour tous les échantillons :

        #   batch_size,8732,21 -> batch_size,8732
        # --------------------------------------------- #
        conf_loss = self._softmax_loss(y_true[:, :, 4:-1], y_pred[:, :, 4:])
     def _softmax_loss(self, y_true, y_pred):
        #torch.clamp将输入input张量每个元素的夹紧到区间 [min,max]，并返回结果到一个新张量。
        y_pred = torch.clamp(y_pred, min = 1e-7)
        softmax_loss = -torch.sum(y_true * torch.log(y_pred),
                                      axis=-1)
        return softmax_loss

• choisiréchantillon positifLa fonction de perte de classification de et additionnée :

		#batch_size,8732
        pos_conf_loss = torch.sum(conf_loss * y_true[:, :, -1],
                                      axis=1)

• sélectionneréchantillon négatifLa fonction de perte de classification pour :

Dans le résultat de la prédiction, les valeurs prédites de chaque trame de prédiction qui n'est pas l'arrière-plan sont additionnées.Plus la probabilité après la sommation est élevée, plus il est difficile de classer la trame de prédiction. Après avoir trié du plus grand au plus petit, sortez de la boîte de prédiction du nombre total d'échantillons négatifs, en pensant qu'il s'agit d'échantillons négatifs. En supposant qu'il y a 1245 échantillons négatifs, le format change lors de la sélection :

[batch_size,8732,20]->[batch_size,8732]->[batch_size,1245] puis selon le process spécifique
de ces 100 échantillons négatifs (sera ajouté ultérieurement) :

1. Comptez le nombre d'échantillons positifs pour chaque image :

		#num_pos [batch_size,]
        num_pos = torch.sum(y_true[:, :, -1], axis=-1)

2. Comptez le nombre d'échantillons négatifs par image :

Extrayez les échantillons positifs selon le rapport des échantillons positifs et négatifs, sélectionnez ici les échantillons négatifs selon 1:3 :

        num_neg = torch.min(self.neg_pos_ratio * num_pos, num_boxes - num_pos)

4. Compter le nombre d'échantillons négatifs dans chaque lot (16 photos) :

  		num_neg_batch = torch.sum(num_neg)

5. Choisissez les cases prédites qui sont l'arrière-plan :

Le dernier chiffre du cadre de prédiction est utilisé pour évaluer la cible.
Vous pouvez sélectionner le cadre de prédiction qui est l'arrière-plan en fonction du dernier chiffre :

        max_confs   = (max_confs * (1 - y_true[:, :, -1])).view([-1])

Vous pouvez également sélectionner la case de prédiction qui est le fond selon la 5ème position :

        max_confs   = (max_confs * y_true[:, :, 4]).view([-1])

Trouvez les valeurs k avec la plus grande somme de probabilités, où k est le nombre d'échantillons négatifs.
Trouver l'index des échantillons négatifs par la fonction torch.topk()

		#torch.topk
        #返回列表中最大的n个值
        #input -> 输入tensor
        # k -> 前k个
        # dim -> 默认为输入tensor的最后一个维度
        # sorted -> 是否排序
        # largest -> False表示返回第k个最小值
        #indeces 负样本的索引
        _, indices  = torch.topk(max_confs, k = int(num_neg_batch.cpu().numpy().tolist()))

Étalez ensuite toutes les fonctions de perte de classification des images batch_size et trouvez les valeurs de perte de ces échantillons négatifs en fonction de l'indice.
Par exemple, k est 1245, il y a 16 images au total, chaque image a 8732 cases, toutes les tuiles ont 16*8732=139712 cases, et 1245 fonctions de perte de classification sont sélectionnées selon l'index.

        #torch.gather作用：收集输入的特定维度指定位置的数值
        # input(tensor): 待操作数。
        # dim(int): 待操作的维度。
        # index(LongTensor): 如何对input进行操作.
        neg_conf_loss = torch.gather(conf_loss.view([-1]), 0, indices)

À ce stade, la fonction de perte de classification de l'échantillon négatif est obtenue.

fonction de perte de régression

La fonction de perte de régression calcule non seulement la différence entre l'image prédite et les coordonnées de l'image réelle.

La fonction de perte de position de l'algorithme SSD :

comme indiqué dans la formule, il y a $X_{je,j}^{}$, lorsque les échantillons positifs $X_{je,j}^{}=1$ , 0 pour les échantillons négatifs. doncLa fonction de perte de position ne fonctionne que sur des échantillons positifs.
Voici l1_smooth_loss :
$$L_{}=\sum _{je=1}|l-g|$$
$l$ est les coordonnées prédites du cadre,$g$ est les coordonnées réelles du cadre, soit$X=|l-g|$，$x$ est la différence entre la trame prédite et la trame réelle.

Dans le code, le l1_Smooth_loss de toutes les boîtes de prédiction et de toutes les boîtes réelles est calculé en premier, puis les résultats de calcul des échantillons positifs sont sélectionnés comme valeur de la fonction de perte de position du modèle SSD.

Calculez la perte de position pour toutes les cases :

        loc_loss = self._l1_smooth_loss(y_true[:, :, :4],
                                        y_pred[:, :, :4])
    def _l1_smooth_loss(self, y_true, y_pred):
        abs_loss = torch.abs(y_true - y_pred)
        sq_loss = 0.5 * (y_true - y_pred)**2
        l1_loss = torch.where(abs_loss < 1.0, sq_loss, abs_loss - 0.5)
        return torch.sum(l1_loss, -1)

Sélectionnez la perte de position de tous les échantillons positifs et additionnez :

        pos_loc_loss = torch.sum(loc_loss * y_true[:, :, -1],
                                     axis=1)

Terminez le calcul de la fonction de perte de position.

Fonction de perte Perte

Après avoir additionné la fonction de perte de classification et la fonction de perte de position des échantillons positifs et négatifs calculés ci-dessus et pris la moyenne, il s'agit de la valeur de la fonction de perte du modèle SSD.

        total_loss  = torch.sum(pos_conf_loss) + torch.sum(neg_conf_loss) +torch.sum(self.alpha * pos_loc_loss)
        total_loss  = total_loss / torch.sum(num_pos)