o
    ?e
(                  	   @   s   d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm	Z	 dd	lm
Z
 dd
lmZ ddlmZ ddlmZ edg dejdddejdddfddZeddgdeddddejfddZdddZdS )zbincount ops.    )constant_op)dtypes)ops)tensor)tensor_conversion)	array_ops)gen_math_ops)math_ops)deprecation)dispatch)	tf_exportzmath.bincount)v1NFc           
      C   s|  |du rdn|}t |% |s|du rt j| dtjd} tt| dk}t	|tjt
| d  }	|durIt j|dtjd}t||	}	|dur\t j|dtjd}t||	}	|durut j|d	d
}t|| |	W  d   S tg |}t| dg} t| |	|W  d   S tj| dd
} |durtj|d	d
}|dur|rtd| jjst	| tj} |du rd}|dvrtd| dt| dk}t	|| jt
| d  }	|durt j|d| jd}t||	}	|durt j|d| jd}t||	}	|dkr|durt|dg}t| dg} t| ||}tj| |	||dW  d   S 1 s7w   Y  dS )a]  Counts the number of occurrences of each value in an integer array.

  If `minlength` and `maxlength` are not given, returns a vector with length
  `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.
  If `weights` are non-None, then index `i` of the output stores the sum of the
  value in `weights` at each index where the corresponding value in `arr` is
  `i`.

  ```python
  values = tf.constant([1,1,2,3,2,4,4,5])
  tf.math.bincount(values) #[0 2 2 1 2 1]
  ```
  Vector length = Maximum element in vector `values` is 5. Adding 1, which is 6
                  will be the vector length.

  Each bin value in the output indicates number of occurrences of the particular
  index. Here, index 1 in output has a value 2. This indicates value 1 occurs
  two times in `values`.

  ```python
  values = tf.constant([1,1,2,3,2,4,4,5])
  weights = tf.constant([1,5,0,1,0,5,4,5])
  tf.math.bincount(values, weights=weights) #[0 6 0 1 9 5]
  ```
  Bin will be incremented by the corresponding weight instead of 1.
  Here, index 1 in output has a value 6. This is the summation of weights
  corresponding to the value in `values`.

  **Bin-counting on a certain axis**

  This example takes a 2 dimensional input and returns a `Tensor` with
  bincounting on each sample.

  >>> data = np.array([[1, 2, 3, 0], [0, 0, 1, 2]], dtype=np.int32)
  >>> tf.math.bincount(data, axis=-1)
  <tf.Tensor: shape=(2, 4), dtype=int32, numpy=
    array([[1, 1, 1, 1],
           [2, 1, 1, 0]], dtype=int32)>


  **Bin-counting with binary_output**

  This example gives binary output instead of counting the occurrence.

  >>> data = np.array([[1, 2, 3, 0], [0, 0, 1, 2]], dtype=np.int32)
  >>> tf.math.bincount(data, axis=-1, binary_output=True)
  <tf.Tensor: shape=(2, 4), dtype=int32, numpy=
    array([[1, 1, 1, 1],
           [1, 1, 1, 0]], dtype=int32)>

  **Missing zeros in SparseTensor**

  Note that missing zeros (implict zeros) in SparseTensor are **NOT** counted.
  This supports cases such as `0` in the values tensor indicates that index/id
  `0`is present and a missing zero indicates that no index/id is present.

  If counting missing zeros is desired, there are workarounds.
  For the `axis=0` case, the number of missing zeros can computed by subtracting
  the number of elements in the SparseTensor's `values` tensor from the
  number of elements in the dense shape, and this difference can be added to the
  first element of the output of `bincount`. For all cases, the SparseTensor
  can be converted to a dense Tensor with `tf.sparse.to_dense` before calling
  `tf.math.bincount`.

  Args:
    arr: A Tensor, RaggedTensor, or SparseTensor whose values should be counted.
      These tensors must have a rank of 2 if `axis=-1`.
    weights: If non-None, must be the same shape as arr. For each value in
      `arr`, the bin will be incremented by the corresponding weight instead of
      1.
    minlength: If given, ensures the output has length at least `minlength`,
      padding with zeros at the end if necessary.
    maxlength: If given, skips values in `arr` that are equal or greater than
      `maxlength`, ensuring that the output has length at most `maxlength`.
    dtype: If `weights` is None, determines the type of the output bins.
    name: A name scope for the associated operations (optional).
    axis: The axis to slice over. Axes at and below `axis` will be flattened
      before bin counting. Currently, only `0`, and `-1` are supported. If None,
      all axes will be flattened (identical to passing `0`).
    binary_output: If True, this op will output 1 instead of the number of times
      a token appears (equivalent to one_hot + reduce_any instead of one_hot +
      reduce_add). Defaults to False.

  Returns:
    A vector with the same dtype as `weights` or the given `dtype`. The bin
    values.

  Raises:
    `InvalidArgumentError` if negative values are provided as an input.

  Nbincountarr)namedtyper      	minlength	maxlengthweights)r   zXArguments `binary_output` and `weights` are mutually exclusive. Please specify only one.)r   r   z$Unsupported value for argument axis=z(. Only 0 and -1 are currently supported.)inputsizer   binary_output)r   Z
name_scopeZconvert_to_tensorr   int32r	   Zreduce_prodr   shapecastZ
reduce_maxr   maximumminimumZunsorted_segment_sumr   constantZreshaper   r   Z"convert_to_tensor_v2_with_dispatch
ValueErrorr   
is_integerr   validate_dense_weightsZdense_bincount)
r   r   r   r   r   r   Zaxisr   Zarray_is_nonemptyZoutput_size r#   c/home/www/facesmatcher.com/pyenv/lib/python3.10/site-packages/tensorflow/python/ops/bincount_ops.pyr      s   e


&r   c                 C   s   t | ||||S )a&  Counts the number of occurrences of each value in an integer array.

  If `minlength` and `maxlength` are not given, returns a vector with length
  `tf.reduce_max(arr) + 1` if `arr` is non-empty, and length 0 otherwise.
  If `weights` are non-None, then index `i` of the output stores the sum of the
  value in `weights` at each index where the corresponding value in `arr` is
  `i`.

  Args:
    arr: An int32 tensor of non-negative values.
    weights: If non-None, must be the same shape as arr. For each value in
      `arr`, the bin will be incremented by the corresponding weight instead of
      1.
    minlength: If given, ensures the output has length at least `minlength`,
      padding with zeros at the end if necessary.
    maxlength: If given, skips values in `arr` that are equal or greater than
      `maxlength`, ensuring that the output has length at most `maxlength`.
    dtype: If `weights` is None, determines the type of the output bins.

  Returns:
    A vector with the same dtype as `weights` or the given `dtype`. The bin
    values.
  )r   )r   r   r   r   r   r#   r#   r$   bincount_v1   s   r%   c                 C   sT   |du r|rt jg |dS t jg | jdS t|tjs(td| dt|j |S )z;Validates the passed weight tensor or creates an empty one.N)r   zTArgument `weights` must be a tf.Tensor if `values` is a tf.Tensor. Received weights=z
 of type: )	r   r   r   
isinstancer   ZTensorr    type__name__)valuesr   r   r#   r#   r$   r"      s   r"   )N)__doc__Ztensorflow.python.frameworkr   r   r   r   r   Ztensorflow.python.opsr   r   r	   Ztensorflow.python.utilr
   r   Z tensorflow.python.util.tf_exportr   Zadd_dispatch_supportr   r   Zdeprecated_endpointsr%   r"   r#   r#   r#   r$   <module>   s>   
 (