o ei!O@s4ddlZddlmZmZddlmZmZddlZddl m Z ddl m Z ddl mZmZddlmZmZmZgd Ze d d d d Ze d d ddZe d d eGdddZe d d d d ejjfdejjdeedededeejjdeejjeejjeeeffff ddZ e d d dddZ!dS)N) dataclassfield)OptionalUnion) compatibility)map_arg) HolderModulelift_subgraph_as_module)CALLABLE_NODE_OPSis_node_output_tensorNodeList)getattr_recursivesetattr_recursive Component split_by_tags!move_non_tensor_nodes_on_boundaryF)is_backward_compatiblecCsb|dD])}t|tjjr!t|dr||jvr|j|}qdSt||r,t||}qdS|S)N._modules)split isinstancetorchnn ModuleListhasattrrgetattr)objnamelayerr e/var/www/addictedbytheproject.nl/epg/venv/lib/python3.10/site-packages/torch/fx/passes/split_utils.pyrs   rcCsJd|vr t|||dS|d}tt||dd|dd|dS)Nrrr )setattrrrrjoin)rattrvaluerr r r!r&s (rc@seZdZUdZejjed<eed<e ed<e e dZ e ed<e e dZ e ed<e e dZe ed<e edZeejjejjfed <e e dZe e ed <d Zeejjed <d S) rzX A component serves as a container for a subgraph we want to create afterwards. graphorderr)default_factoryinput_placeholders orig_inputs orig_outputs getattr_mapsconstructor_argsNgm)__name__ __module__ __qualname____doc__rfxGraph__annotations__intstrrlistr)r*r+dictr,Noder-r.r GraphModuler r r r!r/s  "rr.tagsreturn_fqn_mapping return_tupleGraphModuleClsreturncsdtjjjdtfdd}iii}g}itj}i} d} |D]} ttjt|| ||| <q!|j j D]} | j dkrO| durLt d| } q=| j dkri|j | j| jd | | <t| j| | _q=| j d kroq=t| d s}td | fd d|| j|| jD} || j| <tdd| Ddd}j|krtdjdjd|fdd}j | |}| j|_|| <|<q=| durt d|| jdD]}|j d kr|j|j|jd | |<qd|<qD]}|j dkr |j|qi}|D]qttjj}|r&j |nj t|dkr4|dn|t!|j jd\_"}|#||j$jtt| jj%dd}t|dkrk|sk|| jd<qt&jD]\}}tj'||j| |<qpq| t(| jd| jt)dd|D}|j j*|_*|| jdD]}|j d krt+||jt,||j-q|||}|r||fS|S)a9 Splits a GraphModule using tags on its graph nodes. We honor the order of tags. For example, we have tags = ["a", "b", "c"], the function will create the initial submodules in the order of "a", "b", "c". To set a tag: gm.graph.nodes[idx].tag = "mytag" This will result in all nodes with the same tag being extracted and placed in their own submodule. For placeholder, output and get_attr node, the tag is ignored. placeholder and output nodes are created when needed while get_attr nodes get copied to submodules where they are used. Given the following module def: class SimpleModule(torch.nn.Module): def __init__(self) -> None: super().__init__() self.linear1 = torch.nn.Linear(...) self.linear2 = torch.nn.Linear(...) self.linear3 = torch.nn.Linear(...) def forward(self, in1, in2): r1 = self.linear1(in1) r2 = self.linear2(in2) r3 = torch.cat([r1, r2]) return self.linear3(r3) Marking the node corresponding to in1 with the tag sc.REQUEST_ONLY.lower() results in the following split: ro: def forward(self, in1): self = self.root linear1 = self.linear1(in1) return linear1 main: def forward(self, in2, linear1): self = self.root linear2 = self.linear2(in2) cat_1 = torch.cat([linear1, linear2]) linear3 = self.linear3(cat_1) return linear3 main: def forward(self, in1, in2): self = self.root ro_0 = self.ro_0(in1) main_1 = self.main_1(in2, ro_0) return main_1 Returns: split_gm: torch fx graph after split orig_to_split_fqn_mapping: a map between the original fqn and the fqn after split for call_module and get_attr. xr@cSsg}t||j|S)zC Stores nodes in x to a list and returns the list. )rappend)rArr r r!flattens zsplit_by_tags..flattenNoutputzMultiple output nodes in graph! placeholder type_exprget_attrtagzNode does not have tag: csg|] }|jdvr|qS)>rIrF)op).0rA)node_to_componentr r! s  z!split_by_tags..css|]}|jVqdSN)r')rLcr r r! sz split_by_tags..r)defaultz Component z8 order must be >= max of its upstream components, order=z and max=cs|jdkr&|jvr!jj|j|jdj|<t|jj|_j|S|jdkr5|kr5|S|jvr[j |jj |j |jd}t|j|_j |d|<j j |S)NrIrGrF)rKr,r&rItargettypecopymetar*rBrFrr)index)rArFcompnode_remappingrM used_in_mainr r! remap_funcs       z!split_by_tags..remap_funczGraph had no output node!r )subgraph comp_name)argskwargscSsi|]}|j|jqSr )rr.)rLrYr r r! 4sz!split_by_tags..).rr3nodeArgumentr r4rlenrBr&nodesrK RuntimeErrorrFrrTrUrVrAssertionError format_noder_r`rJmaxr' node_copyrIr+tuplemap __getitem__rEr r.update call_moduler* enumerateProxyrr_codegenr"rrS)r.r<r=r>r?rDtag_to_componentall_componentsmain_gmain_remapping output_noderJrbupstream_componentsmxr\nrAorig_to_split_fqn_mappingoutscomp_orig_to_split_fqn_mapping main_nodeio main_root result_gmr rXr!rIsA                 "     rcsit|D]\}}|jD]}||<q qdtjjdttjjffdd dtjjdttjjffdd }dtjjdtdtffdd }dtjjd td tdttt tjjfffd d }t|D]\}}|j smqeg}t } |jD]}t |r|qu|||r| |qu|rY| d} | | vrq| | | vs| |krq| } t| dkrtdt } | D]} | }||kr| |qt| dkrtd| jdq| }|| ||\}}|rW|D]:}|j|||j |||<td| jd|jd|j r dndd|d||j rdndd| q|| }|D]-}t |sU|| vrU|vrU||krU|||sPtd|jd| |q)|sqedS)a Move non-tensor nodes on the boundary between subgraphs. For each subgraph: 1. Find nodes whose type is not tensor and any of its children is in another subgraph, put them in a queue for next step 2. Do a BFS on those nodes in the queue, and run a DFS for each node, let's say node X and it is in subgraph A: a. if it is in to_subgraph, return (continue DFS) b. if it is in from_subgraph, collect the nodes to nodes_to_move, and continue DFS c. otherwise, this means it cannot be moved d. also check if node X's parent should be put into the queue. (The queue may have duplicated nodes, just process the node once) Args: subgraphs: List of subgraphs containing nodes to be processed rbr@cfdd|jDS)z@Get children nodes that are in callable ops and in some subgraphc"g|] }|jtvr|vr|qSr rKr )rLusernode_to_subgraphr r!rNa zTmove_non_tensor_nodes_on_boundary..get_children_in_graph..)usersrbrr r!get_children_in_graph_ z@move_non_tensor_nodes_on_boundary..get_children_in_graphcr)z>Get parent nodes that are in callable ops and in some subgraphcrr r)rLargrr r!rNirzSmove_non_tensor_nodes_on_boundary..get_parents_in_graph..)all_input_nodesrrr r!get_parents_in_graphgrz?move_non_tensor_nodes_on_boundary..get_parents_in_graphcurrent_subgraph_idxcs |}tfdd|DS)z Check if the node has any children in a subgraph different from current_subgraph_idx. This is the requirement used in both step 1 and step d. c3s|] }|kVqdSrOr )rLchild)rrr r!rQws  z\move_non_tensor_nodes_on_boundary..has_children_in_other_subgraph..)any)rbrchildrenrr)rr!has_children_in_other_subgraphoszImove_non_tensor_nodes_on_boundary..has_children_in_other_subgraph from_subgraph to_subgraphcs:ttdfdd|fS)a Check if node and its dependencies can be moved from from_subgraph to to_subgraph. Returns (can_move, nodes_to_move) For node X, do a DFS on its descendants, for each node: - if it is in to_subgraph, return (continue DFS) - if it is in from_subgraph, collect the nodes to nodes_to_move, and continue DFS - otherwise, this means it cannot be moved Tcst|vrdS||vrdS|}|krdS|kr%|nddS|}|D]}r7|q/dS)NF)add) current_nodecurrent_subgraphrr)can_movedfsrrr nodes_to_movervisitedr r!rs$  zVmove_non_tensor_nodes_on_boundary..can_move_node_and_dependencies..dfs)set)rbrrr)rrrrrrr!can_move_node_and_dependencies{s  zImove_non_tensor_nodes_on_boundary..can_move_node_and_dependenciesrz:Only node that has children in other subgraph can be movedr zCannot move non-tensor node z: on boundary because it has children in multiple subgraphsz"In order move the non-tensor node z on boundary, moved node z from accgpu_z to zParent z) should have children in another subgraphN)rprerr3r:r8r6boolrkris_accr rBpoprrdrgprintrremove) subgraphsrr]rbrrr subgraph_idxqueue processedrrtarget_subgraph_candidatesrchild_subgraphtarget_subgraphrr node_to_moveparentsparentr rr!rDs  "" 4                 r)r@N)"rU dataclassesrrtypingrrtorch.fxrtorch.fx._compatibilityrtorch.fx.graphrtorch.fx.passes.utilsrr tools_commonr r r __all__rrrr3r;r8r7rrTrkr9rrr r r r!sH     " {