我们从Python开源项目中，提取了以下11个代码示例，用于说明如何使用keras.backend.not_equal()。
def _drop_path(self, inputs): count = len(inputs) drops = K.switch( self.is_global, self._gen_global_path(count), self._gen_local_drops(count, self.p) ) ave = K.zeros(shape=self.average_shape) for i in range(0, count): ave += inputs[i] * drops[i] sum = K.sum(drops) # Check that the sum is not 0 (global droppath can make it # 0) to avoid divByZero ave = K.switch( K.not_equal(sum, 0.), ave/sum, ave) return ave
def compute_mask(self, inputs, mask=None): channel_axis = K.ndim(inputs) - 1 mask_tensor = K.cast(mask, K.floatx()) mask_tensor = K.expand_dims(mask_tensor) mask_output = self.layer._pooling_function( mask_tensor, self.layer.pool_size, self.layer.strides, self.layer.padding, self.layer.data_format, ) mask_output = K.sum(mask_output, axis=channel_axis) next_mask_tensor = K.not_equal(mask_output, 0.0) return next_mask_tensor
def compute_mask(self, inputs, mask): channel_axis = K.ndim(inputs) - 1 mask_tensor = K.cast(mask, K.floatx()) mask_tensor = K.expand_dims(mask_tensor) mask_output = self._compute_mask_output(mask_tensor) mask_output = K.sum(mask_output, axis=channel_axis) next_mask_tensor = K.not_equal(mask_output, 0.0) return next_mask_tensor
def bp_mll_loss(y_true, y_pred): # get true and false labels y_i = K.equal(y_true, K.ones_like(y_true)) y_i_bar = K.not_equal(y_true, K.ones_like(y_true)) # cast to float as keras backend has no logical and y_i = K.cast(y_i, dtype='float32') y_i_bar = K.cast(y_i_bar, dtype='float32') # get indices to check truth_matrix = pairwise_and(y_i, y_i_bar) # calculate all exp'd differences sub_matrix = pairwise_sub(y_pred, y_pred) exp_matrix = K.exp(-sub_matrix) # check which differences to consider and sum them sparse_matrix = exp_matrix * truth_matrix sums = K.sum(sparse_matrix, axis=[1,2]) # get normalizing terms and apply them y_i_sizes = K.sum(y_i, axis=1) y_i_bar_sizes = K.sum(y_i_bar, axis=1) normalizers = y_i_sizes * y_i_bar_sizes results = sums / normalizers # sum over samples return K.sum(results) # compute pairwise differences between elements of the tensors a and b
def get_output_mask(self, train=None): X = self.get_input(train) if not self.mask_zero: return None else: return K.not_equal(X, 0)
def compute_loss(self, y_true, y_pred): class_loss = self.cross_entropy(y_true[:, :, 4:], y_pred[:, :, 4:]) """ class_loss = K.categorical_crossentropy(y_true[:, :, 4:], y_pred[:, :, 4:]) """ # return K.concatenate([class_loss, class_loss_old], axis=0) local_loss = self.smooth_l1(y_true[:, :, :4], y_pred[:, :, :4]) negative_mask = y_true[:, :, 4 + self.background_id] positive_mask = 1 - negative_mask # calculating the positive loss positive_local_losses = local_loss * positive_mask positive_class_losses = class_loss * positive_mask positive_class_loss = K.sum(positive_class_losses, axis=-1) positive_local_loss = K.sum(positive_local_losses, axis=-1) # obtaining the number of negatives in the batch num_positives_per_sample = K.cast(K.sum(positive_mask, -1), 'int32') num_negatives_per_sample = K.cast(K.sum(negative_mask, -1), 'int32') num_negatives_in_batch = K.sum(num_negatives_per_sample) num_hard_negatives = self.neg_pos_ratio * num_positives_per_sample num_negatives = K.minimum(num_hard_negatives, num_negatives_in_batch) all_negative_class_losses = class_loss * negative_mask negative_class_loss = [] for batch_arg in range(self.batch_size): sample_num_negatives = num_negatives[batch_arg] all_negative_sample_loss = all_negative_class_losses[batch_arg] negative_sample_losses = tf.nn.top_k(all_negative_sample_loss, k=sample_num_negatives, sorted=True)[0] negative_sample_loss = K.sum(negative_sample_losses) negative_sample_loss = K.expand_dims(negative_sample_loss, -1) negative_class_loss.append(negative_sample_loss) negative_class_loss = K.concatenate(negative_class_loss) return negative_class_loss class_loss = positive_class_loss + negative_class_loss total_loss = class_loss + (self.alpha * positive_local_loss) batch_mask = K.not_equal(num_positives_per_sample, 0) total_loss = tf.where(batch_mask, total_loss, K.zeros_like(total_loss)) num_positives_per_sample = tf.where( batch_mask, num_positives_per_sample, K.ones_like(num_positives_per_sample)) num_positives_per_sample = K.cast(num_positives_per_sample, 'float32') total_loss = total_loss / num_positives_per_sample return total_loss
def cce_flatt(void_class, weights_class): def categorical_crossentropy_flatt(y_true, y_pred): '''Expects a binary class matrix instead of a vector of scalar classes. ''' if dim_ordering == 'th': y_pred = K.permute_dimensions(y_pred, (0, 2, 3, 1)) shp_y_pred = K.shape(y_pred) y_pred = K.reshape(y_pred, (shp_y_pred[0]*shp_y_pred[1]*shp_y_pred[2], shp_y_pred[3])) # go back to b01,c # shp_y_true = K.shape(y_true) if dim_ordering == 'th': y_true = K.cast(K.flatten(y_true), 'int32') # b,01 -> b01 else: y_true = K.cast(K.flatten(y_true), 'int32') # b,01 -> b01 # remove void classes from cross_entropy if len(void_class): for i in range(len(void_class)): # get idx of non void classes and remove void classes # from y_true and y_pred idxs = K.not_equal(y_true, void_class[i]) if dim_ordering == 'th': idxs = idxs.nonzero() y_pred = y_pred[idxs] y_true = y_true[idxs] else: y_pred = tf.boolean_mask(y_pred, idxs) y_true = tf.boolean_mask(y_true, idxs) if dim_ordering == 'th': y_true = T.extra_ops.to_one_hot(y_true, nb_class=y_pred.shape[-1]) else: y_true = tf.one_hot(y_true, K.shape(y_pred)[-1], on_value=1, off_value=0, axis=None, dtype=None, name=None) y_true = K.cast(y_true, 'float32') # b,01 -> b01 out = K.categorical_crossentropy(y_pred, y_true) # Class balancing if weights_class is not None: weights_class_var = K.variable(value=weights_class) class_balance_w = weights_class_var[y_true].astype(K.floatx()) out = out * class_balance_w return K.mean(out) # b01 -> b,01 return categorical_crossentropy_flatt
def IoU(n_classes, void_labels): def IoU_flatt(y_true, y_pred): '''Expects a binary class matrix instead of a vector of scalar classes. ''' if dim_ordering == 'th': y_pred = K.permute_dimensions(y_pred, (0, 2, 3, 1)) shp_y_pred = K.shape(y_pred) y_pred = K.reshape(y_pred, (shp_y_pred[0]*shp_y_pred[1]*shp_y_pred[2], shp_y_pred[3])) # go back to b01,c # shp_y_true = K.shape(y_true) y_true = K.cast(K.flatten(y_true), 'int32') # b,01 -> b01 y_pred = K.argmax(y_pred, axis=-1) # We use not_void in case the prediction falls in the void class of # the groundtruth for i in range(len(void_labels)): if i == 0: not_void = K.not_equal(y_true, void_labels[i]) else: not_void = not_void * K.not_equal(y_true, void_labels[i]) sum_I = K.zeros((1,), dtype='float32') out = {} for i in range(n_classes): y_true_i = K.equal(y_true, i) y_pred_i = K.equal(y_pred, i) if dim_ordering == 'th': I_i = K.sum(y_true_i * y_pred_i) U_i = K.sum(T.or_(y_true_i, y_pred_i) * not_void) # I = T.set_subtensor(I[i], I_i) # U = T.set_subtensor(U[i], U_i) sum_I = sum_I + I_i else: U_i = K.sum(K.cast(tf.logical_and(tf.logical_or(y_true_i, y_pred_i), not_void), 'float32')) y_true_i = K.cast(y_true_i, 'float32') y_pred_i = K.cast(y_pred_i, 'float32') I_i = K.sum(y_true_i * y_pred_i) sum_I = sum_I + I_i out['I'+str(i)] = I_i out['U'+str(i)] = U_i if dim_ordering == 'th': accuracy = K.sum(sum_I) / K.sum(not_void) else: accuracy = K.sum(sum_I) / tf.reduce_sum(tf.cast(not_void, 'float32')) out['acc'] = accuracy return out return IoU_flatt
