BVh UdZddlZddlmZmZmZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl mZmZmZmZmZmZmZmZmZddlmZddlZddlm ZddlmZddlmZdd lm Z dd lm!Z!dd lm"Z"dd lm#Z#dd lm$Z$ddlm%Z%ddlm&Z&ddl'm(Z(ddl)m*Z*ddl)m+Z+ddl)m,Z,ddl-m.Z.ddl/m0Z0ddl/m1Z1ddl/m2Z2ddl/m3Z3ddl4m5Z5ddl4m6Z6ddl4m7Z8ddl4m9Z9ddl4m:Z:ddl4m;Z;ddl4mZ?dd"l4m@Z@dd#l4mAZAdd$l4mBZBdd%l4mCZCdd&l4mDZDdd'lEmFZFdd(lEmGZGdd)lHmIZJdd*lKmLZMddlNm1ZOdd+lNmPZPdd,lQmRZRdd-lQmSZSdd.lQmTZTdd/lQmUZUdd0lQmVZVdd1lQmWZWdd2lQmXZXdd3lQmYZYdd4lQmZZZdd5l[m\Z\dd6l]m^Z^dd7l_m`Z`dd8l_maZaed9Zbed:d;<Zced=d><Zded?d@<ZeedAdB<ZfdCZgdCZheiejdD<dCZkeiejdE<e2jdFdGZme2jdHdIZne2jdJdKZoe9jZqere%je9jfejdL<dMefdNZuGdOdPevZwGdQdRejdZydSZzdMeifdTZ{dMe|fdUZ}ddMe~fdWZddMefdXZeadYGdZd[e.je?jZdMe?jfd\ZGd]dBe?jePj eOj Zead^g_e+jeZdd`dae~dbee~dMe~fdcZddMefddZeMjdedddVddde?jffdMeeeffdfZeZedgeeeffejdh< ddMeeeeffdiZ ddMeeeeffdjZ ddMeeee6j$ffdkZ ddMeeee6j$ffdlZ ddMeeeee6j$edffdmZ ddMeeeee6j$edffdnZdMe~fdoZddMe#j2fdpZe j6dqZee~ejdr<e j6dsZee~ejdt<eadug_eZj< ddMe.j>fdvZead@Gdwd@e.jBZe<jFejdx<e<jFejdy<e<jFdzxZZead{Gd|d{evZeTjNd}d~eadgd_de~dMdfdZeZee~gdfejd~<eZee~gdfejd}<dZddZGdd>evZe<jFdZe<jFejd<GddevZdMefdZdMe~fdZdZe|ejd<dZe|ejd<eXjhdMedfdZead;Gdd;e.jlZeadg_dMedfdZ7eadg_dMedfdZeadg_dMee~fdZ ddMedfdZddMedfdZeTjxddeadg_ddMedfdZeaddMej|fdZe=jZ d ddZGdde=jeZeëZeejd<dMeegeefeCjffdZeadeXjhdMedfdZeadg_dMeifdZeadg_dMeifdZeadg_ d ddZeadg_ddZ d ddZddMefdZeadg_ddZeadg_dMefdZdMeifdZeadg_dMe~fdZddZddMefdZeadg_GddevZddZeadg_ddZeadg_ddZeadg_dMeefdZeadg_ddMeefd„ZdMee~fdÄZ ddMeee~fdĄZGdńdeje~Zeadg_GdȄdejee~Zeadg_dMe~fd˄Zeadg_Gd̄deje~Zdbe~dMe~fd΄Zdbe~dMe~fdτZeadg_eXjhddMeee~fdфZe<jFdҫZ d ddӄZdMeeejfdԄZdMeeegejffdՄZdMeeejgeffdքZdMeeeeegdfffdׄZde jdMedgeffdلZdMefdڄZddۄZdMeee?jee?jffd܄ZGd݄dejZejaeejd<dMefdZdMeifdZdMeifdZddZdMefdZdMe~fdZdVaeiejd<ddZddZdMefdZeGjZddZeaddg_dMeifdZy)z/Classes and functions used to construct graphs.N)CallableIteratorSequence) castTypeVarAnyAnyStrNoReturnOptionalPatternUnionContextManager)app)typing)message)attr_value_pb2) full_type_pb2) function_pb2) graph_pb2) node_def_pb2) op_def_pb2) types_pb2) versions_pb2) config_pb2)pywrap_tensorflow) pywrap_tfe)tf2)pywrap_tf_session)context)core) monitoring)record) c_api_util)composite_tensor)device)dtypes)errors) op_callbacks)registry)stacktensor)tensor_conversion_registry) tensor_shape) tensor_util)traceable_stack)versions)control_flow_util)handle_data_util) tf_logging)trace)internal)compat)decorator_utils) deprecation)function_utils) lock_util)object_identity) tf_contextlib)tf_stack)traceback_utils)collections_abc)deprecated_args) kwarg_only) tf_export_T GraphTypeGraph)bound OpStatsTypeOpStats OperationType OperationEagerTensorType_EagerTensorBaseT _USE_C_API _USE_C_SHAPESz#/tensorflow/api/ops_eager_executionz/Whether ops.enable_eager_execution() is called.z&/tensorflow/api/enable_control_flow_v2z+Whether enable_control_flow_v2() is called.z/tensorflow/api/tf_functionzWhether tf.function() is used._DTYPES_INTERN_TABLEreturnc|jS)z,Returns a unique identifier for this Tensor.)_idr+s O/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/framework/ops.py tensor_idrUzs c$eZdZdZddZdefdZy)_UserDeviceSpeczEStore user-specified device and provide computation of merged device.rQNc||_t|j|_||_d|_t |t jr|j|_nt|rjd|_|j}tj|}tj|}|r|j}|j}nd}d}d|||fz|_nF|d|_n<||_t j||_|jj|_t |jt j|_y)NFunknownz %s<%s, %d>)_device_name_or_functionstr display_namefunction raw_string isinstancepydev MergeDevice is_null_mergecallabler: get_func_name get_func_code co_filenameco_firstlineno merge_devicefast_string_merge)selfdevice_name_or_functiondev_func func_name func_codefnamelinenos rT__init__z_UserDeviceSpec.__init__s$;D!D99:D+DMDO)5+<+<=2@@d ) * d..h ..x8i ..x8i %%))&)UF)CCd (!d0do(()@Adm==66d( u7H7HIDrVc|jr|jj|Stjt |j|SN)rkr_shortcut_string_merger7as_str_device_string)rlnode_defs rT string_mergez_UserDeviceSpec.string_merges=  ]] 0 0 :: == h(?@ AArVrQN)__name__ __module__ __qualname____doc__rsr]rzrVrTrXrXsM#JJBcBrVrXc(eZdZddZddZdefdZy)NullContextmanagerrQNcyrur)rlargskwargss rTrszNullContextmanager.__init__rVcyrurrls rT __enter__zNullContextmanager.__enter__rrVcyNFrrltype_arg value_arg traceback_args rT__exit__zNullContextmanager.__exit__s rVr{)r|r}r~rsrboolrrrVrTrrs  DrVrcFt|dd}|rt|r|Sy)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)getattrre)objconv_fns rTrrs( C,d 3' '" 9 rVc6t|tjSru)ra core_tf_typesTensor)ts rTis_dense_tensor_likers A}++ ,,rVc*tjS)z1A unique (within this program execution) integer.)r TFE_Py_UIDrrVrTuidrs     rVFc|jjri|j}|rKtj|r*t |t st|j}nt|}nt|}nd}d|vrd|z}|S)z8Human readable representation of a tensor's numpy value.  ) dtypeis_numpy_compatible_numpynpisscalarrabytesrepritemr])r,is_repr tensor_numpytexts rT numpy_textrsu \\%%==?L \ ":lE+JL%%'(L!  d D T\ $;D +rVc|jr|j}|rd|z}|St||}|rd|z}|S)aQEither the NumPy value or a custom TensorFlow formatting of `tensor`. Custom formatting is used for custom device tensors, e.g. parallel tensors with multiple components on different devices. Args: tensor: The tensor to format. is_repr: Controls the style/verbosity of formatting. Returns: The formatted tensor. zvalue=rznumpy=)_prefer_custom_summarizer_summarize_valuer)r,rrs rT value_textrsP %%'  " " $D _d + fg .D _d +rVz__internal__.SymbolicTensorc"eZdZdZdddZddZy)SymbolicTensorz.A symbolic tensor from a graph or tf.function.Nc| t}tjjt||t j ||Sru)rrPyTensor__new__rr&as_dtype)clsop value_indexr unique_ids rTrzSymbolicTensor.__new__s<%i  % % - -K)? rVc|j}|j||j|j|j|j }|j j|j |Sru) __class__rrrrrS__dict__update)rlrresults rT__copy__zSymbolicTensor.__copy__sN ..C [[dggt'7'7TXX NF OO4==) MrVru)rQr)r|r}r~rrrrrVrTrrs6rVrc t}tj}|jj t j |||||tj|jj}||d} |jdg|jg| |jd} tjr*tjdt| | f||} | | \} | S)z6Create a graph constant and invoke constant callbacks.)rshape verify_shapeallow_broadcasttype)valuerConst)attrsnamer)op_namegraph)get_default_graphr AttrValuer,CopyFromr/make_tensor_protor_create_op_internalroutputsr(should_invoke_op_callbacksinvoke_op_callbackstuple) rrrrrrg tensor_value dtype_valuer const_tensorcallback_outputss rT_create_graph_constantrs!))+,## uE )+,((l.A.A.G.GH+ ; 7%&& rK$$%U'??FwqJ,,,.$77%,$aI#'n| rVceZdZdZdefdZdefdZdefdZ defdZ de fdZ e Z defdZd Zd edefd Zd edefd Zdefd ZdefdZdefdZd5dej0fdZdefdZdej8fdZdej8fdZede jBfdZ"dej8fdZ#edZ$de%fdZ&de%fdZ'de%fdZ(de%fdZ)de%fdZ*e+d6dZ, d7d edefdZ- d7d edefdZ.ede/j`fd Z1de/j`fd!Z2de3efd"Z4e5jldd#d edefd$Z7e5jldd%d8d edefd&Z8d6d'Z9ede%fd(Z:ede%fd)Z;ede%fd*Zde%fd-Z?de%fd.Z@de%fd/ZAd7de%fd0ZB d7d1eCe jBd2eCedeDjffd3 ZFdeCeDjfd4ZGxZHS)9rMzBase class for EagerTensor.rQc4t|jSru)complexrrs rT __complex__z_EagerTensorBase.__complex__4s 4;;= !!rVc4t|jSru)intrrs rT__int__z_EagerTensorBase.__int__7s t{{} rVc4t|jSru)floatrrs rT __float__z_EagerTensorBase.__float__:s  rVcnttj|jj Sru)rrndarrayr __index__rs rTrz_EagerTensorBase.__index__=s"  DKKM * 4 4 66rVc|j}t|tjrt |j dkDxr|St |SNr)rrarrrsizerlxs rT__bool__z_EagerTensorBase.__bool__@s< A!RZZ !&&1*" ## !WnrVc|jr|jj|S|jjr|j j|Sdj|S)Nr)rr __format__rrr)rl format_specs rTrz_EagerTensorBase.__format__Is] %%'  " " $ / / <<  ' ' [[] % %k 22  ' ' 44rVc0t|jffSru)convert_to_tensorrrs rT __reduce__z_EagerTensorBase.__reduce__Rs t{{}. ..rVrlc|Srurrs rTrz_EagerTensorBase.__copy__U KrVc~|Srur)rlmemos rT __deepcopy__z_EagerTensorBase.__deepcopy__Ys  KrVcldt|dd|jd|jjdS)Nz tf.Tensor(Frz, shape=, dtype=))rrrrrs rT__str__z_EagerTensorBase.__str__^s(4'TZZ__ FFrVc ld|jd|jjdt|ddS)Nz)rrrrrs rT__repr__z_EagerTensorBase.__repr__bs( DJJOOZd%C EErVc|jjs td |jdS#tj $r}t j |dd}~wwxYw)z8Returns the length of the first dimension in the Tensor.zScalar tensor has no `len()`rN)rndims TypeError _shape_tupler _NotOkStatusException_status_to_exceptionrles rT__len__z_EagerTensorBase.__len__fs] ::   4 553     ##  % %3  % %a (d23s6A$ AA$Nc|j}|sttj|Stj||S)N)r)rrrrarray)rlras rT __array__z_EagerTensorBase.__array__ps2 A  "**a  88AU ##rVctd)Nz;Tensor is unhashable. Instead, use tensor.ref() as the key.)rrs rT__hash__z_EagerTensorBase.__hash__ws < ==rVctruNotImplementedErrorrs rT_numpy_internalz _EagerTensorBase._numpy_internal|  rVc |jS#tj$r}tj|dd}~wwxYwru)rr rrr s rTrz_EagerTensorBase._numpys?3  ! ! ##  % %3  % %a (d23sA;AcDtj|jSru)r& _INTERN_TABLE_datatype_enumrs rTrz_EagerTensorBase.dtypes    3 3 5 66rVcz|j}t|tjr|j S|S)aCopy of the contents of this Tensor into a NumPy array or scalar. Unlike NumPy arrays, Tensors are immutable, so this method has to copy the contents to ensure safety. Use `memoryview` to get a readonly view of the contents without doing a copy: >>> t = tf.constant([42]) >>> np.asarray(memoryview(t)) array([42], dtype=int32) Note that `memoryview` is only zero-copy for Tensors on CPU. If a Tensor is on GPU, it will have to be transferred to CPU first in order for `memoryview` to work. Returns: A NumPy array of the same shape and dtype or a NumPy scalar, if this Tensor has rank 0. Raises: ValueError: If the dtype of this Tensor does not have a compatible NumPy dtype. )rrarrcopy)rl maybe_arrs rTnumpyz_EagerTensorBase.numpys.0 I))RZZ@9>> OiOrVct)aReturns the name of the device holding this tensor's memory. `.backing_device` is usually the same as `.device`, which returns the device on which the kernel of the operation that produced this tensor ran. However, some operations can produce tensors on a different device (e.g., an operation that executes on the GPU but produces output tensors in host memory). rrs rTbacking_devicez_EagerTensorBase.backing_device   rVctrurrs rTrz_EagerTensorBase._datatype_enumrrVct)aThe shape of this Tensor, as a tuple. This is more performant than tuple(shape().as_list()) as it avoids two list and one object creation. Marked private for now as from an API perspective, it would be better to have a single performant way of getting a shape rather than exposing shape() and shape_tuple() (and heaven forbid, shape_list() etc. as well!). Punting on that for now, but ideally one would work things out and remove the need for this method. Returns: tuple with the shape. rrs rTrz_EagerTensorBase._shape_tuples   rVct)zInteger rank of this Tensor. Unlike regular Tensors, the rank is always known for EagerTensors. This is more performant than len(self._shape_tuple()) Returns: Integer rank rrs rT_rankz_EagerTensorBase._rankr!rVct)zNumber of elements of this Tensor. Unlike regular Tensors, the number of elements is always known for EagerTensors. This is more performant than tensor.shape.num_elements Returns: Long - num elements in the tensor rrs rT _num_elementsz_EagerTensorBase._num_elementss   rVctrur)rl device_names rT_copy_to_devicez _EagerTensorBase._copy_to_devicerrVc&tt||yru)setattrrM)rfuncs rT_override_operatorz#_EagerTensorBase._override_operators dD)rVc|tj}| |j} |j|j|}|S#tj $r}t j |dd}~wwxYw)z?Copies tensor to dest device, but doesn't record the operation.N)rr)ensure_initializedr*r rr)rlctxr) new_tensorr s rT _copy_nogradz_EagerTensorBase._copy_nogradsx  { OO cOOk3 '' 4j   % %3  % %a (d23s!A A7A22A7c|j||}tjr+|jfd}t j d|g|g||S)zCopies tensor to dest device.cHt|dr|jgS|gS)N_copyr))hasattrr6)dresult self_devices rTgrad_funz(_EagerTensorBase._copy..grad_funs6w( MMkM 2  .5  rVr6)r3rexecuting_eagerlyr%r"record_operation)rlr1r)r2r;r:s @rTr6z_EagerTensorBase._copysQ""3 4J  "KKk  g |dVXF rVc|j5 tj|j|_|jS|jS#tj $r}t j |dd}~wwxYwru) _tensor_shaper. TensorShaperr rrr s rTrz_EagerTensorBase.shapesu !5*55d6G6G6IJ   4   ' '5''*45s(AA<!A77A<c|jS)zAlias of Tensor.shape.rrs rT get_shapez_EagerTensorBase.get_shape ::rVc4t|jS)z"The shape of the tensor as a list.)listrrs rT_shape_as_listz_EagerTensorBase._shape_as_lists !!# $$rVz7Use tf.identity with explicit device placement instead.cJ|jtjdS)z:A copy of this Tensor with contents backed by host memory.zCPU:0)r6rrs rTcpuz_EagerTensorBase.cpus ::goo' 11rVzUse tf.identity instead.cb|jtjdt|zS)aA copy of this Tensor with contents backed by memory on the GPU. Args: gpu_index: Identifies which GPU to place the contents on the returned Tensor in. Returns: A GPU-memory backed Tensor object initialized with the same contents as this Tensor. zGPU:)r6rr])rl gpu_indexs rTgpuz_EagerTensorBase.gpu#s% ::goo'#i.)@ AArVcNtj|}|j}|y|jj}t |t |k7rt d|jd|dt ||D])\}}| ||k7st d|jd|dy)NzTensor's shape z' is not compatible with supplied shape .)r.as_shape_dimsrlen ValueErrorzip)rlr shape_dims self_dims shape_dimself_dims rT set_shapez_EagerTensorBase.set_shape1s  ! !% (EJ    I :#i.(  5..3WA7 88":y9: 8  8y#8?4::,7005wa9: ::rVctd)Nz7Tensor.op is undefined when eager execution is enabled.AttributeErrorrs rTrz_EagerTensorBase.opBs A CCrVctd)Nz:Tensor.graph is undefined when eager execution is enabled.rZrs rTrz_EagerTensorBase.graphGs D FFrVctd)Nz9Tensor.name is undefined when eager execution is enabled.rZrs rTrz_EagerTensorBase.nameLs C EErVctd)Nz@Tensor.value_index is undefined when eager execution is enabled.rZrs rTrz_EagerTensorBase.value_indexQs J LLrVctd)Nz>Tensor.consumers is undefined when eager execution is enabled.rrs rT consumersz_EagerTensorBase.consumersVs H JJrVctd)Nz<_add_consumer not supported when eager execution is enabled.r)rlconsumers rT _add_consumerz_EagerTensorBase._add_consumerZ F HHrVctd)NzA_as_node_def_input not supported when eager execution is enabled.rrs rT_as_node_def_inputz#_EagerTensorBase._as_node_def_input^s K MMrVctd)Nz<_as_tf_output not supported when eager execution is enabled.rrs rT _as_tf_outputz_EagerTensorBase._as_tf_outputbrdrVctd)Nz[eval is not supported when eager execution is enabled, is .numpy() what you're looking for?rrl feed_dictsessions rTevalz_EagerTensorBase.evalfs  / 00rVrrctjs?t}|jst t d||j ||St|!||S)NzAAttempting to capture an EagerTensor without building a function.r) rr<rbuilding_function RuntimeError_add_error_prefixcapturesuper __tf_tensor__)rlrrrrs rTruz_EagerTensorBase.__tf_tensor__ksf  $ $ &!e  $ $ '   ]]4d] ++ 7  --rVc td5tj|}| dddyt||j|j |dd}ddd|S#1swYSxYw)z3Capture the EagerTensor to a graph constant tensor.NFT)rrrrr)control_dependenciesr/constant_valuerrr)rlrrxrs rT_capture_as_constz"_EagerTensorBase._capture_as_constysq d # 4"11$7n   4 4,  $**4d4l 4  4 sA%AA'rur{NNr)Ir|r}r~rrrrrrrrrr __nonzero__r]rrrLrrrrr rrrrnpt ArrayLikerrpropertyr&DTyperrr r rrr%r'r* staticmethodr.r3r6r.r@rrCrFrGr9 deprecatedrIrLrXrrrrr`rcrfrhrmr tensor_librrury __classcell__rs@rTrMrM.sl#"7"s  77+5s5/_? FsFEE3s3$RZZ$==  s}} 3cmm3  7V\\7 7 PS]]P6       h   H    X    X   H **48 $48 &  \--   11%d3i%; EG22O2G2;$ :; B B B< B :" C(C C FXF F EHE E L8L LJJHxHM(MHXH0(0 IM .FLL) .8@  .    . x 0A0A'B rVz__internal__.EagerTensor)v1romsgrc||S|d|S)N: r)rrs rTrrrrs 2TF"SE"22rVc &t|tstdt||s t d|dj }|dj }|dj}|tjk(}tt|D]}||}t|tstdt|d|j |k7rt d|d|d|j |j |k7rt d |d|d |j |s|j|k7st d |d|d |j|tj}|j|}|||_d } tj d|g|| |S)zPack multiple `EagerTensor`s of the same dtype and shape. Args: tensors: a list of EagerTensors to pack. ctx: context.context(). Returns: A packed EagerTensor. z"tensors must be a list, but got a z%Cannot pack an empty list of tensors.rzDAll tensors being packed must be EagerTensor. Found an item of type rNz4All tensors being packed should have the same dtype z , but the z-th tensor is of dtype z4All tensors being packed should have the same shape z-th tensor is of shape z:All tensors being packed should have the same handle data z-th tensor is of handle data ctd)Nz@Computing gradients through pack_eager_tensors is not supported.)rR_s rTr;z$pack_eager_tensors..grad_funs J LLrVpack_eager_tensors)rarFrrrRrr _handle_datar&resourcerangerQ EagerTensorrrr"r=) tensorsr1rr handle_data is_resourceir packed_tensorr;s rTrrs GT " 8gH II  < == !*  % !*  % ''+(+ W Ga A a % //3Awiq: ;; ww%  @HC.qwwi 9 :: ww%  @HC.qwwi 9 ::q~~4  F MC4Q^^4D F GG!G, [ // C((1-!,ML ."$ rVrcB|xs|}tj||||||S)z/Implementation of the public convert_to_tensor.)r-convert)rrras_refpreferred_dtype dtype_hintr1accepted_result_typess rTrrs/$1z/ # + + UD&/3H rV.internal_convert_to_tensorc t|tjs tdg}t |D]/\}}|dnd||fz} |j t ||| ||1|S)a:Converts `values` to a list of `Tensor` objects. Args: values: A list of objects that can be consumed by `tf.convert_to_tensor()`. dtype: (Optional.) The required `DType` of the returned `Tensor` objects. name: (Optional.) A name prefix to used when a new `Tensor` is created, in which case element `i` will be given the name `name + '_' + i`. as_ref: True if the caller wants the results as ref tensors. preferred_dtype: Optional element type for the returned tensors, used when dtype is None. In some cases, a caller may not have a dtype in mind when converting to a tensor, so preferred_dtype can be used as a soft preference. If the conversion to `preferred_dtype` is not possible, this argument has no effect. ctx: Unused. Present for API backwards compatibility. Returns: A list of `Tensor` and/or `IndexedSlices` objects. Raises: TypeError: If no conversion function is registered for an element in `values`. RuntimeError: If a registered conversion function returns an invalid value. values must be a sequence.N%s_%d)rrrr)rar@rr enumerateappendr) valuesrrrrr1retrrns rTinternal_convert_n_to_tensorrs|@ FO44 5 0 11 #F#.ha 'T1I"5AJJ +  -.. *rVc"t||||dS)aConverts `values` to a list of `Tensor` objects. Args: values: A list of objects that can be consumed by `tf.convert_to_tensor()`. dtype: (Optional.) The required `DType` of the returned `Tensor` objects. name: (Optional.) A name prefix to used when a new `Tensor` is created, in which case element `i` will be given the name `name + '_' + i`. preferred_dtype: Optional element type for the returned tensors, used when dtype is None. In some cases, a caller may not have a dtype in mind when converting to a tensor, so preferred_dtype can be used as a soft preference. If the conversion to `preferred_dtype` is not possible, this argument has no effect. Returns: A list of `Tensor` and/or `IndexedSlices` objects. Raises: TypeError: If no conversion function is registered for an element in `values`. RuntimeError: If a registered conversion function returns an invalid value. F)rrrrr)r)rrrrs rTconvert_n_to_tensorrs 2 &   %   rVc t|||dS)ajConverts the given object to a `Tensor` or `CompositeTensor`. If `value` is a `CompositeTensor` it is returned unmodified. Otherwise, it is converted to a `Tensor` using `convert_to_tensor()`. Args: value: A `CompositeTensor` or an object that can be consumed by `convert_to_tensor()`. dtype: (Optional.) The required `DType` of the returned `Tensor` or `CompositeTensor`. name: (Optional.) A name to use if a new `Tensor` is created. Returns: A `Tensor` or `CompositeTensor`, based on `value`. Raises: ValueError: If `dtype` does not match the element type of `value`. F)rrrr)'internal_convert_to_tensor_or_composite)rrrs rTconvert_to_tensor_or_compositer9s* 1 T% 99rVct|tjrzt|dd}|rit j |j |sEtdt j |jd|jjd||St||||tjtjfS)aConverts the given object to a `Tensor` or `CompositeTensor`. If `value` is a `CompositeTensor` it is returned unmodified. Otherwise, it is converted to a `Tensor` using `convert_to_tensor()`. Args: value: A `CompositeTensor`, or an object that can be consumed by `convert_to_tensor()`. dtype: (Optional.) The required `DType` of the returned `Tensor` or `CompositeTensor`. name: (Optional.) A name to use if a new `Tensor` is created. as_ref: True if the caller wants the results as ref tensors. Returns: A `Tensor` or `CompositeTensor`, based on `value`. Raises: ValueError: If `dtype` does not match the element type of `value`. rNz5Tensor conversion dtype mismatch. Requested dtype is z, Tensor has dtype r)rrrr) rar$CompositeTensorrr&ris_compatible_withrRrrrrr)rrrr value_dtypes rTrrRs0'778%$/K V__U+>>{K --3__U-C-H-H,IJ++0;;+;+;*(  #1mmA"# /rVz!^[A-Za-z0-9.][A-Za-z0-9_.\\/>-]*$_VALID_OP_NAME_REGEXz^[A-Za-z0-9_.\\/>-]*$_VALID_SCOPE_NAME_REGEXz__internal__.create_c_opc ||j|j}t|||j}|jj 5}t j|tj|jtj|j}ddd|jr3t jtj|j|D]o}t|ttfr3t j |D cgc]} | j#c} Lt j$|j#q|D]"} t j&| j($|jj+D]?\} } | j-} t j.tj| | A t j0}|r*t j:|t=j>d|S#1swYxYwcc} w#t2j4$r}t7|j8d}~wwxYw)ahCreates a TF_Operation. Args: graph: a `Graph`. node_def: `node_def_pb2.NodeDef` for the operation to create. inputs: A flattened list of `Tensor`s. This function handles grouping tensors into lists as per attributes in the `node_def`. control_inputs: A list of `Operation`s to set as control dependencies. op_def: Optional. `op_def_pb2.OpDef` for the operation to create. If not specified, is looked up from the `graph` using `node_def.op`. extract_traceback: if True, extract the current Python traceback to the TF_Operation. Returns: A wrapped TF_Operation*. N) stacklevel) op_def_for_typer_reconstruct_sequence_inputsr_c_graphgetrTF_NewOperationr7rwrr% TF_SetDevicerarFrTF_AddInputListrh TF_AddInputTF_AddControlInput_c_oprSerializeToStringTF_SetAttrValueProtoTF_FinishOperationr'InvalidArgumentErrorrRrTF_SetOpStackTracer> extract_stack)rryinputscontrol_inputsop_defextract_tracebackc_graphop_descop_inputr control_inputr attr_value serializedc_opr s rT _create_c_oprs0 ^  " "8;; /F ( F& ~~Nw//06 hkk0J06 hmm0LNGN__""7FMM(//,JKGh(T5M*''DL(Mq):(MO##GX-C-C-EF G&Gm((-2E2EFG #----/7dJ--/J**7FMM$4G+57 7  / / 8D(( h$$2 +QNN)N&  $ $ QYY  s+AH#H0 H5#H-5I"II"ceZdZdZe d+deedefdZedeedefdZd,dZ d-d.dZ de e fd Z deed ffd Zd Zd.d ZedefdZedefdZede ej2fdZedeeej2ffdZede efdZd.dZd.dZd.dZ defdZ!defdZ"d/de#fdZ$ede%e&jNfdZ(ede e)jTfdZ+edZ,ede-j\fdZ/ede0jbfdZ2d.dZ3d.dZ4d.d Z5d.d!Z6d.d"Z7d.d#Z8d.d$Z9d%Z:de)jTfd&Z;ded.d)Z?d/d.d*Z@y)0rKaRepresents a graph node that performs computation on tensors. An `Operation` is a node in a `tf.Graph` that takes zero or more `Tensor` objects as input, and produces zero or more `Tensor` objects as output. Objects of type `Operation` are created by calling a Python op constructor (such as `tf.matmul`) within a `tf.function` or under a `tf.Graph.as_default` context manager. For example, within a `tf.function`, `c = tf.matmul(a, b)` creates an `Operation` of type "MatMul" that takes tensors `a` and `b` as input, and produces `c` as output. If a `tf.compat.v1.Session` is used, an `Operation` of a `tf.Graph` can be executed by passing it to `tf.Session.run`. `op.run()` is a shortcut for calling `tf.compat.v1.get_default_session().run(op)`. NrrQc "t|tstdt|t|tj stdt|d|j dk\s|j dkrtd|j dtj|js td|jd td ~|g}n't|tstd t||D]4} t| tjrtd t| d|$|D cgc]} | jj}} nSt!dt#||Ds7td|jd|D cgc]} | jc} d|dg} |r||D]w} d } t| t$r| } nOt| tjt&j(fr | j*} ntdt| d| j-| yt/|||| |}t%|t0}|j3|||_|j7||Scc} wcc} w)a<Creates an `Operation`. NOTE: This constructor validates the name of the `Operation` (passed as `node_def.name`). Valid `Operation` names match the following regular expression: [A-Za-z0-9.][A-Za-z0-9_.\\-/]* Args: node_def: `node_def_pb2.NodeDef`. `NodeDef` for the `Operation`. Used for attributes of `node_def_pb2.NodeDef`, typically `name`, `op`, and `device`. The `input` attribute is irrelevant here as it will be computed when generating the model. g: `Graph`. The parent graph. inputs: list of `Tensor` objects. The inputs to this `Operation`. output_types: list of `DType` objects. List of the types of the `Tensors` computed by this operation. The length of this list indicates the number of output endpoints of the `Operation`. control_inputs: list of operations or tensors from which to have a control dependency. input_types: List of `DType` objects representing the types of the tensors accepted by the `Operation`. By default uses `[x.dtype.base_dtype for x in inputs]`. Operations that expect reference-typed inputs must specify these explicitly. original_op: Optional. Used to associate the new `Operation` with an existing `Operation` (for example, a replica with the op that was replicated). op_def: Optional. The `op_def_pb2.OpDef` proto that describes the op type that this `Operation` represents. Raises: TypeError: if control inputs are not Operations or Tensors, or if `node_def` is not a `NodeDef`, or if `g` is not a `Graph`, or if `inputs` are not tensors, or if `inputs` and `input_types` are incompatible. ValueError: if the `node_def` name is not valid. Returns: Operation object. z9Argument g must be a Graph. Received an instance of type zCArgument node_def must be a NodeDef. Received an instance of type: rNrzQCannot create a tensor proto whose content is larger than 2GB. Size of tensor is z bytes.`z=` is not a valid node name. Accepted names conform to Regex //NzIArgument inputs shall be a list of Tensors. Received an instance of type zGItems of argument inputs shall be Tensor. Received an instance of type c3XK|]"\}}|j|j$ywru)rr).0rrs rT z*Operation.from_node_def..s*N,0Aq!  qww 'Ns(*zIn op 'z', input types (z*) are not compatible with expected types (rz]Control input must be an Operation, a Tensor, or IndexedSlices. Received an instance of type )r) input_tensors)rarFrrrrByteSizerRrmatchrrFrrr base_dtypeallrSrKr6 IndexedSlicesrrrr_init _original_op_control_flow_post_processing)rryrr output_typesr input_types original_oprrrcontrol_input_opsc control_oprrls rT from_node_defzOperation.from_node_defCsj a  66:1gY@ AA h 4 4 5 77;H~6FaI JJw'8+<+<+>+B  '00237 < == % %hmm 4  hmm_..B-C1 F GG  ~f  % 66:6l^E FF D :,, -88q'!EF F   , - 8V->v ND T> *DJJqM#D &&V&< KC9 )Bs JJ cHt|t}|j||S)a1Create an Operation from a TF_Operation. For internal use only: This is useful for creating Operation for ops indirectly created by C API methods, e.g. the ops created by TF_ImportGraphDef. Args: c_op: a TF_Operation. g: A Graph. Returns: an Operation object. )rKrr)rrrrls rT _from_c_opzOperation._from_c_ops  T> *DJJqM KrVc||_d|_d|_d|_d|_|jj |_d|_|j|jj||_ y)z*Initializes Operation from a TF_Operation.N) rr _inputs_val_device_code_locations_colocation_code_locations_get_control_flow_context_control_flow_context_gradient_function _init_outputs_add_op _id_value)rlrs rTrzOperation._initspDJDD#'D'+D#!%!E!E!GD#DZZ''-DNrVc| |j}|D]"}tj||j$|j|jj |yy)aAdd this op to its control flow context. This may add new ops and change this op's inputs. self.inputs must be available before calling this method. Args: input_tensors: (Optional.) A list of `Tensors` corresponding to the inputs of this op, which should be equivalent to `self.inputs`. Pass this argument to avoid evaluating `self.inputs` unnecessarily. N)rr2CheckInputFromValidContextrrAddOp)rlr input_tensors rTrz'Operation._control_flow_post_processings]kkm%J 224IJ !!-   &&t,.rVctjd|jzg} |jd}|Dcgc]}|j dr|}}|r|S|S#t$r|cYSwxYwcc}w)z0Returns the list of colocation groups of the op.zloc:@%s_classsloc:@)r7rrget_attrrR startswith)rldefault_colocation_group class_attr class_name attr_groupss rTcolocation_groupszOperation.colocation_groupss & DII0E FG&==*j&0!   * K&;C+CC &&%& sAA- A*)A*.c,t|jS)zDEPRECATED: Use outputs.)rrrs rTrzOperation.values s  rVc|jS)zWReturns the control flow context of this op. Returns: A context object. rrs rTrz#Operation._get_control_flow_context  % %%rVc||_y)z^Sets the current control flow context of this op. Args: ctx: a context object. Nrrlr1s rT_set_control_flow_contextz#Operation._set_control_flow_context "%DrVc|jS)z(The unique integer id of this operation.)rrs rTrSz Operation._id!s >>rVc@tj|jS)zThe name of the device to which this op has been assigned, if any. Returns: The string name of the device to which this op has been assigned, or an empty string if it has not been assigned to a device. )rTF_OperationDevicerrs rTr%zOperation.device&s  / / ;;rVc"|jxsgS)aCode locations for device context managers active at op creation. This property will return a list of traceable_stack.TraceableObject instances where .obj is a string representing the assigned device (or information about the function that would be applied to this op to compute the desired device) and the filename and lineno members record the location of the relevant device context manager. For example, suppose file_a contained these lines: file_a.py: 15: with tf.device('/gpu:0'): 16: node_b = tf.constant(4, name='NODE_B') Then a TraceableObject t_obj representing the device context manager would have these member values: t_obj.obj -> '/gpu:0' t_obj.filename = 'file_a.py' t_obj.lineno = 15 and node_b.op._device_assignments would return the list [t_obj]. Returns: [str: traceable_stack.TraceableObject, ...] as per this method's description, above. )rrs rT_device_assignmentszOperation._device_assignments1s:  & & ,",rVcB|jxsi}|jS)a)Code locations for colocation context managers active at op creation. This property will return a dictionary for which the keys are nodes with which this Operation is colocated, and for which the values are traceable_stack.TraceableObject instances. The TraceableObject instances record the location of the relevant colocation context manager but have the "obj" field set to None to prevent leaking private data. For example, suppose file_a contained these lines: file_a.py: 14: node_a = tf.constant(3, name='NODE_A') 15: with tf.compat.v1.colocate_with(node_a): 16: node_b = tf.constant(4, name='NODE_B') Then a TraceableObject t_obj representing the colocation context manager would have these member values: t_obj.obj -> None t_obj.filename = 'file_a.py' t_obj.lineno = 15 and node_b.op._colocation_dict would return the dictionary { 'NODE_A': t_obj } Returns: {str: traceable_stack.TraceableObject} as per this method's description, above. )rr)rllocations_dicts rT_colocation_dictzOperation._colocation_dictPs$@44:N     rVc tj|j}t|Dcgc]/}t tj |j |1}}|Scc}w)aVList this operation's output types. Returns: List of the types of the Tensors computed by this operation. Each element in the list is an integer whose value is one of the TF_DataType enums defined in pywrap_tf_session.h The length of this list indicates the number of output endpoints of the operation. )rTF_OperationNumOutputsrrrTF_OperationOutputType _tf_output)rl num_outputsrrs rT _output_typeszOperation._output_typesssc$::4::FK{#   4 4T__Q5G HIL  s4A%c^|jtjt|y)zfSet the device of this operation. Args: device: string or device.. The device to set. N)_set_device_from_stringr7rwrx)rlr%s rT _set_devicezOperation._set_devices    ~f/E!FGrVcTt|tjstd|zt ||d|_|j jj5}tj||j|j|dddy#1swYyxYw)aUpdate the input to this operation at the given index. NOTE: This is for TF internal use only. Please don't use it. Args: index: the index of the input to update. tensor: the Tensor to be used as the input at the given index. Raises: TypeError: if tensor is not a Tensor, or if input tensor type is not convertible to dtype. ValueError: if the Tensor is from a different graph. tensor must be a Tensor: %sN) rarrr_assert_same_graphrrrrr UpdateEdgerh _tf_input)rlindexr,rs rT _update_inputzOperation._update_inputs fj// 0 3f< ==tV$D    "!g""     .. !!!!s 5BB'cZ|jjj5}|D]l}t|tj st d|zt||d|_tj||j|jn dddy#1swYyxYw)aHSee AddWhileInputHack in python_api.h. NOTE: This is for TF internal use only. Please don't use it. Args: tensors: list of Tensors Raises: TypeError: if tensor is not a Tensor, or if input tensor type is not convertible to dtype. ValueError: if the Tensor is from a different graph. r.N) rrrrarrrr/rrAddWhileInputHackrhr)rlrrr,s rT_add_while_inputszOperation._add_while_inputss    " g &&*"3"347&@A A4( ++   " JJ     s A2B!!B*c,t|jSru)r]ryrs rTrzOperation.__str__s t}} rVc<d|jd|jdS)Nz.s*E ** - -a 0Es%()rrrGetOperationInputsrrs`rTrzOperation.inputssK E$77 CEEd   rVc tj|j}t|Dcgc]9}t j tj |j|;}}|Scc}wru)rTF_OperationNumInputsrrr&rTF_OperationInputTyper1)rl num_inputsrrs rT _input_typeszOperation._input_typessj"88DJz"    3 3DNN14E F HK  s>A/c@tj|jS)z@Returns the call stack from when this operation was constructed.)rTF_OperationGetStackTracerrs rT tracebackzOperation.tracebacks  6 6tzz BBrVcTtjj|jSru)rr FromString _node_defrs rTryzOperation.node_defs    * *4>> ::rVcTtjj|jSru)rOpDefrH_op_defrs rTrzOperation.op_defs    & &t|| 44rVctjtj|j } |j ||tj |y#tj |wxYw)z8Private method used to set an attribute in the node_def.N)rTF_NewBufferFromStringr7rr_set_attr_with_bufTF_DeleteBuffer)rl attr_namerbufs rT _set_attrzOperation._set_attrsZ  2 2 4467 9C- i-'','',s A A7c|jjj5}tj||j ||dddy#1swYyxYw)z8Set an attr in the node_def with a pre-allocated buffer.N)rrrrSetAttrr)rlrQattr_bufrs rTrOzOperation._set_attr_with_bufsK    "JgYIJJJs #AAc|tj|}|j|tj|y)z@Private method used to set a function attribute in the node_def.ror-N)r NameAttrListrSr)rlrQror-s rT_set_func_attrzOperation._set_func_attrs+  & &I 6DNN9n66DABrVc|Dcgc]}tj|}}tjj|}|j |tj|ycc}w)zFPrivate method used to set a list(function) attribute in the node_def.rorXrFN)rrYr ListValuerS)rlrQ func_namesrofuncs funcs_lists rT_set_func_list_attrzOperation._set_func_list_attrsc) * ( (i 8 *E *))333?JNN9n66JGH *sA+c |syt|dtjr|Dcgc]}|j}}tj j |}|j|t j |ycc}w)zBPrivate method used to set a list(type) attribute in the node_def.Nrrr\)rar&ras_datatype_enumrrr]rS)rlrQ data_typesdt types_lists rT_set_type_list_attrzOperation._set_type_list_attr sj  *Q-.2<=BB''=j=))333DJNN9n66JGH>sBc|Dcgc]}|j}}tjj|}|j |tj|ycc}w)zCPrivate method used to set a list(shape) attribute in the node_def.rBr\N)as_protorrr]rS)rlrQshapess shapes_lists rT_set_shape_list_attrzOperation._set_shape_list_attrsR$* +qajjl +F + **4464BKNN9n66KHI,sA%c|jjj5}tj||j |dddy#1swYyxYw)z:Private method used to clear an attribute in the node_def.N)rrrr ClearAttrr)rlrQrs rT _clear_attrzOperation._clear_attrsI    "Bg!!'4::yABBBs "AAc:d} tj5}tj|j||tj |}dddtj}|j|jd}|gS|dk(r~|D]w}t|j|s|dk(r9|jj D cgc]} t#j$| c} cStt|j|cSgS|dk(rt#j$|j S||vsJdt'|zt||S#1swYxYw#t j$r}t|jd}~wwxYwcc} w)aReturns the value of the attr of this op with the given `name`. Args: name: The name of the attr to fetch. Returns: The value of the attr, as a Python object. Raises: ValueError: If this op does not have an attr with the given `name`. )rkrfbrrr,r-NrrFrzUnsupported field type in )r# tf_bufferrTF_OperationGetAttrValueProtor TF_GetBufferr'rrRrrrParseFromString WhichOneofrrFrr&rr]) rlrfieldsrRdatar r oneof_valuerrrs rTr zOperation.get_attr#siEF"    !3S77 D#N --c23   "Ad,,w'K if,! 1661  &[01 <1FOOA&< <*+ + , if __QVV $$ & G">Q"GG 1k ""/33  & &" qyy !!"=s4E(7EE(FE% E((F;FFc tj|j|}t|S#tj $r}t |jd}~wwxYw)zGReturns the `DType` value of the attr of this op with the given `name`.N)rTF_OperationGetAttrTyperrPr'rrRr)rlr dtype_enumr s rT_get_attr_typezOperation._get_attr_typeJsM"$< ?G:%%gtzz:FG GG GG GGs$A2C"C 9C C CCc4t|||j|y)a~Runs this operation in a `Session`. Calling this method will execute all preceding operations that produce the inputs needed for this operation. *N.B.* Before invoking `Operation.run()`, its graph must have been launched in a session, and either a default session must be available, or `session` must be specified explicitly. Args: feed_dict: A dictionary that maps `Tensor` objects to feed values. See `tf.Session.run` for a description of the valid feed values. session: (Optional.) The `Session` to be used to run to this operation. If none, the default session will be used. N)_run_using_default_sessionrrjs rTrunz Operation.runvs tY GDrV)NNNNNN)rrFrQNrur{rz)Ar|r}r~r classmethodrrJrrrrrFrrrrrrrrrrSr]r%r0TraceableObjectr dictr#r)r,r3r6rrr rurrrrr&rrCrFrrryrrKrrSrOrZrargrmrpr rrrrrrrrVrTrKrK0s"  u  uuund=)}$.4-$DeD&eCHo&% 3  Registers the function `f` as gradient function for `op_type`.)rregisterrrlrrs rT__call__zRegisterGradient.__call__sq$--0 HrVNr|r}r~r __slots__rsrDrrrVrTrrs(0l)   r rVNotDifferentiable NoGradient no_gradient)rrrrcft|ts tdtj d|y)a<Specifies that ops of type `op_type` is not differentiable. This function should *not* be used for operations that have a well-defined gradient that is not yet implemented. This function is only used when defining a new op type. It may be used for ops such as `tf.size()` that are not differentiable. For example: ```python tf.no_gradient("Size") ``` The gradient computed for 'op_type' will then propagate zeros. For ops that have a well-defined gradient but are not yet implemented, no declaration should be made, and an error *must* be thrown if an attempt to request its gradient is made. Args: op_type: The string type of an operation. This corresponds to the `OpDef.name` field for the proto that defines the operation. Raises: TypeError: If `op_type` is not a string. rN)rar]rrr)rs rTrrs*< GS ! . //T7+rVc|jsy|j}|r|S |jd}t j |S#t$r|j}Y,wxYw)z6Returns the function that computes gradients for "op".N_gradient_op_type)rrr rRrrlookup)rgradient_functionrs rTget_gradient_functionrsb  ++ kk-.G  ! !' ** ggGsAAAcy)z%No op. TODO(b/74620627): Remove this.Nrrs rT%set_shape_and_handle_data_for_outputsrsrVceZdZdZddgZdddZedZejdZed Z e jd Z d e d e de fd Z y)rIa6A holder for statistics about an operator. This class holds information about the resource requirements for an op, including the size of its weight parameters on-disk and how many FLOPS it requires to execute forward inference. If you define a new operation, you can create a function that will return a set of information about its usage of the CPU and disk space when serialized. The function itself takes a Graph object that's been set up so you can call methods like get_tensor_by_name to help calculate the results, and a NodeDef argument. _statistic_type_valueNrQc ||_||_y)z4Sets up the initial placeholders for the statistics.N)statistic_typer)rlrrs rTrszOpStats.__init__ s(DDJrVc|jSrurrs rTrzOpStats.statistic_types   rVc||_yrur)rlrs rTrzOpStats.statistic_types )DrVc|jSrurrs rTrz OpStats.values ;;rVc||_yrur)rlrs rTrz OpStats.values DKrVrlotherc|j|jk7r&td|jd|jd|j|j|_|S|j|xj|jz c_|S)NzCan't add an OpStat of type z to one of rN)rrRrr)rlrs rT__iadd__zOpStats.__iadd__!s{ t222 ++U-A-AC DD zz;;dj K   kkU[[ k KrVrur{) r|r}r~rrrsrrsetterrrHrrrVrTrIrIs !(+)     **   <<[rVzstatistical functions_stats_registryc0eZdZdZddgZd dZdedefdZy) RegisterStatisticsaqA decorator for registering the statistics function for an op type. This decorator can be defined for an op type so that it gives a report on the resources used by an instance of an operator, in the form of an OpStats object. Well-known types of statistics include these so far: - flops: When running a graph, the bulk of the computation happens doing numerical calculations like matrix multiplications. This type allows a node to return how many floating-point operations it takes to complete. The total number of FLOPs for a graph is a good guide to its expected latency. You can add your own statistics just by picking a new type string, registering functions for the ops you care about, and then calling get_stats_for_node_def. If a statistic for an op is registered multiple times, a KeyError will be raised. Since the statistics is counted on a per-op basis. It is not suitable for model parameters (capacity), which is expected to be counted only once, even if it is shared by multiple ops. (e.g. RNN) For example, you can define a new metric called doohickey for a Foo operation by placing this in your code: ```python @ops.RegisterStatistics("Foo", "doohickey") def _calc_foo_bojangles(unused_graph, unused_node_def): return ops.OpStats("doohickey", 20) ``` Then in client code you can retrieve the value by making this call: ```python doohickey = ops.get_stats_for_node_def(graph, node_def, "doohickey") ``` If the NodeDef is for an op with a registered doohickey function, you'll get back the calculated amount in doohickey.value, or None if it's not defined. rrrQNct|ts tdd|vr td||_t|ts tdd|vr td||_y)z,Saves the `op_type` as the `Operation` type.zop_type must be a string.,z!op_type must not contain a comma.z statistic_type must be a string.z(statistic_type must not contain a comma.N)rar]rrr)rlrrs rTrszRegisterStatistics.__init__]sd gs # 1 22 g~ 9 ::DM nc * 8 99 n @ AA)DrVrrcftj||jdz|jz|S)z7Registers "f" as the statistics function for "op_type".r)rrrrrs rTrzRegisterStatistics.__call__js+Q  3d6J6J JK HrVr{rrrVrTrr/s-)V,-) *  r rVrc tj|jdz|z}|||}|S#t$rt |}Y|SwxYw)a_Looks up the node's statistics function in the registry and calls it. This function takes a Graph object and a NodeDef from a GraphDef, and if there's an associated statistics method, calls it and returns a result. If no function has been registered for the particular node type, it returns an empty statistics object. Args: graph: A Graph object that's been set up with the node's graph. node: A NodeDef describing the operator. statistic_type: A string identifying the statistic we're interested in. Returns: An OpStats object containing information about resource usage. r)rrr LookupErrorrI)rnoder stats_funcrs rTget_stats_for_node_defrpsW"% ''# (FGJ t $F - % ^ $F -%s.2A  A c$|r |ddk(r|ddS|S)zReturns the name of an op given the name of its scope. Args: name: the name of the scope. Returns: the name of the op (equal to scope name minus any trailing slash). r[rNrros rTname_from_scope_namers!RCcr:d:rV_MUTATION_LOCK_GROUP_SESSION_RUN_LOCK_GROUPc#rKtj||5ddddy#1swYyxYwwru)r_resource_creator_scope) resource_typeresource_creators rTresource_creator_scopers422=3CE     s7+ 747c4 eZdZdZdnfd ZedZdedefdZdndZ dedefd Z e jdode dfd Ze jde dfd Zedeeeed efffd Zej,deeeed effddfdZedeeeed efffdZej,deeeed effddfdZdndZedej8fdZedeefdZej,deddfdZede fdZ!dndZ"dndZ#dZ$dndZ%dndZ& dpdee'jPeffdZ) dpde'jPfdZ*de fd Z+d!Z,dqdnd"Z-dnd#Z.dnd$Z/ede fd%Z0e1dd&d'e2jf dr dsd)Z4 dt dsd*Z5 du dsd+Z6dudnd,Z7duded(fd-Z8 dvde9e:jvd(ffd.Zdsd1Z?de:jvfd2Z@de:jvfd3ZAdeBjfd4ZDdeEdfd5ZFedeefd6ZGdnd7ZHdnd8ZIdeefd9ZJdwdeefd:ZKdeefd;ZLdnd<ZMe jde dfd=ZNedefd>ZOeOj,d?eddfd@ZOe jde efdAZPdudefdBZQdefdCZRe j dqde dfdDZSe jdqde dfdEZT dxdeUfdFZVe jde dfdGZWdndHZXe jde efdIZYGdJdKeZZ[dndLZ\dndMZ]de^e_fdNZ`dee_fdOZadndPZbde[fdQZce jde dfdRZde jde dfdSZee jde dfdTZfe jde dfdUZgdndVZhde fdWZidndXZjde fdYZkdndZZledemjfd[Zoed\Zpdeemjfd]Zreoj,d^emjddfd_Zoedemjfd`ZsdeeemjffdaZtesj,dbemjddfdcZsedee[fddZueuj,deee[ddfdfZuedeefdgZvevj,dheeddfdiZvedjZwewj,dkZwdexjjfdlZ{dexjjfdmZ|xZ}S)yrFaA TensorFlow computation, represented as a dataflow graph. Graphs are used by `tf.function`s to represent the function's computations. Each graph contains a set of `tf.Operation` objects, which represent units of computation; and `tf.Tensor` objects, which represent the units of data that flow between operations. ### Using graphs directly (deprecated) A `tf.Graph` can be constructed and used directly without a `tf.function`, as was required in TensorFlow 1, but this is deprecated and it is recommended to use a `tf.function` instead. If a graph is directly used, other deprecated TensorFlow 1 classes are also required to execute the graph, such as a `tf.compat.v1.Session`. A default graph can be registered with the `tf.Graph.as_default` context manager. Then, operations will be added to the graph instead of being executed eagerly. For example: ```python g = tf.Graph() with g.as_default(): # Define operations and tensors in `g`. c = tf.constant(30.0) assert c.graph is g ``` `tf.compat.v1.get_default_graph()` can be used to obtain the default graph. Important note: This class *is not* thread-safe for graph construction. All operations should be created from a single thread, or external synchronization must be provided. Unless otherwise specified, all methods are not thread-safe. A `Graph` instance supports an arbitrary number of "collections" that are identified by name. For convenience when building a large graph, collections can store groups of related objects: for example, the `tf.Variable` uses a collection (named `tf.GraphKeys.GLOBAL_VARIABLES`) for all variables that are created during the construction of a graph. The caller may define additional collections by specifying a new name. rQNct|tj|_t j d|_i|_d|_ tj|_ tj|_d|_d|_g|_i|_d|_i|_i|_i|_i|_d|_t3j4|_t9j:t<j>t<j@|_!d|_"tj|_#tIjJ|_&tO|_(i|_)i|_*i|_+i|_,dt[fz|_.d|_/d|_0d|_1d|_2d|_3i|_4i|_5tmjnr|jqyy)zCreates a new, empty Graph.) num_groupsFN)producer min_consumerz graph-key-%d/)9rtrs threadingRLock_lockr; GroupLock _group_lock _names_in_use_stack_state_is_thread_locallocal _thread_localr0TraceableStack_graph_device_function_stack_default_original_opr!_graph_control_dependencies_stack _collections_seed_attr_scope_map_op_to_kernel_label_map_gradient_override_map_gradient_function_map _finalized collections OrderedDict _functionsr VersionDefr1GRAPH_DEF_VERSIONGRAPH_DEF_VERSION_MIN_CONSUMER_graph_def_versions_building_function_graph_colocation_stackr<ObjectIdentitySet_unfeedable_tensorsset_unfetchable_ops_handle_feeders_handle_readers_handle_movers_handle_deletersr _graph_key_last_loss_reduction_is_loss_scaled_by_optimizer _containerexperimental_acd_manager_add_control_dependencies _op_def_cache_reduced_shape_cacherenabledswitch_to_thread_localrlrs rTrszGraph.__init__s G"DJ!**a8DD(-D%"*D)8(F(F(HD% $D"&D.0D*DDJD#%D #%D"$DDO!--/DO+66++<< >D$D$3#A#A#CD .@@BDEDDDDD &0DO!%D(-D%DO%)D!&+D"D!#D {{} !!#rVc|Srurrs rTrzGraph._c_graph7rrVrlc|Srurrs rTrzGraph.__enter__; KrVcyrur)rlrs rTrzGraph.__exit__>s rVc|Srurrs rTrz Graph.getAr rVc#K|j}t|}|j||f|jd||j_ d|jj|ur t d||j_y#|jj|ur t d||j_wxYww)a Scope which defines a variable creation function. Args: creator: A callable taking `next_creator` and `kwargs`. See the `tf.variable_creator_scope` docstring. priority: Creators with a higher `priority` are called first. Within the same priority, creators are called inner-to-outer. Yields: `_variable_creator_scope` is a context manager with a side effect, but doesn't return a value. Raises: RuntimeError: If variable creator scopes are not properly nested. c |dSrr)rs rTz/Graph._variable_creator_scope..^s d1grVkeyNz6Exiting variable_creator_scope without proper nesting.)_variable_creator_stackrFrsortrrq)rlcreatorpriorityoldnews rT_variable_creator_scopezGraph._variable_creator_scopeFs&  & &C s)CJJ'"#HH%H&14D.7   3 33 > DF F36d0    3 33 > DF F36d0sACB 5C 6CCc#K|j}tj|}t|tt fr|D]}||j |n||j |||j_ d|jj|ur td||j_y#|jj|ur td||j_wxYww)aScope which defines a resource creation function used by some resource. The resource should be a subclass of CapturableResource with a class method `cls._resource_type`, the output of which is what the `resource_type` argument should be. By default, `cls._resource_type` returns the class name, `cls.__name__`. Given a scope, creators being added with the same `resource_type` argument will be composed together to apply to all classes with this `_resource_type`. `creator` is expected to be a function with the following signature: ``` def resource_creator(next_creator, *a, **kwargs) ``` The creator is supposed to eventually call the next_creator to create an instance if it does want to create an instance and not call the class initialization method directly. This helps make creators composable. A creator may choose to create multiple instances, return already existing instances, or simply register that an instance was created and defer to the next creator in line. Creators can also modify keyword arguments seen by the next creators. Valid keyword arguments in `kwargs` depends on the specific resource class. For StaticHashTable, this may be: * initializer: The table initializer to use. * default_value: The value to use if a key is missing in the table. * name: Optional name for the table, default to None. Args: resource_type: the output of the resource class's `_resource_type` method. creator: the passed creator for the resource. Yields: A scope in which the creator is active Raises: RuntimeError: If resource_creator_scope is existed without proper nesting. Nz6Exiting resource_creator_scope without proper nesting.) _resource_creator_stackrdeepcopyrarFrrrrq)rlrrrrrs rTrzGraph._resource_creator_scopejsZ  & &C -- C-$/! A g -(14D.7   3 33 > DF F36d0    3 33 > DF F36d0sA9C.<B55C.56C++C..ct|jds(tjt|j_|jj S)Nr)r8rr defaultdictrFrrs rTrzGraph._resource_creator_stacks> 4%%'@ A3>3J3J43Pd0    5 55rVresource_creator_stackc&||j_yru)rr)rlr s rTrzGraph._resource_creator_stack 2HD.rVc|t|jdsg|j_|jjS)Nr)r8rrrs rTrzGraph._variable_creator_stacks5 4%%'@ A35d0&    5 55rVvariable_creator_stackc&||j_yru)rr)rlr$s rTrzGraph._variable_creator_stackr"rVc2|jr tdy)z^Check if the graph is finalized. Raises: RuntimeError: If the graph finalized. z*Graph is finalized and cannot be modified.N)rrqrs rT_check_not_finalizedzGraph._check_not_finalizeds   E FFrVcTtjj|jS)zThe GraphDef version information of this graph. For details on the meaning of each version, see [`GraphDef`](https://www.tensorflow.org/code/tensorflow/core/framework/graph.proto). Returns: A `VersionDef`. )rrrH _version_defrs rTgraph_def_versionszGraph.graph_def_versionss!  " " - -d.?.? @@rVc|jS)z*The graph-level random seed of this graph.rrs rTseedz Graph.seeds ::rVr-c||_yrur,)rlr-s rTr-z Graph.seeds DJrVc|jS)z&True if this graph has been finalized.rrs rT finalizedzGraph.finalizeds ??rVcd|_y)a3Finalizes this graph, making it read-only. After calling `g.finalize()`, no new operations can be added to `g`. This method is used to ensure that no operations are added to a graph when it is shared between multiple threads, for example when using a `tf.compat.v1.train.QueueRunner`. TNr0rs rTfinalizezGraph.finalizes DOrVcd|_y)a[Opposite of `finalize`. Internal interface. NOTE: Unfinalizing a graph could have negative impact on performance, especially in a multi-threaded environment. Unfinalizing a graph when it is in use by a Session may lead to undefined behavior. Ensure that all sessions using a graph are closed before calling this method. FNr0rs rT_unsafe_unfinalizezGraph._unsafe_unfinalize s DOrVc|jS)zTReturns the current control flow context. Returns: A context object. rrs rTrzGraph._get_control_flow_context rrVc||_y)zSSets the current control flow context. Args: ctx: a context object. Nrrs rTrzGraph._set_control_flow_context rrVc|}|jjD]}||jjz }|dk\s|dkr t d|j j j|jgt|ddsstj}|j|_ |j|_|j jj|gy)z;If this graph contains functions, copy them to `graph_def`.rrz#GraphDef cannot be larger than 2GB.grad_func_nameN)rrcached_definitionrrRlibraryr_extendrr GradientDefr function_namer9 gradient_funcr)rl graph_defstarting_bytesizebytesizerrgrad_defs rT_copy_functions_to_graph_defz"Graph._copy_functions_to_graph_def s H __ # # % 6!%%..00h g (Q,>??  '')<)<(=> $d +++-!"!"!1!1""))8*5 6rVc  |j5|r\|jj5}tj}|j t j|dddntj5}|jj5}t j||t j|}ddddddtj}|jtjjj s|j#d|r|j$D]}|j'|j(} | j*s+|j,dj.j0j3| j*D cgc] } | j5j7"c} |jj D]e} |j8| j:j(} | j<} | j,d} | j@}tC|j.j0dtC|fvsJ|j.j0stE|| j:jFD]~\}}|j.j0jIj |j5j7|jJtLjNk(sstQ||tE| j*| j:jRD]/\}}|jJtLjNk(s$tQ||1| jTD]} | jW|j(} | j*}| jZdk(r1tC|j,dj.jZ}|d|}|j,dj.j0j3|D cgc] } | j5j7"c} hddd|j\fS#1swYhxYw#1swYxYw#1swYxYwcc} w#t>$rYwxYw#t>$rYwxYw#tX$rY:wxYwcc} w#1swYxxYw)a{Returns a serialized `GraphDef` representation of this graph. The serialized `GraphDef` can be imported into another `Graph` (using `tf.import_graph_def`) or used with the [C++ Session API](https://chromium.googlesource.com/external/github.com/tensorflow/tensorflow/+/r0.10/tensorflow/g3doc/api_docs/cc/index.md). This method is thread-safe. Args: from_version: Optional. If this is set, returns a `GraphDef` containing only the nodes that were added to this graph since its `version` property had the given value. add_shapes: If true, adds an "_output_shapes" list attr to each node with the inferred shapes of each of its outputs. use_pybind11_proto: If true, uses the c++ pybind11_proto api to get the GraphDef proto directly from c++, instead of through a TF buffer. Returns: A tuple containing a [`GraphDef`](https://www.tensorflow.org/code/tensorflow/core/framework/graph.proto) protocol buffer, and the version of the graph to which that `GraphDef` corresponds. Raises: ValueError: If the `graph_def` would be too large. Nr;_output_shapes _input_shapesrStatefulPartitionedCallTout)/rrrrGraphDefrrTF_GraphToGraphDefPybindr#rtTF_GraphToGraphDefrvrwr7rr;r_ ClearFieldr_get_operation_by_namerrrrFrr<rCrir signaturerr[rrQrS input_argaddrr&r_copy_handle_data_to_arg_def output_argryget_operation_by_nameKeyErrorrversion)rl from_version add_shapesuse_pybind11_protorrrRrzrroutput function_defdefined_function func_graph input_shapesfunc_graph_inputsr arg_def output_tensorrr(s rT _as_graph_defzGraph._as_graph_def. s<@ CG  ]]    NG$$&% ..*CCGL M N N ! ! # 7s}}  " 7g  0 0# >$11#6D 7 7""$ food34 ]] # # # JJ JD**4995" ZZ II& ' , , 2 2 9 9=?ZZH6!!#,,.H J J "MM22- GL!__\-C-C-H-HI  )//J &**?;,  * 1 1  \&&,,-!S9J5K1LL LL""((),->-9-C-C-M-M*O D% g%%))+44((*3357##v6,\7C  D),J,>,>,8,B,B,M,M)O C$mW""foo5*='B C #++ Gd 33DII>bjjGww33  & 1 6 6 ; ;CSAS1SR9*A ""j5G#IFA MrVcDtj||jvS)zTests whether 'name' is registered in this graph's function library. Args: name: string op name. Returns: bool indicating whether or not 'name' is registered in function library. )r7rwrrlrs rT _is_functionzGraph._is_function s == $// 11rVc`|jjtj|dS)zReturns the function definition for 'name'. Args: name: string function name. Returns: The function def proto. N)rrr7rwrgs rT _get_functionzGraph._get_function s$ ??  v}}T2D 99rVc|j|jr/|r>|j|j|j|n|j|t |drn|j D]^}|j|jr0|s!|j|j|j|N|j|`yy)zBAdds function to the graph including other functions in its graph.childrenN)rhr_remove_function _add_functionr8rl)rlr_ overwriterrs rT_add_function_recursivezGraph._add_function_recursive s '  hmm, 8$ "x$   !   QVV $   ! !!&& )   q !   Q   %rVc|j|j}t|ddrt|ddrtd|z|jj 5}|j j 5}t|ddrE|jj j 5}tj|||dddntj||ddddddd||jtj|<|jjdkrd|j_yy#1swYgxYw#1swYkxYw#1swYoxYw)aEAdds a function to the graph. After the function has been added, you can call to the function by passing the function name in place of an op name to `Graph.create_op()`. Args: function: A `_DefinedFunction` object. Raises: ValueError: if another function is defined with the same name. r9Npython_grad_funcz&Gradient defined twice for function %s _grad_func )r'rrrRrr_c_funcrsrTF_GraphCopyFunctionrr7rwrr)rlr_rrr-rs rTrnzGraph._add_function sO  ==Dx)40W$d6 ?$F GG    F      !FT 8\4 0""**..0 LH  2 27D( K L L  0 0$ E FF,4DOOFMM$'( ,,r1.0d+2 L LFFFFs<E:2E,E E$EE EE EE#cZ|j|j|std|d|d|jj 5}t j |tj||jtj|=dddy#1swYyxYw)Nz Function z is not found in rN) r'rhrRrrrTF_GraphRemoveFunctionr7rrrw)rlrrs rTrmzGraph._remove_function s   T " 4(*;D81E FF    /..w8MN //&--- .///s A B!!B*c|jS)z2Returns True iff this graph represents a function.)rrs rTrpzGraph.building_function s  " ""rVzMShapes are always computed; don't use the compute_shapes as it has no effect.compute_shapesrKc ~t|D]/\} } t| tjr!t d| | fz|j |||||||| S)aCreates an `Operation` in this graph. This is a low-level interface for creating an `Operation`. Most programs will not call this method directly, and instead use the Python op constructors, such as `tf.constant()`, which add ops to the default graph. Args: op_type: The `Operation` type to create. This corresponds to the `OpDef.name` field for the proto that defines the operation. inputs: A list of `Tensor` objects that will be inputs to the `Operation`. dtypes: (Optional) A list of `DType` objects that will be the types of the tensors that the operation produces. input_types: (Optional.) A list of `DType`s that will be the types of the tensors that the operation consumes. By default, uses the base `DType` of each input in `inputs`. Operations that expect reference-typed inputs must specify `input_types` explicitly. name: (Optional.) A string name for the operation. If not specified, a name is generated based on `op_type`. attrs: (Optional.) A dictionary where the key is the attribute name (a string) and the value is the respective `attr` attribute of the `NodeDef` proto that will represent the operation (an `AttrValue` proto). op_def: (Optional.) The `OpDef` proto that describes the `op_type` that the operation will have. compute_shapes: (Optional.) Deprecated. Has no effect (shapes are always computed). compute_device: (Optional.) If True, device functions will be executed to compute the device property of the Operation. Raises: TypeError: if any of the inputs is not a `Tensor`. ValueError: if colocation conflicts with existing device assignment. Returns: An `Operation` object. zInput #%d is not a tensor: %s)rrarrrr) rlrrr&rrrrrzcompute_deviceidxrs rT create_opzGraph.create_op soh F#DQ :,, -73(BCCD  # #GVV[$$)6> CCrVc |j||}|r|ddk(r t|}n|j|}t|||} t d|D} |j | } |j 5tj| |||| ||j|} |j| |ddd| S#1swY SxYw)aCreates an `Operation` in this graph. Implements `Graph.create_op()` without the overhead of the deprecation wrapper. Args: op_type: The `Operation` type to create. This corresponds to the `OpDef.name` field for the proto that defines the operation. inputs: A list of `Tensor` objects that will be inputs to the `Operation`. dtypes: (Optional) A list of `DType` objects that will be the types of the tensors that the operation produces. input_types: (Optional.) A list of `DType`s that will be the types of the tensors that the operation consumes. By default, uses the base `DType` of each input in `inputs`. Operations that expect reference-typed inputs must specify `input_types` explicitly. name: (Optional.) A string name for the operation. If not specified, a name is generated based on `op_type`. attrs: (Optional.) A dictionary where the key is the attribute name (a string) and the value is the respective `attr` attribute of the `NodeDef` proto that will represent the operation (an `AttrValue` proto). op_def: (Optional.) The `OpDef` proto that describes the `op_type` that the operation will have. compute_device: (Optional.) If True, device functions will be executed to compute the device property of the Operation. Raises: ValueError: if colocation conflicts with existing device assignment. Returns: An `Operation` object. Nr[rc34K|]}|jywru)r)rrs rTrz,Graph._create_op_internal.. s)QADD)s)rrrrrrr|) r'r unique_namerr _control_dependencies_for_inputs_mutation_lockrKrr_create_op_helper) rlrrr&rrrrr|ry input_opsrrs rTrzGraph._create_op_internalV sT  | d RC !$ 'd   d #du-H)&))I::9EN     A  # #  '!// $ c S@ A J A Js <;CC c|jtj||}|jj }||j vrd|j |<|j |||S)a3Creates an `Operation` in this graph from the supplied TF_Operation. This method is like create_op() except the new Operation is constructed using `c_op`. The returned Operation will have `c_op` as its _c_op field. This is used to create Operation objects around TF_Operations created indirectly by the C API (e.g. by TF_ImportGraphDef, TF_FinishWhile). This function does not call Operation._control_flow_post_processing or Graph._control_dependencies_for_inputs (since the inputs may not be available yet). The caller is responsible for calling these methods. Args: c_op: a wrapped TF_Operation compute_device: (Optional.) If True, device functions will be executed to compute the device property of the Operation. Returns: An `Operation` object. )rrrr)r'rKrrlowerrr)rlrr|rname_keys rT_create_op_from_tf_operationz"Graph._create_op_from_tf_operation sm,    DD  1C xx~~Ht)))%&d"3~> JrVcv|jjD]\}} |j| |j|j}|jdtjtj||j j#|j|_ |j&|j}|jdtjtj||j)||r|j+||j-|_|j0rg}d}|j0j3D]O} |j5| j7| j:s0|r3|j=| j:d}Qt?tA|}|jd tjtjjC| |jDrf|jFrY |jd } | sD|jd tjtj|jDyyyy#t$rkt |rH||j }t |tdtjfstd|d||r|j||YwxYw#t$rYwxYw#t$rYwxYw#t8$rYwxYw#t$rYywxYw) z.Common logic for creating an op in this graph.NzCallable for scope map key 'zL' must return either None or an AttrValue protocol buffer; but it returned: _kernel)rkrFTr r\ container)$rrr rRreryrarrrrrSrr7rrUrrrr'_record_op_seen_by_control_dependencies_apply_device_functions#_snapshot_colocation_stack_metadatar_colocation_stack peek_objsr<rr[r%r,sortedrr]r _is_stateful) rlrr|rr kernel_labelmapped_op_typeall_colocation_groups is_device_set colocation_opcontainer_attrs rTrzGraph._create_op_helper s**002 # U # C # 11"'':lll9!++fool.KLN !77;;BGGDB 22277;nll&!++foon.MNP  004 ""2& %)$L$L$NB!  m11;;= -   & &}'F'F'H I    ..-- .- %S)>%?@ll   " "!++558M5N PQ 2??3[1  ,,{N$<$<0%2 3+K # E? $%EDJ0H0H#IJe   ,,sE " #        *   0   s[JAK<3AL ,L+L,A0K98K9< L L  LL L)(L), L87L8c|j|jDcgc]}|j||}}|D]>}|j|j}|j ||j @|Scc}w)a%Creates `Operations` in this graph for any new TF_Operations. This is useful for when TF_Operations are indirectly created by the C API outside of the Operation constructor (e.g. by TF_ImportGraphDef, TF_FinishWhile). This ensures there are corresponding Operations for all TF_Operations in the underlying TF_Graph. Args: compute_devices: (Optional.) If True, device functions will be executed to compute the device properties of each new Operation. Returns: A list of the new `Operation` objects. r)r'new_operationsrrr_add_control_inputsr)rlcompute_devicesrnew_opsrnew_control_inputss rT_add_new_tf_operationszGraph._add_new_tf_operations s  '')  ))$)OG )@@K/0&&() NsBc|jr|j|||S|j5|j|||cdddS#1swYyxYw)aReturns the object referred to by `obj`, as an `Operation` or `Tensor`. This function validates that `obj` represents an element of this graph, and gives an informative error message if it is not. This function is the canonical way to get/validate an object of one of the allowed types from an external argument reference in the Session API. This method may be called concurrently from multiple threads. Args: obj: A `Tensor`, an `Operation`, or the name of a tensor or operation. Can also be any object with an `_as_graph_element()` method that returns a value of one of these types. Note: `_as_graph_element` will be called inside the graph's lock and so may not modify the graph. allow_tensor: If true, `obj` may refer to a `Tensor`. allow_operation: If true, `obj` may refer to an `Operation`. Returns: The `Tensor` or `Operation` in the Graph corresponding to `obj`. Raises: TypeError: If `obj` is not a type we support attempting to convert to types. ValueError: If `obj` is of an appropriate type but invalid. For example, an invalid string. KeyError: If `obj` is not an object in the graph. N)r_as_graph_element_lockedr)rlr allow_tensorallow_operations rTas_graph_elementzGraph.as_graph_element8 sS@   * *3 o NN O  * *3 o NOOOs A  Ac  |r|rd}n|rd}n|rd}n tdt|}||}t|tjrtj |}d|vrD|rB |j d\}}t|} |j|} | j|Sd|vr|std t|d|dd|vr|r |j|} | Sd|vr7|s4 |j|} dt|d|d} | dz } t| yyt|tjr |r|j|urtd|z|St|t r |r|j|urtd|z|St#dt%|j&d|d#tdt|zxYw#t$r*} tdt|d t|d | d} ~ wwxYw#tdt|d t|d t| jd xYw#t$r} tdt|z| d} ~ wwxYw#t$rdt|d|d} YywxYw)z+See `Graph.as_graph_element()` for details.zTensor or OperationrrKz5allow_tensor and allow_operation can't both be False.N:z|The name %s looks a like a Tensor name, but is not a valid one. Tensor names must be of the form ":".z The name z9 refers to a Tensor which does not exist. The operation, z, does not exist in the graph.z, exists but only has z outputs.zName z% appears to refer to a Tensor, not a rNz4The name %s refers to an Operation not in the graph.z refers to an Operation, not a z/ looks like an (invalid) Operation name, not a z= Tensor names must be of the form ":".z*Tensor %s is not an element of this graph.z-Operation %s is not an element of this graph.zCan not convert a z into a )rRrrar7bytes_or_text_typesrwsplitrrrNrUrrQrrrrKrrr|) rlrrr types_strtemp_objrrout_nrexcerr_msgs rTrzGraph._as_graph_element_locked^ s'i i i N OO %H c#v112 ]]3 d  N::c?.'5e*%  **73" GE" " $;|t*i12 2 d? **40"  d?? <**40"4j)-' 4 5!!$3? C** + $ EKLL j C # $ H3NOO j Cy))96 77 N@BFt*MN N  t*d7m5     Gt*d7mS_FG G DT     <$(J ;' A$$A-crt|tr|fn t|}|D]}|j||y)a|Stores `value` in the collections given by `names`. Note that collections are not sets, so it is possible to add a value to a collection several times. This function makes sure that duplicates in `names` are ignored, but it will not check for pre-existing membership of `value` in any of the collections in `names`. `names` can be any iterable, but if `names` is a string, it is treated as a single collection name. Args: names: The keys for the collections to add to. The `GraphKeys` class contains many standard names for collections. value: The value to add to the collections. N)rar]rr)rlnamesrrs rTadd_to_collectionszGraph.add_to_collectionsT s9"#5#.UHCJE* T5)*rVc|j5|jj|d}|g}||j|<|cdddS#1swYyxYw)aReturns a list of values in the collection with the given `name`. If the collection exists, this returns the list itself, which can be modified in place to change the collection. If the collection does not exist, it is created as an empty list and the list is returned. This is different from `get_collection()` which always returns a copy of the collection list if it exists and never creates an empty collection. Args: name: The key for the collection. For example, the `GraphKeys` class contains many standard names for collections. Returns: The list of values in the collection with the given `name`, or an empty list if no value has been added to that collection. N)rrr)rlr coll_lists rTget_collection_refzGraph.get_collection_refi sV$ ##''d3i   "+$  s 1AAc||j5|jj|d}| gcdddS|t|cdddSg}t j |}|D]/} |j |jr|j|1|cdddS#t$rYHwxYw#1swYyxYw)aReturns a list of values in the collection with the given `name`. This is different from `get_collection_ref()` which always returns the actual collection list if it exists in that it returns a new list each time it is called. Args: name: The key for the collection. For example, the `GraphKeys` class contains many standard names for collections. scope: (Optional.) A string. If supplied, the resulting list is filtered to include only items whose `name` attribute matches `scope` using `re.match`. Items without a `name` attribute are never returned if a scope is supplied. The choice of `re.match` means that a `scope` without special tokens filters by prefix. Returns: The list of values in the collection with the given `name`, or an empty list if no value has been added to that collection. The list contains the values in the order under which they were collected. N) rrrrFrecompilerrrr[)rlrscope collectionrregexrs rTget_collectionzGraph.get_collection s, $$((t4j   J   5! D {{499%hhtn !    s: B2 B2 B2*,B#B2# B/,B2.B//B22B;c|j5|jDcgc]}t|ts|c}cdddScc}w#1swYyxYw)z1Returns a list of collections used in this graph.N)rrrar]rs rTget_all_collection_keyszGraph.get_all_collection_keys sH B** AAjC.@a ABB ABBs AAAAAAc|j|j5||jvr |j|=dddy#1swYyxYw)zClears all values in a collection. Args: name: The key for the collection. The `GraphKeys` class contains many standard names for collections. N)r'rrrgs rTclear_collectionzGraph.clear_collection sH  $ "" "   d #$$$s AA c#bK|j}||_ d||_y#||_wxYww)aPython 'with' handler to help annotate ops with their originator. An op may have an 'original_op' property that indicates the op on which it was based. For example a replica op is based on the op that was replicated and a gradient op is based on the op that was differentiated. All ops created in the scope of this 'with' handler will have the given 'op' as their original op. Args: op: The Operation that all ops created in this scope will have as their original op. Yields: Nothing. N)r)rlrold_original_ops rTrzGraph._original_op s3$//O "D2 "1d/ds/#/ ,/c|t|jdsd|j_|jjS)N _name_stackr)r8rrrs rTrzGraph._name_stack s4 4%%} 5')d$    ) ))rV name_stackc&||j_yru)rr)rlrs rTrzGraph._name_stack s%/D"rVc#K|rt|tjrtj|}|jr4t j |sStd|dt jtj |std|dtj|j}|sd}d}n,|ddk(rt|}|}n|j|}|dz}||_ |||_y#||_wxYww)a Returns a context manager that creates hierarchical names for operations. A graph maintains a stack of name scopes. A `with name_scope(...):` statement pushes a new name onto the stack for the lifetime of the context. The `name` argument will be interpreted as follows: * A string (not ending with '/') will create a new name scope, in which `name` is appended to the prefix of all operations created in the context. If `name` has been used before, it will be made unique by calling `self.unique_name(name)`. * A scope previously captured from a `with g.name_scope(...) as scope:` statement will be treated as an "absolute" name scope, which makes it possible to re-enter existing scopes. * A value of `None` or the empty string will reset the current name scope to the top-level (empty) name scope. For example: ```python with tf.Graph().as_default() as g: c = tf.constant(5.0, name="c") assert c.op.name == "c" c_1 = tf.constant(6.0, name="c") assert c_1.op.name == "c_1" # Creates a scope called "nested" with g.name_scope("nested") as scope: nested_c = tf.constant(10.0, name="c") assert nested_c.op.name == "nested/c" # Creates a nested scope called "inner". with g.name_scope("inner"): nested_inner_c = tf.constant(20.0, name="c") assert nested_inner_c.op.name == "nested/inner/c" # Create a nested scope called "inner_1". with g.name_scope("inner"): nested_inner_1_c = tf.constant(30.0, name="c") assert nested_inner_1_c.op.name == "nested/inner_1/c" # Treats `scope` as an absolute name scope, and # switches to the "nested/" scope. with g.name_scope(scope): nested_d = tf.constant(40.0, name="d") assert nested_d.op.name == "nested/d" with g.name_scope(""): e = tf.constant(50.0, name="e") assert e.op.name == "e" ``` The name of the scope itself can be captured by `with g.name_scope(...) as scope:`, which stores the name of the scope in the variable `scope`. This value can be used to name an operation that represents the overall result of executing the ops in a scope. For example: ```python inputs = tf.constant(...) with g.name_scope('my_layer') as scope: weights = tf.Variable(..., name="weights") biases = tf.Variable(..., name="biases") affine = tf.matmul(inputs, weights) + biases output = tf.nn.relu(affine, name=scope) ``` NOTE: This constructor validates the given `name`. Valid scope names match one of the following regular expressions: [A-Za-z0-9.][A-Za-z0-9_.\-/]* (for scopes at the root) [A-Za-z0-9_.\-/]* (for other scopes) Args: name: A name for the scope. Returns: A context manager that installs `name` as a new name scope. Raises: ValueError: If `name` is not a valid scope name, according to the rules above. 'zN' is not a valid scope name. A scope name has to match the following pattern: zX' is not a valid root scope name. A root scope name has to match the following pattern: rr[rN) rar7rrwrrrrRpatternrrr)rlr old_stack new_stackreturned_scopes rT name_scopezGraph.name_scope sj D&44 5}}T"  ',,T2$((?(G(G'HJK K $))$/$11E1M1M0NPQ Q  I in bS&t,in""4(i 3n D# "ddsC,D/C;3D; DDcX|jr|jdz|z}|j}|jj|d}|r|dz|j|<|dkDrF|}||jvrd||fz}|dz }||jvr|rd|j|<d||dz fz}|S)aReturn a unique operation name for `name`. Note: You rarely need to call `unique_name()` directly. Most of the time you just need to create `with g.name_scope()` blocks to generate structured names. `unique_name` is used to generate structured names, separated by `"/"`, to help identify operations when debugging a graph. Operation names are displayed in error messages reported by the TensorFlow runtime, and in various visualization tools such as TensorBoard. If `mark_as_used` is set to `True`, which is the default, a new unique name is created and marked as in use. If it's set to `False`, the unique name is returned without actually being marked as used. This is useful when the caller simply wants to know what the name to be created will be. Args: name: The name for an operation. mark_as_used: Whether to mark this name as being used. Returns: A string to be passed to `create_op()` that will be used to name the operation being created. rrrr)rrrr)rlr mark_as_usedrr base_name_keys rTrzGraph.unique_nameZ s6     #d *dzz|H x+A%&Ud"1um ** *mQ// Q ** * '(8$a!e} $d KrVc|jS)aBReturns the current name scope. For example: ```python with tf.name_scope('scope1'): with tf.name_scope('scope2'): print(tf.compat.v1.get_default_graph().get_name_scope()) ``` would print the string `scope1/scope2`. Returns: A string representing the current name scope. )rrs rTget_name_scopezGraph.get_name_scope s   rVc# K|j||5|B//M"1"@"@"BD,,m.==?d ~ %%b%3  * ''(=a'H  5 66 / %2d!  &&( ,  ( ( * !. %2d!  &&( ,  ( ( * !. s B7E:D>A EA EEc`d|z}t|}|jj|||S)z>Add device to stack manually, separate from a context manager.rr)rXrr)rlrmr total_offsetspecs rT_add_device_to_stackzGraph._add_device_to_stack s6v:L 2 3D((l(C KrVc#K|j|d|jj} d|jj}||ur td|jj y#|jj}||ur td|jj wxYww)a-Returns a context manager that specifies the default device to use. The `device_name_or_function` argument may either be a device name string, a device function, or None: * If it is a device name string, all operations constructed in this context will be assigned to the device with that name, unless overridden by a nested `device()` context. * If it is a function, it will be treated as a function from Operation objects to device name strings, and invoked each time a new Operation is created. The Operation will be assigned to the device with the returned name. * If it is None, all `device()` invocations from the enclosing context will be ignored. For information about the valid syntax of device name strings, see the documentation in [`DeviceNameUtils`](https://www.tensorflow.org/code/tensorflow/core/util/device_name_utils.h). For example: ```python with g.device('/device:GPU:0'): # All operations constructed in this context will be placed # on GPU 0. with g.device(None): # All operations constructed in this context will have no # assigned device. # Defines a function from `Operation` to device string. def matmul_on_gpu(n): if n.type == "MatMul": return "/device:GPU:0" else: return "/cpu:0" with g.device(matmul_on_gpu): # All operations of type "MatMul" constructed in this context # will be placed on GPU 0; all other operations will be placed # on CPU 0. ``` **N.B.** The device scope may be overridden by op wrappers or other library code. For example, a variable assignment op `v.assign()` must be colocated with the `tf.Variable` `v`, and incompatible device scopes will be ignored. Args: device_name_or_function: The device name or function to use in the context. Yields: A context manager that specifies the default device to use for newly created ops. Raises: RuntimeError: If device scopes are not properly nested. rrNz2Exiting device scope without proper scope nesting.)rr peek_top_objrqr)rlrmold_top_of_stacknew_top_of_stacks rTr%z Graph.devicesz 5a@22??A, 44AAC !1 1OPP !!))+44AAC !1 1OPP !!))+s.CA9AC9AB>>Ccd}|jjD]F}|jr|jn+|j |}||us4|j ||}H|j |_y)zAApplies the current device function stack to the given operation.N)rrrdr_rzr+(_snapshot_device_function_stack_metadatar)rlrprior_device_string device_spec device_strings rTrzGraph._apply_device_functionsOs22<<> ,  " "    % !..r2m 1 1 ""=1+ ,!% M M OBrVc#vK|j}||_ |j||_y#||_wxYww)aReturns a context manager that specifies the resource container to use. Stateful operations, such as variables and queues, can maintain their states on devices so that they can be shared by multiple processes. A resource container is a string name under which these stateful operations are tracked. These resources can be released or cleared with `tf.Session.reset()`. For example: ```python with g.container('experiment0'): # All stateful Operations constructed in this context will be placed # in resource container "experiment0". v1 = tf.Variable([1.0]) v2 = tf.Variable([2.0]) with g.container("experiment1"): # All stateful Operations constructed in this context will be # placed in resource container "experiment1". v3 = tf.Variable([3.0]) q1 = tf.queue.FIFOQueue(10, tf.float32) # All stateful Operations constructed in this context will be # be created in the "experiment0". v4 = tf.Variable([4.0]) q1 = tf.queue.FIFOQueue(20, tf.float32) with g.container(""): # All stateful Operations constructed in this context will be # be placed in the default resource container. v5 = tf.Variable([5.0]) q3 = tf.queue.FIFOQueue(30, tf.float32) # Resets container "experiment0", after which the state of v1, v2, v4, q1 # will become undefined (such as uninitialized). tf.Session.reset(target, ["experiment0"]) ``` Args: container_name: container name string. Returns: A context manager for defining resource containers for stateful ops, yields the container name. N)r)rlcontainer_nameoriginal_containers rTrzGraph.containeris8Z$DO+ OO*do*dos9-9 69cLeZdZdZd dZd dZd dZedZd dZ de fd Z y) $Graph._ControlDependenciesControllerz-Context manager for `control_dependencies()`.rQNc||_|g|_d|_n||_d|_t|_d|_d|_y)a Create a new `_ControlDependenciesController`. A `_ControlDependenciesController` is the context manager for `with tf.control_dependencies()` blocks. These normally nest, as described in the documentation for `control_dependencies()`. The `control_inputs` argument list control dependencies that must be added to the current set of control dependencies. Because of uniquification the set can be empty even if the caller passed a list of ops. The special value `None` indicates that we want to start a new empty set of control dependencies instead of extending the current set. In that case we also clear the current control flow context, which is an additional mechanism to add control dependencies. Args: graph: The graph that this controller is managing. control_inputs: List of ops to use as control inputs in addition to the current control dependencies. None to indicate that the dependencies should be cleared. NTF)_graph_control_inputs_val _new_stackr _seen_nodes _old_stack_old_control_flow_context)rlrrs rTrsz-Graph._ControlDependenciesController.__init__sH,dk  #% #1 ddo'+d$rVc|jrf|jj|_g|j_|jj |_|jj d|jj|yru)rr _control_dependencies_stackrrrr%_push_control_dependencies_controllerrs rTrz.Graph._ControlDependenciesController.__enter__s_ ++AA24 /)-)N)N)P& --d3 kk77=rVc|jj||jrA|j|j_|jj |j yyru)r $_pop_control_dependencies_controllerrrrrr)rl unused_type unused_valueunused_tracebacks rTrz-Graph._ControlDependenciesController.__exit__sH kk66t< 26// / --d.L.LM rVc|jSru)rrs rTrz3Graph._ControlDependenciesController.control_inputss  % %%rVct|tjr|j}|jj |yru)rarrrefrrQrlrs rTadd_opz+Graph._ControlDependenciesController.add_ops1 B )) * VVX 2rVcrt|tjr|j}||jvSru)rarrrrrs rT op_in_groupz0Graph._ControlDependenciesController.op_in_groups. B )) * VVX 4## ##rVr{) r|r}r~rrsrrrrrrr!rrVrT_ControlDependenciesControllerr s;7,F>N&& $$rVr"c:|jj|yru)rrrl controllers rTrz+Graph._push_control_dependencies_controllers$$++J7rVc^|jd|usJ|jjy)Nr[)rpopr$s rTrz*Graph._pop_control_dependencies_controllers-  + +B /: == =$$((*rVct}|jD]$}|jD]}|j|&|Sru)rrrrQ)rlrr%rs rT_current_control_dependenciesz#Graph._current_control_dependenciessE %C66 ))"   JrVcg}|jD]G}d}D]}|j|sd}n|r$|jfd|jDI|S)aFor an op that takes `input_ops` as inputs, compute control inputs. The returned control dependencies should yield an execution that is equivalent to adding all control inputs in self._control_dependencies_stack to a newly created op. However, this function attempts to prune the returned control dependencies by observing that nodes created within the same `with control_dependencies(...):` block may have data dependencies that make the explicit approach redundant. Args: input_ops: The data input ops for an op to be created. Returns: A list of control inputs for the op to be created. FTc3,K|] }|vs| ywrur)rrrs rTrz9Graph._control_dependencies_for_inputs..sN1I;M1Ns )rr!r<r)rlrrr% dominatedrs ` rTrz&Graph._control_dependencies_for_inputsss" C66 O i"  ! !" %)  Nj77NN O JrVcH|jD]}|j|y)zpRecord that the given op depends on all registered control dependencies. Args: op: An Operation. N)rr)rlrr%s rTrz-Graph._record_op_seen_by_control_dependenciess' 66 rVcB||j|dSg}|j}|D]}t|tjst |drt |dr |j }|j|}t|tjr |j }nt|tstd|z||vs|j||j||jdtj d|j||S)av Returns a context manager that specifies control dependencies. Use with the `with` keyword to specify that all operations constructed within the context should have control dependencies on `control_inputs`. For example: ```python with g.control_dependencies([a, b, c]): # `d` and `e` will only run after `a`, `b`, and `c` have executed. d = ... e = ... ``` Multiple calls to `control_dependencies()` can be nested, and in that case a new `Operation` will have control dependencies on the union of `control_inputs` from all active contexts. ```python with g.control_dependencies([a, b]): # Ops constructed here run after `a` and `b`. with g.control_dependencies([c, d]): # Ops constructed here run after `a`, `b`, `c`, and `d`. ``` You can pass None to clear the control dependencies: ```python with g.control_dependencies([a, b]): # Ops constructed here run after `a` and `b`. with g.control_dependencies(None): # Ops constructed here run normally, not waiting for either `a` or `b`. with g.control_dependencies([c, d]): # Ops constructed here run after `c` and `d`, also not waiting # for either `a` or `b`. ``` *N.B.* The control dependencies context applies *only* to ops that are constructed within the context. Merely using an op or tensor in the context does not add a control dependency. The following example illustrates this point: ```python # WRONG def my_func(pred, tensor): t = tf.matmul(tensor, tensor) with tf.control_dependencies([pred]): # The matmul op is created outside the context, so no control # dependency will be added. return t # RIGHT def my_func(pred, tensor): with tf.control_dependencies([pred]): # The matmul op is created in the context, so a control dependency # will be added. return tf.matmul(tensor, tensor) ``` Also note that though execution of ops created under this scope will trigger execution of the dependencies, the ops created under this scope might still be pruned from a normal tensorflow graph. For example, in the following snippet of code the dependencies are never executed: ```python loss = model.loss() with tf.control_dependencies(dependencies): loss = loss + tf.constant(1) # note: dependencies ignored in the # backward pass return tf.gradients(loss, model.variables) ``` This is because evaluating the gradient graph does not require evaluating the constant(1) op created in the forward pass. Args: control_inputs: A list of `Operation` or `Tensor` objects which must be executed or computed before running the operations defined in the context. Can also be `None` to clear the control dependencies. Returns: A context manager that specifies control dependencies for all operations constructed within the context. Raises: TypeError: If `control_inputs` is not a list of `Operation` or `Tensor` objects. N_handlerz-Control input must be Operation or Tensor: %s _has_manual_control_dependenciesT)rs)r"r)rar6rr8rrrrrKrrrQrSrr)rlr control_opscurrentrs rTrwzGraph.control_dependenciess t  0 0t << K002G 6 Q.. / 1i WQ%5 DD    "a Az(( ) DD!Y'G!KLL ' 1 A 6",,t4 6)6.  . .t[ AArVc#Kt|ts tdi}|jD]\}}t|tr0t|t dt jfst|s td |j|||<||j|=t||j|< d|jD]\}} |||j|<y#t$rY]wxYw#t$r|j|=YCwxYw#|jD]4\}} |||j|<#t$r|j|=Y2wxYwwxYww)aEXPERIMENTAL: A context manager for setting attributes on operators. This context manager can be used to add additional attributes to operators within the scope of the context. For example: with ops.Graph().as_default() as g: f_1 = Foo() # No extra attributes with g._attr_scope({"_a": tf.attr_value_pb2.AttrValue(b=False)}): f_2 = Foo() # Additional attribute _a=False with g._attr_scope({"_a": tf.attr_value_pb2.AttrValue(b=True)}): f_3 = Foo() # Additional attribute _a=False with g._attr_scope({"_a": None}): f_4 = Foo() # No additional attributes. Args: attr_map: A dictionary mapping attr name strings to AttrValue protocol buffers or None. Returns: A context manager that sets the kernel label to be used for one or more ops created in that context. Raises: TypeError: If attr_map is not a dictionary mapping strings to AttrValue protobufs. zKattr_map must be a dictionary mapping strings to AttrValue protocol buffersNz}attr_map must be a dictionary mapping strings to AttrValue protocol buffers or callables that emit AttrValue protocol buffers) rarrrr]rrrrerrU)rlattr_map saved_attrsrrs rT _attr_scopezGraph._attr_scopes< h % > ??Knn&* ds#$d^-E-E FG~IJ J  006 D    &%)T"* ) !()*$ )'24'8$  t $)    )""4( )!()*$ )'24'8$  t $ )""4( ))sA?EC&!E6D:EC5#E& C2/E1C22E5D E DEE)D<;E<E EE EEc#^Kt|ts tdi}|jD]R\}}t|trt|ts td |j |||<||j |<T d|jD]\}} |||j |<y#t $rYMwxYw#t $r|j |=YCwxYw#|jD]4\}} |||j |<#t $r|j |=Y2wxYwwxYww)aEXPERIMENTAL: A context manager for setting kernel labels. This context manager can be used to select particular implementations of kernels within the scope of the context. For example: with ops.Graph().as_default() as g: f_1 = Foo() # Uses the default registered kernel for the Foo op. with g.kernel_label_map({"Foo": "v_2"}): f_2 = Foo() # Uses the registered kernel with label "v_2" # for the Foo op. with g.kernel_label_map({"Foo": "v_3"}): f_3 = Foo() # Uses the registered kernel with label "v_3" # for the Foo op. with g.kernel_label_map({"Foo": ""}): f_4 = Foo() # Uses the default registered kernel # for the Foo op. Args: op_to_kernel_label_map: A dictionary mapping op type strings to kernel label strings. Returns: A context manager that sets the kernel label to be used for one or more ops created in that context. Raises: TypeError: If op_to_kernel_label_map is not a dictionary mapping strings to strings. zFop_to_kernel_label_map must be a dictionary mapping strings to stringsN)rarrrr]rrU)rlop_to_kernel_label_map saved_labelsrlabels rT_kernel_label_mapzGraph._kernel_label_mapsbB ,d 3 + ,,L0668 4#&$-. . $ < w2G$ & &w /4    4**73 4388:4.'5 42>w2G$ & &w / 4**73 44AD-"B64D-C! D-!C3D-6 C?D-CD-CD-CD-!D*9D  D* D% "D*$D% %D**D-c#fK|jrJ||_ di|_y#i|_wxYww)z0Specify gradient function for the given op type.N)r)rlgradient_function_maps rT_override_gradient_functionz!Graph._override_gradient_functions7*** *"7D' $&d!Bd!s1%1 .1c#^Kt|ts tdi}|jD]R\}}t|trt|ts td |j |||<||j |<T d|jD]\}} |||j |<y#t $rYMwxYw#t $r|j |=YCwxYw#|jD]4\}} |||j |<#t $r|j |=Y2wxYwwxYww)aEXPERIMENTAL: A context manager for overriding gradient functions. This context manager can be used to override the gradient function that will be used for ops within the scope of the context. For example: ```python @tf.RegisterGradient("CustomSquare") def _custom_square_grad(op, grad): # ... with tf.Graph().as_default() as g: c = tf.constant(5.0) s_1 = tf.square(c) # Uses the default gradient for tf.square. with g.gradient_override_map({"Square": "CustomSquare"}): s_2 = tf.square(s_2) # Uses _custom_square_grad to compute the # gradient of s_2. ``` Args: op_type_map: A dictionary mapping op type strings to alternative op type strings. Returns: A context manager that sets the alternative op type to be used for one or more ops created in that context. Raises: TypeError: If `op_type_map` is not a dictionary mapping strings to strings. z;op_type_map must be a dictionary mapping strings to stringsN)rarrrr]rrU)rl op_type_mapsaved_mappingsrrs rTgradient_override_mapzGraph.gradient_override_map*sdD k4 ( + ,,N#.#4#4#6 <#&--. . "&"="=g"Fw. 31?1H$ % %g .3    3))'2 3&1%6%6%83 !'> 31?1H$ % %g . 3))'2 33r<c:|jj|y)z5Marks the given `tensor` as unfeedable in this graph.N)rrQrlr,s rTprevent_feedingzGraph.prevent_feedingis  (rVc||jvS)z3Returns `True` if and only if `tensor` is feedable.)rrEs rT is_feedablezGraph.is_feedablems 11 11rVc:|jj|y)z2Marks the given `op` as unfetchable in this graph.N)rrQrs rTprevent_fetchingzGraph.prevent_fetchingqsb!rVct|tjr|j|jvS||jvS)z:Returns `True` if and only if `tensor_or_op` is fetchable.)rarrrr)rl tensor_or_ops rT is_fetchablezGraph.is_fetchableus8, 1 12 __D$9$9 99 !6!6 66rVc,|jsd|_yy)aMake device, colocation and dependencies stacks thread-local. Device, colocation and dependencies stacks are not thread-local be default. If multiple threads access them, then the state is shared. This means that one thread may affect the behavior of another thread. After this method is called, the stacks become thread-local. If multiple threads access them, then the state is not shared. Each thread uses its own value; a thread doesn't affect other threads by mutating such a stack. The initial value for every thread's stack is set to the current value of the stack when `switch_to_thread_local()` was first called. TN)rrs rTrzGraph.switch_to_thread_local|s  , ,*.d' -rVc|jrWt|jds+|jj }||j_|jj S|jS)Nr)rr8rrrrrlstack_copy_for_this_threads rTrzGraph._device_function_stacksa ((T'')A B%)%F%F%K%K%M"4N1    6 66 . ..rVc|jj}|Dcgc]}|j}}tt |}|Scc}wru)rrr_rFreversed)rluser_device_specsrdevice_functionsdevice_functions_outer_to_inners rT _device_functions_outer_to_innerz&Graph._device_functions_outer_to_innersL33==?2CD$ DD&*84D+E&F# **EsA cg}|jjD]>}|j}|jj|_|j |@|S)avReturn device function stack as a list of TraceableObjects. Returns: [traceable_stack.TraceableObject, ...] where each TraceableObject's .obj member is a displayable name for the user's argument to Graph.device, and the filename and lineno members point to the code location where Graph.device was called directly or indirectly by the user. )rpeek_traceable_objs copy_metadatarr^r)rlsnapshotrobj_copys rTrz.Graph._snapshot_device_function_stack_metadatasYH**>>@ ""$hWW))hlooh  OrVdevice_function_stackcN|jr||j_y||_yru)rrrr)rlr]s rTrzGraph._device_function_stacks& ((2Gd/+@d'rVc|jrWt|jds+|jj }||j_|jj S|jS)z-Return thread-local copy of colocation stack.r)rr8rrrrrPs rTrzGraph._colocation_stacksc ((T'')< =%)%A%A%F%F%H"/I,    1 11 ) ))rVc|jjDcic]'}|jj|j )c}Scc}w)z1Return colocation stack metadata as a dictionary.)rrYrrrZ)rl traceable_objs rTrz)Graph._snapshot_colocation_stack_metadatasM "33GGI    ; ; ==  s,A colocation_stackcN|jr||j_y||_yru)rrrr)rlrbs rTrzGraph._colocation_stacks% ((-=d*&6d"rVc|jrJt|jds|jdd|j_|jjS|jS)Nr)rr8rrrrs rTrz!Graph._control_dependencies_stacksX ((T'')F G  2 21 5 6    ; ;;  3 33rVcontrol_deps_controllerscN|jr||j_y||_yru)rrrr)rlres rTrz!Graph._control_dependencies_stacks#  ((7Od4/Gd,rVc|t|jdsg|j_|jjS)zBA stack to maintain distribution strategy context for each thread._distribution_strategy_stack)r8rrhrs rTrhz"Graph._distribution_strategy_stacks5 4%%'E F8:d5    : ::rVrhc&||j_yru)rrh)rlrhs rTrhz"Graph._distribution_strategy_stacks % 3rVc|t|jdsd|j_|jjS)z0For implementing `tf.distribute.set_strategy()`.distribute_strategy_scopeN)r8rrkrs rT!_global_distribute_strategy_scopez'Graph._global_distribute_strategy_scopes5 4%%'B C59d2    7 77rVc&||j_yru)rrk)rlrks rTrlz'Graph._global_distribute_strategy_scope s4MD0rVc@|jjtS)zvReturns a lock to guard code that creates & mutates ops. See the comment for self._group_lock for more info. )rgrouprrs rTrzGraph._mutation_locks    ! !"6 77rVc@|jjtS)zkReturns a lock to guard code for Session.run. See the comment for self._group_lock for more info. )rrorrs rT_session_run_lockzGraph._session_run_locks    ! !"9 ::rVr{)d)NFFF)NNNNNTT)rQrK)NNNNNT)T)TTrur{)~r|r}r~rrsrrrErrrr=contextmanagerrrrrr]rFrrrrrrrr'rrr*r r-rr1r3r5rrrDrrJrbrerhrjrprnrmrprAr?filter_tracebackr~rrrrr rrrrrTrrr=rrKrrrrrrrrrrrrrrrrrrXrr%rrobjectr"rrrrKr)rrrwr6r;r?rCrFrHrJrMrr0rrrWrrrrrrhrlr;r_Contextrrqrrs@rTrFrFs)Ve$T  iI  i 7htn7 7F:7x~:7 :7x 6tChsCx6H1I,I'J6 6 !!H"3Xc3h-?(@#@AH H"H 6tE#xS7I2I,J'K6 6.!!H"5hsCx.@)@#ABH H"H G  A,"9"9 A  A HSM ;;st   &% 6EJe Y   $%ePEJ$$L 2$ 2 : &&1P/ ## # 4*+;=##    5C*5C$=5Cv   F*FR"&  DU3nD.combined;si   % %&= >/0~~56        s3A0!A$A A$ A0A! A$$A-)A0) rr<rerqr%#executing_eagerly_outside_functionsr=rtr)rmrzs rTr%r%$s~   '(    >>1 22*,!!" + ,,   % %&= >>rVcDt|r tdt|S)aSpecifies the device for ops created/executed in this context. This function specifies the device to be used for ops created/executed in a particular context. Nested contexts will inherit and also create/execute their ops on the specified device. If a specific device is not required, consider not using this function so that a device can be automatically assigned. In general the use of this function is optional. `device_name` can be fully specified, as in "/job:worker/task:1/device:cpu:0", or partially specified, containing only a subset of the "/"-separated fields. Any fields which are specified will override device annotations from outer scopes. For example: ```python with tf.device('/job:foo'): # ops created here have devices with /job:foo with tf.device('/job:bar/task:0/device:gpu:2'): # ops created here have the fully specified device above with tf.device('/device:gpu:1'): # ops created here have the device '/job:foo/device:gpu:1' ``` Args: device_name: The device name to use in the context. Returns: A context manager that specifies the default device to use for newly created ops. Raises: RuntimeError: If a function is passed in. z%tf.device does not support functions.)rerqr%r7s rT device_v2r}Hs$Dk > ??  rVrc4tj|S)zWrapper for `Graph.container()` using the default graph. Args: container_name: The container string to use in the context. Returns: A context manager that specifies the default container to use for newly created stateful ops. )rr)rs rTrros   & &~ 66rVcZtjr8|,t|ds t|}t |jSt St }t|tr2|jr|j |jStd|j|||S)aReturns a context manager for colocating op gradients with an op. Internal API. In eager mode, returns a context manager that sets the default device for new ops to the same device as the given op. Does the same if a function is currently being built (i.e. the current mode is graph, but the overall mode is eager). In all other cases, returns a `Graph.colocate_with()` context manager, optionally accounting for gradients (if a gradient UID is specified). Args: op: Operation or Tensor with which to colocate. gradient_uid: Optional gradient UID to enable colocation of gradients during compilation. ignore_existing: See `Graph.colocate_with()`. Returns: A context manager used to colocate ops and gradients with the specified operation. r%zbEncountered an Eager-defined Tensor during graph construction, but a function was not being built.)rr) rr<r8rr%rrrarrprRr)rrr default_graphs rTrr}s.   ~ R " r " BII   !!%'M"k"  ( (##BII..MN N  4 4  5 HHrVct|d|S)N)r)rrrs rTrrs $R OOrVz,Colocations handled automatically by placer.)date instructionsrct||Sru)rrs rT_colocate_withrs r? ++rVrwctjr&|r|D]}t|s|tSt j |S)a# Wrapper for `Graph.control_dependencies()` using the default graph. See `tf.Graph.control_dependencies` for more details. In TensorFlow 2 with eager and/or Autograph, you should not need this method most of the times, as ops execute in the expected order thanks to automatic control dependencies. Only use it to manually control ordering, for example as a workaround to known issues such as `tf.function` with `tf.debugging.assert*` and `tf.py_function`. For example: >>> @tf.function( ... input_signature=[tf.TensorSpec([None, None], tf.float32), ... tf.TensorSpec([None, None], tf.float32)]) ... def my_assert_func_1(x, bias): ... # `tf.function` attempts to execute `tf.math.add` in parallel to ... # `assert_equal`. As a result an error can get raised from `tf.math.add` ... # without triggering the assertion error. ... tf.assert_equal(tf.shape(x)[1], ... tf.shape(bias)[1], ... message='bad shape') ... return x + bias >>> # Error raised in either `add` or `assert` >>> my_assert_func_1(tf.ones((2, 5)), tf.ones((2, 7))) Traceback (most recent call last): ... InvalidArgumentError: ... >>> @tf.function( ... input_signature=[tf.TensorSpec([None, None], tf.float32), ... tf.TensorSpec([None, None], tf.float32)]) ... def my_assert_func_2(x, bias): ... with tf.control_dependencies( ... [tf.assert_equal(tf.shape(x)[1], ... tf.shape(bias)[1], ... message='bad shape')]): ... return x + bias >>> # Error raised in `assert` >>> my_assert_func_2(tf.ones((2, 5)), tf.ones((2, 7))) Traceback (most recent call last): ... InvalidArgumentError: ... When eager execution is enabled, any callable object in the `control_inputs` list will be called. Args: control_inputs: A list of `Operation` or `Tensor` objects which must be executed or computed before running the operations defined in the context. Can also be `None` to clear the control dependencies. If eager execution is enabled, any callable object in the `control_inputs` list will be called. Returns: A context manager that specifies control dependencies for all operations constructed within the context. )rr<rerrrw)rcontrols rTrwrwsO@  #' G  )     3 3N CCrVc|:tj}| td|j|ur$td|j|ur td|j ||y)a*Uses the default session to run "operation". Args: operation: The Operation to be run. feed_dict: A dictionary that maps Tensor objects (or tensor names) to lists, numpy ndarrays, TensorProtos, or strings. graph: The graph in which "operation" is defined. session: (Optional) A different session to use to run "operation". Raises: ValueError: If no default session is available; the default session does not have "graph" as its graph; or if "session" is specified, and it does not have "graph" as its graph. NzCannot execute operation using `run()`: No default session is registered. Use `with sess.as_default():` or pass an explicit session to `run(session=sess)`zCannot use the default session to execute operation: the operation's graph is different from the session's graph. Pass an explicit session to run(session=sess).zoCannot use the given session to execute operation: the operation's graph is different from the session's graph.)r*get_default_sessionrRrr) operationrkrrls rTrrs~  _'')G - ..}}E! , -- }}E!   !! ++i#rVc|eZdZdZdfd ZdefdZdefdZdfd Ze jde effd Z xZ S) _DefaultGraphStackzHA thread-local stack of objects for providing an implicit default graph.rQc8tt| d|_yru)rtrrs_global_default_graphrs rTrsz_DefaultGraphStack.__init__*s d,.!%DrVc|jr|jdS|jr |jSt|_|jS)z=Override that returns a global default if the stack is empty.r[)r*rrFrs rT get_defaultz_DefaultGraphStack.get_default.sB zz ZZ^ # #  ' ''#(7d  ' ''rVcP|jt|_|jSru)rrFrs rT_GetGlobalDefaultGraphz)_DefaultGraphStack._GetGlobalDefaultGraph8s& !!) $)7d  % %%rVc8tt| d|_yru)rtrresetrrs rTrz_DefaultGraphStack.resetAs d)+!%DrVc#Ktjjj|j|j|j  t t|#|5}tj5|ddddddtjjjy#1swY>xYw#1swYBxYw#tjjjwxYwwru) rcontext_switchespushrprrrtrr graph_moder')rldefaultrrs rTrz!_DefaultGraphStack.get_controllerEs OO&&++G,E,E,3,>,>,3,J,JL/ # &&-.23W5G5G5I oo((,,.  oo((,,.sNADC%C:B<?CC-D<C CC C.DDr{)r|r}r~rrsrFrrrr=rtrrrrs@rTrr'sMP&(5(&e&& /x /  /rVrrct}d}|j}tjs$|jr t d|j }n~ttjjjD]*}|s |j}|jr|j}n|tjj }| t d||fS)z2Get the outermost context not building a function.Nz(The global graph is building a function.zNAll graphs are building functions, and no eager context was previously active.)rrrr*rprqrrSrr device_stackis_building_functionenter_context_fnr)r outer_contextinnermost_nonempty_device_stack stack_entrys rT)_get_outer_context_and_inner_device_stackrZs$%--$1$H$H!  # #&& C DD!,,M  1 B B H HI ,*5*B*B'  - -#44   +AACNNm > ?? 7 77rV init_scopec #Ktjr"tj5ddddyt j }|r |ddk7r|dz}t \}}d}d} |5t|d5td5tj5t}d}tjst }|j}||_ nO|M|jD]:}|jn,|jstj}|j}n||5dddddddddddddddd|||_ yy#1swYyxYw#1swY@xYw#1swYDxYw#1swYHxYw#1swYLxYw#1swYPxYw#|||_ wwxYww)aA context manager that lifts ops out of control-flow scopes and function-building graphs. There is often a need to lift variable initialization ops out of control-flow scopes, function-building graphs, and gradient tapes. Entering an `init_scope` is a mechanism for satisfying these desiderata. In particular, entering an `init_scope` has three effects: (1) All control dependencies are cleared the moment the scope is entered; this is equivalent to entering the context manager returned from `control_dependencies(None)`, which has the side-effect of exiting control-flow scopes like `tf.cond` and `tf.while_loop`. (2) All operations that are created while the scope is active are lifted into the lowest context on the `context_stack` that is not building a graph function. Here, a context is defined as either a graph or an eager context. Every context switch, i.e., every installation of a graph as the default graph and every switch into eager mode, is logged in a thread-local stack called `context_switches`; the log entry for a context switch is popped from the stack when the context is exited. Entering an `init_scope` is equivalent to crawling up `context_switches`, finding the first context that is not building a graph function, and entering it. A caveat is that if graph mode is enabled but the default graph stack is empty, then entering an `init_scope` will simply install a fresh graph as the default one. (3) The gradient tape is paused while the scope is active. When eager execution is enabled, code inside an init_scope block runs with eager execution enabled even when tracing a `tf.function`. For example: ```python tf.compat.v1.enable_eager_execution() @tf.function def func(): # A function constructs TensorFlow graphs, # it does not execute eagerly. assert not tf.executing_eagerly() with tf.init_scope(): # Initialization runs with eager execution enabled assert tf.executing_eagerly() ``` Raises: RuntimeError: if graph state is incompatible with this initialization. Nr[rF skip_on_eager)rr<r"stop_recordingrrrrrwrrrr_r`r%)rrr outer_graphouter_device_stackcontext_managercontext_manager_inputrs rTrrsf           . . 0E rc!cke 233M2K!@ ?J u&';(**,- $((* *++*AA /N+ , , 8<FFH k##+%% 'o&1&<&<#  2 3   5>  -? * !a  V  5>  -? * !s)G E2AG 2F:9F. F"F(A*F 'F :E> ?F FF"F.F:' G 2E;7G >FF F FF F""F+ 'F..F73F:: GG r{ctjryt\}}|5tjcdddS#1swYyxYw)a}Returns True if executing eagerly, even if inside a graph function. This function will check the outermost context for the program and see if it is in eager mode. It is useful comparing to `tf.executing_eagerly()`, which checks the current context and will return `False` within a `tf.function` body. It can be used to build library that behave differently in eager runtime and v1 session runtime (deprecated). Example: >>> tf.compat.v1.enable_eager_execution() >>> @tf.function ... def func(): ... # A function constructs TensorFlow graphs, it does not execute eagerly, ... # but the outer most context is still eager. ... assert not tf.executing_eagerly() ... return tf.compat.v1.executing_eagerly_outside_functions() >>> func() Returns: boolean, whether the outermost context is in eager mode. TN)rr<r)rrs rTr{r{sF2  @BM1 )  & & ()))s AAinside_functionc*tjS)a>Indicates whether the caller code is executing inside a `tf.function`. Returns: Boolean, True if the caller code is executing inside a `tf.function` rather than eagerly. Example: >>> tf.inside_function() False >>> @tf.function ... def f(): ... print(tf.inside_function()) >>> f() True )rrprrVrTrr s$   . ..rVenable_eager_executionctjjdtjddt j t jk7rt|||dSy)a Enables eager execution for the lifetime of this program. Eager execution provides an imperative interface to TensorFlow. With eager execution enabled, TensorFlow functions execute operations immediately (as opposed to adding to a graph to be executed later in a `tf.compat.v1.Session`) and return concrete values (as opposed to symbolic references to a node in a computational graph). For example: ```python tf.compat.v1.enable_eager_execution() # After eager execution is enabled, operations are executed as they are # defined and Tensor objects hold concrete values, which can be accessed as # numpy.ndarray`s through the numpy() method. assert tf.multiply(6, 7).numpy() == 42 ``` Eager execution cannot be enabled after TensorFlow APIs have been used to create or execute graphs. It is typically recommended to invoke this function at program startup and not in a library (as most libraries should be usable both with and without eager execution). @compatibility(TF2) This function is not necessary if you are using TF2. Eager execution is enabled by default. @end_compatibility Args: config: (Optional.) A `tf.compat.v1.ConfigProto` to use to configure the environment in which operations are executed. Note that `tf.compat.v1.ConfigProto` is also used to configure graph execution (via `tf.compat.v1.Session`) and many options within `tf.compat.v1.ConfigProto` are not implemented (or are irrelevant) when eager execution is enabled. device_policy: (Optional.) Policy controlling how operations requiring inputs on a specific device (e.g., a GPU 0) handle inputs on a different device (e.g. GPU 1 or CPU). When set to None, an appropriate value will be picked automatically. The value picked may change between TensorFlow releases. Valid values: - DEVICE_PLACEMENT_EXPLICIT: raises an error if the placement is not correct. - DEVICE_PLACEMENT_WARN: copies the tensors which are not on the right device but logs a warning. - DEVICE_PLACEMENT_SILENT: silently copies the tensors. Note that this may hide performance problems as there is no notification provided when operations are blocked on the tensor being copied between devices. - DEVICE_PLACEMENT_SILENT_FOR_INT32: silently copies int32 tensors, raising errors on the other ones. execution_mode: (Optional.) Policy controlling how operations dispatched are actually executed. When set to None, an appropriate value will be picked automatically. The value picked may change between TensorFlow releases. Valid values: - SYNC: executes each operation synchronously. - ASYNC: executes each operation asynchronously. These operations may return "non-ready" handles. Raises: ValueError: If eager execution is enabled after creating/executing a TensorFlow graph, or if options provided conflict with a previous call to this function. TrzEnabling eager executionNconfig device_policyexecution_mode server_def) _api_usage_gaugeget_cellrloggingvlogrdefault_execution_mode EAGER_MODEenable_eager_execution_internal)rrrs rTrr s]H!!$' ,,q,- ##w'9'99 *#%  :rVdisable_eager_executionctjjdtjddt j t _t j}|d|j_ yy)a{Disables eager execution. This function can only be called before any Graphs, Ops, or Tensors have been created. @compatibility(TF2) This function is not necessary if you are using TF2. Eager execution is enabled by default. If you want to use Graph mode please consider [tf.function](https://www.tensorflow.org/api_docs/python/tf/function). @end_compatibility FrzDisabling eager executionN) rrrrrr GRAPH_MODEr context_safe_thread_local_datais_eager)rs rTrrns^!!%( ,,q-.#*#5#5'  !]$)A!rVc|1t|tjstdt |z|dt j t jt jt jfvr td|dt jt jfvr tdt jt jk(rtj du}|r tdt j"t _ t j$5t j&-t j(t j*||||n||t j&j,us<||t j&j.us||t j&j0urftdt j&j,d|d t j&j.d |d t j&j0d |d dt j&j2_dddt j6t _y#1swY#xYw)aEnables eager execution for the lifetime of this program. Most of the doc string for enable_eager_execution is relevant here as well. Args: config: See enable_eager_execution doc string device_policy: See enable_eager_execution doc string execution_mode: See enable_eager_execution doc string server_def: (Optional.) A tensorflow::ServerDef proto. Enables execution on remote devices. GrpcServers need to be started by creating an identical server_def to this, and setting the appropriate task_indexes, so that the servers can communicate. It will then be possible to execute operations on remote devices. Raises: ValueError Nz+config must be a tf.ConfigProto, but got %sz5device_policy must be one of None, DEVICE_PLACEMENT_*z/execution_mode must be one of None, SYNC, ASYNCz> I JJ ##w'9'9922$>  H JJ#*#5#5' : !!'//%' #!"  &0@0@0H0H"H  $  0 0 ? ? ?  % !1!1!A!A A     # #VW-=-=-L-L '**::N  L MM6:g))2-:4(('/5::s DIIcDttj||y)aRuns the program with an optional main function and argv list. The program will run with eager execution enabled. Example: ```python import tensorflow as tf # Import subject to future changes: def main(_): u = tf.constant(6.0) v = tf.constant(7.0) print(u * v) if __name__ == "__main__": tfe.run() ``` Args: main: the main function to run. argv: the arguments to pass to it. N)rrr)mainargvs rT eager_runrs.''$rVreset_default_graphcjtjs tdtjy)aClears the default graph stack and resets the global default graph. NOTE: The default graph is a property of the current thread. This function applies only to the current thread. Calling this function while a `tf.compat.v1.Session` or `tf.compat.v1.InteractiveSession` is active will result in undefined behavior. Using any previously created `tf.Operation` or `tf.Tensor` objects after calling this function will result in undefined behavior. @compatibility(TF2) `reset_default_graph` does not work with either eager execution or `tf.function`, and you should not invoke it directly. To migrate code that uses Graph-related functions to TF2, rewrite the code without them. See the [migration guide](https://www.tensorflow.org/guide/migrate) for more description about the behavior and semantic changes between Tensorflow 1 and Tensorflow 2. @end_compatibility Raises: AssertionError: If this function is called within a nested graph. zDo not use tf.reset_default_graph() to clear nested graphs. If you need a cleared graph, exit the nesting and create a new graph.N)r is_clearedAssertionErrorrrrVrTrrs3.  ( ( * D EErVrc*tjS)aReturns the default graph for the current thread. The returned graph will be the innermost graph on which a `Graph.as_default()` context has been entered, or a global default graph if none has been explicitly created. NOTE: The default graph is a property of the current thread. If you create a new thread, and wish to use the default graph in that thread, you must explicitly add a `with g.as_default():` in that thread's function. @compatibility(TF2) `get_default_graph` does not work with either eager execution or `tf.function`, and you should not invoke it directly. To migrate code that uses Graph-related functions to TF2, rewrite the code without them. See the [migration guide](https://www.tensorflow.org/guide/migrate) for more description about the behavior and semantic changes between Tensorflow 1 and Tensorflow 2. @end_compatibility Returns: The default `Graph` being used in the current thread. )rrrrVrTrrs2  ) ) ++rVc:ttjdk\S)z)Returns True if there is a default graph.r)rQrr*rrVrThas_default_graphrs ! ' ' (A --rVz__internal__.get_name_scopectjr-tjjjdSt j S)a%Returns the current name scope in the default_graph. For example: ```python with tf.name_scope('scope1'): with tf.name_scope('scope2'): print(tf.get_name_scope()) ``` would print the string `scope1/scope2`. Returns: A string representing the current name scope. rrr< scope_namerstriprrrrVrTrr#s@   ??  ' ' . .s 33   + + --rVc zt|dd}t|dd}|r|r||urt|d|d|d|dyyy)zFail if the 2 items are from different graphs. Args: original_item: Original item to check against. item: Item to check. Raises: ValueError: if graphs do not match. rNz must be from the same graph as z (graphs are z and z).)rrR) original_itemroriginal_graphrs rTr/r/8sP='48. $ &%."=  }e^ 5 66#>^rVcrt}|jr|St|}|rt|tst d|d}|D]h}d}t|t tfr|}n t|}|,|s|}t|dd}>| t||M|j|us\td|z|xs|S)a&Returns the appropriate graph to use for the given inputs. This library method provides a consistent algorithm for choosing the graph in which an Operation should be constructed: 1. If the default graph is being used to construct a function, we use the default graph. 2. If the "graph" is specified explicitly, we validate that all of the inputs in "op_input_list" are compatible with that graph. 3. Otherwise, we attempt to select a graph from the first Operation- or Tensor-valued input in "op_input_list", and validate that all other such inputs are in the same graph. 4. If the graph was not specified and it could not be inferred from "op_input_list", we attempt to use the default graph. Args: op_input_list: A list of inputs to an operation, which may include `Tensor`, `Operation`, and other objects that may be converted to a graph element. graph: (Optional) The explicit graph to use. Raises: TypeError: If op_input_list is not a list or tuple, or if graph is not a Graph. ValueError: If a graph is explicitly passed and not all inputs are from it, or if the inputs are from multiple graphs, or we could not find a graph and there was no default graph. Returns: The appropriate graph to use for the given inputs. z!Input graph needs to be a Graph: Nrz#%s is not from the passed-in graph.) rrprrarFrrKrrrr/rrR) op_input_listrcurrent_default_graphoriginal_graph_elementr graph_elements rT_get_graph_from_inputsrJs@,-,,   &- :eU+ UD EE PhM(Y78m'1m !. w5 ! -1=A   e +>NOOP"  '''rV GraphKeysceZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!d Z"d!Z#d"Z$eeeeee eegZ%d#Z&e'jPe)jTd$d%d&Z+y$)'raStandard names to use for graph collections. The standard library uses various well-known names to collect and retrieve values associated with a graph. For example, the `tf.Optimizer` subclasses default to optimizing the variables collected under `tf.GraphKeys.TRAINABLE_VARIABLES` if none is specified, but it is also possible to pass an explicit list of variables. The following standard keys are defined: * `GLOBAL_VARIABLES`: the default collection of `Variable` objects, shared across distributed environment (model variables are subset of these). See `tf.compat.v1.global_variables` for more details. Commonly, all `TRAINABLE_VARIABLES` variables will be in `MODEL_VARIABLES`, and all `MODEL_VARIABLES` variables will be in `GLOBAL_VARIABLES`. * `LOCAL_VARIABLES`: the subset of `Variable` objects that are local to each machine. Usually used for temporarily variables, like counters. * `MODEL_VARIABLES`: the subset of `Variable` objects that are used in the model for inference (feed forward). * `TRAINABLE_VARIABLES`: the subset of `Variable` objects that will be trained by an optimizer. See `tf.compat.v1.trainable_variables` for more details. * `SUMMARIES`: the summary `Tensor` objects that have been created in the graph. See `tf.compat.v1.summary.merge_all` for more details. * `QUEUE_RUNNERS`: the `QueueRunner` objects that are used to produce input for a computation. See `tf.compat.v1.train.start_queue_runners` for more details. * `MOVING_AVERAGE_VARIABLES`: the subset of `Variable` objects that will also keep moving averages. See `tf.compat.v1.moving_average_variables` for more details. * `REGULARIZATION_LOSSES`: regularization losses collected during graph construction. The following standard keys are _defined_, but their collections are **not** automatically populated as many of the others are: * `WEIGHTS` * `BIASES` * `ACTIVATIONS` variableslocal_variablesmetric_variablesmodel_variablestrainable_variables summaries queue_runnerstable_initializerasset_filepathsmoving_average_variablesregularization_lossesconcatenated_variablessaversweightsbiases activations update_opslossessaveable_objects resourceslocal_resourcestrainable_resource_variablesinit_op local_init_opready_opready_for_local_init_op summary_op global_step eval_steptrain_op cond_context while_context _SUMMARY_V2streaming_model_portsNz,Use `tf.GraphKeys.GLOBAL_VARIABLES` instead.c|jSru)GLOBAL_VARIABLES)rs rT VARIABLESzGraphKeys.VARIABLESs   rV),r|r}r~rrLOCAL_VARIABLESMETRIC_VARIABLESMODEL_VARIABLESTRAINABLE_VARIABLES SUMMARIES QUEUE_RUNNERSTABLE_INITIALIZERSASSET_FILEPATHSMOVING_AVERAGE_VARIABLESREGULARIZATION_LOSSESCONCATENATED_VARIABLESSAVERSWEIGHTSBIASES ACTIVATIONS UPDATE_OPSLOSSESSAVEABLE_OBJECTS RESOURCESLOCAL_RESOURCESTRAINABLE_RESOURCE_VARIABLESINIT_OP LOCAL_INIT_OPREADY_OPREADY_FOR_LOCAL_INIT_OP SUMMARY_OP GLOBAL_STEP EVAL_STEPTRAIN_OP COND_CONTEXT WHILE_CONTEXT_SUMMARY_COLLECTION_VARIABLE_COLLECTIONS_STREAMING_MODEL_PORTSr8 classpropertyr9rrrrVrTrrs).d!&/(%/.)!-*&/713 & ' &+* &')&/!? '!- (5*+) ( ,!-&" 3  ;$ NO P! rVcX|jj|jy)aCleans up reference cycles from a `Graph`. Helpful for making sure the garbage collector doesn't need to run after a temporary `Graph` is no longer needed. Args: graph: A `Graph` object to destroy. Neither it nor any of its ops are usable after this function runs. N)rclear Dismantlers rTdismantle_graphr9s //rVrc8tj||y)aWrapper for `Graph.add_to_collection()` using the default graph. See `tf.Graph.add_to_collection` for more details. Args: name: The key for the collection. For example, the `GraphKeys` class contains many standard names for collections. value: The value to add to the collection. @compatibility(eager) Collections are only supported in eager when variables are created inside an EagerVariableStore (e.g. as part of a layer or template). @end_compatibility N)rr)rrs rTrr*s"''e4rVrc8tj||y)aWrapper for `Graph.add_to_collections()` using the default graph. See `tf.Graph.add_to_collections` for more details. Args: names: The key for the collections. The `GraphKeys` class contains many standard names for collections. value: The value to add to the collections. @compatibility(eager) Collections are only supported in eager when variables are created inside an EagerVariableStore (e.g. as part of a layer or template). @end_compatibility N)rr)rrs rTrr>s"((6rVrc4tj|S)avWrapper for `Graph.get_collection_ref()` using the default graph. See `tf.Graph.get_collection_ref` for more details. Args: key: The key for the collection. For example, the `GraphKeys` class contains many standard names for collections. Returns: The list of values in the collection with the given `name`, or an empty list if no value has been added to that collection. Note that this returns the collection list itself, which can be modified in place to change the collection. @compatibility(eager) Collections are not supported when eager execution is enabled. @end_compatibility )rrrs rTrrRs*   / / 44rVrc6tj||S)aWrapper for `Graph.get_collection()` using the default graph. See `tf.Graph.get_collection` for more details. Args: key: The key for the collection. For example, the `GraphKeys` class contains many standard names for collections. scope: (Optional.) If supplied, the resulting list is filtered to include only items whose `name` attribute matches using `re.match`. Items without a `name` attribute are never returned if a scope is supplied and the choice or `re.match` means that a `scope` without special tokens filters by prefix. Returns: The list of values in the collection with the given `name`, or an empty list if no value has been added to that collection. The list contains the values in the order under which they were collected. @compatibility(eager) Collections are not supported when eager execution is enabled. @end_compatibility )rr)rrs rTrrjs4   + +C 77rVc2tjS)z8Returns a list of collections used in the default graph.)rrrrVrTrrs   4 4 66rVctjs t|||S|r tS||n|}|r0t d|Dd}||j j |St|xsdS)a5Internal-only entry point for `name_scope*`. Internal ops do not use the public API and instead rely on `ops.name_scope` regardless of the execution mode. This function dispatches to the correct `name_scope*` implementation based on the arguments provided and the current mode. Specifically, * if `values` contains a graph tensor `Graph.name_scope` is used; * `name_scope_v1` is used in graph mode; * `name_scope_v2` -- in eager mode. Args: name: The name argument that is passed to the op function. default_name: The default name to use if the `name` argument is `None`. values: The list of `Tensor` arguments that are passed to the op function. skip_on_eager: Indicates to return NullContextmanager if executing eagerly. By default this is True since naming tensors and operations in eager mode have little use and cause unnecessary performance overhead. However, it is important to preserve variable names since they are often useful for debugging and saved models. Returns: `name_scope*` context manager. Nc38K|]}t|s|ywru)is_symbolic_tensor)rrs rTrzname_scope..s@5&8&?@sr)rr<internal_name_scope_v1rnextrr name_scope_v2)r default_namerr graph_values rTrrs}6  " " $ !$ f ==  4$ @F@$K    ) )$ // tzr ""rVc>eZdZdZedZdd dZdefdZd dZ y) rBz&Graph-only version of `name_scope_v1`.c|jSru_namers rTrzinternal_name_scope_v1.namerDrVNrQc|'t|tstdt|z||n||_||_||_y)^Initialize the context manager. Args: name: The name argument that is passed to the op function. default_name: The default name to use if the `name` argument is `None`. values: The list of `Tensor` arguments that are passed to the op function. Raises: TypeError: if `default_name` is passed in but not a string. Nze`default_name` type (%s) is not a string type. You likely meant to pass this into the `values` kwarg.)rar]rrrJ _default_name_valuesrlrrErs rTrszinternal_name_scope_v1.__init__sS  J|S$A  /15l1C D EE"&4DJ%DDLrVcf|j2|j&td|jd|jdt }|jr_|j sSt |j}||ur2|}|j|_|jjnd|_nd|_ |j|j|_ |jjS#|j+|jjtjxYw)zStart the scope block. Returns: The scope name. Raises: ValueError: if neither `name` nor `default_name` is provided but `values` are. NzAt least one of name (z) and default_name (z) must be provided.)rJrNrRrMrrprr _g_managerrr _name_scopersysexc_info)rlr g_from_inputss rTrz internal_name_scope_v1.__enter__s zzdll6  ZZ++ - .. A ||A//-T\\:m a  ,,. !!#do djj1d    ' ' ))  $   #,,.1 s <9C66:D0c|jj||j|jj|yyru)rRrrQrlrTs rTrzinternal_name_scope_v1.__exit__s;Dx( "doo)#rVrzr{) r|r}r~rrrrsr]rrrrVrTrBrBs..  && & P*rVrBrcVeZdZdZddgZedZd d dZdee fdZ dee fd Z y) name_scope_v1aA context manager for use when defining a Python op. This context manager validates that the given `values` are from the same graph, makes that graph the default graph, and pushes a name scope in that graph (see `tf.Graph.name_scope` for more details on that). For example, to define a new Python op called `my_op`: ```python def my_op(a, b, c, name=None): with tf.name_scope(name, "MyOp", [a, b, c]) as scope: a = tf.convert_to_tensor(a, name="a") b = tf.convert_to_tensor(b, name="b") c = tf.convert_to_tensor(c, name="c") # Define some computation that uses `a`, `b`, and `c`. return foo_op(..., name=scope) ``` rJrRc|jSrurIrs rTrzname_scope_v1.namerDrVNrQcNt|||d|_|||_y||_y)rLFrN)rrRrJrOs rTrszname_scope_v1.__init__#s+" lF%9D!%DJ4DJrVc6|jjSru)rRrrs rTrzname_scope_v1.__enter__2s    % % ''rVc4|jj|Sru)rRrrWs rTrzname_scope_v1.__exit__5s $4   $ $h //rVrzr{) r|r}r~rrrrrsr r]rrrrrVrTrYrYsJ* &)   8(#(08D>0rVrYget_current_name_scopectj}|jr|jjdSt j S)aReturns current full name scope specified by `tf.name_scope(...)`s. For example, ```python with tf.name_scope("outer"): tf.get_current_name_scope() # "outer" with tf.name_scope("inner"): tf.get_current_name_scope() # "outer/inner" ``` In other words, `tf.get_current_name_scope()` returns the op name prefix that will be prepended to, if an op is created at that place. Note that `@tf.function` resets the name scope stack as shown below. ``` with tf.name_scope("outer"): @tf.function def foo(x): with tf.name_scope("inner"): return tf.add(x * x) # Op name is "inner/Add", not "outer/inner/Add" ``` rr)r1s rTr^r^9sC8 # >>  %%   - - //rVceZdZdZddgZddZedZdefdZ d dd dd dde fd Z de ee ed efffdZddZy)rDaKA 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`: ```python def my_op(a, b, c, name=None): with tf.name_scope("MyOp") as scope: a = tf.convert_to_tensor(a, name="a") b = tf.convert_to_tensor(b, name="b") c = tf.convert_to_tensor(c, name="c") # Define some computation that uses `a`, `b`, and `c`. return foo_op(..., name=scope) ``` When executed, the Tensors `a`, `b`, `c`, will have names `MyOp/a`, `MyOp/b`, and `MyOp/c`. Inside a `tf.function`, if the scope name already exists, the name will be made unique by appending `_n`. For example, calling `my_op` the second time will generate `MyOp_1/a`, etc. rJ _exit_fnsrQNcVt|ts td||_g|_y)zInitialize the context manager. Args: name: The prefix to use on all names created within the name scope. Raises: ValueError: If name is not a string. z%name for name_scope must be a string.N)rar]rRrJrargs rTrszname_scope_v2.__init__ys( dC > ??DJDNrVc|jSrurIrs rTrzname_scope_v2.namerDrVctjjrbj|j}|sd}n|ddk(r|}nr |zdz}n|dz}|_fd}|jj ||St j|j}|j}|jj |j|S)z?Start the scope block. Returns: The scope name. rr[rc_yru)r)rr1old_names rT_restore_name_scopez4name_scope_v2.__enter__.._restore_name_scopes !rV) rr<rrJrarrrrr)rlrrrgrr1rfs @@rTrzname_scope_v2.__enter__s // C  h ZZd  8s? _s* CZ !cn" nn/0  !,,TZZ8e??$j nnENN+ rVrrrcH|jj|||yr)rar'rs rTrzname_scope_v2.__exit__s"DNN9m< rV.c2|j|jfSrurJrars rT __getstate__zname_scope_v2.__getstate__s ::t~~ %%rVc,|d|_|d|_y)Nrrrj)rlstates rT __setstate__zname_scope_v2.__setstate__sqDJ1XDNrVr{)r|r}r~rrrsrrr]rrrrrFrrrkrnrrVrTrDrD\s2 $)     D'+<@  &E#tHS#X,>'?"?@&rVrDc|rB|ddk(r|dd} d|zdz}tj|dtj|dS|S#t$r!}t j ||cYd}~Sd}~wwxYw) zRemoves name scope from a name. Args: name: A `string` name. export_scope: Optional `string`. Name scope to remove. Returns: Name with name scope removed, or the original name if export_scope is None. r[rNz([\^]|loc:@|^)z [\/]+(.*)z\1\2r)countrsubr7rwrrwarning)r export_scopestr_to_replacer s rTstrip_name_scopervs~B3!#2&l)<7,Fn VVNGV]]4-@ JJ K  ooa ks3A A1A,&A1,A1c|r@|ddk(r|dd} d}tj|d|zdztj|S|S#t$r!}t j ||cYd}~Sd}~wwxYw)zPrepends name scope to a name. Args: name: A `string` name. import_scope: Optional `string`. Name scope to add. Returns: Name with name scope added, or the original name if import_scope is None. r[rNz([\^]|loc:@|^)(.*)z\1z/\2rq)r import_scoperur s rTprepend_name_scoperysB3!#2&l,n VVNEL$86$AMM$')) K  ooa ks1A A/A*$A/*A/op_scopec#Ktjdt|||5}|dddy#1swYyxYww)zDDEPRECATED. Same as name_scope above, just different argument order.zdtf.op_scope(values, name, default_name) is deprecated, use tf.name_scope(name, default_name, values))rErN)rwarnr)rrrErs rTrzrzsB ,,@A$\&AU Ks$A4 A=Azproto functionsc|rt|s td|rt|s tdtj|||f|y)axRegisters `to_proto` and `from_proto` functions for collection_name. `to_proto` function converts a Python object to the corresponding protocol buffer, and returns the protocol buffer. `from_proto` function converts protocol buffer into a Python object, and returns the object.. Args: collection_name: Name of the collection. proto_type: Protobuf type, such as `saver_pb2.SaverDef`, `variable_pb2.VariableDef`, `queue_runner_pb2.QueueRunnerDef`.. to_proto: Function that implements Python object to protobuf conversion. from_proto: Function that implements protobuf to Python object conversion. zto_proto must be callable.zfrom_proto must be callable.N)rer_proto_function_registryr)collection_name proto_typeto_proto from_protos rTregister_proto_functionrsJ&hx( 0 11, 2 33##Z:$F$35rVcR tj|dS#t$rYywxYw)z+Returns the proto_type for collection_name.rNr~rrrs rTget_collection_proto_typer/ # * *? ;A >>    &&cR tj|dS#t$rYywxYw)z2Returns the to_proto function for collection_name.rNrrs rTget_to_proto_functionr'rrcR tj|dS#t$rYywxYw)z4Returns the from_proto function for collection_name.rNrrs rTget_from_proto_functionr1rrcl|yt|tr|dfSt|drt|jtj rpd}|j |_|j|_|jr'|j|jj|fS|jj|fSt|tr-tjst|djdfSt|tj r|jdfSt|djdfS)zFOperation object corresponding to v to use for colocation constraints.NrzhandlecyrurrrVrTrz&_op_to_colocate_with..PsrVT)r)rarKr8rrrr%rrprsrrrr<rr6 NativeObject)rrrs rTrr;sY 9 d7N Qj:3D3DE(#$88 !"  ]]188 $ ' ')> >> XX[[/ //;(A(A(C Qt , / / 55!X**+ 44: Qt , / / 55rVrrctj|j|j|j|j |j }t|S)zMake a given op wrapper function `f` raw. Raw op wrappers can only be called with keyword arguments. Args: f: An op wrapper function to make raw. Returns: Raw `f`. )types FunctionType__code__ __globals__r| __defaults__ __closure__rB)rrs rT to_raw_oprbs= Q]]AJJ(! ArVcx|xjdt||ndzz c_tj|d)Nz name: r)rr]r r)r rs rTraise_from_not_ok_statusrts4)) C(8bAAB) !!!$$.rVct}|jstdj||j |y)aAdd a callback to run when the default function graph goes out of scope. Usage: ```python @tf.function def fn(x, v): expensive = expensive_object(v) add_exit_callback_to_default_func_graph(lambda: expensive.release()) return g(x, expensive) fn(x=tf.constant(...), v=...) # `expensive` has been released. ``` Args: fn: A callable that takes no arguments and whose output is ignored. To be executed when exiting func graph scope. Raises: RuntimeError: If executed when the current default graph is not a FuncGraph, or not currently executing in function creation mode (e.g., if inside an init_scope). zPCannot add scope exit callbacks when not building a function. Default graph: {}N)rrrqr:_add_scope_exit_callback)fnrs rT'add_exit_callback_to_default_func_graphrysA2$%-  ) )  "F=1 33((,rVcg}d}|jD]}|jr||jj}d}n?|jr/t ||jj j }d}nd}d}|r|j||||zn|j||||z }|t |k(sJ|S)aRegroups a flat list of input tensors into scalar and sequence inputs. Args: op_def: The `op_def_pb2.OpDef` (for knowing the input types) inputs: a list of input `Tensor`s to the op. attrs: mapping from attr name to `attr_value_pb2.AttrValue` (these define how long each sequence is) Returns: A list of `Tensor`s (corresponding to scalar inputs) and lists of `Tensor`s (corresponding to sequence inputs). rTrF)rP number_attrrtype_list_attrrQrFrr)rrrgrouped_inputsrrP input_len is_sequences rTrrs.!##i --.00ik  ! !eI445::??@ikikF1Q]34F1I&NA" c&k   rVcFeZdZUdZeed<dZeed<dZeed<dZeed<y ) PromoModerOFFrLEGACYrSAFErALLN) r|r}r~rr__annotations__rrrrrVrTrrs& #s,&#/$- #s,rVr_dtype_conversion_modectSru)rrrVrTget_dtype_conversion_moders rVcbttjk(xsttjk(Sru)rrrrrrVrT is_auto_dtype_conversion_enabledrs$ -2 9>> 1rVc0ttjk(Sru)rrrrrVrTis_numpy_style_type_promotionrs 9#3#3 33rVct|ay)zEnables the specified dtype conversion mode. Args: dtype_conversion_mode: a string that specifies dtype conversion mode. This string corresponds to a PromoMode Enum and can be 'off', 'legacy', 'safe' or 'all'. N)_get_promo_mode_enumrdtype_conversion_modes rTset_dtype_conversion_moders00EFrVc|dk(rtjS|dk(rtjS|dk(rtjS|dk(rtjSt d|d)z;Returns the corresponding PromoMode enum value from string.offlegacysaferThe provided promotion mode zy does not exist. Make sure the provided dtype conversion mode is one of the followings: 'off', 'legacy', 'safe' or 'all'.rrrrrrRrs rTrrsle# ==h&   & >>% ==  &'<&=>9 9 rVc|tjk(ry|tjk(ry|tjk(ry|tjk(ryt d|d)zEReturns the corresponding PromoMode string value from PromoMode enum.rrrrrz does not exist.r)promo_safety_mode_enums rTpromo_mode_enum_to_stringrs\y}}, y/// / .   &'=&>>NO rV_numpy_style_slicingcday)zuIf called, follows NumPy's rules for slicing Tensors. Used for enabling NumPy behavior on slicing for TF NumPy. TN)rrrVrTenable_numpy_style_slicingrs rVctjj|}|j|tj|y)zETF internal method used to set a list(int) attribute in the node_def.)rr\N)rrr]rS)rrQints ints_lists rTset_int_list_attrrs4&&00408),,y.22 BCrVc|y|j |jS|jr"t|drt|jSyy)Nr)rrpr8rrr8s rTrr sM ]    ,  & &&  !> !%"3"3 44"?rVc tj|}|jrm|jd}|jj }|j |_|j j|jdj yyr)r3get_resource_handle_datashape_and_typerrQrrr)r,r`rrprotos rTrRrR0st 99&A+ //2N    # # %E &&EK KK33A6<<=  rVrAc"t|tS)zTest if `tensor` is a symbolic Tensor. Args: tensor: a tensor-like object Returns: True if `tensor` is a symbolic tensor (not an eager tensor). )rarr+s rTrArA9s FN ++rVrsru)NNFNN)NNNrz)NNF)NTr{)NNNN)NNT(rrcollections.abcrrr contextlibrenumrrSrrrrrrr r r r r rabslrrrr}google.protobufrtensorflow.core.frameworkrrrrrrrrtensorflow.core.protobufrtensorflow.pythonrrrtensorflow.python.clientrtensorflow.python.eagerrr r!r"tensorflow.python.frameworkr#r$r%rbr&r'r(r)r*r,rr-r.r/r0r1tensorflow.python.opsr2r3tensorflow.python.platformr4rtensorflow.python.profilerr5profiler_tracetensorflow.python.typesrr6tensorflow.python.utilr7r8r9r:r;r<r=r>r?tensorflow.python.util.compatr@"tensorflow.python.util.deprecationrA tensorflow.python.util.tf_exportrBrCrDrErHrJrLrdrNrrrO BoolGauger_control_flow_api_gauge_tf_function_api_gaugerrPrDataTyperrUrvrXAbstractContextManagerrrrrrr]rrrrrrrValuerMTFE_Py_InitEagerTensorrrrr trace_wrapperrrrFrrrrrrrrrxrrrrrru TF_Operationr PyOperationrKRegistryrrrdeprecated_endpointsrrrrrrIrrrrrrrtrPyGraphrFr}rrrrrr"rwrr DefaultStackrrrrrrr{rrrrrrrrrr/rrr9rrrrrrrBrYr^rDrvryrzr~rMessagerrrrrrrrrEnumrrrrrrrrrrrrrrrRrArrVrTrs 688  aaa#432/20/2/0(!6+(.*287..40-<B437032<>9,)2.1,20+29>76 T] Kw / m95 {; +3EF  D t(:'')57/*..,13.--!$&  d9--v||;<  ,Bf,B^ ::4@  "-t-!S! *4 ()&//1B1B*"2Xx,,m.A.AX~ ;i2r:%J%%&679 :>333#3#39[9x12   %,,. ; &'3(0AH{N* ++-A   , eK789, `48 5n, -.D!9 ;(8(H(H HI94 &B ;(8(H(H HI &BV   (  %!1!A!A4:M OP ( X"; %!1!A!A4:M OP;:<+?+?.&0RZZ(&*gcl*(2 ) %"-!! #' D ->,J,J D".DN ;U E!--U EU En$$$%%%):):)::)FF& , v, , ^"!!"5|D =OP,,,QE,D%0 HcUD[ !/+68SE4K(6 +  .f.b&7X%6%67N%O""O> > B32 ;# ;c   x~   7|%;  % %|%;|%;FL xj ?~d'; ? ?F 8#nT2##L {m 7!4 7 7','HD'HZPt0DP JL  ,1E,!L, !"GD ))GD#GDT//*.!$26!$H*/++E2*/Z,>+?(? #8 8Bu-- .0N0N NO#8N <d@HTNd@d@N 456)T)7)@ $//%/( '()6:*.J37J*JZ ()**+*(,02637/3B)9=B)Jx6 $%&': "#$,5,%,6.4.  (R0..1.(6$?(?(D {mL L L ^  "#$5%5& #$%7&7& #$%5tCy5&5.  !8tCy8"887c7 9=,#HSM",#^E*Z>>sCE*V |n/0J55hsmD/0/0d #+00,0D ?(,%)'+51558 d7??#$ hugoo-./ h(#-./!6 8I "d(); < <=!6N##c(:$// -B# % !!4 (9(9#:: ;<#V %.MM 1 9 $4t4 G9$   #d"D 5S 5,DD> %9$:; ,$ ,< ,rV