a Sicc @sdZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m mZddlmZddlmZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd l m!Z!dd l"m#Z$ddl%m&Z&ddl'm(Z(e)Z*e+Z,e-Z.e/a0e/a1Gdddej/Z2e2a3e 4Z5e6Z7Gdddej/Z8e8Z9da:da;ejZ>ej?Z?ej@Z@ejAZAe&de(jBddZCe&dejDjEjFe(jBddZGe&dd]ddZHe&dd d!ZIe&d"d#d$ZJejDKeJe&d%e(jBd&d'ZLe&d(e(jBd)d*ZMd+d,ZNd-d.ZOd/d0ZPd1d2ZQd3d4ZRd5d6ZSe&d7e(jBd8d9ZTd:d;ZUe&d<ejVe(jBd=d>ZWejVd?d@ZXejVdAdBZYdCdDZZdEdFZ[d^dGdHZ\d_dJdKZ]e&dLgdMd`dNdOZ^ejD_e^ejDj`ae^dPdQZbejVdadRdSZce&dTgdMdUdVZddWdXZedYdZZfGd[d\d\Zgd]d^Zhd_d`ZidadbZjdcddZkdedfZldgdhZme&die(jBdjdkZne&dlejDjEjFe(jBdmdnZoe&dogdMe(jBdpdqZpej jqjpZre&dogdrdsere&dte(jBdbdudvZsdwdxZte&dygdMdzd{Zud|d}Zvdcd~dZwddddZxe&dgdMddZye&dejDjEjFe(jBdeddZze&dddZ{e&de(jBdfddZ|ddZ}e&dejDjEjFe(jBddZ~e&de(jBddZe&de(jBddZe&dejDjEjFe(jBddZe(jBddZe&de(jBddZe&de(jBdgddZe&dejDjEjFe(jBdhddZe&dejDjEjFe(jBdiddZe&de(jBdjddZe&dejDjEjFe(jBdkddZdlddZdae/Ze&dgdMddZe&dgdMddZe&dgdMddZGdddejDj`jZe&de(jBdmddZe&de(jBdndd„Ze&dÃe(jBddńZe&dƃejDjEjFe(jBddȄZe&dɃe(jBdd˄Ze&d̃e(jBdd΄Ze&dσe(jBddфZe&d҃e(jBddԄZe&dՃejDjEjFe(jBddׄZe&d؃ejDjEjFe(jBdoddڄZe&dۃejDjEjFe(jBdd݄Ze&dރejDjEjFe(jBddZe&dejDjEjFe(jBdpddZe&dejDjEjFe(jBdqddZe&dejDjEjFe(jBdrddZ+e&dejDjEjFe(jBdsddZe&dejDjEjFe(jBdtddZe&dejDjEjFe(jBduddZe&de(jBdvddZe&dejDjEjFe(jBdwddZe&dejDjEjFe(jBdxddZe&dejDjEjFe(jBdyddZ-e&dejDjEjFe(jBdzddZ)e&dejDjEjFe(jBd{ddZe&dejDjEjFe(jBd|ddZe&d ejDjEjFe(jBd d Ze&d ejDjEjFe(jBd dZe&dejDjEjFe(jBddZe&dejDjEjFe(jBddZe&dejDjEjFe(jBddZd}ddZe&dejDjEjFe(jBddZe&dejDjEjFe(jBddZe&d ejDjEjFe(jBd!d"Ze&d#ejDjEjFe(jBd$d%Ze&d&ejDjEjFe(jBd'd(Ze&d)ejDjEjFe(jBd*d+Ze&d,ejDjEjFe(jBd-d.Ze&d/ejDjEjFe(jBd0d1Ze&d2ejDjEjFe(jBd3d4Ze&d5ejDjEjFe(jBd6d7Ze&d8ejDjEjFe(jBd9d:Ze&d;ejDjEjFe(jBd<d=Ze&d>ejDjEjFe(jBd?d@Ze&dAejDjEjFe(jBdBdCZd~dEdFZddGdHZddIdJZe&dKe(jBddLdMZe&dNejDjEjFe(jBddOdPZe&dQejDjEjFe(jBddRdSZe&dTejDjEjFe(jBdUdVZe&dWejDjEjFe(jBdXdYZe&dZejDjEjFe(jBdd\d]Ze&d^ejDjEjFe(jBd_d`Ze&daejDjEjFe(jBdbdcZe&ddejDjEjFe(jBdedfZe&dgejDjEjFe(jBddjdkZe&dlejDjEjFe(jBdmdnZe&doejDjEjFe(jBdpdqZe&drejDjEjFe(jBdsdtZe&duejDjEjFe(jBddvdwZe&dxejDjEjFe(jBdydzZe&d{ejDjEjFe(jBdd}d~Ze&dejDjEjFe(jBdddZe&dejDjEjFe(jBdddZe&dejDjEjFe(jBdddZe&dejDjEjFe(jBddZe&dejDjEjFe(jBddZҐdddZe&de(jBddZe&dejDjEjFe(jBddZe&de(jBddZe&dejDjEjFe(jBddZejjeӐde_ejjeӐde_e&dejDjEjFe(jBdddZGdddZe&de(jBdddZe&de(jBddZe&dejDjEjFe(jBddZe&dejDjEjFdddZe&dejDjEjFe(jBddZe&de(jBdddZe&de(jBdddZe&dejDjEjFe(jBdddZe&dejDjEjFe(jBdddZe&dejDjEjFe(jBdddÄZe&dăejDjEjFe(jBdŐdƄZe&dǃejDjEjFe(jBdȐdɄZdʐd˄Ze&d̃ejDjEjFe(jBdd͐d΄Ze&dσejDjEjFe(jBddАdфZe&d҃ejDjEjFe(jBddӐdԄZe&dՃejDjEjFe(jBddؐdلZe&dڃejDjEjFe(jBdېd܄Ze&d݃ejDjEjFe(jBdސd߄Ze&dejDjEjFe(jBddZe&dejDjEjFe(jBdddZe&dejDjEjFe(jBdddZe&dejDjEjFe(jBddZddZdddZddZddZe&dejDjEjFe(jBdddZe&dejDjEjFe(jBdddZe&dejDjEjFe(jBdddZdddZe&dejDjEjFe(jBdddZe&dejDjEjFe(jBdddZe&dejDjEjFe(jBddd Zdd d Ze&d ejDjEjFe(jBdd dZe&dejDjEjFe(jBdddZdddZe&dejDjEjFe(jBdddZe&dejDjEjFe(jBdddZe&dejDjEjFe(jBdddZe&dejDjEjFe(jBdddZe&d ejDjEjFe(jBdd!d"Ze&d#ejDjEjFe(jBdd$d%Ze&d&ejDjEjFe(jBdd'd(Ze&d)ejDjEjFe(jBdd*d+Ze&d,ejDjEjFe(jBd-d.Z e&d/ejDjEjFe(jBd0d1Z e&d2ejDjEjFe(jBdd4d5Z e&d6e(jBdd7d8Z e&d9e(jBdd:d;Z e&d<e(jBdd=d>Zd?ejvr$ejd?Zn,ejd@ZejedAZejejedBZejerzDee"ZeeZWdn1s0YWneyiZYn0edCe=ZedDvsJedEe<Zeee s>JedFe>Z!e!dGvsfJe@ee?eeAe!ejesze"eWne#yYn0ejes`e=e<dHe>dIZzXeedJ2Z$e$%ej&edKdLWdn1s<0YWne'y^Yn0dMdNZ(dOdPZ)dQdRZ*dSdTZ+dUdVZ,dWdXZ-ddYdZZ.Gd[d\d\e j4Z/e/ej0a1e/ej0a2e/ej0a3dS(zKeras backend API.N)backend_config)distribute_coordinator_utils) keras_tensor)control_flow_util)object_identity) tf_contextlib) tf_inspect) config_pb2)context) get_config) tf_logging) keras_export) doc_controlscseZdZfddZZS) SessionLocalcstd|_dSN)super__init__sessionself __class__I/var/www/html/django/DPS/env/lib/python3.9/site-packages/keras/backend.pyrDs zSessionLocal.__init__)__name__ __module__ __qualname__r __classcell__rrrrrCsrcs.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._WeakReferencableClassaThis 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)rrr__doc__rrrr_WeakReferencableClasses r cstt|_d|_dSNF)rrrr keylearning_phase_is_setrrrrrss  z_DummyEagerGraph.__init__)rrrrr rrrrrrr]srFzkeras.backend.backendcCsdS)zPublicly accessible method for determining the current backend. Only exists for API compatibility with multi-backend Keras. Returns: The string "tensorflow". tensorflowrrrrrbackends r%zkeras.backend.cast_to_floatxcCs6t|tjtjtjfr&tj|tdStj|tdS)a%Cast 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) isinstancetfTensorVariable SparseTensorcastfloatxnpasarrayxrrrcast_to_floatxsr3zkeras.backend.get_uidcCs<t}|tvrttt|<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)prefixgraphlayer_name_uidsrrrget_uids r>zkeras.backend.reset_uidscCsttdS)zResets graph identifiers.N)r7clearOBSERVED_NAMESrrrr reset_uidssrAzkeras.backend.clear_sessioncCsdt_tjjttjdur2tj dt_t }| Bdt _ iat}t||t|dt|dWdn1s0YtrtdS)akResets 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)_GRAPHr<r)compatv1reset_default_graphrA_SESSIONrcloser6 as_default_DUMMY_EAGER_GRAPHr#_GRAPH_LEARNING_PHASES_default_learning_phase_internal_set_learning_phase_GRAPH_VARIABLESpop_GRAPH_TF_OPTIMIZERSexecuting_eagerlyr clear_kernel_cacher<phaserrr clear_sessions 2      *rTz,keras.backend.manual_variable_initializationcCs|adS)a@Sets 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_INITvaluerrrmanual_variable_initialization/srXzkeras.backend.learning_phasecCstjj}|ttddur$t}nptXt rpt j t vrXt }tt j |dt _tt j WdSt}Wdn1s0Yt|||S)a)Returns 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). r<NT)r)rCrDget_default_graphgetattrrBsymbolic_learning_phase init_scoper rPrIr"rJrKrLr#_internal_get_learning_phase_mark_func_graph_as_unsaveable)r<learning_phaserSrrrr_As    $ r_cCstjSr)rIr#rrrrglobal_learning_phase_is_setgsr`cCs|jrt|r|ddS)aMark 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_placeholdermark_as_unsaveable)r<r_rrrr^ks r^cCsRt}|0|tvr(t}t||t|WdS1sD0YdSr)r6rHrJrKrLr]rRrrrr[s   r[cCs,t|tjr t|}|t|<n|t|<dSr)r(r)r*weakrefrefrJ)r<rWZ value_refrrrrLs   rLcCs&t|d}t|tjr|S|SdSr)rJgetr(rdrerRrrrr]s  r]cCsLtr dStd$tjjjddddWdS1s>0YdS)Nrr4Frkeras_learning_phaseshapename)r rP name_scoper)rCrDplaceholder_with_defaultrrrrrKs  rKz 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_phaserVrrrset_learning_phasesrpcCsb|dvrtdt6tr4dt_ttj|tt|Wdn1sT0YdS)aA 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`. rr5%Expected learning phase to be 0 or 1.TN) ValueErrorr)r\rPrIr#rLr"r6rVrrrros  roz"keras.backend.learning_phase_scopeccsHtjdddt|z dVWn0Wdn1s:0YdS)aiProvides 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. stacklevelN)rmrn(deprecated_internal_learning_phase_scoperVrrrlearning_phase_scopes rxccs|dvrtdt,tr,ttj}tt}Wdn1sJ0Ytj}zt |dVW|svdt_thtr|durt tj|ntjt vrt tj=t}|durt ||n|t vrt |=Wdn1s0Yn|sdt_trtrD|dur0t tj|ntjt vrDt tj=t}|dur`t ||n|t vrpt |=Wdn1s0Y0dS)aAn 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`. rqrrNF) rsr)r\rPr]rIr"r6r#rorLrJ)rWprevious_eager_valueprevious_graph_valuelearning_phase_previously_setr<rrrrwsT (   &       rwc cs~|dvs JtjjsJt}|r,t}z0ttj|dVW|rTttj|qzt tj=n|rpttj|nt tj=0dS)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`. rqN) r)rCrD#executing_eagerly_outside_functionsr`r_rLrIr"rJ)rWglobal_learning_phase_was_setprevious_valuerrreager_learning_phase_scopeJs   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)rZcallable)objconv_fnrrrris  rcCs@t|dd}t|dd}|r<|r<||ur|jt|Wdn1s40Y|S)atReturns the TF session to be used by the backend. If a default TensorFlow session is available, we will return it. Else, we will return the global Keras session assuming it matches the current graph. If no global Keras session exists at this point: we will create a new global session. Note that you can manually set the global session via `K.set_session(sess)`. Args: op_input_list: An option sequence of tensors or ops, which will be used to determine the current graph. Otherwise the default graph will be used. Returns: A TensorFlow session. N)rrUr<rH_initialize_variables)rrrrr get_sessions  &rcCs8tr(ttdds"tjdt_tjStjj SdS)Nr< keras_graph) r)rPrZrBr FuncGraphr<rCrDrYrrrrr6s  r6ccsnttdd}|dur,|dur,||ur,td|r:|VdS|pHtjd}z|t_|VWdt_ndt_0dS)aZRetrieve a shared and temporary func graph. The eager execution path lifts a subgraph from the keras global graph into a scratch graph in order to create a function. DistributionStrategies, in turn, constructs multiple functions as well as a final combined function. In order for that logic to work correctly, all of the functions need to be created on the same scratch FuncGraph. Args: graph: A graph to be used as the current scratch graph. If not set then a scratch graph will either be retrieved or created: Yields: The current scratch graph. r<Nz"Multiple scratch graphs specified.keras_scratch_graph)rZ_CURRENT_SCRATCH_GRAPHrsr)rrr<)r< scratch_graphrrr_scratch_graph(s  rzkeras.backend.set_sessioncCs |t_dS)zRSets the global TensorFlow session. Args: session: A TF Session. N)rFrrrrr set_sessionOsrcCs&tjdrtdt}d|_|S)NOMP_NUM_THREADSzOMP_NUM_THREADS is no longer used by the default Keras config. To configure the number of threads, use tf.config.threading APIs.T)osenvironrfloggingwarningr allow_soft_placementrrrrrZs rcCs6tjj}t|d}|dur2tt}|t|<|Sr) r)rCrDrYr7rfr8r9r:)r< name_uid_maprrrget_default_graph_uid_mapgs    rc@s(eZdZdZddZddZddZdS) _TfDeviceCaptureOpz(Class for capturing the TF device scope.cCs d|_dSrdevicerrrrrvsz_TfDeviceCaptureOp.__init__cCst|tjr|}||_dS)z8This method captures TF's explicit device scope setting.N)r(r) DeviceSpec to_stringr)rrrrr _set_deviceys z_TfDeviceCaptureOp._set_devicecCs ||_dSrr)r device_strrrr_set_device_from_stringsz*_TfDeviceCaptureOp._set_device_from_stringN)rrrrrrrrrrrrssrcCsFt}t}||tjjr0tj|j Stj j j|j SdS)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) r6r_apply_device_functionsr)rtf2enabledr from_stringrrCrD)r<oprrr_get_current_tf_devices   rcCs4|}|dvrtdt}|duo2|j|kS)azCheck 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)upperrsr device_type)rrrrr_is_current_explicit_devices rcCsBtjjr"ddtjdDStdur4taddtDS)zwGet a list of available GPU devices (formatted as strings). Returns: A list of available GPU devices. cSsg|] }|jqSrrj.0drrr z'_get_available_gpus..rNcSsg|]}|jdkr|jqS)r)rrjrr2rrrrr) r)rCrDr|rlist_logical_devices_LOCAL_DEVICESr list_devicesrrrr_get_available_gpuss   rcCstd}tt}| o|S)aRCheck 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)explicitly_on_cpugpus_availablerrr_has_nchw_supports  rcCstj||dS)aJConvert 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. r&)r)constantr2r'rrr_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. r&)r)convert_to_tensorrrrr _to_tensors rzkeras.backend.is_sparsecCs,t|dd}|dur t|tjSt|tjS)a{Returns 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 _type_specN)rZr(r)SparseTensorSpecr,)tensorspecrrr is_sparses  rzkeras.backend.to_densecCst|rtj|S|SdS)aConverts 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)sparseto_denserrrrrs rzkeras.backend.name_scopecCs t|S)a}A 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. )r)rkrrrrrk"srkT)rDallow_multiple_exportszkeras.backend.variablecCs|durt}t|drd|}tt|jdt|jdfd}tj ||j |j d}|j |_ |Stj |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) Ntocoor5)indicesvalues dense_shape)r'rj constraintri)r.hasattrrr/ concatenate expand_dimsrowcolr)r,datari _keras_shaper+as_dtyper(ndarray int_shapetrack_variable)rWr'rjr sparse_coorvrrrvariableFs4       rcCs"tr dStd}||dS)zBTracks the given TF optimizer for initialization of its variables.N)r)rPrOadd) tf_optimizer optimizersrrrtrack_tf_optimizersrz)keras.__internal__.backend.track_variablecCs4tr dSt|dr|jnt}t||dS)z-Tracks the given variable for initialization.Nr<)r)rPrr<r6rMr)rr<rrrrsrcCst|dS)zFObserve a name and make sure it won't be used by `unique_object_name`.N)r@rrrrrobserve_object_namesrc Cs|durt}|dur&|r t}nt}d}|dus:||vr||f}|rz||}|rd|dt|}n|}||d7<q*||d7<|dt||}q*|S)a Makes 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_r5)rr@setstr) rjr avoid_names namespace zero_basedavoid_observed_names proposed_namename_keynumberrrrunique_object_names$#rcCs6tr Jt|}t|D]}||jq|S)zFReturns variables corresponding to the given graph for initialization.)r)rPrMrOupdate optimizer variables)r<r optrrr_get_variabless   r z/keras.__internal__.backend.initialize_variablescstt}g}|D]}t|dds||q|r|dd|Dfddt|D}g}t||D]\}}|r||d|_qj|r|tj j |dS)z9Utility to initialize uninitialized variables on the fly._keras_initializedFcSsg|]}tjj|qSr)r)rCrDis_variable_initializedrrrrrrrz)_initialize_variables..cs$g|]\}}| o|jduqSr) initializer)rnris_initializedrrrsTN) r r6rZappendrun enumeratezipr r)rCrDvariables_initializer)rr candidate_varsrshould_be_initializeduninitialized_varsflagrrrrs&      rzkeras.backend.constantcCs |durt}tj||||dS)a"Creates 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)r'rirj)r.r)r)rWr'rirjrrrrsrzkeras.backend.is_keras_tensorcCsXt|tjtjtjtjtjfs6tdt t |dtj j rNt|tjSt|dS)a`Returns 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)r(r)r*r+r, RaggedTensorr KerasTensorrsrrrCrDr|rr1rrris_keras_tensor s&,    rzkeras.backend.placeholderc Cs|r|rtd|durt}|s.|r.d|}tjjr|rNtj||d}nj|rd}tdt|D]0}||dust ||drd||j durd|}qdtj |||d}ntj |||d }t j||d } nt|rtjjj|||d } nr|rLd}tdt|D]}||dur|}qtj |||d} d d } tjj| | dd} ntjjj|||d } Wdn1sv0Ytrddlm} | j| d} d| _| S)a[Instantiates 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_tensor). 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.Nr)rir'rr5rW)rir' ragged_rankrir'rjrrhcSstjj|j|jSr)r)rCrD placeholderr'ri) tensorspecrrrtensor_spec_to_placeholdersz/placeholder..tensor_spec_to_placeholderTexpand_composites) input_layerr)rsr.r)rCrDr|rrangelenrrWRaggedTensorSpec TensorSpecrkeras_tensor_from_type_specr6rHsparse_placeholdernest map_structurer"rP keras.enginer'Input_is_backend_placeholder) rindimr'rrjraggedrr ir2 type_specr$r'rrrr"Jsf#     4   r"cCs~zdtjjrt|dWSddlm}||rTtjj |dd}t dd|DWS|j j dkWSWnt yxYd S0d S) zxReturns whether `x` is a placeholder. Args: x: A candidate placeholder. Returns: Boolean. r2rtf_utilsTr%css|]}t|VqdSr)rb)rcrrr rz!is_placeholder.. PlaceholderFN)r)rCrDr|r keras.utilsr8is_extension_typer.flattenpy_anyrrAttributeError)r2r8flat_componentsrrrrbs      rbzkeras.backend.shapecCs t|S)a0Returns 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) )r)rir1rrrrisrizkeras.backend.int_shapecCs<z"|j}t|tst|}|WSty6YdS0dS)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)rir(ras_listrsr2rirrrrs   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 )rirankr1rrrr3sr3zkeras.backend.dtypecCs |jjjS)a{Returns 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' )r' base_dtyperjr1rrrr'sr'cCst|jjS)zReturns the numpy dtype of a Keras tensor or variable. Args: x: Tensor or variable. Returns: numpy.dtype, dtype of `x`. )r)rr'as_numpy_dtyper1rrr dtype_numpy?s rGzkeras.backend.evalcCs tt|S)a^Evaluates 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_valuerr1rrrevalLsrIzkeras.backend.zeroscCstf|durt}t|}tj|||d}t|jr\t|||dWdS|WdS1st0YdS)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) Nr!r'rj) r)r\r.rzerospy_allrirBrrir'rjtf_dtyperrrrrKcs#  rKzkeras.backend.onescCstf|durt}t|}tj|||d}t|jr\t|||dWdS|WdS1st0YdS)aInstantiates 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) Nr!rJ) r)r\r.ronesrLrirBrrMrrrrOs  rOzkeras.backend.eyecCs.|durt}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) Nr&)r.r)rreye)sizer'rjrNrrrrPs rPzkeras.backend.zeros_likecCstj|||dS)aKInstantiates 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 kvar = tf.keras.backend.variable(np.random.random((2,3))) kvar_zeros = tf.keras.backend.zeros_like(kvar) K.eval(kvar_zeros) # array([[ 0., 0., 0.], [ 0., 0., 0.]], dtype=float32) ``` rJr) zeros_liker2r'rjrrrrSsrSzkeras.backend.ones_likecCstj|||dS)aUInstantiates 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) rJ)r) ones_likerTrrrrUsrUcCstj||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. rr)identity)r2rjrrrrWs rWz9keras.backend.experimental.is_tf_random_generator_enabledcCstS)aCheck whether `tf.random.Generator` is used for RNG in Keras. Compared to existing TF stateful random ops, `tf.random.Generator` uses `tf.Variable` and stateless random ops to generate random numbers, which leads to better reproducibility in distributed training. Note enabling it might introduce some breakage to existing code, by producing differently-seeded random number sequences and breaking tests that rely on specific random numbers being generated. To disable the usage of `tf.random.Generator`, please use `tf.keras.backend.experimental.disable_random_generator`. We expect the `tf.random.Generator` code path to become the default, and will remove the legacy stateful random ops such as `tf.random.uniform` in the future (see the [TF RNG guide]( https://www.tensorflow.org/guide/random_numbers)). This API will also be removed in a future release as well, together with `tf.keras.backend.experimental.enable_tf_random_generator()` and `tf.keras.backend.experimental.disable_tf_random_generator()` Returns: boolean: whether `tf.random.Generator` is used for random number generation in Keras. _USE_GENERATOR_FOR_RNGrrrris_tf_random_generator_enabled&srZz5keras.backend.experimental.enable_tf_random_generatorcCsdadS)zEnable the `tf.random.Generator` as the RNG for Keras. See `tf.keras.backend.experimental.is_tf_random_generator_enabled` for more details. TNrXrrrrenable_tf_random_generatorFs r[z6keras.backend.experimental.disable_tf_random_generatorcCsdadS)zDisable the `tf.random.Generator` as the RNG for Keras. See `tf.keras.backend.experimental.is_tf_random_generator_enabled` for more details. FNrXrrrrdisable_tf_random_generatorRsr\c@sveZdZdZdZdZdZdddZdd Zd d Z d d Z ddZ ddZ dddZ dddZdddZd ddZdS)!RandomGeneratora1Random generator that selects appropriate random ops. This class contains the logic for legacy stateful random ops, as well as the new stateless random ops with seeds and tf.random.Generator. Any class that relies on RNG (eg initializer, shuffle, dropout) should use this class to handle the transition from legacy RNGs to new RNGs. Args: seed: Optional int seed. When `rng_type` is "stateful", the seed is used to create `tf.random.Generator` to produce deterministic sequences. When `rng_type` is "stateless", new seed will be created if it is not provided by user, and it will be passed down to stateless random ops. When `rng_type` is "legacy_stateful", the seed will be passed down to stateful random ops. rng_type: Type of RNG to use, one of "stateful", "stateless", "legacy_stateful". It defaults to "stateful" if `enable_tf_random_generator` has been activated, or to "legacy_stateful" otherwise. - When using "stateless", the random ops outputs are constant (the same inputs result in the same outputs). - When using "stateful" or "legacy_stateful", the random ops outputs are non-constant, but deterministic: calling the same random op multiple times with the same inputs results in a deterministic sequence of different outputs. - "legacy_stateful" is backed by TF1 stateful RNG ops (e.g. `tf.random.uniform`), while "stateful" is backed by TF2 APIs (e.g. `tf.random.Generator.uniform`). statelessstatefulZlegacy_statefulNcKs"||_|j|fi|d|_dSr!)_seed _set_rng_type_built)rseedrng_typekwargsrrrrszRandomGenerator.__init__cKs`|ddr|j}|dur4tr*|j|_q\|j|_n(||j|j|jfvrVtd|||_dS)NZforce_generatorFzeInvalid `rng_type` received. Valid `rng_type` are ["stateless", "stateful", "legacy_stateful"]. Got: )rf RNG_STATEFULrZ _rng_typeRNG_LEGACY_STATEFUL RNG_STATELESSrs)rrdrerrrras"   zRandomGenerator._set_rng_typecCs|jr dS|j|jkr*tjjs*|j|_|j|jkrL| |j |_ d|_ nf|j|jkrddl m }||,| |j }tjj||_ Wdq1s0Ynd|_ d|_dS)aLazily init the RandomGenerator. The TF API executing_eagerly_outside_functions() has some side effect, and couldn't be used before API like tf.enable_eager_execution(). Some of the client side code was creating the initializer at the code load time, which triggers the creation of RandomGenerator. Lazy init this class to walkaround this issue until it is resolved on TF side. Nrr7T)rbrgrfr)rCrDr|rhri _create_seedr` _generatorr<r8maybe_init_scoperandom Generator from_seed)rr8rcrrr _maybe_inits"        0zRandomGenerator._maybe_initcCsD||j|jkr|jdgS|j|jkr@|jdddfSdS)aTGenerate a new seed based on the init config. Note that this will not return python ints which will be frozen in the graph and cause stateless op to return the same value. It will only return value when generator is used, otherwise it will return None. Returns: A tensor with shape [2,]. rN)rprgrir`rfrk make_seedsrrrrmake_seed_for_stateless_ops    z*RandomGenerator.make_seed_for_stateless_opcCs&|jdur"|j}|jd7_|SdS)aCreate a new seed for the legacy stateful ops to use. When user didn't provide any original seed, this method will return None. Otherwise it will increment the counter and return as the new seed. Note that it is important to generate different seed for stateful ops in the `tf.function`. The random ops will return same value when same seed is provided in the `tf.function`. Returns: int as new seed, or None. Nr5)r`)rresultrrrmake_legacy_seeds  z RandomGenerator.make_legacy_seedcCs6|dur |Sttddr&tjddStddSdS)N generatorr5eA)rZ_SEED_GENERATORrurandintrm)rZuser_specified_seedrrrrjs  zRandomGenerator._create_seed?cCs||pt}|j|jkr2|jj||||dS|j|jkrp|}|rZtj j ||}tj j |||||dStj j||||| dS)aProduce random number based on the normal distribution. Args: shape: The shape of the random values to generate. mean: Floats, default to 0. Mean of the random values to generate. stddev: Floats, default to 1. Standard deviation of the random values to generate. dtype: Optional dtype of the tensor. Only floating point types are supported. If not specified, `tf.keras.backend.floatx()` is used, which default to `float32` unless you configured it otherwise (via `tf.keras.backend.set_floatx(float_dtype)`) nonce: Optional integer scalar, that will be folded into the seed in the stateless mode. rimeanstddevr'rir|r}r'rc)rpr.rgrfrknormalrirrr)rm experimentalstateless_fold_instateless_normalrtrrir|r}r'noncercrrr random_normals(    zRandomGenerator.random_normalcCs||pt}|j|jkr2|jj||||dS|j|jkrp|}|rZtj j ||}tj j |||||dStj j||||| dS)aProduce random number based on the uniform distribution. Args: shape: The shape of the random values to generate. minval: Floats, default to 0. Lower bound of the range of random values to generate (inclusive). minval: Floats, default to None. Upper bound of the range of random values to generate (exclusive). dtype: Optional dtype of the tensor. Only floating point types are supported. If not specified, `tf.keras.backend.floatx()` is used, which default to `float32` unless you configured it otherwise (via `tf.keras.backend.set_floatx(float_dtype)`) nonce: Optional integer scalar, that will be folded into the seed in the stateless mode. )riminvalmaxvalr'rirrr'rc)rpr.rgrfrkuniformrirrr)rmrrstateless_uniformrt)rrirrr'rrcrrrrandom_uniforms0   zRandomGenerator.random_uniformcCs||pt}|j|jkr2|jj||||dS|j|jkrp|}|rZtj j ||}tj j |||||dStj j||||| dS)aProduce random number based on the truncated normal distribution. Args: shape: The shape of the random values to generate. mean: Floats, default to 0. Mean of the random values to generate. stddev: Floats, default to 1. Standard deviation of the random values to generate. dtype: Optional dtype of the tensor. Only floating point types are supported. If not specified, `tf.keras.backend.floatx()` is used, which default to `float32` unless you configured it otherwise (via `tf.keras.backend.set_floatx(float_dtype)`) nonce: Optional integer scalar, that will be folded into the seed in the stateless mode. r{r~)rpr.rgrfrktruncated_normalrirrr)rmrrstateless_truncated_normalrtrrrrrCs(    z RandomGenerator.truncated_normalcCsL||j|j|jfvr4tjjj||||dStjj |||| dS)Nrate noise_shaperc) rprgrfrir)nnrstateless_dropoutrrdropoutrt)rinputsrrrrrriszRandomGenerator.dropout)NN)ryrzNN)ryNNN)ryrzNN)N)rrrrrirfrhrrarprrrtrjrrrrrrrrr]]s" ( ' , &r]z%keras.backend.random_uniform_variablecCsT|durt}t|}|dur,tjd}tjjj||||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 Nrvr'rcrJ) r.r)rr/rmrxrCrDrandom_uniform_initializerr)rilowhighr'rjrcrNrWrrrrandom_uniform_variablezs  rz$keras.backend.random_normal_variablecCsT|durt}t|}|dur,tjd}tjjj||||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 NrvrrJ) r.r)rr/rmrxrCrDrandom_normal_initializerr)rir|scaler'rjrcrNrWrrrrandom_normal_variables  rzkeras.backend.count_paramscCst|jS)aReturns 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) )r/prodrirBr1rrr 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)r-rrrrr-sr-zkeras.backend.updatecCstjj||Sr)r)rCrDassign)r2new_xrrrrsrzkeras.backend.update_addcCstjj||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)rCrD assign_add)r2 incrementrrr update_add s rzkeras.backend.update_subcCstjj||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)rCrD assign_sub)r2 decrementrrr update_sub s rz#keras.backend.moving_average_updatecCsXtjjr>t||j}t||j}|||d|Stjjj|||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. r5T) zero_debiasN) r)rrrr-r'rtrainassign_moving_average)r2rWmomentumrrrmoving_average_update! s' rzkeras.backend.dotc Csxt|durNt|dks(t|dkrNg}tt|tt|D]&\}}|durb||qF||qFt|}g}tt|tt|D]&\}}|dur||q||qt|}tt t|}| dg|}t |d|dg}t tj j j||d|ddg}t t|||dd|dd|ddSt|rhtj||} n t||} | S)aMultiplies 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) Nrtperm)r3rrr)unstackrirrlistr(rNreshaperCrD transposematmulrrsparse_dense_matmul) r2yx_shaper5sy_shape y_permute_dimxtytoutrrrdotU s4'("  "  ,  rzkeras.backend.batch_dotcCst|}t|}t|}t|}|dks0|dkrPtdt|dt|d|d}|d}|dur|dur||krtdt|dt|dt|tr||g}|dur|dkr|d|dg}n|d|dg}td d |Drtd t|t|}|ddkr$|d|7<|ddkrB|d|7<d|vrTtd |\} } || } || } | dur| dur| | krtd t|dt|dt|d|d|d| | f|} |}|dkrt |d}| d7} |d7}|dkrt |d}|d7}| |dkrntt |}t | |dD]}||d||<q>| |d<tj j ||}| dkrtt |}t | ddD]}||d||<q| |d<tj j ||}|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)aBatchwise 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)` rtzICannot 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 r5css|]}t|ttfVqdSr)r(rr)rarrrr: rzbatch_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).rTF)rr)rsrr(r:r?rr)rr(rCrDrristackrrconcatsqueeze)r2raxesrrx_ndimy_ndim x_batch_size y_batch_sizea0a1d1d2 orig_x_ndim orig_y_ndimpatternr5 x_mid_dimsx_squashed_shape x_squashed y_trail_dimsy_squashed_shape y_squashedrs output_shape do_reshaperrr batch_dot s/                       rzkeras.backend.transposecCstjj|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 r)rCrDrr1rrrri srzkeras.backend.gathercCstjj||S)asRetrieves 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) )r)rCrDgather) referencerrrrr srzkeras.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_maxr2axiskeepdimsrrrmax srzkeras.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) reduce_minrrrrmin srzkeras.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_sumrrrrsum srzkeras.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) reduce_prodrrrrr srzkeras.backend.cumsumcCstj||dS)aCumulative 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)cumsumr2rrrrr s rzkeras.backend.cumprodcCstjj||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)mathcumprodrrrrr s rzkeras.backend.varcCs.|jjtjkrt|t}tjj|||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`. rr)r'rEr)rr-r.rreduce_variancerrrrvar srzkeras.backend.stdcCs.|jjtjkrt|t}tjj|||dS)a7Standard 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'rEr)rr-r.r reduce_stdrrrrstd4 srzkeras.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`. )r'rEr)rr-r. reduce_meanrrrrr|P sr|zkeras.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)r-r reduce_anyrrrranyf srzkeras.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)r-r reduce_allrrrrallx srzkeras.backend.argmaxrcCs 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)argmaxrrrrr s rzkeras.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)argminrrrrr s rzkeras.backend.squarecCs t|S)zcElement-wise square. Args: x: Tensor or variable. Returns: A tensor. )r)squarer1rrrr s rzkeras.backend.abscCs t|S)zkElement-wise absolute value. Args: x: Tensor or variable. Returns: A tensor. )r)absr1rrrr s rzkeras.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. ry)rr'rEr)maximumsqrt)r2zerorrrr s rzkeras.backend.expcCs t|S)zhElement-wise exponential. Args: x: Tensor or variable. Returns: A tensor. )r)expr1rrrr s rzkeras.backend.logcCs tj|S)z`Element-wise log. Args: x: Tensor or variable. Returns: A tensor. )r)rlogr1rrrr s rcCst|||S)aComputes 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)reduce_logsumexprrrr logsumexp srzkeras.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)roundr1rrrr srzkeras.backend.signcCs t|S)zaElement-wise sign. Args: x: Tensor or variable. Returns: A tensor. )r)signr1rrrr s rzkeras.backend.powcCs t||S)zElement-wise exponentiation. Args: x: Tensor or variable. a: Python integer. Returns: A tensor. )r)pow)r2rrrrr/ s rzkeras.backend.clipcCsTt|ttfr(t|ttfr(||kr(|}|dur8tj }|durFtj}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)r(r:floatr/infr) clip_by_value)r2 min_value max_valuerrrclip? sr zkeras.backend.equalcCs t||S)zElement-wise equality between two tensors. Args: x: Tensor or variable. y: Tensor or variable. Returns: A bool tensor. )r)equalr2rrrrr Y 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_equalr rrrr i 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)greaterr rrrry s rzkeras.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_equalr rrrr s rzkeras.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)lessr rrrr s rzkeras.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_equalr rrrr s rzkeras.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)rr rrrr srzkeras.backend.minimumcCs t||S)zElement-wise minimum of two tensors. Args: x: Tensor or variable. y: Tensor or variable. Returns: A tensor. )r)minimumr rrrr s rzkeras.backend.sincCs t|S)znComputes sin of x element-wise. Args: x: Tensor or variable. Returns: A tensor. )r)sinr1rrrr s rzkeras.backend.coscCs t|S)znComputes cos of x element-wise. Args: x: Tensor or variable. Returns: A tensor. )r)cosr1rrrr s rMbP?cCs<tjjj||ddd\}}tj||||||}|||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)rCrDrmomentsbatch_normalization)r2gammabetareduction_axesepsilonr|rnormedrrr$_regular_normalize_batch_in_training srcCstjjj||ddd\}}g}tt|D],}||vrD|dq,|t||q,t |}t ||} t ||} |durd} n t ||} |durd} n t ||} tj || | | | |} | ||fS)aNon-fused, broadcast 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)`. NFr5) r)rCrDrrr(r3rrirrr)r2rrrrr|r target_shaperbroadcast_mean broadcast_varbroadcast_gammabroadcast_betarrrr&_broadcast_normalize_batch_in_training s0      r$cCst|gdkrd}d}nd}d}|durDtjd|j|j|gd}|durftjd |j|j|gd}tjjjj|||||d S) aFused 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)`. rr5rtrNHWCr5NCHWNrz)r'riry)r data_format) rr)rr'rirCrDrfused_batch_norm)r2rrrrnormalization_axistf_data_formatrrr"_fused_normalize_batch_in_trainingE s   r,z)keras.backend.normalize_batch_in_trainingcCst|dkr^t|gdgdfvr^tsLt|gdkrLt|||||dSt|||||dSt|ttt|ddkrt|||||dSt|||||dSdS)aComputes mean and std for batch then apply batch_normalization on batch. 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)`. r%)rrtr)rNr)r3rrr$r,sortedr(r)r2rrrrrrrnormalize_batch_in_trainingj s$     r/z!keras.backend.batch_normalizationc Cs t|dkr |dks|dkr$d}n|dks4|dkr:d}nd}|dksT|dkrtrt|dkrnt|dg}t|dkrt|dg}|durt|}nt|dkrt|dg}|durt|}nt|dkrt|dg}tjjjj |||||||d d \}} } |Stj ||||||S) aApplies batch normalization on x given mean, var, beta and gamma. I.e. returns: `output = (x - mean) / (sqrt(var) + epsilon) * gamma + beta` Args: x: Input tensor or variable. mean: Mean of batch. var: Variance of batch. beta: Tensor with which to center the input. gamma: Tensor by which to scale the input. axis: Integer, the axis that should be normalized. (typically the features axis). epsilon: Fuzz factor. Returns: A tensor. r-r5r'rrr&NF)rr|variancer( is_training) r3rr)rrSrUrCrDrr)r) r2r|rrrrrr+rrrrrr sH        rzkeras.backend.concatenatecCs|dkr&t|d}|r"||;}nd}tdd|DrHtjj||Stdd|Drft||Stdd|D|SdS)aPConcatenates 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|VqdSr)rrrrrr: rzconcatenate..css|]}t|tjVqdSrr(r)rrrrrr: rcSsg|] }t|qSr)rrrrrr rzconcatenate..N)r3rLr)rCrD sparse_concatr)tensorsrrDrrrr s   rzkeras.backend.reshapecCs t||S)avReshapes 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)) r)rrCrrrr srz keras.backend.permute_dimensionscCstjjj||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)) rr)r2rrrrpermute_dimensionssr7zkeras.backend.resize_imagesnearestc CsX|dkrd\}}n |dkr$d\}}ntd|f|j||d}|r`tj|dd}nt|||d}|ttj||gdd9}|dkrt|gd }tj j j tj j j tj j j tj j jtj j jtj j jtj j jtj j jd }d d |d } ||vr&tj j||||d }ntd| d|d|dkrTt|gd}|S)a0Resizes 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 `"area"`, `"bicubic"`, `"bilinear"`, `"gaussian"`, `"lanczos3"`, `"lanczos5"`, `"mitchellcubic"`, `"nearest"`. Returns: A tensor. Raises: ValueError: in case of incorrect value for `data_format` or `interpolation`. channels_first)rtr channels_last)r5rtz"Invalid `data_format` argument: %sr5int32r&rrtrr5)areabicubicbilineargaussianlanczos3lanczos5 mitchellcubicr8"z", ")methodz+`interpolation` argument should be one of: z . Received: "z".rrr5rt)rsriis_fully_definedr)rrBr/arrayr7image ResizeMethodAREABICUBICBILINEARGAUSSIANLANCZOS3LANCZOS5 MITCHELLCUBICNEAREST_NEIGHBORjoinkeysresize) r2 height_factor width_factorr( interpolationrowscols new_shapeZinterpolationsZinterploations_listrrr resize_images7sH     r\zkeras.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`. r9rtrrr-r:r5zInvalid data_format: N)repeat_elementsrsr)r2 depth_factorrVrWr(outputrrrresize_volumesysr`zkeras.backend.repeat_elementscs|j}||durFtj||||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)rWnum_or_size_splitsrcsg|]}tD]}|qqSrr()rrrreprrrrz#repeat_elements..r5rr;r&)rirBr)splitrrr/rOr)tiledeleterr set_shaperr)r2rdrrsplitsx_repauxiliary_axisrepsrrcrr]s(          r]zkeras.backend.repeatcCs8t|dksJt|d}td|dg}t||S)aRepeats 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) rtr5)r3r)rrrf)r2rrrrrrepeats rmzkeras.backend.aranger5r;cCs<|dur|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)limitdeltarjr;)r)r(r-)startstopstepr'rsrrrrns  rnzkeras.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. )r(r:r)rf)r2rrrrrf%s rfzkeras.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) rr6r1rrrr>8sr>zkeras.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) rr5N)r)rrrrir1rrr batch_flattenSs&rtzkeras.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. )r)rrrrrrns 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. )r)rrrrrr~s rzkeras.backend.temporal_paddingr5r5cCs>t|dksJddg|d|dgddgg}tjj||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. rtrr5)r)r)rCrDpad)r2paddingrrrrtemporal_paddingsrxz keras.backend.spatial_2d_paddingrurucCst|dksJt|ddks$Jt|ddks8J|durFt}|dvr^tdt||dkrddgddgt|dt|dg}n$ddgt|dt|dddgg}tjj||S)alPads 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`. rtrr5N>r9r:Unknown data_format: r9) r)image_data_formatrsrrr)rCrDrvr2rwr(rrrrspatial_2d_paddings&$r}z keras.backend.spatial_3d_paddingrururucCs0t|dksJt|ddks$Jt|ddks8Jt|ddksLJ|durZt}|dvrrtdt||dkrddgddg|dd|ddg|dd|ddg|dd|ddgg}nRddg|dd|ddg|dd|ddg|dd|ddgddgg}tjj||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`. rrrtr5N>r9r:rzr9)r)r{rsrr)rCrDrvr|rrrspatial_3d_paddings, 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)r)rrrrrrsrzkeras.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)r)one_hot)r num_classesrrrrsrzkeras.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. )r(r:r)reverse)r2rrrrr*s 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.0rzkeras.backend.get_valuecCst|s|Sts$t|tjjr,|St|ddsltjj |WdS1sb0Ytj j rt |WdS1s0Y|j"|jt|fdWdS1s0YdS)aWReturns 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. _in_graph_modeTNr)r) is_tensorrPr(r EagerTensornumpyrZ eager_context eager_moderCrDr|r\r<rHrIrr1rrrrH\s  &  & rHzkeras.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|] }|qSr)rrrrrrrz#batch_get_value..z2Cannot get value inside Tensorflow graph function.N)r)rPrrrr)r5rrrbatch_get_valuesrzkeras.backend.set_valuecCstj|t|d}tjjr*||nt t |j j dd}t|drf|j}|j}n:tdg|j}tjjj||d}||}||_||_tj|||idWdn1s0YdS)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). r&rr_assign_placeholderNri feed_dict)r/r0rGr)rCrDr|rr6rHrr'rjrerr _assign_op TensorShaper3r"rr)r2rWrNassign_placeholder assign_opplaceholder_shaperrr set_values      rzkeras.backend.batch_set_valuec Cs tstr8|D] \}}|tj|t|dqnt|rg}i}|D]\}}tj|t|d}t |j j dd}t |dr|j}|j}n:tdg|j}tjjj||d}||}||_||_|||||<qTtj||dWdn1s0YdS)zSets the values of many tensor variables at once. Args: tuples: a list of tuples `(tensor, value)`. `value` should be a Numpy array. r&rrrNrr)r)rPrrr/r0rGr6rHrr'rjrerrrrr3rCrDr"rrr) tuplesr2rW assign_opsrrNrrrrrrbatch_set_values.        r)snippetzkeras.backend.print_tensorc Cst|tjrt|drthtj||tj|d}t |g(t |WdWdS1sp0YWdq1s0Yntj||tj|d|SdS)aPrints `message` and the tensor value when evaluated. Note that `print_tensor` returns a new tensor identical to `x` which should be used in the following code. Otherwise the print operation is not taken into account during evaluation. Example: >>> x = tf.constant([[1.0, 2.0], [3.0, 4.0]]) >>> tf.keras.backend.print_tensor(x) 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. r<) output_stream summarizeN) r(r)r*rr6rHprintsysstdoutcontrol_dependenciesrW)r2messagerrrrr print_tensors  Vrc@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 Ks|pg}t|ttfstd||_tjj|dd|_||_ t tjj|dd|_ t |j dg^g}|D]8}t|tr|\}} | tjj|| qn| |qntj||_Wdn1s0Y||_|dd|_|dg|_t|jts |jg|_|dd|_|dd|_d d |jD|_||_i|_|r^td |fd|_d|_d|_d|_ d|_!d|_"dS) Nz@`updates` in a Keras backend function should be a list or tuple.Tr%rrfetchesoptions run_metadatacSsg|]}t|qSrrVrrrrrYrz3GraphExecutionFunction.__init__..z>Some keys in session_kwargs are not supported at this time: %s)#r(rrr_inputs_structurer)r.r>r_outputs_structurecast_variables_to_tensoroutputsrrrCrDrgroup updates_oprjrNrr run_optionsrsession_kwargsfetch_callbacksrsrT _callable_fn _feed_arrays _feed_symbols _symbol_vals_fetches_session) rrrupdatesrjr updates_opsrpnew_prrrr0sR  * zGraphExecutionFunction.__init__c Cs"t}|D]}|j|jq |jrHt|jD]}|j|jq4t||D]R\}}|j } |j |j krt j ||j d}t|} | dur|} | j| _|j| _qR|j|jD]}|j|jq|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. r&N) r CallableOptionsfeedrrjrr.rTrtensor_connectionrr'r)r-r from_tensor to_tensorrrfetchtargetrrCopyFrom_make_callable_from_optionsrrrrrrr) r feed_arrays feed_symbols symbol_valsr callable_optsr2r"r connectionr callable_fnrrr_make_callablens6     z%GraphExecutionFunction._make_callablecCs2t|j|D] \}}||jvr |j||q dSr)rrr)rfetches_outputrr_rrr_call_fetch_callbackss z,GraphExecutionFunction._call_fetch_callbackscCs*ddlm}||r"|j|S|SdS)z@Helper method which evaluates any CompositeTensors passed to it.rr7N)r<r8r=rr)rrr8rrr_eval_if_composites   z)GraphExecutionFunction._eval_if_compositec Cstjj|dd}t|}g}g}g}g}t|j|D]^\}}|durFq4t|rf||||q4||t|j } |t j || j dq4|j rt|j D]"} |t j |j | | j j dq|jdus||jks||jks||jks|j|jks||jkr&||||||j|d|ji} || t|j dtjj|j| dt|jdd} tj|j| S)NTr%r&r) r)r.r>rrrrrrr'r/r0rFrr.rTrrrrrrrrrrr)pack_sequence_asrrr/r) rrrr array_valsrrrrW tensor_typer"fetchedoutput_structurerrr__call__sZ       zGraphExecutionFunction.__call__)NN) rrrrrrrrrrrrrrs >2rzkeras.backend.functionc  stjjr|rtd|f|r0td|fddlm}ddlm|j ||dt |t ojt |dkfdd }|S|r|D]6}|t tjjjjdvr|d vrd |}t|qt||f||d |S) aInstantiates 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)modelsr7)rrr5cs|}r|g}|Sr)sync_to_numpy_or_python_type) model_inputsoutsmodelr8 wrap_outputsrrfuncszfunction..func)rrrrjzBInvalid argument "%s" passed to K.function with TensorFlow backend)rrj)r)rCrDr|rskerasrr<r8Modelr(rr)rgetfullargspecrrr) rrrrjrerrr"msgrrrfunctionsJ    rzkeras.backend.gradientscCstjjj||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)colocate_gradients_with_ops)r)rCrD gradients)lossr rrrr,s rzkeras.backend.stop_gradientcCs$t|ttfrttj|St|S)agReturns `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. )r(rrmapr) stop_gradient)r rrrr=s rzkeras.backend.rnnc * stjjsddd} |s*tj|  tj } | djd| djdt| dd| D]} | jdqh|dur|j tj krt |tj }t |jdkrt |}|s| |}durgd4d d |rstd t}g}g}fd d }tj r tj| n | f fdd}|durt|}rZ|tD]}||}|| |t|t\}} |}|st|}n|d}t|||}tj|}tj|}t fdd|D}tddt|||D}tj||}r4||||n |g}|g}qb|d}|d}t|}rt|d||t|}t||dd|t|}nttD]P}||}|t|t\}}r||||n |g}|g}q|d}|d}t|}nt}tfddt| Dtfddt| Dtj dd| D}|tt\} }!rnd t fddttj| D}"tjdddd}#tsttjj !rdur}$n t"}$nd}$fdd|$ddd }%|durjr4t|d}tj#tj d!d" | fd#d$ fd%d&nZt$tj%rrtj"dd'}&t&|&dfd(d$ n fd)d$ d*d&nd dur6td+dtj| D f d,d-}'tjj j'f|'|#|"f|d.|%}(|(dd}nD fd/d-}'tjj j'f|'|#|"f|d.|%}(|(dd}|(d}"td0d|"D}td1d|D}tj| |}tj| |}fd2d3})tj|)|}|stj| |}|||fS)5a8Iterates 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. return_all_outputs: Boolean. If True, return the recurrent outputs for all timesteps in the sequence. If False, only return the output for the last timestep (which consumes less memory). Returns: A tuple, `(last_output, outputs, new_states)`. last_output: the latest output of the rnn, of shape `(samples, ...)` outputs: - If `return_all_outputs=True`: a tensor with shape `(samples, time, ...)` where each entry `outputs[s, t]` is the output of the step function at time `t` for sample `s` - Else, a tensor equal to `last_output` with shape `(samples, 1, ...)` 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). TcSs2ttt|j}d\|d<|d<tjj||S)N)r5rrr5)rr(r)rir)rCrDr)input_trrrrswap_batch_timestepsz rnn..swap_batch_timesteprr5rNrtcSstj|rtd|tj|r0td|t|jt|j}t|D]}t|d}qLdg||j|d}t ||S)Nz+mask_t is expected to be tensor, but got %sz,input_t is expected to be tensor, but got %srr5) r)r. is_nestedrsr)rir(rrBrf)mask_tr fixed_dim rank_diffr multiplesrrr _expand_masks   zrnn.._expand_maskz/Unrolling requires a fixed number of timesteps.cst|}r||Sr)r)rr)r go_backwardsrr_process_single_input_ts z$rnn.._process_single_input_tcs fddD}tj|S)Ncsg|] }|qSrr)rt_timerrrrz2rnn.._get_input_tensor..)r)r.r)rinp)rprocessed_inputrr_get_input_tensorszrnn.._get_input_tensorrc3s|]}|VqdSrr)rrrrrrr: szrnn..css"|]\}}}t|||VqdSrr)where)rmrpsrrrr:src3s(|] \}}tj|jd|dVqdS)z input_ta_%sr'rQtensor_array_nameN)r) TensorArrayr')rr5r time_steps_trrr:Cs c3s0|](\}}s||n|t|dVqdS)rN)rr)rtainput_rrrr:Ks cSsg|] }|dqS)rr)rrrrrrVrzrnn..c3s,|]$\}}tj|j|jd|dVqdS)z output_ta_%s)r'rQ element_shaperN)r)rr'ri)rr5r)output_ta_sizerrr:_sr;rrJcs|kSrr)rrrrr{rzrnn.. )condmaximum_iterationsparallel_iterations swap_memorymask_tarcs |Srreadr)r rr masking_fnszrnn..masking_fncs2tfdd|D}tddt|||DS)Nc3s"|]}|tjdVqdS)rN)r)rirorrrr:s5rnn..compute_masked_output..css"|]\}}}t|||VqdSrr)rrrfmrrrr:srr)rflat_out flat_mask tiled_mask_t)rrrcompute_masked_outputs  z"rnn..compute_masked_outputrcs t|Srrr)rev_input_lengthrrr scs t|Srr r) input_lengthrrr scstfddt||DS)Nc3s$|]\}}tjj||VqdSr)r)rCrDr)rrzorrrr:srr)rrrrrrrs css|]}t|VqdSrrRr rrrr:scstfddD}tj|}} |t|t\}}tj|} rZn tj|} ||| } tj|} tj|} t| | D] \} }t|tjr|| j q|| | }tj||}r؈ndtfddt|| D}d|t| ft|S)asRNN 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|]}|VqdSrr rrrrrr:r%rnn.._step..rc3s|]\}}||VqdSrwriterrrta_index_to_writerrr:sr5 rr)r.rr>rr(r*rhri)r output_ta_t prev_outputstates current_inputrr_ new_states flat_outputflat_mask_outputflat_new_output flat_stateflat_new_statestate new_stateflat_final_state) r constantsflat_zero_outputinput_tarr return_all_outputs step_functionzero_output_for_maskr rr_steps@        zrnn.._step)body loop_varsc stfddD}tj|}|t|t\}}tj|}tj|}t||D] \}} t| tjr`| |j q`tj|} rndtfddt|| D}tj|}d|ft|S)a)RNN 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|]}|VqdSrr rrrrr:rrrc3s|]\}}||VqdSrrrrrrr: sr5r!) rr"r$r%r_r&r*r+r,r-r')r/initial_statesr1rr2r3r5rr6s&       css|]}|VqdSr)rr rrrr:rcss|]}|dVqdS)rNrr rrrr:rcsBt|tjr>|j}r$|d<nd|d<|d<|||S)Nrr5)r(r)r*rirBrh)output_ri)batchr2 time_stepsrrrh#s    zrnn..set_shape)r5)(r)rrrr.r/r>riwith_rank_at_leastr'rr-r)rrsrrrrr(rSrrrrrrrrPrGraphOrParentsInXlaContextrCrDrYrrr(r*subtract while_loop)*r3rr9rmaskr/unrollr time_majorr4r2rflatted_inputsrr$successive_statessuccessive_outputsrr mask_listr5rr_r&rr# flat_statesflat_new_statesflat_final_states last_outputrinput_time_zerooutput_time_zeror output_tarmax_iterationswhile_loop_kwargsmax_lenr6 final_outputsrhr)rr;rr/r0rr9rr1rrr r rrr2rr3r<rr4rrnnTsXQ                                         5  "    rSzkeras.backend.switchc s8|jtjkrt|d}t|}|slts:fdd}n}tsTfdd}n}tjj|||}ntrztrt}||krt dt |dt ||dkr&||}tj 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. rcsSrrr)then_expressionrrthen_expression_fnPsz"switch..then_expression_fncsSrrr)else_expressionrrelse_expression_fnWsz"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)=r5rr)r'r)rr-r3rrCrDrrsrrrirrrUrf) conditionrTrV cond_ndimrUrWr2 expr_ndim ndim_diff cond_shape expr_shape shape_diff tile_shaper)rVrTrswitch6sP      r`zkeras.backend.in_train_phasecCsddlm}|dur|j}|dur,t}t|s||dksF|durZt|rT|S|Sn"|dksj|dur|t|rx|S|St|||}|S)aFSelects `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_utilsNr5TF) r0ra call_contexttrainingr_r)rrr`)r2altrcrarrrin_train_phases     rezkeras.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`. )rc)re)r2rdrcrrr in_test_phasesrfzkeras.backend.relurycCst|dt}|dkr`|dur6|dkr6tjj||dS|dkrRtj| |}ntj| }|du}|dkr|tjt|||d}n&|dkrtj|}d}n tj|}|rt ||j j }t d|j j }t |||}|dkrt ||j j }|||8}|S) a Rectified 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. r'ryNr)alphar&F)rZr.r)r leaky_relurelur-rrelu6rr'rErr)r2rgr thresholdr' negative_partclip_maxrrrrrjs,    rjzkeras.backend.elurzcCs2tj|}|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. r5rN)r)relur)r2rgresrrrros rozkeras.backend.softmaxcCstjj||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)rsoftmaxrrrrrqsrqzkeras.backend.softpluscCs tj|S)zfSoftplus of a tensor. Args: x: A tensor or variable. Returns: A tensor. )r)rsoftplusr1rrrrr(s rrzkeras.backend.softsigncCs tj|S)zfSoftsign of a tensor. Args: x: A tensor or variable. Returns: A tensor. )r)rsoftsignr1rrrrs7s rscCs|}|}t|d}|r |j}d}t|tjjtjf oF|jj|koF| }|rpt |jj dks`J|jj d}d}|r|s||rt j d|d|ddd ||fS) N _keras_logitsTr5rz"`zK` received `from_logits=True`, but the `output` argument was produced by a zB activation and thus does not represent logits. Was this intended?rtru) rrtr(r)rrr+rrr)rrmrn)r_ from_logitsop_typefn_namer:Z from_logits_Zhas_keras_logitsZfrom_expected_op_typerrr _get_logitsFs.    rxz&keras.backend.categorical_crossentropycCst|}t|}|j|jt||dd\}}|rJtjj|||dS|t||d}tt |j j }t ||d|}t|tj || S)aCategorical 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.] Softmaxcategorical_crossentropy)labelslogitsrTrz)r)rriassert_is_compatible_withrxr!softmax_cross_entropy_with_logitsrrrr'rErrr)rr_rurepsilon_rrrrzis.  rzz-keras.backend.sparse_categorical_crossentropycCsDt|}t|}t|d}t||dd\}}|sbtt|jj}t||d|}tj |}t |j t tfr~t|j }n|j j}|dur||;}||dkrttt|t|d||g}tjjj||d}n|dkrtd|t |}|j j} | duo|duo| |dk} | rBt|}t|d|dg}|durpt|t||j} || }|| }td d ||fDrt tjj ||d } Wdn1s0Yntjj ||d } |durt|ddd} t| | } t!t"| | | } | | _#| S| r@|d kr@t| |dd} | S) 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`. ignore_class: Optional integer. The ID of a class to be ignored during loss computation. This is useful, for example, in segmentation problems featuring a "void" class (commonly -1 or 255) in segmentation maps. By default (`ignore_class=None`), all classes are considered. Returns: Output tensor. Raises: ValueError: if `axis` is neither -1 nor one of the axes of `output`. int64rysparse_categorical_crossentropyr5NrrzcCannot compute sparse categorical crossentropy with `axis={}` on an output tensor with unknown rankcss|]}t|VqdSr)_is_symbolic_tensorrrrrr:rz2sparse_categorical_crossentropy..r{r|r)$r)rr-rxrrr'rErrrr(rirrr)ndims itertoolschainr(rCrDrrsformatr>rr r?r6rHr(sparse_softmax_cross_entropy_with_logits scatter_ndr _keras_mask)rr_rurZ ignore_classr output_rank permutationr target_rank update_shapeZ valid_maskrpZ res_shaperrrrsv           (  rz!keras.backend.binary_crossentropycCst|}t|}t||dd\}}|r:tjj||dStt|jj}t ||d|}|tj |t}|d|tj d|t7}| S)apBinary 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. Sigmoidbinary_crossentropyrrzr5) r)rrxr!sigmoid_cross_entropy_with_logitsrrr'rErrr)rr_rurbcerrrrs  "rz'keras.backend.binary_focal_crossentropy?@c stjj|fddfdd}||d|d|}td||}t||d} || } |r||d|d|} | | } | S)aBinary focal crossentropy between an output tensor and a target tensor. According to [Lin et al., 2018](https://arxiv.org/pdf/1708.02002.pdf), it helps to apply a focal factor to down-weight easy examples and focus more on hard examples. By default, the focal tensor is computed as follows: `focal_factor = (1 - output) ** gamma` for class 1 `focal_factor = output ** gamma` for class 0 where `gamma` is a focusing parameter. When `gamma` = 0, there is no focal effect on the binary crossentropy. If `apply_class_balancing == True`, this function also takes into account a weight balancing factor for the binary classes 0 and 1 as follows: `weight = alpha` for class 1 (`target == 1`) `weight = 1 - alpha` for class 0 where `alpha` is a float in the range of `[0, 1]`. Args: target: A tensor with the same shape as `output`. output: A tensor. apply_class_balancing: A bool, whether to apply weight balancing on the binary classes 0 and 1. alpha: A weight balancing factor for class 1, default is `0.25` as mentioned in the reference. The weight for class 0 is `1.0 - alpha`. gamma: A focusing parameter, default is `2.0` as mentioned in the reference. from_logits: Whether `output` is expected to be a logits tensor. By default, we consider that `output` encodes a probability distribution. Returns: A tensor. cstSr)sigmoidrr_rrrhrz+binary_focal_crossentropy..csSrrrrrrrirr5rz)rr_ru)r)r smart_condrr) rr_Zapply_class_balancingrgrruZ sigmoidalp_tZ focal_factorrZ focal_bceweightrrrbinary_focal_crossentropy:s",  rzkeras.backend.sigmoidcCs t|S)zfElement-wise sigmoid. Args: x: A tensor or variable. Returns: A tensor. )r)rr1rrrr}s rzkeras.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?ryrz)rr'rEr)multiplyrr)r2 point_two point_fiverrr hard_sigmoids   rzkeras.backend.tanhcCs t|S)zcElement-wise tanh. Args: x: A tensor or variable. Returns: A tensor. )r)tanhr1rrrrs rzkeras.backend.dropoutcCs(|durtjd}tjj||||dS)aSets 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. NcAr)r/rmrxr)rr)r2levelrrcrrrrs rzkeras.backend.l2_normalizecCstjj||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)linalg l2_normalizerrrrrs rzkeras.backend.in_top_kcCstjjj|||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)rCrDrin_top_k) predictionstargetskrrrrsrcCs0d}|dkr(ts$tjj|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. NWCr9rrtr5NCWrr)rCrDrr2r(r+rrr_preprocess_conv1d_inputs rcCs4d}|dkr,tr|r(tjj|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. r&r9r<r'r)r2r(force_transposer+rrr_preprocess_conv2d_inputs  rcCs0d}|dkr(ts$tjj|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. NDHWCr9)rrtrr-r5NCDHWrrrrr_preprocess_conv3d_inputs rcCs0|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'` sameSAMEvalidVALIDzInvalid padding: )rsr)rwrrr_preprocess_padding-s rzkeras.backend.conv1drc Cs|durt}|dvr&tdt||j}|dkrZ||dd}t||df}d}t|}t||\}}tj j j j ||||||d}|d kr|d krtj j |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>r9r:rzcausalrr5rinputfilter dilation_ratestridesrwr(r9rr)r{rsrrirBrxrrr)rCrDr convolutionr) r2kernelrrwr(r kernel_shapeleft_padr+rrrconv1dBs,  rzkeras.backend.conv2dcCs||durt}|dvr&tdt|t||\}}t|}tjjjj ||||||d}|dkrx|dkrxtjj |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>r9r:rzrr9r&rF) r{rsrrrr)rCrDrrrr2rrrwr(rr+rrrconv2dts" rzkeras.backend.conv2d_transposec Csr|durt}|dvr&tdt||dkr<|dkrr9r:rzr9ruTFr&rrtrr5r5rwr(zmExpected the 2 dimensions of the `dilation_rate` argument to be equal to each other. Received: dilation_rate=)rrwrF)r{rsrrrirr(rr)rrrCrDrconv2d_transposeatrous_conv2d_transposer) r2rrrrwr(rrr+rrrrsZ     rc Cs|durt}|dvr&tdt|t|tr6|f}t|trF|f}t||\}}t|}t|tsnt|}|dkrd}d|dd}nd}d|d}t ||}t |d }t |d }d|}tj j j j |||||||d }t||g}|d kr|dkrtj j |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>r9r:rzrr5rrtrurrrwrr(r9r)r{rsrr(r:rrrr)rrCrDrseparable_conv2drr) r2depthwise_kernelpointwise_kernelrrwr(rr+spatial_start_dimrrrseparable_conv1dsD         rzkeras.backend.separable_conv2dc Cs|durt}|dvr&tdt|t|dkr:tdt||\}}t|}t|tsbt|}|dkrxd|d}nd|}tj j j j |||||||d }|d kr|dkrtj j |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>r9r:rzrt(`strides` must be a tuple of 2 integers.r&rrurr9rF)r{rsrr)rrr(rr)rCrDrrr)r2rrrrwr(rr+rrrrDs2     rzkeras.backend.depthwise_conv2dcCs|durt}|dvr&tdt|t||\}}t|}|dkrRd|d}nd|}tjjjj ||||||d}|dkr|dkrtjj |d }|S) a.2D 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>r9r:rzr&rrurr9rF) r{rsrrrr)rCrDrdepthwise_conv2dr)r2rrrwr(rr+rrrrs( rzkeras.backend.conv3dr5r5r5cCs||durt}|dvr&tdt|t||\}}t|}tjjjj ||||||d}|dkrx|dkrxtjj |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>r9r:rzrr9rrr-r5rtr) r{rsrrrr)rCrDrrrrrrrconv3ds" rcCs"|durt}|dvr&tdt|t|ttfr>t|}t||\}}|dkr~|dkr~|d|d|d|d |d f}|ddurt |dft|d d}tt|}t |}|dkrd |d }nd |}tj j j j||||||d }|dkr|dkrtj j |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>r9r:rzr9rrrtrr-r5rrurr)r{rsrr(rrr)rrrirrCrDrconv3d_transposer)r2rrrrwr(r+rrrrs@    rzkeras.backend.pool2dcCs|durt}|dvr&tdt|t|dkr:tdt|dkrNtdt||\}}t|}|dkrd|d}d|d}nd |}d |}|d krtjjj j |||||d }n4|d krtjjj j |||||d }ntd t||dkr|dkrtjj |d}|S)a2D 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>r9r:rzrtz*`pool_size` must be a tuple of 2 integers.rr&rrurravgInvalid pooling mode: r9rF) r{rsrr)rrr)rCrDrmax_poolavg_poolrr2 pool_sizerrwr( pool_moder+rrrpool2d+s6       rzkeras.backend.pool3dcCs|durt}|dvr&tdt|t||\}}t|}|dkr^d|d}d|d}nd|}d|}|dkrtjj|||||d}n0|d krtjj|||||d}ntd t||d kr|dkrtj j |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>r9r:rzrrrurrrrr9r) r{rsrrrr)r max_pool3d avg_pool3drCrDrrrrrpool3dls.   rcsB|durt}|dvr&tdt|t|}|d}|d}t|} tt| } g} dd|D} tj| D]pt dg} |dkr| t d| fd d | D|d kr| t d| t || dd|fqnt | d d }t||}t ||d|f}|dkr$| | dg| }n| g| | dg}t||S)a2Apply 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>r9r:rzr5rcSsg|] }t|qSrrb)raxis_maxrrrrrzlocal_conv..r9c3s8|]0}t|||||VqdSr)slicer kernel_sizepositionrrrr:s zlocal_conv..r:rr)r{rsrrr)rr(rproductrrextendrrrr7)rrrrrr(r feature_dim channels_outrspatial_dimensionsxsoutput_axes_ticksslices x_aggregater_rrrr local_convs8"     rzkeras.backend.local_conv1dcCs|jdf}t||||||S)aApply 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)rir)rrrrr(rrrr local_conv1ds  rzkeras.backend.local_conv2dcCst||||||S)a-Apply 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'. )r)rrrrrr(rrr local_conv2ds  rzkeras.backend.bias_addcCs|durt}|dvr&tdt|t|}t|dkrjt|t|dkrjtdt|t|dft|dkr|dkrtjj||ddStjj||d dSt|d vr|dkrd|d f|dd }|t ||S|t |d |Stj||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>r9r:rzr5z>Unexpected bias dimensions %d, expect to be 1 or %d dimensionsr9r')r(r&)rr-rr) r{rsrrr)r3r)rbias_addr)r2biasr( bias_shapebias_reshape_axisrrrr<s*   rzkeras.backend.random_normalcCs8|durt}|dur"tjd}tjj|||||dS)aReturns 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 Nr)r|r}r'rc)r.r/rmrxr)rr~rrrrks  rzkeras.backend.random_uniformcCs8|durt}|dur"tjd}tjj|||||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 Nr)rrr'rc)r.r/rmrxr)rrrrrrs  rzkeras.backend.random_binomialcCstjdddt||||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.rtru)rmrnrandom_bernoullirirr'rcrrrrandom_binomials rzkeras.backend.random_bernoullicCsV|durt}|dur"tjd}ttjj|||d|ktj||dtj||dS)aQReturns 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. Nrrr&) r.r/rmrxr)rrrOrKrrrrrs   rzkeras.backend.truncated_normalcCs8|durt}|dur"tjd}tjj|||||dS)aAReturns 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. Nrr)r.r/rmrxr)rr~rrrrs  rz'keras.backend.ctc_label_dense_to_sparsec sHt|}t|dg}t|dgfdd}ttd|dgdtj}tjjj|||dd}|dddddf}t t t d|d||}tjj ||}tjj t t t d|dt|d} tjj | |} tjj t t| |gdddd g} tjj|| } 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. rr5cs(ttt|ddt|kS)Nr5r)r)rr(rifill) old_inputr%max_num_labels_tnsrrrange_less_than+sz2ctc_label_dense_to_sparse..range_less_than)rrNrrtr)r)rirr-rrrCrDscanrrfr( boolean_maskrrr gather_ndr,r) r{ label_lengths label_shapenum_batches_tnsrinit dense_mask label_array label_ind batch_array batch_indr vals_sparserrrctc_label_dense_to_sparses6  r zkeras.backend.ctc_batch_costcCsttj|ddtj}ttj|ddtj}tt||tj}tjtjjj |gddt }t tjjj j |||ddS)avRuns 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. rrr5rrtr)rr{sequence_lengthr5)r)r-rr;r rrrCrDrrrrctc_loss)y_truey_predr label_length sparse_labelsrrrctc_batch_costMs  rzkeras.backend.ctc_decodedc Cst|}|d|d}}tjtjjj|gddt}t|tj }|rftj j ||d\}} ntjjj j ||||d\}} g} |D]0} t | j| j||f} | tjj| ddq| | 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. rr5r r)rr )rr  beam_width top_pathsr)sp_input default_value)rir)rrrCrDrrr-r;rctc_greedy_decoderctc_beam_search_decoderr,rrrrr) rrgreedyrr input_shape num_samples num_stepsdecodedlog_prob decoded_densestrrr ctc_decodess*    r#zkeras.backend.map_fncCstjjj||||dS)a9Map 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`. )rjr')r)rCrDmap_fn)fnelemsrjr'rrrr$sr$zkeras.backend.foldlcCstjjj||||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`. rrj)r)rCrDfoldlr%r&rrjrrrr(sr(zkeras.backend.foldrcCstjjj||||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 r')r)rCrDfoldrr)rrrr*sr*Z KERAS_HOME~z.kerasz keras.jsonr.>float32float64float16rr{>r9r:r$)r.rr%r{wr-)indentcCs,dd}|jr t||n||dS)z6Configure session config and create a session with it.cSst}ttddr(tjjr(|tjjt|rZ|||jj }t j j j||d}nLt}|r|j}||t j j j||jd}n||t j j j|d}t|dS)z(Create the Distributed Strategy session.rN)rrr)rrZrFr_config MergeFromis_tpu_strategy configureextended_tpu_cluster_resolvermasterr)rCrDrdcget_current_worker_contextsession_config master_targetr)distribution_strategyr:r7rworker_contextdc_session_configrrr_create_sessions&    zAconfigure_and_create_distributed_session.._create_sessionN)r5_in_multi_worker_moder8run_distribute_coordinator)r<r?rrrrs% rcCs$dd}||rdSttt|jS)NcSs |jdS)N TPUStrategy)r startswith)rrrrrDrz(_is_tpu_strategy_class..T)r?r_is_tpu_strategy_class __bases__)clz is_tpu_stratrrrrDCsrDcCs t|jS)zEReturns whether input is a TPUStrategy instance or subclass instance.)rDr)strategyrrrr3Jsr3cCsdd}tj||S)NcSst|tjrt|S|Sr)r(r)r+rWrrrr_cast_variables_to_tensorPs  z;cast_variables_to_tensor.._cast_variables_to_tensor)r)r.r/)r5rIrrrrOsrcCst|ot|tjj Sr)r)rr(rrr1rrrrXsrcCs`dd}tj|}tdd|D}|s2|dfStj||}t|ddd}||fS)z%Converts any ragged tensors to dense.cSst|tjr|S|Sr)r(r)rr)rrrr_convert_ragged_input_s z7convert_inputs_if_ragged.._convert_ragged_inputcss|]}t|tjVqdSrr3)rr5rrrr:esz+convert_inputs_if_ragged..Nrr;)r)r.r>r?r/r-nested_row_lengths)rrJ flat_inputscontains_raggedrKrrrconvert_inputs_if_ragged\s rNcCsD|s|S|r2t|dg}tj||}t|dgStj||SdS)z8Converts any ragged input back to its initial structure.r5N)rr)rr)is_ragged_inputr_rKrr4rrrmaybe_convert_to_raggedus  rPc@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|dSr)default_factoryrdWeakKeyDictionaryr)rrRrrrrszContextValueCache.__init__cCstrtjStjjSdSr)r)rPrIr"rCrDrYrrrr_keyszContextValueCache._keycCs*|j}t|tjjs&tjjr&tj S|S)z/Returns the parent graph or dummy eager object.) outer_graphr(r)rrrCrDr|rIr")rr< parent_graphrrr_get_parent_graphs  z#ContextValueCache._get_parent_graphcCs8||}|dur|St|tjjr4|||SdS)z2Gets the value at key or the closest parent graph.N)rfr(r)rr_get_recursiverWrr"rWrrrrXs  z ContextValueCache._get_recursivecCs6|dur|}||}|dur2|}||<|S)a Gets 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)rTrXrRrYrrr __getitem__s  zContextValueCache.__getitem__NcCsH|dur|}|pi}|dur8||vr8|jfi|}tj|||S)zLSets the default value if key is not in dict, and returns the value.N)rTrRrdrS setdefault)rr"defaultrerrrr[s zContextValueCache.setdefault)NNN) rrrrrrTrWrXrZr[rrrrrQs/ rQ)r4)N)r)r)N)NNN)NNr4FF)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)r)r)r)r)rr)r)r8)Nr5r;)r)ru)ryN)r~N)r)r4r)NN)FNNFNFFT)N)N)ryNry)rz)r)Fr)FrN)F)FrrF)NN)N)F)r5rNr5)rurNru)rurNru)r5rNr5)rurNru)rurNru)rrNr)rrN)rurNr)rrNr)N)N)N)N)ryrzNN)ryrzNN)ryNN)ryNN)ryrzNN)Trr5)NN)NN)NN)F(4rr8rjsonrrmr threadingrmrdrr/tensorflow.compat.v2rCv2r)rrkeras.distributerr8r0rr<rrrrtensorflow.core.protobufr tensorflow.python.eagerr tensorflow.python.eager.contextr tensorflow.python.platformr r tensorflow.python.util.tf_exportr tensorflow.tools.docsrrrLrpy_sumrr?localrBrrrFrSr7rr@rrIrUrrr.r{ set_epsilon set_floatxset_image_data_formatdo_not_generate_docsr%rdispatchadd_dispatch_supportr3r>rArTregister_clear_session_functionrXr_r`r^r[rLr]rKrprocontextmanagerrxrwrrrrrrregister_get_session_functiontrackingregister_session_providerr6rrrrrrrrrrrrrrkrD_v1_name_scoperrrrrr rrrr"rbrirr3r'rGrIrKrOrPrSrUrWrYrwrZr[r\ AutoTrackabler]rrrr-rrrrrrrrrrrrrrrr|rrrrrrrrrrrr r r rrrrrrrrrr$r,r/rrrr7r\r`r]rmrnrfr>rtrrrxr}rrrr_VALUE_SET_CODE_STRINGrHrrrrrrrrrrSr`rerfrjrorqrrrsrxrzrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rr#r$r(r*rrf _keras_dirpath expanduser_keras_base_dirrS _config_pathexistsopenfhloadr1rsZ_floatx_epsilonr(rZ_image_data_formatmakedirsOSErrorfrdumpsIOErrorrrDr3rrrNrPrQObjectIdentityWeakSetrJrMrOrrrrs                  K   $   !# 9  K   &          7   :   ?g    +!      "$     2CL"                   0%!@$?:"%  4"'')V9cF/7  #?h!@      /-[F;31C>9N",$ #"0#9$4     D. x