- 传统softmax loss
- 缺点
只考虑是否正确分类 没考虑类内距离 后面的算法都是解决这个问题
- 亮点
度量学习(tripletloss)
- 难点
负样本的选择,与正样本尽可能的相似(som聚类)
def triplet_loss(anchor, positive, negative, alpha):
"""Calculate the triplet loss according to the FaceNet paper
Args:
anchor: the embeddings for the anchor images.
positive: the embeddings for the positive images.
negative: the embeddings for the negative images.
Returns:
the triplet loss according to the FaceNet paper as a float tensor.
"""
with tf.variable_scope('triplet_loss'):
pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), 1)
neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), 1)
basic_loss = tf.add(tf.subtract(pos_dist,neg_dist), alpha)
loss = tf.reduce_mean(tf.maximum(basic_loss, 0.0), 0)
return loss
- 亮点
centerloss + softmaxloss搭配使用,单独使用类间难分
def center_loss(features, label, alfa, nrof_classes):
"""Center loss based on the paper "A Discriminative Feature Learning Approach for Deep Face Recognition"
(http://ydwen.github.io/papers/WenECCV16.pdf)
"""
nrof_features = features.get_shape()[1]
centers = tf.get_variable('centers', [nrof_classes, nrof_features], dtype=tf.float32,
initializer=tf.constant_initializer(0), trainable=False)
label = tf.reshape(label, [-1])
centers_batch = tf.gather(centers, label)
diff = (1 - alfa) * (centers_batch - features)
centers = tf.scatter_sub(centers, label, diff)
with tf.control_dependencies([centers]):
loss = tf.reduce_mean(tf.square(features - centers_batch))
return loss, centers
- 亮点
直接在角度空间中最大化分类界限,比余弦距离在对角度的影响更加直接
余弦空间loss:L-softmax SphereFace(A-Softmax) CosFace Cocoloss
def arcface_loss(embedding, labels, out_num, w_init=None, s=64., m=0.5):
'''
:param embedding: the input embedding vectors
:param labels: the input labels, the shape should be eg: (batch_size, 1)
:param s: scalar value default is 64
:param out_num: output class num
:param m: the margin value, default is 0.5
:return: the final cacualted output, this output is send into the tf.nn.softmax directly
'''
cos_m = math.cos(m)
sin_m = math.sin(m)
mm = sin_m * m # issue 1
threshold = math.cos(math.pi - m)
with tf.variable_scope('arcface_loss'):
# inputs and weights norm
embedding_norm = tf.norm(embedding, axis=1, keep_dims=True)
embedding = tf.div(embedding, embedding_norm, name='norm_embedding')
weights = tf.get_variable(name='embedding_weights', shape=(embedding.get_shape().as_list()[-1], out_num),
initializer=w_init, dtype=tf.float32)
weights_norm = tf.norm(weights, axis=0, keep_dims=True)
weights = tf.div(weights, weights_norm, name='norm_weights')
# cos(theta+m)
cos_t = tf.matmul(embedding, weights, name='cos_t')
cos_t2 = tf.square(cos_t, name='cos_2')
sin_t2 = tf.subtract(1., cos_t2, name='sin_2')
sin_t = tf.sqrt(sin_t2, name='sin_t')
cos_mt = s * tf.subtract(tf.multiply(cos_t, cos_m), tf.multiply(sin_t, sin_m), name='cos_mt')
# this condition controls the theta+m should in range [0, pi]
# 0<=theta+m<=pi
# -m<=theta<=pi-m
cond_v = cos_t - threshold
cond = tf.cast(tf.nn.relu(cond_v, name='if_else'), dtype=tf.bool)
keep_val = s*(cos_t - mm)
cos_mt_temp = tf.where(cond, cos_mt, keep_val)
mask = tf.one_hot(labels, depth=out_num, name='one_hot_mask')
# mask = tf.squeeze(mask, 1)
inv_mask = tf.subtract(1., mask, name='inverse_mask')
s_cos_t = tf.multiply(s, cos_t, name='scalar_cos_t')
output = tf.add(tf.multiply(s_cos_t, inv_mask), tf.multiply(cos_mt_temp, mask), name='arcface_loss_output')
return output
- 亮点
每一个样本对,我们不仅需要考虑样本对本身的自相似性,同时还要考虑它与其它样本对的相对相似性。其中相对相似性又可以分为正相对相似性 (正样本)、负相对相似性(负样本)两种相似性。
def ms_loss(embeddings, labels, batch_size = 90, alpha=2.0, beta=50.0, lamb=1.0, eps=0.1, ms_mining=False):
'''
ref: http://openaccess.thecvf.com/content_CVPR_2019/papers/Wang_Multi-Similarity_Loss_With_General_Pair_Weighting_for_Deep_Metric_Learning_CVPR_2019_paper.pdf
official codes: https://github.com/MalongTech/research-ms-loss
'''
# make sure emebedding should be l2-normalized
labels = tf.reshape(labels, [-1, 1])
# batch_size = 90
adjacency = tf.equal(labels, tf.transpose(labels))
adjacency_not = tf.logical_not(adjacency)
mask_pos = tf.cast(adjacency, dtype=tf.float32) - tf.eye(batch_size, dtype=tf.float32)
mask_neg = tf.cast(adjacency_not, dtype=tf.float32)
sim_mat = tf.matmul(embeddings, embeddings, transpose_a=False, transpose_b=True)
sim_mat = tf.maximum(sim_mat, 0.0)
pos_mat = tf.multiply(sim_mat, mask_pos)
neg_mat = tf.multiply(sim_mat, mask_neg)
if ms_mining:
max_val = tf.reduce_max(neg_mat, axis=1, keepdims=True)
tmp_max_val = tf.reduce_max(pos_mat, axis=1, keepdims=True)
min_val = tf.reduce_min(tf.multiply(sim_mat - tmp_max_val, mask_pos), axis=1, keepdims=True) + tmp_max_val
max_val = tf.tile(max_val, [1, batch_size])
min_val = tf.tile(min_val, [1, batch_size])
mask_pos = tf.where(pos_mat < max_val + eps, mask_pos, tf.zeros_like(mask_pos))
mask_neg = tf.where(neg_mat > min_val - eps, mask_neg, tf.zeros_like(mask_neg))
pos_exp = tf.exp(-alpha * (pos_mat - lamb))
pos_exp = tf.where(mask_pos > 0.0, pos_exp, tf.zeros_like(pos_exp))
neg_exp = tf.exp(beta * (neg_mat - lamb))
neg_exp = tf.where(mask_neg > 0.0, neg_exp, tf.zeros_like(neg_exp))
pos_term = tf.log(1.0 + tf.reduce_sum(pos_exp, axis=1)) / alpha
neg_term = tf.log(1.0 + tf.reduce_sum(neg_exp, axis=1)) / beta
loss = tf.reduce_mean(pos_term + neg_term)
return loss