BVh vdZddlZddlZddlmZddlmZddlmZddlmZddl m Z ddl m Z dd l m Z dd l mZdd l mZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddl m!Z!ddl m"Z"ddl#m$Z$dZ%e&ddgZ'e&ddgZ(e'jSe(Z*GddejVdgd Z,Gd!d"ejVd"d#d$gZ-Gd%d&ejVd&d'd(gZ.Gd)d*e/Z0Gd+d,e0Z1Gd-d.e0Z2Gd/d0e2Z3Gd1d2e2Z4Gd3d4e2Z5Gd5d6e2Z6Gd7d8e2Z7Gd9d:e2Z8Gd;de9Z:Gd?d@e9Z;GdAdBe9Z<GdCdDe9Z=GdEdFe0Z>GdGdHe/Z?GdIdJe?Z@GdKdLe@ZAGdMdNe@ZBGdOdPe?ZCdQZDdRZEdSZFdTZG d^dUZH d^dVZI d^dWZJ d_dXZKe!jddYZe$d[g\ d_d]ZMy)`z {})r6source destinationr%s r'r8z _Edge.__str__Is   T[[$*:*: ;;r)Nr9r r)r'r;r;Es)cNeZdZdZdZdZdZdZdZe dZ e dZ y ) _Convertiblez9An entity that can have variables converted to constants.c.||_g|_d|_yN)_enclosing_graph_outgoing_edges_converted_self)r&enclosing_graphs r'__init__z_Convertible.__init__Ps+DDDr)ct)amA copy of this Convertible to be modified during conversion. Returns: Implementations should return the copied instance, which in turn should be contained in converted_enclosing_graph(). This instance is the one that will be modified during conversion. Its main use will be in the implementations of convert_variable_to_constant(). NotImplementedErrorr%s r'converted_selfz_Convertible.converted_selfUs  r)ct)aConverts a variable in this Convertible and its dependencies. This method should make sure that a converted copy of itself is present in the converted graph, and that all Convertibles depending on this one also go through the same process. Args: incoming_edge: The graph edge into this Convertible that is being converted to a constant. tensor_data: The tensor representing the constant. rIr& incoming_edge tensor_datas r'convert_variable_to_constantz)_Convertible.convert_variable_to_constant`s  r)ct)a,Calls add_outgoing_edge for all edges known to this Convertible. This is used to build the graph dependencies, so that conversion of variables to constants can be properly propagated through the graph. Usually this method will call add_outgoing_edge() to all the Convertible inputs. rIr%s r' create_edgesz_Convertible.create_edgesns  r)c:|jj|y)zAdds an outgoing edge to the Convertible's list of edges. Args: edge: The outgoing edge (its source should be 'self'). N)rDappend)r&edges r'add_outgoing_edgez_Convertible.add_outgoing_edgews  %r)c6|jjS)zThe graph being converted.)rCrKr%s r'converted_enclosing_graphz&_Convertible.converted_enclosing_graphs  / / 11r)c|jS)z/The list of edges starting at this Convertible.)rDr%s r'outgoing_edgesz_Convertible.outgoing_edgess   r)N) r*r+r,r-rGrKrPrRrVr/rXrZr r)r'r@r@MsFA  & 2 2    r)r@cZeZdZdZfdZdZedZedZdZ dZ dZ xZ S) _FunctionzA library function Convertible. Edges into functions are edges from node _inputs_ into function _inputs_: Functions get their input from their callers, not from node outputs, and the callers in turn get those values as inputs. c tt| |||_|jDcic]%}|j t j|||'c}|_ycc}w)NnodefunctionrF) superr\rG _functionnode_defname_Nodenew_nodes)r&r`rFn __class__s r'rGz_Function.__init__s^ )T#O4DN""   q4 I JDKs*AcB|jjjSrB)r` signaturerdr%s r'r8z_Function.__str__s == " " ' ''r)c|jSrB)rbr%s r'r`z_Function.functions >>r)c|jSrBrgr%s r'nodesz_Function.nodes ;;r)c|js|jjj}|jj |}|j j|||j j||_|jS)aThe Function copy to be converted. The copy will be renamed according to the graph's converted_function_name map, to ensure the name does not match anything currently in TensorFlow's function cache. Returns: The function instance to be converted. ) rEr`rkrdrCconverted_function_namesrXrename_function functions)r&old_namenew_names r'rKz_Function.converted_selfsv #((--h&&??Ih $$44XxH!;;EEhOd   r)c|jj}|jD]B}|jj|k(s|jjj ||D|j j}|j|jj|_ d|jvr^d|jdjj|_|jdjj|j dd=|j"|j}d|vrKd|djjd_|djjdj dd=yy)zConverts one function argument into a constant. Args: incoming_edge: The edge into the argument to be converted. tensor_data: The constant value. _input_shapesTN_output_shapesr)r>r2rZr=r7rPrKr`r$rk input_argr"attrlistshape unknown_rankdimarg_attr)r&rNrOr2rUr` arg_attrss r'rPz&_Function.convert_variable_to_constantsO  % % + +E##   e # $$AA +  ""$--H/:/@/@H  ',(--'FJhmmO$))//6C -- ( - - 3 3E : > >q A!!%(--I9$?Ci !&&,,Q/< $ % * * 0 0 3 7 7 :%r)cb|jjD]}|jyrB)rgvaluesrR)r&rhs r'rRz_Function.create_edgess( [[   !nnr)) r*r+r,r-rGr8r/r`rorKrPrR __classcell__ris@r'r\r\sI(     ";4r)r\cveZdZdZfdZdZedZedZ edZ dZ dZ d Z d Zd ZxZS) rezA Convertible NodeDef.cHtt| |||_||_yrB)rarerG_noderbr&r_r`rFris r'rGz_Node.__init__s  %0DJDNr)c.|jjSrB)rrdr%s r'r8z _Node.__str__s ::??r)c||jdvr t|||S|jdk(r t|||S|jdk(r t|||S|jdk(r t |||S|jdk(r t |||S|jdk(r t |||S|jdk(r t |||S|jdk(r t|||S|jd vr t|||S|jd vr t|||S|jd vr t|||St|||S) z/Creates a new _Node base on its operation type.) VariableV2 VarHandleOp PlaceholderCaseMergePartitionedCallStatefulPartitionedCallReadVariableOpResourceGatherResourceGatherNd)rr)rr)EnterExitIdentity NextIterationSwitch_SwitchN) op _VarHandle_Case_Merge_PartitionedCall _ReadVariable_ResourceGather_ResourceGatherNd_If_While _Intermediaterer^s r'rfz _Node.newsK ww>> h 88 F  4? 33 G  D(O 44 % % dHo >> - - dHo >> $ $ 4? ;; $ $ T8_ == & & tX ?? ) ) x 11 / / D(O 44 L L 4? ;; 4? 33r)c|jSrB)rr%s r'r_z _Node.nodes ::r)cr|j|jjS|jjS)z2The node container (either a graph or a function).)rbr`rC graph_defr%s r' containerz_Node.containers0 ~~! ^^ $ $$  * **r)c|jP|jxs |j}|jj|j j |_|jS)zThe NodeDef to be converted. Returns: The NodeDef to be converted, which can come from either a graph for a function. Derived classes should call this (via 'super') to make sure the node is retrieved from the right place. )rErbrCrKrorrd)r&r=s r'rKz_Node.converted_self sT #~~6!6!6f#224::4::??Kd   r)cyrBr rMs r'rPz"_Node.convert_variable_to_constantsr)c t|jjD]N\}}|ddk(r|j|}|jj t |t||Py)Nr^) enumeraterinput resolve_inputr7rVr;r4)r&r2rdr=s r'rRz_Node.create_edgessg !1!121 t aC!!$'f **  $. /1 1r)c^|jd}|d}|ddk(r|dd}d}t|dkDr!|djrt|d}|j#t |j j||S|dk7s||jjvr#t |jj||S|jjjjDcgc]}|j}}t |j|j|Scc}w)a#Resolves an input into its _EndPoint. A NodeDef's input name can refer to either global NodeDefs (in the GraphDef's node list), a NodeDef in a function's node list, or a Function (in the GraphDef's function library). The name can also carry semantic information, depending on whether it starts with "^". This method handles all that logic in order to find the object to which the input name refers to. Args: input_name: The input name to resolve. Returns: The object referred to by 'input_name'. :rrN) splitlen isnumericintrbr4rCror`rkrzrdr2)r& input_name name_elts source_name source_indexiinputss r'rz_Node.resolve_input"s 2  %IA,K1~OkL 9~im5572'l ~~ t,,22;? NNqK4>>+?+?? t~~++K8, GG"nn55??II Jaff JF J T^^V\\+%> ??Ks0D*c N|jj|}d}|jdr,|jj}t |}||kDr&|||<y|jdrd}|dk(r||_yt d|dd|jjd |d |dd ) zChanges the type of a given input. Args: attr_name: The NodeDef attribute containing the type to change. index: The index of the input type to change. dtype: The type to change to. rr|Nr"rz`index` dz is out of range for node(z).attr(z ), which has z elements.)rr{HasFieldr|r"r ValueErrorrd)r& attr_namer2r$r{ num_typestypess r' update_dtypez_Node.update_dtypeLs ::??9 %DI }}Viinnee*i U e  v i !  xay)!ZZ__-WYK}!!}J0 11r))r*r+r,r-rGr8 staticmethodrfr/r_rrKrPrRrrrrs@r'reresg 448   + +   1(@T1r)receZdZdZdZy)rz,Specialization of _Node to intermediate ops.cR|j}|jd|jj|jd|j j vr|j j d=|jD](}|jjj||*y)NTry) rKrr>r2r$r_r{rZr7rP)r&rNrOr_rUs r'rPz*_Intermediate.convert_variable_to_constantks    Dc=44::K>) ))..) *## ""??  r)Nr*r+r,r-rPr r)r'rrhs 4r)rc"eZdZdZfdZxZS)rz%Specialization of _Node to Merge ops.c tt| t|jt|j j d|y)Nr)rarrPr;r=r>r7)r&rNrOris r'rPz#_Merge.convert_variable_to_constantxs> &$4 m""M--991= ?@KMr))r*r+r,r-rPrrs@r'rrus-MMr)rceZdZdZdZy)rz'Specialization of _Node to VarHandleOp.c(tj|j|j|jj}|j j }|j|jj|_ d|_ |jdj|j|jdjj||jD](}|j j"j%||*y)NConstr$value)rmake_tensor_protor1r$r}rKr_Clearrrdrr{CopyFromr(tensorrZr>r7rP)r&rNrO tensor_protor_rUs r'rPz'_VarHandle.convert_variable_to_constants001B1B1<1B1B1<1B1B1H1HJL    % %DJJL DIDGIIg 6 67IIg&&|4## ""??  r)Nrr r)r'rrs /r)rceZdZdZdZy)rz*Specialization of _Node to ResourceGather.c|jy|jjdjdk7rGt d|jj d|jjdjd|jj dz}|jjd}t j|jjdj}|jj}||jvrQtj|jjj|j||j|<|j|j}||_d |_|jd j#|t%j&||j(|j* }|jd j,j#||jj} | j/|jj | _d | _| j0j3|jj0d|jj0d|g| jdj#|jjd | jdj#|jjd| jdj#|d|jjvr6| jdj#|jjdyy)N batch_dimsrz4batch_dims must be 0 for freeze_graph, but got node(z).attr('batch_dims') = .z/axisTindicesr^rr$)r$r}rGatherV2rTparamsTaxis_class)rbrr{rrrdnparrayrCrKrorerfrr_addrrrrr"r}rrrextend) r&rNrOaxis_node_name axis_dtype axis_dataconverted_graphoutput_axis_noder output_nodes r'rPz,_ResourceGather.convert_variable_to_constants ~~!  zz|$&&!+ #zz//F**//,799:!= >>ZZ__w.N,J6889I++::>)/8/+oN+',,^<AA*!'"++J7  * * AF'"))226:%%',,KzzKKN   ! djj..q1>BDY(()ABZ ))$**//**EFW&&z24::??"x ))$**//(*CD#r)Nrr r)r'rrs 2$Er)rceZdZdZdZy)rz,Specialization of _Node to ResourceGatherNd.c|jj}|j|jj|_d|_|j j|jj d|jj dg|jdj|jjd|jdj|jjdd|jjvr6|jdj|jjdyy)NGatherNdrrrr$rr) rKr_rrrdrrrr{r)r&rNrOrs r'rPz._ResourceGatherNd.convert_variable_to_constants%%',,KzzKKNdjj..q14::3C3CA3FGHY(()ABZ ))$**//**EF4::??"x ))$**//(*CD#r)Nrr r)r'rrs 4 Er)rceZdZdZdZy)rz*Specialization of _Node to ReadVariableOp.c|jj}|j|jj|_d|_|j j|jj d|jdj|jjdd|jjvr5|jdj|jjd|j|jD]}|jj}|jjj}t|t sN|jj |j#d}t%|dkDs|ddk(sd |d<dj'||jj |<yy) Nrrrr$rrrroutput)rKr_rrrdrrrTr{rrbrZr>r2r7 isinstancererrjoin)r&rNrOr_rUr2destinput_name_partss r'rPz*_ReadVariable.convert_variable_to_constantsj    % %DJJL DIDGJJdjj&&q)*IIcNDJJOOG454::??" ii""4::??8#<=  ~~!%%@$  &&++::< dE "!YY__U399#>  ! "Q &+;A+>'+I"* Q %(XX.>%?DIIOOE "@"r)Nrr r)r'rrs 2@r)rc<eZdZdZfdZfdZdZfdZxZS)_FunctionCallerz7A base class for Convertibles that reference functions.cZtt| |||||_||_||_y)aInitializes a _FunctionCaller. Args: node: As in _Node. function: As in _Node. enclosing_graph: As in _Node. first_function_input: The index of the first NodeDef input that is tied to the function inputs. It is assumed that the rest of the NodeDef inputs map one to one to function inputs. type_attribute: The name of the NodeDef attribute that defines the input types. It is assumed that the types listed here map one-to-one with the function inputs (that is, they do _not_ specify types for inputs that are not passed to functions). function_attributes: The names of the NodeDef attributes containing references to functions. N)rarrG_first_function_input_type_attribute_function_attributes)r&r_r`rFfirst_function_inputtype_attributefunction_attributesris r'rGz_FunctionCaller.__init__s0$ /4)$/J!5D)D 3Dr)cz|j"tt|j}|j j }|jD]}|j|}|jdrX|j j|jjr)||jj|j_ {|jds|jjD]<}|j j|js)||j|_ >|jS)Nfuncr|)rErarrKr_rCrrrr{ris_converted_functionrrdr|)r&r_converted_namesrr{rris r'rKz_FunctionCaller.converted_selfs # ?D 8 : ? ?d--FFo00 5)yy# ==  --CC  *499>>:$)). ]]6 "iinn 5d$$::499E)$))4di 5 5   r)c|jj}|jD]U}|jj}|jj|k(s3t |t sD|j||W|j}||jk\r5|j|j||jz |jyyrB) r>r2rZr7r=rr\rPrKrrrr$)r&rNrOr2rUrr_s r'rPz,_FunctionCaller.convert_variable_to_constants  % % + +E##=    ) )d   e # 4(C ))$ <=    D *** ,, : ::K}|jt!t#|||jzt#||@|j ds|j$jD]}|jj|j}tt|jj|jz D]>}|jt!t#|||jzt#||@y)zCreates edges related to a function caller. Edges from a function caller to its called functions are always edges from _inputs_ to _inputs_: a FunctionDef input is given by the caller, based on its own inputs. rr|N)rarrRrrr{rrCrtrrdrangerrrrVr;r4r|)r&rr{r`r2rris r'rRz_FunctionCaller.create_edges+sl /4-/..1 ZZ__Y 'd v ((22499>>B3tzz//043M3MMN /E  D%$*D*D"DEHe,. / / == IINN 1D**44TYY?($**""#d&@&@@B 1e  " "dED,F,F$FGh.0 1 1 11r)) r*r+r,r-rGrKrPrRrrs@r'rrs ?4. O.11r)rc"eZdZdZfdZxZS)rz.Specialization of _Node to If-like operations.c <tt| |||ddddgy)NrTin then_branch else_branchrrr)rarrGrs r'rGz _If.__init__Js. #t *M: r2rrTensorShapeProtor1DimrrrdrCrtr`r$rk output_argr")r&rNrOr_r body_namerris r'rPz#_While.convert_variable_to_constantzs5 &$4]KP    D yy~~o&++11 iinn_%**00  # # ) )++38//(..445#3377S7A5, ',,11I  * *9 5 D D F O OD0;0A0A NN!!''))-5s'F )r*r+r,r-rGrPrrs@r'rrns9.BBr)rczeZdZdZfdZedZedZedZedZ dZ dZ d Z d Z xZS) _GraphDefzA convertible GraphDef.c tt| d||_|jDcic]%}|j t j|d|'c}|_|jjDcic]$}|jj t||&c}|_ |jd|_ycc}wcc}w)N)rFr^)rarrG _graph_defr_rdrerfrglibraryr`rkr\ _functionsrR_converted_function_names)r&rrhrris r'rGz_GraphDef.__init__s )T#D#9DO   q4 FFDK ""++  )At<<DO %)D"s *B>5)Cc|jSrBr r%s r'rz_GraphDef.graph_def ??r)c|jSrBrnr%s r'roz_GraphDef.nodesrpr)c|jSrB)r"r%s r'rtz_GraphDef.functionsr&r)c |jg}|jD]m}|jdd}t|dk(r7|dj r$|j t |d|d|fZ|j d||fot|Dcic]+\}}}|dj|tj-c}}}|_|jScc}}}w)a:Map from original to new function names. In order to avoid conflicts (two functions with the same name, one converted and one not), we need to change the name of every converted function to something that is hopefully unique. Returns: Map from original to new suggested function names. _rrrz {}_frozen_{}) r#rtrsplitrrrTrsortedr6ruid)r& parsed_namesrdelementsr* base_names r'rrz"_GraphDef.converted_function_namess %%-l..0$;;sA& x=A (1+"7"7"9   s8A;/!dC D   r4. / 0'-\&:(("q)T %%i; ;(d$  ) )) (s0C c|jj|}||jj_||j|<yrB)rtpopr`rkrd)r&rurvrs r'rsz_GraphDef.rename_functions6 >>  h 'D#+DMM #DNN8r)cZ||jjvxr||jvSrB)rKrtrr)r& function_names r'rz_GraphDef.is_converted_functions1 !4!4!6!@!@ @ 86668r)c|j?tj}|j|jt ||_|jSrB)rErGraphDefrr r)r& copied_graphs r'rKz_GraphDef.converted_selfsG #'')lDOO,&|4d   r)c|jjD]}|j|jjD]}|jyrB)rgrrRr")r&rhrs r'rRz_GraphDef.create_edgessN [[   !nn __ # # %nnr))r*r+r,r-rGr/rrortrrrsrrKrRrrs@r'rrso *       * *2$ 8  r)rcXeZdZdZ d dZedZedZedZdZ dZ y) _ConverterDataaContainer for constant conversion supporting data. The data includes the graph being converted, and the pre-converted tensors. This class will be specialized for ConcreteFunction and Session-based conversions, as the means to obtain that data is different for each case. Nc\||_i|_|j||_||_yrB)r  _tensor_data_build_node_defs_list_variable_names_allowlist_variable_names_denylist)r&rvariable_names_allowlistvariable_names_denylists r'rGz_ConverterData.__init__s/ DOD %=D"$;D!r)c|jS)zThe graph to be converted.r%r%s r'rz_ConverterData.graph_defs ??r)c|jS)zAll the node defs in the graph to be converted. Returns: A map from node name to the NodeDef for all NodeDefs in the graph, as well as all control flow NodeDefs in the functions. ) _node_defsr%s r' node_defsz_ConverterData.node_defss ??r)c|jS)z4A map from tensor name to its converted _TensorData.)r=r%s r'rOz_ConverterData.tensor_datas   r)c~|jduxs||jvxr|jduxs||jvS)z@Checks whether to convert the given variable name to a constant.N)r?r@)r&rds r'_should_convertz_ConverterData._should_convertsN  * *d 2 3 D22 2 ;--5:D999;r)c|jjDcic]}|j|c}|_|jjrv|jjj D]R}|jj |jDcic]!}|jtvr |j|#c}Tyycc}wcc}w)aBuilds the list of NodeDefs in the GraphDef. This list consists of all NodeDefs in the main graph as well as all control flow NodeDefs in the functions. The remaining NodeDefs in the functions are not included because the op names are not unique and the variables are handled differently than the main graph. The control flow ops need to be extracted because they are need their attributes to be updated similar to the control flow ops in the main graph. N) r r_rdrEr!r`updatercr_CONTROL_FLOW_OPS)r&r_rs r'r>z$_ConverterData._build_node_defs_list s48??3G3GH4tyy$HDO //))22 $   ww++ IItO   I s C&C NN) r*r+r,r-rGr/rrFrOrIr>r r)r'r;r;sZ)-'+<      ; r)r;c4eZdZdZ dfd ZdZdZxZS)_FunctionConverterDataz5Container for ConcreteFunction-based conversion data.cz||_t|||}tt|||||j y)azCreates the conversion data for the given function. Args: func: ConcreteFunction. lower_control_flow: Boolean indicating whether or not to lower control flow ops such as If and While. aggressive_inlining: Boolean indicating whether or not to do aggressive function inlining (might be unsafe if function has stateful ops, not properly connected to control outputs). variable_names_allowlist: The set of variable names to convert (by default, all variables are converted). variable_names_denylist: The set of variable names to omit converting to constants. rArBN)_func_run_inline_graph_optimizationrarOrG_build_tensor_data)r&rlower_control_flowaggressive_inliningrArBrris r'rGz_FunctionConverterData.__init__$sK*DJ.t5G/BDI $0!9 719  r)c,tjd)DReturns the value in the tensor. Must be implemented in sub-classes.z;The evaluation method should be implemented in sub-classes.)r UnimplementedErrorr&rs r'_evalz_FunctionConverterData._evalDs  # #E GGr)ci}|jjjD]>}t|jjD]\}}|j |us|||<>@t|jjj D]\}\}}|jjdd}|j|s9||vr|j||}n[|jtjk(rtjdd|zt!j"|j|}t%|tj&|jj(||j*|<|j,j/D]3} | j0dk(s|j| js0| j|j2vsI|jjj55t7j8|jjj;| jdz} ddd|jj=g jgd} t%| j?| j@d jBd|j*| j<6y#1swYxYw) zBCaches the tensor data for all Placeholders in the given function.rrrz"Skip converting resource tensor %sr0r:0Nr$)"rRgraphrrcaptured_inputshandlecapturesrdrrIr[r$r resourceloggingvlogrrras_dtypeas_datatype_enumr=rFrrrO as_defaultridentityas_graph_elementpruner1r{r") r&map_index_to_variablevaridxcaptured_input val_tensor name_tensor tensor_namedatar_ identity_node pruned_graphs r'rTz)_FunctionConverterData._build_tensor_dataIsfzz))!*4::+E+E!F #~ :: ''*  $ +4DJJ4D4D4M4M*N& &j+$$**3/2k  ! !+ . % %zz/45   v . ,,q>L M xx :./'2 +<<(d $$%%'  L ##DII.  99D,, ,zz**, E%..   11$))d2BCEM ED))"}/A/A.BCEaH,)4 &&(IIg&++*$  DII &   E Es AKK rM)r*r+r,r-rGr[rTrrs@r'rOrO!s= )-'+ @G (r)rOceZdZdZdZy)_FunctionConverterDataInEagerzCContainer for ConcreteFunction-based conversion data in Eager mode.c"|jSrX)r1rZs r'r[z#_FunctionConverterDataInEager._evalws <<>r)N)r*r+r,r-r[r r)r'rvrvts Kr)rvc0eZdZdZ dfd ZdZxZS)_FunctionConverterDataInGraphzCContainer for ConcreteFunction-based conversion data in Graph mode.c||_|jtjt j j tD]}|j|tt|+|||||y)aCreates the conversion data for the given function. Args: func: ConcreteFunction. lower_control_flow: Boolean indicating whether or not to lower control flow ops such as If and While. aggressive_inlining: Boolean indicating whether or not to do aggressive function inlining (might be unsafe if function has stateful ops, not properly connected to control outputs). variable_names_allowlist: The set of variable names to convert (by default, all variables are converted). variable_names_denylist: The set of variable names to omit converting to constants. session: Session object. N) _sessionrunrglobal_variables_initializerrget_default_graphget_collectionVAR_ASSIGN_COLLECTIONrarzrG) r&rrUrVrArBsessionrris r'rGz&_FunctionConverterDataInGraph.__init__ss,DM KK 6689##%445JK kk"o '7   !r)c8|jj|Srx)r|r}rZs r'r[z#_FunctionConverterDataInGraph._evals ==  V $$r))NNN)r*r+r,r-rGr[rrs@r'rzrz|sK )-'+ #!J%r)rzc(eZdZdZ dfd ZxZS)_SessionConverterDataz,Container for Session-based conversion data.c0tj||}tt||||g}g}|j j D]h}|jdvs|j} |j| s0|jdk(r| dz} |j||j| dzj|rb|j|} t|| D]A\}} t| |jdjd|j |j<Cyy)NrQ)Variablerrrz/Read/ReadVariableOpr]r$r0)rextract_sub_graphrarrGrr_rrdrIrTr}ziprr{r"r=) r&rroutput_node_namesrArBnodes_to_converttensor_names_to_convertr_rqconverted_tensors tensor_valueris r'rGz_SessionConverterData.__init__s% ,,Y8IJI /!9 709  ##; = =ii ##K0  77m ##&<<+%&&{T'9:;!++&=> #$46G HK $ '2dii&8&=&=T(K$))$Kr)rMr rs@r'rrs4 )-'+ KKr)rctj}|j|d}|jD] }|| |jr4|jj D]}|j D] }|| |S)zSet '_lower_using_switch_merge' attributes to False. Sets the attribute to False in the NodeDefs in the main graph and the NodeDefs in each function's graph. Args: graph_def: GraphDef proto. Returns: GraphDef cR|jtvrd|jd_yy)NF_lower_using_switch_merge)rrLr{b)r_s r'disable_control_flow_loweringzGdisable_lower_using_switch_merge..disable_control_flow_lowerings& ww##16dii+,.$r))rr7rr_r!r`rc)routput_graph_defrr_rs r' disable_lower_using_switch_mergers'')I&7##(d!$'( ((11,--,$%d+,, r)cH|jj}|s t|}|jjD]}d|j vs|j d= t ||j}dD]}g}|jdjjD]W}tj} | j|| jd|j| jY||j|jjddt!j"} |j$|j&zD]1} | j(jj| j*3|jdj-| t/j0} | j2j4} d| _| j8jd |rt:j<j>| _ tCjD| |S) aGApply function inline optimization to the graph. Returns the GraphDef after Grappler's function inlining optimization is applied. This optimization does not work on models with control flow. Args: func: ConcreteFunction. lower_control_flow: Boolean indicating whether or not to lower control flow ops such as If and While. (default True) aggressive_inlining: Boolean indicating whether or not to do aggressive function inlining (might be unsafe if function has stateful ops not properly connected to control outputs). Returns: GraphDef api_implements)rr^)rmodel_variablestrainable_variableslocal_variablesrinitializer_nameNtrain_oprr`)#r^ as_graph_defrr!r`r{rcollection_def bytes_listrr VariableDefParseFromString ClearFieldrTSerializeToStringr CollectionDefroutputs node_listrdrr ConfigProto graph_optionsrewrite_optionsmin_graph_nodes optimizersr RewriterConfig AGGRESSIVEfunction_optimizationr OptimizeGraph)rrUrVrr` meta_graphrdraw_listrawvariablefetch_collectionrconfigrs r'rSrSs$jj%%') 0;I##,,*h8==( --( )*!9DJJG* CdH((5@@FF4))+hs#,-ooh0023 4 ;CJd#..44Q7 C$113{{T\\)8e$$++EJJ78 J'001AB  ! ! #&((88/$&/!##J/((33)  # #FJ 77r)cL|jj}tj|Dcgc]}|| c}}|jDcgc] }||vs| }}|Dcic]}|j |}}|Dcgc]}|j } }|j Dcgc]}|j } }|jjD]q} tjj| jj s;tjj| jj stj|| | } | jD]*} | j|| j j ,| Scc}wcc}wcc}wcc}wcc}w)aConstructs a concrete function from the `output_graph_def`. Args: func: ConcreteFunction output_graph_def: GraphDef proto. converted_input_indices: Set of integers of input indices that were converted to constants. Returns: ConcreteFunction. )r^internal_capturesrObjectIdentitySetrrdrr!r`r has_functionrkremove_functionr function_from_graph_def set_shaper})rrconverted_input_indices input_tensorsr2converted_inputsrnot_converted_inputsnot_converted_inputs_mapnew_input_namesnew_output_namesrnew_func input_tensors r'_construct_concrete_functionr)s**..-$66)@A}UAC ;;&8H*Hf)=$fkk60DDVV[[D/D04 =ffkk==  # # , ,:a%%akk&6&67 oo'' (8(89: 2 23C3B3CE( ooNl3L4E4EFLLMN /1BE=s# F  FFF9FF!cnt|j}|jjD]$\}}|j|j d|&|j j}|jjDchc]}|j |j}}||fScc}w)aVReplaces variables by constants on a given graph. Given a _ConverterData instance with converted variables in its tensor_data field, create a new graph where the respective variables are replaced with the converted constants. Args: converter_data: A pre-populated _ConverterData instance. Returns: The converted graph. N) rrrOitemsrorPrKrr2)converter_data input_graphrqrOrtrs r'_replace_variables_by_constantsrTs.223+"0"<"<"B"B"Dk;k"?? k ..0::/))002  gg 1 11 s B2cVt|||}t|\}}t|||S)aReplaces all the variables in a graph with constants of the same values. TensorFlow 2.0 function for converting all Variable ops into Const ops holding the same values. This makes it possible to describe the network fully with a single GraphDef file, and allows the removal of a lot of ops related to loading and saving the variables. This function runs Grappler's function inlining optimization in order to return a single subgraph. The current implementation only works for graphs that do not contain any control flow or embedding related ops. Args: func: ConcreteFunction. lower_control_flow: Boolean indicating whether or not to lower control flow ops such as If and While. (default True) aggressive_inlining: Boolean indicating whether or not to do aggressive function inlining (might be unsafe if function has stateful ops, not properly connected to control outputs). (default False) Returns: ConcreteFunction containing a simplified version of the original. rrUrVrrvrr)rrUrVrrrs r'!convert_variables_to_constants_v2rrsE41 +-/. /N#/%++ &d,<&= ??r)ctj}| tdt||||}t |\}}t |||S)aReplaces all the variables in a graph with constants of the same values. This function works as same as convert_variables_to_constants_v2, but it should be used in Graph mode. It is a temporary solution when users want to integrate their models written in TF2 with infra that requires TF1 mode. The current implementation only works for graphs that do not contain any control flow or embedding related ops. The function must be called in a Session context. Args: func: ConcreteFunction. lower_control_flow: Boolean indicating whether or not to lower control flow ops such as If and While. (default True) aggressive_inlining: Boolean indicating whether or not to do aggressive function inlining (might be unsafe if function has stateful ops, not properly connected to control outputs). (default False) Raises: RuntimeError: If no Session context is present. Returns: ConcreteFunction containing a simplified version of the original. z8The conversion must be carried out in a Session context.)rrUrVrr)rget_default_session RuntimeErrorrzrr)rrUrVrrrrs r'#convert_var_to_const_function_in_v1rso:  # # %' _ B DD1 +- . /N#/%++ &d,<&= ??r)c^t|||}t|\}}t|||}||fS)agReplaces all the variables in a graph with constants of the same values. This function works as same as convert_variables_to_constants_v2, but it returns the intermediate `GraphDef` as well. This `GraphDef` contains all the debug information after all the transformations in the frozen phase. Args: func: ConcreteFunction. lower_control_flow: Boolean indicating whether or not to lower control flow ops such as If and While. (default True) aggressive_inlining: Boolean indicating whether or not to do aggressive function inlining (might be unsafe if function has stateful ops, not properly connected to control outputs). Returns: ConcreteFunction containing a simplified version of the original, and also the intermediate GraphDef containing the node debug information for the transformations in the frozen phase. rrr)rrUrVrrr frozen_funcs r'*convert_variables_to_constants_v2_as_graphrsO,1 +-/. /N#/%++-T3C-DF+ & &&r)c @tt|||||\}}|S)aReplaces all the variables in a graph with constants of the same values. This function works similarly to convert_variables_to_constants_v2, but it retrieves the constant values from a Session instead of from a ConcreteFunction. This is useful when converting graphs generated from TensorFlow V1, where ConcreteFunctions are not available. This also differs from graph_util.convert_variables_to_constants in that it supports resource variables when V2 control flow constructions are present. Args: session: Active TensorFlow session containing the variables. graph_def: A GraphDef to convert. output_node_names: List of name strings for the result nodes of the graph. variable_names_allowlist: The set of variable names to convert (by default, all variables are converted). variable_names_denylist: The set of variable names to omit converting to constants. Returns: An optimized GraphDef. rrrrArBr)rr)rrrrArBr*s r'1convert_variables_to_constants_from_session_graphrs161*-#;"9 ;<,)Q r)zThis API was designed for TensorFlow v1. See https://www.tensorflow.org/guide/migrate for instructions on how to migrate your code to TensorFlow v2.)date instructionsz)graph_util.convert_variables_to_constants)v1c&t|||||}|S)aReplaces all the variables in a graph with constants of the same values. If you have a trained graph containing Variable ops, it can be convenient to convert them all to Const ops holding the same values. This makes it possible to describe the network fully with a single GraphDef file, and allows the removal of a lot of ops related to loading and saving the variables. Args: sess: Active TensorFlow session containing the variables. input_graph_def: GraphDef object holding the network. output_node_names: List of name strings for the result nodes of the graph. variable_names_whitelist: The set of variable names to convert (by default, all variables are converted). variable_names_blacklist: The set of variable names to omit converting to constants. Returns: GraphDef containing a simplified version of the original. Raises: RuntimeError: if a DT_RESOURCE op is found whose ancestor Variables are both denylisted AND whitelisted for freezing. r)r)sessinput_graph_defrvariable_names_whitelistvariable_names_blacklistrets r'convert_variables_to_constantsrs%F :)76  8# *r))TFrM)Nr- collectionsr1rtensorflow.core.frameworkrrrrtensorflow.core.protobufrrr tensorflow.python.eagerr r tensorflow.python.frameworkr r rrrtensorflow.python.grapplerrtensorflow.python.opsrrtensorflow.python.platformrrc tensorflow.python.training.saverrtensorflow.python.utilrr tensorflow.python.util.tf_exportrrset_CONDITIONAL_OPS _LOOP_OPSunionrL namedtuplerr4r;objectr@r\rerrrrrrrrrrrrr;rOrvrzrrrSrrrrrr deprecatedrr r)r'rsC4/62/38+1..2+33++<>.26/m,- *+ , $**955K=*EF59& &&{]G4LM9< "K " "7X},E F<: 6: zI IXO1LO1d E  MU M('Ee'ET E E@E@8Z1eZ1z L L^B VB JP^Pf$:*%$:*%ZKNKD:>8B(V2>:>:?#?N<@