import tensorflow as tf

def f1_reweight_loss(logits, labels, beta2):

"""from paper: Adaptive Scaling for Sparse Detection in Information Extraction"""

m = tf.count_nonzero(labels, dtype=tf.float32)

batch_size = tf.shape(labels)[0]

n = tf.cast(batch_size, tf.float32) - m

probs = tf.nn.softmax(logits) # [batch_size, num_classes]

batch_idx = tf.range(batch_size)

label_with_idx = tf.concat([tf.expand_dims(t, 1) for t in [batch_idx, tf.cast(labels, tf.int32)]], 1) # [batch_size, 2]

golden_probs = tf.gather_nd(probs, label_with_idx) # [batch_size]

zeros = tf.zeros_like(golden_probs)

is_negative = tf.equal(labels, 0)

p1 = tf.reduce_sum(tf.where(is_negative, zeros, golden_probs)) # TP

p2 = tf.reduce_sum(tf.where(is_negative, golden_probs, zeros)) # TN

neg_weights = p1 / ((beta2 * m) + n - p2 + 1e-8)

ones = tf.ones_like(golden_probs)

weights = tf.where(is_negative, ones * neg_weights, ones)

return tf.losses.sparse_softmax_cross_entropy(labels, logits, weights)

def f1_reweight_loss_v2(logits, labels, beta2):

probs = tf.nn.softmax(logits) # [batch_size, num_classes]

labels = tf.cast(labels, tf.int32)

negative_idx = tf.where(tf.equal(labels, 0), tf.ones_like(labels, dtype=tf.float32), tf.zeros_like(labels, dtype=tf.float32))

positive_idx = 1.0 - negative_idx

batch_idx = tf.range(tf.shape(probs)[0])

label_with_idx = tf.concat([tf.expand_dims(t, 1) for t in [batch_idx, labels]], 1)

golden_prob = tf.gather_nd(probs, label_with_idx)

m = tf.reduce_sum(positive_idx)

n = tf.reduce_sum(negative_idx)

p1 = tf.reduce_sum(positive_idx * golden_prob)

p2 = tf.reduce_sum(negative_idx * golden_prob)

neg_weight = p1 / ((beta2 * m) + n - p2 + 1e-8)

all_one = tf.ones(tf.shape(golden_prob))

loss_weight = all_one * positive_idx + all_one * neg_weight * negative_idx

loss = - loss_weight * tf.log(golden_prob + 1e-8)

return loss

def f1_reweight_sigmoid_cross_entropy(logits, labels, beta_square, label_smoothing=0, weights=None):

probs = tf.nn.sigmoid(logits)

if len(labels.shape.as_list()) == 1:

labels = tf.expand_dims(labels, -1)

labels = tf.to_float(labels)

batch_size = tf.shape(labels)[0]

batch_size_float = tf.to_float(batch_size)

num_pos = tf.reduce_sum(labels, axis=0)

num_neg = batch_size_float - num_pos

tp = tf.reduce_sum(probs, axis=0)

tn = batch_size_float - tp

neg_weight = tp / (beta_square * num_pos + num_neg - tn + 1e-8)

neg_weight_tile = tf.tile(tf.expand_dims(neg_weight, 0), [batch_size, 1])

final_weights = tf.where(tf.equal(labels, 1.0), tf.ones_like(labels), neg_weight_tile)

if weights is not None:

if len(weights.shape.as_list()) == 1:

weights = tf.expand_dims(weights, -1)

final_weights *= weights

return tf.losses.sigmoid_cross_entropy(labels, logits, final_weights, label_smoothing=label_smoothing)

import tensorflow as tf

def get_center_loss(features, labels, alpha, num_classes):

"""获取center loss及center的更新op

# 获取特征的维数，例如256维

len_features = features.get_shape()[1]

# 建立一个Variable,shape为[num_classes, len_features]，用于存储整个网络的样本中心，

# 设置trainable=False是因为样本中心不是由梯度进行更新的

centers = tf.get_variable('centers', [num_classes, len_features], dtype=tf.float32, trainable=False,

initializer=tf.contrib.layers.xavier_initializer())

# initializer=tf.constant_initializer(0))

# 将label展开为一维的，输入如果已经是一维的，则该动作其实无必要

# labels = tf.reshape(labels, [-1])

# 根据样本label,获取mini-batch中每一个样本对应的中心值

centers_batch = tf.gather(centers, labels)

# 计算loss

loss = tf.losses.mean_squared_error(features, centers_batch)

# 当前mini-batch的特征值与它们对应的中心值之间的差

diff = centers_batch - features

# 获取mini-batch中同一类别样本出现的次数,了解原理请参考原文公式(4)

unique_label, unique_idx, unique_count = tf.unique_with_counts(labels)

appear_times = tf.gather(unique_count, unique_idx)

appear_times = tf.reshape(appear_times, [-1, 1])

diff = diff / tf.cast((1 + appear_times), tf.float32)

return loss, centers

def AM_logits_compute(embeddings, label_batch, args, nrof_classes):

'''

embeddings : normalized embedding layer of Facenet, it's normalized value of output of resface

label_batch : ground truth label of current training batch

args: arguments from cmd line

nrof_classes: number of classes

'''

with tf.name_scope('AM_logits'):

kernel = tf.get_variable(name='kernel', dtype=tf.float32, shape=[args.embedding_size, nrof_classes],

kernel_norm = tf.nn.l2_normalize(kernel, 0, 1e-10, name='kernel_norm')

if __name__ == '__main__':

import tensorflow as tf

import numpy as np

def circle_loss(pair_wise_cosine_matrix, pred_true_mask,

pred_neg_mask,

margin=0.25,

gamma=64):

"""

O_p = 1 + margin

O_n = -margin

Delta_p = 1 - margin

Delta_n = margin

ap = tf.nn.relu(-tf.stop_gradient(pair_wise_cosine_matrix * pred_true_mask) + 1 + margin)

an = tf.nn.relu(tf.stop_gradient(pair_wise_cosine_matrix * pred_neg_mask) + margin)

logit_p = -ap * (pair_wise_cosine_matrix - Delta_p) * gamma * pred_true_mask

logit_n = an * (pair_wise_cosine_matrix - Delta_n) * gamma * pred_neg_mask

logit_p = logit_p - (1 - pred_true_mask) * 1e12

logit_n = logit_n - (1 - pred_neg_mask) * 1e12

joint_neg_loss = tf.reduce_logsumexp(logit_n, axis=-1)

joint_pos_loss = tf.reduce_logsumexp(logit_p, axis=-1)

logits = tf.nn.softplus(joint_neg_loss + joint_pos_loss)

return logits

def _get_anchor_positive_triplet_mask(labels):

"""Return a 2D mask where mask[a, p] is True iff a and p are distinct and have same label.

# Check that i and j are distinct

indices_equal = tf.cast(tf.eye(tf.shape(labels)[0]), tf.bool)

indices_not_equal = tf.logical_not(indices_equal)

# Check if labels[i] == labels[j]

# Uses broadcasting where the 1st argument has shape (1, batch_size) and the 2nd (batch_size, 1)

labels_equal = tf.equal(tf.expand_dims(labels, 0), tf.expand_dims(labels, 1))

# Combine the two masks

mask = tf.logical_and(indices_not_equal, labels_equal)

return mask

def _get_anchor_negative_triplet_mask(labels):

"""Return a 2D mask where mask[a, n] is True iff a and n have distinct labels.

# Check if labels[i] != labels[k]

# Uses broadcasting where the 1st argument has shape (1, batch_size) and the 2nd (batch_size, 1)

labels_equal = tf.equal(tf.expand_dims(labels, 0), tf.expand_dims(labels, 1))

mask = tf.logical_not(labels_equal)

return mask

input_tensor = tf.convert_to_tensor(np.random.random((10, 16)).astype(np.float32))

input_tensor = tf.nn.l2_normalize(input_tensor, axis=-1)

labels = tf.convert_to_tensor([1, 0, 2, 2, 1, 1, 4, 0, 4, 1])

pair_wise_cosine_matrix = tf.matmul(input_tensor, tf.transpose(input_tensor))

positive_mask = _get_anchor_positive_triplet_mask(labels)

negative_mask = _get_anchor_negative_triplet_mask(labels)

positive_mask = tf.cast(positive_mask, tf.float32)

negative_mask = tf.cast(negative_mask, tf.float32)

loss = circle_loss(pair_wise_cosine_matrix, positive_mask,

negative_mask,

margin=0.25,

gamma=64)

sess = tf.Session()

print(sess.run([positive_mask, negative_mask, loss]))

import tensorflow as tf

def sparse_softmax_cross_entropy_with_prior(labels, logits, priors, tau=1.0):

"""带先验分布的稀疏交叉熵: Long-Tail Learning via Logit Adjustment. priors: shape is [num_classes], 类别的先验概率分布"""

log_priors = tf.math.log(priors)

if len(log_priors.shape.as_list()) == 1:

log_priors = tf.expand_dims(log_priors, 0)

# print(log_priors.shape)

# print(logits.shape)

# print(labels.shape)

logits += tau * log_priors

return tf.losses.sparse_softmax_cross_entropy(labels, logits)

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import tensorflow as tf

def sigmoid_focal_loss_with_logits(y_true, y_pred, alpha=0.25, gamma=2.0):

"""

if gamma and gamma < 0:

raise ValueError(

"Value of gamma should be greater than or equal to zero")

y_pred = tf.convert_to_tensor(y_pred)

y_true = tf.cast(y_true, y_pred.dtype)

# Get the binary cross_entropy

bce = tf.nn.sigmoid_cross_entropy_with_logits(labels=y_true, logits=y_pred)

# convert the predictions into probabilities

y_pred = tf.nn.sigmoid(y_pred)

p_t = (y_true * y_pred) + ((1 - y_true) * (1 - y_pred))

alpha_factor = 1

modulating_factor = 1

if alpha:

alpha = tf.convert_to_tensor(alpha, dtype=tf.float32)

alpha_factor = y_true * alpha + ((1 - alpha) * (1 - y_true))

if gamma:

gamma = tf.convert_to_tensor(gamma, dtype=tf.float32)

modulating_factor = tf.pow((1 - p_t), gamma)

# compute the final loss and return

return tf.reduce_mean(alpha_factor * modulating_factor * bce, axis=-1, keepdims=True)

def softmax_focal_loss_with_logits(logits, labels, alpha=None, sample_weights=None, gamma=2.0, epsilon=1.e-7):

"""

labels = tf.cast(labels, dtype=tf.int32)

softmax = tf.reshape(tf.nn.softmax(logits), [-1]) # [batch_size * num_class]

batch_size, num_class = get_shape_list(logits)

# (N,) > (N,), 但是数值变换了，变成了每个label在 N * num_class 中的位置

labels_shift = tf.range(0, batch_size) * num_class + labels

# (N * num_class,) > (N,)

prob = tf.gather(softmax, labels_shift) # 属于当前类的概率

# 预防预测概率值为0的情况; (N,)

prob = tf.clip_by_value(prob, epsilon, 1. - epsilon)

weights = tf.pow(tf.subtract(1., prob), gamma)

if alpha is not None:

alpha = tf.constant(alpha, dtype=tf.float32) # (num_class, 1)

# (num_class ,1) > (N,)

alpha_choice = tf.gather(alpha, labels)

weights = tf.multiply(alpha_choice, weights)

if sample_weights is not None:

weights = tf.multiply(weights, sample_weights)

return tf.losses.sparse_softmax_cross_entropy(labels, logits, weights=weights)

def get_shape_list(tensor):

"""Returns a list of the shape of tensor, preferring static dimensions.

shape = tensor.shape.as_list()

non_static_indexes = []

for (index, dim) in enumerate(shape):

if dim is None:

non_static_indexes.append(index)

if not non_static_indexes:

return shape

dyn_shape = tf.shape(tensor)

for index in non_static_indexes:

shape[index] = dyn_shape[index]

return shape