Python tensorflow.not_equal() Examples
The following are 30
code examples of tensorflow.not_equal().
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
, or try the search function
.
Example #1
Source File: t2t_model.py From BERT with Apache License 2.0 | 6 votes |
def summarize_features(features, num_shards=1): """Generate summaries for features.""" if not common_layers.should_generate_summaries(): return with tf.name_scope("input_stats"): for (k, v) in sorted(six.iteritems(features)): if (isinstance(v, tf.Tensor) and (v.get_shape().ndims > 1) and (v.dtype != tf.string)): tf.summary.scalar("%s_batch" % k, tf.shape(v)[0] // num_shards) tf.summary.scalar("%s_length" % k, tf.shape(v)[1]) nonpadding = tf.to_float(tf.not_equal(v, 0)) nonpadding_tokens = tf.reduce_sum(nonpadding) tf.summary.scalar("%s_nonpadding_tokens" % k, nonpadding_tokens) tf.summary.scalar("%s_nonpadding_fraction" % k, tf.reduce_mean(nonpadding))
Example #2
Source File: loss.py From mobile-segmentation with Apache License 2.0 | 6 votes |
def flatten_binary_scores(scores, labels, ignore=None): """ Flattens predictions in the batch (binary case) Remove labels equal to 'ignore' """ scores = tf.reshape(scores, (-1,)) labels = tf.reshape(labels, (-1,)) if ignore is None: return scores, labels valid = tf.not_equal(labels, ignore) vscores = tf.boolean_mask(scores, valid, name='valid_scores') vlabels = tf.boolean_mask(labels, valid, name='valid_labels') return vscores, vlabels # --------------------------- MULTICLASS LOSSES ---------------------------
Example #3
Source File: content.py From ConMask with MIT License | 6 votes |
def multiple_content_lookup(content, vocab_table, ids, name=None): """ :param content: :param vocab_table: :param ids: :param name: :return: 2-D [batch_size, max_length_in_batch] content id matrix, 1-D [batch_size] content len vector """ with tf.name_scope(name, 'multiple_content_lookup', [content, vocab_table, ids]): content_list = tf.nn.embedding_lookup(content, ids) extracted_sparse_content = tf.string_split(content_list, delimiter=' ') sparse_content = tf.SparseTensor(indices=extracted_sparse_content.indices, values=vocab_table.lookup(extracted_sparse_content.values), dense_shape=extracted_sparse_content.dense_shape) extracted_content_ids = tf.sparse_tensor_to_dense(sparse_content, default_value=0, name='dense_content') extracted_content_len = tf.reduce_sum(tf.cast(tf.not_equal(extracted_content_ids, 0), tf.int32), axis=-1) return extracted_content_ids, extracted_content_len
Example #4
Source File: loss.py From mobile-segmentation with Apache License 2.0 | 6 votes |
def flatten_probas(probas, labels, ignore=None, order='BHWC'): """ Flattens predictions in the batch """ if len(probas.shape) == 3: probas, order = tf.expand_dims(probas, 3), 'BHWC' if order == 'BCHW': probas = tf.transpose(probas, (0, 2, 3, 1), name="BCHW_to_BHWC") order = 'BHWC' if order != 'BHWC': raise NotImplementedError('Order {} unknown'.format(order)) C = probas.shape[3] probas = tf.reshape(probas, (-1, C)) labels = tf.reshape(labels, (-1,)) if ignore is None: return probas, labels valid = tf.not_equal(labels, ignore) vprobas = tf.boolean_mask(probas, valid, name='valid_probas') vlabels = tf.boolean_mask(labels, valid, name='valid_labels') return vprobas, vlabels
Example #5
Source File: compress.py From onnx-tensorflow with Apache License 2.0 | 6 votes |
def _common(cls, node, **kwargs): attrs = copy.deepcopy(node.attrs) tensor_dict = kwargs["tensor_dict"] x = tensor_dict[node.inputs[0]] condition = tensor_dict[node.inputs[1]] x = tf.reshape(x, [-1]) if node.attrs.get("axis") is None else x if condition.shape.is_fully_defined(): condition_shape = condition.shape[0] indices = tf.constant(list(range(condition_shape)), dtype=tf.int64) else: condition_shape = tf.shape(condition, out_type=tf.int64)[0] indices = tf.range(condition_shape, dtype=tf.int64) not_zero = tf.not_equal(condition, tf.zeros_like(condition)) attrs['indices'] = tf.boolean_mask(indices, not_zero) return [ cls.make_tensor_from_onnx_node(node, inputs=[x], attrs=attrs, **kwargs) ]
Example #6
Source File: __init__.py From astroNN with MIT License | 6 votes |
def magic_correction_term(y_true): """ Calculate a correction term to prevent the loss being lowered by magic_num :param y_true: Ground Truth :type y_true: tf.Tensor :return: Correction Term :rtype: tf.Tensor :History: | 2018-Jan-30 - Written - Henry Leung (University of Toronto) | 2018-Feb-17 - Updated - Henry Leung (University of Toronto) """ import tensorflow as tf from astroNN.config import MAGIC_NUMBER num_nonmagic = tf.reduce_sum(tf.cast(tf.not_equal(y_true, MAGIC_NUMBER), tf.float32), axis=-1) num_magic = tf.reduce_sum(tf.cast(tf.equal(y_true, MAGIC_NUMBER), tf.float32), axis=-1) # If no magic number, then num_zero=0 and whole expression is just 1 and get back our good old loss # If num_nonzero is 0, that means we don't have any information, then set the correction term to ones return (num_nonmagic + num_magic) / num_nonmagic
Example #7
Source File: path_context_reader.py From code2vec with MIT License | 6 votes |
def _filter_input_rows(self, *row_parts) -> tf.bool: row_parts = self.model_input_tensors_former.from_model_input_form(row_parts) #assert all(tensor.shape == (self.config.MAX_CONTEXTS,) for tensor in # {row_parts.path_source_token_indices, row_parts.path_indices, # row_parts.path_target_token_indices, row_parts.context_valid_mask}) # FIXME: Does "valid" here mean just "no padding" or "neither padding nor OOV"? I assumed just "no padding". any_word_valid_mask_per_context_part = [ tf.not_equal(tf.reduce_max(row_parts.path_source_token_indices, axis=0), self.vocabs.token_vocab.word_to_index[self.vocabs.token_vocab.special_words.PAD]), tf.not_equal(tf.reduce_max(row_parts.path_target_token_indices, axis=0), self.vocabs.token_vocab.word_to_index[self.vocabs.token_vocab.special_words.PAD]), tf.not_equal(tf.reduce_max(row_parts.path_indices, axis=0), self.vocabs.path_vocab.word_to_index[self.vocabs.path_vocab.special_words.PAD])] any_contexts_is_valid = reduce(tf.logical_or, any_word_valid_mask_per_context_part) # scalar if self.estimator_action.is_evaluate: cond = any_contexts_is_valid # scalar else: # training word_is_valid = tf.greater( row_parts.target_index, self.vocabs.target_vocab.word_to_index[self.vocabs.target_vocab.special_words.OOV]) # scalar cond = tf.logical_and(word_is_valid, any_contexts_is_valid) # scalar return cond # scalar
Example #8
Source File: SegmentationOutputLayers.py From MOTSFusion with MIT License | 6 votes |
def _create_loss(self, loss_str, fraction, logits, targets): raw_ce = None n_valid_pixels_per_im = None if "ce" in loss_str: # we need to replace the void label to avoid nan no_void_label_mask = tf.not_equal(targets, VOID_LABEL) targets_no_void = tf.where(no_void_label_mask, targets, tf.zeros_like(targets)) raw_ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=targets_no_void, name="ce") # set the loss to 0 for the void label pixels raw_ce *= tf.cast(no_void_label_mask, tf.float32) n_valid_pixels_per_im = tf.reduce_sum(tf.cast(no_void_label_mask, tf.int32), axis=[1, 2]) if loss_str == "ce": ce_per_im = tf.reduce_sum(raw_ce, axis=[1, 2]) ce_per_im /= tf.cast(tf.maximum(n_valid_pixels_per_im, 1), tf.float32) ce_total = tf.reduce_mean(ce_per_im, axis=0) loss = ce_total elif loss_str == "bootstrapped_ce": loss = bootstrapped_ce_loss(raw_ce, fraction, n_valid_pixels_per_im) elif loss_str == "class_balanced_ce": loss = class_balanced_ce_loss(raw_ce, targets, self.n_classes) else: assert False, ("unknown loss", loss_str) return loss
Example #9
Source File: keras_model.py From code2vec with MIT License | 6 votes |
def _create_metrics_for_keras_eval_model(self) -> Dict[str, List[Union[Callable, keras.metrics.Metric]]]: top_k_acc_metrics = [] for k in range(1, self.config.TOP_K_WORDS_CONSIDERED_DURING_PREDICTION + 1): top_k_acc_metric = partial( sparse_top_k_categorical_accuracy, k=k) top_k_acc_metric.__name__ = 'top{k}_acc'.format(k=k) top_k_acc_metrics.append(top_k_acc_metric) predicted_words_filters = [ lambda word_strings: tf.not_equal(word_strings, self.vocabs.target_vocab.special_words.OOV), lambda word_strings: tf.strings.regex_full_match(word_strings, r'^[a-zA-Z\|]+$') ] words_subtokens_metrics = [ WordsSubtokenPrecisionMetric(predicted_words_filters=predicted_words_filters, name='subtoken_precision'), WordsSubtokenRecallMetric(predicted_words_filters=predicted_words_filters, name='subtoken_recall'), WordsSubtokenF1Metric(predicted_words_filters=predicted_words_filters, name='subtoken_f1') ] return {'target_index': top_k_acc_metrics, 'target_string': words_subtokens_metrics}
Example #10
Source File: losses.py From R3Det_Tensorflow with MIT License | 6 votes |
def focal_loss_(labels, pred, anchor_state, alpha=0.25, gamma=2.0): # filter out "ignore" anchors indices = tf.reshape(tf.where(tf.not_equal(anchor_state, -1)), [-1, ]) labels = tf.gather(labels, indices) pred = tf.gather(pred, indices) logits = tf.cast(pred, tf.float32) onehot_labels = tf.cast(labels, tf.float32) ce = tf.nn.sigmoid_cross_entropy_with_logits(labels=onehot_labels, logits=logits) predictions = tf.sigmoid(logits) predictions_pt = tf.where(tf.equal(onehot_labels, 1), predictions, 1.-predictions) alpha_t = tf.scalar_mul(alpha, tf.ones_like(onehot_labels, dtype=tf.float32)) alpha_t = tf.where(tf.equal(onehot_labels, 1.0), alpha_t, 1-alpha_t) loss = ce * tf.pow(1-predictions_pt, gamma) * alpha_t positive_mask = tf.cast(tf.greater(labels, 0), tf.float32) return tf.reduce_sum(loss) / tf.maximum(tf.reduce_sum(positive_mask), 1)
Example #11
Source File: common_attention.py From fine-lm with MIT License | 6 votes |
def attention_bias_same_segment(query_segment_id, memory_segment_id): """Create an bias tensor to be added to attention logits. Positions with the same segment_ids can see each other. Args: query_segment_id: a float `Tensor` with shape [batch, query_length]. memory_segment_id: a float `Tensor` with shape [batch, memory_length]. Returns: a `Tensor` with shape [batch, 1, query_length, memory_length]. """ ret = tf.to_float( tf.not_equal( tf.expand_dims(query_segment_id, 2), tf.expand_dims(memory_segment_id, 1))) * -1e9 return tf.expand_dims(ret, axis=1)
Example #12
Source File: common_layers.py From BERT with Apache License 2.0 | 6 votes |
def weights_multi_problem(labels, taskid=-1): """Assign weight 1.0 to only the "targets" portion of the labels. Weight 1.0 is assigned to all labels past the taskid. Args: labels: A Tensor of int32s. taskid: an int32 representing the task id for a problem. Returns: A Tensor of floats. Raises: ValueError: The Task ID must be valid. """ taskid = check_nonnegative(taskid) past_taskid = tf.cumsum(to_float(tf.equal(labels, taskid)), axis=1) # Additionally zero out the task id location past_taskid *= to_float(tf.not_equal(labels, taskid)) non_taskid = to_float(labels) return to_float(tf.not_equal(past_taskid * non_taskid, 0))
Example #13
Source File: modalities.py From fine-lm with MIT License | 6 votes |
def bottom_simple(self, x, name, reuse): with tf.variable_scope(name, reuse=reuse): # Ensure the inputs are 3-D if len(x.get_shape()) == 4: x = tf.squeeze(x, axis=3) while len(x.get_shape()) < 3: x = tf.expand_dims(x, axis=-1) var = self._get_weights() x = common_layers.dropout_no_scaling( x, 1.0 - self._model_hparams.symbol_dropout) ret = common_layers.gather(var, x) if self._model_hparams.multiply_embedding_mode == "sqrt_depth": ret *= self._body_input_depth**0.5 ret *= tf.expand_dims(tf.to_float(tf.not_equal(x, 0)), -1) return ret
Example #14
Source File: mask_rcnn_model.py From training_results_v0.5 with Apache License 2.0 | 6 votes |
def _rpn_box_loss(box_outputs, box_targets, normalizer=1.0, delta=1./9): """Computes box regression loss.""" # delta is typically around the mean value of regression target. # for instances, the regression targets of 512x512 input with 6 anchors on # P2-P6 pyramid is about [0.1, 0.1, 0.2, 0.2]. with tf.name_scope('rpn_box_loss'): mask = tf.not_equal(box_targets, 0.0) # The loss is normalized by the sum of non-zero weights before additional # normalizer provided by the function caller. box_loss = tf.losses.huber_loss( box_targets, box_outputs, weights=mask, delta=delta, reduction=tf.losses.Reduction.SUM_BY_NONZERO_WEIGHTS) box_loss /= normalizer return box_loss
Example #15
Source File: modalities.py From training_results_v0.5 with Apache License 2.0 | 6 votes |
def bottom_simple(self, x, name, reuse): with tf.variable_scope(name, reuse=reuse): # Ensure the inputs are 3-D if len(x.get_shape()) == 4: x = tf.squeeze(x, axis=3) while len(x.get_shape()) < 3: x = tf.expand_dims(x, axis=-1) var = self._get_weights() x = common_layers.dropout_no_scaling( x, 1.0 - self._model_hparams.symbol_dropout) ret = common_layers.gather(var, x) if self._model_hparams.multiply_embedding_mode == "sqrt_depth": ret *= self._body_input_depth**0.5 ret *= tf.expand_dims(tf.to_float(tf.not_equal(x, 0)), -1) return ret
Example #16
Source File: common_attention.py From training_results_v0.5 with Apache License 2.0 | 6 votes |
def attention_bias_same_segment(query_segment_id, memory_segment_id): """Create an bias tensor to be added to attention logits. Positions with the same segment_ids can see each other. Args: query_segment_id: a float `Tensor` with shape [batch, query_length]. memory_segment_id: a float `Tensor` with shape [batch, memory_length]. Returns: a `Tensor` with shape [batch, 1, query_length, memory_length]. """ ret = tf.to_float( tf.not_equal( tf.expand_dims(query_segment_id, 2), tf.expand_dims(memory_segment_id, 1))) * -1e9 return tf.expand_dims(ret, axis=1)
Example #17
Source File: metrics.py From yolo_v2 with Apache License 2.0 | 5 votes |
def sequence_accuracy(predictions, targets, rej_char, streaming=False): """Computes sequence level accuracy. Both input tensors should have the same shape: [batch_size x seq_length]. Args: predictions: predicted character classes. targets: ground truth character classes. rej_char: the character id used to mark empty element (end of sequence). streaming: if True, uses the streaming mean from the slim.metric module. Returns: a update_ops for execution and value tensor whose value on evaluation returns the total sequence accuracy. """ with tf.variable_scope('SequenceAccuracy'): predictions.get_shape().assert_is_compatible_with(targets.get_shape()) targets = tf.to_int32(targets) const_rej_char = tf.constant( rej_char, shape=targets.get_shape(), dtype=tf.int32) include_mask = tf.not_equal(targets, const_rej_char) include_predictions = tf.to_int32( tf.where(include_mask, predictions, tf.zeros_like(predictions) + rej_char)) correct_chars = tf.to_float(tf.equal(include_predictions, targets)) correct_chars_counts = tf.cast( tf.reduce_sum(correct_chars, reduction_indices=[1]), dtype=tf.int32) target_length = targets.get_shape().dims[1].value target_chars_counts = tf.constant( target_length, shape=correct_chars_counts.get_shape()) accuracy_per_example = tf.to_float( tf.equal(correct_chars_counts, target_chars_counts)) if streaming: return tf.contrib.metrics.streaming_mean(accuracy_per_example) else: return tf.reduce_mean(accuracy_per_example)
Example #18
Source File: Resize.py From MOTSFusion with MIT License | 5 votes |
def object_crop_fixed_offset(tensors, size): label = tensors[DataKeys.SEGMENTATION_LABELS] object_locations = tf.cast(tf.where(tf.not_equal(label, 0))[:, :2], tf.int32) min_val = tf.maximum(tf.constant([0, 0]), tf.reduce_max(object_locations, axis=0) - size) offset = tf.concat([min_val, [0]], axis=0) return random_crop_tensors(tensors, size, offset)
Example #19
Source File: metrics.py From yolo_v2 with Apache License 2.0 | 5 votes |
def char_accuracy(predictions, targets, rej_char, streaming=False): """Computes character level accuracy. Both predictions and targets should have the same shape [batch_size x seq_length]. Args: predictions: predicted characters ids. targets: ground truth character ids. rej_char: the character id used to mark an empty element (end of sequence). streaming: if True, uses the streaming mean from the slim.metric module. Returns: a update_ops for execution and value tensor whose value on evaluation returns the total character accuracy. """ with tf.variable_scope('CharAccuracy'): predictions.get_shape().assert_is_compatible_with(targets.get_shape()) targets = tf.to_int32(targets) const_rej_char = tf.constant(rej_char, shape=targets.get_shape()) weights = tf.to_float(tf.not_equal(targets, const_rej_char)) correct_chars = tf.to_float(tf.equal(predictions, targets)) accuracy_per_example = tf.div( tf.reduce_sum(tf.multiply(correct_chars, weights), 1), tf.reduce_sum(weights, 1)) if streaming: return tf.contrib.metrics.streaming_mean(accuracy_per_example) else: return tf.reduce_mean(accuracy_per_example)
Example #20
Source File: normalisation.py From DeepXi with Mozilla Public License 2.0 | 5 votes |
def compute_mask(self, inputs, mask=None): """ """ if not self.mask_zero: return None return tf.not_equal(inputs, 0)
Example #21
Source File: model.py From yolo_v2 with Apache License 2.0 | 5 votes |
def error_computation(self): #computes the error of each example in a batch math_error = 0.5 * tf.square(tf.subtract(self.scalar_output, self.batch_answer)) #scale math error math_error = math_error / self.rows math_error = tf.minimum(math_error, self.utility.FLAGS.max_math_error * tf.ones(tf.shape(math_error), self.data_type)) self.init_print_error = tf.where( self.batch_gold_select, -1 * tf.log(self.batch_lookup_answer + 1e-300 + self.invert_select_full_mask), -1 * tf.log(1 - self.batch_lookup_answer)) * self.select_full_mask print_error_1 = self.init_print_error * tf.cast( tf.equal(self.batch_print_answer, 0.0), self.data_type) print_error = tf.reduce_sum(tf.reduce_sum((print_error_1), 1), 1) for val in range(1, 58): print_error += self.compute_lookup_error(val + 0.0) print_error = print_error * self.utility.FLAGS.print_cost / self.num_entries if (self.mode == "train"): error = tf.where( tf.logical_and( tf.not_equal(self.batch_answer, 0.0), tf.not_equal( tf.reduce_sum(tf.reduce_sum(self.batch_print_answer, 1), 1), 0.0)), self.soft_min(math_error, print_error), tf.where( tf.not_equal(self.batch_answer, 0.0), math_error, print_error)) else: error = tf.where( tf.logical_and( tf.equal(self.scalar_output, 0.0), tf.equal( tf.reduce_sum(tf.reduce_sum(self.batch_lookup_answer, 1), 1), 0.0)), tf.ones_like(math_error), tf.where( tf.equal(self.scalar_output, 0.0), print_error, math_error)) return error
Example #22
Source File: metrics.py From DOTA_models with Apache License 2.0 | 5 votes |
def char_accuracy(predictions, targets, rej_char, streaming=False): """Computes character level accuracy. Both predictions and targets should have the same shape [batch_size x seq_length]. Args: predictions: predicted characters ids. targets: ground truth character ids. rej_char: the character id used to mark an empty element (end of sequence). streaming: if True, uses the streaming mean from the slim.metric module. Returns: a update_ops for execution and value tensor whose value on evaluation returns the total character accuracy. """ with tf.variable_scope('CharAccuracy'): predictions.get_shape().assert_is_compatible_with(targets.get_shape()) targets = tf.to_int32(targets) const_rej_char = tf.constant(rej_char, shape=targets.get_shape()) weights = tf.to_float(tf.not_equal(targets, const_rej_char)) correct_chars = tf.to_float(tf.equal(predictions, targets)) accuracy_per_example = tf.div( tf.reduce_sum(tf.multiply(correct_chars, weights), 1), tf.reduce_sum(weights, 1)) if streaming: return tf.contrib.metrics.streaming_mean(accuracy_per_example) else: return tf.reduce_mean(accuracy_per_example)
Example #23
Source File: check_video_id.py From youtube-8m with Apache License 2.0 | 5 votes |
def build_graph(all_readers, input_reader, input_data_pattern, all_eval_data_patterns, batch_size=256): original_video_id, original_input, unused_labels_batch, unused_num_frames = ( get_input_evaluation_tensors( input_reader, input_data_pattern, batch_size=batch_size)) video_id_equal_tensors = [] model_input_tensor = None input_distance_tensors = [] for reader, data_pattern in zip(all_readers, all_eval_data_patterns): video_id, model_input_raw, labels_batch, unused_num_frames = ( get_input_evaluation_tensors( reader, data_pattern, batch_size=batch_size)) video_id_equal_tensors.append(tf.reduce_sum(tf.cast(tf.not_equal(original_video_id, video_id), dtype=tf.float32))) if model_input_tensor is None: model_input_tensor = model_input_raw input_distance_tensors.append(tf.reduce_mean(tf.reduce_sum(tf.square(model_input_tensor - model_input_raw), axis=1))) video_id_equal_tensor = tf.stack(video_id_equal_tensors) input_distance_tensor = tf.stack(input_distance_tensors) tf.add_to_collection("video_id_equal", video_id_equal_tensor) tf.add_to_collection("input_distance", input_distance_tensor)
Example #24
Source File: check_video_id_match.py From youtube-8m with Apache License 2.0 | 5 votes |
def build_graph(all_readers, input_reader, input_data_pattern, all_eval_data_patterns, batch_size=256): original_video_id, original_input, unused_labels_batch, unused_num_frames = ( get_input_evaluation_tensors( input_reader, input_data_pattern, batch_size=batch_size)) video_id_notequal_tensors = [] model_input_tensor = None input_distance_tensors = [] for reader, data_pattern in zip(all_readers, all_eval_data_patterns): video_id, model_input_raw, labels_batch, unused_num_frames = ( get_input_evaluation_tensors( reader, data_pattern, batch_size=batch_size)) video_id_notequal_tensors.append(tf.reduce_sum(tf.cast(tf.not_equal(original_video_id, video_id), dtype=tf.float32))) if model_input_tensor is None: model_input_tensor = model_input_raw input_distance_tensors.append(tf.reduce_mean(tf.reduce_sum(tf.square(model_input_tensor - model_input_raw), axis=1))) video_id_mismatch_tensor = tf.stack(video_id_notequal_tensors) input_distance_tensor = tf.stack(input_distance_tensors) actual_batch_size = tf.shape(original_video_id)[0] tf.add_to_collection("video_id_mismatch", video_id_mismatch_tensor) tf.add_to_collection("input_distance", input_distance_tensor) tf.add_to_collection("actual_batch_size", actual_batch_size)
Example #25
Source File: training.py From CVTron with Apache License 2.0 | 5 votes |
def get_valid_entries_indices_from_annotation_batch(annotation_batch_tensor, class_labels): """Returns tensor of size (num_valid_eintries, 3). Returns tensor that contains the indices of valid entries according to the annotation tensor. This can be used to later on extract only valid entries from logits tensor and labels tensor. This function is supposed to work with a batch input like [b, w, h] -- where b is a batch size, w, h -- are width and height sizes. So the output is a tensor which contains indexes of valid entries. This function can also work with a single annotation like [w, h] -- the output will be (num_valid_eintries, 2). Parameters ---------- annotation_batch_tensor : Tensor of size (batch_size, width, height) Tensor with class labels for each batch class_labels : list of ints List that contains the numbers that represent classes. Last value in the list should represent the number that was used for masking out. Returns ------- valid_labels_indices : Tensor of size (num_valid_eintries, 3). Tensor with indices of valid entries """ # Last value in the classes list should show # which number was used in the annotation to mask out # the ambigious regions or regions that should not be # used for training. # TODO: probably replace class_labels list with some custom object mask_out_class_label = class_labels[-1] # Get binary mask for the pixels that we want to # use for training. We do this because some pixels # are marked as ambigious and we don't want to use # them for trainig to avoid confusing the model valid_labels_mask = tf.not_equal(annotation_batch_tensor, mask_out_class_label) valid_labels_indices = tf.where(valid_labels_mask) return tf.to_int32(valid_labels_indices)
Example #26
Source File: losses.py From R3Det_Tensorflow with MIT License | 5 votes |
def scale_focal_loss(labels, pred, anchor_state, target_boxes, alpha=0.25, gamma=2.0, use_scale_factor=False): # filter out "ignore" anchors indices = tf.reshape(tf.where(tf.not_equal(anchor_state, -1)), [-1, ]) labels = tf.gather(labels, indices) pred = tf.gather(pred, indices) target_boxes = tf.gather(target_boxes, indices) # compute the focal loss per_entry_cross_ent = (tf.nn.sigmoid_cross_entropy_with_logits( labels=labels, logits=pred)) prediction_probabilities = tf.sigmoid(pred) p_t = ((labels * prediction_probabilities) + ((1 - labels) * (1 - prediction_probabilities))) modulating_factor = 1.0 if gamma: modulating_factor = tf.pow(1.0 - p_t, gamma) alpha_weight_factor = 1.0 if alpha is not None: alpha_weight_factor = (labels * alpha + (1 - labels) * (1 - alpha)) focal_cross_entropy_loss = (modulating_factor * alpha_weight_factor * per_entry_cross_ent) if use_scale_factor: area = target_boxes[:, 2] * target_boxes[:, 3] area = tf.reshape(area, [-1, 1]) scale_factor = tf.stop_gradient(tf.exp(-1 * area) + 1) else: scale_factor = 1.0 # compute the normalizer: the number of positive anchors normalizer = tf.stop_gradient(tf.where(tf.equal(anchor_state, 1))) normalizer = tf.cast(tf.shape(normalizer)[0], tf.float32) normalizer = tf.maximum(1.0, normalizer) # normalizer = tf.stop_gradient(tf.cast(tf.equal(anchor_state, 1), tf.float32)) # normalizer = tf.maximum(tf.reduce_sum(normalizer), 1) return tf.reduce_sum(focal_cross_entropy_loss * scale_factor) / normalizer
Example #27
Source File: losses.py From R3Det_Tensorflow with MIT License | 5 votes |
def focal_loss(labels, pred, anchor_state, alpha=0.25, gamma=2.0): # filter out "ignore" anchors indices = tf.reshape(tf.where(tf.not_equal(anchor_state, -1)), [-1, ]) labels = tf.gather(labels, indices) pred = tf.gather(pred, indices) # compute the focal loss per_entry_cross_ent = (tf.nn.sigmoid_cross_entropy_with_logits( labels=labels, logits=pred)) prediction_probabilities = tf.sigmoid(pred) p_t = ((labels * prediction_probabilities) + ((1 - labels) * (1 - prediction_probabilities))) modulating_factor = 1.0 if gamma: modulating_factor = tf.pow(1.0 - p_t, gamma) alpha_weight_factor = 1.0 if alpha is not None: alpha_weight_factor = (labels * alpha + (1 - labels) * (1 - alpha)) focal_cross_entropy_loss = (modulating_factor * alpha_weight_factor * per_entry_cross_ent) # compute the normalizer: the number of positive anchors normalizer = tf.stop_gradient(tf.where(tf.equal(anchor_state, 1))) normalizer = tf.cast(tf.shape(normalizer)[0], tf.float32) normalizer = tf.maximum(1.0, normalizer) # normalizer = tf.stop_gradient(tf.cast(tf.equal(anchor_state, 1), tf.float32)) # normalizer = tf.maximum(tf.reduce_sum(normalizer), 1) return tf.reduce_sum(focal_cross_entropy_loss) / normalizer
Example #28
Source File: losses_win.py From R3Det_Tensorflow with MIT License | 5 votes |
def scale_focal_loss(labels, pred, anchor_state, target_boxes, alpha=0.25, gamma=2.0, use_scale_factor=False): # filter out "ignore" anchors indices = tf.reshape(tf.where(tf.not_equal(anchor_state, -1)), [-1, ]) labels = tf.gather(labels, indices) pred = tf.gather(pred, indices) target_boxes = tf.gather(target_boxes, indices) # compute the focal loss per_entry_cross_ent = (tf.nn.sigmoid_cross_entropy_with_logits( labels=labels, logits=pred)) prediction_probabilities = tf.sigmoid(pred) p_t = ((labels * prediction_probabilities) + ((1 - labels) * (1 - prediction_probabilities))) modulating_factor = 1.0 if gamma: modulating_factor = tf.pow(1.0 - p_t, gamma) alpha_weight_factor = 1.0 if alpha is not None: alpha_weight_factor = (labels * alpha + (1 - labels) * (1 - alpha)) focal_cross_entropy_loss = (modulating_factor * alpha_weight_factor * per_entry_cross_ent) if use_scale_factor: area = target_boxes[:, 2] * target_boxes[:, 3] area = tf.reshape(area, [-1, 1]) scale_factor = tf.stop_gradient(tf.exp(-1 * area) + 1) else: scale_factor = 1.0 # compute the normalizer: the number of positive anchors normalizer = tf.stop_gradient(tf.where(tf.equal(anchor_state, 1))) normalizer = tf.cast(tf.shape(normalizer)[0], tf.float32) normalizer = tf.maximum(1.0, normalizer) # normalizer = tf.stop_gradient(tf.cast(tf.equal(anchor_state, 1), tf.float32)) # normalizer = tf.maximum(tf.reduce_sum(normalizer), 1) return tf.reduce_sum(focal_cross_entropy_loss * scale_factor) / normalizer
Example #29
Source File: losses_win.py From R3Det_Tensorflow with MIT License | 5 votes |
def angle_focal_loss(labels, pred, anchor_state, alpha=0.25, gamma=2.0): # filter out "ignore" anchors indices = tf.reshape(tf.where(tf.not_equal(anchor_state, -1)), [-1, ]) labels = tf.gather(labels, indices) pred = tf.gather(pred, indices) # compute the focal loss per_entry_cross_ent = - labels * tf.log(tf.sigmoid(pred) + cfgs.EPSILON) \ - (1 - labels) * tf.log(1 - tf.sigmoid(pred) + cfgs.EPSILON) prediction_probabilities = tf.sigmoid(pred) p_t = ((labels * prediction_probabilities) + ((1 - labels) * (1 - prediction_probabilities))) modulating_factor = 1.0 if gamma: modulating_factor = tf.pow(1.0 - p_t, gamma) alpha_weight_factor = 1.0 if alpha is not None: alpha_weight_factor = (labels * alpha + (1 - labels) * (1 - alpha)) focal_cross_entropy_loss = (modulating_factor * alpha_weight_factor * per_entry_cross_ent) # compute the normalizer: the number of positive anchors normalizer = tf.stop_gradient(tf.where(tf.greater(anchor_state, -2))) normalizer = tf.cast(tf.shape(normalizer)[0], tf.float32) normalizer = tf.maximum(1.0, normalizer) # normalizer = tf.stop_gradient(tf.cast(tf.equal(anchor_state, 1), tf.float32)) # normalizer = tf.maximum(tf.reduce_sum(normalizer), 1) return tf.reduce_sum(focal_cross_entropy_loss) / normalizer
Example #30
Source File: losses_win.py From R3Det_Tensorflow with MIT License | 5 votes |
def focal_loss(labels, pred, anchor_state, alpha=0.25, gamma=2.0): # filter out "ignore" anchors indices = tf.reshape(tf.where(tf.not_equal(anchor_state, -1)), [-1, ]) labels = tf.gather(labels, indices) pred = tf.gather(pred, indices) # compute the focal loss per_entry_cross_ent = (tf.nn.sigmoid_cross_entropy_with_logits( labels=labels, logits=pred)) prediction_probabilities = tf.sigmoid(pred) p_t = ((labels * prediction_probabilities) + ((1 - labels) * (1 - prediction_probabilities))) modulating_factor = 1.0 if gamma: modulating_factor = tf.pow(1.0 - p_t, gamma) alpha_weight_factor = 1.0 if alpha is not None: alpha_weight_factor = (labels * alpha + (1 - labels) * (1 - alpha)) focal_cross_entropy_loss = (modulating_factor * alpha_weight_factor * per_entry_cross_ent) # compute the normalizer: the number of positive anchors normalizer = tf.stop_gradient(tf.where(tf.equal(anchor_state, 1))) normalizer = tf.cast(tf.shape(normalizer)[0], tf.float32) normalizer = tf.maximum(1.0, normalizer) # normalizer = tf.stop_gradient(tf.cast(tf.equal(anchor_state, 1), tf.float32)) # normalizer = tf.maximum(tf.reduce_sum(normalizer), 1) return tf.reduce_sum(focal_cross_entropy_loss) / normalizer