o ?e4A@sdZddlZddlZddlZddlmZddlmZddl m Z ddl m Z ddl m Z ddl mZdd l mZdd l mZdd l mZdd l mZdd l mZddl mZddlmZddlmZddlmZddlmZddlmZGddde jZ edGdddej!ej"e j#Z!e$dgdZ%edGdddej&Z'e(e)e'ej*j+edgdd)ddZ,   d*d d!Z-   d*d"d#Z.d)d$d%Z/d&Z0d*d'd(Z1e2e!e1dS)+zIndexed slices.N) struct_pb2)tf2)context)composite_tensor)composite_tensor_gradient)dtypes)ops)tensor_conversion_registry) tensor_shape) tensor_spec) tensor_util) type_spec) gen_math_ops)nested_structure_coder)internal)collections_abc) tf_exportc@s eZdZdZddZddZdS)$IndexedSlicesCompositeTensorGradientz*CompositeTensorGradient for IndexedSlices.cCs|SNselfvaluerrk/home/www/facesmatcher.com/pyenv/lib/python3.10/site-packages/tensorflow/python/framework/indexed_slices.pyget_gradient_components.z> D0`. The values in `indices` are the indices in the first dimension of the slices that have been extracted from the larger tensor. The dense tensor `dense` represented by an `IndexedSlices` `slices` has ```python dense[slices.indices[i], :, :, :, ...] = slices.values[i, :, :, :, ...] ``` The `IndexedSlices` class is used principally in the definition of gradients for operations that have sparse gradients (e.g. `tf.gather`). >>> v = tf.Variable([[0.,1, 2], [2, 3, 4], [4, 5, 6], [6, 7, 8]]) >>> with tf.GradientTape() as tape: ... r = tf.gather(v, [1,3]) >>> index_slices = tape.gradient(r,v) >>> index_slices <...IndexedSlices object ...> >>> index_slices.indices.numpy() array([1, 3], dtype=int32) >>> index_slices.values.numpy() array([[1., 1., 1.], [1., 1., 1.]], dtype=float32) Contrast this representation with `tf.sparse.SparseTensor`, which uses multi-dimensional indices and scalar values. NcCs||_||_||_dS)zCreates an `IndexedSlices`.N)_values_indices _dense_shape)rvaluesindices dense_shaperrr__init__bs zIndexedSlices.__init__cC|jS)z/A `Tensor` containing the values of the slices.)r"rrrrr%hzIndexedSlices.valuescCr))z4A 1-D `Tensor` containing the indices of the slices.)r#r*rrrr&mr+zIndexedSlices.indicescCr))zFA 1-D `Tensor` containing the shape of the corresponding dense tensor.)r$r*rrrr'rr+zIndexedSlices.dense_shapecCs |jdur tdSt|jS)zyGets the `tf.TensorShape` representing the shape of the dense tensor. Returns: A `tf.TensorShape` object. N)r$r TensorShaper constant_value_as_shaper*rrrshapews   zIndexedSlices.shapecC|jjS)z!The name of this `IndexedSlices`.)r%namer*rrrr0zIndexedSlices.namecCr/)zEThe name of the device on which `values` will be produced, or `None`.)r%devicer*rrrr2r1zIndexedSlices.devicecCr/)z4The `Operation` that produces `values` as an output.)r%opr*rrrr3r1zIndexedSlices.opcCr/)z'The `DType` of elements in this tensor.)r%dtyper*rrrr4r1zIndexedSlices.dtypecCr/)zAThe `Graph` that contains the values, indices, and shape tensors.)r"graphr*rrrr5r1zIndexedSlices.graphcCs,d|j|j|jdurd|jffSdfS)Nz&IndexedSlices(indices=%s, values=%s%s)z, dense_shape=%s)r#r"r$r*rrr__str__szIndexedSlices.__str__cCst|j |j|jSr)r!r%r&r'r*rrr__neg__szIndexedSlices.__neg__cCsx|jj|jjdd}tdg|jjdd}|jdur/|jj}|t |j}nd}t ||j|jj||SN) r#r.Z merge_withr"r r, concatenater$r4r r-IndexedSlicesSpec)r indices_shaper'dense_shape_dtyperrr _type_specs   zIndexedSlices._type_speccCsT|dd}tdg|dd}|jdurd}n|jj}t||j|jj||Sr9)r r,r;r$r4r<r#)rr.r=r'r>rrr_shape_invariant_to_type_specs  z+IndexedSlices._shape_invariant_to_type_speccCs|Sr)Z _consumersr*rrr consumersszIndexedSlices.consumersr)rrrr r(propertyr%r&r'r.r0r2r3r4r5r7r8rZ__composite_gradient__r?r@rArrrrr!6s8 '           IndexedSlicesValue)r%r&r'r<c@s`eZdZdZgdZeddZdejej ddfddZ dd Z ed d Z d d Z ddZdS)r<z,Type specification for a `tf.IndexedSlices`._shape _values_dtype_indices_dtype_dense_shape_dtype_indices_shapecCstSr)r!r*rrrszIndexedSlicesSpec.NcCsVt||_t||_t||_|durd|_nt||_t|d|_ dS)aConstructs a type specification for a `tf.IndexedSlices`. Args: shape: The dense shape of the `IndexedSlices`, or `None` to allow any dense shape. dtype: `tf.DType` of values in the `IndexedSlices`. indices_dtype: `tf.DType` of the `indices` in the `IndexedSlices`. One of `tf.int32` or `tf.int64`. dense_shape_dtype: `tf.DType` of the `dense_shape` in the `IndexedSlices`. One of `tf.int32`, `tf.int64`, or `None` (if the `IndexedSlices` has no `dense_shape` tensor). indices_shape: The shape of the `indices` component, which indicates how many slices are in the `IndexedSlices`. Nr:) r Zas_shaperEras_dtyperFrGrHZ with_rankrI)rr.r4Z indices_dtyper>r=rrrr(s    zIndexedSlicesSpec.__init__cCs|j|j|j|j|jfSrrDr*rrr _serializes zIndexedSlicesSpec._serializecCs`|j|jdd}t||jt|j|jg}|jdur,|t|jj g|jt |Sr9) rIr;rEr Z TensorSpecrFrGrHappendZndimstuple)rZ value_shapespecsrrr_component_specss  z"IndexedSlicesSpec._component_specscCs&|jdur |j|jfS|j|j|jfSr)r'r%r&rrrr_to_componentss  z IndexedSlicesSpec._to_componentscCsJtdd|Dr!ts!t|dkrt|d|ddSt|St|S)Ncss|] }t|tjVqdSr) isinstancenpZndarray).0trrr sz5IndexedSlicesSpec._from_components..rr:)allrenabledlenrCr!)rZ tensor_listrrr_from_componentss z"IndexedSlicesSpec._from_components)rrrr __slots__rBZ value_typerZfloat32Zint64r(rLrPrQr[rrrrr<s    #convert_to_tensor_or_indexed_slices)v1cCt|||ddS)aConverts the given object to a `Tensor` or an `IndexedSlices`. If `value` is an `IndexedSlices` or `SparseTensor` it is returned unmodified. Otherwise, it is converted to a `Tensor` using `convert_to_tensor()`. Args: value: An `IndexedSlices`, `SparseTensor`, or an object that can be consumed by `convert_to_tensor()`. dtype: (Optional.) The required `DType` of the returned `Tensor` or `IndexedSlices`. name: (Optional.) A name to use if a new `Tensor` is created. Returns: A `Tensor`, `IndexedSlices`, or `SparseTensor` based on `value`. Raises: ValueError: If `dtype` does not match the element type of `value`. Frr4r0as_ref),internal_convert_to_tensor_or_indexed_slices)rr4r0rrrr]sFcCst|tjrtstj||||dSt|tjr:|r8t | |j s8t dt |j d|d|j j d|Stj||||dS)aConverts the given object to a `Tensor` or an `IndexedSlices`. If `value` is an `IndexedSlices` or `SparseTensor` it is returned unmodified. Otherwise, it is converted to a `Tensor` using `convert_to_tensor()`. Args: value: An `IndexedSlices`, `SparseTensor`, or an object that can be consumed by `convert_to_tensor()`. dtype: (Optional.) The required `DType` of the returned `Tensor` or `IndexedSlices`. name: (Optional.) A name to use if a new `Tensor` is created. as_ref: True if the caller wants the results as ref tensors. Returns: A `Tensor`, `IndexedSlices`, or `SparseTensor` based on `value`. Raises: ValueError: If `dtype` does not match the element type of `value`. r4r0ra4Incompatible tensor conversion requested to `dtype` z for `value` ( ) with dtype .)rRrZ EagerTensorrexecuting_eagerlyZconvert_to_tensorr NativeObjectrrKis_compatible_withr4 ValueErrorr0r`rrrrb.s  rbc Cspt|tjs tdg}t|D]%\}}|dur||q|dur$dnd||f}|t||||dq|S)auConverts `values` to a list of `Tensor` or `IndexedSlices` objects. Any `IndexedSlices` or `SparseTensor` objects in `values` are returned unmodified. Args: values: An iterable of `None`, `IndexedSlices`, `SparseTensor`, or objects that can be consumed by `convert_to_tensor()`. dtype: (Optional.) The required `DType` of the returned `Tensor` or `IndexedSlices`. name: (Optional.) A name prefix to used when a new `Tensor` is created, in which case element `i` will be given the name `name + '_' + i`. as_ref: True if the caller wants the results as ref tensors. Returns: A list of `Tensor`, `IndexedSlices`, `SparseTensor` and/or `None` objects. Raises: TypeError: If no conversion function is registered for an element in `values`. RuntimeError: If a registered conversion function returns an invalid value. z#Argument `values` must be iterable.Nz%s_%drc)rRrIterable TypeError enumeraterMrb)r%r4r0raretirnrrr.internal_convert_n_to_tensor_or_indexed_slicesTs  rqcCr_)a%Converts `values` to a list of `Output` or `IndexedSlices` objects. Any `IndexedSlices` or `SparseTensor` objects in `values` are returned unmodified. Args: values: A list of `None`, `IndexedSlices`, `SparseTensor`, or objects that can be consumed by `convert_to_tensor()`. dtype: (Optional.) The required `DType` of the returned `Tensor` `IndexedSlices`. name: (Optional.) A name prefix to used when a new `Tensor` is created, in which case element `i` will be given the name `name + '_' + i`. Returns: A list of `Tensor`, `IndexedSlices`, and/or `SparseTensor` objects. Raises: TypeError: If no conversion function is registered for an element in `values`. RuntimeError: If a registered conversion function returns an invalid value. F)r%r4r0ra)rq)r%r4r0rrr%convert_n_to_tensor_or_indexed_slices}srricCs|}|r||jstd|jd|d|jj|jdur&td|tsDt|j}|durDt |}|t krDt d|tj|j|j|jd|dS) aConverts an IndexedSlices object `value` to a Tensor. NOTE(mrry): This function is potentially expensive. Args: value: An ops.IndexedSlices object. dtype: The dtype of the Tensor to be returned. name: Optional name to use for the returned Tensor. as_ref: True if a ref is requested. Returns: A dense Tensor representing the values in the given IndexedSlices. Raises: ValueError: If the IndexedSlices does not have the same dtype. rdz for IndexedSlices (reNzXTensor conversion requested for IndexedSlices for argument `value` without dense_shape: znConverting sparse IndexedSlices to a dense Tensor with %d elements. This may consume a large amount of memory.r)r0)rir4rjr0r'rrgr Zconstant_valuerSprod_LARGE_SPARSE_NUM_ELEMENTSwarningswarnrZunsorted_segment_sumr%r&)rr4r0ra_Zdense_shape_valueZ num_elementsrrr_indexed_slices_to_tensors8    rx)NN)NNF)3r collectionsrunumpyrSZtensorflow.core.protobufrZtensorflow.pythonrZtensorflow.python.eagerrZtensorflow.python.frameworkrrrrr r r r r Ztensorflow.python.opsrZtensorflow.python.saved_modelrZtensorflow.python.typesrZtensorflow.python.util.compatrZ tensorflow.python.util.tf_exportrZCompositeTensorGradientrr!rhZCompositeTensor namedtuplerCZTypeSpecr<Zregister_codecZBuiltInTypeSpecCodecZ TypeSpecProtoZINDEXED_SLICES_SPECr]rbrqrrrtrxZ#register_tensor_conversion_functionrrrrsr                   B   ' ) )