Python tensorflow.is_tensor() Examples

def __init__(self, bits=8, stochastic=True):
    """Initializer for the PerChannelUniformQuantizationEncodingStage.

    Args:
      bits: The number of bits to quantize to. Must be an integer between 1 and
        16. Can be either a TensorFlow or a Python value.
      stochastic: A Python bool, whether to use stochastic or deterministic
        rounding. If `True`, the encoding is randomized and on expectation
        unbiased. If `False`, the encoding is deterministic.

    Raises:
      ValueError: The inputs do not satisfy the above constraints.
    """
    if (not tf.is_tensor(bits) and bits not in self._ALLOWED_BITS_ARG):
      raise ValueError('The bits argument must be an integer between 1 and 16.')
    self._bits = bits

    if not isinstance(stochastic, bool):
      raise TypeError('The stochastic argument must be a bool.')
    self._stochastic = stochastic 

def _decode_after_sum_impl(self, encoded_tensors, decode_params, num_summands,
                             shape):
    """Implementation for the `decode_after_sum` method."""
    if not self.stage.commutes_with_sum:
      # This should have been decoded earlier in the decode_before_sum method.
      assert tf.is_tensor(encoded_tensors)
      return encoded_tensors

    temp_encoded_tensors = {}
    for key, value in six.iteritems(encoded_tensors):
      if key in self.children:
        with tf.compat.v1.name_scope(None, '/'.join([self.stage.name, key])):
          temp_encoded_tensors[key] = self.children[key]._decode_after_sum_impl(  # pylint: disable=protected-access
              value, decode_params[EncoderKeys.CHILDREN][key], num_summands,
              shape[EncoderKeys.CHILDREN][key])
      else:
        temp_encoded_tensors[key] = value
    return self.stage.decode(temp_encoded_tensors,
                             decode_params[EncoderKeys.PARAMS],
                             num_summands=num_summands,
                             shape=shape[EncoderKeys.SHAPE]) 

def maybe_evaluate(self, fetches, session=None):
    """Evaluates `fetches`, if containing any `Tensor` objects.

    Args:
      fetches: Any nested structure compatible with `tf.nest`.
      session: Optional. A `tf.Session` object in the context of which the
        evaluation is to happen.

    Returns:
      `fetches` with any `Tensor` objects replaced by numpy values.
    """
    if any((tf.is_tensor(t) for t in tf.nest.flatten(fetches))):
      if session:
        fetches = session.run(fetches)
      else:
        fetches = self.evaluate(fetches)
    return fetches 

def state_aegmm(od: OutlierAEGMM) -> Dict:
    """
    OutlierAEGMM parameters to save.

    Parameters
    ----------
    od
        Outlier detector object.
    """
    if not all(tf.is_tensor(_) for _ in [od.phi, od.mu, od.cov, od.L, od.log_det_cov]):
        logger.warning('Saving AEGMM detector that has not been fit.')

    state_dict = {'threshold': od.threshold,
                  'n_gmm': od.aegmm.n_gmm,
                  'recon_features': od.aegmm.recon_features,
                  'phi': od.phi,
                  'mu': od.mu,
                  'cov': od.cov,
                  'L': od.L,
                  'log_det_cov': od.log_det_cov}
    return state_dict 

def state_vaegmm(od: OutlierVAEGMM) -> Dict:
    """
    OutlierVAEGMM parameters to save.

    Parameters
    ----------
    od
        Outlier detector object.
    """
    if not all(tf.is_tensor(_) for _ in [od.phi, od.mu, od.cov, od.L, od.log_det_cov]):
        logger.warning('Saving VAEGMM detector that has not been fit.')

    state_dict = {'threshold': od.threshold,
                  'samples': od.samples,
                  'n_gmm': od.vaegmm.n_gmm,
                  'latent_dim': od.vaegmm.latent_dim,
                  'beta': od.vaegmm.beta,
                  'recon_features': od.vaegmm.recon_features,
                  'phi': od.phi,
                  'mu': od.mu,
                  'cov': od.cov,
                  'L': od.L,
                  'log_det_cov': od.log_det_cov}
    return state_dict 

def static_or_dynamic_shape(value):
  """Returns shape of the input `Tensor` or a `np.ndarray`.

  If `value` is a `np.ndarray` or a `Tensor` with statically known shape, it
  returns a Python object. Otherwise, returns result of `tf.shape(value)`.

  Args:
    value: A `Tensor` or a `np.ndarray` object.

  Returns:
    Static or dynamic shape of `value`.

  Raises:
    TypeError:
      If the input is not a `Tensor` or a `np.ndarray` object.
  """
  if tf.is_tensor(value):
    return value.shape if value.shape.is_fully_defined() else tf.shape(value)
  elif isinstance(value, np.ndarray):
    return value.shape
  else:
    raise TypeError('The provided input is not a Tensor or numpy array.') 

def is_scalar(tensor):
  """Returns True iff the given tensor is a scalar.

  Args:
    tensor: The tensor to test for being a scalar.

  Returns:
    True if 'tensor' is a scalar, i.e. all dims are 1, False otherwise.

  Raises:
    TypeError: when the argument is not a tensor.
  """
  if not tf.is_tensor(tensor):
    raise TypeError('Expected a tensor, found "{}".'.format(
        py_typecheck.type_string(type(tensor))))
  return (hasattr(tensor, 'get_shape') and
          all(dim == 1 for dim in tensor.get_shape())) 

def _detokenize(self, tokens, sequence_length):
    if isinstance(tokens, tf.RaggedTensor):
      rank = len(tokens.shape)
      if rank == 1:
        return self._detokenize_tensor(tokens.values)
      elif rank == 2:
        return self._detokenize_ragged_tensor(tokens)
      else:
        raise ValueError("Unsupported RaggedTensor rank %d for detokenization" % rank)
    elif tf.is_tensor(tokens):
      rank = len(tokens.shape)
      if rank == 1:
        return self._detokenize_tensor(tokens)
      elif rank == 2:
        if sequence_length is None:
          raise ValueError("sequence_length is required for Tensor detokenization")
        return self._detokenize_batch_tensor(tokens, sequence_length)
      else:
        raise ValueError("Unsupported tensor rank %d for detokenization" % rank)
    elif isinstance(tokens, list) and tokens and isinstance(tokens[0], list):
      return list(map(self.detokenize, tokens))
    else:
      tokens = [tf.compat.as_text(token) for token in tokens]
      return self._detokenize_string(tokens) 

def __eq__(self, other):
    if not isinstance(other, _StaticExplicitDeferredTensorState):
      return False
    if self.auto_cast != other.auto_cast:
      return False

    # If at least one of the objects is a Tensor, then we check that they're the
    # same object, instead of calling __eq__.
    #
    # In eager mode, we could potentially check for value-equality, by using the
    # np.array_equal() code below after *explicitly* casting the Tensors to
    # numpy arrays by calling Tensor.numpy(). This would probably be a bad idea,
    # though, since if the Tensor is actually a tf.Variable, its value could
    # change in the future.
    if tf.is_tensor(self.value) or tf.is_tensor(other.value):
      return self.value is other.value

    # Every other allowed type can be handled by numpy.
    #
    # We can hope that in most cases, this will be quick (e.g. same object -->
    # equal, different shapes --> unequal), but if we're unlucky, this has the
    # potential to be slow.
    return np.array_equal(self.value, other.value) 

def __init__(self, value, auto_cast):
    """Creates a new `_StaticExplicitDeferredTensorState`.

    Args:
      value: `Tensor`-like, the value of the `DeferredTensor`.
      auto_cast: `Boolean`, whether the value should be automatically
        type-promoted, if necessary. Only applies if "value" is a `Tensor`:
          non-`Tensor` types are always auto-castable.
    """
    assert not callable(value)
    self._value = value
    self._auto_cast = auto_cast

    # For non-Tensor types, we make a deep copy to make extra-certain that it is
    # immutable (since we'll hash it).
    if not tf.is_tensor(self._value):
      self._value = copy.deepcopy(self._value)

    # We memoize the hash, since it can be expensive to compute.
    self._hash = None 

def assert_state_is_compatible(expected_state, state):
  """Asserts that states are compatible.

  Args:
    expected_state: The reference state.
    state: The state that must be compatible with :obj:`expected_state`.

  Raises:
    ValueError: if the states are incompatible.
  """
  # Check structure compatibility.
  tf.nest.assert_same_structure(expected_state, state)

  # Check shape compatibility.
  expected_state_flat = tf.nest.flatten(expected_state)
  state_flat = tf.nest.flatten(state)

  for x, y in zip(expected_state_flat, state_flat):
    if tf.is_tensor(x):
      expected_depth = x.shape[-1]
      depth = y.shape[-1]
      if depth != expected_depth:
        raise ValueError("Tensor in state has shape %s which is incompatible "
                         "with the target shape %s" % (y.shape, x.shape)) 

def _convert_to_binary_classification_predictions(predictions):
  """Converts a `Tensor` into a set of binary classification predictions.

  This function checks that the given `Tensor` is floating-point, and that it is
  trivially convertible to rank-1, i.e. has only one "nontrivial" dimension
  (e.g. the shapes [1000] and [1, 1, None, 1] are allowed, but [None, 1, None]
  and [50, 10] are not). If it satisfies these conditions, then it is reshaped
  to be rank-1 (if necessary) and returned.

  Args:
    predictions: a rank-1 floating-point `Tensor` of predictions.

  Returns:
    The predictions `Tensor`, reshaped to be rank-1, if necessary.

  Raises:
    TypeError: if "predictions" is not a floating-point `Tensor`.
    ValueError: if "predictions" is not trivially convertible to rank-1.
  """
  if not tf.is_tensor(predictions):
    raise TypeError("predictions must be a Tensor")
  if not predictions.dtype.is_floating:
    raise TypeError("predictions must be floating-point")

  return helpers.convert_to_1d_tensor(predictions, name="predictions") 

def __call__(self, audio=None, sr=None, speed=1.0):
        """extract feature from audo data
        :param audio data or audio file
        :sr sample rate
        :return feature
        """

        if audio is not None and not tf.is_tensor(audio):
            audio = tf.convert_to_tensor(audio)
        if sr is not None and not tf.is_tensor(sr):
            sr = tf.convert_to_tensor(sr)

        return self.__impl(audio, sr, speed) 

def is_tensor_or_variable(x):
    return tf.is_tensor(x) or isinstance(x, tf.Variable) 

def identity(source):
  """Applies `tf.identity` pointwise to `source`.

  This utility function provides the exact same behavior as `tf.identity`, but
  it generalizes to a wider class of objects, including ordinary tensors,
  variables, as well as various types of nested structures. It would typically
  be used together with `tf.control_dependencies` in non-eager TensorFlow.

  Args:
    source: A nested structure composed of tensors or variables embedded in
      containers that are compatible with `tf.nest`, or instances of
      `anonymous_tuple.AnonymousTuple`. Elements that represent variables have
      their content extracted prior to identity mapping by first invoking
      `tf.Variable.read_value`.

  Returns:
    The result of applying `tf.identity` to read all elements of the `source`
    pointwise, with the same structure as `source`.

  Raises:
    TypeError: If types mismatch.
  """

  def _mapping_fn(x):
    if not tf.is_tensor(x):
      raise TypeError('Expected a tensor, found {}.'.format(
          py_typecheck.type_string(type(x))))
    if hasattr(x, 'read_value'):
      x = x.read_value()
    return tf.identity(x)

  # TODO(b/113112108): Extend this to containers of mixed types.
  if isinstance(source, anonymous_tuple.AnonymousTuple):
    return anonymous_tuple.map_structure(_mapping_fn, source)
  else:
    return tf.nest.map_structure(_mapping_fn, source) 

def evaluate(self, value):
    if tf.is_tensor(value):
      return super().evaluate(value)
    elif isinstance(value, (np.ndarray, np.number)):
      return value
    else:
      raise TypeError('Cannot evaluate value of type `{!s}`.'.format(
          type(value))) 

def create_eval_metrics_tuple(fn, kwargs):
  """Creates TPU eval metrics tuple.

  Helper function to make eval_metric tuple (eval_metric_fn, fn_kwargs) used
  by `TPUEstimator`. TPUEstimator requires that `eval_metric_fn` take
  exclusively Tensor arguments. This helper can help create such a function from
  a more generic function that can take both Tensor and non-Tensor arguments.

  Args:
    fn: A eval_metric_fn that takes both Tensor and non-Tensor arguments. This
      function must return a dict of form
        {'metric name': (metric_tensor, eval_op)}
    kwargs: Dict of arguments for `fn`.

  Returns:
    `eval_metric` tuple that can be passed to a `model_fn._TPUEstimatorSpec`.
  """
  tensor_kwargs = {}
  nontensor_kwargs = {}
  for k, v in six.iteritems(kwargs):
    if tf.is_tensor(v):
      tensor_kwargs[k] = v
    else:
      nontensor_kwargs[k] = v

  def _fn(**tensors):
    return fn(**dict(nontensor_kwargs, **tensors))

  return (_fn, tensor_kwargs) 

def test_deserialize_and_call_tf_computation_with_add_one(self):
    identity_type = computation_types.TensorType(tf.int32)
    identity_fn = building_block_factory.create_compiled_identity(identity_type)
    init_op, result = tensorflow_deserialization.deserialize_and_call_tf_computation(
        identity_fn.proto, tf.constant(10), tf.compat.v1.get_default_graph())
    self.assertTrue(tf.is_tensor(result))
    with tf.compat.v1.Session() as sess:
      if init_op:
        sess.run(init_op)
      result_val = sess.run(result)
    self.assertEqual(result_val, 10) 

def _assert_binding_matches_type_and_value(self, binding, type_spec, val,
                                             graph):
    """Asserts that 'bindings' matches the given type, value, and graph."""
    self.assertIsInstance(binding, pb.TensorFlow.Binding)
    self.assertIsInstance(type_spec, computation_types.Type)
    binding_oneof = binding.WhichOneof('binding')
    if binding_oneof == 'tensor':
      self.assertTrue(tf.is_tensor(val))
      if not isinstance(val, tf.Variable):
        # We insert a read_value() op for Variables, which produces
        # a name we don't control. Otherwise, names should match:
        self.assertEqual(binding.tensor.tensor_name, val.name)
      self.assertIsInstance(type_spec, computation_types.TensorType)
      self.assertEqual(type_spec.dtype, val.dtype.base_dtype)
      self.assertEqual(repr(type_spec.shape), repr(val.shape))
    elif binding_oneof == 'sequence':
      self.assertIsInstance(val,
                            type_conversions.TF_DATASET_REPRESENTATION_TYPES)
      sequence_oneof = binding.sequence.WhichOneof('binding')
      self.assertEqual(sequence_oneof, 'variant_tensor_name')
      variant_tensor = graph.get_tensor_by_name(
          binding.sequence.variant_tensor_name)
      op = str(variant_tensor.op.type)
      self.assertTrue((op == 'Placeholder') or ('Dataset' in op))
      self.assertEqual(variant_tensor.dtype, tf.variant)
      self.assertIsInstance(type_spec, computation_types.SequenceType)
      self.assertEqual(
          computation_types.to_type(val.element_spec), type_spec.element)
    elif binding_oneof == 'tuple':
      self.assertIsInstance(type_spec, computation_types.NamedTupleType)
      if not isinstance(val, (list, tuple, anonymous_tuple.AnonymousTuple)):
        self.assertIsInstance(val, dict)
        if isinstance(val, collections.OrderedDict):
          val = list(val.values())
        else:
          val = [v for _, v in sorted(val.items())]
      for idx, e in enumerate(anonymous_tuple.to_elements(type_spec)):
        self._assert_binding_matches_type_and_value(binding.tuple.element[idx],
                                                    e[1], val[idx], graph)
    else:
      self.fail('Unknown binding.') 

def init_od_aegmm(state_dict: Dict,
                  aegmm: tf.keras.Model) -> OutlierAEGMM:
    """
    Initialize OutlierAEGMM.

    Parameters
    ----------
    state_dict
        Dictionary containing the parameter values.
    aegmm
        Loaded AEGMM.

    Returns
    -------
    Initialized OutlierAEGMM instance.
    """
    od = OutlierAEGMM(threshold=state_dict['threshold'],
                      aegmm=aegmm)
    od.phi = state_dict['phi']
    od.mu = state_dict['mu']
    od.cov = state_dict['cov']
    od.L = state_dict['L']
    od.log_det_cov = state_dict['log_det_cov']

    if not all(tf.is_tensor(_) for _ in [od.phi, od.mu, od.cov, od.L, od.log_det_cov]):
        logger.warning('Loaded AEGMM detector has not been fit.')

    return od 

def init_od_vaegmm(state_dict: Dict,
                   vaegmm: tf.keras.Model) -> OutlierVAEGMM:
    """
    Initialize OutlierVAEGMM.

    Parameters
    ----------
    state_dict
        Dictionary containing the parameter values.
    vaegmm
        Loaded VAEGMM.

    Returns
    -------
    Initialized OutlierVAEGMM instance.
    """
    od = OutlierVAEGMM(threshold=state_dict['threshold'],
                       vaegmm=vaegmm,
                       samples=state_dict['samples'])
    od.phi = state_dict['phi']
    od.mu = state_dict['mu']
    od.cov = state_dict['cov']
    od.L = state_dict['L']
    od.log_det_cov = state_dict['log_det_cov']

    if not all(tf.is_tensor(_) for _ in [od.phi, od.mu, od.cov, od.L, od.log_det_cov]):
        logger.warning('Loaded VAEGMM detector has not been fit.')

    return od 

def __call__(self, audio=None, sr=None, speed=1.0):
        """extract feature from audo data
        :param audio data or audio file
        :sr sample rate
        :return feature
        """

        if audio is not None and not tf.is_tensor(audio):
            audio = tf.convert_to_tensor(audio)
        if sr is not None and not tf.is_tensor(sr):
            sr = tf.convert_to_tensor(sr)

        return self.__impl(audio, sr, speed) 

def _create_eval_metrics_tuple(fn, kwargs):
  """Creates TPU eval metrics tuple.

  Helper function to make eval_metric tuple (eval_metric_fn, fn_kwargs) used
  by `TPUEstimator`. TPUEstimator requires that `eval_metric_fn` take
  exclusively Tensor arguments. This helper can help create such a function from
  a more generic function that can take both Tensor and non-Tensor arguments.

  Args:
    fn: A eval_metric_fn that takes both Tensor and non-Tensor arguments. This
      function must return a dict of form
        {'metric name': (metric_tensor, eval_op)}
    kwargs: Dict of arguments for `fn`.

  Returns:
    `eval_metric` tuple that can be passed to a `model_fn._TPUEstimatorSpec`.
  """
  tensor_kwargs = {}
  nontensor_kwargs = {}
  for k, v in six.iteritems(kwargs):
    if tf.is_tensor(v):
      tensor_kwargs[k] = v
    else:
      nontensor_kwargs[k] = v

  def _fn(**tensors):
    return fn(**dict(nontensor_kwargs, **tensors))

  return (_fn, tensor_kwargs) 

def _convert_tensor(x):
  """Create or cast tensor if needed."""
  if not tf.is_tensor(x):
    # x is a numpy array
    x = tf.compat.v1.convert_to_tensor_or_sparse_tensor(x)
  return x 

def run(self, tensor, feed_dict=None):
    """Evaluates the given `Tensor`.

    Unlike `tf.Session.run()`, this method expects a single `Tensor` argument
    (i.e. not a list of `Tensor`s or any other more complex structure).

    Args:
      tensor: the `Tensor` to evaluate, or a nullary function returning a
        `Tensor`.
      feed_dict: dict mapping placeholder `Tensor`s to their desired values.

    Returns:
      The value of the given `Tensor`.

    Raises:
      TypeError: if (i) the given tensor is neither a `Tensor` nor a nullary
        function returning a `Tensor`, or (ii) we're given a feed_dict but the
        tensor argument is not callable.
    """
    if callable(tensor):
      tensor = tensor()
    elif feed_dict:
      raise TypeError("if a feed_dict is provided to run(), then the tensor "
                      "argument must be a nullary function returning a Tensor")

    if not tf.is_tensor(tensor):
      raise TypeError("_GraphWrappedSession.run expects a Tensor argument, "
                      "or a nullary function returning a Tensor")

    return self._session.run(tensor, feed_dict=feed_dict) 

def _tokenize(self, text):
    if tf.is_tensor(text):
      rank = len(text.shape)
      if rank == 0:
        return self._tokenize_tensor(text)
      elif rank == 1:
        return self._tokenize_batch_tensor(text)
      else:
        raise ValueError("Unsupported tensor rank %d for tokenization" % rank)
    elif isinstance(text, list):
      return list(map(self.tokenize, text))
    else:
      text = tf.compat.as_text(text)
      return self._tokenize_string(text) 

def _process_inputs(call_inputs):
        _basic_usage = (
            "OutputDistributionMatchingLossLayer should be called with a list of length 3, where:\n "
            " - the first element contains a tensor that will be returned as is,\n"
            " - the second argument contains the logits of the teacher,\n"
            " - and the third the logits of the student.\n\n Instead, it was called with: "
        )
        if isinstance(call_inputs, list):
            if len(call_inputs) == 3 and all([tf.is_tensor(ci) for ci in call_inputs]):
                return tuple(call_inputs)
            raise ValueError(_basic_usage + str([type(ci) for ci in call_inputs]))
        else:
            raise ValueError(_basic_usage + str(type(call_inputs))) 

def _apply_gradients(self, gradients, scale=1):
    """Applies the gradients."""
    gradient_scale = scale * self.num_replicas
    if tf.is_tensor(gradient_scale) or gradient_scale != 1:
      gradients = [
          self._all_reduce_sum(gradient / tf.cast(gradient_scale, gradient.dtype))
          for gradient in gradients]
    self._optimizer.apply_gradients(list(zip(gradients, self._model.trainable_variables))) 

def get_num_columns_of_2d_tensor(tensor, name="tensor"):
  """Gets the number of columns of a rank-two `Tensor`.

  Args:
    tensor: a rank-2 `Tensor` with a known number of columns.
    name: str, how to refer to the tensor in error messages.

  Returns:
    The number of columns in the tensor.

  Raises:
    TypeError: if "tensor" is not a `Tensor`.
    ValueError: if "tensor" is not a rank-2 `Tensor` with a known number of
      columns.
  """
  if not tf.is_tensor(tensor):
    raise TypeError("%s must be a Tensor" % name)

  dims = tensor.shape.dims
  if dims is None:
    raise ValueError("%s must have a known rank" % name)
  if len(dims) != 2:
    raise ValueError("%s must be rank 2 (it is rank %d)" % (name, len(dims)))

  columns = dims[1].value
  if columns is None:
    raise ValueError("%s must have a known number of columns" % name)

  return columns 

def __init__(self, *args, pad_values=0.0, **kwargs):
        self.pad_values = pad_values
        super().__init__(*args, **kwargs)
        self._is_native_padding = self.padding != "same" or (
            not tf.is_tensor(self.pad_values) and self.pad_values == 0.0
        )