a Sic P@sdZddlZddlZddlZddlZddlmmZ ddl m Z ddl m Z ddlmZddlmZddlmZddlmZed gd d d Zd dZdBddZddZddZdCddZddZGdddZdDddZdd Zd!d"Ze a!d#d$Z"d%d&Z#ed'gd d(d)Z$d*d+Z%d,d-Z&d.d/Z'd0d1Z(d2d3Z)d4d5Z*ej+d6d7Z,ej+d8d9Z-d:d;Z.dEdd?Z0d@dAZ1dS)FzTensorFlow-related utilities.N)backend) keras_tensor)object_identity) tf_contextlib)ops) keras_exportzkeras.utils.set_random_seed)v1cCsXt|ts$td|dt|dt|tj|tj|t |t j _ dS)aSets all random seeds for the program (Python, NumPy, and TensorFlow). You can use this utility to make almost any Keras program fully deterministic. Some limitations apply in cases where network communications are involved (e.g. parameter server distribution), which creates additional sources of randomness, or when certain non-deterministic cuDNN ops are involved. Calling this utility is equivalent to the following: ```python import random import numpy as np import tensorflow as tf random.seed(seed) np.random.seed(seed) tf.random.set_seed(seed) ``` Arguments: seed: Integer, the random seed to use. z:Expected `seed` argument to be an integer. Received: seed=z (of type )N) isinstanceint ValueErrortyperandomseednptfset_seedRandomr_SEED_GENERATOR generator)rrP/var/www/html/django/DPS/env/lib/python3.9/site-packages/keras/utils/tf_utils.pyset_random_seed"s    rcCs,tj|}|r$t|dtjr$dSdSdS)NrTF)rnestflattenr Tensor)vrrris_tensor_or_tensor_listEs rcCstjj|dd}t|}|r0ttj|}t|}|r|}t|t t rXq:t|tj r|j ddptg}||j 7}nTt|tjrz |jg}Wqtyg}Yq0n"t|r|}ntd||D]0}||vr|||r||||q|r:|s:|Sq:|S)a_Returns the set of tensors/ops reachable from `inputs`. Stops if all targets have been found (target is optional). Only valid in Symbolic mode, not Eager mode. Args: inputs: List of tensors. targets: List of tensors. Returns: A set of tensors reachable from the inputs (includes the inputs themselves). Texpand_compositesNzz-map_structure_with_atomic..csg|]}t|qSrmap_structure_with_atomicr:ele) is_atomic_fnmap_fnrrr>s) rr is_nestedr r __internal__ is_mappingsortedkeysis_attrs_astuple sequence_like)rDrEr=values mapped_valuesr)rDrEr=rrAs"   rAcCstjdd|S)zGets shapes from tensors.cSst|dr|jSdS)Nshape)hasattrrPr7rrrr?zget_shapes..)rr map_structuretensorsrrr get_shapessrWTcs,ddfdd}fdd}t|||S)aConverts nested shape representations to desired format. Performs: TensorShapes -> tuples if `to_tuples=True`. tuples of int or None -> TensorShapes if `to_tuples=False`. Valid objects to be converted are: - TensorShapes - tuples with elements of type int or None. - ints - None Args: input_shape: A nested structure of objects to be converted to TensorShapes. to_tuples: If `True`, converts all TensorShape to tuples. Otherwise converts all tuples representing shapes to TensorShapes. Returns: Nested structure of shapes in desired format. Raises: ValueError: when the input tensor shape can't be converted to tuples, eg unknown tensor shape. cSs|dupt|ttjjjfSN)r r rcompatr Dimensionvaluerrr_is_shape_componentsz+convert_shapes.._is_shape_componentcsH|r dSt|tjrdSt|ttfrDtfdd|DrDdSdS)NTc3s|]}|VqdSrXrrBr]rr sz;convert_shapes.._is_atomic_shape..F)r r TensorShaper$listall input_shaper^rr_is_atomic_shapes z(convert_shapes.._is_atomic_shapecst|}rt|}|SrX)rr`r$as_listrc to_tuplesrr_convert_shapes  z&convert_shapes.._convert_shaper@)rdrhrerir)r]rhrconvert_shapess  rjcCst|}|j}|s"td|t|tr4|g}nt|}t|D]\}}|dkrD||||<qD|D],}|dksz||krftd|dt|qft |t t |krtdt||S)aTValidate an axis value and returns its standardized form. Args: axis: Value to validate. Can be an integer or a list/tuple of integers. Integers may be negative. input_shape: Reference input shape that the axis/axes refer to. Returns: Normalized form of `axis`, i.e. a list with all-positive values. z0Input has undefined rank. Received: input_shape=rzVInvalid value for `axis` argument. Expected 0 <= axis < inputs.rank (with inputs.rank=z). Received: axis=zDuplicate axis: ) rr`rankr r r ra enumerater$lenset)axisrdrkidxr7rrr validate_axiss0  rqc@s eZdZdZddZddZdS) ListWrapperz9A wrapper for lists to be treated as elements for `nest`.cCs ||_dSrX_list)self list_to_wraprrr__init__szListWrapper.__init__cCs|jSrXrs)rurrrrfszListWrapper.as_listN)__name__ __module__ __qualname____doc__rwrfrrrrrrsrrFcs.ddfdd}fdd}t|||S)a^Either wraps or unwraps innermost node data lists in `ListWrapper` objects. Args: nested: A nested data structure. wrap: If `True`, wrap innermost lists in `ListWrapper` objects. If `False`, unwraps `ListWrapper` objects into lists. Returns: Structure of same type as nested, with lists wrapped/unwrapped. cSs,t|tr(t|dvr(t|dtr(dSdS)N)rTF)r rarmstrr<rrr_is_serialized_node_data,s  z9convert_inner_node_data.._is_serialized_node_datacs(t|trdS|rdStj| S)z._is_atomic_nestedcs@r&t|tr|S|r"t|S|St|tr8|S|SdS)z:Convert b/t `ListWrapper` object and list representations.N)r rrrfr<rwraprr_convert_object_or_list?s  z8convert_inner_node_data.._convert_object_or_listr@)r=rrrrrrconvert_inner_node_datas   rcsfdd}|S)zDecorator that handles tuple/TensorShape conversion. Used in `compute_output_shape` and `build`. Args: fn: function to wrap. Returns: Wrapped function. cs6|durt|dd}||}|dur2t|dd}|S)NTrgF)rj)instancerd output_shapefnrrwrapper]s    z&shape_type_conversion..wrapperr)rrrrrshape_type_conversionQs rcCsttt|SrX)rbmapis_symbolic_tensorrUrrrare_all_symbolic_tensorsksrcCst|tjjS)aReturns whether a tensor is of an ExtensionType. github.com/tensorflow/community/pull/269 Currently it works by checking if `tensor` is a `CompositeTensor` instance, but this will be changed to use an appropriate extensiontype protocol check once ExtensionType is made public. Args: tensor: An object to test Returns: True if the tensor is an extension type object, false if not. )r rrGCompositeTensortensorrrris_extension_typersrcCst|tjrt|dSt|r@tjj|dd}tdd|DSt|tjrbt |ddp`t St|t t rt |}t|SdSdS) a[Returns whether a tensor is symbolic (from a TF graph) or an eager tensor. A Variable can be seen as either: it is considered symbolic when we are in a graph scope, and eager when we are in an eager scope. Args: tensor: A tensor instance to test. Returns: True for symbolic tensors, False for eager tensors. graphTrcss|]}t|dVqdS)rN)rQ)r:trrrr_r?z%is_symbolic_tensor.._keras_historyFN)r rrrQrrranyr)getattrexecuting_eagerlyr$r%rconvert_to_tensor_or_compositer)rcomponent_tensorsrrrrs     rz6keras.__internal__.utils.register_symbolic_tensor_typecCs$|tvrt|tjt|dS)a%Allows users to specify types regarded as symbolic `Tensor`s. Used in conjunction with `tf.register_tensor_conversion_function`, calling `tf.keras.__internal__.utils.register_symbolic_tensor_type(cls)` allows non-`Tensor` objects to be plumbed through Keras layers. Example: ```python # One-time setup. class Foo: def __init__(self, input_): self._input = input_ def value(self): return tf.constant(42.) tf.register_tensor_conversion_function( Foo, lambda x, *args, **kwargs: x.value()) tf.keras.__internal__.utils.register_symbolic_tensor_type(Foo) # User-land. layer = tf.keras.layers.Lambda(lambda input_: Foo(input_)) ``` Args: cls: A `class` type which shall be regarded as a symbolic `Tensor`. N)r%r$register_keras_tensor_specializationUserRegisteredTypeKerasTensorr/)clsrrrregister_symbolic_tensor_types rcCs@t|r|jSt|dr2t|dr2t|j|jSt|SdS)z9Grab type_spec without converting array-likes to tensors.rPdtypeN)r _type_specrQr TensorSpecrPrtype_spec_from_valuer[rrrrs rcCst|tjtjjjjfS)zCReturns true if `tensor` is a ragged tensor or ragged tensor value.)r r RaggedTensorrYrraggedRaggedTensorValuerrrr is_raggedsrcCst|tjtjjjfS)zCReturns true if `tensor` is a sparse tensor or sparse tensor value.)r r SparseTensorrYrSparseTensorValuerrrr is_sparsesrcCst|pt|tjSrX)rr,r r)rRrrris_tensor_or_variablesrcCst|pt|S)zr?z+assert_no_legacy_layers.. css|]}dt|VqdS)z N)r~rrrrr_r?z*assert_no_legacy_layers..z+The following are legacy tf.layers.Layers: z To use keras as a framework (for instance using the Network, Model, or Sequential classes), please use the tf.keras.layers implementation instead. (Or, if writing custom layers, subclass from tf.keras.layers rather than tf.layers)N)joinr.)layers legacy_layers layer_strrrrassert_no_legacy_layerss  rccsRtjjrHt|ddrHtdVWdqN1s<0YndVdS)zOpen an `init_scope` if in V2 mode and using the keras graph. Args: layer: The Layer/Model that is currently active. Yields: None _keras_styleTN)rrYr#executing_eagerly_outside_functionsr init_scope)layerrrrmaybe_init_scopes  &rcos`tddt|t|DrVtdVWdq\1sJ0YndVdS)zLReturns graph context manager if any of the inputs is a symbolic tensor.css|]}t|VqdSrX)r)r:rrrrr_ r?z5graph_context_for_symbolic_tensors..N)rrarNr get_graph as_default)argskwargsrrr"graph_context_for_symbolic_tensorss"&rcCsRtjjr(ttjj|tjjjSt tjj|}|tjjjkSdS)z'True if the passed dataset is infinite.N) rrYrrequaldata experimental cardinalityINFINITE_CARDINALITYr get_sessionrun)dataset dataset_sizerrrdataset_is_infinite's   rcCst|tjr|}nxt|r"|j}nht|drHt|jddrH|jdjSt|tjr\|j }n.t|drt|drtj |j |j |d}ndS|s|S|j }|j dus|j dkr|S|}d|d<t|}t|t|S)z?Returns a `TensorSpec` given a single `Tensor` or `TensorSpec`.rrrrPr)rPrnameN)r rTypeSpecrrrQrr KerasTensor type_specrrPrrkrfcopydeepcopytype_spec_with_shaper`)r dynamic_batchrspecrP shape_listrrrget_tensor_spec5s,      rcCs0t|tjjjjr|}dd}tj||S)aSyncs and converts a structure of `Tensor`s to `NumPy` arrays or Python scalar types. For each tensor, it calls `tensor.numpy()`. If the result is a scalar value, it converts it to a Python type, such as a float or int, by calling `result.item()`. Numpy scalars are converted, as Python types are often more convenient to deal with. This is especially useful for bfloat16 Numpy scalars, which don't support as many operations as other Numpy values. Async strategies (such as `TPUStrategy` and `ParameterServerStrategy`) are forced to sync during this process. Args: tensors: A structure of tensors. Returns: `tensors`, but scalar tensors are converted to Python types and non-scalar tensors are converted to Numpy arrays. cSsDt|tjr|}t|tjtjfs*|St|dkr@|S|S)Nr) r rrnumpyrndarraygenericndimitem)rrrr_to_single_numpy_or_python_typeqs  zEsync_to_numpy_or_python_type.._to_single_numpy_or_python_type) r r distributer coordinator RemoteValuefetchrrT)rVrrrrsync_to_numpy_or_python_typeWs rcCsRt|}t|dd}|dur*t|dg}|D]}|t||jq2t|S)z2Converts the given attrs to tuple non-recursively.__attrs_attrs__Nz! is not an attrs-decorated class.)r rr appendrr$)attrsrfieldsrNfieldrrrrL~s rL)N)T)F)FN)2r{r!rrrrtensorflow.compat.v2rYv2rkerasr keras.enginer keras.utilsrrtensorflow.python.frameworkr tensorflow.python.util.tf_exportrrrr9rArWrjrqrrrrrrnr%rrrrrrrrrcontextmanagerrrrrrrLrrrrsT        " >% 6( 2#  %    "'