def get_f1(y_true, y_pred): #taken from old keras source code true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1))) possible_positives = K.sum(K.round(K.clip(y_true, 0, 1))) predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1))) precision = true_positives / (predicted_positives + K.epsilon()) recall = true_positives / (possible_positives + K.epsilon()) f1_val = 2*(precision*recall)/(precision+recall+K.epsilon()) return f1_val
def precision(y_true, y_pred): """Precision metric. Only computes a batch-wise average of precision. Computes the precision, a metric for multi-label classification of how many selected items are relevant. """ true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1))) predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1))) precision = true_positives / (predicted_positives + K.epsilon()) return precision
def recall(y_true, y_pred): """Recall metric. Only computes a batch-wise average of recall. Computes the recall, a metric for multi-label classification of how many relevant items are selected. """ true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1))) possible_positives = K.sum(K.round(K.clip(y_true, 0, 1))) recall = true_positives / (possible_positives + K.epsilon()) return recall
def focal_loss_fixed(y_true, y_pred): eps = 1e-6 alpha = 0.5 y_pred=K.clip(y_pred,eps,1.-eps)#improve the stability of the focal loss and see issues 1 for more information pt_1 = tf.where(tf.equal(y_true, 1), y_pred, tf.ones_like(y_pred)) pt_0 = tf.where(tf.equal(y_true, 0), y_pred, tf.zeros_like(y_pred)) return -K.mean(alpha * K.pow(1. - pt_1, gamma) * K.log(pt_1))-K.sum((1-alpha) * K.pow( pt_0, gamma) * K.log(1. - pt_0),axis=-1)
def FocalLoss(target, output): gamma = 5 alpha = 0.3 output = tfb.clip(output, tfb.epsilon(), 1 - tfb.epsilon()) value = -alpha * target * tf.log(output + tfb.epsilon()) * tf.pow( 1 - output, gamma) - (1 - alpha) * (1 - target) * tf.log( 1 - output + tfb.epsilon()) * tf.pow(output, gamma) return tf.reduce_mean(value)
def loss(y_true, y_pred): # scale predictions so that the class probas of each sample sum to 1 y_pred /= K.sum(y_pred, axis=-1, keepdims=True) # clip to prevent NaN's and Inf's y_pred = K.clip(y_pred, K.epsilon(), 1 - K.epsilon()) # calc loss = y_true * K.log(y_pred) * weights loss = -K.sum(loss, -1) return loss
def weighted_BCE(y_true, y_pred): # scale predictions so that the class probas of each sample sum to 1 # weights = tfb.variable(1/np.array([0.07050923, 0.24034695, 0.19802742, 0.09862899, 0.16046447, 0.08317012, 0.10002798, 0.04882485])) weights = tfb.variable(np.array([1, 1, 1, 1, 1, 1, 1, 1])) y_pred /= tfb.sum(y_pred, axis=-1, keepdims=True) # clip to prevent NaN's and Inf's y_pred = tfb.clip(y_pred, tfb.epsilon(), 1 - tfb.epsilon()) # calc loss = y_true * tfb.log(y_pred) * weights loss = -tfb.sum(loss, -1) return loss
class focal_loss: """ A loss function similar to cross_entropy # Usage model.compile('sgd',loss=focal_loss.loss,.......) # Arguments class_weights : weights for each class to solve the class imbalance problem. dtype --> array default --> None pixel_weights : weights for each pixels in order to segment certain part of the image clearly. dtype --> array default --> None """ def c_weights(self, x): try: if list(x) != None: return x except TypeError: return 1 def p_weights(self, x): try: if list(x) != None: return x except TypeError: return 1 clipping = lambda self,x: K.clip(x, K.epsilon(), 1.-K.epsilon()) def __init__(self,class_weights=None, pixel_weights=None, gamma=2): self.class_weights = class_weights self.gamma = gamma self.pixel_weights = pixel_weights def loss(self,y_true,y_pred): """ executes the focal loss # Arguments y_true : true class values y_pred : predicted class values from the model # Returns fl : mean focal loss for the given batch """ y_pred = self.clipping(y_pred) fl = -(K.sum((self.c_weights(self.class_weights) * K.pow(1.-y_pred,self.gamma) * (y_true * K.log(y_pred))),axis=-1)) fl = K.sum((self.p_weights(self.pixel_weights) * fl),axis=(1,2)) fl = K.mean(fl, axis=0) return fl/1000 ## scaling down the loss to prevent gradient explosion
def mean_log_Gaussian_like(self, y_true, parameters): """Mean Log Gaussian Likelihood distribution Note: The 'c' variable is obtained as global variable """ components = ktf.reshape(parameters,[-1, 2*9 + 1, self.n_classes]) mu = components[:, 0:9, :] sigma = components[:, 9:18, :] alpha = components[:, 18, :] alpha = ktf.softmax(ktf.clip(alpha,1e-8,1.)) exponent = ktf.log(alpha) - .5 * float(self.c) * ktf.log(2 * np.pi) \ - ktf.sum(ktf.log(sigma), axis=1) \ - ktf.sum((ktf.expand_dims(y_true,2) - mu)**2 / (2*(sigma)**2), axis=1) log_gauss = log_sum_exp(exponent, axis=1) res = - ktf.mean(log_gauss) return res
def kld(self, product_embeds1, product_embeds2): product_embeds2 = K.clip(product_embeds2, K.epsilon(), 1) product_embeds1 = K.clip(product_embeds1, K.epsilon(), 1) return K.sum(product_embeds1 * K.log(product_embeds1 / product_embeds2), axis=-1)
def kld(self, E, P): E = K.clip(E, K.epsilon(), 1) P = K.clip(P, K.epsilon(), 1) return K.sum(P * K.log(P / E), axis=-1)
def precision_m(y_true, y_pred): true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1))) predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1))) precision = true_positives / (predicted_positives + K.epsilon()) return precision
def recall_m(y_true, y_pred): true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1))) possible_positives = K.sum(K.round(K.clip(y_true, 0, 1))) recall = true_positives / (possible_positives + K.epsilon()) return recall