예제 #1
0
 def _assert_non_singular(self):
     """Private default implementation of _assert_non_singular."""
     logging.warn(
         "Using (possibly slow) default implementation of assert_non_singular."
         "  Requires conversion to a dense matrix and O(N^3) operations.")
     if self._can_use_cholesky():
         return self.assert_positive_definite()
     else:
         singular_values = linalg_ops.svd(self.to_dense(), compute_uv=False)
         # TODO(langmore) Add .eig and .cond as methods.
         cond = (math_ops.reduce_max(singular_values, axis=-1) /
                 math_ops.reduce_min(singular_values, axis=-1))
         return check_ops.assert_less(
             cond,
             self._max_condition_number_to_be_non_singular(),
             message="Singular matrix up to precision epsilon.")
예제 #2
0
def assert_no_entries_with_modulus_zero(
    x, message=None, name="assert_no_entries_with_modulus_zero"):
  """Returns `Op` that asserts Tensor `x` has no entries with modulus zero.

  Args:
    x:  Numeric `Tensor`, real, integer, or complex.
    message:  A string message to prepend to failure message.
    name:  A name to give this `Op`.

  Returns:
    An `Op` that asserts `x` has no entries with modulus zero.
  """
  with ops.name_scope(name, values=[x]):
    x = ops.convert_to_tensor(x, name="x")
    dtype = x.dtype
    should_be_nonzero = math_ops.abs(x)
    zero = ops.convert_to_tensor(0, dtype=dtypes.real_dtype(dtype))
    return check_ops.assert_less(zero, should_be_nonzero, message=message)
예제 #3
0
    def assert_hermitian_spectrum(self, name="assert_hermitian_spectrum"):
        """Returns an `Op` that asserts this operator has Hermitian spectrum.

    This operator corresponds to a real-valued matrix if and only if its
    spectrum is Hermitian.

    Args:
      name:  A name to give this `Op`.

    Returns:
      An `Op` that asserts this operator has Hermitian spectrum.
    """
        eps = np.finfo(dtypes.real_dtype(self.dtype)).eps
        with self._name_scope(name):  # pylint: disable=not-callable
            # Assume linear accumulation of error.
            max_err = eps * self.domain_dimension_tensor()
            imag_convolution_kernel = math_ops.imag(self.convolution_kernel())
            return check_ops.assert_less(math_ops.abs(imag_convolution_kernel),
                                         max_err,
                                         message="Spectrum was not Hermitian")