a /Sic@stdZddlZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl m ZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddl m!Z!ddl m"Z"ddl#m$Z$ddl%m&Z&e'ddZ(Gddde)Z*ddZ+ddZ,ej-ddddd dfej.d!de,d"dfe)d#dd$dd%dfgZ/d&d'Z0dGd(d)Z1d*d+Z2d,d-Z3Gd.d/d/e)Z4Gd0d1d1e4Z5d2d3Z6Gd4d5d5e4Z7Gd6d7d7e4Z8Gd8d9d9e4Z9Gd:d;d;e)Z:dd?d?e)Ze&dEgdCGdFdEdEe=Z?dS)Hz"A client interface for TensorFlow.N) config_pb2)rewriter_config_pb2)pywrap_tf_session)context) monitoring)device)error_interpolation)errors)indexed_slices)ops) sparse_tensor) session_ops) tf_logging)mixed_precision_global_state)compat)nest)collections_abc) tf_exportz-/tensorflow/api/python/session_create_counterz1Counter for number of sessions created in Python.c@sFeZdZdZeddZeddZd ddZdd d Zdd d Z dS)SessionInterfacez=Base class for implementations of TensorFlow client sessions.cCs tddS)zCThe underlying TensorFlow graph, to be used in building Operations.graphNNotImplementedErrorselfr\/var/www/html/django/DPS/env/lib/python3.9/site-packages/tensorflow/python/client/session.pyr5szSessionInterface.graphcCs tddS)z:The TensorFlow process to which this session will connect.sess_strNrrrrrr:szSessionInterface.sess_strNcCs tddS)zDRuns operations in the session. See `BaseSession.run()` for details.runNr)rfetches feed_dictoptions run_metadatarrrr?szSessionInterface.runcCs tddS)z>Sets up the feeds and fetches for partial runs in the session.partial_run_setupNr)rrfeedsrrrr"Csz"SessionInterface.partial_run_setupcCs tddS)z:Continues the execution with additional feeds and fetches. partial_runNrrhandlerrrrrr$GszSessionInterface.partial_run)NNN)N)N) __name__ __module__ __qualname____doc__propertyrrrr"r$rrrrr2s    rcCs*t|d|dt|dkr$|dndS)Nr)r IndexedSlicesValuelenZ fetched_valsrrr&_get_indexed_slices_value_from_fetchesLs r2cCs0tt|jdur|j|jgn|j|j|jg|SN)listzip dense_shapevaluesindicesfeedfeed_valrrr_get_feeds_for_indexed_slicesRs r<cCs|j|j|jgddfS)NcSs tj|Sr3)r SparseTensorValuer1rrru..r8r7r6fetchrrrr>ss r>cCstt|j|j|jg|Sr3)r4r5r8r7r6r9rrrr>vscCs|j|j|jgSr3rAr:rrrr>xr?cCs*|jdur|j|jgn|j|j|jgtfSr3)r6r7r8r2rBrrrr>|scCs&|jdur|j|jgS|j|j|jgSr3)r6r7r8rDrrrr>scCs|gddfS)NcSs|dSNrrr1rrrr>r?r@rrBrrrr>r?cCs ||fgSr3rr9rrrr>r?cCs|gSr3rrDrrrr>r?cCs|tur||St|S)zBExplicitly convert obj based on numpy type except for string type.)objectstr) numpy_dtypeobjrrr_convert_to_numpy_objsrJcCs>tD] }t|d|rt|dqtd||||fdS)a Register fetch and feed conversion functions for `tf.Session.run()`. This function registers a triple of conversion functions for fetching and/or feeding values of user-defined types in a call to tf.Session.run(). An example ```python class SquaredTensor(object): def __init__(self, tensor): self.sq = tf.square(tensor) #you can define conversion functions as follows: fetch_function = lambda squared_tensor:([squared_tensor.sq], lambda val: val[0]) feed_function = lambda feed, feed_val: [(feed.sq, feed_val)] feed_function_for_partial_run = lambda feed: [feed.sq] #then after invoking this register function, you can use as follows: session.run(squared_tensor1, feed_dict = {squared_tensor2 : some_numpy_array}) ``` Args: tensor_type: The type for which you want to register a conversion function. fetch_function: A callable that takes an object of type `tensor_type` and returns a tuple, where the first element is a list of `tf.Tensor` objects, and the second element is a callable that takes a list of ndarrays and returns an object of some value type that corresponds to `tensor_type`. fetch_function describes how to expand fetch into its component Tensors and how to contract the fetched results back into a single return value. feed_function: A callable that takes feed_key and feed_value as input, and returns a list of tuples (feed_tensor, feed_val), feed_key must have type `tensor_type`, and feed_tensor must have type `tf.Tensor`. Each feed function describes how to unpack a single fed value and map it to feeds of one or more tensors and their corresponding values. feed_function_for_partial_run: A callable for specifying tensor values to feed when setting up a partial run, which takes a `tensor_type` type object as input, and returns a list of Tensors. Raises: ValueError: If `tensor_type` has already been registered. rz* has already been registered so ignore it.N)_REGISTERED_EXPANSIONS issubclass ValueErrorinsert) tensor_typeZfetch_functionZ feed_functionZfeed_function_for_partial_runZconversion_functionrrr)register_session_run_conversion_functionss . rPcCst|jddduS)zFReturns True if the given obj is an instance of attrs-decorated class.__attrs_attrs__Ngetattr __class__rIrrr_is_attrs_instancesrVcstjd}fdd|DS)z2Returns the list of values from an attrs instance.rQcsg|]}t|jqSr)rSname).0arUrr r?z%_get_attrs_values..rR)rIattrsrrUr_get_attrs_valuess r\c@s,eZdZdZddZddZeddZdS) _FetchMapperavDefinition of the interface provided by fetch mappers. Fetch mappers are utility classes used by the _FetchHandler to handle arbitrary structures for the `fetch` argument to `Session.run()`. The `fetch` argument can be of various shapes: single tensor or op, list of fetches, tuple of fetches, namedtuple of fetches, or dict of fetches. The structures can be arbitrarily nested. The low level run() API only wants a list of tensor or op names. The various `_FetchMapper` subclasses below take care of handling the different shapes: uniquifying the fetches, and constructing results with the original shape. cCs tddS)zxReturn the list of unique tensors or ops needed by this fetch mapper. Returns: A list of tensors or ops. z0unique_fetches must be implemented by subclassesNrrrrrunique_fetchessz_FetchMapper.unique_fetchescCs tddS)aBuild results that match the original shape of the fetch. Args: values: List of values returned by run(). The values correspond exactly to the list tensors or ops returned by unique_fetches(). Returns: A struct of the same shape as the original fetch object handled by this fetch mapper. In the returned struct, the original fetches are replaced by their fetched values. z/build_results must be implemented by subclassesNrrr7rrr build_resultss z_FetchMapper.build_resultscCs|dur&td|dt|jdnpt|ttfrsz"_ElementFetchMapper.unique_fetchescCs|sdS||SdSr3)rzr_rrrr`Asz!_ElementFetchMapper.build_resultsNr'r(r)r*r|r^r`rrrrrls!rlcCsxg}g}i}|D]^}g}|D]B}|t|}|durXt|}||t|<||||q ||q||fS)a{Uniquifies fetches from a list of fetch_mappers. This is a utility function used by _ListFetchMapper and _DictFetchMapper. It gathers all the unique fetches from a list of mappers and builds a list containing all of them but without duplicates (unique_fetches). It also returns a 2-D list of integers (values_indices) indicating at which index in unique_fetches the fetches of the mappers are located. This list is as follows: values_indices[mapper_index][mapper_fetch_index] = unique_fetches_index Args: fetch_mappers: list of fetch mappers. Returns: A list of fetches. A 2-D list of integers. N)r^getidr0rv)Z fetch_mappersr^Z value_indicesZ seen_fetchesmZm_value_indicesfjrrr_uniquify_fetchesIs     rc@s(eZdZdZddZddZddZdS) rhz0Fetch mapper for lists, tuples, and namedtuples.cCsJt|tjrt|j|_n t||_dd|D|_t|j\|_|_ dS)zaCreates a _ListFetchMapper. Args: fetches: List, tuple, or namedtuple of fetches. cSsg|]}t|qSrr]rorXrCrrrrZzr?z-_ListFetchMapper.__init__..N) rfwrapt ObjectProxyre __wrapped__ _fetch_type_mappersrru_value_indicesrrrrrr|ps   z_ListFetchMapper.__init__cCs|jSr3r}rrrrr^}sz_ListFetchMapper.unique_fetchescsjg}t|j|jD]&\}}||fdd|Dqt|jtrJ|S|jtkr\t|S|j|SdS)Ncsg|] }|qSrrrXrr7rrrZr?z2_ListFetchMapper.build_results..) r5rrrvr`rLrr4rgrr7resultsrvirrrr`s   z_ListFetchMapper.build_resultsNr~rrrrrhms rhc@s(eZdZdZddZddZddZdS) rjzFetch mapper for dicts.cCsft||_t|tjr*ttj|j|_n|j|_| |_ dd| D|_ t |j \|_|_dS)zKCreates a _DictFetchMapper. Args: fetches: Dict of fetches. cSsg|]}t|qSrrrrrrrZsz-_DictFetchMapper.__init__..N)rerrf collections defaultdict functoolspartialdefault_factory _type_ctorkeys_keysr7rrrurrrrrr|s   z_DictFetchMapper.__init__cCs|jSr3r}rrrrr^sz_DictFetchMapper.unique_fetchescsfdd}|S)Nc3s@tjjjD](\}}}||fdd|DfVqdS)Ncsg|] }|qSrrrrrrrZr?zF_DictFetchMapper.build_results.._generator..)r5rrrr`)krrr_rr _generatorsz2_DictFetchMapper.build_results.._generator)r)rr7rrr_rr`sz_DictFetchMapper.build_resultsNr~rrrrrjsrjc@s(eZdZdZddZddZddZdS) rkz)Fetch mapper for attrs decorated classes.cCs8t|}t||_dd|D|_t|j\|_|_dS)zdCreates a _AttrsFetchMapper. Args: fetches: An instance of an attrs decorated class. cSsg|]}t|qSrrrrrrrZr?z._AttrsFetchMapper.__init__..N)r\rerrrrur)rrr7rrrr|s z_AttrsFetchMapper.__init__cCs|jSr3r}rrrrr^sz _AttrsFetchMapper.unique_fetchescsDg}t|j|jD]&\}}||fdd|Dq|j|S)Ncsg|] }|qSrrrrrrrZr?z3_AttrsFetchMapper.build_results..)r5rrrvr`rrrrrr`s z_AttrsFetchMapper.build_resultsNr~rrrrrks rkc@s:eZdZdZd ddZddZddZd d Zd d ZdS) _FetchHandleraHandler for structured fetches. Given a graph, a user-provided structure for fetches, and a feed dict, this class takes care of generating a list of tensor names to fetch and op names to run for a low level `run()` call. Given the results of the low level run call, this class can also rebuild a result structure matching the user-provided structure for fetches, but containing the corresponding results. Ncs|t||_Wdn1s*0Yg|_g|_|_|pLi|_g|_i|_ |j D]}t |t j r||||j||jdn&|||j|j||jdt |t jrf|jjdks|jjdkrf|jjdj|j |<qffdd|jD|_dS) aCreates a fetch handler. Args: graph: Graph of the fetches. Used to check for fetchability and to convert all fetches to tensors or ops as needed. fetches: An arbitrary fetch structure: singleton, list, tuple, namedtuple, or dict. feeds: A feed dict where keys are Tensors. feed_handles: A dict from feed Tensors to TensorHandle objects used as direct feeds. NTFGetSessionHandleGetSessionHandleV2rcsg|]}|vr|qSr)ref)rXxr#rrrZr?z*_FetchHandler.__init__..) as_defaultr]ro _fetch_mapper_fetches_targets_feeds _feed_handles_ops_fetch_handlesr^rfr Operation_assert_fetchablervopTensorreinputsdtyper_final_fetches)rrrr# feed_handlesrCrrrr|s. *         z_FetchHandler.__init__cCs"||std|jddS)Nz Operation z has been marked as not fetchable. Typically this happens when it is defined in another function or code block. Use return values, explicit Python locals or TensorFlow collections to access it.) is_fetchabler InaccessibleTensorErrorrW)rrrrrrrs  z_FetchHandler._assert_fetchablecCs|jS)zXReturn the unique names of tensors to fetch. Returns: A list of strings. )rrrrrrsz_FetchHandler.fetchescCs|jS)zRReturn the unique names of ops to run. Returns: A list of strings. )rrrrrtargets sz_FetchHandler.targetsc Csg}t|jt|ksJd}d}|jD]}|r<|dq(|j||jvrj|j|j|}n|j |j|}|dur||}|d7}|j |j|}|r|t |||n |||d7}q(|t|ksJ|j |S)aBuild results matching the original fetch shape. `tensor_values` must be a list of the same length as the one returned by `fetches()`, and holding the requested fetch values. This method builds a struct with the same shape as the original `fetches` passed to the constructor, in which the fetches are replaced by their fetched value. Args: session: The enclosing session. Used for tensor handles. tensor_values: List of values matching the list returned by fetches(). Returns: A structure of the same shape as the original `fetches` argument but containing tensors or None (for fetched ops). rNr,)r0rrrvrrrevalrrrr TensorHandlerr`) rsessionZ tensor_valuesZ full_valuesirZis_opvaluerrrrr`s(    z_FetchHandler.build_results)N) r'r(r)r*r|rrrr`rrrrrs  $rcCsdd|DS)zUtility function for transitioning to the new session API. Args: tensor_list: a list of `Tensor`s. Returns: A list of each `Tensor`s name (as byte arrays). cSsg|]}t|jqSr)ras_bytesrWrXtrrrrZMr?z_name_list..r) tensor_listrrr _name_listDs rc@sPeZdZdZddZeddZeddZedd Zed d Z d d Z dS)_DeviceAttributesaStruct-like object describing a device's attributes. Each device has 3 key properties: - name: the fully-qualified TensorFlow path to the device. For example: /job:worker/replica:0/task:3/device:CPU:0 - device_type: the type of the device (e.g. CPU, GPU, TPU, etc.) - memory_limit_bytes: the maximum amount of memory available on the device (in bytes). cCs"t||_||_||_||_dSr3)rcanonical_name_name _device_type_memory_limit_bytes _incarnation)rrW device_typememory_limit_bytes incarnationrrrr|[s z_DeviceAttributes.__init__cCs|jSr3)rrrrrrWasz_DeviceAttributes.namecCs|jSr3)rrrrrresz_DeviceAttributes.device_typecCs|jSr3)rrrrrrisz$_DeviceAttributes.memory_limit_bytescCs|jSr3)rrrrrrmsz_DeviceAttributes.incarnationcCsd|j|j|j|jfS)Nz!_DeviceAttributes(%s, %s, %d, %d))rWrrrrrrr__repr__qs z_DeviceAttributes.__repr__N) r'r(r)r*r|r+rWrrrrrrrrrPs     rc@seZdZdZd3ddZddZdd Zd d Zed d Z eddZ eddZ ddZ d4ddZ d5ddZd6ddZddZd7ddZedZd d!Zd"d#Zd$d%Zd&Zd'd(Zd)d*Zd+d,Zd-d.ZGd/d0d0eZd1d2ZdS)8 BaseSessionzA class for interacting with a TensorFlow computation. The BaseSession enables incremental graph building with inline execution of Operations and evaluation of Tensors. Nc Cstd|dur"t|_n(t|tjsDtdt |j d||_d|_ |durzt ||_Wqtyt|tjrtdt |j dtdt |j dYq0nd|_t|_g|_|durtj}t|tjstdt |j dtrF|jjjtjjkrFt}||tjj |jj_|}n|jjjtjj krdt!d ||_"|jj#|_$d|_%t&j'|j|d }zJ|jj()}t&*|||_%Wdn1s0YWt&+|n t&+|0dS) a}Constructs a new TensorFlow session. Args: target: (Optional) The TensorFlow execution engine to connect to. graph: (Optional) The graph to be used. If this argument is None, the default graph will be used. config: (Optional) ConfigProto proto used to configure the session. If no config is specified, the global default will be used. The global default can be configured via the tf.config APIs. Raises: tf.errors.OpError: Or one of its subclasses if an error occurs while creating the TensorFlow session. TypeError: If one of the arguments has the wrong type. r,Nz.Argument `graph` must be a tf.Graph, but got "rcFz-Argument `target` must be a string, but got "zD". Did you do "Session(config)" instead of "Session(config=config)"?z5Argument `config` must be a tf.ConfigProto, but got "T)targetconfig),_python_session_create_counterget_cell increase_byr rw_graphrfGraphrdrer'_closedrr_targetr ConfigProto threadingLock _delete_lock _dead_handlesrrrZ(is_mixed_precision_graph_rewrite_enabled graph_optionsrewrite_optionsauto_mixed_precisionrRewriterConfigOFFCopyFromONZ'set_non_mixed_precision_session_created_config infer_shapes _add_shapes_session tf_sessionTF_NewSessionOptions_c_graphrTF_NewSessionRefTF_DeleteSessionOptions)rrrrZ new_configoptsc_graphrrrr|sf             0zBaseSession.__init__c Cszt|j}g}t|}t|D]H}t||}t||}t||}t||}| t ||||q"t ||S)aLists available devices in this session. ```python devices = sess.list_devices() for d in devices: print(d.name) ``` Where: Each element in the list has the following properties name: A string with the full name of the device. ex: `/job:worker/replica:0/task:3/device:CPU:0` device_type: The type of the device (e.g. `CPU`, `GPU`, `TPU`.) memory_limit: The maximum amount of memory available on the device. Note: depending on the device, it is possible the usable memory could be substantially less. Raises: tf.errors.OpError: If it encounters an error (e.g. session is in an invalid state, or network errors occur). Returns: A list of devices in the session. ) rTF_SessionListDevicesrTF_DeviceListCountrangeTF_DeviceListNameTF_DeviceListTypeTF_DeviceListMemoryBytesTF_DeviceListIncarnationrvrTF_DeleteDeviceList) rZraw_device_list device_listsizerrWrmemoryrrrr list_devicess         zBaseSession.list_devicescCs"|jr|jsd|_t|jdS)zCloses this session. Calling this method frees all resources associated with the session. Raises: tf.errors.OpError: Or one of its subclasses if an error occurs while closing the TensorFlow session. TN)rrrTF_CloseSessionrrrrcloses zBaseSession.closec Cs\z |WntyYn0|jdurXzt|jWnttfyPYn0d|_dSr3)r ExceptionrrTF_DeleteSessionAttributeErrorrdrrrr__del__s   zBaseSession.__del__cCs|jS)z,The graph that was launched in this session.)rrrrrrszBaseSession.graphcCs|jj|jdS)zA serializable version of the underlying TensorFlow graph. Returns: A graph_pb2.GraphDef proto containing nodes for all of the Operations in the underlying TensorFlow graph. ) add_shapes)r as_graph_defrrrrr graph_defszBaseSession.graph_defcCs|jSr3)rrrrrr szBaseSession.sess_strcCs t|S)aReturns a context manager that makes this object the default session. Use with the `with` keyword to specify that calls to `tf.Operation.run` or `tf.Tensor.eval` should be executed in this session. ```python c = tf.constant(..) sess = tf.compat.v1.Session() with sess.as_default(): assert tf.compat.v1.get_default_session() is sess print(c.eval()) ``` To get the current default session, use `tf.compat.v1.get_default_session`. *N.B.* The `as_default` context manager *does not* close the session when you exit the context, and you must close the session explicitly. ```python c = tf.constant(...) sess = tf.compat.v1.Session() with sess.as_default(): print(c.eval()) # ... with sess.as_default(): print(c.eval()) sess.close() ``` Alternatively, you can use `with tf.compat.v1.Session():` to create a session that is automatically closed on exiting the context, including when an uncaught exception is raised. *N.B.* The default session is a property of the current thread. If you create a new thread, and wish to use the default session in that thread, you must explicitly add a `with sess.as_default():` in that thread's function. *N.B.* Entering a `with sess.as_default():` block does not affect the current default graph. If you are using multiple graphs, and `sess.graph` is different from the value of `tf.compat.v1.get_default_graph`, you must explicitly enter a `with sess.graph.as_default():` block to make `sess.graph` the default graph. Returns: A context manager using this session as the default session. )r default_sessionrrrrr$s5zBaseSession.as_defaultc Cs|rtt|nd}|r(tnd}zP|d||||}|r^t|}|t|W|rnt ||rt |n|rt ||rt |0|S)aRuns operations and evaluates tensors in `fetches`. This method runs one "step" of TensorFlow computation, by running the necessary graph fragment to execute every `Operation` and evaluate every `Tensor` in `fetches`, substituting the values in `feed_dict` for the corresponding input values. The `fetches` argument may be a single graph element, or an arbitrarily nested list, tuple, namedtuple, dict, or OrderedDict containing graph elements at its leaves. A graph element can be one of the following types: * A `tf.Operation`. The corresponding fetched value will be `None`. * A `tf.Tensor`. The corresponding fetched value will be a numpy ndarray containing the value of that tensor. * A `tf.sparse.SparseTensor`. The corresponding fetched value will be a `tf.compat.v1.SparseTensorValue` containing the value of that sparse tensor. * A `get_tensor_handle` op. The corresponding fetched value will be a numpy ndarray containing the handle of that tensor. * A `string` which is the name of a tensor or operation in the graph. The value returned by `run()` has the same shape as the `fetches` argument, where the leaves are replaced by the corresponding values returned by TensorFlow. Example: ```python a = tf.constant([10, 20]) b = tf.constant([1.0, 2.0]) # 'fetches' can be a singleton v = session.run(a) # v is the numpy array [10, 20] # 'fetches' can be a list. v = session.run([a, b]) # v is a Python list with 2 numpy arrays: the 1-D array [10, 20] and the # 1-D array [1.0, 2.0] # 'fetches' can be arbitrary lists, tuples, namedtuple, dicts: MyData = collections.namedtuple('MyData', ['a', 'b']) v = session.run({'k1': MyData(a, b), 'k2': [b, a]}) # v is a dict with # v['k1'] is a MyData namedtuple with 'a' (the numpy array [10, 20]) and # 'b' (the numpy array [1.0, 2.0]) # v['k2'] is a list with the numpy array [1.0, 2.0] and the numpy array # [10, 20]. ``` The optional `feed_dict` argument allows the caller to override the value of tensors in the graph. Each key in `feed_dict` can be one of the following types: * If the key is a `tf.Tensor`, the value may be a Python scalar, string, list, or numpy ndarray that can be converted to the same `dtype` as that tensor. Additionally, if the key is a `tf.compat.v1.placeholder`, the shape of the value will be checked for compatibility with the placeholder. * If the key is a `tf.sparse.SparseTensor`, the value should be a `tf.compat.v1.SparseTensorValue`. * If the key is a nested tuple of `Tensor`s or `SparseTensor`s, the value should be a nested tuple with the same structure that maps to their corresponding values as above. Each value in `feed_dict` must be convertible to a numpy array of the dtype of the corresponding key. The optional `options` argument expects a [`RunOptions`] proto. The options allow controlling the behavior of this particular step (e.g. turning tracing on). The optional `run_metadata` argument expects a [`RunMetadata`] proto. When appropriate, the non-Tensor output of this step will be collected there. For example, when users turn on tracing in `options`, the profiled info will be collected into this argument and passed back. Args: fetches: A single graph element, a list of graph elements, or a dictionary whose values are graph elements or lists of graph elements (described above). feed_dict: A dictionary that maps graph elements to values (described above). options: A [`RunOptions`] protocol buffer run_metadata: A [`RunMetadata`] protocol buffer Returns: Either a single value if `fetches` is a single graph element, or a list of values if `fetches` is a list, or a dictionary with the same keys as `fetches` if that is a dictionary (described above). Order in which `fetches` operations are evaluated inside the call is undefined. Raises: RuntimeError: If this `Session` is in an invalid state (e.g. has been closed). TypeError: If `fetches` or `feed_dict` keys are of an inappropriate type. ValueError: If `fetches` or `feed_dict` keys are invalid or refer to a `Tensor` that doesn't exist. N) rTF_NewBufferFromStringrrSerializeToString TF_NewBuffer_run TF_GetBufferParseFromStringTF_DeleteBuffer) rrrr r! options_ptrrun_metadata_ptrresult proto_datarrrr[s.i       zBaseSession.runcCs||||ddS)aBContinues the execution with more feeds and fetches. This is EXPERIMENTAL and subject to change. To use partial execution, a user first calls `partial_run_setup()` and then a sequence of `partial_run()`. `partial_run_setup` specifies the list of feeds and fetches that will be used in the subsequent `partial_run` calls. The optional `feed_dict` argument allows the caller to override the value of tensors in the graph. See run() for more information. Below is a simple example: ```python a = array_ops.placeholder(dtypes.float32, shape=[]) b = array_ops.placeholder(dtypes.float32, shape=[]) c = array_ops.placeholder(dtypes.float32, shape=[]) r1 = math_ops.add(a, b) r2 = math_ops.multiply(r1, c) h = sess.partial_run_setup([r1, r2], [a, b, c]) res = sess.partial_run(h, r1, feed_dict={a: 1, b: 2}) res = sess.partial_run(h, r2, feed_dict={c: res}) ``` Args: handle: A handle for a sequence of partial runs. fetches: A single graph element, a list of graph elements, or a dictionary whose values are graph elements or lists of graph elements (see documentation for `run`). feed_dict: A dictionary that maps graph elements to values (described above). Returns: Either a single value if `fetches` is a single graph element, or a list of values if `fetches` is a list, or a dictionary with the same keys as `fetches` if that is a dictionary (see documentation for `run`). Raises: tf.errors.OpError: Or one of its subclasses on error. N)rr%rrrr$s-zBaseSession.partial_runc s"dd}jrtdjjdkr*td|dur6g}g}t|ttf}|sR|g}|D]x}||D]j}z$jj|ddd }|| Wqbt y} z(d | j | _ | j f| _ | WYd} ~ qbd} ~ 00qbqVt j|i} fd d } d d| D} dd| D} | j|| | S)aSets up a graph with feeds and fetches for partial run. This is EXPERIMENTAL and subject to change. Note that contrary to `run`, `feeds` only specifies the graph elements. The tensors will be supplied by the subsequent `partial_run` calls. Args: fetches: A single graph element, or a list of graph elements. feeds: A single graph element, or a list of graph elements. Returns: A handle for partial run. Raises: RuntimeError: If this `Session` is in an invalid state (e.g. has been closed). TypeError: If `fetches` or `feed_dict` keys are of an inappropriate type. tf.errors.OpError: Or one of its subclasses if a TensorFlow error happens. cSsHtD]"\}}}}t||r||Sqtd|dt|jddS)NzFeed argument rbrcrKrfrdrer')r:rOrmfeed_fnrrr_feed_fns   z/BaseSession.partial_run_setup.._feed_fn"Attempted to use a closed Session.rMThe Session graph is empty. Add operations to the graph before calling run().NTFrqz0Cannot interpret argument `feed` key as Tensor: cst||||Sr3) _extend_graphrTF_SessionPRunSetup_wrapper)r feed_list fetch_list target_listrrr _setup_fnCsz0BaseSession.partial_run_setup.._setup_fncSsg|] }|qSr _as_tf_outputrrrrrZIr?z1BaseSession.partial_run_setup..cSsg|] }|jqSr_c_oprXrrrrrZJr?)r RuntimeErrorrversionrfr4rgrxrvrrmessageargsrrrr_do_callr)rrr#rrZ is_list_feedr:subfeed subfeed_tr{ fetch_handlerr final_fetches final_targetsrrrr"s>    zBaseSession.partial_run_setupc Csbdd}|jrtd|jjdkr*tdi}i}i} |rt|}|D]\} } || | D]\} } z|jj| ddd}Wn8ty}z t d |j dWYd }~n d }~00t | t j rt d t| d t| d |jj}t | tr:t|| | kr:t dt| dtt| dt|dt | tj}|rb| }| | |<ntj| |d}|s||jstdt|jd|jdt||j|std|jd|||<|| f|t !|j<qbqNt"|j#||| d}|$||}|%}|&}|s<|s<|rR|rR|'||||||}ng}|(||S)zFPerform either run or partial_run, depending the presence of `handle`.cSsHtD]$\}}}}t||r|||Sqt|dt|jddS)Nz+ in argument `feed_dict` has invalid type "rcr )r:r;rOrmrrrrrSs  z"BaseSession._run.._feed_fnrrrTFrqz*Cannot interpret feed_dict key as Tensor: NzThe value of a feed cannot be a tf.Tensor object. Acceptable feed values include Python scalars, strings, lists, numpy ndarrays, or TensorHandles. For reference, the tensor object was z7 which was passed to the argument `feed_dict` with key .zType of feed value z with type z$ is not compatible with Tensor type zS. Try explicitly setting the type of the feed tensor to a larger type (e.g. int64).rzCannot feed value of shape z for Tensor z, which has shape zTensor z may not be fed.)r))rrrrrflatten_dict_itemsitemsrxrrdr rfr rrGras_numpy_dtypeintrJrer rZto_numpy_arrayrnpasarray get_shapeis_compatible_withshaperMrW is_feedablerrrr_update_with_moversrr_do_runr`)rr&rrr r!rZfeed_dict_tensorfeed_maprr:r;r"Z subfeed_valr#r{Z subfeed_dtypeZis_tensor_handle_feednp_valr$rmr%r&rrrrrPs         zBaseSession._runFc sdur8tttfs$tdfdd}|StjiddDddDdfdd }|rt |Stt j rʈrJt d ksJfd d }|Stt jrt d ksJrJfd d}|Sfdd}|SdS)aReturns a Python callable that runs a particular step. The returned callable will take `len(feed_list)` arguments whose types must be compatible feed values for the respective elements of `feed_list`. For example, if element `i` of `feed_list` is a `tf.Tensor`, the `i`th argument to the returned callable must be a numpy ndarray (or something convertible to an ndarray) with matching element type and shape. See `tf.Session.run` for details of the allowable feed key and value types. The returned callable will have the same return type as `tf.Session.run(fetches, ...)`. For example, if `fetches` is a `tf.Tensor`, the callable will return a numpy ndarray; if `fetches` is a `tf.Operation`, it will return `None`. Args: fetches: A value or list of values to fetch. See `tf.Session.run` for details of the allowable fetch types. feed_list: (Optional.) A list of `feed_dict` keys. See `tf.Session.run` for details of the allowable feed key types. accept_options: (Optional.) If `True`, the returned `Callable` will be able to accept `tf.compat.v1.RunOptions` and `tf.compat.v1.RunMetadata` as optional keyword arguments `options` and `run_metadata`, respectively, with the same syntax and semantics as `tf.Session.run`, which is useful for certain use cases (profiling and debugging) but will result in measurable slowdown of the `Callable`'s performance. Default: `False`. Returns: A function that when called will execute the step defined by `feed_list` and `fetches` in this session. Raises: TypeError: If `fetches` or `feed_list` cannot be interpreted as arguments to `tf.Session.run`. NzBArgument `feed_list` must be a list or tuple. Received: feed_list=cs*ddt|D}jfd|i|S)NcSsi|]\}}||qSrr)rXr:r;rrr szCBaseSession.make_callable.._generic_run..r)r5r)Z feed_argskwargsr)rrrrr _generic_runsz/BaseSession.make_callable.._generic_runcSsg|] }|qSrrrrrrrZr?z-BaseSession.make_callable..cSsg|] }|jqSrrrrrrrZr?c s|rtt|nd}|r(tnd}zr|i|||}|rR||}n|r^|dnd}|rt|}| t|W|rt ||rt |n|rt ||rt |0|S)z:Template callable that accepts RunOptions and RunMetadata.Nr) rrrrrr_call_tf_sessionrunr`rrr) rrr$r r!r r rr rrr,_callable_template_with_options_and_metadatas4       zOBaseSession.make_callable.._callable_template_with_options_and_metadatar,csdigddSr3r:rrrrr_single_operation_runsz8BaseSession.make_callable.._single_operation_runcsdigd}|dSrEr<r)rrrr_single_tensor_runsz5BaseSession.make_callable.._single_tensor_runcsdid}|Sr3)r:r`r?)r$rrrrr_fetch_handler_run$s z5BaseSession.make_callable.._fetch_handler_run)NN)rfr4rgrdrrrrrrrr rr0r) rrrZaccept_optionsr9r;r>r@rAr)rr$rrrrr make_callables<$ zBaseSession.make_callablez.\[\[(Node: )?(\{\{node )?([^\} ]*)(\}\})?\s*=*c s|tdd|D}dd|D}ddD} fdd} fdd } |d urh| ||| ||S| |||Sd S) a+Runs a step based on the given fetches and feeds. Args: handle: a handle for partial_run. None if this is just a call to run(). target_list: A list of operations to be run, but not fetched. fetch_list: A list of tensors to be fetched. feed_dict: A dictionary that maps tensors to numpy ndarrays. options: A (pointer to a) [`RunOptions`] protocol buffer, or None run_metadata: A (pointer to a) [`RunMetadata`] protocol buffer, or None Returns: A list of numpy ndarrays, corresponding to the elements of `fetch_list`. If the ith element of `fetch_list` contains the name of an operation, the first Tensor output of that operation will be returned for that element. Raises: tf.errors.OpError: Or one of its subclasses on error. css"|]\}}||fVqdSr3)derefr)rXrvrrr Hr?z&BaseSession._do_run..cSsg|] }|qSrrrrrrrZIr?z'BaseSession._do_run..cSsg|] }|jqSrrrrrrrZJr?cs|||||Sr3)rr:)rrrr r!rrr_run_fnNs z$BaseSession._do_run.._run_fncs"rtdd|||S)NzBpartial_run() requires empty `target_list`. Received: target_list=z (non-empty))r_call_tf_sessionprun)r&rrr=rr_prun_fnTs  z%BaseSession._do_run.._prun_fnN)dictr*r!) rr&rrrr r!r#rrrFrHrr=rr42s zBaseSession._do_runc Gsz ||WStjy}zt|j}tj|}d}d}|durx|d}z|j |}|j }Wnt yvYn0t ||j }d|vr|d7}t||||WYd}~n d}~00dS)Nr-z only supports NHWC tensor formatz A possible workaround: Try disabling Grappler optimizer by modifying the config for creating the session eg. session_config.graph_options.rewrite_options.disable_meta_optimizer = True)r OpErrorras_textrr_NODEDEF_NAME_REsearchgrouprget_operation_by_namenode_defryr interpolatere) rfnr r{rrrPr node_namerrrr!`s$       zBaseSession._do_callcCs:|jt|jWdn1s,0YdSr3)r_session_run_lockr ExtendSessionrrrrrrws zBaseSession._extend_graph c Csd}|j8|j|t|jtjkr4|j}g|_Wdn1sH0Y|ri}g}t|D].\}}t|j ||\}}|||<||qf|j ||ddS)Nr) rrrvr0r_DEAD_HANDLES_THRESHOLD enumerater Z_get_handle_deleterrr) rr&Ztensors_to_deleter#rZ deleter_keyZ tensor_handleholderdeleterrrr_register_dead_handle~s  $ z!BaseSession._register_dead_handlecCsg}|D]4\}}tj|jg|R}|r |||d|fq |sJgSi}g}|D]$\} } }| ||d<||dqV|j||d} t|| D]:\} } tj| j tj d} | d}||d}| || <q| SdS)Nr,rrWr() r*r Z_get_handle_moverrrvrr5r-arrayr&object_r)rrr5Z handle_moversZ feed_namevalZmoverr#rrmr&handlesZ handle_moverr6Z feed_tensorrrrr3s&  zBaseSession._update_with_moverscCst|j|||||Sr3)rTF_SessionRun_wrapperr)rr rrrr!rrrr:s zBaseSession._call_tf_sessionruncCst|j|||Sr3)rTF_SessionPRun_wrapperr)rr&rrrrrrGs z BaseSession._call_tf_sessionprunc@s(eZdZdZddZddZddZdS) zBaseSession._Callablez?Experimental wrapper for the C++ `Session::MakeCallable()` API.c CsP||_d|_tt|}zt|j||_Wt|n t|0dSr3) r_handlerrrrrTF_SessionMakeCallabler)rrcallable_optionsr rrrr|s zBaseSession._Callable.__init__c Osx|dd}zV|rtnd}t|jj|j||}|rRt|}|t |W|rtt |n|rrt |0|S)Nr!) rrrTF_SessionRunCallablerrcrrrrr)rr r8r!r retr rrr__call__s     zBaseSession._Callable.__call__cCs4|jdur0|jjdur0|jjs0t|jj|jdSr3)rcrrrTF_SessionReleaseCallablerrrrrs  zBaseSession._Callable.__del__N)r'r(r)r*r|rhrrrrr _Callables rjcCs|t||S)a Returns a handle to a "callable" with the given options. Args: callable_options: A `CallableOptions` protocol buffer message describing the computation that will be performed by the callable. Returns: A handle to the new callable. )rrrj)rrerrr_make_callable_from_optionss z'BaseSession._make_callable_from_options)rNN)NNN)N)N)NF) r'r(r)r*r|rrrr+rrrrrr$r"rrBrecompilerLr4r!rrXr\r3r:rGrFrjrkrrrrrzs> L&    7 y / M] .(rSession)v1cs@eZdZdZd fdd ZddZdd Zed d d ZZ S)rnaA class for running TensorFlow operations. A `Session` object encapsulates the environment in which `Operation` objects are executed, and `Tensor` objects are evaluated. For example: ```python tf.compat.v1.disable_eager_execution() # need to disable eager in TF2.x # Build a graph. a = tf.constant(5.0) b = tf.constant(6.0) c = a * b # Launch the graph in a session. sess = tf.compat.v1.Session() # Evaluate the tensor `c`. print(sess.run(c)) # prints 30.0 ``` A session may own resources, such as `tf.Variable`, `tf.queue.QueueBase`, and `tf.compat.v1.ReaderBase`. It is important to release these resources when they are no longer required. To do this, either invoke the `tf.Session.close` method on the session, or use the session as a context manager. The following two examples are equivalent: ```python # Using the `close()` method. sess = tf.compat.v1.Session() sess.run(...) sess.close() # Using the context manager. with tf.compat.v1.Session() as sess: sess.run(...) ``` The [`ConfigProto`](https://www.tensorflow.org/code/tensorflow/core/protobuf/config.proto) protocol buffer exposes various configuration options for a session. For example, to create a session that uses soft constraints for device placement, and log the resulting placement decisions, create a session as follows: ```python # Launch the graph in a session that allows soft device placement and # logs the placement decisions. sess = tf.compat.v1.Session(config=tf.compat.v1.ConfigProto( allow_soft_placement=True, log_device_placement=True)) ``` @compatibility(TF2) `Session` does not work with either eager execution or `tf.function`, and you should not invoke it directly. To migrate code that uses sessions to TF2, rewrite the code without it. See the [migration guide](https://www.tensorflow.org/guide/migrate#1_replace_v1sessionrun_calls) on replacing `Session.run` calls. @end_compatibility rNcs&tt|j|||dd|_d|_dS)aCreates a new TensorFlow session. If no `graph` argument is specified when constructing the session, the default graph will be launched in the session. If you are using more than one graph (created with `tf.Graph()`) in the same process, you will have to use different sessions for each graph, but each graph can be used in multiple sessions. In this case, it is often clearer to pass the graph to be launched explicitly to the session constructor. Args: target: (Optional.) The execution engine to connect to. Defaults to using an in-process engine. See [Distributed TensorFlow](https://tensorflow.org/deploy/distributed) for more examples. graph: (Optional.) The `Graph` to be launched (described above). config: (Optional.) A [`ConfigProto`](https://www.tensorflow.org/code/tensorflow/core/protobuf/config.proto) protocol buffer with configuration options for the session. )rN)superrnr|_default_graph_context_manager _default_session_context_manager)rrrrrTrrr|/szSession.__init__cCsH|jdur|j|_ntd|jdur4||_|j|jS)NzvSession context managers are not re-entrant. Use `Session.as_default()` if you want to enter a session multiple times.)rqrrrrr __enter__rrrrrtIs    zSession.__enter__c Cs|tjurtd|fz|j|||Wn0ty\}z||krFnWYd}~n d}~00|j|||d|_d|_|rtj d|j d}d|_ | | d|rtdn| dS)Nz"Session closing due to OpError: %sZSessionCloseThread)rWrTg>@zsSession failed to close after 30 seconds. Continuing after this point may leave your program in an undefined state.)r rJloggingerrorrr__exit__rrqrThreadrdaemonstartjoinis_alive)r exec_typeZ exec_valueZexec_tbrvZ close_threadrrrrwUs2    zSession.__exit__cCs@|durt|}|dur*dd|D}ng}t|||dS)aResets resource containers on `target`, and close all connected sessions. A resource container is distributed across all workers in the same cluster as `target`. When a resource container on `target` is reset, resources associated with that container will be cleared. In particular, all Variables in the container will become undefined: they lose their values and shapes. NOTE: (i) reset() is currently only implemented for distributed sessions. (ii) Any sessions on the master named by `target` will be closed. If no resource containers are provided, all containers are reset. Args: target: The execution engine to connect to. containers: A list of resource container name strings, or `None` if all of all the containers are to be reset. config: (Optional.) Protocol buffer with configuration options. Raises: tf.errors.OpError: Or one of its subclasses if an error occurs while resetting containers. NcSsg|]}t|qSr)rr)rXcrrrrZr?z!Session.reset..)rrrTF_Reset)r containersrrrrreset}s  z Session.reset)rNN)NN) r'r(r)r*r|rtrwrpr __classcell__rrrsrrns @ (InteractiveSessioncs:eZdZdZeZdZd fdd ZfddZ Z S) raA TensorFlow `Session` for use in interactive contexts, such as a shell. The only difference with a regular `Session` is that an `InteractiveSession` installs itself as the default session on construction. The methods `tf.Tensor.eval` and `tf.Operation.run` will use that session to run ops. This is convenient in interactive shells and [IPython notebooks](http://ipython.org), as it avoids having to pass an explicit `Session` object to run ops. For example: ```python sess = tf.compat.v1.InteractiveSession() a = tf.constant(5.0) b = tf.constant(6.0) c = a * b # We can just use 'c.eval()' without passing 'sess' print(c.eval()) sess.close() ``` Note that a regular session installs itself as the default session when it is created in a `with` statement. The common usage in non-interactive programs is to follow that pattern: ```python a = tf.constant(5.0) b = tf.constant(6.0) c = a * b with tf.compat.v1.Session(): # We can also use 'c.eval()' here. print(c.eval()) ``` rrNcs|stjdd}tj|d}d|j_tt||||tj2tj dkrTt dtj d7_ Wdn1sv0Yd|_ | |_d|j_|j||_|jdur| |_d|j_|jdS) aCreates a new interactive TensorFlow session. If no `graph` argument is specified when constructing the session, the default graph will be launched in the session. If you are using more than one graph (created with `tf.Graph()`) in the same process, you will have to use different sessions for each graph, but each graph can be used in multiple sessions. In this case, it is often clearer to pass the graph to be launched explicitly to the session constructor. Args: target: (Optional.) The execution engine to connect to. Defaults to using an in-process engine. graph: (Optional.) The `Graph` to be launched (described above). config: (Optional) `ConfigProto` proto used to configure the session. T) allow_growth) gpu_optionsrzAn interactive session is already active. This can cause out-of-memory errors in some cases. You must explicitly call `InteractiveSession.close()` to release resources held by the other session(s).r,NF)r GPUOptionsrrplace_pruned_graphrprr| _count_lock_active_session_countwarningswarn_explicitly_closedr_default_sessionenforce_nestingrt_explicit_graph_default_graph)rrrrrrsrrr|s$    ,    zInteractiveSession.__init__cstt|tj<|js2tjd8_d|_nWddSWdn1sV0Y|jdur|jdddd|_|j dddd|_ dS)zCloses an `InteractiveSession`.r,TN) rprrrrrrrrwrrrsrrrs. zInteractiveSession.close)rNN) r'r(r)r*rrrrr|rrrrrsrrs &2)NN)@r*rrrlrrnumpyr-rtensorflow.core.protobufrrtensorflow.python.clientrrtensorflow.python.eagerrrtensorflow.python.frameworkrrr r r r tensorflow.python.opsr tensorflow.python.platformrruZ'tensorflow.python.training.experimentalrtensorflow.python.utilrrtensorflow.python.util.compatr tensorflow.python.util.tf_exportrCounterrrFrr2r< SparseTensor IndexedSlicesrKrJrPrVr\r]rlrrhrjrkrrrrrnrrrrrs                  !   7I/$""{ *y 3