我们从Python开源项目中，提取了以下46个代码示例，用于说明如何使用tensorflow.reduce_any()。
def recall(proposals, proposals_num, ground_truth, ground_truth_num, iou_threshold): '''Calculate recall with given IoU threshold proposals: N x 4 tensor (N x (y, x, h, w)) proposals_num: proposals count ground_truth: M x 4 tensor (M x (y, x, h, w)) ground_truth_num: ground truth boxes count iou_threshold: float in range [0; 1] returns recall ''' # shape is N x M iou_metric = iou(ground_truth, ground_truth_num, proposals, proposals_num) # shape is M x 1 true_positives = tf.reduce_sum( tf.cast(tf.reduce_any(iou_metric >= iou_threshold, axis=0), tf.float32)) return true_positives / tf.cast(ground_truth_num, tf.float32)
def precision(proposals, proposals_num, ground_truth, ground_truth_num, iou_threshold): '''Calculate precision with given IoU threshold proposals: N x 4 tensor (N x (y, x, h, w)) proposals_num: proposals count ground_truth: M x 4 tensor (M x (y, x, h, w)) ground_truth_num: ground truth boxes count iou_threshold: float in range [0; 1] returns precision ''' # shape is N x M iou_metric = iou(ground_truth, ground_truth_num, proposals, proposals_num) # shape is M x 1 true_positives = tf.reduce_sum( tf.cast(tf.reduce_any(iou_metric >= iou_threshold, axis=1), tf.float32)) return true_positives / tf.cast(proposals_num, tf.float32)
def insert(self, ids, scores): """Insert the ids and scores into the TopN.""" with tf.control_dependencies(self.last_ops): scatter_op = tf.scatter_update(self.id_to_score, ids, scores) larger_scores = tf.greater(scores, self.sl_scores[0]) def shortlist_insert(): larger_ids = tf.boolean_mask(tf.to_int64(ids), larger_scores) larger_score_values = tf.boolean_mask(scores, larger_scores) shortlist_ids, new_ids, new_scores = self.ops.top_n_insert( self.sl_ids, self.sl_scores, larger_ids, larger_score_values) u1 = tf.scatter_update(self.sl_ids, shortlist_ids, new_ids) u2 = tf.scatter_update(self.sl_scores, shortlist_ids, new_scores) return tf.group(u1, u2) # We only need to insert into the shortlist if there are any # scores larger than the threshold. cond_op = tf.cond( tf.reduce_any(larger_scores), shortlist_insert, tf.no_op) with tf.control_dependencies([cond_op]): self.last_ops = [scatter_op, cond_op]
def aggregate_gradients_using_copy_with_device_selection( benchmark_cnn, tower_grads, use_mean, check_inf_nan): """Aggregate gradients, controlling device for the aggregation. Args: benchmark_cnn: benchmark_cnn class. tower_grads: List of lists of (gradient, variable) tuples. The outer list is over towers. The inner list is over individual gradients. use_mean: if True, mean is taken, else sum of gradients is taken. check_inf_nan: If true, check grads for nans and infs. Returns: The tuple ([(average_gradient, variable),], has_nan_or_inf) where the gradient has been averaged across all towers. The variable is chosen from the first tower. The has_nan_or_inf indicates the grads has nan or inf. """ if benchmark_cnn.local_parameter_device_flag == 'gpu': avail_devices = benchmark_cnn.raw_devices else: avail_devices = [benchmark_cnn.param_server_device] agg_grads = [] has_nan_or_inf_list = [] for i, single_grads in enumerate(zip(*tower_grads)): with tf.device(avail_devices[i % len(avail_devices)]): grad_and_var, has_nan_or_inf = aggregate_single_gradient_using_copy( single_grads, use_mean, check_inf_nan) agg_grads.append(grad_and_var) has_nan_or_inf_list.append(has_nan_or_inf) if check_inf_nan: return agg_grads, tf.reduce_any(has_nan_or_inf_list) else: return agg_grads, None
def aggregate_gradients_using_copy_with_variable_colocation( tower_grads, use_mean, check_inf_nan): """Aggregate gradients, colocating computation with the gradient's variable. Args: tower_grads: List of lists of (gradient, variable) tuples. The outer list is over towers. The inner list is over individual gradients. All variables of the same gradient across towers must be the same (that is, tower_grads[x][a][1] == tower_grads[y][a][1] for all indices x, y, and a) use_mean: if True, mean is taken, else sum of gradients is taken. check_inf_nan: If true, check grads for nans and infs. Returns: The tuple ([(average_gradient, variable),], has_nan_or_inf) where the gradient has been averaged across all towers. The variable is chosen from the first tower. The has_nan_or_inf indicates the grads has nan or inf. """ agg_grads = [] has_nan_or_inf_list = [] for single_grads in zip(*tower_grads): # Note that each single_grads looks like the following: # ((grad0_gpu0, var0_gpu0), ... , (grad0_gpuN, var0_gpuN)) var = single_grads[0][1] for _, v in single_grads: assert v == var with tf.device(var.device): grad_and_var, has_nan_or_inf = aggregate_single_gradient_using_copy( single_grads, use_mean, check_inf_nan) agg_grads.append(grad_and_var) has_nan_or_inf_list.append(has_nan_or_inf) if check_inf_nan: return agg_grads, tf.reduce_any(has_nan_or_inf_list) else: return agg_grads, None
def aggregate_gradients_using_copy(tower_grads, use_mean, check_inf_nan): """Calculate the average gradient for each shared variable across all towers. Note that this function provides a synchronization point across all towers. Args: tower_grads: List of lists of (gradient, variable) tuples. The outer list is over towers. The inner list is over individual gradients. use_mean: if True, mean is taken, else sum of gradients is taken. check_inf_nan: check grads for nans and infs. Returns: The tuple ([(average_gradient, variable),], has_nan_or_inf) where the gradient has been averaged across all towers. The variable is chosen from the first tower. The has_nan_or_inf indicates the grads has nan or inf. """ agg_grads = [] has_nan_or_inf_list = [] for single_grads in zip(*tower_grads): grad_and_var, has_nan_or_inf = aggregate_single_gradient_using_copy( single_grads, use_mean, check_inf_nan) agg_grads.append(grad_and_var) has_nan_or_inf_list.append(has_nan_or_inf) if check_inf_nan: return agg_grads, tf.reduce_any(has_nan_or_inf_list) else: return agg_grads, None
def segment_argmax(input, segment_ids): """Computes row and col indices Tensors of the segment max in the 2D input.""" with tf.name_scope("segment_argmax"): num_partitions = tf.reduce_max(segment_ids) + 1 is_max = segment_is_max(input, segment_ids) # The current is_max could still contain multiple True entries per # partition. As long as they are in the same row, that is not a problem. # However, we do need to remove duplicate Trues in the same partition # in multiple rows. # For that, we'll multiply is_max with the row indices + 1 and perform # segment_is_max() again. rows = tf.shape(input)[0] cols = tf.shape(input)[1] row_indices = tf.tile(tf.expand_dims(tf.range(rows), 1), [1, cols]) is_max = segment_is_max(tf.cast(is_max, tf.int32) * (row_indices + 1), segment_ids) # Get selected rows and columns row_selected = tf.reduce_any(is_max, axis=1) row_indices = tf.squeeze(tf.where(row_selected)) rows_selected = tf.reduce_sum(tf.cast(row_selected, tf.int64)) # Assert rows_selected is correct & ensure row_indices is always 1D with tf.control_dependencies([tf.assert_equal(rows_selected, num_partitions)]): row_indices = tf.reshape(row_indices, [-1]) selected_rows_is_max = tf.gather(is_max, row_indices) col_indices = tf.argmax(tf.cast(selected_rows_is_max, tf.int64), axis=1) # Pack indices return row_indices, col_indices
def any(x, axis=None, keepdims=False): '''Bitwise reduction (logical OR). Returns an uint8 tensor (0s and 1s). ''' axis = _normalize_axis(axis, ndim(x)) x = tf.cast(x, tf.bool) x = tf.reduce_any(x, reduction_indices=axis, keep_dims=keepdims) return tf.cast(x, tf.uint8)
def _sample(self, n_samples): try: # tf.random_poisson is implemented after v1.2 random_poisson = tf.random_poisson except AttributeError: # This algorithm to generate random Poisson-distributed numbers is # given by Kunth [1] # [1]: https://en.wikipedia.org/wiki/ # Poisson_distribution#Generating_Poisson-distributed_random_variables shape = tf.concat([[n_samples], self.batch_shape], 0) static_n_samples = n_samples if isinstance(n_samples, int) else None static_shape = tf.TensorShape([static_n_samples]).concatenate( self.get_batch_shape()) enlam = tf.exp(-self.rate) x = tf.zeros(shape, dtype=self.dtype) prod = tf.ones(shape, dtype=self.param_dtype) def loop_cond(prod, x): return tf.reduce_any(tf.greater_equal(prod, enlam)) def loop_body(prod, x): prod *= tf.random_uniform(tf.shape(prod), minval=0, maxval=1) x += tf.cast(tf.greater_equal(prod, enlam), dtype=self.dtype) return prod, x _, samples = tf.while_loop( loop_cond, loop_body, loop_vars=[prod, x], shape_invariants=[static_shape, static_shape]) samples.set_shape(static_shape) else: samples = random_poisson(self.rate, [n_samples], dtype=self.param_dtype) if self.param_dtype != self.dtype: samples = tf.cast(samples, self.dtype) return samples
def _cond(self, unused_x, unused_cumul_out, unused_prev_state, unused_cumul_state, cumul_halting, unused_iteration, unused_remainder): """The `cond` of the `tf.while_loop`.""" return tf.reduce_any(cumul_halting < 1)
def any(self, x, axis=None, keepdims=False): '''Bitwise reduction (logical OR). Returns an uint8 tensor (0s and 1s). ''' x = self.cast(x, tf.bool) x = tf.reduce_any(x, reduction_indices=axis, keep_dims=keepdims) return self.cast(x, tf.uint8)
def any(x, axis=None, keepdims=False): """Bitwise reduction (logical OR). # Arguments x: input tensor. axis: axis along which to perform the reduction. keepdims: whether the drop or broadcast the reduction axes. # Returns A uint8 tensor (0s and 1s). """ axis = _normalize_axis(axis, ndim(x)) x = tf.cast(x, tf.bool) x = tf.reduce_any(x, reduction_indices=axis, keep_dims=keepdims) return tf.cast(x, tf.uint8)
def test_name(self): result_lt = ops.reduce_any(self.bool_lt, {'channel'}) self.assertIn('lt_reduce_any', result_lt.name)
def test(self): result_lt = ops.reduce_any(self.bool_lt, {'channel'}) golden_lt = core.LabeledTensor( tf.reduce_any(self.bool_tensor, 1), [self.a0, self.a2, self.a3]) self.assertLabeledTensorsEqual(result_lt, golden_lt)
def __call__(self, inputs, state, timestep = 0, scope=None): with vs.variable_scope(scope or type(self).__name__): # define within cell constants/ counters used to control while loop for ACTStep prob = tf.constant(0.0,tf.float32,[self.batch_size], name="prob") prob_compare = tf.constant(0.0,tf.float32,[self.batch_size], name="prob_compare") counter = tf.constant(0.0, tf.float32,[self.batch_size], name="counter") acc_outputs = tf.zeros_like(state, tf.float32, name="output_accumulator") acc_states = tf.zeros_like(state, tf.float32, name="state_accumulator") batch_mask = tf.constant(True, tf.bool,[self.batch_size]) # While loop stops when this predicate is FALSE. # Ie all (probability < 1-eps AND counter < N) are false. pred = lambda batch_mask,prob_compare,prob,\ counter,state,inputs,acc_output,acc_state:\ tf.reduce_any( tf.logical_and( tf.less(prob_compare,self.one_minus_eps), tf.less(counter,self.N))) # only stop if all of the batch have passed either threshold # Do while loop iterations until predicate above is false. _,_,remainders,iterations,_,_,output,next_state = \ control_flow_ops.while_loop(pred,self.ACTStep, [batch_mask,prob_compare,prob, counter,state,inputs, acc_outputs, acc_states]) #accumulate remainder and N values self.ACT_remainder.append(tf.reduce_mean(1 - remainders)) self.ACT_iterations.append(tf.reduce_mean(iterations)) return output, next_state
def do_act_steps(self, premise, hypothesis): self.rep_size = premise.get_shape()[-1].value self.one_minus_eps = tf.constant(1.0 - self.config.eps, tf.float32,[self.batch_size]) self.N = tf.constant(self.config.max_computation, tf.float32,[self.batch_size]) prob = tf.constant(0.0,tf.float32,[self.batch_size], name="prob") prob_compare = tf.constant(0.0,tf.float32,[self.batch_size], name="prob_compare") counter = tf.constant(0.0, tf.float32,[self.batch_size], name="counter") initial_state = tf.zeros([self.batch_size, 2*self.rep_size], tf.float32, name="state") acc_states = tf.zeros([self.batch_size,2*self.rep_size], tf.float32, name="state_accumulator") batch_mask = tf.constant(True, tf.bool,[self.batch_size]) # While loop stops when this predicate is FALSE. # Ie all (probability < 1-eps AND counter < N) are false. pred = lambda batch_mask,prob_compare,prob,\ counter,state,premise, hypothesis ,acc_state:\ tf.reduce_any( tf.logical_and( tf.less(prob_compare,self.one_minus_eps), tf.less(counter,self.N))) # only stop if all of the batch have passed either threshold # Do while loop iterations until predicate above is false. _,_,remainders,iterations,_,_,_,state = \ tf.while_loop(pred,self.inference_step, [batch_mask,prob_compare,prob, counter,initial_state, premise, hypothesis, acc_states]) return state, remainders, iterations
def do_inference_steps(self, initial_state, premise, hypothesis): self.one_minus_eps = tf.constant(1.0 - self.config.eps, tf.float32,[self.batch_size]) self.N = tf.constant(self.config.max_computation, tf.float32,[self.batch_size]) prob = tf.constant(0.0,tf.float32,[self.batch_size], name="prob") prob_compare = tf.constant(0.0,tf.float32,[self.batch_size], name="prob_compare") counter = tf.constant(0.0, tf.float32,[self.batch_size], name="counter") acc_states = tf.zeros_like(initial_state, tf.float32, name="state_accumulator") batch_mask = tf.constant(True, tf.bool,[self.batch_size]) # While loop stops when this predicate is FALSE. # Ie all (probability < 1-eps AND counter < N) are false. pred = lambda batch_mask,prob_compare,prob,\ counter,state,premise, hypothesis ,acc_state:\ tf.reduce_any( tf.logical_and( tf.less(prob_compare,self.one_minus_eps), tf.less(counter,self.N))) # only stop if all of the batch have passed either threshold # Do while loop iterations until predicate above is false. _,_,remainders,iterations,_,_,_,state = \ tf.while_loop(pred,self.inference_step, [batch_mask,prob_compare,prob, counter,initial_state,premise, hypothesis, acc_states]) return state, remainders, iterations
def __call__(self, inputs, state, timestep = 0, scope=None): with vs.variable_scope(scope or type(self).__name__): # define within cell constants/ counters used to control while loop for ACTStep prob = tf.constant(0.0,tf.float32,[self.batch_size], name="prob") prob_compare = tf.constant(0.0,tf.float32,[self.batch_size], name="prob_compare") counter = tf.constant(0.0, tf.float32,[self.batch_size], name="counter") acc_outputs = tf.zeros_like(state, tf.float32, name="output_accumulator") acc_states = tf.zeros_like(state, tf.float32, name="state_accumulator") batch_mask = tf.constant(True, tf.bool,[self.batch_size]) # While loop stops when this predicate is FALSE. # Ie all (probability < 1-eps AND counter < N) are false. #x = self.ACTStep(batch_mask,prob_compare,prob,counter,state,inputs,acc_outputs,acc_states) pred = lambda batch_mask,prob_compare,prob,\ counter,state,input,acc_output,acc_state:\ tf.reduce_any( tf.logical_and( tf.less(prob_compare,self.one_minus_eps), tf.less(counter,self.N))) # only stop if all of the batch have passed either threshold # Do while loop iterations until predicate above is false. _,_,remainders,iterations,_,_,output,next_state = \ control_flow_ops.while_loop(pred,self.ACTStep, [batch_mask,prob_compare,prob, counter,state,inputs, acc_outputs, acc_states]) #accumulate remainder and N values self.ACT_remainder.append(tf.reduce_mean(1 - remainders)) self.ACT_iterations.append(tf.reduce_mean(iterations)) return output, next_state
def retrieve_seq_length_op3(data, pad_val=0): # HangSheng: return tensor for sequence length, if input is tf.string data_shape_size = data.get_shape().ndims if data_shape_size == 3: return tf.reduce_sum(tf.cast(tf.reduce_any(tf.not_equal(data, pad_val), axis=2), dtype=tf.int32), 1) elif data_shape_size == 2: return tf.reduce_sum(tf.cast(tf.not_equal(data, pad_val), dtype=tf.int32), 1) elif data_shape_size == 1: raise ValueError("retrieve_seq_length_op3: data has wrong shape!") else: raise ValueError("retrieve_seq_length_op3: handling data_shape_size %s hasn't been implemented!" % (data_shape_size))
def target_mask_op(data, pad_val=0): # HangSheng: return tensor for mask,if input is tf.string data_shape_size = data.get_shape().ndims if data_shape_size == 3: return tf.cast(tf.reduce_any(tf.not_equal(data, pad_val), axis=2), dtype=tf.int32) elif data_shape_size == 2: return tf.cast(tf.not_equal(data, pad_val), dtype=tf.int32) elif data_shape_size == 1: raise ValueError("target_mask_op: data has wrong shape!") else: raise ValueError("target_mask_op: handling data_shape_size %s hasn't been implemented!" % (data_shape_size)) # Dynamic RNN
def sample_inference_model(self, source: tf.Tensor, length: tf.Tensor, samples=1, reuse: bool=False) -> tf.Tensor: x = tf.cast(source, tf.int32) logprops, labels = bytenet_sampling_translator( x, beam_size=samples, **self._parameters, name="bytenet-model", reuse=reuse ) # check if <eos> exists in each sequence # eos_found.shape = (batch, beam) eos_found = tf.reduce_any(tf.equal(labels, 1), axis=2) # set properbility to something very small if <eos> was not found # log(epsilon) = -1e9 log_eps = tf.constant(-1e9, dtype=logprops.dtype) logprops = tf.where(eos_found, logprops, tf.fill(tf.shape(logprops), log_eps)) # sort by logprops _, indices = tf.nn.top_k(logprops, k=samples, sorted=True) labels = batch_beam_gather(labels, indices) return tf.cast(labels, source.dtype)
def any(x, axis=None, keepdims=False): """Bitwise reduction (logical OR). # Arguments x: Tensor or variable. axis: axis along which to perform the reduction. keepdims: whether the drop or broadcast the reduction axes. # Returns A uint8 tensor (0s and 1s). """ axis = _normalize_axis(axis, ndim(x)) x = tf.cast(x, tf.bool) return tf.reduce_any(x, reduction_indices=axis, keep_dims=keepdims)
def __call__(self, inputs, state, scope=None): with vs.variable_scope(scope or type(self).__name__): # define within cell constants/ counters used to control while loop for ACTStep if self.state_is_tuple: state = array_ops.concat(1, state) self.batch_size = tf.shape(inputs)[0] self.one_minus_eps = tf.fill([self.batch_size], tf.constant(1.0 - self.epsilon, dtype=tf.float32)) prob = tf.fill([self.batch_size], tf.constant(0.0, dtype=tf.float32), "prob") counter = tf.zeros_like(prob, tf.float32, name="counter") acc_outputs = tf.fill([self.batch_size, self.output_size], 0.0, name='output_accumulator') acc_states = tf.zeros_like(state, tf.float32, name="state_accumulator") flag = tf.fill([self.batch_size], True, name="flag") pred = lambda flag, prob, counter, state, inputs, acc_outputs, acc_states: tf.reduce_any(flag) _, probs, iterations, _, _, output, next_state = control_flow_ops.while_loop(pred, self.act_step, loop_vars=[flag, prob, counter, state, inputs, acc_outputs, acc_states]) self.ACT_remainder.append(1 - probs) self.ACT_iterations.append(iterations) if self.state_is_tuple: next_c, next_h = array_ops.split(1, 2, next_state) next_state = rnn_cell._LSTMStateTuple(next_c, next_h) return output, next_state
def any(x, axis=None, keepdims=False): return tf.reduce_any(x, axis=axis, keep_dims=keepdims)
def test_Any(self): t = tf.reduce_any(self.random(3, 4, 5), reduction_indices=[0, 1], keep_dims=True) self.check(t) if td._tf_version[:3] >= (0, 12, 0): t = tf.reduce_any(self.random(3, 4, 5), axis=[0, 1], keep_dims=True) self.check(t) # # segmentation #
def prune_outside_window(boxlist, window, scope=None): """Prunes bounding boxes that fall outside a given window. This function prunes bounding boxes that even partially fall outside the given window. See also clip_to_window which only prunes bounding boxes that fall completely outside the window, and clips any bounding boxes that partially overflow. Args: boxlist: a BoxList holding M_in boxes. window: a float tensor of shape [4] representing [ymin, xmin, ymax, xmax] of the window scope: name scope. Returns: pruned_corners: a tensor with shape [M_out, 4] where M_out <= M_in valid_indices: a tensor with shape [M_out] indexing the valid bounding boxes in the input tensor. """ with tf.name_scope(scope, 'PruneOutsideWindow'): y_min, x_min, y_max, x_max = tf.split( value=boxlist.get(), num_or_size_splits=4, axis=1) win_y_min, win_x_min, win_y_max, win_x_max = tf.unstack(window) coordinate_violations = tf.concat([ tf.less(y_min, win_y_min), tf.less(x_min, win_x_min), tf.greater(y_max, win_y_max), tf.greater(x_max, win_x_max) ], 1) valid_indices = tf.reshape( tf.where(tf.logical_not(tf.reduce_any(coordinate_violations, 1))), [-1]) return gather(boxlist, valid_indices), valid_indices
def prune_completely_outside_window(boxlist, window, scope=None): """Prunes bounding boxes that fall completely outside of the given window. The function clip_to_window prunes bounding boxes that fall completely outside the window, but also clips any bounding boxes that partially overflow. This function does not clip partially overflowing boxes. Args: boxlist: a BoxList holding M_in boxes. window: a float tensor of shape [4] representing [ymin, xmin, ymax, xmax] of the window scope: name scope. Returns: pruned_corners: a tensor with shape [M_out, 4] where M_out <= M_in valid_indices: a tensor with shape [M_out] indexing the valid bounding boxes in the input tensor. """ with tf.name_scope(scope, 'PruneCompleteleyOutsideWindow'): y_min, x_min, y_max, x_max = tf.split( value=boxlist.get(), num_or_size_splits=4, axis=1) win_y_min, win_x_min, win_y_max, win_x_max = tf.unstack(window) coordinate_violations = tf.concat([ tf.greater_equal(y_min, win_y_max), tf.greater_equal(x_min, win_x_max), tf.less_equal(y_max, win_y_min), tf.less_equal(x_max, win_x_min) ], 1) valid_indices = tf.reshape( tf.where(tf.logical_not(tf.reduce_any(coordinate_violations, 1))), [-1]) return gather(boxlist, valid_indices), valid_indices
def any(x, axis=None, keepdims=False): '''Bitwise reduction (logical OR). Return array of uint8 (0s and 1s). ''' axis = normalize_axis(axis, ndim(x)) x = tf.cast(x, tf.bool) x = tf.reduce_any(x, reduction_indices=axis, keep_dims=keepdims) return tf.cast(x, tf.uint8)
def kMeans(iterations, labelledSet, columnPrefix="cluster"): X = labelledSet.as_matrix() start_pos = tf.Variable(X[np.random.randint(X.shape[0], size=iterations),:], dtype=tf.float32) centroids = tf.Variable(start_pos.initialized_value(), "S", dtype=tf.float32) points = tf.Variable(X, 'X', dtype=tf.float32) ones_like = tf.ones((points.get_shape()[0], 1)) prev_assignments = tf.Variable(tf.zeros((points.get_shape()[0], ), dtype=tf.int64)) p1 = tf.matmul( tf.expand_dims(tf.reduce_sum(tf.square(points), 1), 1), tf.ones(shape=(1, iterations)) ) p2 = tf.transpose(tf.matmul( tf.reshape(tf.reduce_sum(tf.square(centroids), 1), shape=[-1, 1]), ones_like, transpose_b=True )) distance = tf.sqrt(tf.add(p1, p2) - 2 * tf.matmul(points, centroids, transpose_b=True)) point_to_centroid_assignment = tf.argmin(distance, axis=1) total = tf.unsorted_segment_sum(points, point_to_centroid_assignment, iterations) count = tf.unsorted_segment_sum(ones_like, point_to_centroid_assignment, iterations) means = total / count is_continue = tf.reduce_any(tf.not_equal(point_to_centroid_assignment, prev_assignments)) with tf.control_dependencies([is_continue]): loop = tf.group(centroids.assign(means), prev_assignments.assign(point_to_centroid_assignment)) sess = tf.Session() sess.run(tf.global_variables_initializer()) has_changed, cnt = True, 0 while has_changed and cnt < 300: cnt += 1 has_changed, _ = sess.run([is_continue, loop]) res = sess.run(point_to_centroid_assignment) return pandas.DataFrame(res, columns=[columnPrefix + "_" + str(iterations)])
def split_proposals(proposals, proposals_num, gt, gt_num, iou, scores, cross_boundary_mask): '''Generate batches from proposals and ground truth boxes Idea is to drastically reduce number of proposals to evaluate. So, we find those proposals that have IoU > 0.7 with _any_ ground truth and mark them as positive samples. Proposals with IoU < 0.3 with _all_ ground truth boxes are considered negative. All other proposals are discarded. We generate batch with at most half of examples being positive. We also pad them with negative have we not enough positive proposals. proposals: N x 4 tensor proposal_num: N gt: M x 4 tensor gt_num: M iou: N x M tensor of IoU between every proposal and ground truth scores: N x 2 tensor with scores object/not-object cross_boundary_mask: N x 1 Tensor masking out-of-image proposals ''' # now let's get rid of non-positive and non-negative samples # Sample is considered positive if it has IoU > 0.7 with _any_ ground truth box # XXX: maximal IoU ground truth proposal should be treated as positive positive_mask = tf.reduce_any(tf.greater(iou, 0.7), axis=1) & cross_boundary_mask # Sample would be considered negative if _all_ ground truch box # have iou less than 0.3 negative_mask = tf.reduce_all(tf.less(iou, 0.3), axis=1) & cross_boundary_mask # Select only positive boxes and their corresponding predicted scores positive_boxes = tf.boolean_mask(proposals, positive_mask) positive_scores = tf.boolean_mask(scores, positive_mask) positive_labels = tf.reduce_mean(tf.ones_like(positive_scores), axis=1) # Same for negative negative_boxes = tf.boolean_mask(proposals, negative_mask) negative_scores = tf.boolean_mask(scores, negative_mask) negative_labels = tf.reduce_mean(tf.zeros_like(negative_scores), axis=1) return ( (positive_boxes, positive_scores, positive_labels), (negative_boxes, negative_scores, negative_labels) )
def merge(tensors_list, mode, axis=1, name='merge', outputs_collections=None, **kwargs): """ Merge op Args: tensor_list: A list `Tensors` to merge mode: str, available modes are ['concat', 'elemwise_sum', 'elemwise_mul', 'sum', 'mean', 'prod', 'max', 'min', 'and', 'or'] name: a optional scope/name of the layer outputs_collections: The collections to which the outputs are added. Returns: A `Tensor` representing the results of the repetition operation. Raises: ValueError: If 'kernel_size' is not a 2-D list """ assert len(tensors_list) > 1, "Merge required 2 or more tensors." with tf.name_scope(name): tensors = [l for l in tensors_list] if mode == 'concat': output = tf.concat(tensors, axis=axis) elif mode == 'elemwise_sum': output = tensors[0] for i in range(1, len(tensors)): output = tf.add(output, tensors[i]) elif mode == 'elemwise_mul': output = tensors[0] for i in range(1, len(tensors)): output = tf.multiply(output, tensors[i]) elif mode == 'sum': output = tf.reduce_sum(tf.concat(tensors, axis=axis), axis=axis) elif mode == 'mean': output = tf.reduce_mean(tf.concat(tensors, axis=axis), axis=axis) elif mode == 'prod': output = tf.reduce_prod(tf.concat(tensors, axis=axis), axis=axis) elif mode == 'max': output = tf.reduce_max(tf.concat(tensors, axis=axis), axis=axis) elif mode == 'min': output = tf.reduce_min(tf.concat(tensors, axis=axis), axis=axis) elif mode == 'and': output = tf.reduce_all(tf.concat(tensors, axis=axis), axis=axis) elif mode == 'or': output = tf.reduce_any(tf.concat(tensors, axis=axis), axis=axis) else: raise Exception("Unknown merge mode", str(mode)) return _collect_named_outputs(outputs_collections, name, output) return output
def inference_step(self,batch_mask, prob_compare,prob,counter, state, premise, hypothesis, acc_states): if self.config.keep_prob < 1.0 and self.is_training: premise = tf.nn.dropout(premise, self.config.keep_prob) hypothesis = tf.nn.dropout(hypothesis,self.config.keep_prob) hyp_attn = self.attention(state, hypothesis, "hyp_attn") state_for_premise = tf.concat(1, [state, hyp_attn]) prem_attn = self.attention(state_for_premise, premise, "prem_attn") new_state = tf.concat(1, [hyp_attn ,prem_attn]) with tf.variable_scope('sigmoid_activation_for_pondering'): p = tf.squeeze(tf.sigmoid(tf.nn.rnn_cell._linear(new_state, 1, True))) new_batch_mask = tf.logical_and(tf.less(prob + p,self.one_minus_eps),batch_mask) new_float_mask = tf.cast(new_batch_mask, tf.float32) prob += p * new_float_mask prob_compare += p * tf.cast(batch_mask, tf.float32) def use_remainder(): remainder = tf.constant(1.0, tf.float32,[self.batch_size]) - prob remainder_expanded = tf.expand_dims(remainder,1) tiled_remainder = tf.tile(remainder_expanded,[1,2*self.rep_size]) acc_state = (new_state * tiled_remainder) + acc_states return acc_state def normal(): p_expanded = tf.expand_dims(p * new_float_mask,1) tiled_p = tf.tile(p_expanded,[1,2*self.rep_size]) acc_state = (new_state * tiled_p) + acc_states return acc_state counter += tf.constant(1.0,tf.float32,[self.batch_size]) * new_float_mask counter_condition = tf.less(counter,self.N) condition = tf.reduce_any(tf.logical_and(new_batch_mask,counter_condition)) acc_state = tf.cond(condition, normal, use_remainder) return (new_batch_mask, prob_compare,prob,counter, new_state, premise, hypothesis, acc_state)
def inference_step(self,batch_mask, prob_compare,prob,counter, state, premise, hypothesis, acc_states): if self.config.keep_prob < 1.0 and self.is_training: premise = tf.nn.dropout(premise, self.config.keep_prob) hypothesis = tf.nn.dropout(hypothesis,self.config.keep_prob) hyp_attn = self.attention(state, hypothesis, "hyp_attn") state_for_premise = tf.concat(1, [state, hyp_attn]) prem_attn = self.attention(state_for_premise, premise, "prem_attn") state_for_gates = tf.concat(1, [state, hyp_attn ,prem_attn, prem_attn * hyp_attn]) hyp_gate = self.gate_mechanism(state_for_gates, "hyp_gate") prem_gate = self.gate_mechanism(state_for_gates, "prem_gate") input = tf.concat(1, [hyp_gate * hyp_attn, prem_gate * prem_attn]) output, new_state = self.inference_cell(input,state) with tf.variable_scope('sigmoid_activation_for_pondering'): p = tf.squeeze(tf.sigmoid(tf.nn.rnn_cell._linear(new_state, 1, True))) new_batch_mask = tf.logical_and(tf.less(prob + p,self.one_minus_eps),batch_mask) new_float_mask = tf.cast(new_batch_mask, tf.float32) prob += p * new_float_mask prob_compare += p * tf.cast(batch_mask, tf.float32) def use_remainder(): remainder = tf.constant(1.0, tf.float32,[self.batch_size]) - prob remainder_expanded = tf.expand_dims(remainder,1) tiled_remainder = tf.tile(remainder_expanded,[1,self.config.inference_size]) acc_state = (new_state * tiled_remainder) + acc_states return acc_state def normal(): p_expanded = tf.expand_dims(p * new_float_mask,1) tiled_p = tf.tile(p_expanded,[1,self.config.inference_size]) acc_state = (new_state * tiled_p) + acc_states return acc_state counter += tf.constant(1.0,tf.float32,[self.batch_size]) * new_float_mask counter_condition = tf.less(counter,self.N) condition = tf.reduce_any(tf.logical_and(new_batch_mask,counter_condition)) acc_state = tf.cond(condition, normal, use_remainder) return (new_batch_mask, prob_compare,prob,counter, new_state, premise, hypothesis, acc_state)
def do_inference_steps(self, initial_state, premise, hypothesis): self.one_minus_eps = tf.constant(1.0 - self.config.eps, tf.float32,[self.batch_size]) self.N = tf.constant(self.config.max_computation, tf.float32,[self.batch_size]) prob = tf.constant(0.0,tf.float32,[self.batch_size], name="prob") prob_compare = tf.constant(0.0,tf.float32,[self.batch_size], name="prob_compare") counter = tf.constant(0.0, tf.float32,[self.batch_size], name="counter") i = tf.constant(0, tf.int32, name="index") acc_states = tf.zeros_like(initial_state, tf.float32, name="state_accumulator") batch_mask = tf.constant(True, tf.bool,[self.batch_size]) # Tensor arrays to collect information about the run: array_probs = tf.TensorArray(tf.float32,0, dynamic_size=True) premise_attention = tf.TensorArray(tf.float32,0, dynamic_size=True) hypothesis_attention = tf.TensorArray(tf.float32,0, dynamic_size=True) incremental_states = tf.TensorArray(tf.float32,0, dynamic_size=True) # While loop stops when this predicate is FALSE. # Ie all (probability < 1-eps AND counter < N) are false. pred = lambda i ,incremental_states, array_probs, premise_attention, hypothesis_attention, batch_mask,prob_compare,prob,\ counter,state,premise, hypothesis ,acc_state:\ tf.reduce_any( tf.logical_and( tf.less(prob_compare,self.one_minus_eps), tf.less(counter,self.N))) # only stop if all of the batch have passed either threshold # Do while loop iterations until predicate above is false. i,incremental_states, array_probs,premise_attention,hypothesis_attention,_,_,remainders,iterations,_,_,_,state = \ tf.while_loop(pred,self.inference_step, [i,incremental_states, array_probs, premise_attention, hypothesis_attention, batch_mask,prob_compare,prob, counter,initial_state,premise, hypothesis, acc_states]) self.ACTPROB = array_probs.pack() self.ACTPREMISEATTN = premise_attention.pack() self.ACTHYPOTHESISATTN = hypothesis_attention.pack() self.incremental_states = incremental_states.pack() return state, remainders, iterations
def do_inference_steps(self, initial_state, premise, hypothesis): self.one_minus_eps = tf.constant(1.0 - self.config.eps, tf.float32,[self.batch_size]) self.N = tf.constant(self.config.max_computation, tf.float32,[self.batch_size]) prob = tf.constant(0.0,tf.float32,[self.batch_size], name="prob") prob_compare = tf.constant(0.0,tf.float32,[self.batch_size], name="prob_compare") counter = tf.constant(0.0, tf.float32,[self.batch_size], name="counter") i = tf.constant(0, tf.int32, name="index") acc_states = tf.zeros_like(initial_state, tf.float32, name="state_accumulator") batch_mask = tf.constant(True, tf.bool,[self.batch_size]) # Tensor arrays to collect information about the run: array_probs = tf.TensorArray(tf.float32,0, dynamic_size=True) premise_attention = tf.TensorArray(tf.float32,0, dynamic_size=True) hypothesis_attention = tf.TensorArray(tf.float32,0, dynamic_size=True) # While loop stops when this predicate is FALSE. # Ie all (probability < 1-eps AND counter < N) are false. pred = lambda i ,array_probs, premise_attention, hypothesis_attention, batch_mask,prob_compare,prob,\ counter,state,premise, hypothesis ,acc_state:\ tf.reduce_any( tf.logical_and( tf.less(prob_compare,self.one_minus_eps), tf.less(counter,self.N))) # only stop if all of the batch have passed either threshold # Do while loop iterations until predicate above is false. i,array_probs,premise_attention,hypothesis_attention,_,_,remainders,iterations,_,_,_,state = \ tf.while_loop(pred,self.inference_step, [i,array_probs, premise_attention, hypothesis_attention, batch_mask,prob_compare,prob, counter,initial_state,premise, hypothesis, acc_states]) self.ACTPROB = array_probs.pack() self.ACTPREMISEATTN = premise_attention.pack() self.ACTHYPOTHESISATTN = hypothesis_attention.pack() return state, remainders, iterations
def do_act_steps(self, premise, hypothesis): self.rep_size = premise.get_shape()[-1].value self.one_minus_eps = tf.constant(1.0 - self.config.eps, tf.float32,[self.batch_size]) self.N = tf.constant(self.config.max_computation, tf.float32,[self.batch_size]) prob = tf.constant(0.0,tf.float32,[self.batch_size], name="prob") prob_compare = tf.constant(0.0,tf.float32,[self.batch_size], name="prob_compare") counter = tf.constant(0.0, tf.float32,[self.batch_size], name="counter") initial_state = tf.zeros([self.batch_size, 2*self.rep_size], tf.float32, name="state") i = tf.constant(0, tf.int32, name="index") acc_states = tf.zeros_like(initial_state, tf.float32, name="state_accumulator") batch_mask = tf.constant(True, tf.bool,[self.batch_size]) # Tensor arrays to collect information about the run: array_probs = tf.TensorArray(tf.float32,0, dynamic_size=True) premise_attention = tf.TensorArray(tf.float32,0, dynamic_size=True) hypothesis_attention = tf.TensorArray(tf.float32,0, dynamic_size=True) # While loop stops when this predicate is FALSE. # Ie all (probability < 1-eps AND counter < N) are false. pred = lambda i ,array_probs, premise_attention, hypothesis_attention, batch_mask,prob_compare,prob,\ counter,state,premise, hypothesis ,acc_state:\ tf.reduce_any( tf.logical_and( tf.less(prob_compare,self.one_minus_eps), tf.less(counter,self.N))) # only stop if all of the batch have passed either threshold # Do while loop iterations until predicate above is false. i,array_probs,premise_attention,hypothesis_attention,_,_,remainders,iterations,_,_,_,state = \ tf.while_loop(pred,self.inference_step, [i,array_probs, premise_attention, hypothesis_attention, batch_mask,prob_compare,prob, counter,initial_state,premise, hypothesis, acc_states]) self.ACTPROB = array_probs.pack() self.ACTPREMISEATTN = premise_attention.pack() self.ACTHYPOTHESISATTN = hypothesis_attention.pack() return state, remainders, iterations
def decode(self, enc_outputs, enc_final_state): with tf.variable_scope(self.decoder.scope): def condition(time, all_outputs: tf.TensorArray, inputs, states): def check_outputs_ends(): def has_end_word(t): return tf.reduce_any(tf.equal(t, ANSWER_MAX)) output_label = tf.arg_max(all_outputs.stack(), 2) output_label = tf.Print(output_label, [output_label], "Output Labels: ") # The outputs are time-major, which means time is the first # dimension. Here I need to check whether all the generated # answers are ends with "</s>", so we need to transpose it # to batch-major. Because `map_fn` only map function by the # first dimension. batch_major_outputs = tf.transpose(output_label, (1, 0)) all_outputs_ends = tf.reduce_all(tf.map_fn(has_end_word, batch_major_outputs, dtype=tf.bool)) return all_outputs_ends # If the TensorArray has 0 size, stack() will trigger error, # so I have to use condition function to check whether the # size is 0. all_ends = tf.cond(tf.equal(all_outputs.size(), 0), lambda: tf.constant(False, tf.bool), check_outputs_ends) condition_result = tf.logical_and(tf.logical_not(all_ends), tf.less(time, ANSWER_MAX)) return condition_result def body(time, all_outputs, inputs, state): dec_outputs, dec_state, output_logits, next_input = self.decoder.step(inputs, state) all_outputs = all_outputs.write(time, output_logits) return time + 1, all_outputs, next_input, dec_state output_ta = tensor_array_ops.TensorArray(dtype=tf.float32, size=0, dynamic_size=True, element_shape=(None, config.DEC_VOCAB), clear_after_read=False) # with time-major data input, the batch size is the second dimension batch_size = tf.shape(enc_outputs)[1] zero_input = tf.ones(tf.expand_dims(batch_size, axis=0), dtype=tf.int32) * ANSWER_START res = control_flow_ops.while_loop( condition, body, loop_vars=[0, output_ta, self.decoder.zero_input(zero_input), enc_final_state], ) final_outputs = res[1].stack() final_outputs = tf.Print(final_outputs, [final_outputs], "Final Output: ") final_state = res[3] return final_outputs, final_state
