U Jc5 @sddlZddlmZmZmZmZmZddlZddlm Z ddl m Z ddgZ e ddGd ddZ e ddd e ejjeejjjgefeeeefeed d dZdS)N)AnyCallableDictListOptional) compatibility) GraphModule Partition split_moduleT)Zis_backward_compatiblec@s(eZdZedddZedddZdS)r namecCsN||_d||_g|_i|_i|_i|_i|_tjj |_ i|_ i|_ dS)NZsubmod_) r submod_name node_namesinputsoutputspartitions_dependent_onpartition_dependentstorchfxgraphGraph environmenttargets)selfr r@/tmp/pip-unpacked-wheel-gikjz4vx/torch/fx/passes/split_module.py__init__ s zPartition.__init__)returnc Cs4d|jd|jd|jd|jd|jd|j S)Nzname: z , nodes: z , inputs: z , outputs: z, partitions depenent on: z, parition dependents: )r rrrrr)rrrr__repr__s2zPartition.__repr__N)__name__ __module__ __qualname__strrrrrrrr s F)mroot_msplit_callback qualname_mapkeep_original_orderc shiitjjjttjjjdfdd |jjD]j<jdkrNq4jdkrxtjj j dfddq4t |} |d krt ||<jj|_tjj j fd dtjj jfd dq4t}g}D] \}tjs ||q g}|r|} || | jD],} | j| | jsT|| qTq2t|tkrtd |D]F}|jD]0} j| } | j| _| j| <qq|jjD]2td rjjtjj j fdd} tjj jfdd}jdkr^j }n|j !d}|}|D].}t||stdj dt"||}qrd#|}|j$|<|d k rڈj%d|}j ||<t&| t'st(t&|t)st(jj*j|| |d}j|_|j<qitjj+}i}|jjD]܉jdkrtj dkrpj dnt,j-j.}|jj j/|dj<jj_nzjdkrF|0j j<jj_|}j !dD].}t||stdj dt"||}q||j <qF|s.|n|}|D]}|t'fddj1D}t|dkrr|dn|}j2|tjj34j$j|j%<|5j%t'fddjD}tj1dkrtjj67|}t8j1D]\}}||j|<qn|tj1d<q6|jjD]6jdkr |2tjj j dfddq tjj34||S)a Creates subgraphs out of main graph Args: m (GraphModule): Graph module to split root_m (torch.nn.Module): root nn module. Not currently used. Included because the root nn module is usually transformed via torch.fx._symbolic_trace.symbolic_trace (see example below) split_callback (Callable[[torch.fx.node.Node], int]): Callable function that maps a given Node instance to a numeric partition identifier. split_module will use this function as the policy for which operations appear in which partitions in the output Module. qualname_map: Optional[Dict[str, str]]: optional output parameter that returns a mapping from new target names in the module after split to old target names in the original module. keep_original_order: Optional[bool]: keep the original order of the GraphModule or use the Topological order of the new constructed GraphModule Returns: GraphModule: the module after split. Example: This is a sample setup: import torch from torch.fx.symbolic_trace import symbolic_trace from torch.fx.graph_module import GraphModule from torch.fx.node import Node from torch.fx.passes.split_module import split_module class MyModule(torch.nn.Module): def __init__(self): super().__init__() self.param = torch.nn.Parameter(torch.rand(3, 4)) self.linear = torch.nn.Linear(4, 5) def forward(self, x, y): z = self.linear(x + self.param).clamp(min=0.0, max=1.0) w = self.linear(y).clamp(min=0.0, max=1.0) return z + w # symbolically trace model my_module = MyModule() my_module_traced = symbolic_trace(my_module) # random mod partitioning partition_counter = 0 NPARTITIONS = 3 def mod_partition(node: Node): global partition_counter partition = partition_counter % NPARTITIONS partition_counter = (partition_counter + 1) % NPARTITIONS return partition # split module in module with submodules module_with_submodules = split_module( my_module_traced, my_module, mod_partition ) Output looks like this. Original graph is broken into partitions > print(module_with_submodules) GraphModule( (submod_0): GraphModule( (linear): Linear(in_features=4, out_features=5, bias=True) ) (submod_1): GraphModule( (linear): Linear(in_features=4, out_features=5, bias=True) ) (submod_2): GraphModule() ) def forward(self, x, y): param = self.param submod_0 = self.submod_0(x, param, y); x = param = y = None getitem = submod_0[0] getitem_1 = submod_0[1]; submod_0 = None submod_1 = self.submod_1(getitem, getitem_1); getitem = getitem_1 = None getitem_2 = submod_1[0] getitem_3 = submod_1[1]; submod_1 = None submod_2 = self.submod_2(getitem_2, getitem_3); getitem_2 = getitem_3 = None return submod_2 Output of split module is the same as output of input traced module. This is an example within a test setting: > orig_out = my_module_traced(x, y) > submodules_out = module_with_submodules(x, y) > self.assertEqual(orig_out, submodules_out) True )def_nodeuse_nodecst|dd}t|dd}||kr|dk rR|}|j|j|dk rR|j||dk r|}|j|j|dk r|j|dS)N _fx_partition)getattrr setdefaultr rrr)r(r)Zdef_partition_nameZuse_partition_nameZ def_partitionZ use_partition) partitionsrrrecord_cross_partition_uses   z0split_module..record_cross_partition_use) placeholderget_attroutputrcs |dSNrn)r.rrzsplit_module..Ncs |Sr2rr(noder.rrr5r6cs |Sr2rr7r8rrr5r6z cycle exists between partitions!r*cs|Sr2rr3rrrr5r6cs|Sr2rr3r:rrr5r6) call_moduler0.zOperator target z not found!_)optargetargskwargsr/)Z type_expr default_valuer0z Node target c3s|]}j|VqdSr2r:.0r ) orig_nodes partitionrr %szsplit_module..c3s|]}|VqdSr2rrC base_mod_envrrrG3scs |jSr2r r3rIrrr5@r6)9rrr9NoderrZnodesr r>Zmap_argr@r"getr rappendr*rAlistkeysitemslenrpopr RuntimeErrorrr/metacopyrhasattrr?splitr+joinrr isinstancetupleAssertionErrordictZ create_noderinspect Signatureemptytyper0rr1Z graph_modulerr;proxyZProxy enumerate)r#r$r%r&r'Zpartition_nameZoriginal_partition_orderZroot_partitionsZsorted_partitionsZroot_partitionZ dependentinputr/Z gathered_argsZgathered_kwargsr?Z target_atomsZ target_attrZatomqualnameZnew_nodeZbase_mod_graphZbase_mod_attrsrBZattr_valZconstruct_order_partitionsZ output_valsZ output_valZoutput_val_proxyiZ output_namer)rJrr9rErFr-r.rr %sf                                       )NF)r]typingrrrrrrZtorch.fx._compatibilityrZtorch.fx.graph_moduler__all__r nnModulerr9rKintr"boolr rrrrs"