我们从Python开源项目中，提取了以下11个代码示例，用于说明如何使用tensorflow.assert_rank()。
def assert_scalar(tensor, name): """ Whether the `tensor` is a scalar (0-D tensor). :param tensor: A tensor to be checked. :param name: The name of `tensor` for error message. :return: The checked tensor. """ static_shape = tensor.get_shape() shape_err_msg = name + " should be a scalar (0-D tensor)." if static_shape and (static_shape.ndims >= 1): raise ValueError(shape_err_msg) else: _assert_shape_op = tf.assert_rank(tensor, 0, message=shape_err_msg) with tf.control_dependencies([_assert_shape_op]): tensor = tf.identity(tensor) return tensor
def __init__(self, dtype, param_dtype, is_continuous, is_reparameterized, use_path_derivative=False, group_ndims=0, **kwargs): if 'group_event_ndims' in kwargs: warnings.warn( "The argument `group_event_ndims` has been deprecated and " "will be removed in the coming version (0.3.1). Please use " "`group_ndims` instead.", FutureWarning) group_ndims = kwargs['group_event_ndims'] self._dtype = dtype self._param_dtype = param_dtype self._is_continuous = is_continuous self._is_reparameterized = is_reparameterized self._use_path_derivative = use_path_derivative if isinstance(group_ndims, int): if group_ndims < 0: raise ValueError("group_ndims must be non-negative.") self._group_ndims = group_ndims else: group_ndims = tf.convert_to_tensor(group_ndims, tf.int32) _assert_rank_op = tf.assert_rank( group_ndims, 0, message="group_ndims should be a scalar (0-D Tensor).") _assert_nonnegative_op = tf.assert_greater_equal( group_ndims, 0, message="group_ndims must be non-negative.") with tf.control_dependencies([_assert_rank_op, _assert_nonnegative_op]): self._group_ndims = tf.identity(group_ndims)
def sample(self, n_samples=None): """ sample(n_samples=None) Return samples from the distribution. When `n_samples` is None (by default), one sample of shape ``batch_shape + value_shape`` is generated. For a scalar `n_samples`, the returned Tensor has a new sample dimension with size `n_samples` inserted at ``axis=0``, i.e., the shape of samples is ``[n_samples] + batch_shape + value_shape``. :param n_samples: A 0-D `int32` Tensor or None. How many independent samples to draw from the distribution. :return: A Tensor of samples. """ if n_samples is None: samples = self._sample(n_samples=1) return tf.squeeze(samples, axis=0) elif isinstance(n_samples, int): return self._sample(n_samples) else: n_samples = tf.convert_to_tensor(n_samples, dtype=tf.int32) _assert_rank_op = tf.assert_rank( n_samples, 0, message="n_samples should be a scalar (0-D Tensor).") with tf.control_dependencies([_assert_rank_op]): samples = self._sample(n_samples) return samples
def assert_positive_integer(value, dtype, name): """ Whether `value` is a scalar (or 0-D tensor) and positive. If `value` is the instance of built-in type, it will be checked directly. Otherwise, it will be converted to a `dtype` tensor and checked. :param value: The value to be checked. :param dtype: The tensor dtype. :param name: The name of `value` used in error message. :return: The checked value. """ sign_err_msg = name + " must be positive" if isinstance(value, (int, float)): if value <= 0: raise ValueError(sign_err_msg) return value else: try: tensor = tf.convert_to_tensor(value, dtype) except ValueError: raise TypeError(name + ' must be ' + str(dtype)) _assert_rank_op = tf.assert_rank( tensor, 0, message=name + " should be a scalar (0-D Tensor).") _assert_positive_op = tf.assert_greater( tensor, tf.constant(0, dtype), message=sign_err_msg) with tf.control_dependencies([_assert_rank_op, _assert_positive_op]): tensor = tf.identity(tensor) return tensor
def test_model_inputs(model_inputs): with tf.Graph().as_default(): input_data, targets, lr, keep_prob = model_inputs() # Check type assert input_data.op.type == 'Placeholder',\ 'Input is not a Placeholder.' assert targets.op.type == 'Placeholder',\ 'Targets is not a Placeholder.' assert lr.op.type == 'Placeholder',\ 'Learning Rate is not a Placeholder.' assert keep_prob.op.type == 'Placeholder', \ 'Keep Probability is not a Placeholder.' # Check name assert input_data.name == 'input:0',\ 'Input has bad name. Found name {}'.format(input_data.name) assert keep_prob.name == 'keep_prob:0', \ 'Keep Probability has bad name. Found name {}'.format(keep_prob.name) assert tf.assert_rank(input_data, 2, message='Input data has wrong rank') assert tf.assert_rank(targets, 2, message='Targets has wrong rank') assert tf.assert_rank(lr, 0, message='Learning Rate has wrong rank') assert tf.assert_rank(keep_prob, 0, message='Keep Probability has wrong rank') _print_success_message()
def _assert_tensor_shape(tensor, shape, display_name): assert tf.assert_rank(tensor, len(shape), message='{} has wrong rank'.format(display_name)) tensor_shape = tensor.get_shape().as_list() if len(shape) else [] wrong_dimension = [ten_dim for ten_dim, cor_dim in zip(tensor_shape, shape) if cor_dim is not None and ten_dim != cor_dim] assert not wrong_dimension, \ '{} has wrong shape. Found {}'.format(display_name, tensor_shape)
def kl_divergence(p, q): tf.assert_rank(p,2) tf.assert_rank(q,2) p_shape = tf.shape(p) q_shape = tf.shape(q) tf.assert_equal(p_shape, q_shape) # normalize sum to 1 p_ = tf.divide(p, tf.tile(tf.expand_dims(tf.reduce_sum(p,axis=1), 1), [1,p_shape[1]])) q_ = tf.divide(q, tf.tile(tf.expand_dims(tf.reduce_sum(q,axis=1), 1), [1,p_shape[1]])) return tf.reduce_sum(tf.multiply(p_, tf.log(tf.divide(p_, q_))), axis=1)
def ensureRank2(input): """Ensures the input tensor has a rank of 2, otherwise it reshapes the tensor""" if (len(input.get_shape()) == 3): input = tf.reshape(input, ([-1, int(input.get_shape()[1])])) tf.assert_rank(input, 2, message="Tensor is not rank 2") return input
def ensureRank3(input): """Ensures the input tensor has a rank of 3, otherwise it reshapes the tensor""" if (len(input.get_shape()) == 2): input = tf.expand_dims(input, 2) tf.assert_rank(input, 3, message="Tensor is not rank 3") return input
def __init__(self, logits, n_experiments, dtype=None, group_ndims=0, check_numerics=False, **kwargs): self._logits = tf.convert_to_tensor(logits) param_dtype = assert_same_float_dtype( [(self._logits, 'Binomial.logits')]) if dtype is None: dtype = tf.int32 assert_same_float_and_int_dtype([], dtype) sign_err_msg = "n_experiments must be positive" if isinstance(n_experiments, int): if n_experiments <= 0: raise ValueError(sign_err_msg) self._n_experiments = n_experiments else: try: n_experiments = tf.convert_to_tensor(n_experiments, tf.int32) except ValueError: raise TypeError('n_experiments must be int32') _assert_rank_op = tf.assert_rank( n_experiments, 0, message="n_experiments should be a scalar (0-D Tensor).") _assert_positive_op = tf.assert_greater( n_experiments, 0, message=sign_err_msg) with tf.control_dependencies([_assert_rank_op, _assert_positive_op]): self._n_experiments = tf.identity(n_experiments) self._check_numerics = check_numerics super(Binomial, self).__init__( dtype=dtype, param_dtype=param_dtype, is_continuous=False, is_reparameterized=False, group_ndims=group_ndims, **kwargs)
def op(name, images, max_outputs=3, display_name=None, description=None, collections=None): """Create an image summary op for use in a TensorFlow graph. Arguments: name: A unique name for the generated summary node. images: A `Tensor` representing pixel data with shape `[k, w, h, c]`, where `k` is the number of images, `w` and `h` are the width and height of the images, and `c` is the number of channels, which should be 1, 3, or 4. Any of the dimensions may be statically unknown (i.e., `None`). max_outputs: Optional `int` or rank-0 integer `Tensor`. At most this many images will be emitted at each step. When more than `max_outputs` many images are provided, the first `max_outputs` many images will be used and the rest silently discarded. display_name: Optional name for this summary in TensorBoard, as a constant `str`. Defaults to `name`. description: Optional long-form description for this summary, as a constant `str`. Markdown is supported. Defaults to empty. collections: Optional list of graph collections keys. The new summary op is added to these collections. Defaults to `[Graph Keys.SUMMARIES]`. Returns: A TensorFlow summary op. """ if display_name is None: display_name = name summary_metadata = metadata.create_summary_metadata( display_name=display_name, description=description) with tf.name_scope(name), \ tf.control_dependencies([tf.assert_rank(images, 4), tf.assert_type(images, tf.uint8), tf.assert_non_negative(max_outputs)]): limited_images = images[:max_outputs] encoded_images = tf.map_fn(tf.image.encode_png, limited_images, dtype=tf.string, name='encode_each_image') image_shape = tf.shape(images) dimensions = tf.stack([tf.as_string(image_shape[1], name='width'), tf.as_string(image_shape[2], name='height')], name='dimensions') tensor = tf.concat([dimensions, encoded_images], axis=0) return tf.summary.tensor_summary(name='image_summary', tensor=tensor, collections=collections, summary_metadata=summary_metadata)
