o i eX7@sdZddlmZddlmZddlmZddZddZd d Z d d Z d+ddZ ddZ d,ddZ ddZddZd,ddZddZ    d-dd ZGd!d"d"eZd#d$Zd%d&Zd'd(Zd)d*Zd S).z#Tools for selecting ops in a graph.)ops)tensor)object_identitycCs,z tj|jjduWStyYdSwNF)r_gradient_registrylookupop_defname LookupErroropr P/var/www/myenv/lib/python3.10/site-packages/tensorflow/python/ops/op_selector.pyis_differentiables  rcCs4t|tjrdSzt|}WdStyYdSw)z&Return true if the object is iterable.FT) isinstance tensor_libTensoriter Exception)obj_r r r is_iterables   rcCs2t|}|D]}||vr||||q|S)aAdd all the elements of `lb` to `la` if they are not there already. The elements added to `la` maintain ordering with respect to `lb`. Args: la: List of Python objects. lb: List of Python objects. Returns: `la`: The list `la` with missing elements from `lb`. )setappendadd)lalbla_setlr r rconcatenate_unique(s   rcCs>t|tjstdt|g}|D]}||j7}q|S)zget all the tensors which are input or output of an op in the graph. Args: graph: a `tf.Graph`. Returns: A list of `tf.Tensor`. Raises: TypeError: if graph is not a `tf.Graph`. zExpected a graph, got: {})rrGraph TypeErrorformattypeget_operationsoutputs)graphtsr r r r get_tensors;s   r(NFcCst|tjr|St|stdt||dur tjtj f}nt|s'|f}d}|D]/}t||sDtdd dd|Dt||durL|j }q+|j |j j krZt d|q+|dure|set d|S) a<Return the unique graph used by the all the elements in tops. Args: tops: iterable of elements to check (usually a list of tf.Operation and/or tf.Tensor). Or a tf.Graph. check_types: check that the element in tops are of given type(s). If None, the types (tf.Operation, tf.Tensor) are used. none_if_empty: don't raise an error if tops is an empty list, just return None. Returns: The unique graph used by all the tops. Raises: TypeError: if tops is not a iterable of tf.Operation. ValueError: if the graph is not unique. z{} is not iterableNz Expected a type in ({}), got: {}z, cSg|]}t|qSr )str.0tr r r hs z$get_unique_graph..z+Operation {} does not belong to given graphz,Can't find the unique graph of an empty list)rrr rr!r"r# Operationrrjoinr& _graph_key ValueError)tops check_types none_if_emptygr r r rget_unique_graphMs0   r7cGsXd}t|D]#\}}|dur|jdur|j}q|jdur)|j|ur)td|dqdS)zCheck that all the element in args belong to the same graph. Args: *args: a list of object with a obj.graph property. Raises: ValueError: if all the elements do not belong to the same graph. Nzargs[z7] does not belong to the same graph as other arguments.) enumerater&r2)argsr&isgvr r r check_graphsssr<TcCsbt|tjr|r t|Stdt|s|g}|sgS|r*|r!dntj}t||ddd|DS)aConvert ts to a list of `tf.Tensor`. Args: ts: can be an iterable of `tf.Tensor`, a `tf.Graph` or a single tensor. check_graph: if `True` check if all the tensors belong to the same graph. allow_graph: if `False` a `tf.Graph` cannot be converted. ignore_ops: if `True`, silently ignore `tf.Operation`. Returns: A newly created list of `tf.Tensor`. Raises: TypeError: if `ts` cannot be converted to a list of `tf.Tensor` or, if `check_graph` is `True`, if all the ops do not belong to the same graph. 0allow_graph is False: cannot convert a tf.Graph.Nr4cSg|] }t|tjr|qSr )rrrr+r r rr.z"make_list_of_t..) rrr r(r!rrrr7)r' check_graph allow_graph ignore_opsr4r r rmake_list_of_ts  rDcCst|dd}dd|DS)aReturn all the generating ops of the tensors in `ts`. Args: ts: a list of `tf.Tensor` Returns: A list of all the generating `tf.Operation` of the tensors in `ts`. Raises: TypeError: if `ts` cannot be converted to a list of `tf.Tensor`. FrBcSg|]}|jqSr r r+r r rr.z&get_generating_ops..)rD)r'r r rget_generating_opss rHcCs>t|dd}g}|D]}|D] }||vr||qq |S)zReturn all the consuming ops of the tensors in ts. Args: ts: a list of `tf.Tensor` Returns: A list of all the consuming `tf.Operation` of the tensors in `ts`. Raises: TypeError: if ts cannot be converted to a list of `tf.Tensor`. FrE)rD consumersr)r'r3r-r r r rget_consuming_opss   rJcCsbt|tjr|r |Stdt|s|g}|sgS|r*|r!dntj}t||ddd|DS)a4Convert ops to a list of `tf.Operation`. Args: tops: can be an iterable of `tf.Operation`, a `tf.Graph` or a single operation. check_graph: if `True` check if all the operations belong to the same graph. allow_graph: if `False` a `tf.Graph` cannot be converted. ignore_ts: if True, silently ignore `tf.Tensor`. Returns: A newly created list of `tf.Operation`. Raises: TypeError: if tops cannot be converted to a list of `tf.Operation` or, if `check_graph` is `True`, if all the ops do not belong to the same graph. r=Nr>cSr?r )rrr/r,r r r rr.r@z#make_list_of_op..)rrr r$r!rr/r7)r3rArB ignore_tsr4r r rmake_list_of_ops  rMcCs|j}|r t|r |SgS|SN)inputsr)r only_differentiable op_inputsr r r _get_inputssrRr csp|o| }ts gztt}Wn tygYSwt|tjr1tdd}t|nt ddt t|}t t rVt ddt Mfdd} t } t } | rt } | D]5} t| |dD]}||vr{qt|j| vr| |jr| |jqt|r| jD]}|| vr| |r| |qqlt| | | } | sg|sfdd| D} | S)aDo a backward graph walk and return all the visited ops. Args: seed_ops: an iterable of operations from which the backward graph walk starts. If a list of tensors is given instead, the seed_ops are set to be the generators of those tensors. inclusive: if True the given seed_ops are also part of the resulting set. within_ops: an iterable of `tf.Operation` within which the search is restricted. If `within_ops` is `None`, the search is performed within the whole graph. within_ops_fn: if provided, a function on ops that should return True iff the op is within the graph traversal. This can be used along within_ops, in which case an op is within if it is also in within_ops. stop_at_ts: an iterable of tensors at which the graph walk stops. control_inputs: if True, control inputs will be used while moving backward. only_differentiable: if True, only traverse ops which are differentiable. This includes natively differentiable ops, or ops with custom gradients. Returns: A Python set of all the `tf.Operation` behind `seed_ops`. Raises: TypeError: if `seed_ops` or `within_ops` cannot be converted to a list of `tf.Operation`. FrEcs dus|vodup|SrNr r ) within_ops within_ops_fnr r is_within!sz(get_backward_walk_ops..is_within)rPcsg|]}|vr|qSr r rK)seed_opsr rr.6sz)get_backward_walk_ops..)rnextr StopIterationrrrrDrHrMrObjectIdentitySetlistrrRr rcontrol_inputsr)rV inclusiverSrT stop_at_tsr[rP first_seed_opr'rUresultwavenew_waver new_tnew_opr )rVrSrTrget_backward_walk_opssR            rdc@seZdZdZdZdS)UnliftableErrorz3Raised if a Tensor cannot be lifted from the graph.TN)__name__ __module__ __qualname____doc__ag_pass_throughr r r rre:srecCst|tjr |jS|SrN)rrrr ) op_or_tensorr r r _as_operationAs rlcCsdd|jDt|jS)NcSrFr r r,xr r rr.HrGz graph_inputs..)rOrZr[r r r r graph_inputsGsroc Cst|tjr |j}t|ts|g}dd|D}tdd|D}t|}i}|rw|}||vr2q'||||kr]|}|g} ||vrQ||}| |||vsDd ddt | DSt |D]} | |vrt| |vrt||| <|| qa|s)dS)a$Find one path from `from_op` to any of `tensors`, ignoring `sources`. Args: from_op: A `tf.Operation`. tensors: A `tf.Operation`, a `tf.Tensor`, or a list thereof. sources: A list of `tf.Tensor`. Returns: A python string containing the path, or "??" if none is found. cSr)r )rl)r,rr r rr.\szshow_path..css|]}|jVqdSrNr rmr r r ^szshow_path..z <- css |] }d|j|jfVqdS)z%s (%s)N)r r#rmr r rrplsz??) rrrr rZrpoprrr0reversedro) from_optensorssources final_ops visited_ops ops_to_visitsome_op_outputr path_oppathinpr r r show_pathKs8      r}c Cst|g}t}|rk|}||vrq ||d} |dur&||vr&d} n|jdkr9|dur3|s3d} ||j| rLtdt |t |t |||ft |D]} || || |vrh| |pa|vrh| | qP|s |S)aWalk a Graph and capture the subgraph between init_tensor and sources. Note: This function mutates visited_ops and op_outputs. Args: init_tensor: A Tensor or Operation where the subgraph terminates. sources: A set of Tensors where subgraph extraction should stop. disallowed_placeholders: An optional set of ops which may not appear in the lifted graph. Defaults to all placeholders. visited_ops: A set of operations which were visited in a prior pass. op_outputs: A defaultdict containing the outputs of an op which are to be copied into the new subgraph. add_sources: A boolean indicating whether placeholders which are not in sources should be allowed. Returns: The set of placeholders upon which init_tensor depends and are not in sources. Raises: UnliftableError: if init_tensor depends on a placeholder which is not in sources and add_sources is False. FNT PlaceholderzjUnable to lift tensor %s because it depends transitively on placeholder %s via at least one path, e.g.: %s) rlrrYrqrr#updater%rereprr}ror) init_tensorrudisallowed_placeholdersrw op_outputs add_sourcesrx extra_sourcesr should_raiser|r r r map_subgraphws6       rr)TTF)TNNr FF)ritensorflow.python.frameworkrrrtensorflow.python.utilrrrrr(r7r<rDrHrJrMrRrdrrerlror}rr r r rs6     &     O ,