@jpddlZddlmZmZmZmZddlZddlmZmZddl m Z dgZ d%de d e d ed ed ejjf d Z d&de de de de deeee ee fde d ed ed ejjfdZded efdZGddejZGddejZGddejZGddejZGd d!ejZGd"d#ejZGd$dejZdS)'N)ListOptionalTupleUnion)nnTensor) functional Tacotron2Tlinearin_dimout_dimbias w_init_gainreturnctj|||}tjj|jtjj||S)aLinear layer with xavier uniform initialization. Args: in_dim (int): Size of each input sample. out_dim (int): Size of each output sample. bias (bool, optional): If set to ``False``, the layer will not learn an additive bias. (Default: ``True``) w_init_gain (str, optional): Parameter passed to ``torch.nn.init.calculate_gain`` for setting the gain parameter of ``xavier_uniform_``. (Default: ``linear``) Returns: (torch.nn.Linear): The corresponding linear layer. rgain)torchrLinearinitxavier_uniform_weightcalculate_gain)r r rrr s LC:\Projects\Historical\venv\Lib\site-packages\torchaudio/models/tacotron2.py_get_linear_layerr)sTX__VW4_ 8 8F HM!!&-ehm6R6RS^6_6_!``` M in_channels out_channels kernel_sizestridepaddingdilationc P|0|dzdkrtdt||dz zdz }tj|||||||}tjj|jtjj||S)al1D convolution with xavier uniform initialization. Args: in_channels (int): Number of channels in the input image. out_channels (int): Number of channels produced by the convolution. kernel_size (int, optional): Number of channels in the input image. (Default: ``1``) stride (int, optional): Number of channels in the input image. (Default: ``1``) padding (str, int or tuple, optional): Padding added to both sides of the input. (Default: dilation * (kernel_size - 1) / 2) dilation (int, optional): Number of channels in the input image. (Default: ``1``) w_init_gain (str, optional): Parameter passed to ``torch.nn.init.calculate_gain`` for setting the gain parameter of ``xavier_uniform_``. (Default: ``linear``) Returns: (torch.nn.Conv1d): The corresponding Conv1D layer. Nrzkernel_size must be odd)r!r"r#r$rr) ValueErrorintrrConv1drrrr) rr r!r"r#r$rrconv1ds r_get_conv1d_layerr+;s4 ?a  677 7h+/2Q677 X__ F HM!!&-ehm6R6RS^6_6_!``` Mrlengthsctj|}tjd||j|j}||dk}tj|d}|S)alReturns a binary mask based on ``lengths``. The ``i``-th row and ``j``-th column of the mask is ``1`` if ``j`` is smaller than ``i``-th element of ``lengths. Args: lengths (Tensor): The length of each element in the batch, with shape (n_batch, ). Returns: mask (Tensor): The binary mask, with shape (n_batch, max of ``lengths``). r)devicedtyper) rmaxitemaranger.r/ unsqueezebytele)r,max_lenidsmasks r_get_mask_from_lengthsr9isui  %%''G ,q''. N N NC '##A&& & , , . .D 8D!  D Krc@eZdZdZdededeffd ZdedefdZxZS) _LocationLayeraLocation layer used in the Attention model. Args: attention_n_filter (int): Number of filters for attention model. attention_kernel_size (int): Kernel size for attention model. attention_hidden_dim (int): Dimension of attention hidden representation. attention_n_filterattention_kernel_sizeattention_hidden_dimc tt|dz dz }td|||ddd|_t ||dd|_dS)Nrr&F)r!r#rr"r$tanhrr)super__init__r(r+ location_convrlocation_dense)selfr<r=r>r# __class__s rrCz_LocationLayer.__init__s ,q0A566. -   0  45f   rattention_weights_catrc||}|dd}||}|S)aLocation layer used in the Attention model. Args: attention_weights_cat (Tensor): Cumulative and previous attention weights with shape (n_batch, 2, max of ``text_lengths``). Returns: processed_attention (Tensor): Cumulative and previous attention weights with shape (n_batch, ``attention_hidden_dim``). rr&)rD transposerE)rFrHprocessed_attentions rforwardz_LocationLayer.forwardsJ#001FGG1;;AqAA"112EFF""r __name__ __module__ __qualname____doc__r(rCrrL __classcell__rGs@rr;r;zs   # "       *#V#########rr;ceZdZdZdedededededdf fd Zd ed ed edefd Zdeded ed ededeeeff dZ xZ S) _AttentionaLocally sensitive attention model. Args: attention_rnn_dim (int): Number of hidden units for RNN. encoder_embedding_dim (int): Number of embedding dimensions in the Encoder. attention_hidden_dim (int): Dimension of attention hidden representation. attention_location_n_filter (int): Number of filters for Attention model. attention_location_kernel_size (int): Kernel size for Attention model. attention_rnn_dimencoder_embedding_dimr>attention_location_n_filterattention_location_kernel_sizerNc,tt||dd|_t||dd|_t|dd|_t ||||_td |_ dS)NFr@rArrinf) rBrCr query_layer memory_layervr;location_layerfloatscore_mask_value)rFrVrWr>rXrYrGs rrCz_Attention.__init__s ,->@T[`ntuuu- !#7eQW   ##7GGG, ' *    "'u rqueryprocessed_memoryrHc||d}||}|t j||z|z}|d}|S)a=Get the alignment vector. Args: query (Tensor): Decoder output with shape (n_batch, n_mels * n_frames_per_step). processed_memory (Tensor): Processed Encoder outputs with shape (n_batch, max of ``text_lengths``, attention_hidden_dim). attention_weights_cat (Tensor): Cumulative and previous attention weights with shape (n_batch, 2, max of ``text_lengths``). Returns: alignment (Tensor): attention weights, it is a tensor with shape (batch, max of ``text_lengths``). rr&)r\r3r_r^rr@squeeze)rFrbrcrHprocessed_queryprocessed_attention_weightsenergies alignments r_get_alignment_energiesz"_Attention._get_alignment_energiessx**5??1+=+=>>&*&9&9:O&P&P#66%*_7R%RUe%effgg$$Q'' rattention_hidden_statememoryr8c||||}|||j}tj|d}t j|d|}|d}||fS)aPass the input through the Attention model. Args: attention_hidden_state (Tensor): Attention rnn last output with shape (n_batch, ``attention_rnn_dim``). memory (Tensor): Encoder outputs with shape (n_batch, max of ``text_lengths``, ``encoder_embedding_dim``). processed_memory (Tensor): Processed Encoder outputs with shape (n_batch, max of ``text_lengths``, ``attention_hidden_dim``). attention_weights_cat (Tensor): Previous and cumulative attention weights with shape (n_batch, current_num_frames * 2, max of ``text_lengths``). mask (Tensor): Binary mask for padded data with shape (n_batch, current_num_frames). Returns: attention_context (Tensor): Context vector with shape (n_batch, ``encoder_embedding_dim``). attention_weights (Tensor): Attention weights with shape (n_batch, max of ``text_lengths``). rdim) rj masked_fillraFsoftmaxrbmmr3re) rFrkrlrcrHr8riattention_weightsattention_contexts rrLz_Attention.forwards.001GIY[pqq ))$0EFF IiQ777!I&7&A&A!&D&DfMM-55a88 "333r) rNrOrPrQr(rCrrjrrLrRrSs@rrUrUs .. #." . &) . ), . ......*Vvflqw*4 &44! 4 & 4  4 vv~ 44444444rrUcLeZdZdZdedeeddffd ZdedefdZxZ S) _PrenetzPrenet Module. It is consists of ``len(output_size)`` linear layers. Args: in_dim (int): The size of each input sample. output_sizes (list): The output dimension of each linear layers. r out_sizesrNct|g|ddz}tjdt ||D|_dS)Nc8g|]\}}t||dS)Fr)r).0in_sizeout_sizes r z$_Prenet.__init__..s- r r rBU7H wu = = = r r rr)rBrCr ModuleListziplayers)rFr rxin_sizesrGs rrCz_Prenet.__init__ sb 8in,m r rY\]egpYqYq r r r   rxc~|jD]4}tjtj||dd}5|S)zPass the input through Prenet. Args: x (Tensor): The input sequence to Prenet with shape (n_batch, in_dim). Return: x (Tensor): Tensor with shape (n_batch, sizes[-1]) ?T)ptraining)rrqdropoutrelu)rFrr s rrLz_Prenet.forwardsFk C CF !&++sTBBBAAr) rNrOrPrQr(rrCrrLrRrSs@rrwrws s tCy T        F        rrwcDeZdZdZdedededeffd Zdedefd ZxZS) _PostnetaPostnet Module. Args: n_mels (int): Number of mel bins. postnet_embedding_dim (int): Postnet embedding dimension. postnet_kernel_size (int): Postnet kernel size. postnet_n_convolution (int): Number of postnet convolutions. n_melspostnet_embedding_dimpostnet_kernel_sizepostnet_n_convolutioncttj|_t |D]}|dkr|n|}||dz kr|n|}||dz krdnd}||dz kr|n|} |jtjt|||dt|dz dz d|tj | t|j|_ dS)Nrrr r@r&r!r"r#r$r) rBrCrr convolutionsrangeappend Sequentialr+r( BatchNorm1dlenn_convs) rFrrrrirr init_gain num_featuresrGs rrCz_Postnet.__init__*s0 MOO,--  A$%FF&&0EK%&+@1+D%E%E66K`L$%*?!*C$D$D&I%&+@1+D%E%E66K`L   $ $ %#$$7 #%81%<$A B B!"$-N<00      4,-- rrrct|jD]p\}}||jdz kr8tjt j||d|j}Ktj||d|j}q|S)aPass the input through Postnet. Args: x (Tensor): The input sequence with shape (n_batch, ``n_mels``, max of ``mel_specgram_lengths``). Return: x (Tensor): Tensor with shape (n_batch, ``n_mels``, max of ``mel_specgram_lengths``). rr)r) enumeraterrrqrrr@r)rFrrconvs rrLz_Postnet.forwardJs!!233 D DGAt4>> encoder = _Encoder(3, 512, 5) >>> input = torch.rand(10, 20, 30) >>> output = encoder(input) # shape: (10, 30, 512) rWencoder_n_convolutionencoder_kernel_sizerNc ttj|_t |D]j}tjt|||dt|dz dz ddtj |}|j |ktj |t|dz ddd|_ |j dS)Nrr&rrT) batch_first bidirectional)rBrCrrrrrr+r(rrLSTMlstmflatten_parameters)rFrWrr_ conv_layerrGs rrCz_Encoder.__init__ks  MOO,-- 1 1A!)) 3!4q!8A =>> &455  J   $ $Z 0 0 0 0G ! %) * *       $$&&&&&rr input_lengthsc|jD]8}tjtj||d|j}9|dd}|}tjj ||d}| |\}}tjj |d\}}|S)a_Pass the input through the Encoder. Args: x (Tensor): The input sequences with shape (n_batch, encoder_embedding_dim, n_seq). input_lengths (Tensor): The length of each input sequence with shape (n_batch, ). Return: x (Tensor): A tensor with shape (n_batch, n_seq, encoder_embedding_dim). rrr&T)r) rrqrrrrJcpurutilsrnnpack_padded_sequencerpad_packed_sequence)rFrrroutputsrs rrLz_Encoder.forwards% ? ?D !&a//3 >>AA KK1  %))++ HL - -aD - Q QYYq\\ X\55g45PP rrMrSs@rrr]s  '"' #'! '  ''''''B6rrc!eZdZdZdededededededed ed ed ed ed edededdffd ZdedefdZ dede eeeeeeeeffdZ dedefdZ dededede eeeffdZ dedededed ed!ed"ed#eded$ed%ede eeeeeeeeef fd&Zded'ed(ede eeeffd)Zdedefd*Zejjded(ede eeeeffd+ZxZS),_Decodera,Decoder with Attention model. Args: n_mels (int): number of mel bins n_frames_per_step (int): number of frames processed per step, only 1 is supported encoder_embedding_dim (int): the number of embedding dimensions in the encoder. decoder_rnn_dim (int): number of units in decoder LSTM decoder_max_step (int): maximum number of output mel spectrograms decoder_dropout (float): dropout probability for decoder LSTM decoder_early_stopping (bool): stop decoding when all samples are finished attention_rnn_dim (int): number of units in attention LSTM attention_hidden_dim (int): dimension of attention hidden representation attention_location_n_filter (int): number of filters for attention model attention_location_kernel_size (int): kernel size for attention model attention_dropout (float): dropout probability for attention LSTM prenet_dim (int): number of ReLU units in prenet layers gate_threshold (float): probability threshold for stop token rn_frames_per_steprWdecoder_rnn_dimdecoder_max_stepdecoder_dropoutdecoder_early_stoppingrVr>rXrYattention_dropout prenet_dimgate_thresholdrNc(t||_||_||_||_||_| |_||_||_ | |_ ||_ ||_ t||z| | g|_tj| |z||_t%||| | | |_tj||z|d|_t+||z||z|_t+||zddd|_dS)NTrsigmoidrA)rBrCrrrWrVrrrrrrrrwprenetrLSTMCell attention_rnnrUattention_layer decoder_rnnrlinear_projection gate_layer)rFrrrWrrrrrVr>rXrYrrrrGs rrCz_Decoder.__init__s2$  !2%:"!2.$ 0,!2.&<#f'88:z:RSS [6K)KM^__)  ! ' *   ;'8;P'PRacghh!2?EZ3Z\bev\v!w!w+ 3 3QTy   rrlc|d}|j}|j}tj||j|jz||}|S)amGets all zeros frames to use as the first decoder input. Args: memory (Tensor): Encoder outputs with shape (n_batch, max of ``text_lengths``, ``encoder_embedding_dim``). Returns: decoder_input (Tensor): all zeros frames with shape (n_batch, max of ``text_lengths``, ``n_mels * n_frames_per_step``). rr/r.sizer/r.rzerosrrrFrln_batchr/r. decoder_inputs r_get_initial_framez_Decoder._get_initial_frameK++a..  GT[4;Q-QY^gmnnn rc<|d}|d}|j}|j}tj||j||}tj||j||}tj||j||}tj||j||} tj||||} tj||||} tj||j||} |j |} |||| | | | | fS)aInitializes attention rnn states, decoder rnn states, attention weights, attention cumulative weights, attention context, stores memory and stores processed memory. Args: memory (Tensor): Encoder outputs with shape (n_batch, max of ``text_lengths``, ``encoder_embedding_dim``). Returns: attention_hidden (Tensor): Hidden state of the attention LSTM with shape (n_batch, ``attention_rnn_dim``). attention_cell (Tensor): Hidden state of the attention LSTM with shape (n_batch, ``attention_rnn_dim``). decoder_hidden (Tensor): Hidden state of the decoder LSTM with shape (n_batch, ``decoder_rnn_dim``). decoder_cell (Tensor): Hidden state of the decoder LSTM with shape (n_batch, ``decoder_rnn_dim``). attention_weights (Tensor): Attention weights with shape (n_batch, max of ``text_lengths``). attention_weights_cum (Tensor): Cumulated attention weights with shape (n_batch, max of ``text_lengths``). attention_context (Tensor): Context vector with shape (n_batch, ``encoder_embedding_dim``). processed_memory (Tensor): Processed encoder outputs with shape (n_batch, max of ``text_lengths``, ``attention_hidden_dim``). rrr) rr/r.rrrVrrWrr])rFrlrmax_timer/r.attention_hiddenattention_celldecoder_hidden decoder_cellrtattention_weights_cumrurcs r_initialize_decoder_statesz#_Decoder._initialize_decoder_statess-*++a..;;q>>  ;w0Fe\bcccWd.DEZ`aaaWd.B%X^___{7D,@V\]]] !KvVVV % GXUSY Z Z Z!K1KSXaghhh/<>@@ #--a33>>@@ #A&DK8(|(%0 #--a33 \:55rrrrrrrtrrurcr8c tj||fd} || ||f\}}tj||j|j}tj|d|dfd} ||| | | | \}}||z }tj||fd}| |||f\}}tj||j |j}tj||fd}| |}| |}|||||||||f S)a& Decoder step using stored states, attention and memory Args: decoder_input (Tensor): Output of the Prenet with shape (n_batch, ``prenet_dim``). attention_hidden (Tensor): Hidden state of the attention LSTM with shape (n_batch, ``attention_rnn_dim``). attention_cell (Tensor): Hidden state of the attention LSTM with shape (n_batch, ``attention_rnn_dim``). decoder_hidden (Tensor): Hidden state of the decoder LSTM with shape (n_batch, ``decoder_rnn_dim``). decoder_cell (Tensor): Hidden state of the decoder LSTM with shape (n_batch, ``decoder_rnn_dim``). attention_weights (Tensor): Attention weights with shape (n_batch, max of ``text_lengths``). attention_weights_cum (Tensor): Cumulated attention weights with shape (n_batch, max of ``text_lengths``). attention_context (Tensor): Context vector with shape (n_batch, ``encoder_embedding_dim``). memory (Tensor): Encoder output with shape (n_batch, max of ``text_lengths``, ``encoder_embedding_dim``). processed_memory (Tensor): Processed Encoder outputs with shape (n_batch, max of ``text_lengths``, ``attention_hidden_dim``). mask (Tensor): Binary mask for padded data with shape (n_batch, current_num_frames). Returns: decoder_output: Predicted mel spectrogram for the current frame with shape (n_batch, ``n_mels``). gate_prediction (Tensor): Prediction of the stop token with shape (n_batch, ``1``). attention_hidden (Tensor): Hidden state of the attention LSTM with shape (n_batch, ``attention_rnn_dim``). attention_cell (Tensor): Hidden state of the attention LSTM with shape (n_batch, ``attention_rnn_dim``). decoder_hidden (Tensor): Hidden state of the decoder LSTM with shape (n_batch, ``decoder_rnn_dim``). decoder_cell (Tensor): Hidden state of the decoder LSTM with shape (n_batch, ``decoder_rnn_dim``). attention_weights (Tensor): Attention weights with shape (n_batch, max of ``text_lengths``). attention_weights_cum (Tensor): Cumulated attention weights with shape (n_batch, max of ``text_lengths``). attention_context (Tensor): Context vector with shape (n_batch, ``encoder_embedding_dim``). rzrrn) rcatrrqrrrr3rrrrr)rFrrrrrrtrrurlrcr8 cell_inputrH decoder_hidden_attention_contextdecoder_outputgate_predictions rdecodez_Decoder.decodecsRY /@A2FF +/+=+=jK[]kJl+m+m(.9%5t7Mt}]] % +<+F+Fq+I+IK`KjKjklKmKm*ntu v v v/3/C/C f&68Mt0 0 ,, !22 #35F"GLL '+'7'7 XdGe'f'f$ >43GWW+09nFW5X^_+`+`+`(//0PQQ//*JKK        !   rmel_specgram_truthmemory_lengthsc x||d}||}tj||fd}||}t |}||\}}} } } } } }ggg}}}t|| ddz kr|t|}| |||| | | | | ||| \ }}}}} } } } } || dgz }|| dgz }|| gz }t|| ddz k| tj |tj |tj |\}}}|||fS)aDecoder forward pass for training. Args: memory (Tensor): Encoder outputs with shape (n_batch, max of ``text_lengths``, ``encoder_embedding_dim``). mel_specgram_truth (Tensor): Decoder ground-truth mel-specs for teacher forcing with shape (n_batch, ``n_mels``, max of ``mel_specgram_lengths``). memory_lengths (Tensor): Encoder output lengths for attention masking (the same as ``text_lengths``) with shape (n_batch, ). Returns: mel_specgram (Tensor): Predicted mel spectrogram with shape (n_batch, ``n_mels``, max of ``mel_specgram_lengths``). gate_outputs (Tensor): Predicted stop token for each timestep with shape (n_batch, max of ``mel_specgram_lengths``). alignments (Tensor): Sequence of attention weights from the decoder with shape (n_batch, max of ``mel_specgram_lengths``, max of ``text_lengths``). rrnr)rr3rrrrr9rrrrrerstack)rFrlrrrrr8rrrrrtrrurc mel_outputsrr mel_output gate_outputrs rrLz_Decoder.forwards,//77AA!DD 334FGGM>#BJJJ^44%n55  + +F 3 3      !  13B:\ +!4!4Q!7!7!!;;;*3{+;+;`_. See Also: * :class:`torchaudio.pipelines.Tacotron2TTSBundle`: TTS pipeline with pretrained model. Args: mask_padding (bool, optional): Use mask padding (Default: ``False``). n_mels (int, optional): Number of mel bins (Default: ``80``). n_symbol (int, optional): Number of symbols for the input text (Default: ``148``). n_frames_per_step (int, optional): Number of frames processed per step, only 1 is supported (Default: ``1``). symbol_embedding_dim (int, optional): Input embedding dimension (Default: ``512``). encoder_n_convolution (int, optional): Number of encoder convolutions (Default: ``3``). encoder_kernel_size (int, optional): Encoder kernel size (Default: ``5``). encoder_embedding_dim (int, optional): Encoder embedding dimension (Default: ``512``). decoder_rnn_dim (int, optional): Number of units in decoder LSTM (Default: ``1024``). decoder_max_step (int, optional): Maximum number of output mel spectrograms (Default: ``2000``). decoder_dropout (float, optional): Dropout probability for decoder LSTM (Default: ``0.1``). decoder_early_stopping (bool, optional): Continue decoding after all samples are finished (Default: ``True``). attention_rnn_dim (int, optional): Number of units in attention LSTM (Default: ``1024``). attention_hidden_dim (int, optional): Dimension of attention hidden representation (Default: ``128``). attention_location_n_filter (int, optional): Number of filters for attention model (Default: ``32``). attention_location_kernel_size (int, optional): Kernel size for attention model (Default: ``31``). attention_dropout (float, optional): Dropout probability for attention LSTM (Default: ``0.1``). prenet_dim (int, optional): Number of ReLU units in prenet layers (Default: ``256``). postnet_n_convolution (int, optional): Number of postnet convolutions (Default: ``5``). postnet_kernel_size (int, optional): Postnet kernel size (Default: ``5``). postnet_embedding_dim (int, optional): Postnet embedding dimension (Default: ``512``). gate_threshold (float, optional): Probability threshold for stop token (Default: ``0.5``). FPr皙?T r mask_paddingrn_symbolrsymbol_embedding_dimrWrrrrrrrVr>rXrYrrrrrrrNct||_||_||_t j|||_tjj |jj t||||_ t|||| | | | | |||||||_t!|||||_dSN)rBrCrrrr Embedding embeddingrrrrrencoderrdecoderrpostnet)rFrrrrrrWrrrrrrrVr>rXrYrrrrrrrGs rrCzTacotron2.__init__s2 ( !2h0DEE  %%dn&;<<< 57LNabb    !    "  ' *       (=?RTijj rtokens token_lengthsrrct||dd}|||}||||\}}}||} || z} |jrt |} | |j| d| d} | ddd} | | d| | d| | dddddfd|| ||fS)aPass the input through the Tacotron2 model. This is in teacher forcing mode, which is generally used for training. The input ``tokens`` should be padded with zeros to length max of ``token_lengths``. The input ``mel_specgram`` should be padded with zeros to length max of ``mel_specgram_lengths``. Args: tokens (Tensor): The input tokens to Tacotron2 with shape `(n_batch, max of token_lengths)`. token_lengths (Tensor): The valid length of each sample in ``tokens`` with shape `(n_batch, )`. mel_specgram (Tensor): The target mel spectrogram with shape `(n_batch, n_mels, max of mel_specgram_lengths)`. mel_specgram_lengths (Tensor): The length of each mel spectrogram with shape `(n_batch, )`. Returns: [Tensor, Tensor, Tensor, Tensor]: Tensor Mel spectrogram before Postnet with shape `(n_batch, n_mels, max of mel_specgram_lengths)`. Tensor Mel spectrogram after Postnet with shape `(n_batch, n_mels, max of mel_specgram_lengths)`. Tensor The output for stop token at each time step with shape `(n_batch, max of mel_specgram_lengths)`. Tensor Sequence of attention weights from the decoder with shape `(n_batch, max of mel_specgram_lengths, max of token_lengths)`. rr&)rrgNg@@) rrJrrrrr9expandrrpermute masked_fill_) rFrrrrembedded_inputsencoder_outputsrrmel_specgram_postnetr8s rrLzTacotron2.forwards<B..00::1a@@,, FF15 \-2>2 2 . lJ $||L99+.BB   :)*>??D;;t{DIIaLL$))A,,GGD<<1a((D  % %dC 0 0 0 - -dC 8 8 8  % %d111a7mS 9 9 91<KKrr,c|j\}}|Ftj|g||j|j}|J||dd}| ||}|j ||\}}} } | |} || z} | d||dd} | || fS)aUsing Tacotron2 for inference. The input is a batch of encoded sentences (``tokens``) and its corresponding lengths (``lengths``). The output is the generated mel spectrograms, its corresponding lengths, and the attention weights from the decoder. The input `tokens` should be padded with zeros to length max of ``lengths``. Args: tokens (Tensor): The input tokens to Tacotron2 with shape `(n_batch, max of lengths)`. lengths (Tensor or None, optional): The valid length of each sample in ``tokens`` with shape `(n_batch, )`. If ``None``, it is assumed that the all the tokens are valid. Default: ``None`` Returns: (Tensor, Tensor, Tensor): Tensor The predicted mel spectrogram with shape `(n_batch, n_mels, max of mel_specgram_lengths)`. Tensor The length of the predicted mel spectrogram with shape `(n_batch, )`. Tensor Sequence of attention weights from the decoder with shape `(n_batch, max of mel_specgram_lengths, max of lengths)`. Nrr&r)rrtensorrtor.r/rrJrrrrunfold) rFrr,r max_lengthrrrrrrmel_outputs_postnets rrzTacotron2.infers2%l ?lJ<0077@@CCFMSYS_``G"""..00::1a@@,,@@<@Lr-s8//////////// $$$$$$  cCtQTdidlds*59+++++  + eCeCj01 2 +  + ++ X_++++\Fv".#.#.#.#.#RY.#.#.#bT4T4T4T4T4T4T4T4nbi<:::::ry:::zEEEEEryEEEP}M}M}M}M}Mry}M}M}M@qEqEqEqEqE qEqEqEqEqEr