sgeoddlmZmZddlmZddlmZmZmZm Z m Z ddl Z ddl m Z ddlmZmZmZmZmZmZddlmZgdZGdd eZGd d eZGd d eZGddeZGddeZGddeZy))ABCabstractmethod)partial)AnyDictOptionalTupleUnionN) DeviceMeshdistribute_moduledistribute_tensorDTensor ReplicateShard) Placement) ParallelStyleRowwiseParallelSequenceParallelColwiseParallelPrepareModuleInputPrepareModuleOutputcVeZdZdZedej dedej fdZy)rz The parallel style contract defines how the module or submodule should be parallelized. It only defines the ``apply`` method for ``parallelize_module`` to use, this allows maximum flexibility for different kind of style implementations. module device_meshreturncyNselfrrs Z/var/www/html/venv/lib/python3.12/site-packages/torch/distributed/tensor/parallel/style.py_applyzParallelStyle._apply&s N) __name__ __module__ __qualname____doc__rnnModuler r"rr#r!rrs8 RYY Z BII  r#rceZdZdZdddddeedeedeffdZed Z d Z d Z ed Z d e jdede jfdZxZS)ra6 Partition a compatible nn.Module in a column-wise fashion. Currently supports nn.Linear and nn.Embedding. Users can compose it together with RowwiseParallel to achieve the sharding of more complicated modules. (i.e. MLP, Attention) Keyword Args: input_layouts (Placement, optional): The DTensor layout of input tensor for the nn.Module, this is used to annotate the input tensor to become a DTensor. If not specified, we assume the input tensor to be replicated. output_layouts (Placement, optional): The DTensor layout of the output for the nn.Module, this is used to ensure the output of the nn.Module with the user desired layout. If not specified, the output tensor is sharded on the last dimension. use_local_output (bool, optional): Whether to use local :class:`torch.Tensor` instead of :class:`DTensor` for the module output, default: True. Returns: A :class:`ParallelStyle` object that represents Colwise sharding of the nn.Module. Example:: >>> # xdoctest: +SKIP(failing) >>> from torch.distributed.tensor.parallel import parallelize_module, ColwiseParallel >>> from torch.distributed.device_mesh import init_device_mesh >>> ... >>> m = Model(...) # m is a nn.Module that contains a "w1" nn.Linear submodule >>> tp_mesh = init_device_mesh("cuda", (8,)) >>> >>> # By default, the input of the "w1" Linear will be converted to Replicated DTensor >>> # and the output of "w1" will return :class:`torch.Tensor` that shards on the last dim. >>> >>> sharded_mod = parallelize_module(m, tp_mesh, {"w1": ColwiseParallel()}) >>> ... .. note:: By default ``ColwiseParallel`` output is sharded on the last dimension if the ``output_layouts`` not specified, if there're operators that require specific tensor shape (i.e. before the paired ``RowwiseParallel``), keep in mind that if the output is sharded the operator might need to be adjusted to the sharded size. NT input_layoutsoutput_layoutsuse_local_outputr,r-r.ct||xs tf|_|xs t df|_tf|_||_yN)super__init__rr,rr-desired_input_layoutsr.r r,r-r. __class__s r!r3zColwiseParallel.__init__PsL +:y{<-:r<'0k^" 0r#c|d}t|tstj|||d}||k7r|j|d}|SNrF run_checkT placementsasync_op isinstancer from_local redistributer,r4modinputsr input_tensors r!_prepare_input_fnz!ColwiseParallel._prepare_input_fn`s]ay ,0"--k=EL 1 1'44045Lr#c |jD]A\}}tjt||t dg}|j ||CyNrnamed_parametersr( Parameterr rregister_parameterr namerrparam dist_params r!_partition_linear_fnz$ColwiseParallel._partition_linear_fntsO"224 8KD%&7{USTXJ&WXJ  % %dJ 7 8r#c |jD]A\}}tjt||t dg}|j ||Cy)NrIrMs r!_partition_embedding_fnz'ColwiseParallel._partition_embedding_fn|M!224 8KD%&7{USTXJ&WXJ  % %dJ 7 8r#cn|j|k7r|j|d}|r|jS|SNTr;r<rAto_localr-r.rCoutputsrs r!_prepare_output_fnz"ColwiseParallel._prepare_output_fns=    /**nt*TG%5w!B7Br#rrrc vt|tjr |j}n2t|tjr |j }n t dt|||t|j|j|jt|j|j|jS)NzBColwiseParallel currently only support nn.Linear and nn.Embedding!)r?r(LinearrQ EmbeddingrTNotImplementedErrorr rrFr,r4r\r-r.r rr partition_fns r!r"zColwiseParallel._applys fbii (44L  -77L%T !    &&(:(:DS>S   r#r$r%r&r'rrboolr3 staticmethodrFrQrTr\r(r)r r" __classcell__r6s@r!rr+s"N.2.2!% 1 *1!+ 1  1 &88 CC RYY Z BII r#rceZdZdZdddddeedeedeffdZed Z d Z d Z ed Z d e jdede jfdZxZS)ra Partition a compatible nn.Module in a row-wise fashion. Currently supports nn.Linear and nn.Embedding. Users can compose it with ColwiseParallel to achieve the sharding of more complicated modules. (i.e. MLP, Attention) Keyword Args: input_layouts (Placement, optional): The DTensor layout of input tensor for the nn.Module, this is used to annotate the input tensor to become a DTensor. If not specified, we assume the input tensor to be sharded on the last dimension. output_layouts (Placement, optional): The DTensor layout of the output for the nn.Module, this is used to ensure the output of the nn.Module with the user desired layout. If not specified, the output tensor is replicated. use_local_output (bool, optional): Whether to use local :class:`torch.Tensor` instead of :class:`DTensor` for the module output, default: True. Returns: A :class:`ParallelStyle` object that represents Rowwise sharding of the nn.Module. Example:: >>> # xdoctest: +SKIP(failing) >>> from torch.distributed.tensor.parallel import parallelize_module, RowwiseParallel >>> from torch.distributed.device_mesh import init_device_mesh >>> ... >>> m = Model(...) # m is a nn.Module that contains a "w2" nn.Linear submodule >>> tp_mesh = init_device_mesh("cuda", (8,)) >>> >>> # By default, the input of the "w2" Linear will be converted to DTensor that shards on the last dim >>> # and the output of "w2" will return a replicated :class:`torch.Tensor`. >>> >>> sharded_mod = parallelize_module(m, tp_mesh, {"w2": RowwiseParallel()}), >>> ... NTr+r,r-r.ct||xs tdf|_|xs t f|_||_yr0)r2r3rr,rr-r.r5s r!r3zRowwiseParallel.__init__s> +8uRy:-<> 0r#c|d}t|tstj|||d}||k7r|j|d}|Sr8r>rBs r!rFz!RowwiseParallel._prepare_input_fns]ay ,0"--k=EL 1 1'44045Lr#c .|jdtjt|j|t dgt |ddD|jdtjt|j|tgyy)NweightrSbias) rLr(rKr rlrgetattrrmr)r rNrrs r!rQz$RowwiseParallel._partition_linear_fns| !!  LL*6==+azR S  664 ( 4  % % %fkk; N  5r#c |jD]A\}}tjt||t dg}|j ||CyrHrIrMs r!rTz'RowwiseParallel._partition_embedding_fnrUr#cn|j|k7r|j|d}|r|jS|SrWrXrZs r!r\z"RowwiseParallel._prepare_output_fns=    /**nt*TG%5w!B7Br#rrrc t|tjr|j}t df|_nBt|tj r|j}tf|_n tdt|||t|j|j|j t|j|j|j S)Nr1zBRowwiseParallel currently only support nn.Linear and nn.Embedding!)r?r(r^rQrr4r_rTrr`r rrFr,r\r-r.ras r!r"zRowwiseParallel._applys fbii (44LAFr D &  -77L*3+D &%T !    &&(:(:DS>S   r#rcrgs@r!rrsF.2.2!% 1 * 1!+ 1  1  "8 CC RYY Z BII r#rceZdZdZddddedeffdZded ejd e fd Z e d Z e d Zd ejd e dejfdZxZS)raa SequenceParallel replicates a compatible ``nn.Module`` parameters and runs the sharded computation with input sharded on the sequence dimension. This currently supports ``nn.LayerNorm``, ``nn.Dropout``, and the `RMSNorm python implementation `__ This style implements the operation that is described in the paper `Reducing Activation Recomputation in Large Transformer Models `__ If the input passed in to this ``nn.Module`` is a :class:`torch.Tensor`, it assumes that the input is already sharded on the sequence dimension and converts the input to a :class:`DTensor` sharded on the sequence dimension. If the input passed in to this ``nn.Module`` is already a :class:`DTensor` but is not sharded on the sequence dimension, it would redistribute the input to be sharded on the sequence dimension. The output of the ``nn.Module`` will be sharded on the sequence dimension. Keyword Args: sequence_dim (int, optional): The sequence dimension of the input tensor for the ``nn.Module``, this is used to annotate the input tensor to become a DTensor that is sharded on the sequence dimension, default: 1. use_local_output (bool, optional): Whether to use local :class:`torch.Tensor` instead of :class:`DTensor` for the module output, default: False. Returns: A :class:`ParallelStyle` object that represents Sequence Parallel of the ``nn.Module``. Example:: >>> # xdoctest: +SKIP(failing) >>> from torch.distributed.tensor.parallel import parallelize_module, SequenceParallel >>> from torch.distributed.device_mesh import init_device_mesh >>> ... >>> m = Model(...) # m is a nn.Module that contains a "norm" nn.LayerNorm submodule >>> tp_mesh = init_device_mesh("cuda", (8,)) >>> >>> # By default, the input of the "norm" will be converted to DTensor that shards on the sequence dim >>> # and the output of "norm" will return a sharded on sequence dimension :class:`DTensor`. >>> >>> sharded_mod = parallelize_module(m, tp_mesh, {"norm": SequenceParallel()}), >>> ... .. note:: SequenceParallel style assumes ones initialization if there are weights in the nn.Module (i.e. ``nn.LayerNorm`` or ``RMSNorm``, and they by default have ones initialization). If you have custom inits for the weights on those modules, you need to broadcast the weights before/after parallelizing to ensure that they are replicated. rSF) sequence_dimr.rsr.cRt|t|f|_||_yr)r2r3rsequence_shardingr.)r rsr.r6s r!r3zSequenceParallel.__init__Gs& "' "5!7 0r#rNrrc |jD]V\}}tjjt j ||t gd}|j||Xy)NFr9)rJtorchr(rKrr@rrL)r rNrrp_namerOreplicated_params r!_replicate_module_fnz%SequenceParallel._replicate_module_fnLse$446 @MFE %xx11""5+ }PUV    % %f.> ?  @r#c|d}t|tr$|j|k7r|j|d}|St|tj rtj |||dStd|d|)NrTr;Fr9zexpecting input of z* to be a torch.Tensor or DTensor, but got )r?rr<rArwTensorr@ ValueError)rurCrDrrEs r!rFz"SequenceParallel._prepare_input_fnWsay lG ,&&*;;+8804 9     ell 3%%k+< %cU*TUaTbc r#c*|r|jS|Sr)rY)r.rCr[rs r!r\z#SequenceParallel._prepare_output_fnks%5w!B7Br#rc t|||jt|j|jt|j |j Sr)r rzrrFrur\r.rs r!r"zSequenceParallel._applyosJ    % % D**D,B,B C D++T-B-B C   r#)r$r%r&r'intrdr3strr(r)r rzrerFr\r"rfrgs@r!rrs*X/0%1141 @ @!# @9C @&CC RYY Z BII r#rc eZdZdZdddddddeeeeeefdeeeeeefdeee efdeee efd e f d Z d e d e d eedeefdZdZdZdej$de dej$fdZy)raW Configure the nn.Module's inputs to convert the input tensors of the nn.Module to DTensors at runtime according to ``input_layouts``, and perform layout redistribution according to the ``desired_input_layouts``. Keyword Args: input_layouts (Union[Placement, Tuple[Optional[Placement]]]): The DTensor layouts of input tensors for the nn.Module, this is used to convert the input tensors to DTensors. If some inputs are not torch.Tensor or no need to convert to DTensors, ``None`` need to be specified as a placeholder. default: None. desired_input_layouts (Union[Placement, Tuple[Optional[Placement]]]): The desired DTensor layout of input tensors for the nn.Module, this is used to ensure the inputs of the nn.Module have the desired DTensor layouts. This argument needs to have the same length with ``input_layouts``. default: None. input_kwarg_layouts (Dict[str, Placement]): The DTensor layouts of input kwargs for the nn.Module, this is used to convert the input kwarg tensors to DTensors. default: None desired_input_kwarg_layouts: (Dict[str, Placement]): The desired DTensor layout of input kwargs for the nn.Module, this is used to ensure the inputs of the nn.Module have the desired DTensor layouts. default: None. use_local_output (bool, optional): Whether to use local :class:`torch.Tensor` instead of :class:`DTensor` for the module inputs, default: False. Returns: A :class:`ParallelStyle` object that prepares the sharding layouts of the nn.Module's inputs. Example:: >>> # xdoctest: +SKIP(failing) >>> from torch.distributed.tensor.parallel import parallelize_module, PrepareModuleInput >>> from torch.distributed.device_mesh import init_device_mesh >>> ... >>> block = TransformerBlock(...) # block is a nn.Module that contains an "attn" Attention submodule >>> tp_mesh = init_device_mesh("cuda", (8,)) >>> >>> # According to the style specified below, the first input of attn will be annotated to Sharded DTensor >>> # and then redistributed to Replicated DTensor. >>> parallelize_module( >>> block, # this can be a submodule or module >>> tp_mesh, >>> parallelize_plan={ >>> "attn": PrepareModuleInput( >>> input_layouts=(Shard(0), None, None, ...), >>> desired_input_layouts=(Replicate(), None, None, ...) >>> ), >>> } >>> ) NF)r,r4input_kwarg_layoutsdesired_input_kwarg_layoutsr.r,r4rrr.ct|tr|fn||_t|tr|fn||_||_|jE|jJdt |jt |jk(sJd|du|_|xsi|_|xsi|_|j r3t |jt |jk(sJdyy)N)desired module inputs should not be None!z@input_layouts and desired_input_layouts should have same length!zLinput_kwarg_layouts and desired_input_kwarg_layouts should have same length!) r?rr,r4r.len with_kwargsrr)r r,r4rrr.s r!r3zPrepareModuleInput.__init__s!+=) D] -  /;# $& " !1    )**6 ;: ;6t))*c**/ RQ R/d:#6#<" +F+L"(   t//0C005 ^] ^ r#inputmesh input_layoutdesired_layoutc|t|tr|}n;t|tjsJdtj|||fd}|||k7r|j |f}|j r|jS|S|S)Nz%expecting input to be a torch.Tensor!Fr9r<)r?rrwr|r@rAr.rY)r rrrrdt_inps r!_prepare_input_argz%PrepareModuleInput._prepare_input_args  #%)!5<<;:;!++4,E)ln.L,,8I,J(,(=(=6??$ I6 ILr#c v|j|Sg}t|ts|f}t|t|jk7r t d|j Jdt ||j|j D])\}}}|j|j||||+t|S)Nz8module inputs and input_layouts should have same length!r) r,r?tuplerr}r4zipappendr)r rDrprepared_inputsinprrs r!rFz$PrepareModuleInput._prepare_input_fns    %M&%(YF v;#d001 1WX X  & & 2 7 6 7 214 D&&(B(B2   -C~  " "''[,W   _%%r#c|j||}i}|jD]T}||}|jj|}|jj|} |j |||| ||<V||fSr)rFkeysrgetrr) r rD kwarg_inputsrprepared_arg_inputsprepared_kwarg_inputs kwarg_key kwarg_valrdesired_input_layouts r!_prepare_input_kwarg_fnz*PrepareModuleInput._prepare_input_kwarg_fns"44V[I "%**, I$Y/I3377 BL#'#C#C#G#G #R /3/F/F; 6J0 !) ,  $%:;;r#rrrc~jr|jfdd|S|jfd|S)Nc*j||Sr)r)_rDkwargsrr s r!z+PrepareModuleInput._apply.. s$*F*FFK+r#T)rc(j|Sr)rF)rrDrr s r!rz+PrepareModuleInput._apply..st?U?UV\^i?jr#)rregister_forward_pre_hookrs` `r!r"zPrepareModuleInput._applysF     , ,! -    , ,-j k r#)r$r%r&r'rr rr rrrdr3rr rrFrr(r)r"rr#r!rrys +`QU >BFJ!&!^ ix 7J1K&K LM!^ ( )U8I#677 8 !^&d3 >&:;!^&.d3 >.B%C!^!^Fy)  !+ 6&( < RYY Z BII r#rceZdZdZdddeeeefdeeeefdefdZdZ d e jd e d e jfd Z y )ra Configure the nn.Module's outputs to convert the output tensors of the nn.Module to DTensors at runtime according to ``output_layouts``, and perform layout redistribution according to the ``desired_output_layouts``. Keyword Args: output_layouts (Union[Placement, Tuple[Placement]]): The DTensor layouts of output tensors for the nn.Module, this is used to convert the output tensors to DTensors if they are :class:`torch.Tensor`. If some outputs are not torch.Tensor or no need to convert to DTensors, ``None`` need to be specified as a placeholder. desired_output_layouts (Union[Placement, Tuple[Placement]]): The desired DTensor layouts of output tensors for the nn.Module, this is used to ensure the outputs of the nn.Module have the desired DTensor layouts. use_local_output (bool, optional): Whether to use local :class:`torch.Tensor` instead of :class:`DTensor` for the module outputs, default: True. Returns: A ParallelStyle object that prepares the sharding layouts of the nn.Module's outputs. Example:: >>> # xdoctest: +SKIP(failing) >>> from torch.distributed.tensor.parallel import parallelize_module, PrepareModuleOutput >>> from torch.distributed.device_mesh import init_device_mesh >>> ... >>> block = TransformerBlock(...) # block is a nn.Module that contains an "attn" Attention submodule >>> tp_mesh = init_device_mesh("cuda", (8,)) >>> >>> # According to the style specified below, the output of the TransformerBlock will be converted to Replicated DTensor >>> # and then redistributed to Sharded DTensor. >>> parallelize_module( >>> block, # this can be a submodule or module >>> tp_mesh, >>> parallelize_plan = PrepareModuleOutput( >>> output_layouts=Replicate(), >>> desired_output_layouts=Shard(0) >>> ) >>> ) T)r.r-desired_output_layoutsr.ct|tr|fn||_t|tr|fn||_||_t |jt |jk(sJdy)NzBoutput_layouts and desired_output_layouts should have same length!)r?rr-rr.r)r r-rr.s r!r3zPrepareModuleOutput.__init__:s.)4  0)<$ %' # !14&&'3  ' ',   P O P r#c g}t|ts|f}t|t|jk7r t dt ||j|j D]\}}}|st|tr|}ntj|||fd}||k7r|j|f}|j|jr|jn|||j|t|dk(r|dSt|S)Nz:module outputs and output_layouts should have same length!Fr9rrSr) r?rrr-r}rrrr@rArr.rY)r r[rprepared_outputsout out_layoutdesired_out_layoutdt_outs r!_prepare_out_fnz#PrepareModuleOutput._prepare_out_fnPs '5)jG w<3t223 3L 47 T(($*E*E4  - /C/%c7+!F$//[:-5F!33#00=O)>FOO%F!'',' -(  A %#A& &)* *r#rrrc4|jfd|S)Nc(j|Sr)r)rrDr[rr s r!rz,PrepareModuleOutput._apply..rs@T@TU\^i@jr#)register_forward_hookrs` `r!r"zPrepareModuleOutput._applyqs$$%jk r#N)r$r%r&r'r rr rdr3rr(r)r r"rr#r!rrsz#T"& Piy)99:P!&iy1A&A B P  P,+BRYYZBIIr#r)abcrr functoolsrtypingrrrr r rwtorch.nnr(torch.distributed.tensorr r r rrr(torch.distributed.tensor.placement_typesr__all__rrrrrrrr#r!rs$44 ?   C  s ms lv mv r\ }\ ~XXv_-_r#