Python tensorflow.keras.backend.clip() Examples
The following are 29
code examples of tensorflow.keras.backend.clip().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
tensorflow.keras.backend
, or try the search function
.
Example #1
Source File: loss.py From Advanced-Deep-Learning-with-Keras with MIT License | 7 votes |
def focal_loss_binary(y_true, y_pred): """Binary cross-entropy focal loss """ gamma = 2.0 alpha = 0.25 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)) epsilon = K.epsilon() # clip to prevent NaN and Inf pt_1 = K.clip(pt_1, epsilon, 1. - epsilon) pt_0 = K.clip(pt_0, epsilon, 1. - epsilon) weight = alpha * K.pow(1. - pt_1, gamma) fl1 = -K.sum(weight * K.log(pt_1)) weight = (1 - alpha) * K.pow(pt_0, gamma) fl0 = -K.sum(weight * K.log(1. - pt_0)) return fl1 + fl0
Example #2
Source File: loss.py From Advanced-Deep-Learning-with-Keras with MIT License | 6 votes |
def focal_loss_categorical(y_true, y_pred): """Categorical cross-entropy focal loss""" gamma = 2.0 alpha = 0.25 # scale to ensure sum of prob is 1.0 y_pred /= K.sum(y_pred, axis=-1, keepdims=True) # clip the prediction value to prevent NaN and Inf epsilon = K.epsilon() y_pred = K.clip(y_pred, epsilon, 1. - epsilon) # calculate cross entropy cross_entropy = -y_true * K.log(y_pred) # calculate focal loss weight = alpha * K.pow(1 - y_pred, gamma) cross_entropy *= weight return K.sum(cross_entropy, axis=-1)
Example #3
Source File: policygradient-car-10.1.1.py From Advanced-Deep-Learning-with-Keras with MIT License | 6 votes |
def action(self, args): """Given mean and stddev, sample an action, clip and return We assume Gaussian distribution of probability of selecting an action given a state Argument: args (list) : mean, stddev list Return: action (tensor): policy action """ mean, stddev = args dist = tfp.distributions.Normal(loc=mean, scale=stddev) action = dist.sample(1) action = K.clip(action, self.env.action_space.low[0], self.env.action_space.high[0]) return action
Example #4
Source File: predictor.py From Deep-Channel with MIT License | 6 votes |
def mcor(y_true, y_pred): # matthews_correlation y_pred_pos = K.round(K.clip(y_pred, 0, 1)) y_pred_neg = 1 - y_pred_pos y_pos = K.round(K.clip(y_true, 0, 1)) y_neg = 1 - y_pos tp = K.sum(y_pos * y_pred_pos) tn = K.sum(y_neg * y_pred_neg) fp = K.sum(y_neg * y_pred_pos) fn = K.sum(y_pos * y_pred_neg) numerator = (tp * tn - fp * fn) denominator = K.sqrt((tp + fp) * (tp + fn) * (tn + fp) * (tn + fn)) return numerator / (denominator + K.epsilon())
Example #5
Source File: mine-13.8.1.py From Advanced-Deep-Learning-with-Keras with MIT License | 6 votes |
def mi_loss(self, y_true, y_pred): """ MINE loss function Arguments: y_true (tensor): Not used since this is unsupervised learning y_pred (tensor): stack of predictions for joint T(x,y) and marginal T(x,y) """ size = self.args.batch_size # lower half is pred for joint dist pred_xy = y_pred[0: size, :] # upper half is pred for marginal dist pred_x_y = y_pred[size : y_pred.shape[0], :] loss = K.mean(K.exp(pred_x_y)) loss = K.clip(loss, K.epsilon(), np.finfo(float).max) loss = K.mean(pred_xy) - K.log(loss) return -loss
Example #6
Source File: metrics.py From solaris with Apache License 2.0 | 6 votes |
def recall(y_true, y_pred): """Precision for foreground pixels. Calculates pixelwise recall TP/(TP + FN). """ # count true positives truth = K.round(K.clip(y_true, K.epsilon(), 1)) pred_pos = K.round(K.clip(y_pred, K.epsilon(), 1)) true_pos = K.sum(K.cast(K.all(K.stack([truth, pred_pos], axis=2), axis=2), dtype='float64')) truth_ct = K.sum(K.round(K.clip(y_true, K.epsilon(), 1))) if truth_ct == 0: return 0 recall = true_pos/truth_ct return recall
Example #7
Source File: _keras_losses.py From solaris with Apache License 2.0 | 5 votes |
def k_jaccard_loss(y_true, y_pred): """Jaccard distance for semantic segmentation. Modified from the `keras-contrib` package. """ eps = 1e-12 # for stability y_pred = K.clip(y_pred, eps, 1-eps) intersection = K.sum(K.abs(y_true*y_pred), axis=-1) sum_ = K.sum(K.abs(y_true) + K.abs(y_pred), axis=-1) jac = intersection/(sum_ - intersection) return 1 - jac
Example #8
Source File: cells.py From DeepPavlov with Apache License 2.0 | 5 votes |
def call(self, inputs, **kwargs): assert isinstance(inputs, list) and len(inputs) == 3 first, second, features = inputs[0], inputs[1], inputs[2] if not self.from_logits: first = K.clip(first, 1e-10, 1.0) second = K.clip(second, 1e-10, 1.0) first_, second_ = K.log(first), K.log(second) else: first_, second_ = first, second # embedded_features.shape = (M, T, 1) if self.use_intermediate_layer: features = K.dot(features, self.first_kernel) features = K.bias_add(features, self.first_bias, data_format="channels_last") features = self.intermediate_activation(features) embedded_features = K.dot(features, self.features_kernel) embedded_features = K.bias_add( embedded_features, self.features_bias, data_format="channels_last") if self.use_dimension_bias: tiling_shape = [1] * (K.ndim(first) - 1) + [K.shape(first)[-1]] embedded_features = K.tile(embedded_features, tiling_shape) embedded_features = K.bias_add( embedded_features, self.dimensions_bias, data_format="channels_last") sigma = K.sigmoid(embedded_features) result = weighted_sum(first_, second_, sigma, self.first_threshold, self.second_threshold) probs = K.softmax(result) if self.return_logits: return [probs, result] return probs
Example #9
Source File: loss.py From keras-YOLOv3-model-set with MIT License | 5 votes |
def softmax_focal_loss(y_true, y_pred, gamma=2.0, alpha=0.25): """ Compute softmax focal loss. Reference Paper: "Focal Loss for Dense Object Detection" https://arxiv.org/abs/1708.02002 # Arguments y_true: Ground truth targets, tensor of shape (?, num_boxes, num_classes). y_pred: Predicted logits, tensor of shape (?, num_boxes, num_classes). gamma: exponent of the modulating factor (1 - p_t) ^ gamma. alpha: optional alpha weighting factor to balance positives vs negatives. # Returns softmax_focal_loss: Softmax focal loss, tensor of shape (?, num_boxes). """ # Scale predictions so that the class probas of each sample sum to 1 #y_pred /= K.sum(y_pred, axis=-1, keepdims=True) # Clip the prediction value to prevent NaN's and Inf's #epsilon = K.epsilon() #y_pred = K.clip(y_pred, epsilon, 1. - epsilon) y_pred = tf.nn.softmax(y_pred) y_pred = tf.maximum(tf.minimum(y_pred, 1 - 1e-15), 1e-15) # Calculate Cross Entropy cross_entropy = -y_true * tf.math.log(y_pred) # Calculate Focal Loss softmax_focal_loss = alpha * tf.pow(1 - y_pred, gamma) * cross_entropy return softmax_focal_loss
Example #10
Source File: predictor.py From Deep-Channel with MIT License | 5 votes |
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
Example #11
Source File: predictor.py From Deep-Channel with MIT License | 5 votes |
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
Example #12
Source File: predictor.py From Deep-Channel with MIT License | 5 votes |
def f1(y_true, y_pred): 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 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 precision = precision(y_true, y_pred) recall = recall(y_true, y_pred) return 2*((precision*recall)/(precision+recall+K.epsilon()))
Example #13
Source File: metrics.py From solaris with Apache License 2.0 | 5 votes |
def precision(y_true, y_pred): """Precision for foreground pixels. Calculates pixelwise precision TP/(TP + FP). """ # count true positives truth = K.round(K.clip(y_true, K.epsilon(), 1)) pred_pos = K.round(K.clip(y_pred, K.epsilon(), 1)) true_pos = K.sum(K.cast(K.all(K.stack([truth, pred_pos], axis=2), axis=2), dtype='float64')) pred_pos_ct = K.sum(pred_pos) + K.epsilon() precision = true_pos/pred_pos_ct return precision
Example #14
Source File: bilstm_siamese_network.py From DeepPavlov with Apache License 2.0 | 5 votes |
def _pairwise_distances(self, inputs: List[Tensor]) -> Tensor: emb_c, emb_r = inputs bs = K.shape(emb_c)[0] embeddings = K.concatenate([emb_c, emb_r], 0) dot_product = K.dot(embeddings, K.transpose(embeddings)) square_norm = K.batch_dot(embeddings, embeddings, axes=1) distances = K.transpose(square_norm) - 2.0 * dot_product + square_norm distances = distances[0:bs, bs:bs+bs] distances = K.clip(distances, 0.0, None) mask = K.cast(K.equal(distances, 0.0), K.dtype(distances)) distances = distances + mask * 1e-16 distances = K.sqrt(distances) distances = distances * (1.0 - mask) return distances
Example #15
Source File: _keras_losses.py From solaris with Apache License 2.0 | 5 votes |
def k_focal_loss(gamma=2, alpha=0.75): # from github.com/atomwh/focalloss_keras def focal_loss_fixed(y_true, y_pred): # with tensorflow eps = 1e-12 # improve the stability of the focal loss y_pred = K.clip(y_pred, eps, 1.-eps) 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.sum( 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)) return focal_loss_fixed
Example #16
Source File: _keras_losses.py From solaris with Apache License 2.0 | 5 votes |
def k_lovasz_hinge(per_image=False): """Wrapper for the Lovasz Hinge Loss Function, for use in Keras. This is a mess. I'm sorry. """ def lovasz_hinge_flat(y_true, y_pred): # modified from Maxim Berman's GitHub repo tf implementation for Lovasz eps = 1e-12 # for stability y_pred = K.clip(y_pred, eps, 1-eps) logits = K.log(y_pred/(1-y_pred)) logits = tf.reshape(logits, (-1,)) y_true = tf.reshape(y_true, (-1,)) y_true = tf.cast(y_true, logits.dtype) signs = 2. * y_true - 1. errors = 1. - logits * tf.stop_gradient(signs) errors_sorted, perm = tf.nn.top_k(errors, k=tf.shape(errors)[0], name="descending_sort") gt_sorted = tf.gather(y_true, perm) grad = tf_lovasz_grad(gt_sorted) loss = tf.tensordot(tf.nn.relu(errors_sorted), tf.stop_gradient(grad), 1, name="loss_non_void") return loss def lovasz_hinge_per_image(y_true, y_pred): # modified from Maxim Berman's GitHub repo tf implementation for Lovasz losses = tf.map_fn(_treat_image, (y_true, y_pred), dtype=tf.float32) loss = tf.reduce_mean(losses) return loss def _treat_image(ytrue_ypred): y_true, y_pred = ytrue_ypred y_true, y_pred = tf.expand_dims(y_true, 0), tf.expand_dims(y_pred, 0) return lovasz_hinge_flat(y_true, y_pred) if per_image: return lovasz_hinge_per_image else: return lovasz_hinge_flat
Example #17
Source File: WCCE.py From TF.Keras-Commonly-used-models with Apache License 2.0 | 5 votes |
def weighted_categorical_crossentropy(weights): """ A weighted version of keras.objectives.categorical_crossentropy Variables: weights: numpy array of shape (C,) where C is the number of classes Usage: weights = np.array([0.5,2,10]) # Class one at 0.5, class 2 twice the normal weights, class 3 10x. loss = weighted_categorical_crossentropy(weights) model.compile(loss=loss,optimizer='adam') """ weights = K.variable(weights) 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 return loss
Example #18
Source File: bilstm_siamese_network.py From DeepPavlov with Apache License 2.0 | 5 votes |
def _batch_hard_triplet_loss(self, y_true: Tensor, pairwise_dist: Tensor) -> Tensor: mask_anchor_positive = self._get_anchor_positive_triplet_mask(y_true, pairwise_dist) anchor_positive_dist = mask_anchor_positive * pairwise_dist hardest_positive_dist = K.max(anchor_positive_dist, axis=1, keepdims=True) mask_anchor_negative = self._get_anchor_negative_triplet_mask(y_true, pairwise_dist) anchor_negative_dist = mask_anchor_negative * pairwise_dist mask_anchor_negative = self._get_semihard_anchor_negative_triplet_mask(anchor_negative_dist, hardest_positive_dist, mask_anchor_negative) max_anchor_negative_dist = K.max(pairwise_dist, axis=1, keepdims=True) anchor_negative_dist = pairwise_dist + max_anchor_negative_dist * (1.0 - mask_anchor_negative) hardest_negative_dist = K.min(anchor_negative_dist, axis=1, keepdims=True) triplet_loss = K.clip(hardest_positive_dist - hardest_negative_dist + self.margin, 0.0, None) triplet_loss = K.mean(triplet_loss) return triplet_loss
Example #19
Source File: bilstm_siamese_network.py From DeepPavlov with Apache License 2.0 | 5 votes |
def _batch_all_triplet_loss(self, y_true: Tensor, pairwise_dist: Tensor) -> Tensor: anchor_positive_dist = K.expand_dims(pairwise_dist, 2) anchor_negative_dist = K.expand_dims(pairwise_dist, 1) triplet_loss = anchor_positive_dist - anchor_negative_dist + self.margin mask = self._get_triplet_mask(y_true, pairwise_dist) triplet_loss = mask * triplet_loss triplet_loss = K.clip(triplet_loss, 0.0, None) valid_triplets = K.cast(K.greater(triplet_loss, 1e-16), K.dtype(triplet_loss)) num_positive_triplets = K.sum(valid_triplets) triplet_loss = K.sum(triplet_loss) / (num_positive_triplets + 1e-16) return triplet_loss
Example #20
Source File: base.py From spektral with MIT License | 5 votes |
def call(self, inputs): F = K.int_shape(inputs)[-1] minkowski_prod_mat = np.eye(F) minkowski_prod_mat[-1, -1] = -1. minkowski_prod_mat = K.constant(minkowski_prod_mat) output = K.dot(inputs, minkowski_prod_mat) output = K.dot(output, K.transpose(inputs)) output = K.clip(output, -10e9, -1.) if self.activation is not None: output = self.activation(output) return output
Example #21
Source File: bilstm_siamese_network.py From DeepPavlov with Apache License 2.0 | 5 votes |
def _euclidian_dist(self, x_pair: List[Tensor]) -> Tensor: x1_norm = K.l2_normalize(x_pair[0], axis=1) x2_norm = K.l2_normalize(x_pair[1], axis=1) diff = x1_norm - x2_norm square = K.square(diff) _sum = K.sum(square, axis=1) _sum = K.clip(_sum, min_value=1e-12, max_value=None) dist = K.sqrt(_sum) / 2. return dist
Example #22
Source File: run_clinicnet.py From CDSS with GNU General Public License v3.0 | 5 votes |
def recall(y_true, y_pred): K.set_epsilon(1e-05) #y_pred = tf.convert_to_tensor(y_pred, np.float32) #y_true = tf.convert_to_tensor(y_true, np.float32) 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
Example #23
Source File: run_clinicnet.py From CDSS with GNU General Public License v3.0 | 5 votes |
def precision(y_true, y_pred): K.set_epsilon(1e-05) #y_pred = tf.convert_to_tensor(y_pred, np.float32) #y_true = tf.convert_to_tensor(y_true, np.float32) 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
Example #24
Source File: run_clinicnet.py From CDSS with GNU General Public License v3.0 | 5 votes |
def f1(y_true, y_pred): K.set_epsilon(1e-05) 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. """ K.set_epsilon(1e-05) #y_pred = tf.convert_to_tensor(y_pred, np.float32) #y_true = tf.convert_to_tensor(y_true, np.float32) 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 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. """ K.set_epsilon(1e-05) #y_pred = tf.convert_to_tensor(y_pred, np.float32) #y_true = tf.convert_to_tensor(y_true, np.float32) 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 precision = precision(y_true, y_pred) recall = recall(y_true, y_pred) return 2*((precision*recall)/(precision+recall+K.epsilon()))
Example #25
Source File: focal_loss.py From pcc_geo_cnn with MIT License | 5 votes |
def focal_loss(y_true, y_pred, gamma=2, alpha=0.95): 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)) pt_1 = K.clip(pt_1, 1e-3, .999) pt_0 = K.clip(pt_0, 1e-3, .999) return -K.sum(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))
Example #26
Source File: utils.py From snn_toolbox with MIT License | 5 votes |
def precision(y_true, y_pred): """Precision metric. Computes the precision, a metric for multi-label classification of how many selected items are relevant. Only computes a batch-wise average of precision. """ import tensorflow.keras.backend as k 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))) return true_positives / (predicted_positives + k.epsilon())
Example #27
Source File: iic-13.5.1.py From Advanced-Deep-Learning-with-Keras with MIT License | 5 votes |
def mi_loss(self, y_true, y_pred): """Mutual information loss computed from the joint distribution matrix and the marginals Arguments: y_true (tensor): Not used since this is unsupervised learning y_pred (tensor): stack of softmax predictions for the Siamese latent vectors (Z and Zbar) """ size = self.args.batch_size n_labels = y_pred.shape[-1] # lower half is Z Z = y_pred[0: size, :] Z = K.expand_dims(Z, axis=2) # upper half is Zbar Zbar = y_pred[size: y_pred.shape[0], :] Zbar = K.expand_dims(Zbar, axis=1) # compute joint distribution (Eq 10.3.2 & .3) P = K.batch_dot(Z, Zbar) P = K.sum(P, axis=0) # enforce symmetric joint distribution (Eq 10.3.4) P = (P + K.transpose(P)) / 2.0 # normalization of total probability to 1.0 P = P / K.sum(P) # marginal distributions (Eq 10.3.5 & .6) Pi = K.expand_dims(K.sum(P, axis=1), axis=1) Pj = K.expand_dims(K.sum(P, axis=0), axis=0) Pi = K.repeat_elements(Pi, rep=n_labels, axis=1) Pj = K.repeat_elements(Pj, rep=n_labels, axis=0) P = K.clip(P, K.epsilon(), np.finfo(float).max) Pi = K.clip(Pi, K.epsilon(), np.finfo(float).max) Pj = K.clip(Pj, K.epsilon(), np.finfo(float).max) # negative MI loss (Eq 10.3.7) neg_mi = K.sum((P * (K.log(Pi) + K.log(Pj) - K.log(P)))) # each head contribute 1/n_heads to the total loss return neg_mi/self.args.heads
Example #28
Source File: metrics.py From neuron with GNU General Public License v3.0 | 5 votes |
def loss(self, y_true, y_pred): """ categorical crossentropy loss """ if self.crop_indices is not None: y_true = utils.batch_gather(y_true, self.crop_indices) y_pred = utils.batch_gather(y_pred, self.crop_indices) if self.use_float16: y_true = K.cast(y_true, 'float16') y_pred = K.cast(y_pred, 'float16') # scale and clip probabilities # this should not be necessary for softmax output. y_pred /= K.sum(y_pred, axis=-1, keepdims=True) y_pred = K.clip(y_pred, K.epsilon(), 1) # compute log probability log_post = K.log(y_pred) # likelihood # loss loss = - y_true * log_post # weighted loss if self.weights is not None: loss *= self.weights if self.vox_weights is not None: loss *= self.vox_weights # take the total loss # loss = K.batch_flatten(loss) mloss = K.mean(K.sum(K.cast(loss, 'float32'), -1)) tf.verify_tensor_all_finite(mloss, 'Loss not finite') return mloss
Example #29
Source File: metrics.py From neuron with GNU General Public License v3.0 | 4 votes |
def dice(self, y_true, y_pred): """ compute dice for given Tensors """ if self.crop_indices is not None: y_true = utils.batch_gather(y_true, self.crop_indices) y_pred = utils.batch_gather(y_pred, self.crop_indices) if self.input_type == 'prob': # We assume that y_true is probabilistic, but just in case: if self.re_norm: y_true = tf.div_no_nan(y_true, K.sum(y_true, axis=-1, keepdims=True)) y_true = K.clip(y_true, K.epsilon(), 1) # make sure pred is a probability if self.re_norm: y_pred = tf.div_no_nan(y_pred, K.sum(y_pred, axis=-1, keepdims=True)) y_pred = K.clip(y_pred, K.epsilon(), 1) # Prepare the volumes to operate on # If we're doing 'hard' Dice, then we will prepare one-hot-based matrices of size # [batch_size, nb_voxels, nb_labels], where for each voxel in each batch entry, # the entries are either 0 or 1 if self.dice_type == 'hard': # if given predicted probability, transform to "hard max"" if self.input_type == 'prob': if self.approx_hard_max: y_pred_op = _hard_max(y_pred, axis=-1) y_true_op = _hard_max(y_true, axis=-1) else: y_pred_op = _label_to_one_hot(K.argmax(y_pred, axis=-1), self.nb_labels) y_true_op = _label_to_one_hot(K.argmax(y_true, axis=-1), self.nb_labels) # if given predicted label, transform to one hot notation else: assert self.input_type == 'max_label' y_pred_op = _label_to_one_hot(y_pred, self.nb_labels) y_true_op = _label_to_one_hot(y_true, self.nb_labels) # If we're doing soft Dice, require prob output, and the data already is as we need it # [batch_size, nb_voxels, nb_labels] else: assert self.input_type == 'prob', "cannot do soft dice with max_label input" y_pred_op = y_pred y_true_op = y_true # reshape to [batch_size, nb_voxels, nb_labels] batch_size = K.shape(y_true)[0] y_pred_op = K.reshape(y_pred_op, [batch_size, -1, K.shape(y_true)[-1]]) y_true_op = K.reshape(y_true_op, [batch_size, -1, K.shape(y_true)[-1]]) # compute dice for each entry in batch. # dice will now be [batch_size, nb_labels] top = 2 * K.sum(y_true_op * y_pred_op, 1) bottom = K.sum(K.square(y_true_op), 1) + K.sum(K.square(y_pred_op), 1) # make sure we have no 0s on the bottom. K.epsilon() bottom = K.maximum(bottom, self.area_reg) return top / bottom