我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用tensorflow.rank()。
def is_same_dynamic_shape(x, y): """ Whether `x` and `y` has the same dynamic shape. :param x: A Tensor. :param y: A Tensor. :return: A scalar Tensor of `bool`. """ # There is a BUG of Tensorflow for not doing static shape inference # right in nested tf.cond()'s, so we are not comparing x and y's # shape directly but working with their concatenations. return tf.cond( tf.equal(tf.rank(x), tf.rank(y)), lambda: tf.reduce_all(tf.equal( tf.concat([tf.shape(x), tf.shape(y)], 0), tf.concat([tf.shape(y), tf.shape(x)], 0))), lambda: tf.convert_to_tensor(False, tf.bool))
def assert_rank_at_least(tensor, k, name): """ Whether the rank of `tensor` is at least k. :param tensor: A tensor to be checked. :param k: The least rank allowed. :param name: The name of `tensor` for error message. :return: The checked tensor. """ static_shape = tensor.get_shape() shape_err_msg = '{} should have rank >= {}.'.format(name, k) if static_shape and (static_shape.ndims < k): raise ValueError(shape_err_msg) if not static_shape: _assert_shape_op = tf.assert_rank_at_least( tensor, k, message=shape_err_msg) with tf.control_dependencies([_assert_shape_op]): tensor = tf.identity(tensor) return tensor
def _crop(image, offset_height, offset_width, crop_height, crop_width): original_shape = tf.shape(image) rank_assertion = tf.Assert( tf.equal(tf.rank(image), 3), ['Rank of image must be equal to 3.']) cropped_shape = control_flow_ops.with_dependencies( [rank_assertion], tf.stack([crop_height, crop_width, original_shape[2]])) size_assertion = tf.Assert( tf.logical_and( tf.greater_equal(original_shape[0], crop_height), tf.greater_equal(original_shape[1], crop_width)), ['Crop size greater than the image size.']) offsets = tf.to_int32(tf.stack([offset_height, offset_width, 0])) # Use tf.slice instead of crop_to_bounding box as it accepts tensors to # define the crop size. image = control_flow_ops.with_dependencies([size_assertion], tf.slice(image, offsets, cropped_shape)) return tf.reshape(image, cropped_shape)
def _crop(image, offset_height, offset_width, crop_height, crop_width): original_shape = tf.shape(image) rank_assertion = tf.Assert( tf.equal(tf.rank(image), 3), ['Rank of image must be equal to 3.']) cropped_shape = control_flow_ops.with_dependencies( [rank_assertion], tf.stack([crop_height, crop_width, original_shape[2]])) size_assertion = tf.Assert( tf.logical_and( tf.greater_equal(original_shape[0], crop_height), tf.greater_equal(original_shape[1], crop_width)), ['Crop size greater than the image size.']) offsets = tf.to_int32(tf.stack([offset_height, offset_width, 0])) # Use tf.slice instead of crop_to_bounding box as it accepts tensors to # define the crop size. image = control_flow_ops.with_dependencies( [size_assertion], tf.slice(image, offsets, cropped_shape)) return tf.reshape(image, cropped_shape)
def image_series_summary(tag, imgs, max_timesteps=10): # take only 3 items from the minibatch imgs = imgs[:, :3] # assume img.shape == (T, batch_size, n_obj, H, W, C) # let's log only for 1st obj tf.cond(tf.equal(tf.rank(imgs), 6), lambda: imgs[:, :, 0], lambda: imgs) shape = (max_timesteps,) + tuple(imgs.get_shape()[1:]) nt = tf.shape(imgs)[0] def pad(): paddings = tf.concat(axis=0, values=([[0, max_timesteps - nt]], tf.zeros((len(shape) - 1, 2), tf.int32))) return tf.pad(imgs, paddings) imgs = tf.cond(tf.greater(nt, max_timesteps), lambda: imgs[:max_timesteps], pad) imgs.set_shape(shape) imgs = tf.squeeze(imgs) imgs = tf.unstack(imgs) # concatenate along the columns imgs = tf.concat(axis=2, values=imgs) tf.summary.image(tag, imgs)
def broadcast_against(tensor, against_expr): """Adds trailing dimensions to mask to enable broadcasting against data :param tensor: tensor to be broadcasted :param against_expr: tensor will be broadcasted against it :return: mask expr with tf.rank(mask) == tf.rank(data) """ def cond(data, tensor): return tf.less(tf.rank(tensor), tf.rank(data)) def body(data, tensor): return data, tf.expand_dims(tensor, -1) shape_invariants = [against_expr.get_shape(), tf.TensorShape(None)] _, tensor = tf.while_loop(cond, body, [against_expr, tensor], shape_invariants) return tensor
def _slice_cov(self, cov): """ Slice the correct dimensions for use in the kernel, as indicated by `self.active_dims` for covariance matrices. This requires slicing the rows *and* columns. This will also turn flattened diagonal matrices into a tensor of full diagonal matrices. :param cov: Tensor of covariance matrices (NxDxD or NxD). :return: N x self.input_dim x self.input_dim. """ cov = tf.cond(tf.equal(tf.rank(cov), 2), lambda: tf.matrix_diag(cov), lambda: cov) if isinstance(self.active_dims, slice): cov = cov[..., self.active_dims, self.active_dims] else: cov_shape = tf.shape(cov) covr = tf.reshape(cov, [-1, cov_shape[-1], cov_shape[-1]]) gather1 = tf.gather(tf.transpose(covr, [2, 1, 0]), self.active_dims) gather2 = tf.gather(tf.transpose(gather1, [1, 0, 2]), self.active_dims) cov = tf.reshape(tf.transpose(gather2, [2, 0, 1]), tf.concat([cov_shape[:-2], [len(self.active_dims), len(self.active_dims)]], 0)) return cov
def multivariate_normal(x, mu, L): """ L is the Cholesky decomposition of the covariance. x and mu are either vectors (ndim=1) or matrices. In the matrix case, we assume independence over the *columns*: the number of rows must match the size of L. """ d = x - mu alpha = tf.matrix_triangular_solve(L, d, lower=True) num_col = 1 if tf.rank(x) == 1 else tf.shape(x)[1] num_col = tf.cast(num_col, settings.float_type) num_dims = tf.cast(tf.shape(x)[0], settings.float_type) ret = - 0.5 * num_dims * num_col * np.log(2 * np.pi) ret += - num_col * tf.reduce_sum(tf.log(tf.matrix_diag_part(L))) ret += - 0.5 * tf.reduce_sum(tf.square(alpha)) return ret
def _sparse_loss_softmax(self, logits, labels, is_training, weighted=False): log.info('Using sparse softmax loss') labels = tf.cast(labels, tf.int64) if weighted: if tf.rank(labels) != 2: labels = tf.one_hot(labels, self.num_classes) weights = self._compute_weights(labels) weights = tf.reduce_max(tf.multiply(weights, labels), axis=1) ce_loss = tf.losses.sparse_softmax_cross_entropy( tf.argmax(labels, axis=1), logits=logits, weights=weights, scope='cross_entropy_loss') else: ce_loss = tf.nn.sparse_softmax_cross_entropy_with_logits( labels=labels, logits=logits, name='cross_entropy_loss') ce_loss_mean = tf.reduce_mean(ce_loss, name='cross_entropy') if is_training: tf.add_to_collection('losses', ce_loss_mean) l2_loss = tf.add_n(tf.get_collection( tf.GraphKeys.REGULARIZATION_LOSSES)) l2_loss = l2_loss * self.cnf.get('l2_reg', 0.0) tf.add_to_collection('losses', l2_loss) return tf.add_n(tf.get_collection('losses'), name='total_loss') else: return ce_loss_mean
def _loss_softmax(self, logits, labels, is_training, weighted=False): log.info('Using softmax loss') labels = tf.cast(labels, tf.int64) if tf.rank(labels) != 2: labels = tf.one_hot(labels, self.num_classes) if weighted: weights = self._compute_weights(labels) weights = tf.reduce_max(tf.multiply(weights, labels), axis=1) ce_loss = tf.losses.softmax_cross_entropy( labels, logits=logits, weights=weights, label_smoothing=self.label_smoothing, scope='cross_entropy_loss') else: ce_loss = tf.nn.softmax_cross_entropy_with_logits( labels=labels, logits=logits, name='cross_entropy_loss') ce_loss_mean = tf.reduce_mean(ce_loss, name='cross_entropy') if is_training: tf.add_to_collection('losses', ce_loss_mean) l2_loss = tf.add_n(tf.get_collection( tf.GraphKeys.REGULARIZATION_LOSSES)) l2_loss = l2_loss * self.cnf.get('l2_reg', 0.0) tf.add_to_collection('losses', l2_loss) return tf.add_n(tf.get_collection('losses'), name='total_loss') else: return ce_loss_mean
def _loss_sigmoid(self, logits, labels, is_training, weighted=False): log.info('Using sigmoid loss') labels = tf.cast(labels, tf.int64) if tf.rank(labels) != 2: labels = tf.one_hot(labels, self.num_classes) if weighted: weights = self._compute_weights(labels) ce_loss = tf.losses.sigmoid_cross_entropy( labels, logits=logits, weights=weights, label_smoothing=self.label_smoothing, scope='sigmoid_cross_entropy_loss') else: ce_loss = tf.nn.sigmoid_cross_entropy_with_logits( labels=labels, logits=logits, name='sigmoid_cross_entropy_loss') ce_loss_mean = tf.reduce_mean(ce_loss, name='sigmoid_cross_entropy') if is_training: tf.add_to_collection('losses', ce_loss_mean) l2_loss = tf.add_n(tf.get_collection( tf.GraphKeys.REGULARIZATION_LOSSES)) l2_loss = l2_loss * self.cnf.get('l2_reg', 0.0) tf.add_to_collection('losses', l2_loss) return tf.add_n(tf.get_collection('losses'), name='total_loss') else: return ce_loss_mean
def random_adjust_contrast(image, min_delta=0.8, max_delta=1.25): """Randomly adjusts contrast. Makes sure the output image is still between 0 and 1. Args: image: rank 3 float32 tensor contains 1 image -> [height, width, channels] with pixel values varying between [0, 1]. min_delta: see max_delta. max_delta: how much to change the contrast. Contrast will change with a value between min_delta and max_delta. This value will be multiplied to the current contrast of the image. Returns: image: image which is the same shape as input image. """ with tf.name_scope('RandomAdjustContrast', values=[image]): image = tf.image.random_contrast(image, min_delta, max_delta) image = tf.clip_by_value(image, clip_value_min=0.0, clip_value_max=1.0) return image
def random_adjust_hue(image, max_delta=0.02): """Randomly adjusts hue. Makes sure the output image is still between 0 and 1. Args: image: rank 3 float32 tensor contains 1 image -> [height, width, channels] with pixel values varying between [0, 1]. max_delta: change hue randomly with a value between 0 and max_delta. Returns: image: image which is the same shape as input image. """ with tf.name_scope('RandomAdjustHue', values=[image]): image = tf.image.random_hue(image, max_delta) image = tf.clip_by_value(image, clip_value_min=0.0, clip_value_max=1.0) return image
def random_adjust_saturation(image, min_delta=0.8, max_delta=1.25): """Randomly adjusts saturation. Makes sure the output image is still between 0 and 1. Args: image: rank 3 float32 tensor contains 1 image -> [height, width, channels] with pixel values varying between [0, 1]. min_delta: see max_delta. max_delta: how much to change the saturation. Saturation will change with a value between min_delta and max_delta. This value will be multiplied to the current saturation of the image. Returns: image: image which is the same shape as input image. """ with tf.name_scope('RandomAdjustSaturation', values=[image]): image = tf.image.random_saturation(image, min_delta, max_delta) image = tf.clip_by_value(image, clip_value_min=0.0, clip_value_max=1.0) return image
def broadcast(tensor, target_tensor): """Broadcast a tensor to match the shape of a target tensor. Args: tensor (Tensor): tensor to be tiled target_tensor (Tensor): tensor whose shape is to be matched """ rank = lambda t: t.get_shape().ndims assert rank(tensor) == rank(target_tensor) # TODO: assert that tensors have no overlapping non-unity dimensions orig_shape = tf.shape(tensor) target_shape = tf.shape(target_tensor) # if dim == 1, set it to target_dim # else, set it to 1 tiling_factor = tf.select(tf.equal(orig_shape, 1), target_shape, tf.ones([rank(tensor)], dtype=tf.int32)) broadcasted = tf.tile(tensor, tiling_factor) # Add static shape information broadcasted.set_shape(target_tensor.get_shape()) return broadcasted
def generate_girl(): output = pixel_cnn() predict = tf.reshape(tf.multinomial(tf.nn.softmax(output), num_samples=1, seed=100), tf.shape(X)) #predict_argmax = tf.reshape(tf.argmax(tf.nn.softmax(output), dimension=tf.rank(output) - 1), tf.shape(X)) with tf.Session() as sess: sess.run(tf.initialize_all_variables()) saver = tf.train.Saver(tf.trainable_variables()) saver.restore(sess, 'girl.ckpt-49') pics = np.zeros((1*1, image_height, image_width, image_channel), dtype=np.float32) for i in range(image_height): for j in range(image_width): for k in range(image_channel): next_pic = sess.run(predict, feed_dict={X:pics}) pics[:, i, j, k] = next_pic[:, i, j, k] cv2.imwrite('girl.jpg', pics[0]) print('generate image: girl.jpg') # ????
def pool(inputs, window_size, pooling_type, padding, strides=(1, 1)): """Pooling (supports "LEFT").""" with tf.name_scope("pool", [inputs]): static_shape = inputs.get_shape() if not static_shape or len(static_shape) != 4: raise ValueError("Inputs to conv must have statically known rank 4.") # Add support for left padding. if padding == "LEFT": assert window_size[0] % 2 == 1 and window_size[1] % 2 == 1 if len(static_shape) == 3: width_padding = 2 * (window_size[1] // 2) padding_ = [[0, 0], [width_padding, 0], [0, 0]] else: height_padding = 2 * (window_size[0] // 2) cond_padding = tf.cond( tf.equal(shape_list(inputs)[2], 1), lambda: tf.constant(0), lambda: tf.constant(2 * (window_size[1] // 2))) width_padding = 0 if static_shape[2] == 1 else cond_padding padding_ = [[0, 0], [height_padding, 0], [width_padding, 0], [0, 0]] inputs = tf.pad(inputs, padding_) inputs.set_shape([static_shape[0], None, None, static_shape[3]]) padding = "VALID" return tf.nn.pool(inputs, window_size, pooling_type, padding, strides=strides)
def shape_list(x): """Return list of dims, statically where possible.""" x = tf.convert_to_tensor(x) # If unknown rank, return dynamic shape if x.get_shape().dims is None: return tf.shape(x) static = x.get_shape().as_list() shape = tf.shape(x) ret = [] for i in xrange(len(static)): dim = static[i] if dim is None: dim = shape[i] ret.append(dim) return ret
def expanded_shape(orig_shape, start_dim, num_dims): """Inserts multiple ones into a shape vector. Inserts an all-1 vector of length num_dims at position start_dim into a shape. Can be combined with tf.reshape to generalize tf.expand_dims. Args: orig_shape: the shape into which the all-1 vector is added (int32 vector) start_dim: insertion position (int scalar) num_dims: length of the inserted all-1 vector (int scalar) Returns: An int32 vector of length tf.size(orig_shape) + num_dims. """ with tf.name_scope('ExpandedShape'): start_dim = tf.expand_dims(start_dim, 0) # scalar to rank-1 before = tf.slice(orig_shape, [0], start_dim) add_shape = tf.ones(tf.reshape(num_dims, [1]), dtype=tf.int32) after = tf.slice(orig_shape, start_dim, [-1]) new_shape = tf.concat([before, add_shape, after], 0) return new_shape
def pad_tensor(t, length): """Pads the input tensor with 0s along the first dimension up to the length. Args: t: the input tensor, assuming the rank is at least 1. length: a tensor of shape [1] or an integer, indicating the first dimension of the input tensor t after padding, assuming length <= t.shape[0]. Returns: padded_t: the padded tensor, whose first dimension is length. If the length is an integer, the first dimension of padded_t is set to length statically. """ t_rank = tf.rank(t) t_shape = tf.shape(t) t_d0 = t_shape[0] pad_d0 = tf.expand_dims(length - t_d0, 0) pad_shape = tf.cond( tf.greater(t_rank, 1), lambda: tf.concat([pad_d0, t_shape[1:]], 0), lambda: tf.expand_dims(length - t_d0, 0)) padded_t = tf.concat([t, tf.zeros(pad_shape, dtype=t.dtype)], 0) if not _is_tensor(length): padded_t = _set_dim_0(padded_t, length) return padded_t
def clip_tensor(t, length): """Clips the input tensor along the first dimension up to the length. Args: t: the input tensor, assuming the rank is at least 1. length: a tensor of shape [1] or an integer, indicating the first dimension of the input tensor t after clipping, assuming length <= t.shape[0]. Returns: clipped_t: the clipped tensor, whose first dimension is length. If the length is an integer, the first dimension of clipped_t is set to length statically. """ clipped_t = tf.gather(t, tf.range(length)) if not _is_tensor(length): clipped_t = _set_dim_0(clipped_t, length) return clipped_t
def pad_or_clip_tensor(t, length): """Pad or clip the input tensor along the first dimension. Args: t: the input tensor, assuming the rank is at least 1. length: a tensor of shape [1] or an integer, indicating the first dimension of the input tensor t after processing. Returns: processed_t: the processed tensor, whose first dimension is length. If the length is an integer, the first dimension of the processed tensor is set to length statically. """ processed_t = tf.cond( tf.greater(tf.shape(t)[0], length), lambda: clip_tensor(t, length), lambda: pad_tensor(t, length)) if not _is_tensor(length): processed_t = _set_dim_0(processed_t, length) return processed_t
def __call__(self,i): # assume hidden, input is of shape [batch,num_h] and [batch,num_in] hidden = i[0] inp = i[1] wz,wr,w = self.wz,self.wr,self.w dims = tf.rank(inp) c = tf.concat([hidden,inp],axis=dims-1) z = tf.sigmoid(wz(c)) r = tf.sigmoid(wr(c)) h_c = tf.tanh(w(tf.concat([hidden*r,inp],axis=dims-1))) h_new = (1-z) * hidden + z * h_c return h_new # GRU2 as reported in *Gate-Variants of Gated Recurrent Unit (GRU) Neural Networks* # the gates are now only driven by hidden state. # mod: removed reset gate. # conclusion 20171220: GRU2(without reset gate) is almost as good as GRU.
def build_backward_variance(self, Yvar): """ Additional method for scaling variance backward (used in :class:`.Normalizer`). Can process both the diagonal variances returned by predict_f, as well as full covariance matrices. :param Yvar: size N x N x P or size N x P :return: Yvar scaled, same rank and size as input """ rank = tf.rank(Yvar) # Because TensorFlow evaluates both fn1 and fn2, the transpose can't be in the same line. If a full cov # matrix is provided fn1 turns it into a rank 4, then tries to transpose it as a rank 3. # Splitting it in two steps however works fine. Yvar = tf.cond(tf.equal(rank, 2), lambda: tf.matrix_diag(tf.transpose(Yvar)), lambda: Yvar) Yvar = tf.cond(tf.equal(rank, 2), lambda: tf.transpose(Yvar, perm=[1, 2, 0]), lambda: Yvar) N = tf.shape(Yvar)[0] D = tf.shape(Yvar)[2] L = tf.cholesky(tf.square(tf.transpose(self.A))) Yvar = tf.reshape(Yvar, [N * N, D]) scaled_var = tf.reshape(tf.transpose(tf.cholesky_solve(L, tf.transpose(Yvar))), [N, N, D]) return tf.cond(tf.equal(rank, 2), lambda: tf.reduce_sum(scaled_var, axis=1), lambda: scaled_var)
def sample(self, n=None): if self._bernoulli is None: self._bernoulli = Bernoulli(self._steps_probs) sample = self._bernoulli.sample(n) sample = tf.cumprod(sample, tf.rank(sample) - 1) sample = tf.reduce_sum(sample, -1) return sample
def repeat_v2(x,k): ''' repeat k times along first dimension ''' def change(x,k): shape = x.get_shape().as_list()[1:] x_1 = tf.expand_dims(x,1) tile_shape = tf.concat([tf.ones(1,dtype='int32'),[k],tf.ones([tf.rank(x)-1],dtype='int32')],axis=0) x_rep = tf.tile(x_1,tile_shape) new_shape = np.insert(shape,0,-1) x_out = tf.reshape(x_rep,new_shape) return x_out return tf.cond(tf.equal(k,1), lambda: x, lambda: change(x,k))
def _mean_image_subtraction(image, means): """Subtracts the given means from each image channel. For example: means = [123.68, 116.779, 103.939] image = _mean_image_subtraction(image, means) Note that the rank of `image` must be known. Args: image: a tensor of size [height, width, C]. means: a C-vector of values to subtract from each channel. Returns: the centered image. Raises: ValueError: If the rank of `image` is unknown, if `image` has a rank other than three or if the number of channels in `image` doesn't match the number of values in `means`. """ if image.get_shape().ndims != 3: raise ValueError('Input must be of size [height, width, C>0]') num_channels = image.get_shape().as_list()[-1] if len(means) != num_channels: raise ValueError('len(means) must match the number of channels') channels = tf.split(2, num_channels, image) for i in range(num_channels): channels[i] -= means[i] return tf.concat(2, channels)
def assert_rank_at_least_one(tensor, name): """ Whether the rank of `tensor` is at least one. :param tensor: A tensor to be checked. :param name: The name of `tensor` for error message. :return: The checked tensor. """ return assert_rank_at_least(tensor, 1, name)
def _mean_image_subtraction(image, means): """Subtracts the given means from each image channel. For example: means = [123.68, 116.779, 103.939] image = _mean_image_subtraction(image, means) Note that the rank of `image` must be known. Args: image: a tensor of size [height, width, C]. means: a C-vector of values to subtract from each channel. Returns: the centered image. Raises: ValueError: If the rank of `image` is unknown, if `image` has a rank other than three or if the number of channels in `image` doesn't match the number of values in `means`. """ if image.get_shape().ndims != 3: raise ValueError('Input must be of size [height, width, C>0]') num_channels = image.get_shape().as_list()[-1] if len(means) != num_channels: raise ValueError('len(means) must match the number of channels') channels = tf.split(axis=2, num_or_size_splits=num_channels, value=image) for i in range(num_channels): channels[i] -= means[i] return tf.concat(axis=2, values=channels)
def normalize_contrast(x): """Normalize contrast of an image: forces values to be stricly in [0, 1] :param x: image tensor :return: """ idx = tf.range(1, tf.rank(x)) min = tf.reduce_min(x, idx, keep_dims=True) max = tf.reduce_max(x, idx, keep_dims=True) return (x - min) / (max - min + 1e-5)
def intersection_within(bbox, within): """Returns the coordinates of the intersection of `bbox` and `within` with respect to `within` :param bbox: :param within: :return: """ x1 = tf.maximum(bbox[..., 1], within[..., 1]) y1 = tf.maximum(bbox[..., 0], within[..., 0]) x2 = tf.minimum(bbox[..., 1] + bbox[..., 3], within[..., 1] + within[..., 3]) y2 = tf.minimum(bbox[..., 0] + bbox[..., 2], within[..., 0] + within[..., 2]) w = x2 - x1 w = tf.where(tf.less_equal(w, 0), tf.zeros_like(w), w) h = y2 - y1 h = tf.where(tf.less_equal(h, 0), tf.zeros_like(h), h) y = y1 - within[..., 0] x = x1 - within[..., 1] area = h * w y = tf.where(tf.greater(area, 0.), y, tf.zeros_like(y)) x = tf.where(tf.greater(area, 0.), x, tf.zeros_like(x)) rank = len(bbox.get_shape()) - 1 return tf.stack((y, x, h, w), rank)
def extract_glimpse(inpt, attention_params, glimpse_size): """Extracts an attention glimpse :param inpt: tensor of shape == (batch_size, img_height, img_width) :param attention_params: tensor of shape = (batch_size, 6) as [uy, sy, dy, ux, sx, dx] with u - mean, s - std, d - stride" :param glimpse_size: 2-tuple of ints as (height, width), size of the extracted glimpse :return: tensor """ ap = attention_params shape = inpt.get_shape() rank = len(shape) assert rank in (3, 4), "Input must be 3 or 4 dimensional tensor" inpt_H, inpt_W = shape[1:3] if rank == 3: inpt = inpt[..., tf.newaxis] rank += 1 Fy = gaussian_mask(ap[..., 0::2], glimpse_size[0], inpt_H) Fx = gaussian_mask(ap[..., 1::2], glimpse_size[1], inpt_W) gs = [] for channel in tf.unstack(inpt, axis=rank - 1): g = tf.matmul(tf.matmul(Fy, channel, adjoint_a=True), Fx) gs.append(g) g = tf.stack(gs, axis=rank - 1) g.set_shape([shape[0]] + list(glimpse_size)) return g
def attention_to_bbox(self, att): with tf.variable_scope('attention_to_bbox'): yx = att[..., :2] * self.inpt_size[np.newaxis, :2] hw = att[..., 2:4] * (self.inpt_size[np.newaxis, :2] - 1) bbox = tf.concat(axis=tf.rank(att) - 1, values=(yx, hw)) bbox.set_shape(att.get_shape()[:-1].concatenate((4,))) return bbox
def bbox_to_attention(self, bbox): with tf.variable_scope('ratm_bbox_to_attention'): us = bbox[..., :2] / self.inpt_size[np.newaxis, :2] ss = 0.5 * bbox[..., 2:] / self.inpt_size[np.newaxis, :2] ds = bbox[..., 2:] / (self.inpt_size[np.newaxis, :2] - 1.) att = tf.concat(axis=tf.rank(bbox) - 1, values=(us, ss, ds)) return att
def _to_attention(self, raw_att, with_bias=True): bbox = FixedStdAttention.attention_to_bbox(self, raw_att) us = bbox[..., :2] if with_bias: us += self.offset_bias ds = bbox[..., 2:4] / (self.glimpse_size[np.newaxis, :2] - 1) ss = self._stride_to_std(ds) ap = tf.concat(axis=tf.rank(raw_att) - 1, values=(us, ss, ds), name='attention') ap.set_shape(raw_att.get_shape()[:-1].concatenate((6,))) return ap
def _mask(expr, mask): assert mask.dtype == tf.bool, '`mask`.dtype has to be tf.bool' mask_rank = tf.rank(mask) sample_shape = tf.shape(expr)[mask_rank:] flat_shape = tf.concat(([-1], sample_shape), 0) flat_expr = tf.reshape(expr, flat_shape) flat_mask = tf.reshape(mask, (-1,)) return tf.boolean_mask(flat_expr, flat_mask)
def __init__(self, input_dim, output_dim, rank, active_dims=None, name=None): """ A Coregionalization kernel. The inputs to this kernel are _integers_ (we cast them from floats as needed) which usually specify the *outputs* of a Coregionalization model. The parameters of this kernel, W, kappa, specify a positive-definite matrix B. B = W W^T + diag(kappa) . The kernel function is then an indexing of this matrix, so K(x, y) = B[x, y] . We refer to the size of B as "num_outputs x num_outputs", since this is the number of outputs in a coregionalization model. We refer to the number of columns on W as 'rank': it is the number of degrees of correlation between the outputs. NB. There is a symmetry between the elements of W, which creates a local minimum at W=0. To avoid this, it's recommended to initialize the optimization (or MCMC chain) using a random W. """ assert input_dim == 1, "Coregion kernel in 1D only" super().__init__(input_dim, active_dims, name=name) self.output_dim = output_dim self.rank = rank self.W = Parameter(np.zeros((self.output_dim, self.rank), dtype=settings.float_type)) self.kappa = Parameter(np.ones(self.output_dim, dtype=settings.float_type), transform=transforms.positive)
def _crop(image, offset_height, offset_width, crop_height, crop_width): """Crops the given image using the provided offsets and sizes. Note that the method doesn't assume we know the input image size but it does assume we know the input image rank. Args: image: an image of shape [height, width, channels]. offset_height: a scalar tensor indicating the height offset. offset_width: a scalar tensor indicating the width offset. crop_height: the height of the cropped image. crop_width: the width of the cropped image. Returns: the cropped (and resized) image. Raises: InvalidArgumentError: if the rank is not 3 or if the image dimensions are less than the crop size. """ original_shape = tf.shape(image) rank_assertion = tf.Assert( tf.equal(tf.rank(image), 3), ['Rank of image must be equal to 3.']) with tf.control_dependencies([rank_assertion]): cropped_shape = tf.stack([crop_height, crop_width, original_shape[2]]) size_assertion = tf.Assert( tf.logical_and( tf.greater_equal(original_shape[0], crop_height), tf.greater_equal(original_shape[1], crop_width)), ['Crop size greater than the image size.']) offsets = tf.to_int32(tf.stack([offset_height, offset_width, 0])) # Use tf.slice instead of crop_to_bounding box as it accepts tensors to # define the crop size. with tf.control_dependencies([size_assertion]): image = tf.slice(image, offsets, cropped_shape) return tf.reshape(image, cropped_shape)
def _mean_image_subtraction(image, means): """Subtracts the given means from each image channel. For example: means = [123.68, 116.779, 103.939] image = _mean_image_subtraction(image, means) Note that the rank of `image` must be known. Args: image: a tensor of size [height, width, C]. means: a C-vector of values to subtract from each channel. Returns: the centered image. Raises: ValueError: If the rank of `image` is unknown, if `image` has a rank other than three or if the number of channels in `image` doesn't match the number of values in `means`. """ if image.get_shape().ndims != 3: raise ValueError('Input must be of size [height, width, C>0]') num_channels = image.get_shape().as_list()[-1] if len(means) != num_channels: raise ValueError('len(means) must match the number of channels') channels = tf.split(2, num_channels, image) for i in range(num_channels): channels[i] -= means[i] return tf.concat(channels, axis=2)
def _transpose_batch_time(x): """Transpose the batch and time dimensions of a Tensor. Retains as much of the static shape information as possible. Args: x: A tensor of rank 2 or higher. Returns: x transposed along the first two dimensions. Raises: ValueError: if `x` is rank 1 or lower. """ x_static_shape = x.get_shape() if x_static_shape.ndims is not None and x_static_shape.ndims < 2: raise ValueError( "Expected input tensor %s to have rank at least 2, but saw shape: %s" % (x, x_static_shape)) x_rank = tf.rank(x) x_t = tf.transpose( x, tf.concat( ([1, 0], tf.range(2, x_rank)), axis=0)) x_t.set_shape( [x_static_shape[1].value, x_static_shape[0].value] + x_static_shape[2:]) return x_t
def run_inception(images, graph_def=None, default_graph_def_fn=_default_graph_def_fn, image_size=INCEPTION_DEFAULT_IMAGE_SIZE, input_tensor=INCEPTION_INPUT, output_tensor=INCEPTION_OUTPUT): """Run images through a pretrained Inception classifier. Args: images: Input tensors. Must be [batch, height, width, channels]. Input shape and values must be in [-1, 1], which can be achieved using `preprocess_image`. graph_def: A GraphDef proto of a pretrained Inception graph. If `None`, call `default_graph_def_fn` to get GraphDef. default_graph_def_fn: A function that returns a GraphDef. Used if `graph_def` is `None. By default, returns a pretrained InceptionV3 graph. image_size: Required image width and height. See unit tests for the default values. input_tensor: Name of input Tensor. output_tensor: Name of output Tensor. This function will compute activations at the specified layer. Examples include INCEPTION_V3_OUTPUT and INCEPTION_V3_FINAL_POOL which would result in this function computing the final logits or the penultimate pooling layer. Returns: Logits. Raises: ValueError: If images are not the correct size. ValueError: If neither `graph_def` nor `default_graph_def_fn` are provided. """ images = _validate_images(images, image_size) if graph_def is None: if default_graph_def_fn is None: raise ValueError('If `graph_def` is `None`, must provide ' '`default_graph_def_fn`.') graph_def = default_graph_def_fn() activations = run_image_classifier(images, graph_def, input_tensor, output_tensor) if tf.rank(activations) != 2: activations = flatten(activations) return activations
