a d~6 @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 re/var/www/html/stable-diffusion-webui/venv/lib/python3.9/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__s zPartition.__repr__N)__name__ __module__ __qualname__strrrrrrrr s F)mroot_msplit_callback qualname_mapkeep_original_orderc sviitjjjttjjjdfdd |jjD]j<jdvrNq4jdkrxtjj j dfddq4t |} |d urt ||<jj|_tjj j fd dtjj jfd dq4t}g}D] \}tjs ||q g}|r|} || | jD],} | j| | jsT|| qTq2t|tkrtd |D]P}|jD]:} jj| | jd } | j| _| j| <qq|jjD]6t drjjtjj j fdd} tjj jfdd}jdvrhj!}n|j!"d}|}|D].}t ||stdj!dt#||}q|d$|}|j%|<|d urj&d|}j!||<t'| t(sJt'|t)sJjj*j|| |jd}j|_|j<qitjj+}i}|jjD]܉jdkrtj dkr~j dnt,j-j.}|jj!j|dj<jj_nzjdkrT|/j!j<jj_|}j!"dD].}t ||stdj!dt#||}q||j!<qT|s<|n|}|D]}|t(fddj0D}t|dkr|dn|}j1|tjj23j%j|j&<|4j&t(fddjD}tj0dkrtjj56|}t7j0D]\}}||j|<qn|tj0d<qD|jjD]6jdkr.|1tjj j dfddq.tjj23||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|durR|}|j|j|durR|j||dur|}|j|j|dur|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!) type_exprr*cs|Sr2rr3rrrr5r6cs|Sr2rr3r;rrr5r6) call_moduler0.zOperator target z not found!_)optargetargskwargsr:r/)r: default_valuer0z Node target c3s|]}j|VqdSr2r;.0r ) orig_nodes partitionrr ,szsplit_module..c3s|]}|VqdSr2rrD base_mod_envrrrH:r6cs |jSr2r r3rJrrr5Gr6)8rrr9Noderrnodesr r?Zmap_argrAr"getr rappendr*rBlistkeysitemslenrpopr RuntimeErrorrr/typemetacopyrhasattrr@splitr+joinrr isinstancetupledictZ create_noderinspect Signatureemptyr0rr1Z 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_attrZatomqualnamenew_nodeZbase_mod_graphZbase_mod_attrsrCZattr_valZconstruct_order_partitionsZ output_valsZ output_valZoutput_val_proxyiZ output_namer)rKrr9rFrGr-r.rr %sf                                 )NF)r_typingrrrrrrZtorch.fx._compatibilityrZtorch.fx.graph_moduler__all__r nnModulerr9rLintr"boolr rrrrs"