Python check_ops.assert_less_equal函数代码示例

 def test_doesnt_raise_when_both_empty(self):
   larry = constant_op.constant([])
   curly = constant_op.constant([])
   with ops.control_dependencies(
       [check_ops.assert_less_equal(larry, curly)]):
     out = array_ops.identity(larry)
   self.evaluate(out)

def calculate_reshape(original_shape, new_shape, validate=False, name=None):
  """Calculates the reshaped dimensions (replacing up to one -1 in reshape)."""
  batch_shape_static = tensor_util.constant_value_as_shape(new_shape)
  if batch_shape_static.is_fully_defined():
    return np.int32(batch_shape_static.as_list()), batch_shape_static, []
  with ops.name_scope(name, "calculate_reshape", [original_shape, new_shape]):
    original_size = math_ops.reduce_prod(original_shape)
    implicit_dim = math_ops.equal(new_shape, -1)
    size_implicit_dim = (
        original_size // math_ops.maximum(1, -math_ops.reduce_prod(new_shape)))
    new_ndims = array_ops.shape(new_shape)
    expanded_new_shape = array_ops.where(  # Assumes exactly one `-1`.
        implicit_dim, array_ops.fill(new_ndims, size_implicit_dim), new_shape)
    validations = [] if not validate else [
        check_ops.assert_rank(
            original_shape, 1, message="Original shape must be a vector."),
        check_ops.assert_rank(
            new_shape, 1, message="New shape must be a vector."),
        check_ops.assert_less_equal(
            math_ops.count_nonzero(implicit_dim, dtype=dtypes.int32),
            1,
            message="At most one dimension can be unknown."),
        check_ops.assert_positive(
            expanded_new_shape, message="Shape elements must be >=-1."),
        check_ops.assert_equal(
            math_ops.reduce_prod(expanded_new_shape),
            original_size,
            message="Shape sizes do not match."),
    ]
    return expanded_new_shape, batch_shape_static, validations

 def test_doesnt_raise_when_equal(self):
   with self.test_session():
     small = constant_op.constant([1, 2], name="small")
     with ops.control_dependencies(
         [check_ops.assert_less_equal(small, small)]):
       out = array_ops.identity(small)
     out.eval()

 def test_doesnt_raise_when_less_equal_and_broadcastable_shapes(self):
   with self.test_session():
     small = constant_op.constant([1], name="small")
     big = constant_op.constant([3, 1], name="big")
     with ops.control_dependencies([check_ops.assert_less_equal(small, big)]):
       out = array_ops.identity(small)
     out.eval()

 def test_raises_when_less_equal_but_non_broadcastable_shapes(self):
   with self.test_session():
     small = constant_op.constant([1, 1, 1], name="small")
     big = constant_op.constant([3, 1], name="big")
     with self.assertRaisesRegexp(ValueError, "must be"):
       with ops.control_dependencies(
           [check_ops.assert_less_equal(small, big)]):
         out = array_ops.identity(small)
       out.eval()

 def test_raises_when_greater(self):
   small = constant_op.constant([1, 2], name="small")
   big = constant_op.constant([3, 4], name="big")
   with self.assertRaisesOpError("fail"):
     with ops.control_dependencies(
         [check_ops.assert_less_equal(
             big, small, message="fail")]):
       out = array_ops.identity(small)
     self.evaluate(out)

 def _maybe_assert_valid_y(self, y):
   if not self.validate_args:
     return y
   is_positive = check_ops.assert_non_negative(
       y, message="Inverse transformation input must be greater than 0.")
   less_than_one = check_ops.assert_less_equal(
       y, constant_op.constant(1., y.dtype),
       message="Inverse transformation input must be less than or equal to 1.")
   return control_flow_ops.with_dependencies([is_positive, less_than_one], y)

  def _maybe_check_valid_shape(self, shape, validate_args):
    """Check that a shape Tensor is int-type and otherwise sane."""
    if not shape.dtype.is_integer:
      raise TypeError("{} dtype ({}) should be `int`-like.".format(
          shape, shape.dtype.name))

    assertions = []

    ndims = array_ops.rank(shape)
    ndims_ = tensor_util.constant_value(ndims)
    if ndims_ is not None and ndims_ > 1:
      raise ValueError("`{}` rank ({}) should be <= 1.".format(
          shape, ndims_))
    elif validate_args:
      assertions.append(check_ops.assert_less_equal(
          ndims, 1, message="`{}` rank should be <= 1.".format(shape)))

    shape_ = tensor_util.constant_value_as_shape(shape)
    if shape_.is_fully_defined():
      es = np.int32(shape_.as_list())
      if sum(es == -1) > 1:
        raise ValueError(
            "`{}` must have at most one `-1` (given {})"
            .format(shape, es))
      if np.any(es < -1):
        raise ValueError(
            "`{}` elements must be either positive integers or `-1`"
            "(given {})."
            .format(shape, es))
    elif validate_args:
      assertions.extend([
          check_ops.assert_less_equal(
              math_ops.reduce_sum(
                  math_ops.cast(math_ops.equal(shape, -1), dtypes.int32)),
              1,
              message="`{}` elements must have at most one `-1`."
              .format(shape)),
          check_ops.assert_greater_equal(
              shape, -1,
              message="`{}` elements must be either positive integers or `-1`."
              .format(shape)),
      ])
    return assertions

 def _maybe_assert_valid_sample(self, counts):
   """Check counts for proper shape, values, then return tensor version."""
   if not self.validate_args:
     return counts
   counts = distribution_util.embed_check_nonnegative_integer_form(counts)
   return control_flow_ops.with_dependencies([
       check_ops.assert_less_equal(
           counts, self.total_count,
           message="counts are not less than or equal to n."),
   ], counts)

 def _maybe_assert_valid_sample(self, event, check_integer=True):
   if not self.validate_args:
     return event
   event = distribution_util.embed_check_nonnegative_discrete(
       event, check_integer=check_integer)
   return control_flow_ops.with_dependencies([
       check_ops.assert_less_equal(
           event, array_ops.ones_like(event),
           message="event is not less than or equal to 1."),
   ], event)

 def check_soundness(ff, fp):
   (sufficient_n1,
    sufficient_n2) = st.min_num_samples_for_dkwm_mean_two_sample_test(
        numbers, 0., 1., 0., 1.,
        false_fail_rate=ff, false_pass_rate=fp)
   d_fn = st.min_discrepancy_of_true_means_detectable_by_dkwm_two_sample
   detectable_d = d_fn(
       sufficient_n1, 0., 1., sufficient_n2, 0., 1.,
       false_fail_rate=ff, false_pass_rate=fp)
   return check_ops.assert_less_equal(detectable_d, numbers)

 def _maybe_assert_valid(self, x):
   if not self.validate_args:
     return x
   return control_flow_ops.with_dependencies([
       check_ops.assert_non_negative(
           x,
           message="sample must be non-negative"),
       check_ops.assert_less_equal(
           x, array_ops.ones([], self.concentration0.dtype),
           message="sample must be no larger than `1`."),
   ], x)

 def test_dkwm_design_mean_one_sample_soundness(self):
   numbers = [1e-5, 1e-2, 1.1e-1, 0.9, 1., 1.02, 2., 10., 1e2, 1e5, 1e10]
   rates = [1e-6, 1e-3, 1e-2, 1.1e-1, 0.2, 0.5, 0.7, 1.]
   with self.test_session() as sess:
     for ff in rates:
       for fp in rates:
         sufficient_n = st.min_num_samples_for_dkwm_mean_test(
             numbers, 0., 1., false_fail_rate=ff, false_pass_rate=fp)
         detectable_d = st.min_discrepancy_of_true_means_detectable_by_dkwm(
             sufficient_n, 0., 1., false_fail_rate=ff, false_pass_rate=fp)
         sess.run(check_ops.assert_less_equal(detectable_d, numbers))

 def _check_counts(self, counts):
   counts = ops.convert_to_tensor(counts, name="counts_before_deps")
   if not self.validate_args:
     return counts
   return control_flow_ops.with_dependencies([
       check_ops.assert_non_negative(
           counts, message="counts has negative components."),
       check_ops.assert_less_equal(
           counts, self._n, message="counts are not less than or equal to n."),
       distribution_util.assert_integer_form(
           counts, message="counts have non-integer components.")], counts)

def get_logits_and_prob(
    logits=None, p=None,
    multidimensional=False, validate_args=False, name="GetLogitsAndProb"):
  """Converts logits to probabilities and vice-versa, and returns both.

  Args:
    logits: Numeric `Tensor` representing log-odds.
    p: Numeric `Tensor` representing probabilities.
    multidimensional: Given `p` a [N1, N2, ... k] dimensional tensor,
      whether the last dimension represents the probability between k classes.
      This will additionally assert that the values in the last dimension
      sum to one. If `False`, will instead assert that each value is in
      `[0, 1]`.
    validate_args: `Boolean`, default `False`.  Whether to assert `0 <= p <= 1`
      if multidimensional is `False`, otherwise that the last dimension of `p`
      sums to one.
    name: A name for this operation (optional).

  Returns:
    Tuple with `logits` and `p`. If `p` has an entry that is `0` or `1`, then
    the corresponding entry in the returned logits will be `-Inf` and `Inf`
    respectively.

  Raises:
    ValueError: if neither `p` nor `logits` were passed in, or both were.
  """
  with ops.name_scope(name, values=[p, logits]):
    if p is None and logits is None:
      raise ValueError("Must pass p or logits.")
    elif p is not None and logits is not None:
      raise ValueError("Must pass either p or logits, not both.")
    elif p is None:
      logits = array_ops.identity(logits, name="logits")
      with ops.name_scope("p"):
        p = math_ops.sigmoid(logits)
    elif logits is None:
      with ops.name_scope("p"):
        p = array_ops.identity(p)
        if validate_args:
          one = constant_op.constant(1., p.dtype)
          dependencies = [check_ops.assert_non_negative(p)]
          if multidimensional:
            dependencies += [assert_close(
                math_ops.reduce_sum(p, reduction_indices=[-1]),
                one, message="p does not sum to 1.")]
          else:
            dependencies += [check_ops.assert_less_equal(
                p, one, message="p has components greater than 1.")]
          p = control_flow_ops.with_dependencies(dependencies, p)
      with ops.name_scope("logits"):
        logits = math_ops.log(p) - math_ops.log(1. - p)
    return (logits, p)