ёio.SSKJr SSKrSSKrSSKJrJrJr SSKr SSK r SSK J r SSK Jr SSKJr SS K Jr S S KJrJr S S KJr S S KJr S SKJr \(aSSKJr SSK Jr SSKJ r J!r! /r"\S"Sj5r#\S#Sj5r#Sr#S$Sjr$"SS\5r%"SS\5r&"SS\5r'"SS\5r("SS\5r)"S S!\5r*g)%) annotationsN) TYPE_CHECKINGLiteraloverload) convert_dtype)tensor) ParamAttr) functional)DropoutLinear) LayerList)Layer) LayerNorm)Sequence)Tensor) DTypeLike ParamAttrLikecgN param_attrns [/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/nn/layer/transformer.py_convert_param_attr_to_listr+scgrrrs rrr1src>[U[[45(a[U5U:Xd SUS35e/nUH~n[U[5(aAU(a'UR [ R"S55 MFUR S5 MYUR [ R"U55 M U$[U[5(aC/nU(a1[U5Vs/sHn[ R"S5PM nnU$S/U-nU$/n[ R"U5n[U5H[n[R"U5nUR(a URS-[U5-Ul UR U5 M] U$s snf)ag If `param_attr` is a list or tuple, convert every element in it to a ParamAttr instance. Otherwise, repeat `param_attr` `n` times to construct a list, and rename every one by appending a increasing index suffix to avoid having same names when `param_attr` contains a name. Parameters: param_attr (list|tuple|ParamAttr|bool|None): A list, tuple or something can be converted to a ParamAttr instance by `ParamAttr._to_attr`. n (int): The times to repeat to construct a list when `param_attr` is not a list or tuple. Returns: list: A list composed of each including cell's `param_attr`. zlength of param_attr should be z when it is a list/tupleNF_) isinstancelisttuplelenboolappendr _to_attrrangecopydeepcopynamestr)rr param_attrsattriattr_is rrr8sj *tUm,,:!# -aS0H I # D$%%&&y'9'9$'?@&&u-""9#5#5d#;<.  J % % =B1XFX9--d3XKF !'A+K  !!*-qA]]4(Fyy$kkC/#a&8   v &  Gs) FcUbeURU:waU[UR5nUS:XdSU;a[R"X5S- S-nU$[R"X5nU$)a Convert the attention mask to the target dtype we expect. Parameters: attn_mask (Tensor, optional): A tensor used in multi-head attention to prevents attention to some unwanted positions, usually the paddings or the subsequent positions. It is a tensor with shape broadcasted to `[batch_size, n_head, sequence_length, sequence_length]`. When the data type is bool, the unwanted positions have `False` values and the others have `True` values. When the data type is int, the unwanted positions have 0 values and the others have 1 values. When the data type is float, the unwanted positions have `-INF` values and the others have 0 values. It can be None when nothing wanted or needed to be prevented attention to. Default None. dtype (VarType): The target type of `attn_mask` we expect. Returns: Tensor: A Tensor with shape same as input `attn_mask`, with data type `dtype`. r'intg?geA)dtyperpaddlecast) attn_maskr5attn_mask_dtypes r_convert_attention_maskr:gsh(E!9' 8 f $(@Y6<CI  I5I rc^\rSrSr%Sr\R "SSS/5r\R "SSS/5rS\ S'S\ S 'S\ S 'S\ S 'S\ S 'S \ S'S\ S'S"S#U4Sjjjr \ S$S%Sjj5r \ S$S&Sjj5r S'Sjr S(Sjr \ S)S*Sjj5r\ S)S+Sjj5rS\4Sjr\ S,S-Sjj5r\ S,S.Sjj5r\ S,S/Sjj5r\ S,S0Sjj5r\ S,S1Sjj5r\ S,S2Sjj5rS3S jrS!rU=r$)4MultiHeadAttentiona Attention maps queries and a set of key-value pairs to outputs, and Multi-Head Attention performs multiple parallel attention to jointly attending to information from different representation subspaces. Please refer to `Attention Is All You Need `_ for more details. Parameters: embed_dim (int): The expected feature size in the input and output. num_heads (int): The number of heads in multi-head attention. dropout (float, optional): The dropout probability used on attention weights to drop some attention targets. 0 for no dropout. Default 0 kdim (int, optional): The feature size in key. If None, assumed equal to `embed_dim`. Default None. vdim (int, optional): The feature size in value. If None, assumed equal to `embed_dim`. Default None. need_weights (bool, optional): Indicate whether to return the attention weights. Default False. weight_attr(ParamAttr|None, optional): To specify the weight parameter property. Default: None, which means the default weight parameter property is used. See usage for details in :code:`ParamAttr` . bias_attr (ParamAttr|bool|None, optional): To specify the bias parameter property. Default: None, which means the default bias parameter property is used. If it is set to False, this layer will not have trainable bias parameter. See usage for details in :code:`ParamAttr` . Examples: .. code-block:: pycon >>> import paddle >>> # encoder input: [batch_size, sequence_length, d_model] >>> query = paddle.rand((2, 4, 128)) >>> # self attention mask: [batch_size, num_heads, query_len, query_len] >>> attn_mask = paddle.rand((2, 2, 4, 4)) >>> multi_head_attn = paddle.nn.MultiHeadAttention(128, 2) >>> output = multi_head_attn(query, None, None, attn_mask=attn_mask) >>> print(output.shape) paddle.Size([2, 4, 128]) Cachekv StaticCacher4 embed_dimkdimvdim num_headshead_dimfloatdropoutr' need_weightsNc >[T U]5 US:d SU35eUS:d SU35eXlUbUOUUlUbUOUUlX lX0lX`lX-UlURU-UR:XdS5e[XXxS9Ul [URXUS9Ul [URXUS9Ul [XXxS9Ul g)Nrz6Expected embed_dim to be greater than 0, but received z6Expected num_heads to be greater than 0, but received z(embed_dim must be divisible by num_heads bias_attr)super__init__rBrCrDrErHrIrFrq_projk_projv_projout_proj) selfrBrErHrCrDrI weight_attrrL __class__s rrNMultiHeadAttention.__init__s 1} DYK P }1} DYK P }# ,D)  ,D) " (!. }}y(DNN: 6 : +   IIy   IIy   +  rcgrrrSquerykeyvaluecaches r _prepare_qkvMultiHeadAttention._prepare_qkvs),rcgrrrXs rr]r^s>Arc&URU5n[R"USSURUR/S9n[R "U/SQS9n[ X@R5(aURURpvOURX#5upg[ X@R5(aS[R"URU/SS9n[R"URU/SS9nURXg5nUcXVU4$XVXt4$)a Prepares linear projected queries, keys and values for usage of subsequent multiple parallel attention. If `cache` is not None, using cached results to reduce redundant calculations. Parameters: query (Tensor): The queries for multi-head attention. It is a tensor with shape `[batch_size, query_length, embed_dim]`. The data type should be float32 or float64. key (Tensor): The keys for multi-head attention. It is a tensor with shape `[batch_size, key_length, kdim]`. The data type should be float32 or float64. If None, use `query` as `key`. value (Tensor): The values for multi-head attention. It is a tensor with shape `[batch_size, value_length, vdim]`. The data type should be float32 or float64. If None, use `query` as `value`. cache (MultiHeadAttention.Cache|MultiHeadAttention.StaticCache|None, optional): It is a namedtuple with `k` and `v` as fields, and stores tensors shaped `[batch_size, num_heads, length, embed_dim]` which are results of linear projection, reshape and transpose calculations in MultiHeadAttention. If is an instance of `Cache`, `k` and `v` fields reserve intermediate results of previous positions, which mostly used for decoder self attention. If it is an instance of `StaticCache`, `key` and `value` args would be ignored, `k` and `v` fields would be used as calculated results on `key` and `value`, which mostly used for decoder-encoder cross attention. It is only used for inference and should be None for training. Default None. Returns: tuple: A tuple including linear projected keys and values. These two \ tensors have shapes `[batch_size, n_head, sequence_length, d_key]` \ and `[batch_size, n_head, sequence_length, d_value]` separately, \ and their data types are same as inputs. rxshaperr r rrbpermr )axis) rOr reshaperErF transposer#rAr?r@ compute_kvr>concat)rSrYrZr[r\qr?r@s rr]r^sJ KK  NNQq!T^^T]]&K L   q| 4 e-- . .77EGGq??3.DA eZZ ( ( uwwl3A uwwl3AJJq$E!May?a/??rc\URU5nURU5n[R"USSURUR /S9n[R "U/SQS9n[R"USSURUR /S9n[R "U/SQS9nX44$)a Applies linear projection on input keys and values, then splits heads (reshape and transpose) to get keys and values from different representation subspaces. The results are used as key-values pairs for subsequent multiple parallel attention. It is part of calculations in multi-head attention, and is provided as a method to pre-compute and prefetch these results, thus we can use them to construct cache for inference. Parameters: key (Tensor): The keys for multi-head attention. It is a tensor with shape `[batch_size, sequence_length, kdim]`. The data type should be float32 or float64. value (Tensor): The values for multi-head attention. It is a tensor with shape `[batch_size, sequence_length, vdim]`. The data type should be float32 or float64. Returns: Tuple. A tuple including transformed keys and values. Their shapes both are `[batch_size, num_heads, sequence_length, embed_dim // num_heads]`, and their data types are same as inputs. rrardre)rPrQr rhrErFri)rSrZr[r?r@s rrjMultiHeadAttention.compute_kv1s0 KK  KK  NNQq!T^^T]]&K L   q| 4 NNQq!T^^T]]&K L   q| 4t rcgrrrSrZr[types r gen_cacheMultiHeadAttention.gen_cacheQsrcgrrrps rrrrsVs rcU[R:Xa$URX5upEURXE5$UcSURSUR/n[ R "U5SR5US'[ R"USUR5n[ R"USUR5nURXE5$URX5$)a Generates cache for `forward` usage in inference according to arguments. The generated cache is an instance of `MultiHeadAttention.Cache` or an instance of `MultiHeadAttention.StaticCache`. `Cache` or `StaticCache` is namedtuple with `k` and `v` as fields, and it stores tensors shaped `[batch_size, num_heads, length, embed_dim]` which are results of linear projection, reshape and transpose calculations in MultiHeadAttention. If the generated cache is an instance of `Cache`, `k` and `v` fields reserve intermediate result tensors of previous positions, and the tensors are incremental among decoding steps, which mostly are used for decoder decoder self attention. If the generated cache is an instance of `StaticCache`, `k` and `v` fields would be used as calculated result tensors on keys an values in `forward`, and the tensors keep unchanged among decoding steps, which are mostly used for decoder-encoder cross attention. The cache is generated as follows: 1. If `type` is `StaticCache`, apply `compute_kv(key, value)` and use the results to create an instance of `StaticCache`. 2. If `type` is `Cache` and `value` is None, generate empty tensors shaped `[batch_size, num_heads, 0, embed_dim // num_heads]` and use the results to create an instance of `Cache`, where `batch_size` is from the first dimension of `key`. 3. If `type` is `Cache` and `value` is not None, use `key`, `value` to create an instance of `Cache`. Parameters: key (Tensor): The keys for multi-head attention. It is a tensor with shape `[batch_size, key_length, kdim]`. The data type should be float32 or float64. If `value` is None, it is only for batch size and data type reference. value (Tensor, optional): The values for multi-head attention. It is a tensor with shape `[batch_size, value_length, vdim]`. The data type should be float32 or float64. If None, `key` is only for batch size reference. Default None. type (type): It should be `MultiHeadAttention.StaticCache` or `MultiHeadAttention.Cache` to indicate the cache type to generate. Returns: namedtuple: an instance of `Cache` or `StaticCache` accordingly. r) r<rArjrErFr6rcitemfullr5r>)rSrZr[rqr?r@ fill_shapes rrrrs^sb %11 1??3.DA##A) ) ]dnna?J"LL-a0557JqM J3995A J3995A::a# #::c) )rcgrrrSrYrZr[r8r\s rforwardMultiHeadAttention.forwardrcgrrr{s rr|r}s!$rcgrrr{s rr|r}s #rcgrrr{s rr|r}s&)rcgrrr{s rr|r}s(+rcgrrr{s rr|r}s.1rc0UcUOUnUcUOUnUcURXX55upgnOURXX55upgp[R"X`RS--USS9n Ub[ XIR 5nX-n [ R"U 5n UR(a+[ R"U URURSS9n [R"X5n [R"U /SQS9n [R"U SSU RS U RS -/S 9n URU 5n U /n UR(aU R!U 5 UbU R!U5 [#U 5S :XaU $[%U 5$) a Applies multi-head attention to map queries and a set of key-value pairs to outputs. Parameters: query (Tensor): The queries for multi-head attention. It is a tensor with shape `[batch_size, query_length, embed_dim]`. The data type should be float32 or float64. key (Tensor|None, optional): The keys for multi-head attention. It is a tensor with shape `[batch_size, key_length, kdim]`. The data type should be float32 or float64. If None, use `query` as `key`. Default None. value (Tensor|None, optional): The values for multi-head attention. It is a tensor with shape `[batch_size, value_length, vdim]`. The data type should be float32 or float64. If None, use `query` as `value`. Default None. attn_mask (Tensor|None, optional): A tensor used in multi-head attention to prevents attention to some unwanted positions, usually the paddings or the subsequent positions. It is a tensor with shape broadcasted to `[batch_size, n_head, sequence_length, sequence_length]`. When the data type is bool, the unwanted positions have `False` values and the others have `True` values. When the data type is int, the unwanted positions have 0 values and the others have 1 values. When the data type is float, the unwanted positions have `-INF` values and the others have 0 values. It can be None when nothing wanted or needed to be prevented attention to. Default None. cache (MultiHeadAttention.Cache|MultiHeadAttention.StaticCache|None, optional): It is a namedtuple with `k` and `v` as fields, and stores tensors shaped `[batch_size, num_heads, length, embed_dim]` which are results of linear projection, reshape and transpose calculations in MultiHeadAttention. If it is an instance of `Cache`, `k` and `v` fields reserve intermediate results of previous positions, which mostly used for decoder self attention. If it is an instance of `StaticCache`, `key` and `value` args would be ignored, `k` and `v` fields would be used as calculated results on `key` and `value`, which mostly used for decoder-encoder cross attention. It is only used for inference and should be None for training. Default None. Returns: Tensor|tuple. It is a tensor that has the same shape and data type as `query`, representing attention output. Or a tuple if `need_weights` is True or `cache` is not None. If `need_weights` is True, except for attention output, the tuple also includes the attention weights tensor shaped `[batch_size, num_heads, query_length, key_length]`. If `cache` is not None, the tuple then includes the new cache having the same type as `cache`, and if it is `StaticCache`, it is same as the input `cache`, if it is `Cache`, the new cache reserves tensors concatenating raw tensors with intermediate results of current query. gT)rby transpose_yupscale_in_train)trainingmoderd)rfrr rrar )r]r6matmulrFr:r5FsoftmaxrHrr rirhrcrRrIr(r&r%) rSrYrZr[r8r\rlr?r@productweightsoutoutss rr|r}skh{eE =''EAGA!!..u5HNA!--==$&'1$   / ==II)G))G$ <<ii ' GmmG's6nns1a1 ! 1L*MNmmC u    KK   KK $i1ns5%+5r) rHrBrFrPrCrIrErRrOrQrD)gNNFNN)rBr4rEr4rHrGrC int | NonerDrrIr'rTParamAttrLike | NonerLrreturnNone.) rYrrZrr[rr\rrztuple[Tensor, Tensor, Tensor]) rYrrZrr[rr\zCache | StaticCacherz2tuple[Tensor, Tensor, Tensor, Cache | StaticCache]r)rZrr[rrtuple[Tensor, Tensor]..)rZrr[ Tensor | Nonerqz type[Cache]rr>)rZrr[rrqztype[StaticCache]rrA)....) rYrrZrr[rr8rr\rrr) rYrrZrr[rr8rr\rrr) rYrrZrr[rr8rr\r>rztuple[Tensor, Cache]) rYrrZrr[rr8rr\rArztuple[Tensor, StaticCache]) rYrrZrr[rr8rr\r>rztuple[Tensor, Tensor, Cache]) rYrrZrr[rr8rr\rArz"tuple[Tensor, Tensor, StaticCache])NNNN)__name__ __module__ __qualname____firstlineno____doc__ collections namedtupler>rA__annotations__rNrr]rjrrr|__static_attributes__ __classcell__rUs@rr<r<s2)V  " "7S#J 7E((c CKN I INM N ",0*.+ + +  +  +  + + *+ (+  + + Z  ,,, ,  , ' ,, &) AAA A # A < AA5@n@KN"/=H  #"%     $(e<*|!"       !" $$$ $  $  $ $$!" ### #  #  # ##!" ))) )  )  ) $))!" +++ +  +  + &++!" 111 1  1  1 ,11[6[6rr<c^\rSrSr%SrS\S'S\S'S SU4Sjjjr\SSSjj5r\SSS jj5rSS jrSS jr S r U=r $)TransformerEncoderLayeri6a TransformerEncoderLayer is composed of two sub-layers which are self (multi-head) attention and feedforward network. Before and after each sub-layer, pre-process and post-process would be applied on the input and output accordingly. If `normalize_before` is True, pre-process is layer normalization and post-process includes dropout, residual connection. Otherwise, no pre-process and post-process includes dropout, residual connection, layer normalization. Parameters: d_model (int): The expected feature size in the input and output. nhead (int): The number of heads in multi-head attention(MHA). dim_feedforward (int): The hidden layer size in the feedforward network(FFN). dropout (float, optional): The dropout probability used in pre-process and post-process of MHA and FFN sub-layer. Default 0.1 activation (str, optional): The activation function in the feedforward network. Default relu. attn_dropout (float, optional): The dropout probability used in MHA to drop some attention target. If None, use the value of `dropout`. Default None act_dropout (float, optional): The dropout probability used after FFN activation. If None, use the value of `dropout`. Default None normalize_before (bool, optional): Indicate whether to put layer normalization into preprocessing of MHA and FFN sub-layers. If True, pre-process is layer normalization and post-process includes dropout, residual connection. Otherwise, no pre-process and post-process includes dropout, residual connection, layer normalization. Default False weight_attr(ParamAttr|list|tuple, optional): To specify the weight parameter property. If it is a list/tuple, `weight_attr[0]` would be used as `weight_attr` for MHA, and `weight_attr[1]` would be used as `weight_attr` for linear in FFN. Otherwise, MHA and FFN both use it as `weight_attr` to create parameters. Default: None, which means the default weight parameter property is used. See usage for details in :code:`ParamAttr` . bias_attr (ParamAttr|list|tuple|bool, optional): To specify the bias parameter property. If it is a list/tuple, `bias_attr[0]` would be used as `bias_attr` for MHA, and `bias_attr[1]` would be used as `bias_attr` for linear in FFN. Otherwise, MHA and FFN both use it as `bias_attr` to create parameters. The `False` value means the corresponding layer would not have trainable bias parameter. See usage for details in :code:`ParamAttr` . Default: None, which means the default bias parameter property is used. layer_norm_eps (float, optional): the eps value in layer normalization components. Default=1e-5. Examples: .. code-block:: pycon >>> import paddle >>> from paddle.nn import TransformerEncoderLayer >>> # encoder input: [batch_size, src_len, d_model] >>> enc_input = paddle.rand((2, 4, 128)) >>> # self attention mask: [batch_size, n_head, src_len, src_len] >>> attn_mask = paddle.rand((2, 2, 4, 4)) >>> encoder_layer = TransformerEncoderLayer(128, 2, 512) >>> enc_output = encoder_layer(enc_input, attn_mask) >>> print(enc_output.shape) paddle.Size([2, 4, 128]) r activationr'normalize_beforec >[5UlURRS5 URRSS5 [TU]5 US:d SU35eUS:d SU35eUS:d SU35eUcUOUnUcUOUnXl[ U S5n [ U S5n [UUUU SU SS9Ul[XU S U S S 9Ul [US S 9Ul [X1U S U S S 9Ul [X5Ul[X5Ul[US S 9Ul[US S 9Ul['[(U5Ulg) NrSrUr4Expected d_model to be greater than 0, but received 2Expected nhead to be greater than 0, but received +   $Q m   l1oA  {1CD  l1oA  w7 w7 .@A .@A !!Z0rcgrrrSsrcsrc_maskr\s rr|TransformerEncoderLayer.forward rcgrrrs rr|rs 36rc t[X!R5nUnUR(aURU5nUcUR XX5nOUR XXU5upX@R U5-nUR(dURU5nUnUR(aUR U5nURURURURU5555nX@RU5-nUR(dUR U5nUcU$UW4$)a Applies a Transformer encoder layer on the input. Parameters: src (Tensor): The input of Transformer encoder layer. It is a tensor with shape `[batch_size, sequence_length, d_model]`. The data type should be float32 or float64. src_mask (Tensor|None, optional): A tensor used in multi-head attention to prevents attention to some unwanted positions, usually the paddings or the subsequent positions. It is a tensor with shape broadcasted to `[batch_size, n_head, sequence_length, sequence_length]`. When the data type is bool, the unwanted positions have `False` values and the others have `True` values. When the data type is int, the unwanted positions have 0 values and the others have 1 values. When the data type is float, the unwanted positions have `-INF` values and the others have 0 values. It can be None when nothing wanted or needed to be prevented attention to. Default None. cache (MultiHeadAttention.Cache, optional): It is an instance of `MultiHeadAttention.Cache`. See `TransformerEncoderLayer.gen_cache` for more details. It is only used for inference and should be None for training. Default None. Returns: Tensor|tuple: It is a tensor that has the same shape and data type \ as `enc_input`, representing the output of Transformer encoder \ layer. Or a tuple if `cache` is not None, except for encoder \ layer output, the tuple includes the new cache which is same \ as input `cache` argument but `incremental_cache` has an \ incremental length. See `MultiHeadAttention.gen_cache` and \ `MultiHeadAttention.forward` for more details. ) r:r5rrrrrrrHrrr)rSrrr\residualincremental_caches rr|rs@+8YY?  **S/C =..39C%)^^#& "Cs++$$**S/C  **S/Cll4<< S8I(JKLs++$$**S/CmsA#/@)AArc`URRXRRS9nU$)ab Generates cache for `forward` usage. The generated cache is an instance of `MultiHeadAttention.Cache`. Parameters: src (Tensor): The input of Transformer encoder. It is a tensor with shape `[batch_size, source_length, d_model]`. The data type should be float32 or float64. Returns: incremental_cache: It is an instance of `MultiHeadAttention.Cache` \ produced by `self_attn.gen_cache`, it reserves two tensors shaped `[batch_size, nhead, 0, d_model // nhead]`. See \ `MultiHeadAttention.gen_cache` and `MultiHeadAttention.forward` \ for more details. rq)rrrr>)rSrrs rrr!TransformerEncoderLayer.gen_caches3"!NN44 nn**5 ! r) rrrHrrrrrrrr皙?reluNNFNNgh㈵>rr4rr4rr4rHrGrr.r float | Nonerrrr'rT.ParamAttrLike | Sequence[ParamAttrLike] | NonerLrrrGrrrrrrrr\rrr)rrrrr\MultiHeadAttention.Cacherz'tuple[Tensor, MultiHeadAttention.Cache]NN)rrrr rrrrrrrNrr|rrrrrs@rrr6sI9v %)$(!&FJDH $818181 81  81  81#81"8181D81B8181 8181t#&      #&*- 6 6 6( 6 1 668Bt!!rrc^\rSrSr%SrS\S'S\S'S SU4Sjjjr\SSSjj5r\SSS jj5rSS jrSS jr S r U=r $)TransformerEncoderia TransformerEncoder is a stack of N encoder layers. Parameters: encoder_layer (Layer): an instance of the `TransformerEncoderLayer`. It would be used as the first layer, and the other layers would be created according to the configurations of it. num_layers (int): The number of encoder layers to be stacked. norm (LayerNorm|None, optional): the layer normalization component. If provided, apply layer normalization on the output of last encoder layer. Examples: .. code-block:: pycon >>> import paddle >>> from paddle.nn import ( ... TransformerEncoderLayer, ... TransformerEncoder, ... ) >>> # encoder input: [batch_size, src_len, d_model] >>> enc_input = paddle.rand((2, 4, 128)) >>> # self attention mask: [batch_size, n_head, src_len, src_len] >>> attn_mask = paddle.rand((2, 2, 4, 4)) >>> encoder_layer = TransformerEncoderLayer(128, 2, 512) >>> encoder = TransformerEncoder(encoder_layer, 2) >>> enc_output = encoder(enc_input, attn_mask) >>> print(enc_output.shape) paddle.Size([2, 4, 128]) r4 num_layersLayerNorm | Nonenormc >[TU]5 [[U5Vs/sH&nUS:XaUO[ U5"S0UR D6PM( sn5UlX lX0lgs snfNrr rMrNrr*rqrlayersrr)rS encoder_layerrrr1rUs rrNTransformerEncoder.__init__4x z*   +AAv"m,E}/D/DEF+     %  -A(cgrrrs rr|TransformerEncoder.forwardHrrcgrrrs rr|rPs 9