B ӻdO: @sndZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z ddl mZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlm Z ddlm!Z!ddlm"Z"ddlm#Z#ddlm$Z$ddl%m&Z&ddl'm(Z)ddl*m+Z+ddl,m-Z-ddl,m.Z.ddl,m/Z/ddl,m0Z0ddl1m2Z2ddl1m3Z3ddl1m4Z4ddl1m5Z6ddl1m7Z7dd l1m8Z9dd!l1m:Z:dd"l1m;Z;dd#l1mZ?dd&l1m@Z@dd'l1mAZAdd(l1mBZBdd)l1mCZCdd*l1mDZDdd+l1mEZEdd,l1mFZFdd-l1mGZHdd.lImJZJdd/lKmLZMdd0lNmOZOdd1lPmQZQdd2lPmRZRdd3lSmTZTdd4lUmVZVeWZXeYZZe[Z\e]a^e]a_e]a`eaZbecZdGd5d6d6ej]ZeeeZfd7agdahe&jiZie&jjZje&jkZke&jlZle&jmZme&jnZneTd8eVjod9d:ZpeTd;eQjqeVjoddid@dAZseTdBdCdDZteTdEdFdGZueTdHeVjodIdJZveTdKeVjodLdMZwdNdOZxdPdQZydRdSZzdTdUZ{eTdVeVjodWdXZ|dYdZZ}eTd[e/j~eVjod\d]Ze/j~d^d_Ze/j~d`daZdbdcZdddeZdjdfdgZdkdidjZeTdkgdldldmdnZdodpZe/j~dmdqdrZeTdsgdldtduZdvdwZdxdyZGdzd{d{Zd|d}Zd~dZddZddZddZddZeTdeVjoddZeTdeQjqeVjoddZeTdgdleVjoddZe jZeTdgdleeTdeVjodnddZddZeTdgdlddZddZdoddZdpddZeTdgdlddZeTdeQjqeVjodqddZeTdddZeTdeVjodrddZddZeTdeQjqeVjoddZeTdeVjoddZeTdeVjoddZeTdeQjqeVjoddZeVjoddZeTdeVjoddZeTdeVjodsddZeTdeQjqeVjodtddÄZeTdăeQjqeVjoduddƄZeTdǃeVjodvddɄZeTdʃeQjqeVjodwdd̄Zdxdd΄ZeTdσeVjodyddфZeTd҃eVjodzddԄZeTdՃeVjoddׄZeTd؃eQjqeVjoddڄZeTdۃeVjodd݄ZeTdރeVjoddZeTdeVjoddZeTdeVjoddZeTdeQjqeVjoddZeTdeQjqeVjod{ddZeTdeQjqeVjoddZeTdeQjqeVjoddZeTdeQjqeVjod|ddZeTdeQjqeVjod}ddZeTdeQjqeVjod~ddZYeTdeQjqeVjodddZeTdeQjqeVjodddZeTdeQjqeVjodddZeTdeVjodddZeTdeQjqeVjodd d ZeTd eQjqeVjodd d ZeTdeQjqeVjodddZ[eTdeQjqeVjodddZWeTdeQjqeVjodddZeTdeQjqeVjodddZeTdeQjqeVjoddZeTdeQjqeVjodd ZeTd!eQjqeVjod"d#ZeTd$eQjqeVjod%d&ZeTd'eQjqeVjod(d)Zɐdd*d+ZeTd,eQjqeVjod-d.ZeTd/eQjqeVjod0d1ZeTd2eQjqeVjod3d4ZeTd5eQjqeVjod6d7ZeTd8eQjqeVjod9d:ZeTd;eQjqeVjod<d=ZeTd>eQjqeVjod?d@ZeTdAeQjqeVjodBdCZeTdDeQjqeVjodEdFZeTdGeQjqeVjodHdIZeTdJeQjqeVjodKdLZeTdMeQjqeVjodNdOZeTdPeQjqeVjodQdRZeTdSeQjqeVjodTdUZؐddWdXZِddYdZZڐdd[d\ZeTd]eVjodd^d_ZeTd`eQjqeVjoddadbZeTdceQjqeVjoddddeZeTdfeQjqeVjodgdhZeTdieQjqeVjodjdkZeTdleQjqeVjoddndoZeTdpeQjqeVjodqdrZeTdseQjqeVjodtduZeTdveQjqeVjodwdxZeTdyeQjqeVjodd|d}ZeTd~eQjqeVjoddZeTdeQjqeVjoddZeTdeQjqeVjoddZeTdeQjqeVjodddZeTdeQjqeVjoddZeTdeQjqeVjodddZeTdeQjqeVjodddZeTdeQjqeVjodddZeTdeQjqeVjodddZeTdeQjqeVjoddZeTdeQjqeVjoddZdddZeTdeVjoddZeTdeQjqeVjoddZeTdeVjoddZeTdeQjqeVjoddZejjede_ejjede_eTdeQjqeVjodddZGdddZeTdeVjodddZeTdeVjoddZ8eTdeQjqeVjoddZeTdeQjqdddZeTdƒeQjqeVjodÐdĄZeTdŃeVjoddƐdDŽZeTdȃeVjoddɐdʄZeTd˃eQjqeVjodd͐d΄ZeTdσeQjqeVjoddѐd҄ZeTdӃeQjqeVjoddԐdՄZeTdփeQjqeVjodאd؄ZeTdكeQjqeVjodڐdۄZeTd܃eQjqeVjoddݐdބZeTd߃eQjqeVjodddZeTdeQjqeVjodddZeTdeQjqeVjoddZeTdeQjqeVjoddZeTdeQjqeVjoddZ eTdeQjqeVjodddZ eTdeQjqeVjodddZ eTdeQjqeVjoddZ ddZ dddZddZddZeTdeQjqeVjodddZeTdeQjqeVjodddZeTdeQjqeVjodddZdd d ZeTd eQjqeVjodd d ZeTdeQjqeVjodddZeTdeQjqeVjodddZdddZeTdeQjqeVjodddZeTdeQjqeVjodddZdddZeTdeQjqeVjodd d!ZeTd"eQjqeVjodd#d$ZeTd%eQjqeVjodd&d'ZeTd(eQjqeVjodd)d*ZeTd+eQjqeVjodd,d-Z eTd.eQjqeVjodd/d0Z!eTd1eQjqeVjodd2d3Z"eTd4eQjqeVjodd5d6Z#eTd7eQjqeVjod8d9Z$eTd:eQjqeVjod;d<Z%eTd=eQjqeVjodd@dAZ&eTdBeVjoddCdDZ>eTdEeVjoddFdGZ'eTdHeVjoddIdJZ(dKej)krej)*dKZ+n,ej,-dLZ.ej,/e.dMZ+ej,-ej,/e+dNZ0ej,1e0ry.e2e0Z3e4e3Z5WdQRXWne6k rRiZ5YnXe5*dOejZ7e7dPks~t8e5*dQeiZ9e:e9e;st8e5*dRekZ<e<dSks֐t8eme7ele9ene<ej,1e+s4ye=e+Wne>k r2YnXej,1e0sejeidTekdUZ5yBe2e0dV(Z?e?@ejAe5dWdXWdQRXWneBk rYnXdYdZZCd[d\ZDd]d^ZEd_d`ZFdadbZGdcddZHddedfZIGdgdhdhejaZJeJe{aKeJe.jLaMeJe.jLaNdS(zKeras backend API.N) config_pb2)tf2)session)distribution_strategy_context)context) get_config)composite_tensor)config) constant_op) device_spec)dtypes) func_graph)ops) sparse_tensor) tensor_shape) tensor_spec) tensor_util)backend_config)distribute_coordinator_utils) keras_tensor)control_flow_util)object_identity) tf_contextlib) tf_inspect) array_ops)clip_ops)control_flow_ops)ctc_ops)functional_ops) gradients) image_ops)init_ops) linalg_ops) logging_ops)map_fn)math_ops)nn) random_ops) sparse_ops) state_ops)tensor_array_grad)tensor_array_ops) variables) ragged_tensor) tf_logging)moving_averages)dispatch)nest) keras_export) doc_controlscs.eZdZdZGdddZfddZZS)_DummyEagerGraphz_DummyEagerGraph provides a thread local `key` attribute. We can't use threading.local directly, i.e. without subclassing, because gevent monkey patches threading.local and its version does not support weak references. c@seZdZdZdS)z'_DummyEagerGraph._WeakReferencableClassaqThis dummy class is needed for two reasons. - We need something that supports weak references. Basic types like string and ints don't. - We need something whose hash and equality are based on object identity to make sure they are treated as different keys to _GRAPH_LEARNING_PHASES. An empty Python class satisfies both of these requirements. N)__name__ __module__ __qualname____doc__r9r9Q/var/www/html/venv/lib/python3.7/site-packages/tensorflow/python/keras/backend.py_WeakReferencableClasss r;cs"tt|t|_d|_dS)NF)superr4__init__r;keylearning_phase_is_set)self) __class__r9r:r=s z_DummyEagerGraph.__init__)r5r6r7r8r;r= __classcell__r9r9)rAr:r4ys r4Fzkeras.backend.backendcCsdS)zPublicly accessible method for determining the current backend. Only exists for API compatibility with multi-backend Keras. Returns: The string "tensorflow". tensorflowr9r9r9r9r:backends rDzkeras.backend.cast_to_floatxcCs6t|tjtjtjfr&tj|t dSt j |t dS)aCast a Numpy array to the default Keras float type. Args: x: Numpy array or TensorFlow tensor. Returns: The same array (Numpy array if `x` was a Numpy array, or TensorFlow tensor if `x` was a tensor), cast to its new type. Example: >>> tf.keras.backend.floatx() 'float32' >>> arr = np.array([1.0, 2.0], dtype='float64') >>> arr.dtype dtype('float64') >>> new_arr = cast_to_floatx(arr) >>> new_arr array([1., 2.], dtype=float32) >>> new_arr.dtype dtype('float32') )dtype) isinstancerTensorvariables_moduleVariabler SparseTensorr%castfloatxnpasarray)xr9r9r:cast_to_floatxs  rPzkeras.backend.get_uidcCs<t}|tkrttt|<t|}||d7<||S)zAssociates a string prefix with an integer counter in a TensorFlow graph. Args: prefix: String prefix to index. Returns: Unique integer ID. Example: >>> get_uid('dense') 1 >>> get_uid('dense') 2 ) get_graphPER_GRAPH_OBJECT_NAME_UIDS collections defaultdictint)prefixgraphZlayer_name_uidsr9r9r:get_uids rZzkeras.backend.reset_uidscCsttdS)zResets graph identifiers. N)rTclearOBSERVED_NAMESr9r9r9r: reset_uidssr]zkeras.backend.clear_sessionc Cs|dt_ttdt_t}|6dt _ t t |t|dt|dWdQRXtrxtdS)aResets all state generated by Keras. Keras manages a global state, which it uses to implement the Functional model-building API and to uniquify autogenerated layer names. If you are creating many models in a loop, this global state will consume an increasing amount of memory over time, and you may want to clear it. Calling `clear_session()` releases the global state: this helps avoid clutter from old models and layers, especially when memory is limited. Example 1: calling `clear_session()` when creating models in a loop ```python for _ in range(100): # Without `clear_session()`, each iteration of this loop will # slightly increase the size of the global state managed by Keras model = tf.keras.Sequential([tf.keras.layers.Dense(10) for _ in range(10)]) for _ in range(100): # With `clear_session()` called at the beginning, # Keras starts with a blank state at each iteration # and memory consumption is constant over time. tf.keras.backend.clear_session() model = tf.keras.Sequential([tf.keras.layers.Dense(10) for _ in range(10)]) ``` Example 2: resetting the layer name generation counter >>> import tensorflow as tf >>> layers = [tf.keras.layers.Dense(10) for _ in range(10)] >>> new_layer = tf.keras.layers.Dense(10) >>> print(new_layer.name) dense_10 >>> tf.keras.backend.set_learning_phase(1) >>> print(tf.keras.backend.learning_phase()) 1 >>> tf.keras.backend.clear_session() >>> new_layer = tf.keras.layers.Dense(10) >>> print(new_layer.name) dense NF)_GRAPHrYrZreset_default_graphr]_SESSIONrrS as_default_DUMMY_EAGER_GRAPHr?_GRAPH_LEARNING_PHASESr[ setdefault_GRAPH_VARIABLESpop_GRAPH_TF_OPTIMIZERSrexecuting_eagerlyZclear_kernel_cache)rYr9r9r: clear_sessions0   rhz,keras.backend.manual_variable_initializationcCs|adS)a0Sets the manual variable initialization flag. This boolean flag determines whether variables should be initialized as they are instantiated (default), or if the user should handle the initialization (e.g. via `tf.compat.v1.initialize_all_variables()`). Args: value: Python boolean. N)_MANUAL_VAR_INIT)valuer9r9r:manual_variable_initialization>srkzkeras.backend.learning_phasec CsJt}|ttddkr t}nttd}WdQRXt|||S)aReturns the learning phase flag. The learning phase flag is a bool tensor (0 = test, 1 = train) to be passed as input to any Keras function that uses a different behavior at train time and test time. Returns: Learning phase (scalar integer tensor or Python integer). rYN)rget_default_graphgetattrr^symbolic_learning_phase init_scoperb_mark_func_graph_as_unsaveable)rYlearning_phaser9r9r:rqPs   rqcCstjS)N)rar?r9r9r9r:global_learning_phase_is_setosrrcCs|jrt|r|ddS)ayMark func graph as unsaveable due to use of symbolic keras learning phase. Functions that capture the symbolic learning phase cannot be exported to SavedModel. Mark the funcgraph as unsaveable, so that an error will be raised if it is exported. Args: graph: Graph or FuncGraph object. learning_phase: Learning phase placeholder or int defined in the graph. zThe keras learning phase placeholder was used inside a function. Exporting placeholders is not supported when saving out a SavedModel. Please call `tf.keras.backend.set_learning_phase(0)` in the function to set the learning phase to a constant value.N)building_functionis_placeholderZmark_as_unsaveable)rYrqr9r9r:rpss rpc Cs"t}| t|SQRXdS)N)rSr`rb)rYr9r9r:rns rnc Cs0tr dStdtjddddSQRXdS)NrrQFr9Zkeras_learning_phase)shapename)rrg name_scoperZplaceholder_with_defaultr9r9r9r:_default_learning_phases  rxz keras.backend.set_learning_phasecCstdt|dS)aSets the learning phase to a fixed value. The backend learning phase affects any code that calls `backend.learning_phase()` In particular, all Keras built-in layers use the learning phase as the default for the `training` arg to `Layer.__call__`. User-written layers and models can achieve the same behavior with code that looks like: ```python def call(self, inputs, training=None): if training is None: training = backend.learning_phase() ``` Args: value: Learning phase value, either 0 or 1 (integers). 0 = test, 1 = train Raises: ValueError: if `value` is neither `0` nor `1`. z`tf.keras.backend.set_learning_phase` is deprecated and will be removed after 2020-10-11. To update it, simply pass a True/False value to the `training` argument of the `__call__` method of your layer or model.N)warningswarn&deprecated_internal_set_learning_phase)rjr9r9r:set_learning_phases r|c CsJ|dkrtdt(tr2dt_|ttj<|tt <WdQRXdS)aWA deprecated internal implementation of set_learning_phase. This method is an internal-only version of `set_learning_phase` that does not raise a deprecation error. It is required because saved_model needs to keep working with user code that uses the deprecated learning phase methods until those APIs are fully removed from the public API. Specifically SavedModel saving needs to make sure the learning phase is 0 during tracing even if users overwrote it to a different value. But, we don't want to raise deprecation warnings for users when savedmodel sets learning phase just for compatibility with code that relied on explicitly setting the learning phase for other values. Args: value: Learning phase value, either 0 or 1 (integers). 0 = test, 1 = train Raises: ValueError: if `value` is neither `0` nor `1`. >rrRz%Expected learning phase to be 0 or 1.TN) ValueErrorrrorrgrar?rbr>rS)rjr9r9r:r{s  r{z"keras.backend.learning_phase_scopec cs0tdt|z dVWdXWdQRXdS)aSProvides a scope within which the learning phase is equal to `value`. The learning phase gets restored to its original value upon exiting the scope. Args: value: Learning phase value, either 0 or 1 (integers). 0 = test, 1 = train Yields: None. Raises: ValueError: if `value` is neither `0` nor `1`. z`tf.keras.backend.learning_phase_scope` is deprecated and will be removed after 2020-10-11. To update it, simply pass a True/False value to the `training` argument of the `__call__` method of your layer or model.N)ryrz(deprecated_internal_learning_phase_scope)rjr9r9r:learning_phase_scopes    rccs|dkrtdt*tr0ttjd}tt d}WdQRXtj }zt |dVWd|sldt_ tZtr|dk r|ttj<ntjtkrttj=t }|dk r|t|<n|tkrt|=WdQRXXdS)a^An internal-only version of `learning_phase_scope`. Unlike the public method, this method does not raise a deprecation warning. This is needed because saved model saving needs to set learning phase to maintain compatibility with code that sets/gets the learning phase, but saved model saving itself shouldn't raise a deprecation warning. We can get rid of this method and its usages when the public API is removed. Args: value: Learning phase value, either 0 or 1 (integers). 0 = test, 1 = train Yields: None. Raises: ValueError: if `value` is neither `0` nor `1`. >rrRz%Expected learning phase to be 0 or 1.NF) r}rrorrgrbgetrar>rSr?r{)rjZprevious_eager_valueZprevious_graph_valueZlearning_phase_previously_setrYr9r9r:r~s0       r~c cs\|dks ttstt}|r(t}z|ttj<dVWd|rN|ttj<nttj=XdS)aInternal scope that sets the learning phase in eager / tf.function only. Args: value: Learning phase value, either 0 or 1 (integers). 0 = test, 1 = train Yields: None. Raises: ValueError: if `value` is neither `0` nor `1`. >rrRN)AssertionErrorr#executing_eagerly_outside_functionsrrrqrbrar>)rjZglobal_learning_phase_was_setprevious_valuer9r9r:eager_learning_phase_scope*s     rcCs"t|dd}|rt|r|SdS)zConvert `obj` to a graph element if possible, otherwise return `None`. Args: obj: Object to convert. Returns: The result of `obj._as_graph_element()` if that method is available; otherwise `None`. _as_graph_elementN)rmcallable)objZconv_fnr9r9r:rIs  rcCs@t|dd}t|dd}|r<|r<||k rt}t}||tr,tj|jStj |jSdS)aReturn explicit device of current context, otherwise returns `None`. Returns: If the current device scope is explicitly set, it returns a string with the device (`CPU` or `GPU`). If the scope is not explicitly set, it will return `None`. N) rSrZ_apply_device_functionsrenabledr rZ from_stringrZ DeviceSpecV1)rYopr9r9r:_get_current_tf_deviceJs  rcCs4|}|dkrtdt}|dk o2|j|kS)ajCheck if the current device is explicitly set on the device type specified. Args: device_type: A string containing `GPU` or `CPU` (case-insensitive). Returns: A boolean indicating if the current device scope is explicitly set on the device type. Raises: ValueError: If the `device_type` string indicates an unsupported device. )CPUGPUz.`device_type` should be either "CPU" or "GPU".N)upperr}r device_type)rrr9r9r:_is_current_explicit_device[s rcCs<trddtdDStdkr.taddtDS)zqGet a list of available GPU devices (formatted as strings). Returns: A list of available GPU devices. cSsg|] }|jqSr9)rv).0dr9r9r: wsz'_get_available_gpus..rNcSsg|]}|jdkr|jqS)r)rrv)rrOr9r9r:r|s)rrr Zlist_logical_devices_LOCAL_DEVICESrZ list_devicesr9r9r9r:_get_available_gpusos  rcCstd}tt}| o|S)aDCheck whether the current scope supports NCHW ops. TensorFlow does not support NCHW on CPU. Therefore we check if we are not explicitly put on CPU, and have GPUs available. In this case there will be soft-placing on the GPU device. Returns: bool: if the current scope device placement would support nchw r)rboolr)Zexplicitly_on_cpuZgpus_availabler9r9r:_has_nchw_supports  rcCstj||dS)a8Convert the input `x` to a tensor of type `dtype`. This is slightly faster than the _to_tensor function, at the cost of handling fewer cases. Args: x: An object to be converted (numpy arrays, floats, ints and lists of them). dtype: The destination type. Returns: A tensor. )rE)r constant)rOrEr9r9r:_constant_to_tensorsrcCstj||dS)zConvert the input `x` to a tensor of type `dtype`. Args: x: An object to be converted (numpy array, list, tensors). dtype: The destination type. Returns: A tensor. )rE)r"convert_to_tensor_v2_with_dispatch)rOrEr9r9r: _to_tensors rzkeras.backend.is_sparsecCs,t|dd}|dk r t|tjSt|tjS)acReturns whether a tensor is a sparse tensor. Args: tensor: A tensor instance. Returns: A boolean. Example: >>> a = tf.keras.backend.placeholder((2, 2), sparse=False) >>> print(tf.keras.backend.is_sparse(a)) False >>> b = tf.keras.backend.placeholder((2, 2), sparse=True) >>> print(tf.keras.backend.is_sparse(b)) True Z _type_specN)rmrFrSparseTensorSpecrJ)tensorspecr9r9r: is_sparses  rzkeras.backend.to_densecCst|rt|S|SdS)axConverts a sparse tensor into a dense tensor and returns it. Args: tensor: A tensor instance (potentially sparse). Returns: A dense tensor. Examples: >>> b = tf.keras.backend.placeholder((2, 2), sparse=True) >>> print(tf.keras.backend.is_sparse(b)) True >>> c = tf.keras.backend.to_dense(b) >>> print(tf.keras.backend.is_sparse(c)) False N)rr(sparse_tensor_to_dense)rr9r9r:to_denses rzkeras.backend.name_scopecCs t|S)aaA context manager for use when defining a Python op. This context manager pushes a name scope, which will make the name of all operations added within it have a prefix. For example, to define a new Python op called `my_op`: def my_op(a): with tf.name_scope("MyOp") as scope: a = tf.convert_to_tensor(a, name="a") # Define some computation that uses `a`. return foo_op(..., name=scope) When executed, the Tensor `a` will have the name `MyOp/a`. Args: name: The prefix to use on all names created within the name scope. Returns: Name scope context manager. )rZ name_scope_v2)rvr9r9r:rwsrwzkeras.backend.variablecCs|dkrt}t|drd|}tt|jdt|jdfd}tj ||j |j d}|j |_ |St j|t|||d}t|tjr|j |_ nt|drt||_ t||S)aInstantiates a variable and returns it. Args: value: Numpy array, initial value of the tensor. dtype: Tensor type. name: Optional name string for the tensor. constraint: Optional projection function to be applied to the variable after an optimizer update. Returns: A variable instance (with Keras metadata included). Examples: >>> val = np.array([[1, 2], [3, 4]]) >>> kvar = tf.keras.backend.variable(value=val, dtype='float64', ... name='example_var') >>> tf.keras.backend.dtype(kvar) 'float64' >>> print(kvar) NtocoorR)indicesvaluesZ dense_shape)rErv constraintru)rLhasattrrrM concatenate expand_dimsrowcolrrJdataru _keras_shaperHrI dtypes_moduleas_dtyperFZndarray int_shapetrack_variable)rjrErvrZ sparse_coorvr9r9r:variable s*     rcCs"tr dStd}||dS)zBTracks the given TF optimizer for initialization of its variables.N)rrgrfadd)Z tf_optimizerZ optimizersr9r9r:track_tf_optimizer=srz)keras.__internal__.backend.track_variablecCs4tr dSt|dr|jnt}t||dS)z-Tracks the given variable for initialization.NrY)rrgrrYrSrdr)rrYr9r9r:rEsrcCst|dS)zFObserve a name and make sure it won't be used by `unique_object_name`.N)r\r)rvr9r9r:observe_object_nameNsrc Cs|dkrt}|dkr&|r t}nt}d}xx|dks<||kr||f}|r|||}|rf|dt|}n|}||d7<q,||d7<|dt||}q,W|S)aMakes a object name (or arbitrary string) unique within a TensorFlow graph. Args: name: String name to make unique. name_uid_map: An optional defaultdict(int) to use when creating unique names. If None (default), uses a per-Graph dictionary. avoid_names: An optional set or dict with names which should not be used. If None (default), don't avoid any names unless `avoid_observed_names` is True. namespace: Gets a name which is unique within the (graph, namespace). Layers which are not Networks use a blank namespace and so get graph-global names. zero_based: If True, name sequences start with no suffix (e.g. "dense", "dense_1"). If False, naming is one-based ("dense_1", "dense_2"). avoid_observed_names: If True, avoid any names that have been observed by `backend.observe_object_name`. Returns: Unique string name. Example: unique_object_name('dense') # dense_1 unique_object_name('dense') # dense_2 N_rR)rr\setstr) rvrZ avoid_names namespaceZ zero_basedZavoid_observed_namesZ proposed_nameZname_keynumberr9r9r:unique_object_nameSs$!rcCs:tr tt|}x t|D]}||jqW|S)zFReturns variables corresponding to the given graph for initialization.)rrgrrdrfupdateZ optimizerr,)rYr,optr9r9r:_get_variabless  rz/keras.__internal__.backend.initialize_variablescstt}g}x"|D]}t|dds||qW|r|dd|Dfddt|D}g}x*t||D]\}}|r||d|_qpW|r|t |dS)z9Utility to initialize uninitialized variables on the fly._keras_initializedFcSsg|]}t|qSr9)rHZis_variable_initialized)rrr9r9r:rsz)_initialize_variables..cs$g|]\}}| o|jdk qS)N) initializer)rnr)is_initializedr9r:rsTN) rrSrmappendrun enumerateziprrHZvariables_initializer)rr,Zcandidate_varsrZshould_be_initializedZuninitialized_varsflagr9)rr:rs"       rzkeras.backend.constantcCs |dkrt}tj||||dS)aCreates a constant tensor. Args: value: A constant value (or list) dtype: The type of the elements of the resulting tensor. shape: Optional dimensions of resulting tensor. name: Optional name for the tensor. Returns: A Constant Tensor. N)rErurv)rLr r)rjrErurvr9r9r:rsrzkeras.backend.is_keras_tensorcCsTt|tjtjtjtjt j fs6t dt t |dtrJt|t j St|dS)aReturns whether `x` is a Keras tensor. A "Keras tensor" is a tensor that was returned by a Keras layer, (`Layer` class) or by `Input`. Args: x: A candidate tensor. Returns: A boolean: Whether the argument is a Keras tensor. Raises: ValueError: In case `x` is not a symbolic tensor. Examples: >>> np_var = np.array([1, 2]) >>> # A numpy array is not a symbolic tensor. >>> tf.keras.backend.is_keras_tensor(np_var) Traceback (most recent call last): ... ValueError: Unexpectedly found an instance of type ``. Expected a symbolic tensor instance. >>> keras_var = tf.keras.backend.variable(np_var) >>> # A variable created with the keras backend is not a Keras tensor. >>> tf.keras.backend.is_keras_tensor(keras_var) False >>> keras_placeholder = tf.keras.backend.placeholder(shape=(2, 4, 5)) >>> # A placeholder is a Keras tensor. >>> tf.keras.backend.is_keras_tensor(keras_placeholder) True >>> keras_input = tf.keras.layers.Input([10]) >>> # An Input is a Keras tensor. >>> tf.keras.backend.is_keras_tensor(keras_input) True >>> keras_layer_output = tf.keras.layers.Dense(10)(keras_input) >>> # Any Keras layer output is a Keras tensor. >>> tf.keras.backend.is_keras_tensor(keras_layer_output) True z(Unexpectedly found an instance of type `z'`. Expected a symbolic tensor instance._keras_history)rFrrGrHrIrrJr- RaggedTensorrZ KerasTensorr}rrrr)rOr9r9r:is_keras_tensors+  rzkeras.backend.placeholderc Cs|r|rtd|dkrt}|s.|r.d|}tr|rJtj||d}nn|rd}xBtdt|D]0}||dkst||drb||j dkrb|}qbWt j |||d}nt j |||d }tj||d } nt|rtj|||d } np|rJd}x*tdt|D]}||dkr|}qWt j |||d} d d } tj| | dd} ntj|||d } WdQRXtrddlm} | j| d} d| _| S)a0Instantiates a placeholder tensor and returns it. Args: shape: Shape of the placeholder (integer tuple, may include `None` entries). ndim: Number of axes of the tensor. At least one of {`shape`, `ndim`} must be specified. If both are specified, `shape` is used. dtype: Placeholder type. sparse: Boolean, whether the placeholder should have a sparse type. name: Optional name string for the placeholder. ragged: Boolean, whether the placeholder should have a ragged type. In this case, values of 'None' in the 'shape' argument represent ragged dimensions. For more information about RaggedTensors, see this [guide](https://www.tensorflow.org/guide/ragged_tensors). Raises: ValueError: If called with sparse = True and ragged = True. Returns: Tensor instance (with Keras metadata included). Examples: >>> input_ph = tf.keras.backend.placeholder(shape=(2, 4, 5)) >>> input_ph zFCannot set both sparse and ragged to True when creating a placeholder.N)N)rurErrRrj)rurE ragged_rank)rurErv)rv)rurvcSst|j|jS)N)r placeholderrEru)Z tensorspecr9r9r:tensor_spec_to_placeholderGsz/placeholder..tensor_spec_to_placeholderT)expand_composites) input_layer)r)r}rLrrrrrangelenrrjr-ZRaggedTensorSpecrZ TensorSpecrZkeras_tensor_from_type_specrSr`rZsparse_placeholderr1 map_structurerrrgtensorflow.python.keras.enginerZInput_is_backend_placeholder) rundimrEsparservraggedrrirOZ type_specrrr9r9r:rsV&          rcCsryXtrt|dSddlm}||rJtj|dd}tdd|DS|j j dkSWnt k rld SXd S) znReturns whether `x` is a placeholder. Args: x: A candidate placeholder. Returns: Boolean. rr)tf_utilsT)rcss|]}t|VqdS)N)rt)rcr9r9r: hsz!is_placeholder..Z PlaceholderFN) rrrtensorflow.python.keras.utilsris_extension_typer1flattenpy_anyrrAttributeError)rOrZflat_componentsr9r9r:rtYs    rtzkeras.backend.shapecCs t|S)aReturns the symbolic shape of a tensor or variable. Args: x: A tensor or variable. Returns: A symbolic shape (which is itself a tensor). Examples: >>> val = np.array([[1, 2], [3, 4]]) >>> kvar = tf.keras.backend.variable(value=val) >>> tf.keras.backend.shape(kvar) >>> input = tf.keras.backend.placeholder(shape=(2, 4, 5)) >>> tf.keras.backend.shape(input) )rru)rOr9r9r:ruosruzkeras.backend.int_shapecCs:y |j}t|tst|}|Stk r4dSXdS)aReturns the shape of tensor or variable as a tuple of int or None entries. Args: x: Tensor or variable. Returns: A tuple of integers (or None entries). Examples: >>> input = tf.keras.backend.placeholder(shape=(2, 4, 5)) >>> tf.keras.backend.int_shape(input) (2, 4, 5) >>> val = np.array([[1, 2], [3, 4]]) >>> kvar = tf.keras.backend.variable(value=val) >>> tf.keras.backend.int_shape(kvar) (2, 2) N)rurFras_listr})rOrur9r9r:rs  rzkeras.backend.ndimcCs|jjS)aReturns the number of axes in a tensor, as an integer. Args: x: Tensor or variable. Returns: Integer (scalar), number of axes. Examples: >>> input = tf.keras.backend.placeholder(shape=(2, 4, 5)) >>> val = np.array([[1, 2], [3, 4]]) >>> kvar = tf.keras.backend.variable(value=val) >>> tf.keras.backend.ndim(input) 3 >>> tf.keras.backend.ndim(kvar) 2 )rurank)rOr9r9r:rsrzkeras.backend.dtypecCs |jjjS)aQReturns the dtype of a Keras tensor or variable, as a string. Args: x: Tensor or variable. Returns: String, dtype of `x`. Examples: >>> tf.keras.backend.dtype(tf.keras.backend.placeholder(shape=(2,4,5))) 'float32' >>> tf.keras.backend.dtype(tf.keras.backend.placeholder(shape=(2,4,5), ... dtype='float32')) 'float32' >>> tf.keras.backend.dtype(tf.keras.backend.placeholder(shape=(2,4,5), ... dtype='float64')) 'float64' >>> kvar = tf.keras.backend.variable(np.array([[1, 2], [3, 4]])) >>> tf.keras.backend.dtype(kvar) 'float32' >>> kvar = tf.keras.backend.variable(np.array([[1, 2], [3, 4]]), ... dtype='float32') >>> tf.keras.backend.dtype(kvar) 'float32' )rE base_dtyperv)rOr9r9r:rEsrEcCst|jjS)zReturns the numpy dtype of a Keras tensor or variable. Args: x: Tensor or variable. Returns: numpy.dtype, dtype of `x`. )rrrEas_numpy_dtype)rOr9r9r: dtype_numpys rzkeras.backend.evalcCs tt|S)aHEvaluates the value of a variable. Args: x: A variable. Returns: A Numpy array. Examples: >>> kvar = tf.keras.backend.variable(np.array([[1, 2], [3, 4]]), ... dtype='float32') >>> tf.keras.backend.eval(kvar) array([[1., 2.], [3., 4.]], dtype=float32) ) get_valuer)rOr9r9r:evalsrzkeras.backend.zerosc Cs\tJ|dkrt}t|}tj|||d}t|j rNt |||dS|SQRXdS)a(Instantiates an all-zeros variable and returns it. Args: shape: Tuple or list of integers, shape of returned Keras variable dtype: data type of returned Keras variable name: name of returned Keras variable Returns: A variable (including Keras metadata), filled with `0.0`. Note that if `shape` was symbolic, we cannot return a variable, and will return a dynamically-shaped tensor instead. Example: >>> kvar = tf.keras.backend.zeros((3,4)) >>> tf.keras.backend.eval(kvar) array([[0., 0., 0., 0.], [0., 0., 0., 0.], [0., 0., 0., 0.]], dtype=float32) >>> A = tf.constant([1,2,3]) >>> kvar2 = tf.keras.backend.zeros(A.shape) # [0., 0., 0.] >>> tf.keras.backend.eval(kvar2) array([0., 0., 0.], dtype=float32) >>> kvar3 = tf.keras.backend.zeros(A.shape,dtype=tf.int32) >>> tf.keras.backend.eval(kvar3) array([0, 0, 0], dtype=int32) >>> kvar4 = tf.keras.backend.zeros([2,3]) >>> tf.keras.backend.eval(kvar4) array([[0., 0., 0.], [0., 0., 0.]], dtype=float32) N)rurErv)rErv) rrorLrrrzerospy_allrurr)rurErvtf_dtyperr9r9r:rs#  rzkeras.backend.onesc Cs\tJ|dkrt}t|}tj|||d}t|j rNt |||dS|SQRXdS)alInstantiates an all-ones variable and returns it. Args: shape: Tuple of integers, shape of returned Keras variable. dtype: String, data type of returned Keras variable. name: String, name of returned Keras variable. Returns: A Keras variable, filled with `1.0`. Note that if `shape` was symbolic, we cannot return a variable, and will return a dynamically-shaped tensor instead. Example: >>> kvar = tf.keras.backend.ones((3,4)) >>> tf.keras.backend.eval(kvar) array([[1., 1., 1., 1.], [1., 1., 1., 1.], [1., 1., 1., 1.]], dtype=float32) N)rurErv)rErv) rrorLrrronesrrurr)rurErvr rr9r9r:r 5s  r zkeras.backend.eyecCs.|dkrt}t|}ttj||d||S)aInstantiate an identity matrix and returns it. Args: size: Integer, number of rows/columns. dtype: String, data type of returned Keras variable. name: String, name of returned Keras variable. Returns: A Keras variable, an identity matrix. Example: >>> kvar = tf.keras.backend.eye(3) >>> tf.keras.backend.eval(kvar) array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]], dtype=float32) N)rE)rLrrrr"eye)sizerErvr r9r9r:r Ys r zkeras.backend.zeros_likecCstj|||dS)a;Instantiates an all-zeros variable of the same shape as another tensor. Args: x: Keras variable or Keras tensor. dtype: dtype of returned Keras variable. `None` uses the dtype of `x`. name: name for the variable to create. Returns: A Keras variable with the shape of `x` filled with zeros. Example: ```python from tensorflow.keras import backend as K kvar = K.variable(np.random.random((2,3))) kvar_zeros = K.zeros_like(kvar) K.eval(kvar_zeros) # array([[ 0., 0., 0.], [ 0., 0., 0.]], dtype=float32) ``` )rErv)r zeros_like)rOrErvr9r9r:r xsr zkeras.backend.ones_likecCstj|||dS)a9Instantiates an all-ones variable of the same shape as another tensor. Args: x: Keras variable or tensor. dtype: String, dtype of returned Keras variable. None uses the dtype of x. name: String, name for the variable to create. Returns: A Keras variable with the shape of x filled with ones. Example: >>> kvar = tf.keras.backend.variable(np.random.random((2,3))) >>> kvar_ones = tf.keras.backend.ones_like(kvar) >>> tf.keras.backend.eval(kvar_ones) array([[1., 1., 1.], [1., 1., 1.]], dtype=float32) )rErv)r ones_like)rOrErvr9r9r:rsrcCstj||dS)zReturns a tensor with the same content as the input tensor. Args: x: The input tensor. name: String, name for the variable to create. Returns: A tensor of the same shape, type and content. )rv)ridentity)rOrvr9r9r:rs rz%keras.backend.random_uniform_variablecCsP|dkrt}t|}|dkr,tjd}tj||||d|}t|||dS)aInstantiates a variable with values drawn from a uniform distribution. Args: shape: Tuple of integers, shape of returned Keras variable. low: Float, lower boundary of the output interval. high: Float, upper boundary of the output interval. dtype: String, dtype of returned Keras variable. name: String, name of returned Keras variable. seed: Integer, random seed. Returns: A Keras variable, filled with drawn samples. Example: >>> kvar = tf.keras.backend.random_uniform_variable(shape=(2,3), ... low=0.0, high=1.0) >>> kvar NgeA)rEseed)rErv) rLrrrMrandomrandintr!Zrandom_uniform_initializerr)rulowhighrErvrr rjr9r9r:random_uniform_variables  rz$keras.backend.random_normal_variablecCsP|dkrt}t|}|dkr,tjd}tj||||d|}t|||dS)aInstantiates a variable with values drawn from a normal distribution. Args: shape: Tuple of integers, shape of returned Keras variable. mean: Float, mean of the normal distribution. scale: Float, standard deviation of the normal distribution. dtype: String, dtype of returned Keras variable. name: String, name of returned Keras variable. seed: Integer, random seed. Returns: A Keras variable, filled with drawn samples. Example: >>> kvar = tf.keras.backend.random_normal_variable(shape=(2,3), ... mean=0.0, scale=1.0) >>> kvar NgeA)rEr)rErv) rLrrrMrrr!Zrandom_normal_initializerr)rumeanscalerErvrr rjr9r9r:random_normal_variables  rzkeras.backend.count_paramscCst|jS)akReturns the static number of elements in a variable or tensor. Args: x: Variable or tensor. Returns: Integer, the number of scalars in `x`. Example: >>> kvar = tf.keras.backend.zeros((2,3)) >>> tf.keras.backend.count_params(kvar) 6 >>> tf.keras.backend.eval(kvar) array([[0., 0., 0.], [0., 0., 0.]], dtype=float32) )rMprodrur)rOr9r9r: count_paramssrzkeras.backend.castcCs t||S)aCasts a tensor to a different dtype and returns it. You can cast a Keras variable but it still returns a Keras tensor. Args: x: Keras tensor (or variable). dtype: String, either (`'float16'`, `'float32'`, or `'float64'`). Returns: Keras tensor with dtype `dtype`. Examples: Cast a float32 variable to a float64 tensor >>> input = tf.keras.backend.ones(shape=(1,3)) >>> print(input) >>> cast_input = tf.keras.backend.cast(input, dtype='float64') >>> print(cast_input) tf.Tensor([[1. 1. 1.]], shape=(1, 3), dtype=float64) )r%rK)rOrEr9r9r:rKsrKzkeras.backend.updatecCs t||S)N)r)assign)rOZnew_xr9r9r:r;srzkeras.backend.update_addcCs t||S)zUpdate the value of `x` by adding `increment`. Args: x: A Variable. increment: A tensor of same shape as `x`. Returns: The variable `x` updated. )r)Z assign_add)rO incrementr9r9r: update_addAs rzkeras.backend.update_subcCs t||S)zUpdate the value of `x` by subtracting `decrement`. Args: x: A Variable. decrement: A tensor of same shape as `x`. Returns: The variable `x` updated. )r)Z assign_sub)rOZ decrementr9r9r: update_subPs rz#keras.backend.moving_average_updatecCsTtr>t||j}t||j}||||d|Stj|||ddSdS)aCompute the exponential moving average of a value. The moving average 'x' is updated with 'value' following: ``` x = x * momentum + value * (1 - momentum) ``` For example: >>> x = tf.Variable(0.0) >>> momentum=0.9 >>> moving_average_update(x, value = 2.0, momentum=momentum).numpy() >>> x.numpy() 0.2 The result will be biased towards the initial value of the variable. If the variable was initialized to zero, you can divide by `1 - momentum ** num_updates` to debias it (Section 3 of [Kingma et al., 2015](https://arxiv.org/abs/1412.6980)): >>> num_updates = 1.0 >>> x_zdb = x/(1 - momentum**num_updates) >>> x_zdb.numpy() 2.0 Args: x: A Variable, the moving average. value: A tensor with the same shape as `x`, the new value to be averaged in. momentum: The moving average momentum. Returns: The updated variable. rRT)Z zero_debiasN)rrr%rKrErr/Zassign_moving_average)rOrjZmomentumr9r9r:moving_average_update_s 'rzkeras.backend.dotc Cszt|dk rRt|dks(t|dkrRg}xDtt|tt|D]&\}}|dk rd||qH||qHWt|}g}xDtt|tt|D]&\}}|dk r||q||qWt|}tt t|}| dg|}t |d|dg}t tj ||d|ddg}t t |||dd|dd|ddSt|rjt||} n t ||} | S)aXMultiplies 2 tensors (and/or variables) and returns a tensor. This operation corresponds to `numpy.dot(a, b, out=None)`. Args: x: Tensor or variable. y: Tensor or variable. Returns: A tensor, dot product of `x` and `y`. Examples: If inputs `x` and `y` are 2-D arrays, then it is equivalent to `tf.matmul`. >>> x = tf.keras.backend.placeholder(shape=(2, 3)) >>> y = tf.keras.backend.placeholder(shape=(3, 4)) >>> xy = tf.keras.backend.dot(x, y) >>> xy >>> x = tf.keras.backend.placeholder(shape=(32, 28, 3)) >>> y = tf.keras.backend.placeholder(shape=(3, 4)) >>> xy = tf.keras.backend.dot(x, y) >>> xy If `x` is an N-D array and `y` is an M-D array (where M>=2), it is a sum product over the last axis of `x` and the second-to-last axis of `y`. >>> x = tf.keras.backend.random_uniform_variable(shape=(2, 3), low=0, high=1) >>> y = tf.keras.backend.ones((4, 3, 5)) >>> xy = tf.keras.backend.dot(x, y) >>> tf.keras.backend.int_shape(xy) (2, 4, 5) N)perm)rrrrunstackrurrlistrrereshape transposer%matmulrr(Zsparse_tensor_dense_matmul) rOyx_shapersy_shapeZ y_permute_dimZxtZytoutr9r9r:dots0&($ $ 0  r.zkeras.backend.batch_dotcCst|}t|}t|}t|}|dks0|dkrPtdt|dt|d|d}|d}|dk r|dk r||krtdt|dt|dt|tr||g}|dkr|dkr|d|dg}n|d|dg}td d |Drtd t|t|}|ddkr$|d|7<|ddkrB|d|7<d|krTtd |\} } || } || } | dk r| dk r| | krtd t|dt|dt|d|d|d| | f|} |}|dkrt |d}| d7} |d7}|dkrt |d}|d7}| |dkrntt |}x(t | |dD]}||d||<q@W| |d<t ||}| dkrtt |}x&t | ddD]}||d||<qW| |d<t ||}|dkrt |}|dd}t |dd|dg}t||}d}nd}|dkrTt |}|dd}t |d|ddg}t||}d}nd}t||}t |}d}|rt|dd||ddgd}d}|rt|dd|gd}d}|rt||}| dkrt|d}n|dkrt|d}|S)aZBatchwise dot product. `batch_dot` is used to compute dot product of `x` and `y` when `x` and `y` are data in batch, i.e. in a shape of `(batch_size, :)`. `batch_dot` results in a tensor or variable with less dimensions than the input. If the number of dimensions is reduced to 1, we use `expand_dims` to make sure that ndim is at least 2. Args: x: Keras tensor or variable with `ndim >= 2`. y: Keras tensor or variable with `ndim >= 2`. axes: Tuple or list of integers with target dimensions, or single integer. The sizes of `x.shape[axes[0]]` and `y.shape[axes[1]]` should be equal. Returns: A tensor with shape equal to the concatenation of `x`'s shape (less the dimension that was summed over) and `y`'s shape (less the batch dimension and the dimension that was summed over). If the final rank is 1, we reshape it to `(batch_size, 1)`. Examples: >>> x_batch = tf.keras.backend.ones(shape=(32, 20, 1)) >>> y_batch = tf.keras.backend.ones(shape=(32, 30, 20)) >>> xy_batch_dot = tf.keras.backend.batch_dot(x_batch, y_batch, axes=(1, 2)) >>> tf.keras.backend.int_shape(xy_batch_dot) (32, 1, 30) Shape inference: Let `x`'s shape be `(100, 20)` and `y`'s shape be `(100, 30, 20)`. If `axes` is (1, 2), to find the output shape of resultant tensor, loop through each dimension in `x`'s shape and `y`'s shape: * `x.shape[0]` : 100 : append to output shape * `x.shape[1]` : 20 : do not append to output shape, dimension 1 of `x` has been summed over. (`dot_axes[0]` = 1) * `y.shape[0]` : 100 : do not append to output shape, always ignore first dimension of `y` * `y.shape[1]` : 30 : append to output shape * `y.shape[2]` : 20 : do not append to output shape, dimension 2 of `y` has been summed over. (`dot_axes[1]` = 2) `output_shape` = `(100, 30)` r zICannot do batch_dot on inputs with rank < 2. Received inputs with shapes z and .rNzVCannot do batch_dot on inputs with different batch sizes. Received inputs with shapes rRcss|]}t|ttfVqdS)N)rFr%r)rar9r9r:r$szbatch_dot..zYMultiple target dimensions are not supported. Expected: None, int, (int, int), Provided: zCannot perform batch_dot over axis 0. If your inputs are not batched, add a dummy batch dimension to your inputs using K.expand_dims(x, 0)z*Cannot do batch_dot on inputs with shapes z with axes=z(. x.shape[%d] != y.shape[%d] (%d != %d).r"TF)rrr}rrFrWrr%rrrr'rustackr&r%r(concatsqueeze)rOr)axesr*r,Zx_ndimZy_ndimZ x_batch_sizeZ y_batch_sizeZa0Za1Zd1Zd2Z orig_x_ndimZ orig_y_ndimpatternrZ x_mid_dimsZx_squashed_shapeZ x_squashedZ y_trail_dimsZy_squashed_shapeZ y_squashedresult output_shapeZ do_reshaper9r9r: batch_dots/  $                      r9zkeras.backend.transposecCs t|S)aTransposes a tensor and returns it. Args: x: Tensor or variable. Returns: A tensor. Examples: >>> var = tf.keras.backend.variable([[1, 2, 3], [4, 5, 6]]) >>> tf.keras.backend.eval(var) array([[1., 2., 3.], [4., 5., 6.]], dtype=float32) >>> var_transposed = tf.keras.backend.transpose(var) >>> tf.keras.backend.eval(var_transposed) array([[1., 4.], [2., 5.], [3., 6.]], dtype=float32) >>> input = tf.keras.backend.placeholder((2, 3)) >>> input >>> input_transposed = tf.keras.backend.transpose(input) >>> input_transposed )rr')rOr9r9r:r'sr'zkeras.backend.gathercCs t||S)aGRetrieves the elements of indices `indices` in the tensor `reference`. Args: reference: A tensor. indices: An integer tensor of indices. Returns: A tensor of same type as `reference`. Examples: >>> var = tf.keras.backend.variable([[1, 2, 3], [4, 5, 6]]) >>> tf.keras.backend.eval(var) array([[1., 2., 3.], [4., 5., 6.]], dtype=float32) >>> var_gathered = tf.keras.backend.gather(var, [0]) >>> tf.keras.backend.eval(var_gathered) array([[1., 2., 3.]], dtype=float32) >>> var_gathered = tf.keras.backend.gather(var, [1]) >>> tf.keras.backend.eval(var_gathered) array([[4., 5., 6.]], dtype=float32) >>> var_gathered = tf.keras.backend.gather(var, [0,1,0]) >>> tf.keras.backend.eval(var_gathered) array([[1., 2., 3.], [4., 5., 6.], [1., 2., 3.]], dtype=float32) )rgather) referencerr9r9r:r:sr:zkeras.backend.maxcCst|||S)aMaximum value in a tensor. Args: x: A tensor or variable. axis: An integer, the axis to find maximum values. keepdims: A boolean, whether to keep the dimensions or not. If `keepdims` is `False`, the rank of the tensor is reduced by 1. If `keepdims` is `True`, the reduced dimension is retained with length 1. Returns: A tensor with maximum values of `x`. )r% reduce_max)rOaxiskeepdimsr9r9r:maxsr?zkeras.backend.mincCst|||S)aMinimum value in a tensor. Args: x: A tensor or variable. axis: An integer, the axis to find minimum values. keepdims: A boolean, whether to keep the dimensions or not. If `keepdims` is `False`, the rank of the tensor is reduced by 1. If `keepdims` is `True`, the reduced dimension is retained with length 1. Returns: A tensor with minimum values of `x`. )r%Z reduce_min)rOr=r>r9r9r:minsr@zkeras.backend.sumcCst|||S)aSum of the values in a tensor, alongside the specified axis. Args: x: A tensor or variable. axis: An integer, the axis to sum over. keepdims: A boolean, whether to keep the dimensions or not. If `keepdims` is `False`, the rank of the tensor is reduced by 1. If `keepdims` is `True`, the reduced dimension is retained with length 1. Returns: A tensor with sum of `x`. )r% reduce_sum)rOr=r>r9r9r:sum srBzkeras.backend.prodcCst|||S)aMultiplies the values in a tensor, alongside the specified axis. Args: x: A tensor or variable. axis: An integer, the axis to compute the product. keepdims: A boolean, whether to keep the dimensions or not. If `keepdims` is `False`, the rank of the tensor is reduced by 1. If `keepdims` is `True`, the reduced dimension is retained with length 1. Returns: A tensor with the product of elements of `x`. )r%Z reduce_prod)rOr=r>r9r9r:r srzkeras.backend.cumsumcCstj||dS)zCumulative sum of the values in a tensor, alongside the specified axis. Args: x: A tensor or variable. axis: An integer, the axis to compute the sum. Returns: A tensor of the cumulative sum of values of `x` along `axis`. )r=)r%cumsum)rOr=r9r9r:rC) s rCzkeras.backend.cumprodcCstj||dS)aCumulative product of the values in a tensor, alongside the specified axis. Args: x: A tensor or variable. axis: An integer, the axis to compute the product. Returns: A tensor of the cumulative product of values of `x` along `axis`. )r=)r%cumprod)rOr=r9r9r:rD9 s rDzkeras.backend.varcCs,|jjtjkrt|t}tj|||dS)aVariance of a tensor, alongside the specified axis. Args: x: A tensor or variable. axis: An integer, the axis to compute the variance. keepdims: A boolean, whether to keep the dimensions or not. If `keepdims` is `False`, the rank of the tensor is reduced by 1. If `keepdims` is `True`, the reduced dimension is retained with length 1. Returns: A tensor with the variance of elements of `x`. )r=r>)rErrrr%rKrLZreduce_variance)rOr=r>r9r9r:varI srEzkeras.backend.stdcCs,|jjtjkrt|t}tj|||dS)aStandard deviation of a tensor, alongside the specified axis. It is an alias to `tf.math.reduce_std`. Args: x: A tensor or variable. It should have numerical dtypes. Boolean type inputs will be converted to float. axis: An integer, the axis to compute the standard deviation. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(x), rank(x))`. keepdims: A boolean, whether to keep the dimensions or not. If `keepdims` is `False`, the rank of the tensor is reduced by 1. If `keepdims` is `True`, the reduced dimension is retained with length 1. Returns: A tensor with the standard deviation of elements of `x` with same dtype. Boolean type input will be converted to float. )r=r>)rErrrr%rKrLZ reduce_std)rOr=r>r9r9r:std^ srFzkeras.backend.meancCs*|jjtjkrt|t}t|||S)aMean of a tensor, alongside the specified axis. Args: x: A tensor or variable. axis: A list of integer. Axes to compute the mean. keepdims: A boolean, whether to keep the dimensions or not. If `keepdims` is `False`, the rank of the tensor is reduced by 1 for each entry in `axis`. If `keepdims` is `True`, the reduced dimensions are retained with length 1. Returns: A tensor with the mean of elements of `x`. )rErrrr%rKrLZ reduce_mean)rOr=r>r9r9r:rz srzkeras.backend.anycCst|tj}t|||S)zBitwise reduction (logical OR). Args: x: Tensor or variable. axis: axis along which to perform the reduction. keepdims: whether the drop or broadcast the reduction axes. Returns: A uint8 tensor (0s and 1s). )r%rKrrZ reduce_any)rOr=r>r9r9r:any srGzkeras.backend.allcCst|tj}t|||S)zBitwise reduction (logical AND). Args: x: Tensor or variable. axis: axis along which to perform the reduction. keepdims: whether the drop or broadcast the reduction axes. Returns: A uint8 tensor (0s and 1s). )r%rKrrZ reduce_all)rOr=r>r9r9r:all srHzkeras.backend.argmaxr"cCs t||S)zReturns the index of the maximum value along an axis. Args: x: Tensor or variable. axis: axis along which to perform the reduction. Returns: A tensor. )r%argmax)rOr=r9r9r:rI s rIzkeras.backend.argmincCs t||S)zReturns the index of the minimum value along an axis. Args: x: Tensor or variable. axis: axis along which to perform the reduction. Returns: A tensor. )r%argmin)rOr=r9r9r:rJ s rJzkeras.backend.squarecCs t|S)zYElement-wise square. Args: x: Tensor or variable. Returns: A tensor. )r%square)rOr9r9r:rK s rKzkeras.backend.abscCs t|S)zaElement-wise absolute value. Args: x: Tensor or variable. Returns: A tensor. )r%abs)rOr9r9r:rL s rLzkeras.backend.sqrtcCs$td|jj}t||}t|S)zElement-wise square root. This function clips negative tensor values to 0 before computing the square root. Args: x: Tensor or variable. Returns: A tensor. g)rrErr%maximumsqrt)rOzeror9r9r:rN s rNzkeras.backend.expcCs t|S)z^Element-wise exponential. Args: x: Tensor or variable. Returns: A tensor. )r%exp)rOr9r9r:rP s rPzkeras.backend.logcCs t|S)zVElement-wise log. Args: x: Tensor or variable. Returns: A tensor. )r%log)rOr9r9r:rQ s rQcCst|||S)ajComputes log(sum(exp(elements across dimensions of a tensor))). This function is more numerically stable than log(sum(exp(x))). It avoids overflows caused by taking the exp of large inputs and underflows caused by taking the log of small inputs. Args: x: A tensor or variable. axis: An integer, the axis to reduce over. keepdims: A boolean, whether to keep the dimensions or not. If `keepdims` is `False`, the rank of the tensor is reduced by 1. If `keepdims` is `True`, the reduced dimension is retained with length 1. Returns: The reduced tensor. )r%Zreduce_logsumexp)rOr=r>r9r9r: logsumexp$ srRzkeras.backend.roundcCs t|S)zElement-wise rounding to the closest integer. In case of tie, the rounding mode used is "half to even". Args: x: Tensor or variable. Returns: A tensor. )r%round)rOr9r9r:rS9 srSzkeras.backend.signcCs t|S)zWElement-wise sign. Args: x: Tensor or variable. Returns: A tensor. )r%sign)rOr9r9r:rTJ s rTzkeras.backend.powcCs t||S)zzElement-wise exponentiation. Args: x: Tensor or variable. a: Python integer. Returns: A tensor. )r%pow)rOr0r9r9r:rUY s rUzkeras.backend.clipcCsTt|ttfr(t|ttfr(||kr(|}|dkr8tj }|dkrFtj}t|||S)zElement-wise value clipping. Args: x: Tensor or variable. min_value: Python float, integer, or tensor. max_value: Python float, integer, or tensor. Returns: A tensor. N)rFrWfloatrMinfr clip_by_value)rOZ min_value max_valuer9r9r:clipi srZzkeras.backend.equalcCs t||S)zElement-wise equality between two tensors. Args: x: Tensor or variable. y: Tensor or variable. Returns: A bool tensor. )r%equal)rOr)r9r9r:r[ s r[zkeras.backend.not_equalcCs t||S)zElement-wise inequality between two tensors. Args: x: Tensor or variable. y: Tensor or variable. Returns: A bool tensor. )r% not_equal)rOr)r9r9r:r\ s r\zkeras.backend.greatercCs t||S)zElement-wise truth value of (x > y). Args: x: Tensor or variable. y: Tensor or variable. Returns: A bool tensor. )r%greater)rOr)r9r9r:r] s r]zkeras.backend.greater_equalcCs t||S)zElement-wise truth value of (x >= y). Args: x: Tensor or variable. y: Tensor or variable. Returns: A bool tensor. )r% greater_equal)rOr)r9r9r:r^ s r^zkeras.backend.lesscCs t||S)zElement-wise truth value of (x < y). Args: x: Tensor or variable. y: Tensor or variable. Returns: A bool tensor. )r%less)rOr)r9r9r:r_ s r_zkeras.backend.less_equalcCs t||S)zElement-wise truth value of (x <= y). Args: x: Tensor or variable. y: Tensor or variable. Returns: A bool tensor. )r% less_equal)rOr)r9r9r:r` s r`zkeras.backend.maximumcCs t||S)aElement-wise maximum of two tensors. Args: x: Tensor or variable. y: Tensor or variable. Returns: A tensor with the element wise maximum value(s) of `x` and `y`. Examples: >>> x = tf.Variable([[1, 2], [3, 4]]) >>> y = tf.Variable([[2, 1], [0, -1]]) >>> m = tf.keras.backend.maximum(x, y) >>> m )r%rM)rOr)r9r9r:rM srMzkeras.backend.minimumcCs t||S)zElement-wise minimum of two tensors. Args: x: Tensor or variable. y: Tensor or variable. Returns: A tensor. )r%minimum)rOr)r9r9r:ra s razkeras.backend.sincCs t|S)zdComputes sin of x element-wise. Args: x: Tensor or variable. Returns: A tensor. )r%sin)rOr9r9r:rb s rbzkeras.backend.coscCs t|S)zdComputes cos of x element-wise. Args: x: Tensor or variable. Returns: A tensor. )r%cos)rOr9r9r:rc s rcMbP?cCs4t||ddd\}}t||||||}|||fS)aNon-fused version of `normalize_batch_in_training`. Args: x: Input tensor or variable. gamma: Tensor by which to scale the input. beta: Tensor with which to center the input. reduction_axes: iterable of integers, axes over which to normalize. epsilon: Fuzz factor. Returns: A tuple length of 3, `(normalized_tensor, mean, variance)`. NF)r&momentsbatch_normalization)rOgammabetareduction_axesepsilonrrEnormedr9r9r:$_regular_normalize_batch_in_training* srlcCst||ddd\}}g}x      rfzkeras.backend.concatenatecCs||dkr&t|d}|r"||;}nd}tdd|DrDt||Stdd|Drbt||Stdd|D|SdS)a4Concatenates a list of tensors alongside the specified axis. Args: tensors: list of tensors to concatenate. axis: concatenation axis. Returns: A tensor. Example: >>> a = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> b = tf.constant([[10, 20, 30], [40, 50, 60], [70, 80, 90]]) >>> tf.keras.backend.concatenate((a, b), axis=-1) rcss|]}t|VqdS)N)r)rrOr9r9r:r szconcatenate..css|]}t|tjVqdS)N)rFr-r)rrOr9r9r:r scSsg|] }t|qSr9)r)rrOr9r9r:r szconcatenate..N)rrr(Z sparse_concatrr3)tensorsr=rr9r9r:r s    rzkeras.backend.reshapecCs t||S)aRReshapes a tensor to the specified shape. Args: x: Tensor or variable. shape: Target shape tuple. Returns: A tensor. Example: >>> a = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]) >>> a >>> tf.keras.backend.reshape(a, shape=(2, 6)) )rr&)rOrur9r9r:r& sr&z keras.backend.permute_dimensionscCstj||dS)aPermutes axes in a tensor. Args: x: Tensor or variable. pattern: A tuple of dimension indices, e.g. `(0, 2, 1)`. Returns: A tensor. Example: >>> a = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]) >>> a >>> tf.keras.backend.permute_dimensions(a, pattern=(1, 0)) )r#)rr')rOr6r9r9r:permute_dimensions5 sryzkeras.backend.resize_imagesnearestcCs|dkrd\}}n |dkr$d\}}ntd|f|j||d}|r`tj|dd}nt|||d}|ttj ||gdd9}|dkrt |d d d dg}|d krt j ||t j jd }n&|dkrt j ||t j jd }ntd|dkr t |d d dd g}|S)aResizes the images contained in a 4D tensor. Args: x: Tensor or variable to resize. height_factor: Positive integer. width_factor: Positive integer. data_format: One of `"channels_first"`, `"channels_last"`. interpolation: A string, one of `nearest` or `bilinear`. Returns: A tensor. Raises: ValueError: in case of incorrect value for `data_format` or `interpolation`. channels_first)r r1 channels_last)rRr z"Invalid `data_format` argument: %srRint32)rErr r1rz)methodZbilinearz7interpolation should be one of "nearest" or "bilinear".)r}ruZis_fully_definedr rrrshape_v2rMarrayryr Zresize_images_v2Z ResizeMethodZNEAREST_NEIGHBORZBILINEAR)rO height_factor width_factorrp interpolationrowscolsZ new_shaper9r9r: resize_imagesV s.   rzkeras.backend.resize_volumescCs|dkr6t||dd}t||dd}t||dd}|S|dkrlt||dd}t||dd}t||dd}|Stdt|d S) aResizes the volume contained in a 5D tensor. Args: x: Tensor or variable to resize. depth_factor: Positive integer. height_factor: Positive integer. width_factor: Positive integer. data_format: One of `"channels_first"`, `"channels_last"`. Returns: A tensor. Raises: ValueError: if `data_format` is neither `channels_last` or `channels_first`. r{r )r=r1rtr|rRzInvalid data_format: N)repeat_elementsr}r)rOZ depth_factorrrrpoutputr9r9r:resize_volumes srzkeras.backend.repeat_elementscs|j}||dk rFtj||||d}fdd|D}t||S|d}t|}tj||d}tt|jd}||<t ||}t ||}||<tj |dd}||9}t ||}|j}| |t||_|S) a Repeats the elements of a tensor along an axis, like `np.repeat`. If `x` has shape `(s1, s2, s3)` and `axis` is `1`, the output will have shape `(s1, s2 * rep, s3)`. Args: x: Tensor or variable. rep: Python integer, number of times to repeat. axis: Axis along which to repeat. Returns: A tensor. Example: >>> b = tf.constant([1, 2, 3]) >>> tf.keras.backend.repeat_elements(b, rep=2, axis=0) N)rjZnum_or_size_splitsr=csg|]}tD]}|qqSr9)r)rr+r)repr9r:r sz#repeat_elements..rR)r=r})rE)rurrsplitrrrMr rtiledeleterr& set_shaperr)rOrr=r*ZsplitsZx_repZauxiliary_axisZrepsr9)rr:r s,          rzkeras.backend.repeatcCs8t|dkstt|d}td|dg}t||S)aoRepeats a 2D tensor. if `x` has shape (samples, dim) and `n` is `2`, the output will have shape `(samples, 2, dim)`. Args: x: Tensor or variable. n: Python integer, number of times to repeat. Returns: A tensor. Example: >>> b = tf.constant([[1, 2], [3, 4]]) >>> b >>> tf.keras.backend.repeat(b, n=2) r rR)rrrrr2r)rOrr6r9r9r:repeat s rzkeras.backend.arangerRr}cCs<|dkr|dkrd}tj|||dd}|dkr8t||}|S)aCreates a 1D tensor containing a sequence of integers. The function arguments use the same convention as Theano's arange: if only one argument is provided, it is in fact the "stop" argument and "start" is 0. The default type of the returned tensor is `'int32'` to match TensorFlow's default. Args: start: Start value. stop: Stop value. step: Difference between two successive values. dtype: Integer dtype to use. Returns: An integer tensor. Example: >>> tf.keras.backend.arange(start=0, stop=10, step=1.5) Nrarange)limitdeltarvr})r%rrK)startstopsteprEr7r9r9r:r s  rzkeras.backend.tilecCst|tr|g}t||S)zCreates a tensor by tiling `x` by `n`. Args: x: A tensor or variable n: A list of integer. The length must be the same as the number of dimensions in `x`. Returns: A tiled tensor. )rFrWrr)rOrr9r9r:r9 s rzkeras.backend.flattencCst|dgS)aFlatten a tensor. Args: x: A tensor or variable. Returns: A tensor, reshaped into 1-D Example: >>> b = tf.constant([[1, 2], [3, 4]]) >>> b >>> tf.keras.backend.flatten(b) r")rr&)rOr9r9r:rL srzkeras.backend.batch_flattenc Cs*t|tdtt|ddg}|S)aTurn a nD tensor into a 2D tensor with same 0th dimension. In other words, it flattens each data samples of a batch. Args: x: A tensor or variable. Returns: A tensor. Examples: Flattening a 3D tensor to 2D by collapsing the last dimension. >>> x_batch = tf.keras.backend.ones(shape=(2, 3, 4, 5)) >>> x_batch_flatten = batch_flatten(x_batch) >>> tf.keras.backend.int_shape(x_batch_flatten) (2, 60) r"rRN)rr&r2rru)rOr9r9r: batch_flatteng s&rzkeras.backend.expand_dimscCs t||S)zAdds a 1-sized dimension at index "axis". Args: x: A tensor or variable. axis: Position where to add a new axis. Returns: A tensor with expanded dimensions. )rr)rOr=r9r9r:r s rzkeras.backend.squeezecCst||gS)zRemoves a 1-dimension from the tensor at index "axis". Args: x: A tensor or variable. axis: Axis to drop. Returns: A tensor with the same data as `x` but reduced dimensions. )rr4)rOr=r9r9r:r4 s r4zkeras.backend.temporal_paddingrRrRcCs:t|dkstddg|d|dgddgg}t||S)zPads the middle dimension of a 3D tensor. Args: x: Tensor or variable. padding: Tuple of 2 integers, how many zeros to add at the start and end of dim 1. Returns: A padded 3D tensor. r rrR)rrrpad)rOpaddingr6r9r9r:temporal_padding srz keras.backend.spatial_2d_padding)rRrR)rRrRcCst|dkstt|ddks$tt|ddks8t|dkrFt}|dkr^tdt||dkrddgddgt|dt|dg}n$ddgt|dt|dddgg}t||S)aXPads the 2nd and 3rd dimensions of a 4D tensor. Args: x: Tensor or variable. padding: Tuple of 2 tuples, padding pattern. data_format: One of `channels_last` or `channels_first`. Returns: A padded 4D tensor. Raises: ValueError: if `data_format` is neither `channels_last` or `channels_first`. r rrRN>r{r|zUnknown data_format: r{)rrimage_data_formatr}rr%rr)rOrrpr6r9r9r:spatial_2d_padding s&$rz keras.backend.spatial_3d_padding)rRrR)rRrR)rRrRcCs,t|dkstt|ddks$tt|ddks8tt|ddksLt|dkrZt}|dkrrtdt||dkrddgddg|dd|ddg|dd|ddg|dd|ddgg}nRddg|dd|ddg|dd|ddg|dd|ddgddgg}t||S) aPads 5D tensor with zeros along the depth, height, width dimensions. Pads these dimensions with respectively "padding[0]", "padding[1]" and "padding[2]" zeros left and right. For 'channels_last' data_format, the 2nd, 3rd and 4th dimension will be padded. For 'channels_first' data_format, the 3rd, 4th and 5th dimension will be padded. Args: x: Tensor or variable. padding: Tuple of 3 tuples, padding pattern. data_format: One of `channels_last` or `channels_first`. Returns: A padded 5D tensor. Raises: ValueError: if `data_format` is neither `channels_last` or `channels_first`. r1rr rRN>r{r|zUnknown data_format: r{)rrrr}rrr)rOrrpr6r9r9r:spatial_3d_padding s"2 rzkeras.backend.stackcCstj||dS)aStacks a list of rank `R` tensors into a rank `R+1` tensor. Args: x: List of tensors. axis: Axis along which to perform stacking. Returns: A tensor. Example: >>> a = tf.constant([[1, 2],[3, 4]]) >>> b = tf.constant([[10, 20],[30, 40]]) >>> tf.keras.backend.stack((a, b)) )r=)rr2)rOr=r9r9r:r2sr2zkeras.backend.one_hotcCstj||ddS)aComputes the one-hot representation of an integer tensor. Args: indices: nD integer tensor of shape `(batch_size, dim1, dim2, ... dim(n-1))` num_classes: Integer, number of classes to consider. Returns: (n + 1)D one hot representation of the input with shape `(batch_size, dim1, dim2, ... dim(n-1), num_classes)` Returns: The one-hot tensor. r")depthr=)rone_hot)rZ num_classesr9r9r:r srzkeras.backend.reversecCst|tr|g}t||S)zReverse a tensor along the specified axes. Args: x: Tensor to reverse. axes: Integer or iterable of integers. Axes to reverse. Returns: A tensor. )rFrWrreverse)rOr5r9r9r:r5s ra >>> K = tf.keras.backend # Common keras convention >>> v = K.variable(1.) >>> # reassign >>> K.set_value(v, 2.) >>> print(K.get_value(v)) 2.0 >>> # increment >>> K.set_value(v, K.get_value(v) + 1) >>> print(K.get_value(v)) 3.0 Variable semantics in TensorFlow 2 are eager execution friendly. The above code is roughly equivalent to: >>> v = tf.Variable(1.) >>> v.assign(2.) >>> print(v.numpy()) 2.0 >>> v.assign_add(1.) >>> print(v.numpy()) 3.0r1zkeras.backend.get_valuec Cst|s|Sts"t|tjr*|St|ddsNt |SQRXt rnt |SQRX|j |jt|fdSQRXdS)aEReturns the value of a variable. `backend.get_value` is the complement of `backend.set_value`, and provides a generic interface for reading from variables while abstracting away the differences between TensorFlow 1.x and 2.x semantics. {snippet} Args: x: input variable. Returns: A Numpy array. Z_in_graph_modeTN)r)r is_tf_typerrgrFr EagerTensornumpyrmZ eager_moderrorYr`rr)rOr9r9r:res     rzkeras.backend.batch_get_valuecCs@trdd|DStr&td|r8t||SgSdS)zReturns the value of more than one tensor variable. Args: tensors: list of ops to run. Returns: A list of Numpy arrays. Raises: RuntimeError: If this method is called inside defun. cSsg|] }|qSr9)r)rrOr9r9r:rsz#batch_get_value..z2Cannot get value inside Tensorflow graph function.N)rrgrrrrr)rxr9r9r:batch_get_valuesrzkeras.backend.set_valuec Cstj|t|d}tr&||ntt |j j dd}t |drb|j}|j}n6tdg|j}tj||d}||}||_||_tj|||idWdQRXdS)aSets the value of a variable, from a Numpy array. `backend.set_value` is the complement of `backend.get_value`, and provides a generic interface for assigning to variables while abstracting away the differences between TensorFlow 1.x and 2.x semantics. {snippet} Args: x: Variable to set to a new value. value: Value to set the tensor to, as a Numpy array (of the same shape). )rErr_assign_placeholderN)ru) feed_dict)rMrNrrrrrSr`rrrErvrrr _assign_opr TensorShaperrrrr)rOrjr assign_placeholder assign_opplaceholder_shaper9r9r: set_values     rzkeras.backend.batch_set_valuec Cststr>> x = tf.constant([[1.0, 2.0], [3.0, 4.0]]) >>> _ = tf.keras.backend.print_tensor(x) [[1 2] [3 4]] Args: x: Tensor to print. message: Message to print jointly with the tensor. summarize: The first and last `summarize` elements within each dimension are recursively printed per Tensor. If None, then the first 3 and last 3 elements of each dimension are printed for each tensor. If set to -1, it will print all elements of every tensor. Returns: The same tensor `x`, unchanged. rY)Z output_stream summarizeN) rFrrGrrSr`r#Zprint_v2sysstdoutcontrol_dependenciesrr)rOmessagerrr9r9r: print_tensors rc@s:eZdZdZd ddZddZddZd d Zd d ZdS)GraphExecutionFunctionaRuns a computation graph. It's possible to pass arguments to `tf.Session.run()` via `session_kwargs`. In particular additional operations via `fetches` argument and additional tensor substitutions via `feed_dict` arguments. Note that given substitutions are merged with substitutions from `inputs`. Even though `feed_dict` is passed once in the constructor (called in `model.compile()`) we can modify the values in the dictionary. Through this feed_dict we can provide additional substitutions besides Keras inputs. Args: inputs: Feed placeholders to the computation graph. outputs: Output tensors to fetch. updates: Additional update ops to be run at function call. name: A name to help users identify what this function does. session_kwargs: Arguments to `tf.Session.run()`: `fetches`, `feed_dict`, `options`, `run_metadata`. Nc Ksl|pg}t|ttfstd||_tj|dd|_||_t tj|dd|_ t |j dgTg}x<|D]4}t|tr|\}} | t|| ql| |qlWtj||_WdQRX||_|dd|_|dg|_t|jts|jg|_|dd|_|dd|_d d |jD|_||_i|_|rDtd |fd|_d|_d|_d|_ d|_!d|_"dS) Nz@`updates` in a Keras backend function should be a list or tuple.T)rrrfetchesoptions run_metadatacSsg|]}t|qSr9)rr)rrOr9r9r:rXsz3GraphExecutionFunction.__init__..z>Some keys in session_kwargs are not supported at this time: %s)#rFr%rrZ_inputs_structurer1rinputs_outputs_structurecast_variables_to_tensoroutputsrrrr)rrgroup updates_oprvrerr run_optionsrsession_kwargsfetch_callbacksr}keys _callable_fn _feed_arrays _feed_symbols _symbol_vals_fetches_session) r@rrupdatesrvrZ updates_opsrpZnew_pr9r9r:r=3sF    zGraphExecutionFunction.__init__c Cs2t}x|D]}|j|jqW|jrPx$t|jD]}|j|jq:Wx`t||D]R\}}|j } |j |j krt j ||j d}t|} | dkr|} | j| _|j| _q\Wx"|j|jD]}|j|jqW|j|jj|jr|j|j||} | |_||_||_||_t|j|_||_dS)aGenerates a callable that runs the graph. Args: feed_arrays: List of input tensors to be fed Numpy arrays at runtime. feed_symbols: List of input tensors to be fed symbolic tensors at runtime. symbol_vals: List of symbolic tensors to be fed to `feed_symbols`. session: Session to use to generate the callable. Returns: Function that runs the graph according to the above options. )rEN) rZCallableOptionsfeedrrvrrurrZtensor_connectionrrEr%rKr from_tensor to_tensorrrfetchtargetrrZCopyFromZ_make_callable_from_optionsrrrrr%rr) r@ feed_arrays feed_symbols symbol_valsrZ callable_optsrOr>r) connectionrZ callable_fnr9r9r:_make_callableks6       z%GraphExecutionFunction._make_callablecCs6x0t|j|D] \}}||jkr|j||qWdS)N)rrr)r@Zfetches_outputrrr9r9r:_call_fetch_callbackss z,GraphExecutionFunction._call_fetch_callbackscCs*ddlm}||r"|j|S|SdS)z@Helper method which evaluates any CompositeTensors passed to it.r)rN)rrrrr)r@rrr9r9r:_eval_if_composites   z)GraphExecutionFunction._eval_if_compositec Cstj|dd}t|}g}g}g}g}xnt|j|D]^\}}|dkrFq4t|rf||||q4||t |j } |t j || j dq4W|jrx4t|jD]"} |t j |j| | j j dqW|jdks||jks||jks||jks|j|jks||jkr,||||||j|d|ji} || t|j dtj|j| dt|jdd} t|j | S)NT)r)rEr)!r1rrrrrrrrrrErMrNrrrurrrrrrrrrrrrpack_sequence_asrrrr) r@rrrZ array_valsrrrrjZ tensor_typer>ZfetchedZoutput_structurer9r9r:__call__sB         zGraphExecutionFunction.__call__)NN) r5r6r7r8r=rrrrr9r9r9r:rs  81rzkeras.backend.functionc  str||rtd|f|r,td|fddlm}ddlm|j||dt|t oft |dkfdd }|S|rx:|D]2}|t t jjdkr|d krd |}t|qWt||f||d |S) ayInstantiates a Keras function. Args: inputs: List of placeholder tensors. outputs: List of output tensors. updates: List of update ops. name: String, name of function. **kwargs: Passed to `tf.Session.run`. Returns: Output values as Numpy arrays. Raises: ValueError: if invalid kwargs are passed in or if in eager execution. zRSession keyword arguments are not supported during eager execution. You passed: %szJ`updates` argument is not supported during eager execution. You passed: %sr)models)r)rrrRcs|}r|g}|S)N)Zsync_to_numpy_or_python_type)Z model_inputsZouts)modelr wrap_outputsr9r:funcszfunction..func)rrrrvzBInvalid argument "%s" passed to K.function with TensorFlow backend)rrv)rrr}tensorflow.python.kerasrrrZModelrFr%rrgetfullargspecrrrr) rrrrvkwargsrrr>msgr9)rrrr:functions,      rzkeras.backend.gradientscCstj||ddS)zReturns the gradients of `loss` w.r.t. `variables`. Args: loss: Scalar tensor to minimize. variables: List of variables. Returns: A gradients tensor. T)Zcolocate_gradients_with_ops)gradients_moduler)Zlossr,r9r9r:rs rzkeras.backend.stop_gradientcCs$t|ttfrttj|St|S)aYReturns `variables` but with zero gradient w.r.t. every other variable. Args: variables: Tensor or list of tensors to consider constant with respect to any other variable. Returns: A single tensor or a list of tensors (depending on the passed argument) that has no gradient with respect to any other variable. )rFr%rmapr stop_gradient)r,r9r9r:r%s rzkeras.backend.rnnc )sdd} |st|  t } | djd| djdt| ddx| D]} | jdqVW|dk r|jtjkrt |tj}t |jdkrt |}|s| |}dkrgd4dd |r܈st d t} g}g}fd d }t r t|  n | f fd d}|dk rtt|}rF|xtD]}||}|| |t| t\}} |}|st|}n|d}t|||}t| }t|}t fdd|D}tddt|||D}t| |} |||| qPW|d}|d}t|}rt|d||t|}t||dd|t|}ndxHtD]<}||}|t| t\}} |||| q~W|d}|d}t|}ntt} tfddt| Dtfddt| Dt dd| D}|tt\}} tfddtt|D}!tjdddd}"tstt !rt "}#nd}#fdd|#ddd }$|dk r rt|d}t#j$tjd!d" | fd#d$ fd%d&nZt%t j&r`rJt j"dd'}%t '|%dfd(d$ n fd)d$ d*d&nd dk rtd+dt|D fd,d-}&t(j)f|&|"|!f| d.|$}'|'dd}n> fd/d-}&t(j)f|&|"|!f| d.|$}'|'dd}|'d}!td0d|!D}td1d|D}t||}t||}fd2d3}(t|(|}|s|t| |}|||fS)5aA Iterates over the time dimension of a tensor. Args: step_function: RNN step function. Args; input; Tensor with shape `(samples, ...)` (no time dimension), representing input for the batch of samples at a certain time step. states; List of tensors. Returns; output; Tensor with shape `(samples, output_dim)` (no time dimension). new_states; List of tensors, same length and shapes as 'states'. The first state in the list must be the output tensor at the previous timestep. inputs: Tensor of temporal data of shape `(samples, time, ...)` (at least 3D), or nested tensors, and each of which has shape `(samples, time, ...)`. initial_states: Tensor with shape `(samples, state_size)` (no time dimension), containing the initial values for the states used in the step function. In the case that state_size is in a nested shape, the shape of initial_states will also follow the nested structure. go_backwards: Boolean. If True, do the iteration over the time dimension in reverse order and return the reversed sequence. mask: Binary tensor with shape `(samples, time, 1)`, with a zero for every element that is masked. constants: List of constant values passed at each step. unroll: Whether to unroll the RNN or to use a symbolic `while_loop`. input_length: An integer or a 1-D Tensor, depending on whether the time dimension is fixed-length or not. In case of variable length input, it is used for masking in case there's no mask specified. time_major: Boolean. If true, the inputs and outputs will be in shape `(timesteps, batch, ...)`, whereas in the False case, it will be `(batch, timesteps, ...)`. Using `time_major = True` is a bit more efficient because it avoids transposes at the beginning and end of the RNN calculation. However, most TensorFlow data is batch-major, so by default this function accepts input and emits output in batch-major form. zero_output_for_mask: Boolean. If True, the output for masked timestep will be zeros, whereas in the False case, output from previous timestep is returned. Returns: A tuple, `(last_output, outputs, new_states)`. last_output: the latest output of the rnn, of shape `(samples, ...)` outputs: tensor with shape `(samples, time, ...)` where each entry `outputs[s, t]` is the output of the step function at time `t` for sample `s`. new_states: list of tensors, latest states returned by the step function, of shape `(samples, ...)`. Raises: ValueError: if input dimension is less than 3. ValueError: if `unroll` is `True` but input timestep is not a fixed number. ValueError: if `mask` is provided (not `None`) but states is not provided (`len(states)` == 0). cSs.ttt|j}d\|d<|d<t||S)N)rRrrrR)r%rrrurr')input_tr5r9r9r:swap_batch_timestepsz rnn..swap_batch_timesteprrRr1Nr cSst|rtd|t|r,td|t|jt|j}xt|D]}t|d}qJWdg||j|d}t ||S)Nz+mask_t is expected to be tensor, but got %sz,input_t is expected to be tensor, but got %sr"rR) r1 is_nestedr}rrurrrrr)mask_tr fixed_dimZ rank_diffrZ multiplesr9r9r: _expand_masks    zrnn.._expand_maskz/Unrolling requires a fixed number of timesteps.cst|}r||S)N)rr$r)r) go_backwardsr9r:_process_single_input_ts z$rnn.._process_single_input_tcsfddD}t|S)Ncsg|] }|qSr9r9)rZt_)timer9r:rsz2rnn.._get_input_tensor..)r1r)rinp)rprocessed_input)rr:_get_input_tensorszrnn.._get_input_tensorr"c3s|]}|VqdS)Nr9)rr+)rrr9r:rszrnn..css"|]\}}}t|||VqdS)N)rwhere_v2)rmr+Zpsr9r9r:rs)rc3s(|] \}}tj|jd|dVqdS)z input_ta_%s)rEr tensor_array_nameN)r+ TensorArrayrE)rrr) time_steps_tr9r:rsc3s0|](\}}s||n|t|dVqdS)rN)r$r)rtainput_)rr9r:r scSsg|] }|dqS)rr9)rrr9r9r:rszrnn..c3s,|]$\}}tj|j|jd|dVqdS)z output_ta_%s)rEr Z element_shaperN)r+rrEru)rrr-)rr9r:rsr}r)rErvcs|kS)Nr9)rr)rr9r:,zrnn.. T)condZmaximum_iterationsparallel_iterationsZ swap_memorymask_ta)rEr rcs |S)N)read)r)rr9r: masking_fn;szrnn..masking_fncs2tfdd|D}tddt|||DS)Nc3s"|]}|tjdVqdS))rN)rru)ro)rrr9r:r@sz5rnn..compute_masked_output..css"|]\}}}t|||VqdS)N)rr)rrrfmr9r9r:rCs)rr)rflat_out flat_mask tiled_mask_t)r)rr:compute_masked_output>s   z"rnn..compute_masked_output)r=cs t|S)N)r%r_)r)rev_input_lengthr9r:rJscs t|S)N)r%r])r) input_lengthr9r:rNscstfddt||DS)Nc3s |]\}}t||VqdS)N)rwhere)rrZzo)rr9r:rSsz5rnn..compute_masked_output..)rr)rrrr9)rr:rQs css|]}t|VqdS)N)rr )rrr9r9r:r[scstfddD}t|}}|t|t\}}t|}rVnt|} ||| } t|} t|} x.t| | D] \} }t|tjr|| j qW|| | }t||}tfddt|| D}d|t| ft|S)a3RNN step function. Args: time: Current timestep value. output_ta_t: TensorArray. prev_output: tuple of outputs from time - 1. *states: List of states. Returns: Tuple: `(time + 1, output_ta_t, output) + tuple(new_states)` c3s|]}|VqdS)N)r)rr)rr9r:risz%rnn.._step..c3s|]\}}||VqdS)N)write)rrr-)rr9r:rsrR) rr1rrrrFrrGrru)r output_ta_t prev_outputstates current_inputrr new_states flat_outputZflat_mask_outputZflat_new_output flat_stateflat_new_statestate new_stateZflat_final_state)r constantsflat_zero_outputinput_tarr step_functionzero_output_for_mask)rr:_step]s.         zrnn.._step)bodyZ loop_varsc stfddD}t|}|t|t\}}t|}t|}x.t||D] \}} t| tjr\| |j q\Wt|} tfddt|| D}t|}d|ft|S)zRNN step function. Args: time: Current timestep value. output_ta_t: TensorArray. *states: List of states. Returns: Tuple: `(time + 1,output_ta_t) + tuple(new_states)` c3s|]}|VqdS)N)r)rr)rr9r:rsz%rnn.._step..c3s|]\}}||VqdS)N)r )rrr-)rr9r:rsrR) rr1rrrrFrrGrru) rr r rrrrrrrr)rinitial_statesrrr)rr:rs       css|]}|VqdS)N)r2)rrr9r9r:rscss|]}|dVqdS)r"Nr9)rrr9r9r:rscs4t|tjr0|j}|d<|d<|||S)NrrR)rFrrGrurr)Zoutput_ru)batch time_stepsr9r:rs    zrnn..set_shape)rR)*r1rrrurZwith_rank_at_leastrErrr%rKrrr}rrr$rrr rrrrr2rr rrrgrZGraphOrParentsInXlaContextrrlr<r+rrFrGsubtractrZ while_loop))rrrrmaskrZunrollrZ time_majorrrZflatted_inputsrr Zsuccessive_statesZsuccessive_outputsrrZ mask_listrrrrrr Z flat_statesZflat_new_statesZflat_final_statesZ last_outputrZinput_time_zeroZoutput_time_zerorZ output_tarZmax_iterationsZwhile_loop_kwargsmax_lenrZ final_outputsrr9)rrrrrrrrrrrrrrrrrrrr:rnn<sH                                 )     r"zkeras.backend.switchc s4|jtjkrt|d}t|}|shts:fdd}n}tsTfdd}n}t|||}ntrvtrt}||krt dt |dt ||dkr"||}t j t |dg|gd d } t || }t } | | } t | d k| t | } t || }t |}|S) aSwitches between two operations depending on a scalar value. Note that both `then_expression` and `else_expression` should be symbolic tensors of the *same shape*. Args: condition: tensor (`int` or `bool`). then_expression: either a tensor, or a callable that returns a tensor. else_expression: either a tensor, or a callable that returns a tensor. Returns: The selected tensor. Raises: ValueError: If rank of `condition` is greater than rank of expressions. rcsS)Nr9r9)then_expressionr9r:then_expression_fnsz"switch..then_expression_fncsS)Nr9r9)else_expressionr9r:else_expression_fnsz"switch..else_expression_fnzuRank of `condition` should be less than or equal to rank of `then_expression` and `else_expression`. ndim(condition)=z, ndim(then_expression)=rRr)r=)rErrr%rKrrrrr}rrr3rur&rrr) conditionr#r%Z cond_ndimr$r&rOZ expr_ndimZ ndim_diffZ cond_shapeZ expr_shapeZ shape_diffZ tile_shaper9)r%r#r:switchs>        r(zkeras.backend.in_train_phasecCsddlm}|dkr|j}|dkr,t}t|s||dksF|dkrZt|rT|S|Sn"|dksj|dkr|t|rx|S|St|||}|S)a,Selects `x` in train phase, and `alt` otherwise. Note that `alt` should have the *same shape* as `x`. Args: x: What to return in train phase (tensor or callable that returns a tensor). alt: What to return otherwise (tensor or callable that returns a tensor). training: Optional scalar tensor (or Python boolean, or Python integer) specifying the learning phase. Returns: Either `x` or `alt` based on the `training` flag. the `training` flag defaults to `K.learning_phase()`. r)base_layer_utilsNrRTF) rr)Z call_contexttrainingrqrrrr()rOaltr*r)r9r9r:in_train_phase s     r,zkeras.backend.in_test_phasecCst|||dS)aSelects `x` in test phase, and `alt` otherwise. Note that `alt` should have the *same shape* as `x`. Args: x: What to return in test phase (tensor or callable that returns a tensor). alt: What to return otherwise (tensor or callable that returns a tensor). training: Optional scalar tensor (or Python boolean, or Python integer) specifying the learning phase. Returns: Either `x` or `alt` based on `K.learning_phase`. )r*)r,)rOr+r*r9r9r: in_test_phase7sr-zkeras.backend.relucCst|dt}|dkrZ|dkr4|dkr4tj||dS|dkrNt| |}n t| }|dk }|dkr|tjt|||d}n"|dkrt|}d}n t|}|rt ||j j }t d|j j }t |||}|dkrt||j j }|||8}|S) aRectified linear unit. With default values, it returns element-wise `max(x, 0)`. Otherwise, it follows: `f(x) = max_value` for `x >= max_value`, `f(x) = x` for `threshold <= x < max_value`, `f(x) = alpha * (x - threshold)` otherwise. Args: x: A tensor or variable. alpha: A scalar, slope of negative section (default=`0.`). max_value: float. Saturation threshold. threshold: float. Threshold value for thresholded activation. Returns: A tensor. rEgNr)alpha)rEF)rmrLr&Z leaky_relurelur%rKr]Zrelu6rrErrrXr)rOr/rY thresholdrEZ negative_partZclip_maxrOr9r9r:r1Ps,    r1zkeras.backend.elu?cCs0t|}|dkr|St|dk|||SdS)zExponential linear unit. Args: x: A tensor or variable to compute the activation function for. alpha: A scalar, slope of negative section. Returns: A tensor. rRrN)r&elurr)rOr/resr9r9r:r4s r4zkeras.backend.softmaxcCstj||dS)zSoftmax of a tensor. Args: x: A tensor or variable. axis: The dimension softmax would be performed on. The default is -1 which indicates the last dimension. Returns: A tensor. )r=)r&softmax)rOr=r9r9r:r6sr6zkeras.backend.softpluscCs t|S)z\Softplus of a tensor. Args: x: A tensor or variable. Returns: A tensor. )r%softplus)rOr9r9r:r7s r7zkeras.backend.softsigncCs t|S)z\Softsign of a tensor. Args: x: A tensor or variable. Returns: A tensor. )r&softsign)rOr9r9r:r8s r8z&keras.backend.categorical_crossentropycCst|}t|}|j|jt|drD|j}|r@tdd}|rXtj |||dSt |tj t j fs|jjdkrt|dst|jjdkst|jjd}tj |||dS|t||d}tt|jj}t||d |}t|t|| S) a*Categorical crossentropy between an output tensor and a target tensor. Args: target: A tensor of the same shape as `output`. output: A tensor resulting from a softmax (unless `from_logits` is True, in which case `output` is expected to be the logits). from_logits: Boolean, whether `output` is the result of a softmax, or is a tensor of logits. axis: Int specifying the channels axis. `axis=-1` corresponds to data format `channels_last`, and `axis=1` corresponds to data format `channels_first`. Returns: Output tensor. Raises: ValueError: if `axis` is neither -1 nor one of the axes of `output`. Example: >>> a = tf.constant([1., 0., 0., 0., 1., 0., 0., 0., 1.], shape=[3,3]) >>> print(a) tf.Tensor( [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]], shape=(3, 3), dtype=float32) >>> b = tf.constant([.9, .05, .05, .05, .89, .06, .05, .01, .94], shape=[3,3]) >>> print(b) tf.Tensor( [[0.9 0.05 0.05] [0.05 0.89 0.06] [0.05 0.01 0.94]], shape=(3, 3), dtype=float32) >>> loss = tf.keras.backend.categorical_crossentropy(a, b) >>> print(np.around(loss, 5)) [0.10536 0.11653 0.06188] >>> loss = tf.keras.backend.categorical_crossentropy(a, a) >>> print(np.around(loss, 5)) [0. 0. 0.] _keras_logitsz"`categorical_crossentropy` received `from_logits=True`, but the `output` argument was produced by a sigmoid or softmax activation and thus does not represent logits. Was this intended?"T)labelslogitsr=SoftmaxrrRrg?)rrruZassert_is_compatible_withrr9ryrzr&Z$softmax_cross_entropy_with_logits_v2rFrrHrIrrrrrr%rArrjrErrrXrQ)rr from_logitsr=epsilon_r9r9r:categorical_crossentropys,-      r?z-keras.backend.sparse_categorical_crossentropyc Cst|}t|}t|dr8|j}|r2tdd}n|st|tjtj fs|j j dkrt|dst |j j dksxt|j j d}d}n0|stt|jj}t||d|}t|}t|jttfrt |j}n|jj}|dk r0||;}||dkrHttt|t|d||g}tj||d }n|d krHt d !|t"|d }t#|}|jj}|dk o|dk o||dk} | rt$|}t%|d |d g}t&d d||gDrt'(t)j*||d} WdQRXnt)j*||d} | r|dkrt%| |dd S| SdS)aCategorical crossentropy with integer targets. Args: target: An integer tensor. output: A tensor resulting from a softmax (unless `from_logits` is True, in which case `output` is expected to be the logits). from_logits: Boolean, whether `output` is the result of a softmax, or is a tensor of logits. axis: Int specifying the channels axis. `axis=-1` corresponds to data format `channels_last`, and `axis=1` corresponds to data format `channels_first`. Returns: Output tensor. Raises: ValueError: if `axis` is neither -1 nor one of the axes of `output`. r9z"`sparse_categorical_crossentropy` received `from_logits=True`, but the `output` argument was produced by a sigmoid or softmax activation and thus does not represent logits. Was this intended?"Tr<rrRrN)r#r"zcCannot compute sparse categorical crossentropy with `axis={}` on an output tensor with unknown rankint64css|]}t|VqdS)N)_is_symbolic_tensor)rrr9r9r:rosz2sparse_categorical_crossentropy..)r:r;r1)+rrrr9ryrzrFrrHrIrrrrrrrjrErrrXr%rQrurr%ndims itertoolschainrrr'r}formatrKrrr&rrSr`r&Z+sparse_softmax_cross_entropy_with_logits_v2) rrr=r=r>Z output_rank permutationr8Z target_rankZ update_shaper5r9r9r:sparse_categorical_crossentropy s`              rGz!keras.backend.binary_crossentropycCst|}t|}t|dr6|j}|r2tdd}|rHtj||dSt|tj t j fs|j j dkrt|dst|j jdkst|j jd}tj||dStt|jj}t||d |}|t|t}|d|td|t7}| S) a^Binary crossentropy between an output tensor and a target tensor. Args: target: A tensor with the same shape as `output`. output: A tensor. from_logits: Whether `output` is expected to be a logits tensor. By default, we consider that `output` encodes a probability distribution. Returns: A tensor. r9z"`binary_crossentropy` received `from_logits=True`, but the `output` argument was produced by a sigmoid or softmax activation and thus does not represent logits. Was this intended?"T)r:r;ZSigmoidrrRrg?)rrrr9ryrzr&Z!sigmoid_cross_entropy_with_logitsrFrrHrIrrrrrrrjrErrrXr%rQ)rrr=r>Zbcer9r9r:binary_crossentropy~s(     rHzkeras.backend.sigmoidcCs t|S)z\Element-wise sigmoid. Args: x: A tensor or variable. Returns: A tensor. )r&sigmoid)rOr9r9r:rIs rIzkeras.backend.hard_sigmoidcCsFtd|jj}td|jj}t||}t||}t|dd}|S)zSegment-wise linear approximation of sigmoid. Faster than sigmoid. Returns `0.` if `x < -2.5`, `1.` if `x > 2.5`. In `-2.5 <= x <= 2.5`, returns `0.2 * x + 0.5`. Args: x: A tensor or variable. Returns: A tensor. g?g?gg?)rrErr%multiplyrrrX)rOZ point_twoZ point_fiver9r9r: hard_sigmoids   rKzkeras.backend.tanhcCs t|S)zYElement-wise tanh. Args: x: A tensor or variable. Returns: A tensor. )r&tanh)rOr9r9r:rLs rLzkeras.backend.dropoutcCs&|dkrtjd}tj||||dS)awSets entries in `x` to zero at random, while scaling the entire tensor. Args: x: tensor level: fraction of the entries in the tensor that will be set to 0. noise_shape: shape for randomly generated keep/drop flags, must be broadcastable to the shape of `x` seed: random seed to ensure determinism. Returns: A tensor. NgcA)rate noise_shaper)rMrrr&Z dropout_v2)rOlevelrNrr9r9r:dropouts rPzkeras.backend.l2_normalizecCstj||dS)zNormalizes a tensor wrt the L2 norm alongside the specified axis. Args: x: Tensor or variable. axis: axis along which to perform normalization. Returns: A tensor. )r=)r& l2_normalize)rOr=r9r9r:rQs rQzkeras.backend.in_top_kcCst|||S)aReturns whether the `targets` are in the top `k` `predictions`. Args: predictions: A tensor of shape `(batch_size, classes)` and type `float32`. targets: A 1D tensor of length `batch_size` and type `int32` or `int64`. k: An `int`, number of top elements to consider. Returns: A 1D tensor of length `batch_size` and type `bool`. `output[i]` is `True` if `predictions[i, targets[i]]` is within top-`k` values of `predictions[i]`. )r&in_top_k)Z predictionstargetskr9r9r:rR srRcCs,d}|dkr$ts t|d}nd}||fS)zTranspose and cast the input before the conv1d. Args: x: input tensor. data_format: string, `"channels_last"` or `"channels_first"`. Returns: A tensor. NWCr{)rr rRZNCW)rrr')rOrprrr9r9r:_preprocess_conv1d_input#s rVcCs0d}|dkr(tr|r$t|d}nd}||fS)aTranspose and cast the input before the conv2d. Args: x: input tensor. data_format: string, `"channels_last"` or `"channels_first"`. force_transpose: Boolean. If True, the input will always be transposed from NCHW to NHWC if `data_format` is `"channels_first"`. If False, the transposition only occurs on CPU (GPU ops are assumed to support NCHW). Returns: A tensor. rnr{)rr r1rRro)rrr')rOrpforce_transposerrr9r9r:_preprocess_conv2d_input6s  rXcCs,d}|dkr$ts t|d}nd}||fS)zTranspose and cast the input before the conv3d. Args: x: input tensor. data_format: string, `"channels_last"` or `"channels_first"`. Returns: A tensor. NDHWCr{)rr r1rtrRZNCDHW)rrr')rOrprrr9r9r:_preprocess_conv3d_inputMs rZcCs0|dkrd}n|dkrd}ntdt||S)zConvert keras' padding to TensorFlow's padding. Args: padding: string, one of 'same' , 'valid' Returns: a string, one of 'SAME', 'VALID'. Raises: ValueError: if invalid `padding'` ZsameZSAMEvalidZVALIDzInvalid padding: )r}r)rr9r9r:_preprocess_padding`s r\zkeras.backend.conv1dr[c Cs|dkrt}|dkr&tdt||j}|dkrZ||dd}t||df}d}t|}t||\}}tj ||||||d}|d kr|d krt |d }|S) a1D convolution. Args: x: Tensor or variable. kernel: kernel tensor. strides: stride integer. padding: string, `"same"`, `"causal"` or `"valid"`. data_format: string, one of "channels_last", "channels_first". dilation_rate: integer dilate rate. Returns: A tensor, result of 1D convolution. Raises: ValueError: if `data_format` is neither `channels_last` or `channels_first`. N>r{r|zUnknown data_format: ZcausalrrRr[)inputfilter dilation_ratestridesrrpr{rU)rr rR) rr}rrurrr\rVr& convolutionrr') rOkernelr`rrpr_ kernel_shapeZleft_padrrr9r9r:conv1dus*  rdzkeras.backend.conv2dcCsr|dkrt}|dkr&tdt|t||\}}t|}tj||||||d}|dkrn|dkrnt|d}|S)a2D convolution. Args: x: Tensor or variable. kernel: kernel tensor. strides: strides tuple. padding: string, `"same"` or `"valid"`. data_format: `"channels_last"` or `"channels_first"`. dilation_rate: tuple of 2 integers. Returns: A tensor, result of 2D convolution. Raises: ValueError: if `data_format` is neither `channels_last` or `channels_first`. N>r{r|zUnknown data_format: )r]r^r_r`rrpr{rn)rr1rRr ) rr}rrXr\r&rarr')rOrbr`rrpr_rrr9r9r:conv2ds  rezkeras.backend.conv2d_transposec Cs\|dkrt}|dkr&tdt||dkr<|dkrr{r|zUnknown data_format: r{)rRrRTFrnrr r1rR)rR)rrp)rMr)rr1rRr )rr}rrXrurrFr%rr2r\r&conv2d_transposerZatrous_conv2d_transposer') rOrbr8r`rrpr_rWrrr9r9r:rfsB      rfc Cs|dkrt}|dkr&tdt|t|tr6|f}t|trF|f}t||\}}t|}t|tsnt|}|dkrd}d|dd}nd}d|d}t ||}t |d }t |d }d|}t j |||||||d }t ||g}|d kr|dkrt |d }|S) a 1D convolution with separable filters. Args: x: input tensor depthwise_kernel: convolution kernel for the depthwise convolution. pointwise_kernel: kernel for the 1x1 convolution. strides: stride integer. padding: string, `"same"` or `"valid"`. data_format: string, `"channels_last"` or `"channels_first"`. dilation_rate: integer dilation rate. Returns: Output tensor. Raises: ValueError: if `data_format` is neither `channels_last` or `channels_first`. N>r{r|zUnknown data_format: rUrR)rRr )rRrRr)r`rrMrpr{)rr rR)rr}rrFrWrVr\rrrr&separable_conv2dr4r') rOdepthwise_kernelpointwise_kernelr`rrpr_rrZspatial_start_dimr9r9r:separable_conv1d!sB        rjzkeras.backend.separable_conv2dc Cs|dkrt}|dkr&tdt|t|dkr:tdt||\}}t|}t|tsbt|}|dkrxd|d}nd|}tj |||||||d }|d kr|dkrt |d }|S) a2D convolution with separable filters. Args: x: input tensor depthwise_kernel: convolution kernel for the depthwise convolution. pointwise_kernel: kernel for the 1x1 convolution. strides: strides tuple (length 2). padding: string, `"same"` or `"valid"`. data_format: string, `"channels_last"` or `"channels_first"`. dilation_rate: tuple of integers, dilation rates for the separable convolution. Returns: Output tensor. Raises: ValueError: if `data_format` is neither `channels_last` or `channels_first`. ValueError: if `strides` is not a tuple of 2 integers. N>r{r|zUnknown data_format: r z(`strides` must be a tuple of 2 integers.rn)rR)rRrR)r`rrMrpr{)rr1rRr ) rr}rrrXr\rFrr&rgrr')rOrhrir`rrpr_rrr9r9r:rgds0   rgzkeras.backend.depthwise_conv2dcCs|dkrt}|dkr&tdt|t||\}}t|}|dkrRd|d}nd|}tj||||||d}|dkr|dkrt|d }|S) a2D convolution with separable filters. Args: x: input tensor depthwise_kernel: convolution kernel for the depthwise convolution. strides: strides tuple (length 2). padding: string, `"same"` or `"valid"`. data_format: string, `"channels_last"` or `"channels_first"`. dilation_rate: tuple of integers, dilation rates for the separable convolution. Returns: Output tensor. Raises: ValueError: if `data_format` is neither `channels_last` or `channels_first`. N>r{r|zUnknown data_format: rn)rR)rRrR)r`rrMrpr{)rr1rRr ) rr}rrXr\r&depthwise_conv2drr')rOrhr`rrpr_rrr9r9r:rks& rkzkeras.backend.conv3drRrRrRcCsr|dkrt}|dkr&tdt|t||\}}t|}tj||||||d}|dkrn|dkrnt|d}|S)a3D convolution. Args: x: Tensor or variable. kernel: kernel tensor. strides: strides tuple. padding: string, `"same"` or `"valid"`. data_format: string, `"channels_last"` or `"channels_first"`. dilation_rate: tuple of 3 integers. Returns: A tensor, result of 3D convolution. Raises: ValueError: if `data_format` is neither `channels_last` or `channels_first`. N>r{r|zUnknown data_format: )r]r^r_r`rrpr{rY)rrtrRr r1) rr}rrZr\r&rarr')rOrbr`rrpr_rrr9r9r:conv3ds  rmcCs|dkrt}|dkr&tdt|t|ttfr>t|}t||\}}|dkr~|dkr~|d|d|d|d |d f}|ddkrt |dft|d d}tt|}t |}|dkrd |d }nd |}t j ||||||d }|dkr|dkrt |d}|S)a3D deconvolution (i.e. transposed convolution). Args: x: input tensor. kernel: kernel tensor. output_shape: 1D int tensor for the output shape. strides: strides tuple. padding: string, "same" or "valid". data_format: string, `"channels_last"` or `"channels_first"`. Returns: A tensor, result of transposed 3D convolution. Raises: ValueError: if `data_format` is neither `channels_last` or `channels_first`. N>r{r|zUnknown data_format: r{rYrr r1rtrR)rR)rRrR)rrp)rrtrRr r1)rr}rrFrr%rr2rZrur\r&conv3d_transposer')rOrbr8r`rrprrr9r9r:rns6    rnzkeras.backend.pool2dcCs|dkrt}|dkr&tdt|t|dkr:tdt|dkrNtdt||\}}t|}|dkrd|d}d|d}nd |}d |}|d krtj|||||d }n.|d krtj|||||d }ntd t||dkr|dkrt |d}|S)as2D Pooling. Args: x: Tensor or variable. pool_size: tuple of 2 integers. strides: tuple of 2 integers. padding: string, `"same"` or `"valid"`. data_format: string, `"channels_last"` or `"channels_first"`. pool_mode: string, `"max"` or `"avg"`. Returns: A tensor, result of 2D pooling. Raises: ValueError: if `data_format` is neither `"channels_last"` or `"channels_first"`. ValueError: if `pool_size` is not a tuple of 2 integers. ValueError: if `strides` is not a tuple of 2 integers. ValueError: if `pool_mode` is neither `"max"` or `"avg"`. N>r{r|zUnknown data_format: r z*`pool_size` must be a tuple of 2 integers.z(`strides` must be a tuple of 2 integers.rn)rR)rRrRr?)rrpavgzInvalid pooling mode: r{)rr1rRr ) rr}rrrXr\r&Zmax_poolZavg_poolrr')rO pool_sizer`rrp pool_moderrr9r9r:pool2d:s2    rrzkeras.backend.pool3dcCs|dkrt}|dkr&tdt|t||\}}t|}|dkr^d|d}d|d}nd|}d|}|dkrtj|||||d}n.|d krtj|||||d}ntd t||d kr|dkrt |d }|S) a3D Pooling. Args: x: Tensor or variable. pool_size: tuple of 3 integers. strides: tuple of 3 integers. padding: string, `"same"` or `"valid"`. data_format: string, `"channels_last"` or `"channels_first"`. pool_mode: string, `"max"` or `"avg"`. Returns: A tensor, result of 3D pooling. Raises: ValueError: if `data_format` is neither `"channels_last"` or `"channels_first"`. ValueError: if `pool_mode` is neither `"max"` or `"avg"`. N>r{r|zUnknown data_format: rY)rR)rRrRr?)rrprozInvalid pooling mode: r{)rrtrRr r1) rr}rrZr\r&Z max_pool3dZ avg_pool3drr')rOrpr`rrprqrrr9r9r:pool3dws*  rscsF|dkrt}|dkr&tdt|t|}|d}|d}t|} tt| } g} dd|D} x~tj| D]pt dg} |dkr| t d| fd d | D|d kr| t d| t || dd|fqpWt | d d }t||}t ||d|f}|dkr(| | dg| }n| g| | dg}t||S)aApply N-D convolution with un-shared weights. Args: inputs: (N+2)-D tensor with shape (batch_size, channels_in, d_in1, ..., d_inN) if data_format='channels_first', or (batch_size, d_in1, ..., d_inN, channels_in) if data_format='channels_last'. kernel: the unshared weight for N-D convolution, with shape (output_items, feature_dim, channels_out), where feature_dim = np.prod(kernel_size) * channels_in, output_items = np.prod(output_shape). kernel_size: a tuple of N integers, specifying the spatial dimensions of the N-D convolution window. strides: a tuple of N integers, specifying the strides of the convolution along the spatial dimensions. output_shape: a tuple of (d_out1, ..., d_outN) specifying the spatial dimensionality of the output. data_format: string, "channels_first" or "channels_last". Returns: An (N+2)-D tensor with shape: (batch_size, channels_out) + output_shape if data_format='channels_first', or: (batch_size,) + output_shape + (channels_out,) if data_format='channels_last'. Raises: ValueError: if `data_format` is neither `channels_last` nor `channels_first`. N>r{r|zUnknown data_format: rRr"cSsg|] }t|qSr9)r)rZaxis_maxr9r9r:rszlocal_conv..r{c3s8|]0}t|||||VqdS)N)slice)rr) kernel_sizepositionr`r9r:rszlocal_conv..r|r)r=)rr}rrrr%rrCproductrtrextendr&rr9ry)rrbrur`r8rprcZ feature_dimZ channels_outrBZspatial_dimensionsZxsZoutput_axes_ticksZslicesZ x_aggregaterrFr9)rurvr`r: local_convs8%      ryzkeras.backend.local_conv1dcCs|jdf}t||||||S)axApply 1D conv with un-shared weights. Args: inputs: 3D tensor with shape: (batch_size, steps, input_dim) if data_format is "channels_last" or (batch_size, input_dim, steps) if data_format is "channels_first". kernel: the unshared weight for convolution, with shape (output_length, feature_dim, filters). kernel_size: a tuple of a single integer, specifying the length of the 1D convolution window. strides: a tuple of a single integer, specifying the stride length of the convolution. data_format: the data format, channels_first or channels_last. Returns: A 3d tensor with shape: (batch_size, output_length, filters) if data_format='channels_first' or 3D tensor with shape: (batch_size, filters, output_length) if data_format='channels_last'. r)rury)rrbrur`rpr8r9r9r: local_conv1ds rzzkeras.backend.local_conv2dcCst||||||S)aApply 2D conv with un-shared weights. Args: inputs: 4D tensor with shape: (batch_size, filters, new_rows, new_cols) if data_format='channels_first' or 4D tensor with shape: (batch_size, new_rows, new_cols, filters) if data_format='channels_last'. kernel: the unshared weight for convolution, with shape (output_items, feature_dim, filters). kernel_size: a tuple of 2 integers, specifying the width and height of the 2D convolution window. strides: a tuple of 2 integers, specifying the strides of the convolution along the width and height. output_shape: a tuple with (output_row, output_col). data_format: the data format, channels_first or channels_last. Returns: A 4D tensor with shape: (batch_size, filters, new_rows, new_cols) if data_format='channels_first' or 4D tensor with shape: (batch_size, new_rows, new_cols, filters) if data_format='channels_last'. )ry)rrbrur`r8rpr9r9r: local_conv2d s #r{zkeras.backend.bias_addcCs|dkrt}|dkr&tdt|t|}t|dkrjt|t|dkrjtdt|t|dft|dkr|dkrtj||ddStj||d dSt|d kr|dkrd|d f|dd }|t||S|t|d |St||S) aAdds a bias vector to a tensor. Args: x: Tensor or variable. bias: Bias tensor to add. data_format: string, `"channels_last"` or `"channels_first"`. Returns: Output tensor. Raises: ValueError: In one of the two cases below: 1. invalid `data_format` argument. 2. invalid bias shape. the bias should be either a vector or a tensor with ndim(x) - 1 dimension N>r{r|zUnknown data_format: rRz>Unexpected bias dimensions %d, expect to be 1 or %d dimensionsr{ro)rprn)r1rtr")rR) rr}rrrrr&bias_addr&)rOZbiasrpZ bias_shapeZbias_reshape_axisr9r9r:r}Ks&   r}zkeras.backend.random_normalcCs6|dkrt}|dkr"tjd}tj|||||dS)amReturns a tensor with normal distribution of values. It is an alias to `tf.random.normal`. Args: shape: A tuple of integers, the shape of tensor to create. mean: A float, the mean value of the normal distribution to draw samples. Default to 0.0. stddev: A float, the standard deviation of the normal distribution to draw samples. Default to 1.0. dtype: `tf.dtypes.DType`, dtype of returned tensor. Default to use Keras backend dtype which is float32. seed: Integer, random seed. Will use a random numpy integer when not specified. Returns: A tensor with normal distribution of values. Example: >>> random_normal_tensor = tf.keras.backend.random_normal(shape=(2,3), ... mean=0.0, stddev=1.0) >>> random_normal_tensor NgcA)rstddevrEr)rLrMrrr' random_normal)rurr~rErr9r9r:rys  rzkeras.backend.random_uniformcCs6|dkrt}|dkr"tjd}tj|||||dS)aReturns a tensor with uniform distribution of values. Args: shape: A tuple of integers, the shape of tensor to create. minval: A float, lower boundary of the uniform distribution to draw samples. maxval: A float, upper boundary of the uniform distribution to draw samples. dtype: String, dtype of returned tensor. seed: Integer, random seed. Returns: A tensor. Example: >>> random_uniform_tensor = tf.keras.backend.random_uniform(shape=(2,3), ... minval=0.0, maxval=1.0) >>> random_uniform_tensor NgcA)minvalmaxvalrEr)rLrMrrr'random_uniform)rurrrErr9r9r:rs  rzkeras.backend.random_binomialcCstdt||||S)aReturns a tensor with random binomial distribution of values. DEPRECATED, use `tf.keras.backend.random_bernoulli` instead. The binomial distribution with parameters `n` and `p` is the probability distribution of the number of successful Bernoulli process. Only supports `n` = 1 for now. Args: shape: A tuple of integers, the shape of tensor to create. p: A float, `0. <= p <= 1`, probability of binomial distribution. dtype: String, dtype of returned tensor. seed: Integer, random seed. Returns: A tensor. Example: >>> random_binomial_tensor = tf.keras.backend.random_binomial(shape=(2,3), ... p=0.5) >>> random_binomial_tensor z`tf.keras.backend.random_binomial` is deprecated, and will be removed in a future version.Please use `tf.keras.backend.random_bernoulli` instead.)ryrzrandom_bernoulli)rurrErr9r9r:random_binomials rzkeras.backend.random_bernoullicCsT|dkrt}|dkr"tjd}ttj|||d|ktj||dtj ||dS)aAReturns a tensor with random bernoulli distribution of values. Args: shape: A tuple of integers, the shape of tensor to create. p: A float, `0. <= p <= 1`, probability of bernoulli distribution. dtype: String, dtype of returned tensor. seed: Integer, random seed. Returns: A tensor. NgcA)rEr)rE) rLrMrrrrr'rr r)rurrErr9r9r:rs rzkeras.backend.truncated_normalcCs6|dkrt}|dkr"tjd}tj|||||dS)a'Returns a tensor with truncated random normal distribution of values. The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than two standard deviations from the mean are dropped and re-picked. Args: shape: A tuple of integers, the shape of tensor to create. mean: Mean of the values. stddev: Standard deviation of the values. dtype: String, dtype of returned tensor. seed: Integer, random seed. Returns: A tensor. NgcA)rEr)rLrMrrr'truncated_normal)rurr~rErr9r9r:rs  rz'keras.backend.ctc_label_dense_to_sparsec s0t|}t|dg}t|dgfdd}ttd|dgdtj}tj |||dd}|dddddf}t t t d|d||}t ||}tt t t d|dt|d} t | |} tt t| |gdddd g} t|| } tt| tj| t|tjS) zConverts CTC labels from dense to sparse. Args: labels: dense CTC labels. label_lengths: length of the labels. Returns: A sparse tensor representation of the labels. rrRcs(ttt|ddt|kS)NrRr)rrr%rrufill)Z old_inputr)max_num_labels_tnsr9r:range_less_than1sz2ctc_label_dense_to_sparse..range_less_than)rrN)r=r r")rrur2r%rKrrrrscanr&rrZ boolean_maskr'rrZ gather_ndrrJr@) r:Z label_lengthsZ label_shapeZnum_batches_tnsrinitZ dense_maskZ label_arrayZ label_indZ batch_arrayZ batch_indrZ vals_sparser9)rr:ctc_label_dense_to_sparse s0     rzkeras.backend.ctc_batch_costcCs|ttj|ddtj}ttj|ddtj}tt||tj}ttj|dddgdt }t t j |||ddS)a\Runs CTC loss algorithm on each batch element. Args: y_true: tensor `(samples, max_string_length)` containing the truth labels. y_pred: tensor `(samples, time_steps, num_categories)` containing the prediction, or output of the softmax. input_length: tensor `(samples, 1)` containing the sequence length for each batch item in `y_pred`. label_length: tensor `(samples, 1)` containing the sequence length for each batch item in `y_true`. Returns: Tensor with shape (samples,1) containing the CTC loss of each element. r")r=rRrr )r#)rr:sequence_length) r%rKrr4rr}rrQr'rjrctcZctc_loss)Zy_truey_predrZ label_lengthZ sparse_labelsr9r9r:ctc_batch_costPs rzkeras.backend.ctc_decodeTdc Cst|}|d|d}}ttj|dddgdt}t|tj}|r`t j ||d\}} nt j ||||d\}} g} x6|D].} t | j| j||f} | tj| ddqW| | fS) aDecodes the output of a softmax. Can use either greedy search (also known as best path) or a constrained dictionary search. Args: y_pred: tensor `(samples, time_steps, num_categories)` containing the prediction, or output of the softmax. input_length: tensor `(samples, )` containing the sequence length for each batch item in `y_pred`. greedy: perform much faster best-path search if `true`. This does not use a dictionary. beam_width: if `greedy` is `false`: a beam search decoder will be used with a beam of this width. top_paths: if `greedy` is `false`, how many of the most probable paths will be returned. Returns: Tuple: List: if `greedy` is `true`, returns a list of one element that contains the decoded sequence. If `false`, returns the `top_paths` most probable decoded sequences. Each decoded sequence has shape (samples, time_steps). Important: blank labels are returned as `-1`. Tensor `(top_paths, )` that contains the log probability of each decoded sequence. rrRr )r#)rr)rr beam_width top_pathsr")Zsp_input default_value)rur%rQrr'rjrKrr}rZctc_greedy_decoderZctc_beam_search_decoderrrJrrrr(r) rrZgreedyrrZ input_shapeZ num_samplesZ num_stepsdecodedZlog_probZ decoded_densestr9r9r: ctc_decoders&    rzkeras.backend.map_fncCstj||||dS)a)Map the function fn over the elements elems and return the outputs. Args: fn: Callable that will be called upon each element in elems elems: tensor name: A string name for the map node in the graph dtype: Output data type. Returns: Tensor with dtype `dtype`. )rvrE) map_fn_libr$)fnelemsrvrEr9r9r:r$sr$zkeras.backend.foldlcCstj||||dS)aReduce elems using fn to combine them from left to right. Args: fn: Callable that will be called upon each element in elems and an accumulator, for instance `lambda acc, x: acc + x` elems: tensor initializer: The first value used (`elems[0]` in case of None) name: A string name for the foldl node in the graph Returns: Tensor with same type and shape as `initializer`. )rrv)rfoldl)rrrrvr9r9r:rsrzkeras.backend.foldrcCstj||||dS)aReduce elems using fn to combine them from right to left. Args: fn: Callable that will be called upon each element in elems and an accumulator, for instance `lambda acc, x: acc + x` elems: tensor initializer: The first value used (`elems[-1]` in case of None) name: A string name for the foldr node in the graph Returns: Same type and shape as initializer )rrv)rfoldr)rrrrvr9r9r:rsrZ KERAS_HOME~z.kerasz keras.jsonrL>float32float16float64rjr>r{r|rC)rLrjrDrwrt)indentcCs,dd}|jr t||n||dS)z6Configure session config and create a session with it.cSst}ttddr(tjjr(|tjjt|rV|||jj }t j ||d}nDt }|r|j}||t j ||jd}n||t j |d}t|dS)z(Create the Distributed Strategy session.rN)r r)r )rrmr_r_configZ MergeFromis_tpu_strategy configureextendedZ_tpu_cluster_resolvermasterrrdcZget_current_worker_contextsession_configZ master_targetr)distribution_strategyrrrZworker_contextZdc_session_configr9r9r:_create_sessions      zAconfigure_and_create_distributed_session.._create_sessionN)rZ_in_multi_worker_moderZrun_distribute_coordinator)rrr9r9r:rs ! rcCs$dd}||rdSttt|jS)NcSs |jdS)NZ TPUStrategy)r5 startswith)rTr9r9r:r>rz(_is_tpu_strategy_class..T)rr_is_tpu_strategy_class __bases__)ZclzZ is_tpu_stratr9r9r:r=srcCs t|jS)zEReturns whether input is a TPUStrategy instance or subclass instance.)rrA)Zstrategyr9r9r:rDsrcCsdd}t||S)NcSst|tjrt|S|S)N)rFrHrIrr)rr9r9r:_cast_variables_to_tensorKs  z;cast_variables_to_tensor.._cast_variables_to_tensor)r1r)rxrr9r9r:rIsrcCst|ot|tj S)N)rrrFrr)rOr9r9r:rASsrAcCs\dd}t|}tdd|D}|s0|dfSt||}t|ddd}||fS)z%Converts any ragged tensors to dense.cSst|tjr|S|S)N)rFr-rr)rr9r9r:_convert_ragged_inputZs z7convert_inputs_if_ragged.._convert_ragged_inputcss|]}t|tjVqdS)N)rFr-r)rrr9r9r:rasz+convert_inputs_if_ragged..Nrr})r1rrrr%rKnested_row_lengths)rrZ flat_inputsZcontains_raggedrr9r9r:convert_inputs_if_raggedWs  rcCsD|s|S|r2t|dg}tj||}t|dgStj||SdS)z8Converts any ragged input back to its initial structure.rRN)rr-rr)Zis_ragged_inputrrrrr9r9r:maybe_convert_to_raggedns  rc@sBeZdZdZddZddZddZdd Zd d Zdd dZ d S)ContextValueCacheaContainer that caches (possibly tensor) values based on the context. This class is similar to defaultdict, where values may be produced by the default factory specified during initialization. This class also has a default value for the key (when key is `None`) -- the key is set to the current graph or eager context. The default factories for key and value are only used in `__getitem__` and `setdefault`. The `.get()` behavior remains the same. This object will return the value of the current graph or closest parent graph if the current graph is a function. This is to reflect the fact that if a tensor is created in eager/graph, child functions may capture that tensor. The default factory method may accept keyword arguments (unlike defaultdict, which only accepts callables with 0 arguments). To pass keyword arguments to `default_factory`, use the `setdefault` method instead of `__getitem__`. An example of how this class can be used in different contexts: ``` cache = ContextValueCache(int) # Eager mode cache[None] += 2 cache[None] += 4 assert cache[None] == 6 # Graph mode with tf.Graph().as_default() as g: cache[None] += 5 cache[g] += 3 assert cache[g] == 8 ``` Example of a default factory with arguments: ``` cache = ContextValueCache(lambda x: x + 1) g = tf.get_default_graph() # Example with keyword argument. value = cache.setdefault(key=g, kwargs={'x': 3}) assert cache[g] == 4 ``` cCs||_tj|dS)N)default_factoryweakrefWeakKeyDictionaryr=)r@rr9r9r:r=szContextValueCache.__init__cCstrtjStSdS)N)rrgrar>rrl)r@r9r9r:_keyszContextValueCache._keycCs$|j}t|tjs tr tjS|S)z/Returns the parent graph or dummy eager object.)Z outer_graphrFr rrrrar>)r@rYZ parent_graphr9r9r:_get_parent_graphs  z#ContextValueCache._get_parent_graphcCs6||}|dk r|St|tjr2|||SdS)z2Gets the value at key or the closest parent graph.N)rrFr r_get_recursiver)r@r>rjr9r9r:rs   z ContextValueCache._get_recursivecCs6|dkr|}||}|dkr2|}||<|S)zGets the value at key (or current context), or sets default value. Args: key: May be `None` or `Graph`object. When `None`, the key is set to the current context. Returns: Either the cached or default value. N)rrr)r@r>rjr9r9r: __getitem__s  zContextValueCache.__getitem__NcCsD|dkr|}|pi}|dkr4||kr4|jf|}tj|||S)zDSets the default value if key is not in dict, and returns the value.N)rrrrrc)r@r>defaultrr9r9r:rcs  zContextValueCache.setdefault)NNN) r5r6r7r8r=rrrrrcr9r9r9r:r~s,  r)rQ)N)r9)r9)N)NNN)NNrQFF)N)NNN)NNNFNF)NN)NN)NN)NN)NN)N)NNN)NNN)N)NF)NF)NF)NF)r)r)NF)NF)NF)NF)NF)r")r")NF)rd)rd)rd)rd)r"rd)r")rz)NrRr})r")r)rN)rN)r)rQr1)NN)FNNFNFF)N)N)r.Nr)r3)r")Fr")Fr")F)NN)N)F)rRr[NrR)rr[Nr)rr[Nr)rRr[NrR)rr[Nr)rr[Nr)rlr[Nrl)rlr[N)rr[Nr?)rlr[Nr?)N)N)N)N)r.r3NN)r.r3NN)r.NN)r.NN)r.r3NN)TrrR)NN)NN)NN)F(Or8rUrCjsonrr threadingryrrrMZtensorflow.core.protobufrZtensorflow.pythonrZtensorflow.python.clientrrZtensorflow.python.distributerZtensorflow.python.eagerrZtensorflow.python.eager.contextrZtensorflow.python.frameworkrr r r r rr rrrrrrrZ"tensorflow.python.keras.distributerrrrrrrrrZtensorflow.python.opsrrrrrrrrr r!r"r#r$rr%r&r'r(r)r*r+r,rHZtensorflow.python.ops.raggedr-Ztensorflow.python.platformr.rZtensorflow.python.trainingr/Ztensorflow.python.utilr0r1Z tensorflow.python.util.tf_exportr2Ztensorflow.tools.docsr3rHrrBZpy_sumrGrlocalr^rr_rrTrr\r4rarirrjrLrZ set_epsilonZ set_floatxZset_image_data_formatZdo_not_generate_docsrDZadd_dispatch_supportrPrZr]rhrkrqrrrprnrxr|r{contextmanagerrr~rrrrrrrSrrrrrrrrrrrrrrwZ name_scope_v1Z_v1_name_scoperrrrrrrrrrrtrurrrErrrr r r rrrrrrKrrrrr.r9r'r:r?r@rrCrDrErFrrIrJrKrLrNrPrQrRrSrTrUrZr[r\r]r^r_r`rMrarbrcrlrmrsrvrfrr&ryrrrrrrrrrr4rrrr2rrZ_VALUE_SET_CODE_STRINGrrrrrErrrrr"r(r,r-r1r4r6r7r8r?rGrHrIrKrLrPrQrRrVrXrZr\rdrerfrjrgrkrmrnrrrsryrzr{r}rrrrrrrrrrrrZ _keras_dirpath expanduserZ_keras_base_dirjoinZ _config_pathexistsopenfhloadrr}Z_floatxrZ_epsilonrFrVZ_image_data_formatmakedirsOSErrorfr dumpsIOErrorrrrrrArrrrbZObjectIdentityWeakSetrdrfr9r9r9r:s<                                                       A  !6 G   #     1  3 6X  +! !!2A<#          + =$1 =#% ++#&&'F/@,7  P[0   ,%E=2+(654H"#+# !. 7$    ., r