U ʹj< @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[/var/www/html/bwave/python/venv/lib/python3.8/site-packages/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 dependent on: z, partition dependents: )r rrrrr)rrrr__repr__s2zPartition.__repr__N)__name__ __module__ __qualname__strrrrrrrr s F)mroot_msplit_callback qualname_mapkeep_original_orderc! stjjjtttjjjftttjjjfdfdd }iitjjjttjjjdfdd j j D]j <j dkrqnj dkrtjj jd  fd d qnt|}|d krt||<jj |_tjj j fd d tjj j fdd qnt}g}D] \}tjsF||qFg} |r|} | | | jD],} | j| | js|| qqlt| tkrtd| D]P}|jD]:} j j| | jd} | j !| _ | j"| <qqވj j D]6t#dr8jj"tjj jfdd }tjj jfdd }j dkrj$}n|j$%d}}|D].}t#||st&dj$dt'||}qd(|}|j)|<|d k rj*d|}j$||<t+|t,s.t-t+|t.s>t-j j/j |||jd}j !|_ |j"<q8iitjj 0i}|sj j D]||\}qnj j D]j <q|s| n|}t1}|D]P}|t,fddj2D}t|}|dkr0j 3|d n|dkrFj 3||rfddjD}|D].|krvqd||\}|4qdtjjj)j |j*<5j*t,fddjD}tj2}|dkrtjj67|}t8j2D]\}} ||j| <qn|dkr|tj2d <qj j D]6j dkr@3tjj jd fd d q@tjj|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 )node base_mod_envbase_mod_attrscs|jdkrXt|jdkr"|jdntjj}j|j|j|d||j <|j ||j _ nt|jdkr̈ |j||j <|j ||j _ }|j dD]*}t||std|jdt||}q|||j<||fS)N placeholderr) type_expr default_valueget_attr.z Node target not found!)oplenargsinspect Signatureemptyr+targettyper metacopyr.splithasattrAttributeErrorgetattr)r(r)r*r-Zattr_valatom)base_mod_graphr#rrconstruct_graphs&      z%split_module..construct_graph)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)r>r setdefaultr rrr)rBrCZdef_partition_nameZuse_partition_nameZ def_partitionZ use_partition) partitionsrrrecord_cross_partition_uses   z0split_module..record_cross_partition_use)r+r.outputrcs |dSNrn)rGrrzsplit_module..Ncs |SrIrrBr(rGrrrLrMcs |SrIrrNrOrrrLrMz cycle exists between partitions!)r,rDcs|SrIrrJrrrrLrMcs|SrIrrJrPrrrLrM) call_moduler.r/zOperator target r0_)r1r7r3kwargsr,c3s|]}j|VqdSrIrP.0r ) orig_nodes partitionrr @szsplit_module..csg|] }|qSrr)rUkey) org_mod_envrr Msz split_module..c3s|]}|VqdSrIrrTr)rrrX`scs |jSrIr rJr]rrrLorM)9rrr(Noderr"Z graph_modulerrrZnodesr r1Zmap_argr3getr rappendrDrSlistkeysitemsr2rpopr RuntimeErrorrr+r8r9r:rr<r7r;r=r>joinrr isinstancetupleAssertionErrordictZ create_nodersetrrHaddrQproxyZProxy enumerate)!r#r$r%r&r'rAZpartition_nameZoriginal_partition_orderZroot_partitionsZsorted_partitionsZroot_partitionZ dependentinputr+Z gathered_argsZgathered_kwargsr7Z target_atomsZ target_attrr?qualnamenew_noder*Zconstruct_order_partitionsZalready_constructed_attr_nodesZ output_valsZnum_output_valsZorg_mod_attr_nodesZ output_valZ num_outputsZoutput_val_proxyiZ output_namer) r)r@rr#r(r[rVrWrFrGrr %s,h                                          )NF)r4typingrrrrrrZtorch.fx._compatibilityrZtorch.fx.graph_moduler__all__r nnModulerr(r^intr"boolr rrrrs"