La mise en œuvre de contrastive de la perte et de triplet perte de Tensorflow

J'ai commencé à jouer avec TensorFlow il y a deux jours et je me demandais si il est le triplet et le contrastive des pertes de mis en œuvre.

J'ai été à la recherche à la documentation, mais je n'ai pas trouvé d'exemple ou de la description à propos de ces choses.

InformationsquelleAutor Tiago Freitas Pereira | 2016-07-08
  1. 69

    Mise à jour (2018/03/19): j'ai écrit un post de blog détaillant la façon de mettre en œuvre triplet perte de TensorFlow.

    Vous avez besoin pour mettre en œuvre vous-même les contrastive de la perte ou du triplet de la perte, mais une fois que vous connaissez les paires ou triplets c'est assez facile.

    Contrastive Perte

    Supposons que vous avez comme entrée les paires de données et de leur label (positif ou négatif, c'est à dire d'une même classe ou d'une autre classe). Par exemple, vous avez des images en entrée de taille 28x28x1:

    left = tf.placeholder(tf.float32, [None, 28, 28, 1])
right = tf.placeholder(tf.float32, [None, 28, 28, 1])
label = tf.placeholder(tf.int32, [None, 1]). # 0 if same, 1 if different
margin = 0.2

left_output = model(left)  # shape [None, 128]
right_output = model(right)  # shape [None, 128]

d = tf.reduce_sum(tf.square(left_output - right_output), 1)
d_sqrt = tf.sqrt(d)

loss = label * tf.square(tf.maximum(0., margin - d_sqrt)) + (1 - label) * d

loss = 0.5 * tf.reduce_mean(loss)

    Triplet Perte

    Même avec contrastive de la perte, mais avec des triplets (ancre, positif, négatif). Vous n'avez pas besoin d'étiquettes ici. 

    anchor_output = ...  # shape [None, 128]
positive_output = ...  # shape [None, 128]
negative_output = ...  # shape [None, 128]

d_pos = tf.reduce_sum(tf.square(anchor_output - positive_output), 1)
d_neg = tf.reduce_sum(tf.square(anchor_output - negative_output), 1)

loss = tf.maximum(0., margin + d_pos - d_neg)
loss = tf.reduce_mean(loss)

    Les vrais problèmes lors de la mise en œuvre de triplet de perte ou contrastive perte de TensorFlow est comment échantillonner les triplets ou des paires de. Je vais me concentrer sur la génération de triplets parce qu'il est plus difficile de générer des paires.

    Le plus simple est de les générer à l'extérieur de la Tensorflow graphique, c'est à dire en python et les nourrir pour le réseau à travers les espaces réservés. Fondamentalement, vous sélectionnez des images 3 à la fois, avec les deux premiers dans la même catégorie et la troisième d'une autre classe. Nous effectuons ensuite une anticipation sur ces triplets, et de calculer le triplet perte.

    Le problème ici est que la génération de triplets est compliqué. Nous voulons qu'ils soient valide triplets, triplés avec un positif de la perte (dans le cas contraire, la perte est de 0 et le réseau n'a pas à apprendre).

    Pour savoir si un triplet qui est bon ou non vous avez besoin de calculer sa perte, afin de vous faire déjà une anticipation à travers le réseau...

    Clairement, la mise en œuvre de triplet perte de Tensorflow est dur, et il y a des façons de le rendre plus efficaces que l'échantillonnage en python, mais en expliquant pourrait faire l'objet d'un blog ensemble !

    • Salut @Olivier, je suis très intéressé par l'échantillonnage de la partie. Etes-vous ou avez-vous écrit un blog pour elle? Je suis en train de faire ce que vous avez dit, pour se nourrir qu'une fois, et calculer les pertes pour tous les triplets, filtrer invalides, et l'échantillon d'un lot pour en faire un autre avant+arrière...
    • Ne pas écrire n'importe quel blog. Une idée clé est de calculer tous les triplets comme expliqué dans OpenFace, ma réponse ci-dessus contient l'ancienne solution. Pour enlever le milieu sess.run() appel, vous pouvez ajouter un tf.py_func fonctionnement à l'intérieur du graphique pour filtrer les mauvais triplets.
    • Une autre façon pour la 2ème partie est de calculer la perte de tous les triplets, en excluant uniquement les invalides, des triplets (c'est à dire (+, +, +)), qui peut être calculée à l'avance. Cette converge bien, étonnamment.
    • merci pour ce conseil. Je n'ai pas eu l'idée de ce moment, mais l'a trouvé très utile récemment. Ce processus mis en œuvre en tf m'a aidé à réduire le temps de formation de 5 jours à 1 jour. 🙂
    • Ouais il est très pratique. Avez-vous la mettre en œuvre sans tf.py_func (la deuxième idée que j'ai donné)?
    • Pas de. J'ai mis en place, il est presque le même que ce qui est dit dans le OpenFace l'article. J'ai utilisé de la tf.nn.relu() pour filtrer inutiles pertes, et de compter combien de pertes sont de gauche, disons C, puis la perte moyenne est la somme(pertes)/C.
    • comment avez-vous réussi à sélectionner uniquement la validité de triplets pour la formation? Quand j'ai vérifier si la perte est > 0 pour un ensemble de triplets (ancre image, image positive, négative de l'image), j'ai pour nourrir les triplets de nouveau le modèle pour calculer les gradients. Et parce que je utiliser d'abandon, les mêmes triplets pourrait donner perte de 0, lors de la prochaine tétée. Je suis coincé.
    • pouvez-vous veuillez donner un exemple de filtrage de mauvais triplets à l'aide de py_func?
    • Pourquoi d est utilisé à la place de sqrt_d à la fin de la première mission à loss dans contrastive de la perte?
    • C'est la formule pour contrastive de la perte
    • J'ai finalement écrit ce billet de blog. Elle est ici: omoindrot.github.io/triplet de perte
    • J'ai finalement écrit ce billet de blog. Elle est ici: omoindrot.github.io/triplet de perte
    • Le code de Contrastive de la Perte doit être modifié un peu pour éviter NaN erreur. c'est à dire d_sqrt = tf.sqrt(d + 1e-7). Nous avons utilisé le code et trouvé le bug.
    • votre tuto est génial. Merci!

    InformationsquelleAutor Olivier Moindrot
  2. 11

    Triplet perte de semihard négatifs de l'exploitation minière est maintenant mis en œuvre dans tf.contrib, comme suit:

    triplet_semihard_loss(
    labels,
    embeddings,
    margin=1.0
)

    où:

    Args:

    • étiquettes: 1-D tf.int32 Tenseur de la forme [batch_size] de la multiclasse
      étiquettes entières.

    • plongements: 2-D float Tenseur de l'intégration des vecteurs.Plongements devrait
      soit l2 normalisé.

    • marge: Float, marge terme dans theloss définition.

    Retourne:

    • triplet_loss: tf.float32 scalaire.

    Pour de plus amples informations, consultez le lien ci-dessous:

    https://www.tensorflow.org/versions/master/api_docs/python/tf/contrib/losses/metric_learning/triplet_semihard_loss

    • Lien seules réponses? Inclure certaines parties pertinentes à partir du lien ici.
    • Alors que ce lien pourrait fournir quelques limitée, de l'aide immédiate, une réponse doit comporter suffisamment de contexte autour du lien ainsi les autres utilisateurs auront une idée de ce qu'il est et pourquoi il est là. Toujours citer la partie la plus pertinente d'un lien important, pour le rendre plus utile pour les futurs lecteurs avec d'autres, des questions similaires. En outre, les autres utilisateurs ont tendance à réagir négativement aux réponses qui y sont à peine plus d'un lien vers un site externe, et ils peut-être être supprimé.
    InformationsquelleAutor Corey Lynch
  3. 5

    Tiago, je ne pense pas que vous êtes en utilisant la même formule Olivier a donné.
    Voici le bon code (pas sûr que ça va fonctionner, cependant, seulement la fixation de la formule) :

    def compute_euclidean_distance(x, y):
    """
    Computes the euclidean distance between two tensorflow variables
    """

    d = tf.reduce_sum(tf.square(tf.sub(x, y)),1)
    return d


def compute_contrastive_loss(left_feature, right_feature, label, margin):

    """
    Compute the contrastive loss as in


    L = 0.5 * Y * D^2 + 0.5 * (Y-1) * {max(0, margin - D)}^2

    **Parameters**
     left_feature: First element of the pair
     right_feature: Second element of the pair
     label: Label of the pair (0 or 1)
     margin: Contrastive margin

    **Returns**
     Return the loss operation

    """

    label = tf.to_float(label)
    one = tf.constant(1.0)

    d = compute_euclidean_distance(left_feature, right_feature)
    d_sqrt = tf.sqrt(compute_euclidean_distance(left_feature, right_feature))
    first_part = tf.mul(one-label, d)# (Y-1)*(d)

    max_part = tf.square(tf.maximum(margin-d_sqrt, 0))
    second_part = tf.mul(label, max_part)  # (Y) * max(margin - d, 0)

    loss = 0.5 * tf.reduce_mean(first_part + second_part)

    return loss
    • Salut Wasssim, merci pour le correctif, juste un patch dans votre code. d_sqrt = tf.sqrt(compute_euclidean_distance(left_feature, right_feature)), Mais même avec cette correction, je reçois très faible précision (mais la perte diminue comme prévu).
    • Je vais avoir le même problème avec mon triplet de perte de mise en œuvre. Je vous avertira si je trouve une solution...
    • Hey @Wassim, merci. Si c'est plus facile, vous pouvez essayer de bootstrap mon projetgithub.com/tiagofrepereira2012/examples.tensorflow).
    • il semble que cela a à voir avec la façon dont nous mettons en œuvre la précision de calcul. Regarde comme lors de l'utilisation de Triplet de Perte ou Contrastive de Perte, vous ne pouvez pas calculer la précision à l'aide de l'étiquette de vérification (parce que le réseau n'était pas formé pour différencier les 10 classes), cependant, vous devez calculer la précision en évaluant si le réseau deviné que les deux éléments sont de la même classe ou non.
    • Voir la section 4 et 5.6 du présent document de arxiv.org/pdf/1503.03832v3.pdf
    • Salut @Wassim, oui, je comprends, mais mon but ici est de former les siamois net (ou triplet) et utilisez l'une des couches (ou fc2 fc1 dans mon code) que des fonctionnalités. Dans notre exemple, puisque le réseau est bon de diferenciate chiffres, de la formation des fonctionnalités doit être bon.
    • Les fonctionnalités sera bonne, mais vous avez besoin d'ajouter une dernière softmax (initiale et continue) sur eux
    • L'formés caractéristiques sont en effet de bonnes, mais après l'application d'un softmax vous devez vous méfier des indices car depuis que nous avons de ne pas nourrir les étiquettes, une activation du premier neurone sur la softmax couche n'est pas nécessaire de signifier qu'il a détecté un 0, il pourrait être l'un des autres chiffres. Habituellement, si vous vous entraînez à l'aide de contrastive/triplet de perte, vous êtes visant à l'utilisation du réseau à des fins de comparaison plutôt que le classement.

    InformationsquelleAutor Wassim Gr