def tf_occlude(image: tf.Tensor, mask: tf.Tensor, occlusion_size=50): """ TF Wrapper for numpy function Blanks out a cubic subvolume of the image tensor in each channel and each example in the batch Parameters ---------- image : np.ndarray image tensor in xyzc format mask : np.ndarray mask tensor (unaltered) occlusion_size : int, optional side length of the cubic subvolume, by default 50 Returns ------- image, mask the processed image, mask pair """ image_shape = image.shape mask_shape = mask.shape image, mask = tf.numpy_function(np_occlude, inp=[image, mask], Tout=(tf.float32, tf.int32)) image.set_shape(image_shape) mask.set_shape(mask_shape) return image, mask
def call(self, x: tf.Tensor, padding=None) -> tf.Tensor: batch_size = tf.shape(x)[0] length = tf.shape(x)[1] if padding is not None: # removing pad pad_mask = tf.reshape(padding, [-1]) nonpad_ids = tf.to_int32(tf.where(pad_mask < 1e-9)) x = tf.reshape(x, [-1, self.hidden_size]) x = tf.gather_nd(x, indices=nonpad_ids) x.set_shape([None, self.hidden_size]) x = tf.expand_dims(x, axis=0) # [1, batch_size x length, hidden_size] outputs = self.filter_dense_layer(x) if self.is_train: outputs = self.dropout_layer(outputs) outputs = self.output_dense_layer(outputs) if padding is not None: # re add padding outputs = tf.squeeze(outputs, axis=0) # [batch_size x length, hidden_units] outputs = tf.scatter_nd( indices=nonpad_ids, updates=outputs, shape=[batch_size * length, self.hidden_size] ) outputs = tf.reshape(outputs, [batch_size, length, self.hidden_size]) return outputs
def restore_shape(t0: tf.Tensor, t1: tf.Tensor): shape = t0.get_shape() if shape == tensor_shape.unknown_shape(): t1.set_shape([None, None, None]) else: t1.set_shape(shape) return t1
def prepare_input_for_training(skip_gram_pairs_batch: tf.Tensor, sent_percentages: tf.Tensor): """ Prepares the target/context skip-gram pairs for training. Also converts the list of percentages into a single percentage. Parameters ---------- skip_gram_pairs_batch : tf.Tensor Tensor containing input target/context pairs sent_percentages : tf.Tensor Tensor containing percentages of training progress Returns ------- training_data : tuple of tf.Tensor Tuple consisting of targets, contexts and training progress (percentage). """ # Set shape of tf.Tensor and extract targets/contexts skip_gram_pairs_batch.set_shape([batch_size, 2]) input_targets = skip_gram_pairs_batch[:, :1] input_contexts = skip_gram_pairs_batch[:, 1:] # Ensure that dimensions are correct input_targets = tf.squeeze(input_targets, axis=1) input_contexts = tf.squeeze(input_contexts, axis=1) # Return percentage as a single number sent_percentage = sent_percentages[0] sent_percentage = tf.cast(sent_percentage, "float32") # Combine into tuple training_data = (input_targets, input_contexts, sent_percentage) return training_data
def set_shape_dim(tensor: tf.Tensor, index: int, size: int) -> None: """Set value of index-th element of tensor shape to size.""" shape = tensor.get_shape().as_list() if len(shape) <= index: raise ValueError('Tensor rank must be at least %d. Got %d' % (index + 1, len(shape))) shape[index] = size tensor.set_shape(shape)
def tf_affine(image: tf.Tensor, mask: tf.Tensor): image_shape = image.shape mask_shape = mask.shape image, mask = tf.numpy_function(affineTransformation, inp=[image, mask], Tout=(tf.float32, tf.int32)) image.set_shape(image_shape) mask.set_shape(mask_shape) return image, mask
def tf_random_elastic_deform(image: tf.Tensor, mask: tf.Tensor): image_shape = image.shape mask_shape = mask.shape image, mask = tf.numpy_function(random_elastic_deform, inp=[image, mask], Tout=(tf.float32, tf.int32)) image.set_shape(image_shape) mask.set_shape(mask_shape) return image, mask
def tf_encode_wrapper(self, source: tf.Tensor, target: tf.Tensor) -> Tuple[tf.Tensor, tf.Tensor]: shape = source.shape source = tf.py_function(self.encode_source, [source], tf.int32) source.set_shape(shape) shape = target.shape target = tf.py_function(self.encode_target, [target], tf.int32) target.set_shape(shape) return source, target
def set_shape_function(self, lightcurve: tf.Tensor, label: tf.Tensor): """ Explicitly sets the shapes of the lightcurve and label tensor, otherwise TensorFlow can't infer it. :param lightcurve: The lightcurve tensor. :param label: The label tensor. :return: The lightcurve and label tensor with TensorFlow inferable shapes. """ lightcurve.set_shape([self.time_steps_per_example, 1]) label.set_shape([1]) return lightcurve, label
def _split_sample_pairs(x: tf.Tensor, iter_progress: tf.Tensor) \ -> Tuple[tf.Tensor, tf.Tensor, tf.Tensor]: """Split the sample pair tensors into (features, labels, iter_progress) tensor tuples. """ # AutoGraph requires us to set the shape of tensors when # it can't automatically infer it from context. x.set_shape((batch_size, 2)) features = tf.squeeze(x[:, :1], axis=1) labels = tf.squeeze(x[:, 1:], axis=1) iter_progress = tf.cast(iter_progress, tf.float32) return features, labels, iter_progress
def imagenet_slim_preprocess_image(image: tf.Tensor, image_size: int = IMAGE_SIZE, is_training: bool = False, dtype: tf.dtypes.DType = tf.float32, **_) -> tf.Tensor: image = tf.image.central_crop(image, central_fraction=0.875) if is_training: image = tf.image.random_flip_left_right(image) image = utils.resize_image(image, image_size, image_size) image.set_shape([image_size, image_size, 3]) image = image / 255 return tf.image.convert_image_dtype(image, dtype=dtype)
def __img_label_scaling(self, img: tf.Tensor, label: tf.Tensor) -> Tuple[tf.Tensor, tf.Tensor]: """ Scaling casting and set_shape calls which are needed in the chain of dataset map function calls. :param img: Image with values in [0,1] :param label: Label of the image :return: Tuple of (img, label), where img is in [-1,1] and label is a uint8 (Tiny ImageNet has 200 classes) """ img = tf.multiply(2., img) - 1. # float32 [-1., 1] img.set_shape([self.img_width, self.img_height, self.img_channels]) label = tf.string_to_number(label, tf.int32) label = tf.cast(label, tf.uint8) return img, label
def inference_fn(cls, image: tf.Tensor, input_image_size: List[int], num_channels: int = 3) -> tf.Tensor: """Builds image model inputs for serving.""" image = tf.cast(image, dtype=tf.float32) image = preprocess_ops.center_crop_image(image) image = tf.image.resize( image, input_image_size, method=tf.image.ResizeMethod.BILINEAR) # Normalizes image with mean and std pixel values. image = preprocess_ops.normalize_image( image, offset=MEAN_RGB, scale=STDDEV_RGB) image.set_shape(input_image_size + [num_channels]) return image
def random_crop_resize(frames: tf.Tensor, output_h: int, output_w: int, num_frames: int, num_channels: int, aspect_ratio: Tuple[float, float], area_range: Tuple[float, float]) -> tf.Tensor: """First crops clip with jittering and then resizes to (output_h, output_w). Args: frames: A Tensor of dimension [timesteps, input_h, input_w, channels]. output_h: Resized image height. output_w: Resized image width. num_frames: Number of input frames per clip. num_channels: Number of channels of the clip. aspect_ratio: Float tuple with the aspect range for cropping. area_range: Float tuple with the area range for cropping. Returns: A Tensor of shape [timesteps, output_h, output_w, channels] of type frames.dtype. """ shape = tf.shape(frames) seq_len, _, _, channels = shape[0], shape[1], shape[2], shape[3] bbox = tf.constant([0.0, 0.0, 1.0, 1.0], dtype=tf.float32, shape=[1, 1, 4]) factor = output_w / output_h aspect_ratio = (aspect_ratio[0] * factor, aspect_ratio[1] * factor) sample_distorted_bbox = tf.image.sample_distorted_bounding_box( shape[1:], bounding_boxes=bbox, min_object_covered=0.1, aspect_ratio_range=aspect_ratio, area_range=area_range, max_attempts=100, use_image_if_no_bounding_boxes=True) bbox_begin, bbox_size, _ = sample_distorted_bbox offset_y, offset_x, _ = tf.unstack(bbox_begin) target_height, target_width, _ = tf.unstack(bbox_size) size = tf.convert_to_tensor(( seq_len, target_height, target_width, channels)) offset = tf.convert_to_tensor(( 0, offset_y, offset_x, 0)) frames = tf.slice(frames, offset, size) frames = tf.cast( tf.image.resize(frames, (output_h, output_w)), frames.dtype) frames.set_shape((num_frames, output_h, output_w, num_channels)) return frames
def set_tensor_shape(tensor: tf.Tensor, tensor_shape: Any) -> tf.Tensor: """ Set shape for a tensor (not in place, as opposed to tf.set_shape) Parameters: tensor (tensorflow.Tensor): Tensor to reshape. tensor_shape (Any): Shape to apply to the tensor. Returns: tensorflow.Tensor: A reshaped tensor. """ # NOTE: That SOUND LIKE IN PLACE HERE ? tensor.set_shape(tensor_shape) return tensor
def return_crf_result(self, labels: tf.Tensor, logits: tf.Tensor, mode: str, input_mask: tf.Tensor): input_mask.set_shape([None, None]) logits = create_dummy_if_empty(logits) input_mask = create_dummy_if_empty(input_mask) viterbi_decoded, potentials, sequence_length, chain_kernel = self.crf( logits, input_mask) if mode != tf.estimator.ModeKeys.PREDICT: loss = -crf_log_likelihood(potentials, labels, sequence_length, chain_kernel)[0] loss = tf.reduce_mean(loss) loss = nan_loss_handling(loss) self.add_loss(loss) acc = self.metric_fn( labels, viterbi_decoded, sample_weight=input_mask) self.add_metric(acc) # make the crf prediction has the same shape as non-crf prediction return tf.one_hot(viterbi_decoded, name='%s_predict' % self.problem_name, depth=self.params.num_classes[self.problem_name])
def padd_for_aligning_pixels(inputs: tf.Tensor): """This padding operation is here to make the pixels of the output perfectly aligned. It will make the output perfectly aligned at stride 32. """ chan = inputs.shape[3] b4_stride = 32.0 shape2d = tf.shape(inputs)[1:3] new_shape2d = tf.cast( tf.math.ceil(tf.cast(shape2d, tf.float32) / b4_stride) * b4_stride, tf.int32) pad_shape2d = new_shape2d - shape2d inputs = tf.pad(inputs, tf.stack([[0, 0], [3, 2 + pad_shape2d[0]], [3, 2 + pad_shape2d[1]], [0, 0]]), name='conv1_pad') # yapf: disable inputs.set_shape([None, None, None, chan]) return inputs
def _fixup_shape(self, f: tf.Tensor, lb: tf.Tensor): """requires further testing, this is for classification""" f.set_shape([None, None, f.shape[-1]]) lb.set_shape(lb.shape) # number of class return f, lb
def _fixup_shape_semisupervised(self, f: tf.Tensor, lb: tf.Tensor): """requires further testing, only for semisupervised for testing""" f.set_shape([None, None, f.shape[-1]]) lb.set_shape([None, None, lb.shape[-1]]) return f, lb
def decode_image(self, img: tf.Tensor) -> tf.Tensor: """Decode the jpeg or png bytes to 3d tensor.""" img = tf.image.decode_image(img, channels=self.shape[-1], dtype=self.dtype) img.set_shape(self.shape) return img
def tst_set_shape_foo(f: tf.Tensor, lb: tf.Tensor): f.set_shape(f.shape) lb.set_shape(lb.shape) return f, lb
def set_shape(x: tf.Tensor, h: int, w: int, c: int = 3) -> tf.Tensor: x.set_shape([h, w, c]) return x
def _assert_shape(image: tf.Tensor) -> tf.Tensor: image.set_shape(output_shape) return image