o ?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)rZ_gradient_registrylookupZop_defname LookupErroropr b/home/www/facesmatcher.com/pyenv/lib/python3.10/site-packages/tensorflow/python/ops/op_selector.pyis_differentiables  r cCs4t|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)ZlaZlbZla_setlr r r concatenate_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)rrrrrrr Operationrrjoinr!Z _graph_key ValueError)tops check_typesZ none_if_emptygr r r r get_unique_graphMs0   r0cGsXd}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!r,)argsr!iZsgvr r r check_graphsssr4TcCsbt|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.Nr.cSg|] }t|tjr|qSr )rrrr&r r r r)z"make_list_of_t..) rrrr#rrrrr0)r" check_graph allow_graphZ ignore_opsr.r r r make_list_of_ts  r;cCst|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`. Fr:cSg|]}|jqSr r r&r r r r)z&get_generating_ops..)r;)r"r r r get_generating_opss r?cCs>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`. Fr<)r;Z consumersr)r"r-r(r r r r get_consuming_opss   r@cCsbt|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. r5Nr6cSr7r )rrr*r'r r r r r)r8z#make_list_of_op..)rrrrrrr*r0)r-r9r:Z ignore_tsr.r r r make_list_of_ops  rBcCs|j}|r t|r |SgS|SN)inputsr )r only_differentiableZ op_inputsr r r _get_inputssrFr 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`. Fr<cs dus|vodup|SrCr r ) within_ops within_ops_fnr r is_within!sz(get_backward_walk_ops..is_within)rEcsg|]}|vr|qSr r rA)seed_opsr r r)6sz)get_backward_walk_ops..)rnextr StopIterationrrrr;r?rBrObjectIdentitySetlistrrFr rcontrol_inputsr)rJZ inclusiverGrHZ stop_at_tsrOrEZ first_seed_opr"rIresultwaveZnew_waver Znew_tZnew_opr )rJrGrHr get_backward_walk_opssR            rRc@seZdZdZdZdS)UnliftableErrorz3Raised if a Tensor cannot be lifted from the graph.TN)__name__ __module__ __qualname____doc__Zag_pass_throughr r r r rS:srScCst|tjr |jS|SrC)rrrr )Z op_or_tensorr r r _as_operationAs rXcCsdd|jDt|jS)NcSr=r r r'xr r r r)Hr>z graph_inputs..)rDrNrOr r r r graph_inputsGsr[c 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 )rX)r'rr r r r)\szshow_path..css|]}|jVqdSrCr rYr r r ^szshow_path..z <- css |] }d|j|jfVqdS)z%s (%s)N)rrrYr r r r\lsz??) rrrr rNrpoprrr+reversedr[) Zfrom_opZtensorssourcesZ final_ops visited_ops ops_to_visitZsome_op_outputr Zpath_oppathinpr r r show_pathKs8      rdc 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. FNTZ PlaceholderzjUnable to lift tensor %s because it depends transitively on placeholder %s via at least one path, e.g.: %s) rXrrMr]rrupdater rSreprrdr[r) Z init_tensorr_Zdisallowed_placeholdersr`Z op_outputsZ add_sourcesraZ extra_sourcesr Z should_raisercr r r map_subgraphws6       rgr)TTF)TNNr FF)rWZtensorflow.python.frameworkrrrZtensorflow.python.utilrr rrr#r0r4r;r?r@rBrFrRrrSrXr[rdrgr r r r s6     &     O ,