Python tensorflow.compat.v1.cumsum() Examples
The following are 23
code examples of tensorflow.compat.v1.cumsum().
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.compat.v1
, or try the search function
.
Example #1
Source File: preprocessors.py From text-to-text-transfer-transformer with Apache License 2.0 | 6 votes |
def permute_noise_tokens(tokens, noise_mask, unused_vocabulary): """Permute the noise tokens, keeping the non-noise tokens where they are. Args: tokens: a 1d integer Tensor noise_mask: a boolean Tensor with the same shape as tokens unused_vocabulary: a vocabulary.Vocabulary Returns: a Tensor with the same shape and dtype as tokens """ masked_only = tf.boolean_mask(tokens, noise_mask) permuted = tf.random.shuffle(masked_only) # pad to avoid errors when it has size 0 permuted = tf.pad(permuted, [[0, 1]]) indices = tf.cumsum(tf.cast(noise_mask, tf.int32), exclusive=True) return tf.where_v2(noise_mask, tf.gather(permuted, indices), tokens)
Example #2
Source File: generator_utils.py From tensor2tensor with Apache License 2.0 | 6 votes |
def _compute_auxiliary_structure(self, contents_and_mask): """Compute segment and position metadata.""" contents = contents_and_mask[:, :self._num_sequences] start_mask = tf.cast(contents_and_mask[:, self._num_sequences:], dtype=INDEX_DTYPE) segment = tf.cumsum(start_mask, axis=0) uniform_count = tf.ones_like(segment[:, 0]) position = [] for i in range(self._num_sequences): segment_slice = segment[:, i] counts = tf.math.segment_sum(uniform_count, segment[:, i]) position.append(tf.range(self._packed_length) - tf.cumsum( tf.gather(counts, segment_slice - 1) * start_mask[:, i])) position = tf.concat([i[:, tf.newaxis] for i in position], axis=1) # Correct for padding tokens. pad_mask = tf.cast(tf.not_equal(contents, 0), dtype=INDEX_DTYPE) segment *= pad_mask position *= pad_mask return segment, position
Example #3
Source File: spectral_ops.py From magenta with Apache License 2.0 | 6 votes |
def unwrap(p, discont=np.pi, axis=-1): """Unwrap a cyclical phase tensor. Args: p: Phase tensor. discont: Float, size of the cyclic discontinuity. axis: Axis of which to unwrap. Returns: unwrapped: Unwrapped tensor of same size as input. """ dd = diff(p, axis=axis) ddmod = tf.mod(dd + np.pi, 2.0 * np.pi) - np.pi idx = tf.logical_and(tf.equal(ddmod, -np.pi), tf.greater(dd, 0)) ddmod = tf.where(idx, tf.ones_like(ddmod) * np.pi, ddmod) ph_correct = ddmod - dd idx = tf.less(tf.abs(dd), discont) ddmod = tf.where(idx, tf.zeros_like(ddmod), dd) ph_cumsum = tf.cumsum(ph_correct, axis=axis) shape = p.get_shape().as_list() shape[axis] = 1 ph_cumsum = tf.concat([tf.zeros(shape, dtype=p.dtype), ph_cumsum], axis=axis) unwrapped = p + ph_cumsum return unwrapped
Example #4
Source File: specgrams_helper.py From magenta with Apache License 2.0 | 6 votes |
def specgrams_to_stfts(self, specgrams): """Converts specgrams to stfts. Args: specgrams: Tensor of log magnitudes and instantaneous frequencies, shape [batch, time, freq, 2]. Returns: stfts: Complex64 tensor of stft, shape [batch, time, freq, 1]. """ logmag = specgrams[:, :, :, 0] p = specgrams[:, :, :, 1] mag = tf.exp(logmag) if self._ifreq: phase_angle = tf.cumsum(p * np.pi, axis=-2) else: phase_angle = p * np.pi return spectral_ops.polar2rect(mag, phase_angle)[:, :, :, tf.newaxis]
Example #5
Source File: attention.py From language with Apache License 2.0 | 6 votes |
def safe_cumprod(x, *args, **kwargs): """Computes cumprod of x in logspace using cumsum to avoid underflow. The cumprod function and its gradient can result in numerical instabilities when its argument has very small and/or zero values. As long as the argument is all positive, we can instead compute the cumulative product as exp(cumsum(log(x))). This function can be called identically to tf.cumprod. Args: x: Tensor to take the cumulative product of. *args: Passed on to cumsum; these are identical to those in cumprod. **kwargs: Passed on to cumsum; these are identical to those in cumprod. Returns: Cumulative product of x. """ with tf.name_scope(None, "SafeCumprod", [x]): x = tf.convert_to_tensor(x, name="x") tiny = np.finfo(x.dtype.as_numpy_dtype).tiny return tf.exp( tf.cumsum(tf.log(tf.clip_by_value(x, tiny, 1)), *args, **kwargs))
Example #6
Source File: ppo.py From tensor2tensor with Apache License 2.0 | 6 votes |
def _distributional_to_value(value_d, size, subscale, threshold): """Get a scalar value out of a value distribution in distributional RL.""" half = size // 2 value_range = (tf.to_float(tf.range(-half, half)) + 0.5) * subscale probs = tf.nn.softmax(value_d) if threshold == 0.0: return tf.reduce_sum(probs * value_range, axis=-1) # accumulated_probs[..., i] is the sum of probabilities in buckets upto i # so it is the probability that value <= i'th bucket value accumulated_probs = tf.cumsum(probs, axis=-1) # New probs are 0 on all lower buckets, until the threshold probs = tf.where(accumulated_probs < threshold, tf.zeros_like(probs), probs) probs /= tf.reduce_sum(probs, axis=-1, keepdims=True) # Re-normalize. return tf.reduce_sum(probs * value_range, axis=-1)
Example #7
Source File: utils.py From mesh with Apache License 2.0 | 6 votes |
def clean_decodes(ids, eos_id=1, pad_id=0, length_axis=-1): """Replaces everything after EOS with PAD (along last axis). Args: ids: a d Tensor of type int. eos_id: int, EOS id. pad_id: int, PAD id. length_axis: an integer. Returns: a Tensor of type int of ids. """ eos_and_after = tf.cumsum(tf.cast(tf.equal(ids, eos_id), tf.int32), exclusive=True, axis=length_axis) valid_ids = tf.equal(eos_and_after, 0) return tf.where_v2(valid_ids, ids, pad_id)
Example #8
Source File: specgrams_helper.py From magenta with Apache License 2.0 | 5 votes |
def melspecgrams_to_specgrams(self, melspecgrams): """Converts melspecgrams to specgrams. Args: melspecgrams: Tensor of log magnitudes and instantaneous frequencies, shape [batch, time, freq, 2], mel scaling of frequencies. Returns: specgrams: Tensor of log magnitudes and instantaneous frequencies, shape [batch, time, freq, 2]. """ if self._mel_downscale is None: return melspecgrams logmelmag2 = melspecgrams[:, :, :, 0] mel_p = melspecgrams[:, :, :, 1] mel2l = tf.to_float(self._mel_to_linear_matrix()) mag2 = tf.tensordot(tf.exp(logmelmag2), mel2l, 1) logmag = 0.5 * self._safe_log(mag2) mel_phase_angle = tf.cumsum(mel_p * np.pi, axis=-2) phase_angle = tf.tensordot(mel_phase_angle, mel2l, 1) p = spectral_ops.instantaneous_frequency(phase_angle) return tf.concat( [logmag[:, :, :, tf.newaxis], p[:, :, :, tf.newaxis]], axis=-1)
Example #9
Source File: balanced_positive_negative_sampler.py From models with Apache License 2.0 | 5 votes |
def _get_values_from_start_and_end(self, input_tensor, num_start_samples, num_end_samples, total_num_samples): """slices num_start_samples and last num_end_samples from input_tensor. Args: input_tensor: An int32 tensor of shape [N] to be sliced. num_start_samples: Number of examples to be sliced from the beginning of the input tensor. num_end_samples: Number of examples to be sliced from the end of the input tensor. total_num_samples: Sum of is num_start_samples and num_end_samples. This should be a scalar. Returns: A tensor containing the first num_start_samples and last num_end_samples from input_tensor. """ input_length = tf.shape(input_tensor)[0] start_positions = tf.less(tf.range(input_length), num_start_samples) end_positions = tf.greater_equal( tf.range(input_length), input_length - num_end_samples) selected_positions = tf.logical_or(start_positions, end_positions) selected_positions = tf.cast(selected_positions, tf.float32) indexed_positions = tf.multiply(tf.cumsum(selected_positions), selected_positions) one_hot_selector = tf.one_hot(tf.cast(indexed_positions, tf.int32) - 1, total_num_samples, dtype=tf.float32) return tf.cast(tf.tensordot(tf.cast(input_tensor, tf.float32), one_hot_selector, axes=[0, 0]), tf.int32)
Example #10
Source File: autoaugment_utils.py From models with Apache License 2.0 | 5 votes |
def equalize(image): """Implements Equalize function from PIL using TF ops.""" def scale_channel(im, c): """Scale the data in the channel to implement equalize.""" im = tf.cast(im[:, :, c], tf.int32) # Compute the histogram of the image channel. histo = tf.histogram_fixed_width(im, [0, 255], nbins=256) # For the purposes of computing the step, filter out the nonzeros. nonzero = tf.where(tf.not_equal(histo, 0)) nonzero_histo = tf.reshape(tf.gather(histo, nonzero), [-1]) step = (tf.reduce_sum(nonzero_histo) - nonzero_histo[-1]) // 255 def build_lut(histo, step): # Compute the cumulative sum, shifting by step // 2 # and then normalization by step. lut = (tf.cumsum(histo) + (step // 2)) // step # Shift lut, prepending with 0. lut = tf.concat([[0], lut[:-1]], 0) # Clip the counts to be in range. This is done # in the C code for image.point. return tf.clip_by_value(lut, 0, 255) # If step is zero, return the original image. Otherwise, build # lut from the full histogram and step and then index from it. result = tf.cond(tf.equal(step, 0), lambda: im, lambda: tf.gather(build_lut(histo, step), im)) return tf.cast(result, tf.uint8) # Assumes RGB for now. Scales each channel independently # and then stacks the result. s1 = scale_channel(image, 0) s2 = scale_channel(image, 1) s3 = scale_channel(image, 2) image = tf.stack([s1, s2, s3], 2) return image
Example #11
Source File: autoaugment_utils.py From models with Apache License 2.0 | 5 votes |
def autocontrast(image): """Implements Autocontrast function from PIL using TF ops. Args: image: A 3D uint8 tensor. Returns: The image after it has had autocontrast applied to it and will be of type uint8. """ def scale_channel(image): """Scale the 2D image using the autocontrast rule.""" # A possibly cheaper version can be done using cumsum/unique_with_counts # over the histogram values, rather than iterating over the entire image. # to compute mins and maxes. lo = tf.to_float(tf.reduce_min(image)) hi = tf.to_float(tf.reduce_max(image)) # Scale the image, making the lowest value 0 and the highest value 255. def scale_values(im): scale = 255.0 / (hi - lo) offset = -lo * scale im = tf.to_float(im) * scale + offset im = tf.clip_by_value(im, 0.0, 255.0) return tf.cast(im, tf.uint8) result = tf.cond(hi > lo, lambda: scale_values(image), lambda: image) return result # Assumes RGB for now. Scales each channel independently # and then stacks the result. s1 = scale_channel(image[:, :, 0]) s2 = scale_channel(image[:, :, 1]) s3 = scale_channel(image[:, :, 2]) image = tf.stack([s1, s2, s3], 2) return image
Example #12
Source File: range_coding_ops_test.py From compression with Apache License 2.0 | 5 votes |
def test_readme_example(self): data = tf.random.uniform((128, 128), 0, 10, dtype=tf.int32) histogram = tf.bincount(data, minlength=10, maxlength=10) cdf = tf.cumsum(histogram, exclusive=False) cdf = tf.pad(cdf, [[1, 0]]) cdf = tf.reshape(cdf, [1, 1, -1]) data = tf.cast(data, tf.int16) encoded = range_coding_ops.range_encode(data, cdf, precision=14) decoded = range_coding_ops.range_decode( encoded, tf.shape(data), cdf, precision=14) with self.cached_session() as sess: self.assertAllEqual(*sess.run((data, decoded)))
Example #13
Source File: preprocessors.py From text-to-text-transfer-transformer with Apache License 2.0 | 5 votes |
def noise_span_to_unique_sentinel(tokens, noise_mask, vocabulary): """Replace each run of consecutive noise tokens with a different sentinel. The idea here is to be able to align the dropped spans in the inputs with the markers in the targets. We want to generate training examples like "We hold X to be Y that" -> "X these truths Y self evident Z" Sentinels assigned in decreasing order within the sequence starting at vocabulary.size - 1. That is, we appropriate the last tokens in the vocabulary for additional use as sentinels. TODO(noam): we may want to try enlarging the vocabulary and leaving room for the sentinels instead. However, this requires enlarging the embedding tables in the model, so that is a bigger change. Args: tokens: a 1d integer Tensor noise_mask: a boolean Tensor with the same shape as tokens vocabulary: a vocabulary.Vocabulary Returns: a Tensor with the same shape and dtype as tokens """ vocab_size = vocabulary.vocab_size prev_token_is_noise = tf.pad(noise_mask[:-1], [[1, 0]]) first_noise_tokens = tf.logical_and( noise_mask, tf.logical_not(prev_token_is_noise)) subsequent_noise_tokens = tf.logical_and(noise_mask, prev_token_is_noise) sentinel = vocab_size - tf.cumsum(tf.cast(first_noise_tokens, tokens.dtype)) tokens = tf.where_v2(first_noise_tokens, sentinel, tokens) return tf.boolean_mask(tokens, tf.logical_not(subsequent_noise_tokens))
Example #14
Source File: specgrams_helper.py From magenta with Apache License 2.0 | 5 votes |
def specgrams_to_melspecgrams(self, specgrams): """Converts specgrams to melspecgrams. Args: specgrams: Tensor of log magnitudes and instantaneous frequencies, shape [batch, time, freq, 2]. Returns: melspecgrams: Tensor of log magnitudes and instantaneous frequencies, shape [batch, time, freq, 2], mel scaling of frequencies. """ if self._mel_downscale is None: return specgrams logmag = specgrams[:, :, :, 0] p = specgrams[:, :, :, 1] mag2 = tf.exp(2.0 * logmag) phase_angle = tf.cumsum(p * np.pi, axis=-2) l2mel = tf.to_float(self._linear_to_mel_matrix()) logmelmag2 = self._safe_log(tf.tensordot(mag2, l2mel, 1)) mel_phase_angle = tf.tensordot(phase_angle, l2mel, 1) mel_p = spectral_ops.instantaneous_frequency(mel_phase_angle) return tf.concat( [logmelmag2[:, :, :, tf.newaxis], mel_p[:, :, :, tf.newaxis]], axis=-1)
Example #15
Source File: common_layers.py From tensor2tensor with Apache License 2.0 | 5 votes |
def weights_concatenated(labels): """Assign weight 1.0 to the "target" part of the concatenated labels. The labels look like: source English I love you . ID1 target French Je t'aime . ID1 source English the cat ID1 target French le chat ID1 source English ... We want to assign weight 1.0 to all words in the target text (including the ID1 end symbol), but not to the source text or the boilerplate. In the above example, the target words that get positive weight are: Je t'aime . ID1 le chat ID1 Args: labels: a Tensor Returns: a Tensor """ eos_mask = tf.to_int32(tf.equal(labels, 1)) sentence_num = tf.cumsum(eos_mask, axis=1, exclusive=True) in_target = tf.equal(tf.mod(sentence_num, 2), 1) # first two tokens of each sentence are boilerplate. sentence_num_plus_one = sentence_num + 1 shifted = tf.pad(sentence_num_plus_one, [[0, 0], [2, 0], [0, 0], [0, 0]])[:, :-2, :, :] nonboilerplate = tf.equal(sentence_num_plus_one, shifted) ret = to_float(tf.logical_and(nonboilerplate, in_target)) return ret
Example #16
Source File: common_layers.py From tensor2tensor with Apache License 2.0 | 5 votes |
def weights_multi_problem_all(labels, taskid=-1): """Assign weight 1.0 to only examples from the given task.""" taskid = check_nonnegative(taskid) weights = to_float(tf.not_equal(labels, 0)) 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) example_mask = to_float(tf.not_equal(past_taskid * non_taskid, 0)) example_mask = tf.reduce_sum(example_mask, axis=1) example_mask = to_float( tf.greater(example_mask, tf.zeros_like(example_mask))) return weights * tf.expand_dims(example_mask, axis=-1)
Example #17
Source File: common_layers.py From tensor2tensor with Apache License 2.0 | 5 votes |
def weights_prepend_inputs_to_targets(labels): """Assign weight 1.0 to only the "targets" portion of the labels. Weight 1.0 is assigned to all nonzero labels past the first zero. See prepend_mode in common_hparams.py Args: labels: A Tensor of int32s. Returns: A Tensor of floats. """ past_first_zero = tf.cumsum(to_float(tf.equal(labels, 0)), axis=1) nonzero = to_float(labels) return to_float(tf.not_equal(past_first_zero * nonzero, 0))
Example #18
Source File: common_layers.py From tensor2tensor with Apache License 2.0 | 5 votes |
def cumsum(x, axis=0, exclusive=False): """TPU hack for tf.cumsum. This is equivalent to tf.cumsum and is faster on TPU as of 04/2018 unless the axis dimension is very large. Args: x: a Tensor axis: an integer exclusive: a boolean Returns: Tensor of the same shape as x. """ if not is_xla_compiled(): return tf.cumsum(x, axis=axis, exclusive=exclusive) x_shape = shape_list(x) rank = len(x_shape) length = x_shape[axis] my_range = tf.range(length) comparator = tf.less if exclusive else tf.less_equal mask = tf.cast( comparator(tf.expand_dims(my_range, 1), tf.expand_dims(my_range, 0)), x.dtype) ret = tf.tensordot(x, mask, axes=[[axis], [0]]) if axis != rank - 1: ret = tf.transpose( ret, list(range(axis)) + [rank - 1] + list(range(axis, rank - 1))) return ret
Example #19
Source File: common_layers.py From tensor2tensor with Apache License 2.0 | 5 votes |
def gather(params, indices, dtype=tf.float32): """Version of tf.gather that works faster on tpu.""" if not is_xla_compiled(): return tf.gather(params, indices) vocab_size = params.get_shape().as_list()[0] indices_flat = tf.reshape(indices, [-1]) out = tf.matmul(tf.one_hot(indices_flat, vocab_size, dtype=dtype), params) out = reshape_like(out, tf.expand_dims(indices, -1)) return out # TODO(noam): remove this function after TPUs do cumsum faster.
Example #20
Source File: preprocess.py From language with Apache License 2.0 | 4 votes |
def truncate_segment_tokens(segment_tokens, max_tokens): """Truncates segment tokens. Suppose we arrange our segment tokens in a matrix, e.g.: this is query one <pad> <-- first segment this is query two <pad> <-- second segment more text <pad> <pad> <pad> <-- third segment If we visit the tokens in column-major order, we get this ordering: 1 4 7 9 2 5 8 10 3 6 This function removes all tokens with visit index > max_tokens. This function generalizes language.bert.run_classifier._truncate_seq_pair, and exactly matches its behavior when num_segments = 2 (a pair). Args: segment_tokens (RaggedTensor): a 2-D RaggedTensor of strings. One row for each segment. Each row is a list of tokens. max_tokens (Tensor): scalar int, max number of tokens for all segments combined. Returns: segment_tokens_truncated (RaggedTensor) """ # mask is a 2-D int32 Tensor: 1's indicate tokens, 0's indicate padding. mask = tf.ones_like(segment_tokens, dtype=tf.int32).to_tensor() mask.set_shape([None, None]) max_tokens = tf.cast(max_tokens, dtype=tf.int32) # visit_order reflects the column-major order we would visit each entry. transposed_mask = tf.transpose(mask) visit_order_flat = tf.cumsum(tf.reshape(transposed_mask, [-1])) visit_order = tf.transpose( tf.reshape(visit_order_flat, tf.shape(transposed_mask))) should_keep = (visit_order <= max_tokens) & tf.cast(mask, tf.bool) truncated_row_lengths = tf.reduce_sum(tf.cast(should_keep, tf.int64), axis=1) tokens_to_keep = tf.boolean_mask(segment_tokens.to_tensor(), should_keep) return tf.RaggedTensor.from_row_lengths(tokens_to_keep, truncated_row_lengths)
Example #21
Source File: losses.py From models with Apache License 2.0 | 4 votes |
def _subsample_selection_to_desired_neg_pos_ratio(self, indices, match, max_negatives_per_positive, min_negatives_per_image=0): """Subsample a collection of selected indices to a desired neg:pos ratio. This function takes a subset of M indices (indexing into a large anchor collection of N anchors where M<N) which are labeled as positive/negative via a Match object (matched indices are positive, unmatched indices are negative). It returns a subset of the provided indices retaining all positives as well as up to the first K negatives, where: K=floor(num_negative_per_positive * num_positives). For example, if indices=[2, 4, 5, 7, 9, 10] (indexing into 12 anchors), with positives=[2, 5] and negatives=[4, 7, 9, 10] and num_negatives_per_positive=1, then the returned subset of indices is [2, 4, 5, 7]. Args: indices: An integer tensor of shape [M] representing a collection of selected anchor indices match: A matcher.Match object encoding the match between anchors and groundtruth boxes for a given image, with rows of the Match objects corresponding to groundtruth boxes and columns corresponding to anchors. max_negatives_per_positive: (float) maximum number of negatives for each positive anchor. min_negatives_per_image: minimum number of negative anchors for a given image. Allow sampling negatives in image without any positive anchors. Returns: selected_indices: An integer tensor of shape [M'] representing a collection of selected anchor indices with M' <= M. num_positives: An integer tensor representing the number of positive examples in selected set of indices. num_negatives: An integer tensor representing the number of negative examples in selected set of indices. """ positives_indicator = tf.gather(match.matched_column_indicator(), indices) negatives_indicator = tf.gather(match.unmatched_column_indicator(), indices) num_positives = tf.reduce_sum(tf.cast(positives_indicator, dtype=tf.int32)) max_negatives = tf.maximum( min_negatives_per_image, tf.cast(max_negatives_per_positive * tf.cast(num_positives, dtype=tf.float32), dtype=tf.int32)) topk_negatives_indicator = tf.less_equal( tf.cumsum(tf.cast(negatives_indicator, dtype=tf.int32)), max_negatives) subsampled_selection_indices = tf.where( tf.logical_or(positives_indicator, topk_negatives_indicator)) num_negatives = tf.size(subsampled_selection_indices) - num_positives return (tf.reshape(tf.gather(indices, subsampled_selection_indices), [-1]), num_positives, num_negatives)
Example #22
Source File: box_list_ops.py From models with Apache License 2.0 | 4 votes |
def boolean_mask(boxlist, indicator, fields=None, scope=None, use_static_shapes=False, indicator_sum=None): """Select boxes from BoxList according to indicator and return new BoxList. `boolean_mask` returns the subset of boxes that are marked as "True" by the indicator tensor. By default, `boolean_mask` returns boxes corresponding to the input index list, as well as all additional fields stored in the boxlist (indexing into the first dimension). However one can optionally only draw from a subset of fields. Args: boxlist: BoxList holding N boxes indicator: a rank-1 boolean tensor fields: (optional) list of fields to also gather from. If None (default), all fields are gathered from. Pass an empty fields list to only gather the box coordinates. scope: name scope. use_static_shapes: Whether to use an implementation with static shape gurantees. indicator_sum: An integer containing the sum of `indicator` vector. Only required if `use_static_shape` is True. Returns: subboxlist: a BoxList corresponding to the subset of the input BoxList specified by indicator Raises: ValueError: if `indicator` is not a rank-1 boolean tensor. """ with tf.name_scope(scope, 'BooleanMask'): if indicator.shape.ndims != 1: raise ValueError('indicator should have rank 1') if indicator.dtype != tf.bool: raise ValueError('indicator should be a boolean tensor') if use_static_shapes: if not (indicator_sum and isinstance(indicator_sum, int)): raise ValueError('`indicator_sum` must be a of type int') selected_positions = tf.cast(indicator, dtype=tf.float32) indexed_positions = tf.cast( tf.multiply( tf.cumsum(selected_positions), selected_positions), dtype=tf.int32) one_hot_selector = tf.one_hot( indexed_positions - 1, indicator_sum, dtype=tf.float32) sampled_indices = tf.cast( tf.tensordot( tf.cast(tf.range(tf.shape(indicator)[0]), dtype=tf.float32), one_hot_selector, axes=[0, 0]), dtype=tf.int32) return gather(boxlist, sampled_indices, use_static_shapes=True) else: subboxlist = box_list.BoxList(tf.boolean_mask(boxlist.get(), indicator)) if fields is None: fields = boxlist.get_extra_fields() for field in fields: if not boxlist.has_field(field): raise ValueError('boxlist must contain all specified fields') subfieldlist = tf.boolean_mask(boxlist.get_field(field), indicator) subboxlist.add_field(field, subfieldlist) return subboxlist
Example #23
Source File: expert_utils.py From tensor2tensor with Apache License 2.0 | 4 votes |
def __init__(self, requests, expert_capacity): """Create a TruncatingDispatcher. Args: requests: a boolean `Tensor` of shape `[batch, length, num_experts]`. Alternatively, a float or int Tensor containing zeros and ones. expert_capacity: a Scalar - maximum number of examples per expert per batch element. Returns: a TruncatingDispatcher """ self._requests = tf.to_float(requests) self._expert_capacity = expert_capacity expert_capacity_f = tf.to_float(expert_capacity) self._batch, self._length, self._num_experts = tf.unstack( tf.shape(self._requests), num=3) # [batch, length, num_experts] position_in_expert = tf.cumsum(self._requests, axis=1, exclusive=True) # [batch, length, num_experts] self._gates = self._requests * tf.to_float( tf.less(position_in_expert, expert_capacity_f)) batch_index = tf.reshape( tf.to_float(tf.range(self._batch)), [self._batch, 1, 1]) length_index = tf.reshape( tf.to_float(tf.range(self._length)), [1, self._length, 1]) expert_index = tf.reshape( tf.to_float(tf.range(self._num_experts)), [1, 1, self._num_experts]) # position in a Tensor with shape [batch * num_experts * expert_capacity] flat_position = ( position_in_expert + batch_index * (tf.to_float(self._num_experts) * expert_capacity_f) + expert_index * expert_capacity_f) # Tensor of shape [batch * num_experts * expert_capacity]. # each element is an integer in [0, length) self._indices = tf.unsorted_segment_sum( data=tf.reshape((length_index + 1.0) * self._gates, [-1]), segment_ids=tf.to_int32(tf.reshape(flat_position, [-1])), num_segments=self._batch * self._num_experts * expert_capacity) self._indices = tf.reshape( self._indices, [self._batch, self._num_experts, expert_capacity]) # Tensors of shape [batch, num_experts, expert_capacity]. # each element is 0.0 or 1.0 self._nonpadding = tf.minimum(self._indices, 1.0) # each element is an integer in [0, length) self._indices = tf.nn.relu(self._indices - 1.0) # self._flat_indices is [batch, num_experts, expert_capacity], with values # in [0, batch * length) self._flat_indices = tf.to_int32( self._indices + (tf.reshape(tf.to_float(tf.range(self._batch)), [-1, 1, 1]) * tf.to_float(self._length))) self._indices = tf.to_int32(self._indices)