a Sico@s2dZddlmmZddlmZddlmZdZ GdddZ e ej Gdd d e Z Gd d d e Zeejd eejd eejdeejdeejdGdddejZGddde ZGdddZej e feje fejefee fgZddZddZddZd!ddZdd ZdS)"z9Keras Input Tensor used to track functional API Topology.N)object_identity) structurec@seZdZdZd0ddZeddZeddZed d Z ed1d d Z d dZ ddZ ddZ eddZddZdZd2ddZeddZddZddZd d!Zed"d#Zd$d%Zed&d'Zd(d)Zed*d+Zed,d-Zed.d/ZdS)3 KerasTensora#A representation of a Keras in/output during Functional API construction. `KerasTensor`s are tensor-like objects that represent the symbolic inputs and outputs of Keras layers during Functional model construction. They are comprised of the `tf.TypeSpec` of the (Composite)Tensor that will be consumed/produced in the corresponding location of the Functional model. KerasTensors are intended as a private API, so users should never need to directly instantiate `KerasTensor`s. **Building Functional Models with KerasTensors** `tf.keras.Input` produces `KerasTensor`s that represent the symbolic inputs to your model. Passing a `KerasTensor` to a `tf.keras.Layer` `__call__` lets the layer know that you are building a Functional model. The layer __call__ will infer the output signature and return `KerasTensor`s with `tf.TypeSpec`s corresponding to the symbolic outputs of that layer call. These output `KerasTensor`s will have all of the internal KerasHistory metadata attached to them that Keras needs to construct a Functional Model. Currently, layers infer the output signature by: * creating a scratch `FuncGraph` * making placeholders in the scratch graph that match the input typespecs * Calling `layer.call` on these placeholders * extracting the signatures of the outputs before clearing the scratch graph (Note: names assigned to KerasTensors by this process are not guaranteed to be unique, and are subject to implementation details). `tf.nest` methods are used to insure all of the inputs/output data structures get maintained, with elements swapped between KerasTensors and placeholders. In rare cases (such as when directly manipulating shapes using Keras layers), the layer may be able to partially infer the value of the output in addition to just inferring the signature. When this happens, the returned KerasTensor will also contain the inferred value information. Follow-on layers can use this information. during their own output signature inference. E.g. if one layer produces a symbolic `KerasTensor` that the next layer uses as the shape of its outputs, partially knowing the value helps infer the output shape. **Automatically converting TF APIs to layers**: If you passing a `KerasTensor` to a TF API that supports dispatching, Keras will automatically turn that API call into a lambda layer in the Functional model, and return KerasTensors representing the symbolic outputs. Most TF APIs that take only tensors as input and produce output tensors will support dispatching. Calling a `tf.function` does not support dispatching, so you cannot pass `KerasTensor`s as inputs to a `tf.function`. Higher-order APIs that take methods which produce tensors (e.g. `tf.while`, `tf.map_fn`, `tf.cond`) also do not currently support dispatching. So, you cannot directly pass KerasTensors as inputs to these APIs either. If you want to use these APIs inside of a Functional model, you must put them inside of a custom layer. Args: type_spec: The `tf.TypeSpec` for the symbolic input created by `tf.keras.Input`, or symbolically inferred for the output during a symbolic layer `__call__`. inferred_value: (Optional) a non-symbolic static value, possibly partially specified, that could be symbolically inferred for the outputs during a symbolic layer `__call__`. This will generally only happen when grabbing and manipulating `tf.int32` shapes directly as tensors. Statically inferring values in this way and storing them in the KerasTensor allows follow-on layers to infer output signatures more effectively. (e.g. when using a symbolic shape tensor to later construct a tensor with that shape). name: (optional) string name for this KerasTensor. Names automatically generated by symbolic layer `__call__`s are not guaranteed to be unique, and are subject to implementation details. NcCst|tjstd||_||_||_t|tjst |dsRtdt |j dt|j tj stdt |j dt |jj ddS) zConstructs a KerasTensor.z6KerasTensors must be constructed with a `tf.TypeSpec`.shapezAKerasTensor only supports TypeSpecs that have a shape field; got z, which does not have a shape.zRKerasTensor requires that wrapped TypeSpec's shape is a TensorShape; got TypeSpec z(, whose shape field has unexpected type .N) isinstancetfTypeSpec ValueError _type_spec_inferred_value_namerNoneTensorSpechasattrtype __qualname__r TensorShape TypeErrordtype)self type_specinferred_valuenamerU/var/www/html/django/DPS/env/lib/python3.9/site-packages/keras/engine/keras_tensor.py__init__qs,    zKerasTensor.__init__cCs|jS)zAReturns the `tf.TypeSpec` symbolically inferred for Keras output.)r rrrrrszKerasTensor.type_speccCs|jjS)zAReturns the `TensorShape` symbolically inferred for Keras output.)r rrrrrrszKerasTensor.shapecCst|tjrt|dd}t|}d}|jtjkr||jjdur||jjdkr|tj |dj}|j rx| }t |t kr|d}nd}t|||dSt|dd}t|}|||dSdS)zKConvert a traced (composite)tensor to a representative KerasTensor.rNr)rrr)rr Tensorgetattrtype_spec_from_valuerint32rrankonesdimsas_listlen_MAX_TENSOR_RANKr)clstensorrrrrrr from_tensors,         zKerasTensor.from_tensorcCs |||dS)N)rrrr+rrrrrfrom_type_specszKerasTensor.from_type_speccCs\|jdur@ttjjj|jtjd}|jjjdkr<|d}|Sdd}tj j ||jddS)z5Convert this KerasTensor to a placeholder in a graph.N)rrrcSstjj|j|jSN)r compatv1 placeholderrr) componentrrrcomponent_to_placeholdersz=KerasTensor._to_placeholder..component_to_placeholderT)expand_composites) r r rr1r2r3r$rr%nest map_structure)rrr5rrr_to_placeholders zKerasTensor._to_placeholdercCs|jSr0rrrrr get_shapeszKerasTensor.get_shapecCs tddS)Na_Keras symbolic inputs/outputs do not implement `__len__`. You may be trying to pass Keras symbolic inputs/outputs to a TF API that does not register dispatching, preventing Keras from automatically converting the API call to a lambda layer in the Functional Model. This error will also get raised if you try asserting a symbolic input/output directly.rrrrr__len__szKerasTensor.__len__cCs tddS)NaKeras symbolic inputs/outputs do not implement `op`. You may be trying to pass Keras symbolic inputs/outputs to a TF API that does not register dispatching, preventing Keras from automatically converting the API call to a lambda layer in the Functional Model.r;rrrropszKerasTensor.opcCstd|ddS)Nz%Tensors are unhashable (this tensor: z(). Instead, use tensor.ref() as the key.r;rrrr__hash__ s zKerasTensor.__hash__dcCstd|ddS)NzYou are passing a , an intermediate Keras symbolic input/output, to a TF API that does not allow registering custom dispatchers, such as `tf.cond`, `tf.function`, gradient tapes, or `tf.map_fn`. Keras Functional model construction only supports TF API calls that *do* support dispatching, such as `tf.math.add` or `tf.reshape`. Other APIs cannot be called directly on symbolic Kerasinputs/outputs. You can work around this limitation by putting the operation in a custom Keras layer `call` and calling that layer on this symbolic input/output.r;)rrrrr __array__s zKerasTensor.__array__cCsdS)NTrrrrris_tensor_like)szKerasTensor.is_tensor_likecCsZt|tjst|}|j|sd|j}|jdurRd|j}d|j|||fS)N_keras_historyz%, description="created by layer '%s'"z, inferred_value=%sz , name='%s'zKerasTensor(type_spec=%s%s%s%s))rrHlayerrr rr)rsymbolic_descriptioninferred_value_string name_stringrIrrr__str__;s$     zKerasTensor.__str__cCstd}d}t|jtjr*d|j|jjf}n d|j}t|drR|jj }d|jf}|j durfd|j }d|||fS)NrGzshape=%s dtype=%sz type_spec=%srHz (created by layer '%s')z inferred_value=%sz) rrr TensorSpecrrrrrHrIr )rrJrKtype_spec_stringrIrrr__repr__Ps$     zKerasTensor.__repr__cCs^|j}t|ds&tdt|jdt|jtjsXt dt|jdt|jjd|jS)z@Returns the `dtype` symbolically inferred for this Keras output.rzKerasTensor wraps TypeSpec z, which does not have a dtype.zLKerasTensor requires that wrapped TypeSpec's dtype is a DType; got TypeSpec z(, whose dtype field has unexpected type r) r rAttributeErrorrrrrr DTyper)rrrrrrfs  zKerasTensor.dtypecCs t|S)aReturns a hashable reference object to this KerasTensor. The primary use case for this API is to put KerasTensors in a set/dictionary. We can't put tensors in a set/dictionary as `tensor.__hash__()` is not available and tensor equality (`==`) is supposed to produce a tensor representing if the two inputs are equal. See the documentation of `tf.Tensor.ref()` for more info. )r Referencerrrrrefxs zKerasTensor.refcCs$t|dr |j\}}}|j|SdS)a.Find the corresponding `Node` that produce this keras_tensor. During functional model construction, Keras will attach `KerasHistory` to keras tensor to track the connectivity between calls of layers. Return None if there isn't any KerasHistory attached to this tensor. rHN)rrH inbound_nodes)rrI node_index_rrrnodes   zKerasTensor.nodecCs`d}|jjdur"dd|jjD}|dur2td|s>td|ddurRtdt||dS)NcSsg|] }|jqSr)value).0dimrrr z(KerasTensor.__iter__..z0Cannot iterate over a Tensor with unknown shape.zCannot iterate over a scalar.rz:Cannot iterate over a Tensor with unknown first dimension.)rndimsr'r_KerasTensorIteratorrErrr__iter__s  zKerasTensor.__iter__cCs|jS)zMReturns the (non-unique, optional) name of this symbolic Keras value.)rrrrrrszKerasTensor.namecCs4tjjD]}|||qt|dr0||ddS)z%Register overloads for all operators.experimental_refN)r r!OVERLOADABLE_OPERATORS_overload_operatorr)r+ tensor_classoperatorrrr_overload_all_operatorss  z#KerasTensor._overload_all_operatorscCs&t||}t|d|}t|||dS)a3Overload an operator with the same implementation as a base Tensor class. We pull the operator out of the class dynamically to avoid ordering issues. Args: tensor_class: The (Composite)Tensor to get the method from. operator: string. The operator name. __func__N)r"setattr)r+rdre tensor_operrrrrcs  zKerasTensor._overload_operator)NN)N)N)__name__ __module__r__doc__rpropertyrr classmethodr-r/r9r:r<r=r>__array_priority__r@rArFrMrPrrTrXr`rrfrcrrrrr sFP    4 "          rc@seZdZdZddZdS)SparseKerasTensorzA specialized KerasTensor representation for `tf.sparse.SparseTensor`s. Specifically, it specializes the conversion to a placeholder in order to maintain dense shape information. cCs|j}tjjj|j|jdS)N)rr)rr r1r2sparse_placeholderrr)rspecrrrr9sz!SparseKerasTensor._to_placeholderN)rjrkrrlr9rrrrrpsrpcs,eZdZdZfddZeddZZS)RaggedKerasTensoraA specialized KerasTensor representation for `tf.RaggedTensor`s. Specifically, it: 1. Specializes the conversion to a placeholder in order to maintain shape information for non-ragged dimensions. 2. Overloads the KerasTensor's operators with the RaggedTensor versions when they don't match the `tf.Tensor` versions 3. Exposes some of the instance method/attribute that are unique to the RaggedTensor API (such as ragged_rank). c s4|j}|jdks|jjdur&tS|j|jd}tjj |j |}g}d}|jD]<}|dur|duszt |dddurd}n||}| |qVt |jddD]}|j|}|dust |dddur||d}|dur|d}tjj |j|g} tjj|| dd}qt||j} tjj|| dd}q|S)NrrYTF)validate)r ragged_rankrr%superr9r r1r2r3rr"appendrangerow_splits_dtype RaggedTensorfrom_row_splitsconstantfrom_uniform_row_length) r ragged_spec flat_shaperesultknown_num_splitsprod axis_sizeaxis num_splitssplitsrowlen __class__rrr9s@     z!RaggedKerasTensor._to_placeholdercCs|jjSr0)rrwrrrrrwszRaggedKerasTensor.ragged_rank)rjrkrrlr9rmrw __classcell__rrrrrss 'rs __getitem____add____radd____mul____rmul__c@s@eZdZdZddZddZddZdd Zd d Zd d Z dS)UserRegisteredSpecz7TypeSpec to represent user-registered symbolic objects.cCs||_||_||_dSr0)r_dtyper)rrrrrrr)szUserRegisteredSpec.__init__cCstdSr0NotImplementedErrorrrrr_component_specs.sz#UserRegisteredSpec._component_specscCstdSr0r)r componentsrrr_from_components1sz#UserRegisteredSpec._from_componentscCstdSr0rrrrr _serialize4szUserRegisteredSpec._serializecCstdSr0r)rrYrrr_to_components7sz!UserRegisteredSpec._to_componentscCstdSr0rrrrr value_type:szUserRegisteredSpec.value_typeN) rjrkrrlrrrrrrrrrrr&srcsBeZdZdZfddZeddZed ddZd d ZZ S) UserRegisteredTypeKerasTensorzAKerasTensor that represents legacy register_symbolic_tensor_type.cs6|}||_t|j|j}t|dd}t||dS)Nr) _user_registered_symbolic_objectrrrr"rxr)ruser_registered_symbolic_objectxrrrrrrGs  z&UserRegisteredTypeKerasTensor.__init__cCs||Sr0r)r+r,rrrr-Osz)UserRegisteredTypeKerasTensor.from_tensorNcCstd|dS)Nz?You cannot instantiate a KerasTensor directly from TypeSpec: %srr.rrrr/Ss z,UserRegisteredTypeKerasTensor.from_type_speccCs|jSr0)rrrrrr9Zsz-UserRegisteredTypeKerasTensor._to_placeholder)N) rjrkrrlrrnr-r/r9rrrrrrDs   rc@s(eZdZdZddZddZddZdS) r_zLIterates over the leading dim of a KerasTensor. Performs 0 error checks.cCs||_d|_||_dS)Nr)_tensor_index_limit)rr,dim0rrrrbsz_KerasTensorIterator.__init__cCs|Sr0rrrrrr`gsz_KerasTensorIterator.__iter__cCs.|j|jkrt|j|j}|jd7_|S)Nrt)rr StopIterationr)rrrrr__next__js   z_KerasTensorIterator.__next__N)rjrkrrlrr`rrrrrr_^sr_cCstd||fdS)z>Register a specialized KerasTensor subclass for a Tensor type.ruN)keras_tensor_classesinsert)r+keras_tensor_subclassrrr$register_keras_tensor_specializationsrcCst|tr|S|SdS)zFConstruct a graph placeholder to represent a KerasTensor when tracing.N)rrr9)rrrrkeras_tensor_to_placeholders rcCsNd}tD]\}}t||r|}q$q||}t|dddurJt|j|_|S)zCConvert a traced (composite)tensor to a representative KerasTensor.N _keras_mask)rrr-r"keras_tensor_from_tensorr)r,keras_tensor_cls tensor_typer+outrrrrs    rcCs8d}|j}tD]\}}t||r|}q*q|j||dS)z3Convert a TypeSpec to a representative KerasTensor.Nr )rr issubclassr/)rrrrrr+rrrkeras_tensor_from_type_specs  rcCst|tjr t|}||_|St|tjrFt||j|j|j|j St|tj r`t ||jSt |drt| |St ddS)z@Returns a copy of TypeSpec `spec` with its shape set to `shape`. with_shapezjKeras requires TypeSpec to have a `with_shape` method that returns a copy of `self` with an updated shape.N)rr rNr_shapeRaggedTensorSpecrrwr{flat_values_specSparseTensorSpecrrr )rrrrrrrDs&      rD)N)rltensorflow.compat.v2r1v2r keras.utilsrtensorflow.python.data.utilrr*rrfr!rprsrcr|r rrr_ SparseTensorobjectrrrrrrDrrrrs:  ) :