a /Sicz @sBdZddlZddlZddlZddlZddlZddlZddlZddlm Z ddl Z ddl Z ddl mZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddl m!Z!ddl m"Z"ddl m#Z#ddl$m%Z%ddl&m'Z'dZ(dZ)e*r:e)ne(Z+ia,ej-.dZ/dZ0ej1Z2ej3Z4ej5Z6ej7Z8dZ9dZ:dZ;ee?dddka@e?ddkaAddZBd d!ZCd"d#ZDd$d%ZEd&d'ZFd(d)ZGe'd*gd+e>Gd,d-d-eHZIGd.d/d/eHZJiZKGd0d1d1ejLZMeNd2gd3ZOGd4d5d5ejLZPe'd6Gd7d8d8eNd8d9d:gZQe'd;d<Gd=d>d>eNd>gd?ZRe'd@GdAdBdBeNdBd9d:gZSGdCdDdDeHZTeTZUGdEdFdFeHZVGdGdHdHeHZWGdIdJdJeHZXdaYeZZ[dKdLZ\dMdNZ]dOdPZ^dQdRZ_dSdTZ`dUdVZadWdXZbdYdZZcd[d\Zdd]d^Zed_d`ZfdadbZge'dcgd+dddcZhe'dcgd+dedfZidgdhZjdidjZkdkdlZle'dmgd+dndoZmdpdqZndrdsZe'dtgd+dudvZoe'dwgd+dxdyZpe'dzgd+d{d|Zqe'd}gd+d~dZre'dddZse'dddZte#juddZvddZwe#juddZxe#juddZye'de#juddZzddZ{ddZ|ddZ}ddZ~ddZddZddZejudddZddZddZddZddZe'de#juddZddZe'dddZddZddZddZddZddZee"_dS)z%State management for eager execution.N)logging) function_pb2) config_pb2)coordination_config_pb2)rewriter_config_pb2) pywrap_tfe)tf2)pywrap_tf_session)executor) monitoring) c_api_util)device) tfrt_utils)compat)is_in_graph_mode) tf_contextlib) deprecated) tf_exportiiXz3/tensorflow/api/python/eager_context_create_counterz7Counter for number of eager contexts created in Python.ZTF_RUN_EAGER_OP_AS_FUNCTION1ZTF_JIT_COMPILE_REWRITEcCsdatdurdt_dS)adExecute elementary eager ops (non-function) wrapped in a call op. This should be functionally equivalent to running the eager op's kernel directly (the default) but reduces the number of codepaths for executing TF2 programs in the runtime, thereby improving consistency (in terms of optimizations and rewrites for instance) and maintainability. TN!_RUN_EAGER_OP_AS_FUNCTION_ENABLED context_saferun_eager_op_as_functionrr[/var/www/html/django/DPS/env/lib/python3.9/site-packages/tensorflow/python/eager/context.pyenable_run_eager_op_as_functionZs  rcCsdatdurdt_dSNFrrrrr disable_run_eager_op_as_functionis rcCstdurtjStSN)rrrrrrr run_eager_op_as_function_enabledps r!cCsdatdurdt_dS)zRun jit_compile functions through rewrite pass. This runs jit_compile functions through all of the multidevice function rewrite passes. TN_JIT_COMPILE_REWRITE_ENABLEDrjit_compile_rewriterrrrenable_jit_compile_rewritews r%cCsdatdurdt_dSrr"rrrrdisable_jit_compile_rewrites r&cCstdurtjStSr )rr$r#rrrrjit_compile_rewrite_enableds r'z__internal__.is_tfrt_enabled)v1c@s:eZdZdZgdZdddZddZd d Zd d Zd S)_EagerTensorCachezASimple cache which evicts items based on length in a FIFO manner.)_data _max_items_max_tensor_size'cCst|_||_||_dSr ) collections OrderedDictr*r+r,)selfZ max_itemsmax_tensor_sizerrr__init__s z_EagerTensorCache.__init__cCs>||jkrdS||j|<t|j|jkr:|jjdddS)NF)last)Z _num_elementsr,r*lenr+popitemr1keyvaluerrrputs  z_EagerTensorCache.putcCs|j|dSr )r*getr1r8rrrr;sz_EagerTensorCache.getcCs|jdSr )r*clearr1rrrflushsz_EagerTensorCache.flushN)r-r.) __name__ __module__ __qualname____doc__ __slots__r3r:r;r?rrrrr)s   r)c@sVeZdZdZddgZd ddZeddZejd dZed d Z e jd d Z dS)FunctionCallOptionsz|Options applied at call sites of eager functions. Eager functions are functions decorated with tf.contrib.eager.defun. _config_proto_serialized_executor_typeNcCs||_||_dS)aRConstructor. Args: executor_type: (optional) name of the executor to be used to execute the eager function. If None or an empty string, the default Tensorflow executor will be used. config_proto: (optional) a `config_pb2.ConfigProto` proto or a serialized string of that proto. The config used by Grappler when optimizing the function graph. Each concrete function is optimized the first time is called. Changing config_proto after the first call has no effect. If config_proto is None, an empty RewriterConfig will be used. N)config_proto_serialized executor_type)r1rI config_protorrrr3s zFunctionCallOptions.__init__cCs|jSr rGr>rrrrIsz!FunctionCallOptions.executor_typecCs ||_dSr rK)r1rIrrrrIscCs|jSr )rFr>rrrrHsz+FunctionCallOptions.config_proto_serializedcCs\t|tjr|jdd|_n __class__rrr3sz_TensorCaches.__init__cCs|jst|_|jSr )rYr)r>rrrones_rank_cachesz_TensorCaches.ones_rank_cachecCs|jst|_|jSr )rZr)r>rrr zeros_cachesz_TensorCaches.zeros_cache) r@rArBrCrDr3rVr^r_ __classcell__rrr\rrXs  rX ContextSwitchis_building_functionenter_context_fn device_stackcs0eZdZdZfddZddZddZZS)_ContextSwitchStackz)A thread-local stack of context switches.cs,tt|g|_|r(|jdtdddS)NFrb)r[rfr3stackpush eager_mode)r1eagerr\rrr3 sz_ContextSwitchStack.__init__cCs|jt|||dS)aPush metadata about a context switch onto the stack. A context switch can take any one of the two forms: installing a graph as the default graph, or entering the eager context. For each context switch, we record whether or not the entered context is building a function. Args: is_building_function: (bool.) Whether the context is building a function. enter_context_fn: (function.) A callable that executes the context switch. For example, `graph.as_default` or `eager_mode`. device_stack: If applicable, the device function stack for this graph. When breaking out of graphs in init_scope, the innermost nonempty device stack is used. Eager contexts put `None` here and the value is never used. N)rgappendra)r1rcrdrerrrrhs z_ContextSwitchStack.pushcCs|jdS)zPop the stack.N)rgpopr>rrrrl,sz_ContextSwitchStack.pop)r@rArBrCr3rhrlr`rrr\rrfs rfzconfig.LogicalDevicec@seZdZdZdS) LogicalDeviceaAbstraction for a logical device initialized by the runtime. A `tf.config.LogicalDevice` corresponds to an initialized logical device on a `tf.config.PhysicalDevice` or a remote device visible to the cluster. Tensors and operations can be placed on a specific logical device by calling `tf.device` with a specified `tf.config.LogicalDevice`. Fields: name: The fully qualified name of the device. Can be used for Op or function placement. device_type: String declaring the type of device such as "CPU" or "GPU". Nr@rArBrCrrrrrm2s rmname device_typez!config.LogicalDeviceConfigurationz.config.experimental.VirtualDeviceConfigurationcs"eZdZdZdfdd ZZS)LogicalDeviceConfigurationaVConfiguration class for a logical devices. The class specifies the parameters to configure a `tf.config.PhysicalDevice` as it is initialized to a `tf.config.LogicalDevice` during runtime initialization. Not all fields are valid for all device types. See `tf.config.get_logical_device_configuration` and `tf.config.set_logical_device_configuration` for usage examples. Fields: memory_limit: (optional) Maximum memory (in MB) to allocate on the virtual device. Currently only supported for GPUs. experimental_priority: (optional) Priority to assign to a virtual device. Lower values have higher priorities and 0 is the default. Within a physical GPU, the GPU scheduler will prioritize ops on virtual devices with higher priority. Currently only supported for Nvidia GPUs. experimental_device_ordinal: (optional) Ordinal number to order the virtual device. LogicalDevice with lower ordinal number will receive a lower device id. Physical device id and location in the list is used to break ties. Currently only supported for Nvidia GPUs. Nrcstt|||||Sr )r[rq__new__)cls memory_limitexperimental_priorityexperimental_device_ordinalr\rrrras z"LogicalDeviceConfiguration.__new__)NNr)r@rArBrCrrr`rrr\rrqDs rq)rtrurvzconfig.PhysicalDevicec@seZdZdZdS)PhysicalDevicearAbstraction for a locally visible physical device. TensorFlow can utilize various devices such as the CPU or multiple GPUs for computation. Before initializing a local device for use, the user can customize certain properties of the device such as it's visibility or memory configuration. Once a visible `tf.config.PhysicalDevice` is initialized one or more `tf.config.LogicalDevice` objects are created. Use `tf.config.set_visible_devices` to configure the visibility of a physical device and `tf.config.set_logical_device_configuration` to configure multiple `tf.config.LogicalDevice` objects for a `tf.config.PhysicalDevice`. This is useful when separation between models is needed or to simulate a multi-device environment. Fields: name: Unique identifier for device. device_type: String declaring the type of device such as "CPU" or "GPU". Nrnrrrrrwjsrwc@s(eZdZdZddgZddZddZdS) _AtomicCounterzA simple atomic counter._value_lockcCsd|_t|_dSNr)ry threadingLockrzr>rrrr3sz_AtomicCounter.__init__cCs>|j$|jd7_|jWdS1s00YdS)Nr)rzryr>rrrincrement_and_getsz _AtomicCounter.increment_and_getN)r@rArBrCrDr3r~rrrrrxsrxc@s&eZdZdZdgZddZddZdS)_TensorCacheDeleterz*Deletes tensor caches for a given context. _context_idcCs ||_dSr )r)r1 context_idrrrr3sz_TensorCacheDeleter.__init__cCs"tdur dS|jtvrt|j=dSr )_tensor_caches_maprr>rrr__del__s z_TensorCacheDeleter.__del__N)r@rArBrCrDr3rrrrrrsrc@seZdZdZdddZddZddZd d Zd d Zd dZ ddZ ddZ e fddZ e fddZddZddZddZdd d!Zed"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zdd2d3Zd4d5Zd6d7Zed8d9Zed:d;Zdd?Z#d@dAZ$dBdCZ%dDdEZ&edFdGZ'e'j(dHdGZ'edIdJZ)edKdLZ*dMdNZ+dOdPZ,dQdRZ-dSdTZ.edUdVZ/e/j(dWdVZ/dXdYZ0edZd[Z1e1j(d\d[Z1ed]d^Z2d_d`Z3edadbZ4e4j(dcdbZ4dddeZ5dfdgZ6dhdiZ7djdkZ8dldmZ9dndoZ:dpdqZ;drdsZdxdyZ?edzd{Z@ed|d}ZAeAj(d~d}ZAdddZBddZCdddZDddZEddZFdddZGdddZHdddZIddZJddZKddZLddZMddZNddZOdddZPdddZQeRddddddZSeddZTeddZUeTj(ddZTeUj(ddZUeddZVeVj(ddZVddZWddZXeddZYeYj(ddZYeddZZeZj(ddZZeddZ[e[j(ddZ[eddZ\e\j(ddZ\eddZ]e]j(ddZ]eddZ^e^j(ddZ^eddĄZ_e_j(ddĄZ_eddDŽZ`e`j(ddDŽZ`eddʄZaeaj(ddʄZaedd̈́Zbebj(dd̈́ZbddЄZcdd҄ZdddԄZeddքZfdd؄ZgeddڄZhdS)Contextz.Environment in which eager operations execute.NcCstt|_t|j|_tt|j<||_tj |ddt d|_ t | |_d|_d|_d|_t|_d|_|durzt}||_d|_|dttfvrtd||durt}|tk|_t|_d|_t |_!t"|_#||_$d|_%d|_&d|_'d|_(d|_)d|_*t|_+d|_,d|_-d|_.g|_/d|_0i|_1d|_2d|_3d|_4d|_5d|_6d|_7d|_8i|_9t:;z"Context.__init__..)is_eager device_specNFz0execution_mode should be None/SYNC/ASYNC. Got %sr)>_context_id_counterr~_idrZ_tensor_cache_deleterrXr_configrZEagerContextThreadLocalData_starting_device_spec_thread_local_datarfexecuting_eagerly_context_switches_context_handle_context_devices_seedr|r}_initialize_lock _initializedDEVICE_PLACEMENT_SILENT_device_policy_mirroring_policySYNCASYNCrQ_default_is_asyncis_tfrt_enabled _use_tfrt_use_tfrt_distributed_runtimer!_run_eager_op_as_functionr'_jit_compile_rewrite _server_def_collective_ops_server_def_collective_leader(_collective_scoped_allocator_enabled_ops"_collective_use_nccl_communication_collective_device_filters_coordination_service_config _device_lock_physical_devices_physical_device_to_index_pluggable_devices_visible_device_list_memory_growth_map_virtual_device_map_optimizer_jit_intra_op_parallelism_threads_inter_op_parallelism_threads_soft_device_placement_log_device_placement_operation_timeout_in_ms_enable_mlir_graph_optimization_optimizer_experimental_options$_python_eager_context_create_counterget_cellZ increase_by_is_global_context)r1rU device_policyexecution_mode server_defrrrr3sl,      zContext.__init__cCsZ||_z t|Wn ty2tt|}Yn0t||_|j durVt |j dS)z,Set a global eager mode seed for random ops.N) rhash TypeErrorintnparrayrandomRandom_rngrrTFE_ContextClearCaches)r1seedrrr_set_global_seeds    zContext._set_global_seedcCs|jdtS)a2Returns a fake operation seed. In eager mode, user shouldn't set or depend on operation seed. Here, we generate a random seed based on global seed to make operation's randomness different and depend on the global seed. Returns: A fake operation seed based on global seed. r)rrandint _MAXINT32r>rrr_internal_operation_seed#s z Context._internal_operation_seedc Cs g}g}t|j}zd|_d\}}|jp.|j}|durF|j|j}}tt |D]}t ||}| t |t j|} | jdkr| jdddd} | t| | jdt||} | dkrT| j|krT| j|krT|jd7_qTW||_||_t|n||_||_t|0dS) zHelper to initialize devices.r)NNN localhost)jobreplicataskrorpGPUr)rZTFE_ContextListDevicesr _num_gpusrrjob_name task_indexrangeZTF_DeviceListCountZTF_DeviceListNamerkpydevcanonical_name DeviceSpec from_stringrreplacerm to_stringrpZTF_DeviceListTyper_logical_devicesrZTF_DeleteDeviceList) r1Zlogical_devicesZcontext_devicesZ device_listZ current_job current_taskriZdev_namespecZdev_typerrr_initialize_logical_devices/s:       z#Context._initialize_logical_devicesc Cs|jr dS|j|jr*WddS|jdus8Jt}z|j}t|||jdurpt ||j|j durt ||j |j t krt|d|jdurt||j|jdur|jdurt||jt||jt||jt|}Wt|n t|0|jr0|jr0Jd|jdurV|j}t|t|n"|jdurx|j}t||||_|d|_|j rt!|jWdn1s0YdS)z5Initialize handle and devices if not already done so.NTzzCannot enable remote execution as well as collective ops at the moment. If this is important to you, please file an issue.)"rrrrZTFE_NewContextOptionsrUrOZTFE_ContextOptionsSetConfigrZ*TFE_ContextOptionsSetDevicePlacementPolicyrZ$TFE_ContextOptionsSetMirroringPolicyrrZTFE_ContextOptionsSetAsyncrZTFE_ContextOptionsSetTfrtrZ+TFE_ContextOptionsSetTfrtDistributedRuntimeZ)TFE_ContextOptionsSetRunEagerOpAsFunctionrZ&TFE_ContextOptionsSetJitCompileRewriterZTFE_NewContextZTFE_DeleteContextOptionsrrTFE_ContextSetServerDef_KEEP_ALIVE_SECSTFE_EnableCollectiveOpsrrrTFE_Py_SetCEagerContext)r1optsZ config_strZcontext_handleserver_def_strrrrensure_initializedOsh               zContext.ensure_initializedcCs|jrt|jd|_dSNT)rrrrrr>rrrmark_as_global_contexts zContext.mark_as_global_contextcCs$||tdSr )r^r?r_rTFE_ClearScalarCacher>rrr _clear_cachess  zContext._clear_cachescCs|jSr )rr>rrrget_server_defszContext.get_server_defcCsD|s td||_|jr8|}t|j||||dS)aAllow setting a server_def on the context. When a server def is replaced, it effectively clears a bunch of caches within the context. If you attempt to use a tensor object that was pointing to a tensor on the remote device, it will raise an error. Args: server_def: A tensorflow::ServerDef proto. Enables execution on remote devices. keep_alive_secs: Num. seconds after which the remote end will hang up. As long as the client is still alive, the server state for the context will be kept alive. If the client is killed (or there is some failure), the server will clean up its context keep_alive_secs after the final RPC it receives. Raises: ValueError: if server_def is None. server_def is None.N)rQrrrOrrrrr1rZkeep_alive_secsrrrrset_server_defs zContext.set_server_defcCsD|s td||_|jr8|}t|j||||dS)aUpdate a server_def on the context. Args: server_def: A tensorflow::ServerDef proto. Enables execution on remote devices. keep_alive_secs: Num. seconds after which the remote end will hang up. As long as the client is still alive, the server state for the context will be kept alive. If the client is killed (or there is some failure), the server will clean up its context keep_alive_secs after the final RPC it receives. Raises: ValueError: if server_def is None. rN)rQrrrOrZTFE_ContextUpdateServerDefrrrrrrupdate_server_defszContext.update_server_defcCs |jrt|j|StddS)aZChecks whether a remote worker is alive or not. Args: worker_name: a string representing the remote worker. It must be a fully specified name like "/job:worker/replica:0/task:0". Returns: a boolean indicating whether the remote worker is alive or not. Raises: ValueError: if context is not initialized. Context is not initialized.N)rrZTFE_ContextCheckAliverQ)r1 worker_namerrr check_aliveszContext.check_alivecCs |jrt|jntddS)aSync both local executors and the ones on remote workers. In async execution mode, local function calls can return before the corresponding remote op/function execution requests are completed. Calling this method creates a synchronization barrier for remote executors. It only returns when all remote pending nodes are finished, potentially with errors if any remote executors are in error state. Raises: ValueError: if context is not initialized. rN)rrZTFE_ContextSyncExecutorsrQr>rrrsync_executorss zContext.sync_executorscCs |jrt|jntddS)aClear errors in both local executors and remote workers. After receiving errors from remote workers, additional requests on the fly could further taint the status on the remote workers due to the async nature of remote execution. Calling this method block on waiting for all pending nodes in remote executors to finish and clear their error statuses. Raises: ValueError: if context is not initialized. rN)rrZTFE_ContextClearExecutorsrQr>rrrclear_executor_errorss zContext.clear_executor_errorsrTrcCsx|jrtdt}||_|r.t||_||_ ||_ ||_ |durnt |t r`|j|ntd|f||_dS)z?Enable distributed coordination service with specified configs.zfConfiguring coordination service type may not be effective because the context is already initialized.NzC`coordinated_jobs` must be a list of job names or None, but got: %s)rrwarningrZCoordinationServiceConfig service_typerrservice_leaderenable_health_checkcluster_register_timeout_in_msheartbeat_timeout_in_msrMlistcoordinated_jobsextendrQr)r1rrrrrrrUrrrconfigure_coordination_services    z&Context.configure_coordination_servicecCs|jSr )rr>rrrcoordination_serviceszContext.coordination_servicecCstt|j||dSr )rrZTFE_InsertConfigKeyValuerr7rrrset_config_key_value!szContext.set_config_key_valuecCsRtt0}t|j||t|d}Wdn1sD0Y|SNzutf-8) rr tf_bufferrZTFE_GetConfigKeyValuerr TF_GetBufferdecode)r1r8buffer_r9rrrget_config_key_value%s  .zContext.get_config_key_valuecCstt|j|dSr )rrZTFE_DeleteConfigKeyValuerr<rrrdelete_config_key_value,szContext.delete_config_key_valuecCs$|jrt|j||ntddS)zReport error to other members in a multi-client cluster. Args: error_code: a `tf.errors` error code. error_message: a string. The error message. rN)rrZTFE_ReportErrorToClusterrQ)r1 error_code error_messagerrrreport_error_to_cluster0s  zContext.report_error_to_clustercCs|jdurt|jdS)z2Clear kernel cache and reset all stateful kernels.N)rrrr>rrrclear_kernel_cache=s zContext.clear_kernel_cachecCs|s td||_|jdur~td|jB|js8J|j}t |j|| | Wdn1st0YdS)a*Enable distributed collective ops with an appropriate server_def. Args: server_def: A tensorflow::ServerDef proto. Enables execution on remote devices. Raises: ValueError: if server_def is None. RuntimeError: if this method is not called at program startup. rNzhEnabling collective ops after program startup may cause error when accessing previously created tensors.) rQrrrrrrrOrrrr)r1rrrrrenable_collective_opsBs     zContext.enable_collective_opsZCollectiveReduceFcCsn|jdur@|j|ks2|j|ks2|j|ks2|j|krrrrrs zContext._handlecCs|jdurtd|jSr)rrr>rrr_devicess zContext._devicescCsT|jdurdS|j}dt|g}t|D]\}}|d||fq*d|SdS)Nz:Eager TensorFlow Context. Devices currently uninitialized.z(Eager TensorFlow Context with %d devicesz Device %d: %s )rrr5 enumeraterkjoin)r1deviceslinesrdrrr__str__s zContext.__str__ccsp|j}|j}|tk|_|tkr.|jdtdz"dVW||_|tkrl|jn||_|tkrj|j0dS)z;A context manager to allow setting the mode to EAGER/GRAPH.FN)rrrcontext_switchesrhrirl)r1modectxZ old_is_eagerrrr_modes  z Context._modecCs|jjS)z;Returns True if current thread has eager executing enabled.)rrr>rrrrszContext.executing_eagerlycCs t|jjSzPer-device cache for scalars.)rrr^r>rrrr^szContext.ones_rank_cachecCs t|jjSr&)rrr_r>rrrr_szContext.zeros_cachecCs|jjS)z*Returns scope name for the current thread.r scope_namer>rrrr(szContext.scope_namecCs ||j_dS)z'Sets scope name for the current thread.Nr')r1srrrr(scCs|jjS)z/Returns the device name for the current thread.)r device_namer>rrrr*szContext.device_namecCs|jjS)z/Returns the device spec for the current thread.)rrr>rrrrszContext.device_speccCs||j_||j_dSr )rr*r)r1r*rrrr _set_deviceszContext._set_devicecCs.t|tr|j}nt|r$|}t||S)aoContext-manager to force placement of operations and Tensors on a device. Args: name: Name of the device or None to get default placement. Returns: Context manager that forces device placement. Raises: ValueError: If name is not a string or is an invalid device name. RuntimeError: If device scopes are not properly nested. )rMrmrorZis_device_specr_EagerDeviceContextr1rorrrr s  zContext.devicecCs|jS)z=List of the names of devices available to execute operations.)rr>rrrrszContext.devicescCsR|t.}t|j|t|d}Wdn1sD0Y|Sr) rr rrZTFE_HostAddressSpacerr rr)r1rZ address_spacerrrhost_address_spaces  .zContext.host_address_spacecCs|r tStS)z'Gets execution mode for current thread.)is_asyncrrr>rrrrszContext.execution_modecCs~|dttfvrtd||dur&t}|tk}||krz|jdurt|jt|}||j_t |j| n||_ dS)z'Sets execution mode for current thread.Nz0Execution mode should be None/SYNC/ASYNC. Got %s) rrrQr/rr wait new_executorrrTFE_ContextSetExecutorForThreadhandler)r1r#Z enable_async executor_newrrrr s     cCs|jdur|jS|jSdSr )rr r/rr>rrrr/6s  zContext.is_asynccCs|tt|jSr )rr ExecutorrZTFE_ContextGetExecutorForThreadrr>rrrr <s zContext.executorcCs|t|j|dSr )rrr2rr3)r1errrr Bsc stjdur&jjdurLjr>tjjntjjj j _ j dur^j _ jdurpj_jdurj_n _jdurj_jdurj_t}|j_|tjjjkrdj_jdurjj_fdd}fdd}|d|d|d |d |d |d |d |d|d|d|d|d|d|d|d|d|d|dj !dd}|dur|j j"_#dj$d<dj$d<j%D]Z}|j&vrqԈj'!|}|durj$|j(d7<nj$|j(t)|7<qԈ*}j+,|j-rVj-j_.j/rj j"}t0j1j2|_3|j4j5dd=j/D]} |j4j56| qj7rdj_8j9r؈j:dd=j9D]} j:6| qĈj;rjj<j;S)z7Return the ConfigProto with all runtime deltas applied.NTcs>j|d}|durdStjj||r0tjjntjjdSr ) rr;setattr graph_optionsrewrite_optionsrRewriterConfigONOFFoptionZtogglerUr1rrrewriter_toggleos  z'Context.config..rewriter_togglecs.j|d}|durdStjj||dSr )rr;r7r8r9r=r?rr rewriter_boolxsz%Context.config..rewriter_boollayout_optimizerconstant_foldingshape_optimization remappingarithmetic_optimizationdependency_optimizationloop_optimizationfunction_optimizationdebug_stripperdisable_model_pruningscoped_allocator_optimizationpin_to_host_optimizationimplementation_selectorauto_mixed_precisionuse_plugin_optimizersdisable_meta_optimizer$auto_mixed_precision_onednn_bfloat16auto_mixed_precision_mklmin_graph_nodesrCPUrr)=_initialize_physical_devicesrrNrZCopyFromrOptimizerOptionsON_1r<r8optimizer_optionsglobal_jit_levelrintra_op_parallelism_threadsrinter_op_parallelism_threadsrallow_soft_placementrrlog_device_placementroperation_timeout_in_msrTF_IsMlirBridgeEnabled experimentalZmlir_bridge_rollout ExperimentalZMLIR_BRIDGE_ROLLOUT_ENABLEDenable_mlir_bridgerenable_mlir_graph_optimizationrr;r9rT device_countrrrrpr5_compute_gpu_options gpu_optionsZ MergeFromrZcollective_group_leaderrrr:r;rLZscoped_allocator_optsZ enable_oprkrZcollective_ncclrrrZcoordination_config) r1Zis_mlir_bridge_enabledr@rAnodesdevvirtual_devicesrgr9opfrr?rrUGs                          zContext.configcCs`g}g}d}t}|d}|j}|}|D]}||vr*||q*|D]}|d7}||jvr^qF|j|} || |t||jrF|j |g} g} g} g} | D]2}| |j | |j |j dur| |j q| rt | t | krtd|tjjj| | | dqF|s<|rrrrnum_gpusszContext.num_gpuscCs|t|j|dS)zAdd a function definition to the context. Once added, the function (identified by its name) can be executed like any other operation. Args: fn: A wrapped TF_Function (returned from TF_GraphToFunction_wrapper). N)rrZTFE_ContextAddFunctionr)r1fnrrr add_functions zContext.add_functioncCs(||}t|j|t|dS)zAdd a function definition to the context. Once added, the function (identified by its name) can be executed like any other operation. Args: fdef: A FunctionDef protocol buffer message. N)rrOrZTFE_ContextAddFunctionDefrr5)r1fdefZ fdef_stringrrradd_function_def!s  zContext.add_function_defcCsXt*}t|j||t|}Wdn1s80Yt}| ||S)zGet a function definition from the context. Args: name: function signature name. Returns: The requested FunctionDef. Raises: tf.errors.NotFoundError: if name is not the name of a registered function. N) r rrZTFE_ContextGetFunctionDefrr rr FunctionDefParseFromString)r1ror proto_dataZ function_defrrrget_function_def/s ( zContext.get_function_defcCs|t|j|||dS)zrrrlist_function_namesVszContext.list_function_namescCs|t|j|dS)zRemove a function from the context. Once removed, the function cannot be executed anymore. Args: name: function signature name. N)rrZTFE_ContextRemoveFunctionrr-rrrremove_function_szContext.remove_functioncCs|tt|j|S)z)Check if a function `name` is registered.)rboolrZTFE_ContextHasFunctionrr-rrr has_functionjszContext.has_functioncCs||jjvr|jj|dS)alAdd a post-op callback to the context. A post-op callback is invoked immediately after an eager operation or function has finished execution or after a op has been added to a graph, providing access to the op's type, name input and output tensors. Multiple op callbacks can be added, in which case the callbacks will be invoked in the order in which they are added. Args: callback: a callable of the signature `f(op_type, inputs, attrs, outputs, op_name=None, graph=None)`. See doc strings in `op_callbacks.py` for details on the function signature and its semantics. N)r op_callbacksrkr1callbackrrradd_op_callbackos zContext.add_op_callbackcCs,||jjvrtd|jj|jj|=dS)zRemove an already-registered op callback. Args: callback: The op callback to be removed. Raises: KeyError: If `callback` is not already registered. zOThe specified op callback has not been registered, and hence cannot be removed.N)rrKeyErrorindexrrrrremove_op_callbacks  zContext.remove_op_callbackcCs|jjSr )rrr>rrrrszContext.op_callbackscCs|jjSr rinvoking_op_callbacksr>rrrrszContext.invoking_op_callbackscCs ||j_dSr r)r1r9rrrrscsj|s&jdur&WddSt}dd|D_ddtjD_t}dd|D_tj_ fddjD_ Wdn1s0Y dS)zGets local devices visible to the system. Args: reinitialize: If True, reinitializes self._physical_devices so that dynamic registered devices will also be visible to the python front-end. NcSs*g|]"}t||dddqS:rrrwrsplit.0r rrr sz8Context._initialize_physical_devices..cSsi|]\}}||qSrr)rrprrr sz8Context._initialize_physical_devices..cSs*g|]"}t||dddqSrrrrrrrscs&i|]}|jdks|jvr|dqS)rN)rprrr>rrrs) rrrZTF_ListPhysicalDevicesrrZTF_ListPluggablePhysicalDevicesrrrr_import_config)r1Z reinitializeZdevsZpluggable_devsrr>rrVs&   &z$Context._initialize_physical_devicescCs|ddS)z)Gets local devices visible to the system.TN)rVr>rrrreinitialize_physical_devicessz%Context.reinitialize_physical_devicescs.|durt|jSfdd|jDS)aeList local devices visible to the system. This API allows a client to query the devices before they have been initialized by the eager runtime. Additionally a user can filter by device type, to get only CPUs or GPUs. Args: device_type: Optional device type to limit results to Returns: List of PhysicalDevice objects. Ncsg|]}|jkr|qSrrprrrrrrz1Context.list_physical_devices..)rVrrr1rprrrrss  zContext.list_physical_devicescCst|tstd|f|jdus,||jvr:td|f|j|}t|}d|vrz*|dd\}}t|t|f|d<Wn"tytd|dYn0|S)zReturns details about a physical devices. Args: device: A `tf.config.PhysicalDevice` returned by `tf.config.list_physical_devices` or `tf.config.get_visible_devices`. Returns: A dict with string keys. z6device must be a tf.config.PhysicalDevice, but got: %sNzcThe PhysicalDevice must be one obtained from calling `tf.config.list_physical_devices`, but got: %sZcompute_capability.z;Device returned compute capability an in invalid format: %s) rMrwrQrrZTF_GetDeviceDetailsrrr)r1r rdetailsmajorminorrrrget_device_detailss*      zContext.get_device_detailscCs|jdurdS|jjdd}|dkrrdd|jD}|dkrL|gdn&|dkrr||dddt|Ddd|jD}|sdS|jjd d}g}|jjj}|r| d D]2}t |t |krt d || |t |qn|}|dur|d|}||d dS) a%Import config if passed in during construction. If Context was created with a ConfigProto such as when calling tf.compat.v1.enable_eager_execution(), then we need to pull out the various pieces we might be replacing and import then into our internal class representation. NrUrcSsg|]}|jdkr|qS)rUrrrrrrrz*Context._import_config..rcSsg|] }tqSr)rq)r_rrrr rcSsg|]}|jdkr|qS)rrrrrrrrrroz Invalid visible device index: %s)rrer;rset_visible_devices set_logical_device_configurationrrgrqrrr5rQrk)r1num_cpusZcpusZgpusZ gpu_countZ visible_gpusZvisible_indicesrrrrrs4     zContext._import_configcs.|durt|jSfdd|jDS)zReturn logical devices.Ncsg|]}|jkr|qSrrrrrrr/rz0Context.list_logical_devices..)rrrrrrrlist_logical_devices)s zContext.list_logical_devicescs.|durt|jSfdd|jDS)z Get the list of visible devices.Ncsg|]}|jkr|qSrrrrrrr8sz/Context.get_visible_devices..)rVrrrrrrget_visible_devices1s   zContext.get_visible_devicescs|t|ts|g}|D]@}||jvr:tdt|dur|jkrtdt|qg}dur~fdd|jD}||7}|j|krdS|jdurt d||_dS)z Set the list of visible devices.Unrecognized device: %sNcsg|]}|jkr|qSrrrrrrrKsz/Context.set_visible_devices..z:Visible devices cannot be modified after being initialized) rVrMrrrQreprrprrr)r1rrpr rqrrrr<s*     zContext.set_visible_devicescCs||t|j|S)z-Returns a dict of memory info for the device.)rVrrZTFE_GetMemoryInforr1rirrrget_memory_infoZszContext.get_memory_infocCs"||t|j|dS)z/Resets the tracked memory stats for the device.N)rVrrZTFE_ResetMemoryStatsrrrrrreset_memory_stats`szContext.reset_memory_statscCs,|||jvr"tdt||j|S)z5Get if memory growth is enabled for a PhysicalDevice.r)rVrrQrrrrrrget_memory_growthfs zContext.get_memory_growthcCs|||jvr"tdt|||jvr4td|jdkrP||jvrPtd|j||krddS|j durvt d||j|<dS)z.rUrz.Virtual CPUs already set, cannot modify again.) rrrkrrrrr5rrZTFE_SetLogicalCpuDevicesrr)r1rprefixrZlogical_local_devicesrrrset_logical_cpu_devicess   zContext.set_logical_cpu_deviceshlocCst|j||||Sr )rZTF_GetCompilerIrr)r1r* function_nameargsstagerrrget_compiler_irs zContext.get_compiler_irz*XLA:CPU and XLA:GPU devices are deprecated)Z warn_oncecCs tdS)z1Enables XLA:CPU and XLA:GPU devices registration.N)rZTF_EnableXlaDevicesr>rrrenable_xla_devicesszContext.enable_xla_devicescCstSr )rr`r>rrrrcszContext.enable_mlir_bridgecCs|jSr )rr>rrrrdsz&Context.enable_mlir_graph_optimizationcCst|d|j_dSr )rZTF_EnableMlirBridgerrur1enabledrrrrcs cCs||_d|j_dSr )rrrurrrrrdscCs$|jjjj}|tjjkp"|tjjkSr )rUr8rYrZrrWrXZON_2)r1levelrrr optimizer_jits   zContext.optimizer_jitcCs||_d|j_dSr )rrrurrrrrscs|jjjifdd}fdd}|d|d|d|d|d |d |d |d |d |d|d|d|d|d|d|d|d|djdkrΈjd<S)zhGet experimental options for the optimizer. Returns: Dictionary of current option values cs&t|}|dkr"|tjjk|<dSr{)getattrrr:r;)r>attrrwr9rrr@s zCContext.get_optimizer_experimental_options..rewriter_togglecst||<dSr )r)r>rrrrAszAContext.get_optimizer_experimental_options..rewriter_boolrBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrrT)rUr8r9rT)r1r@rArrr"get_optimizer_experimental_optionss2   z*Context.get_optimizer_experimental_optionscCs|j|d|j_dS)zjSet experimental options for the optimizer. Args: options: Dictionary of options to modify N)rupdaterrurvrrr"set_optimizer_experimental_options#s z*Context.set_optimizer_experimental_optionscCs|jjSr )rUr[r>rrrr[-sz$Context.intra_op_parallelism_threadscCs*|j|krdS|jdur td||_dS)Nz=Intra op parallelism cannot be modified after initialization.)rrrr1 num_threadsrrrr[1s  cCs|jjSr )rUr\r>rrrr\<sz$Context.inter_op_parallelism_threadscCs*|j|krdS|jdur td||_dS)Nz=Inter op parallelism cannot be modified after initialization.)rrrrrrrr\@s  cCs|jjSr )rUr]r>rrrsoft_device_placementKszContext.soft_device_placementcCs*|jdurt|j|||_d|j_dSr )rrZ!TFE_ContextSetSoftDevicePlacementrrrrur1rrrrrOs cCs|jjSr )rUr^r>rrrr^WszContext.log_device_placementcCs*|jdurt|j|||_d|j_dSr )rrZ TFE_ContextSetLogDevicePlacementrrrrurrrrr^[s cCs|jSr )rr>rrrrcsz Context.run_eager_op_as_functioncCs"|jdurt|j|||_dSr )rrZ"TFE_ContextSetRunEagerOpAsFunctionrrrrrrrgs cCs|jSr )rr>rrrr$mszContext.jit_compile_rewritecCs"|jdurt|j|||_dSr )rrZTFE_ContextSetJitCompileRewriterrrrrrr$qs cCs|jdurt|jS|jSr )rrZ#TFE_ContextGetDevicePlacementPolicyrrr>rrrrws  zContext.device_policycCs:|dur t}|j|kr6||_|jdur6t|j|jdSr )rrrrZ.TFE_ContextSetThreadLocalDevicePlacementPolicyr)r1policyrrrrs  cCs|jSr )rr>rrruse_tfrtszContext.use_tfrtcCs<t|tstdt||j|kr8|jr2td||_dS)zSets whether to use TFRT.Expecting a boolean but got %s0use_tfrt should be set before being initialized.N)rMrrQrSrr)r1Ztfrtrrrrs   cCs|jSr )rr>rrruse_tfrt_distributed_runtimesz$Context.use_tfrt_distributed_runtimecCs<t|tstdt||j|kr8|jr2td||_dS)a/Sets whether to use TFRT distributed runtime. This is only effective when use_tfrt is also true. Note that currently TFRT distributed runtime is not function complete and this config is for testing only. Args: enable: A boolean to set whether to use TFRT distributed runtime. rrN)rMrrQrSrrrrrrrs  cCs|jjSr )rUr_r>rrrr_szContext.operation_timeout_in_mscCs*|j|krdS|jdur td||_dS)Nz:Operation timeout cannot be modified after initialization.)rrr)r1rrrrr_s  cCs|t|jdS)zEnables tracing of op execution via RunMetadata. To retrieve the accumulated metadata call context.export_run_metadata() and to stop tracing call context.disable_run_metadata(). N)rrZTFE_ContextEnableRunMetadatarr>rrrenable_run_metadataszContext.enable_run_metadatacCs|js dSt|jdSz1Disables tracing of op execution via RunMetadata.N)rrZTFE_ContextDisableRunMetadatar>rrrdisable_run_metadataszContext.disable_run_metadatacCs|t|jdS)zEnables graph collection of executed functions. To retrieve the accumulated graphs call context.export_run_metadata() and to stop collecting graphs call context.disable_graph_collection(). N)rrZ TFE_ContextEnableGraphCollectionrr>rrrenable_graph_collectionszContext.enable_graph_collectioncCs|js dSt|jdSz0Disables graph collection of executed functions.N)rrZ!TFE_ContextDisableGraphCollectionr>rrrdisable_graph_collectionsz Context.disable_graph_collectioncCsf|js dSt(}t|j|t|}Wdn1s@0Yt}| t ||S)aReturns a RunMetadata proto with accumulated information. The returned protocol buffer contains information since the most recent call to either enable_run_metadata or export_run_metadata. Returns: A RunMetadata protocol buffer. Or None if not enabled. N) rr rrZTFE_ContextExportRunMetadatar rrZ RunMetadatar~ras_bytes)r1rrZ run_metadatarrrexport_run_metadatas  (zContext.export_run_metadatacCs|jS)z$Returns a stack of context switches.)rr>rrrr"szContext.context_switches)NNNN)rTrrN)rrFN)F)N)N)N)N)r)r)ir@rArBrCr3rrrrrrrrrrrrrrrVrrrrr r r rrrrrr!rcontextmanagerr%rr^r_r(rWr*rr+r rr.rr/r rUrfrurxrzr|rrrrrrrrrrrVrrsrrrrrrrrrrrrrrrrcrdrrrr[r\rr^rr$rrrr_rrrrrr"rrrrrs^ i  4 !     +             v:          ' .    $         )                       rc@s0eZdZdZgdZddZddZddZd S) r,zAContext-manager forcing placement of ops and Tensors on a device. _device_name_ctx_stackcCs||_||_g|_dSr r)r1r$r*rrrr3sz_EagerDeviceContext.__init__cCs|j}|j}|j}|j}||f}zt|\}}WntyVtdt||fYnty|durt |t j stdt||ft j |}|rt|}n|t j |jd}||}n t j d}|}||ft|<Yn0||||j|||fdS)Nz*Expecting a string device name. Got %s(%s)rr)rr*rr_device_parsing_cacherrQrSrrMsix string_typesrrrcopyrrZmake_merged_specrr+rrk)r1r$old_device_nameold_device_specZnew_device_name cache_keynew_device_specrrrr __enter__s<          z_EagerDeviceContext.__enter__cGs@|j}|jd\}}}|j|ur(td|jd=|||dS)Nrmz1Exiting device scope without proper scope nesting)rrrrr+)r1Zex_infor$rrrrrr__exit__$s  z_EagerDeviceContext.__exit__N)r@rArBrCrDr3rrrrrrr,s "r,cCst|||adSr )rZTFE_Py_SetEagerContextr_contextr$rrr_set_context_locked2s rcCs0tt|Wdn1s"0YdSr ) _context_lockrrrrr _set_context9srcCs>t&tdurt}t|Wdn1s00YdSr )rrrrrrrr_create_context>srcCsVttt$tdur*tdaWdn1s>0YtiadS)zWClears and re-initializes the singleton context. Should only be used for testing. N) gccollectrrrrrrrrrrr_reset_contextEs "rcCs tdS)z[Clears and re-initializes the TF JIT compiler flags. Should only be used for testing. N)rZTF_ResetJitCompilerFlagsrrrr_reset_jit_compiler_flagsYsrcCstdurttS)z#Returns a singleton context object.N)rrrrrrcontextasrcCstS)zAReturns current context (or None if one hasn't been initialized).)rrrrrrhsrcCstdS)zInitialize the context.N)rrrrrrrmsrcCstdS)zInitialize the virtual devices.N)rrrrrrinitialize_logical_devicesrsrcCst|dS)zSets the eager mode seed.N)rr)rrrrset_global_seedwsrcCstjS)zReturns the eager mode seed.)rrrrrr global_seed|srcCs tS)z:Returns the operation seed generated based on global seed.)rrrrrrinternal_operation_seedsrrcCst}|durttkS|S)a\Checks whether the current thread has eager execution enabled. Eager execution is enabled by default and this API returns `True` in most of cases. However, this API might return `False` in the following use cases. * Executing inside `tf.function`, unless under `tf.init_scope` or `tf.config.run_functions_eagerly(True)` is previously called. * Executing inside a transformation function for `tf.dataset`. * `tf.compat.v1.disable_eager_execution()` is called. General case: >>> print(tf.executing_eagerly()) True Inside `tf.function`: >>> @tf.function ... def fn(): ... with tf.init_scope(): ... print(tf.executing_eagerly()) ... print(tf.executing_eagerly()) >>> fn() True False Inside `tf.function` after `tf.config.run_functions_eagerly(True)` is called: >>> tf.config.run_functions_eagerly(True) >>> @tf.function ... def fn(): ... with tf.init_scope(): ... print(tf.executing_eagerly()) ... print(tf.executing_eagerly()) >>> fn() True True >>> tf.config.run_functions_eagerly(False) Inside a transformation function for `tf.dataset`: >>> def data_fn(x): ... print(tf.executing_eagerly()) ... return x >>> dataset = tf.data.Dataset.range(100) >>> dataset = dataset.map(data_fn) False Returns: `True` if the current thread has eager execution enabled. N)rrrrrrrrrs6cCstS)a*Checks whether the current thread has eager execution enabled. Eager execution is typically enabled via `tf.compat.v1.enable_eager_execution`, but may also be enabled within the context of a Python function via tf.contrib.eager.py_func. When eager execution is enabled, returns `True` in most cases. However, this API might return `False` in the following use cases. * Executing inside `tf.function`, unless under `tf.init_scope` or `tf.config.run_functions_eagerly(True)` is previously called. * Executing inside a transformation function for `tf.dataset`. * `tf.compat.v1.disable_eager_execution()` is called. >>> tf.compat.v1.enable_eager_execution() General case: >>> print(tf.executing_eagerly()) True Inside `tf.function`: >>> @tf.function ... def fn(): ... with tf.init_scope(): ... print(tf.executing_eagerly()) ... print(tf.executing_eagerly()) >>> fn() True False Inside `tf.function` after `tf.config.run_functions_eagerly(True)` is called: >>> tf.config.run_functions_eagerly(True) >>> @tf.function ... def fn(): ... with tf.init_scope(): ... print(tf.executing_eagerly()) ... print(tf.executing_eagerly()) >>> fn() True True >>> tf.config.run_functions_eagerly(False) Inside a transformation function for `tf.dataset`: >>> def data_fn(x): ... print(tf.executing_eagerly()) ... return x >>> dataset = tf.data.Dataset.range(100) >>> dataset = dataset.map(data_fn) False Returns: `True` if the current thread has eager execution enabled. rrrrrexecuting_eagerly_v1s>> tf.debugging.set_log_device_placement(True) >>> tf.ones([]) >>> # [...] op Fill in device /job:localhost/replica:0/task:0/device:GPU:0 >>> with tf.device("CPU"): ... tf.ones([]) >>> # [...] op Fill in device /job:localhost/replica:0/task:0/device:CPU:0 >>> tf.debugging.set_log_device_placement(False) Turning on `tf.debugging.set_log_device_placement` also logs the placement of ops inside `tf.function` when the function is called. Args: enabled: Whether to enabled device placement logging. Nrrrrrset_log_device_placements s rccs0t}|j}z||_dVW||_n||_0dS)zGContext manager for setting device placement policy for current thread.N)rr)rr$ old_policyrrrr s rcCs |t_dS)z+Sets execution mode for the current thread.N)rr)r#rrrset_execution_mode sr ccsf|durdVnRt}t|tk}|j}z&|||_dVW||_|n||_|0dS)z>Context manager for setting execution mode for current thread.N)rr r1rr0)r#r$r4 executor_oldrrrr s rccs0t}|j}z||_dVW||_n||_0dS)a!Context manager for changing executor for current thread. Args: e: A Executor to execute eager ops under this scope. Setting it to None will switch back to use the default executor for the context. Yields: Context manager for setting the executor for current thread. Nr)r6r$r rrrexecutor_scope s r z#experimental.function_executor_typeccs:tj}t|}z||_dVW|t_n |t_0dS)atContext manager for setting the executor of eager defined functions. Eager defined functions are functions decorated by tf.contrib.eager.defun. Args: executor_type: a string for the name of the executor to be used to execute functions defined by tf.contrib.eager.defun. Yields: Context manager for setting the executor of eager defined functions. N)rrurrI)rIZcurrent_optionsZ old_optionsrrrfunction_executor_type s  r cCs tS)z0Returns true if current thread is in async mode.)rr/rrrrr/ sr/cCs tS)z`Get the number of available GPU devices. Returns: The number of available GPU devices. )rrxrrrrrx srxcCstdS)zEnables tracing of op execution via RunMetadata. To retrieve the accumulated metadata call context.export_run_metadata() and to stop tracing call context.disable_run_metadata(). N)rrrrrrr srcCstdSr)rrrrrrr srcCstdS)zEnables graph collection of executed functions. To retrieve the accumulated graphs call context.export_run_metadata() and to stop collecting graphs call context.disable_graph_collection(). N)rrrrrrr srcCstdSr)rrrrrrr srcCs tS)zReturns a RunMetadata proto with accumulated information. The returned protocol buffer contains information since the most recent call to either enable_run_metadata or export_run_metadata. Returns: A RunMetadata protocol buffer. )rrrrrrr s rTccsft}|zg}|V|}W|n |0|jD]"}|rT||jq>||jq>dS)aLCollects a flat list of pre- or post-optimization graphs. The collected graphs include device placements, which can be useful for testing. Usage: ``` @def_function.function def f(x): return x + constant_op.constant(1.) with context.collect_graphs() as graphs: with ops.device("CPU:0"): f(constant_op.constant(1.)) graph, = graphs # `graph` contains a single GraphDef for inspection ``` Args: optimized: whether to collect optimized graphs or non-optimized graphs Yields: A list of GraphDefs, populated when the context manager exits. N)rrrrZfunction_graphsrkZpost_optimization_graphZpre_optimization_graph)Z optimizedr$graphsmetadatagraphrrrcollect_graphs s  rcCs tSr )rrrrrrrE srcCst|dSr )rrrrrrrI srcCst|dSr )rrrrrrrM srcCs t|Sr )rr)rrrrrQ srzexperimental.async_scopec csrd}tj|}z>tdtj|<dVtW|durDtj|=qn|tj|<n|durbtj|=n |tj|<0dS)aContext manager for grouping async operations. Ops/function calls inside the scope can return before finishing the actual execution. When exiting the async scope, a synchronization barrier will be automatically added to ensure the completion of all async op and function execution, potentially raising exceptions if async execution results in an error state. Users may write the following code to asynchronously invoke `train_step_fn` and log the `loss` metric for every `num_steps` steps in a training loop. `train_step_fn` internally consumes data using `iterator.get_next()`, and may throw OutOfRangeError when running out of data. In the case: ``` try: with tf.experimental.async_scope(): for _ in range(num_steps): # Step function updates the metric `loss` internally train_step_fn() except tf.errors.OutOfRangeError: tf.experimental.async_clear_error() logging.info('loss = %s', loss.numpy()) ``` Yields: Context manager for grouping async operations. Z(TF_ENABLE_EAGER_CLIENT_STREAMING_ENQUEUETN)osenvironr;rPrr)Zremote_async_env_varrrrr async_scopeU s      rcCs6d}tj|tdkrdStjdur2tdS)aSync all async operations and raise any errors during execution. In async execution mode, an op/function call can return before finishing the actual execution. Calling this method creates a synchronization barrier for all async op and function execution. It only returns when all pending nodes are finished, potentially raising exceptions if async execution results in an error state. It is a no-op if the context is not initialized. Z%TF_PS_DISABLE_ASYNC_EXECUTOR_GLOBALLYTN)rrr;rPrrr)Zdisable_async_executor_env_varrrr async_wait s  rzexperimental.async_clear_errorcCstdS)a:Clear pending operations and error statuses in async execution. In async execution mode, an error in op/function execution can lead to errors in subsequent ops/functions that are scheduled but not yet executed. Calling this method clears all pending operations and reset the async execution state. Example: ``` while True: try: # Step function updates the metric `loss` internally train_step_fn() except tf.errors.OutOfRangeError: tf.experimental.async_clear_error() break logging.info('loss = %s', loss.numpy()) ``` N)rrrrrrasync_clear_error srcCst|dS)z)Add a function definition to the context.N)rrz)r{rrrrz srzcCst|dS)z#Remove a function from the context.N)rrrrrrr srcCs t|Sr )rrrrrrr srcCst|||dS)a!Calls TFE_RegisterCustomDevice to register a custom device with Python. Enables using C extensions specifying a custom device from Python. See the experimental eager C API in tensorflow/c/eager/c_api_experimental.h for details. Note that custom devices are not currently supported inside `tf.function`s. Args: device_capsule: A PyCapsule with the name set to 'TFE_CustomDevice' containing a pointer to a TFE_CustomDevice struct. The capsule retains ownership of the memory. device_name: A string indicating the name to register the custom device under, e.g. '/job:localhost/replica:0/task:0/device:CUSTOM:0'. It may subsequently be passed to `with tf.device(...):`. device_info_capsule: A PyCapsule with the name set to 'TFE_CustomDevice_DeviceInfo' containing a pointer to a device-specific struct with the initial state of the custom device (the void* device_info argument to TFE_RegisterCustomDevice). This method takes ownership of the memory and clears the capsule destructor. N)rr)rr*rrrrr s rcCstdurdSt Sr)rrrrrr_tmp_in_graph_mode s r)T)rCr/ contextlibrrrrr|ZabslrnumpyrrZtensorflow.core.frameworkrZtensorflow.core.protobufrrrtensorflow.pythonrrtensorflow.python.clientr tensorflow.python.eagerr r tensorflow.python.frameworkr r rrtensorflow.python.utilrrrZ"tensorflow.python.util.deprecationr tensorflow.python.util.tf_exportrrrrrrrrrrZTFE_DEVICE_PLACEMENT_EXPLICITZDEVICE_PLACEMENT_EXPLICITZTFE_DEVICE_PLACEMENT_WARNZDEVICE_PLACEMENT_WARNZTFE_DEVICE_PLACEMENT_SILENTrZ%TFE_DEVICE_PLACEMENT_SILENT_FOR_INT32Z!DEVICE_PLACEMENT_SILENT_FOR_INT32rrrCounterrrgetenvrr#rrr!r%r&r'objectr)rErlocalrX namedtuplerarfrmrqrwrxrrrr,rr}rrrrrrrrrrrrrrrrrrrir(rrrrrrrrr rr r r/rxrrrrrrrrrrrrrrzrrrrZIS_IN_GRAPH_MODErrrrsV                    7+  $ \8  <  >         "         ) .