Ë
    óÿæiV<  ã                   ó$  — d dl Z d dlmZmZmZ d dlZd dlmc mZ	 d dlmZm
Z
 g d¢Z G d„ dej                  «      Z G d„ dej                  «      Z G d	„ d
ej                  «      Z G d„ dej                  «      Z G d„ dej                  «      Zy)é    N)ÚListÚOptionalÚTuple)ÚnnÚTensor)ÚResBlockÚ	MelResNetÚ	Stretch2dÚUpsampleNetworkÚWaveRNNc                   ó>   ‡ — e Zd ZdZddeddfˆ fd„Zdedefd„Zˆ xZS )	r   af  ResNet block based on *Efficient Neural Audio Synthesis* :cite:`kalchbrenner2018efficient`.

    Args:
        n_freq: the number of bins in a spectrogram. (Default: ``128``)

    Examples
        >>> resblock = ResBlock()
        >>> input = torch.rand(10, 128, 512)  # a random spectrogram
        >>> output = resblock(input)  # shape: (10, 128, 512)
    Ún_freqÚreturnNc                 ó.  •— t         ‰| �  «        t        j                  t        j                  ||dd¬«      t        j
                  |«      t        j                  d¬«      t        j                  ||dd¬«      t        j
                  |«      «      | _        y )Né   F©Úin_channelsÚout_channelsÚkernel_sizeÚbiasT©Úinplace)ÚsuperÚ__init__r   Ú
SequentialÚConv1dÚBatchNorm1dÚReLUÚresblock_model)Úselfr   Ú	__class__s     €ún/Volumes/fast/ai/experiments/voice-extract-mac/.venv/lib/python3.12/site-packages/torchaudio/models/wavernn.pyr   zResBlock.__init__   si   ø€ Ü‰ÑÔä Ÿm™mÜ�I‰I &°vÈ1ÐSXÔYÜ�N‰N˜6Ó"Ü�G‰G˜DÔ!Ü�I‰I &°vÈ1ÐSXÔYÜ�N‰N˜6Ó"ó
ˆÕó    Úspecgramc                 ó*   — | j                  |«      |z   S )zéPass the input through the ResBlock layer.
        Args:
            specgram (Tensor): the input sequence to the ResBlock layer (n_batch, n_freq, n_time).

        Return:
            Tensor shape: (n_batch, n_freq, n_time)
        )r   ©r    r$   s     r"   ÚforwardzResBlock.forward(   s   € ð ×"Ñ" 8Ó,¨xÑ7Ð7r#   )é€   ©	Ú__name__Ú
__module__Ú__qualname__Ú__doc__Úintr   r   r'   Ú__classcell__©r!   s   @r"   r   r      s.   ø„ ñ	ñ	
˜sð 	
¨Tõ 	
ð	8 ð 	8¨6÷ 	8r#   r   c                   óP   ‡ — e Zd ZdZ	 ddedededededdfˆ fd	„Zd
edefd„Zˆ xZS )r	   a�  MelResNet layer uses a stack of ResBlocks on spectrogram.

    Args:
        n_res_block: the number of ResBlock in stack. (Default: ``10``)
        n_freq: the number of bins in a spectrogram. (Default: ``128``)
        n_hidden: the number of hidden dimensions of resblock. (Default: ``128``)
        n_output: the number of output dimensions of melresnet. (Default: ``128``)
        kernel_size: the number of kernel size in the first Conv1d layer. (Default: ``5``)

    Examples
        >>> melresnet = MelResNet()
        >>> input = torch.rand(10, 128, 512)  # a random spectrogram
        >>> output = melresnet(input)  # shape: (10, 128, 508)
    Ún_res_blockr   Ún_hiddenÚn_outputr   r   Nc                 óT  •— t         ‰| �  «        t        |«      D �cg c]  }t        |«      ‘Œ }}t	        j
                  t	        j                  |||d¬«      t	        j                  |«      t	        j                  d¬«      g|¢t	        j                  ||d¬«      ‘­Ž | _	        y c c}w )NFr   Tr   r   )r   r   r   )
r   r   Úranger   r   r   r   r   r   Úmelresnet_model)	r    r2   r   r3   r4   r   Ú_Ú	ResBlocksr!   s	           €r"   r   zMelResNet.__init__D   s“   ø€ ô 	‰ÑÔä16°{Ô1CÓDÑ1C¨A”X˜hÕ'Ð1Cˆ	ÐDä!Ÿ}™}Ü�I‰I &°xÈ[Ð_dÔeÜ�N‰N˜8Ó$Ü�G‰G˜DÔ!ð 
ð ð	 
ô
 �I‰I (¸ÈqÔQò 
ˆÕùò Es   �B%r$   c                 ó$   — | j                  |«      S )zÿPass the input through the MelResNet layer.
        Args:
            specgram (Tensor): the input sequence to the MelResNet layer (n_batch, n_freq, n_time).

        Return:
            Tensor shape: (n_batch, n_output, n_time - kernel_size + 1)
        )r7   r&   s     r"   r'   zMelResNet.forwardS   s   € ð ×#Ñ# HÓ-Ð-r#   ©é
   r(   r(   r(   é   r)   r0   s   @r"   r	   r	   4   sW   ø„ ñð  vwñ
Øð
Ø-0ð
ØBEð
ØWZð
Øorð
à	õ
ð	. ð 	.¨6÷ 	.r#   r	   c                   ó@   ‡ — e Zd ZdZdededdfˆ fd„Zdedefd„Zˆ xZS )	r
   a‘  Upscale the frequency and time dimensions of a spectrogram.

    Args:
        time_scale: the scale factor in time dimension
        freq_scale: the scale factor in frequency dimension

    Examples
        >>> stretch2d = Stretch2d(time_scale=10, freq_scale=5)

        >>> input = torch.rand(10, 100, 512)  # a random spectrogram
        >>> output = stretch2d(input)  # shape: (10, 500, 5120)
    Ú
time_scaleÚ
freq_scaler   Nc                 ó>   •— t         ‰| �  «        || _        || _        y ©N)r   r   r@   r?   )r    r?   r@   r!   s      €r"   r   zStretch2d.__init__m   s   ø€ Ü‰ÑÔà$ˆŒØ$ˆ�r#   r$   c                 ón   — |j                  | j                  d«      j                  | j                  d«      S )zþPass the input through the Stretch2d layer.

        Args:
            specgram (Tensor): the input sequence to the Stretch2d layer (..., n_freq, n_time).

        Return:
            Tensor shape: (..., n_freq * freq_scale, n_time * time_scale)
        éþÿÿÿéÿÿÿÿ)Úrepeat_interleaver@   r?   r&   s     r"   r'   zStretch2d.forwards   s0   € ð ×)Ñ)¨$¯/©/¸2Ó>×PÑPÐQU×Q`ÑQ`ÐbdÓeÐer#   r)   r0   s   @r"   r
   r
   _   s8   ø„ ñð% 3ð %°Cð %¸Dõ %ð
f ð 
f¨6÷ 
fr#   r
   c                   ól   ‡ — e Zd ZdZ	 	 	 	 	 ddee   dedededededd	fˆ fd
„Zdedeeef   fd„Z	ˆ xZ
S )r   añ  Upscale the dimensions of a spectrogram.

    Args:
        upsample_scales: the list of upsample scales.
        n_res_block: the number of ResBlock in stack. (Default: ``10``)
        n_freq: the number of bins in a spectrogram. (Default: ``128``)
        n_hidden: the number of hidden dimensions of resblock. (Default: ``128``)
        n_output: the number of output dimensions of melresnet. (Default: ``128``)
        kernel_size: the number of kernel size in the first Conv1d layer. (Default: ``5``)

    Examples
        >>> upsamplenetwork = UpsampleNetwork(upsample_scales=[4, 4, 16])
        >>> input = torch.rand(10, 128, 10)  # a random spectrogram
        >>> output = upsamplenetwork(input)  # shape: (10, 128, 1536), (10, 128, 1536)
    Úupsample_scalesr2   r   r3   r4   r   r   Nc                 ó  •— t         ‰| �  «        d}|D ]  }||z  }Œ	 || _        |dz
  dz  |z  | _        t	        |||||«      | _        t        |d«      | _        g }	|D ]‘  }
t        |
d«      }t        j                  ddd|
dz  dz   fd|
fd¬«      }t        j                  j                  j                  |j                  d|
dz  dz   z  «       |	j                  |«       |	j                  |«       Œ“ t        j                  |	Ž | _        y )Nr   é   r   F)r   r   r   Úpaddingr   ç      ð?)r   r   Útotal_scaleÚindentr	   Úresnetr
   Úresnet_stretchr   ÚConv2dÚtorchÚinitÚ	constant_ÚweightÚappendr   Úupsample_layers)r    rH   r2   r   r3   r4   r   rM   Úupsample_scaleÚ	up_layersÚscaleÚstretchÚconvr!   s                €r"   r   zUpsampleNetwork.__init__‘   s  ø€ ô 	‰ÑÔàˆÛ-ˆNØ˜>Ñ)‰Kð .à +ˆÔà" Q‘¨1Ñ,¨{Ñ:ˆŒÜ ¨V°X¸xÈÓUˆŒÜ'¨°QÓ7ˆÔàˆ	Û$ˆEÜ  qÓ)ˆGÜ—9‘9Ø¨A¸A¸uÀq¹yÈ1¹}Ð;MÐXYÐ[`ÐWaÐhmôˆDô �H‰H�M‰M×#Ñ# D§K¡K°¸À¹	ÀA¹Ñ1FÔGØ×Ñ˜WÔ%Ø×Ñ˜TÕ"ð %ô  "Ÿ}™}¨iÐ8ˆÕr#   r$   c                 ó6  — | j                  |«      j                  d«      }| j                  |«      }|j                  d«      }|j                  d«      }| j	                  |«      }|j                  d«      dd…dd…| j
                  | j
                   …f   }||fS )a¿  Pass the input through the UpsampleNetwork layer.

        Args:
            specgram (Tensor): the input sequence to the UpsampleNetwork layer (n_batch, n_freq, n_time)

        Return:
            Tensor shape: (n_batch, n_freq, (n_time - kernel_size + 1) * total_scale),
                          (n_batch, n_output, (n_time - kernel_size + 1) * total_scale)
        where total_scale is the product of all elements in upsample_scales.
        r   N)rO   Ú	unsqueezerP   ÚsqueezerW   rN   )r    r$   Úresnet_outputÚupsampling_outputs       r"   r'   zUpsampleNetwork.forward°   s•   € ð Ÿ™ HÓ-×7Ñ7¸Ó:ˆØ×+Ñ+¨MÓ:ˆØ%×-Ñ-¨aÓ0ˆà×%Ñ% aÓ(ˆØ ×0Ñ0°Ó:ÐØ-×5Ñ5°aÓ8ººA¸t¿{¹{ÈdÏkÉkÈ\Ð?YÐ9YÑZÐà  -Ð/Ð/r#   r;   )r*   r+   r,   r-   r   r.   r   r   r   r'   r/   r0   s   @r"   r   r   €   s‚   ø„ ñð& ØØØØñ9à˜c™ð9ð ð9ð ð	9ð
 ð9ð ð9ð ð9ð 
õ9ð>0 ð 0¨5°¸°Ñ+@÷ 0r#   r   c                   óØ   ‡ — e Zd ZdZ	 	 	 	 	 	 	 ddee   dedededededed	ed
ededdfˆ fd„Zdededefd„Ze	j                  j                  ddedee   deeee   f   fd„«       Zˆ xZS )r   aW  WaveRNN model from *Efficient Neural Audio Synthesis* :cite:`wavernn`
    based on the implementation from `fatchord/WaveRNN <https://github.com/fatchord/WaveRNN>`_.

    The original implementation was introduced in *Efficient Neural Audio Synthesis*
    :cite:`kalchbrenner2018efficient`. The input channels of waveform and spectrogram have to be 1.
    The product of `upsample_scales` must equal `hop_length`.

    See Also:
        * `Training example <https://github.com/pytorch/audio/tree/release/0.12/examples/pipeline_wavernn>`__
        * :class:`torchaudio.pipelines.Tacotron2TTSBundle`: TTS pipeline with pretrained model.

    Args:
        upsample_scales: the list of upsample scales.
        n_classes: the number of output classes.
        hop_length: the number of samples between the starts of consecutive frames.
        n_res_block: the number of ResBlock in stack. (Default: ``10``)
        n_rnn: the dimension of RNN layer. (Default: ``512``)
        n_fc: the dimension of fully connected layer. (Default: ``512``)
        kernel_size: the number of kernel size in the first Conv1d layer. (Default: ``5``)
        n_freq: the number of bins in a spectrogram. (Default: ``128``)
        n_hidden: the number of hidden dimensions of resblock. (Default: ``128``)
        n_output: the number of output dimensions of melresnet. (Default: ``128``)

    Example
        >>> wavernn = WaveRNN(upsample_scales=[5,5,8], n_classes=512, hop_length=200)
        >>> waveform, sample_rate = torchaudio.load(file)
        >>> # waveform shape: (n_batch, n_channel, (n_time - kernel_size + 1) * hop_length)
        >>> specgram = MelSpectrogram(sample_rate)(waveform)  # shape: (n_batch, n_channel, n_freq, n_time)
        >>> output = wavernn(waveform, specgram)
        >>> # output shape: (n_batch, n_channel, (n_time - kernel_size + 1) * hop_length, n_classes)
    rH   Ú	n_classesÚ
hop_lengthr2   Ún_rnnÚn_fcr   r   r3   r4   r   Nc                 ó°  •— t         ‰| �  «        || _        |dz  r|dz
  n|dz  | _        || _        |
dz  | _        || _        || _        t        t        j                  | j                  «      «      | _        d}|D ]  }||z  }Œ	 || j                  k7  rt        d|› d|› �«      ‚t        ||||	|
|«      | _        t        j                   || j
                  z   dz   |«      | _        t        j$                  ||d¬«      | _        t        j$                  || j
                  z   |d¬«      | _        t        j*                  d¬«      | _        t        j*                  d¬«      | _        t        j                   || j
                  z   |«      | _        t        j                   || j
                  z   |«      | _        t        j                   || j                  «      | _        y )	NrJ   r   é   z/Expected: total_scale == hop_length, but found z != T)Úbatch_firstr   )r   r   r   Ú_padre   Ún_auxrd   rc   r.   ÚmathÚlog2Ún_bitsÚ
ValueErrorr   Úupsampler   ÚLinearÚfcÚGRUÚrnn1Úrnn2r   Úrelu1Úrelu2Úfc1Úfc2Úfc3)r    rH   rc   rd   r2   re   rf   r   r   r3   r4   rM   rX   r!   s                €r"   r   zWaveRNN.__init__è   s  ø€ ô 	‰ÑÔà&ˆÔØ(3°aª�[ 1’_¸[ÈQÑNˆŒ	ØˆŒ
Ø ‘]ˆŒ
Ø$ˆŒØ"ˆŒÜœtŸy™y¨¯©Ó8Ó9ˆŒàˆÛ-ˆNØ˜>Ñ)‰Kð .à˜$Ÿ/™/Ò)ÜÐNÈ{ÈmÐ[_Ð`jÐ_kÐlÓmÐmä'¨¸ÀfÈhÐX`ÐbmÓnˆŒÜ—)‘)˜F T§Z¡ZÑ/°!Ñ3°UÓ;ˆŒä—F‘F˜5 %°TÔ:ˆŒ	Ü—F‘F˜5 4§:¡:Ñ-¨uÀ$ÔGˆŒ	ä—W‘W TÔ*ˆŒ
Ü—W‘W TÔ*ˆŒ
ä—9‘9˜U T§Z¡ZÑ/°Ó6ˆŒÜ—9‘9˜T D§J¡JÑ.°Ó5ˆŒÜ—9‘9˜T 4§>¡>Ó2ˆ�r#   Úwaveformr$   c                 ón  — |j                  d«      dk7  rt        d«      ‚|j                  d«      dk7  rt        d«      ‚|j                  d«      |j                  d«      }}|j                  d«      }t        j                  d|| j
                  |j                  |j                  ¬«      }t        j                  d|| j
                  |j                  |j                  ¬«      }| j                  |«      \  }}|j                  dd«      }|j                  dd«      }t        d«      D �cg c]  }| j                  |z  ‘Œ }}|dd…dd…|d   |d   …f   }	|dd…dd…|d   |d   …f   }
|dd…dd…|d   |d	   …f   }|dd…dd…|d	   |d
   …f   }t        j                  |j                  d«      ||	gd¬«      }| j                  |«      }|}| j                  ||«      \  }}||z   }|}t        j                  ||
gd¬«      }| j!                  ||«      \  }}||z   }t        j                  ||gd¬«      }| j#                  |«      }| j%                  |«      }t        j                  ||gd¬«      }| j'                  |«      }| j)                  |«      }| j+                  |«      }|j                  d«      S c c}w )a  Pass the input through the WaveRNN model.

        Args:
            waveform: the input waveform to the WaveRNN layer (n_batch, 1, (n_time - kernel_size + 1) * hop_length)
            specgram: the input spectrogram to the WaveRNN layer (n_batch, 1, n_freq, n_time)

        Return:
            Tensor: shape (n_batch, 1, (n_time - kernel_size + 1) * hop_length, n_classes)
        r   z*Require the input channel of waveform is 1z*Require the input channel of specgram is 1r   )ÚdtypeÚdevicerJ   r=   Né   rh   rE   ©Údim)Úsizero   r_   rR   Úzerosre   r}   r~   rp   Ú	transposer6   rk   Úcatr^   rr   rt   ru   rx   rv   ry   rw   rz   )r    r{   r$   Ú
batch_sizeÚh1Úh2ÚauxÚiÚaux_idxÚa1Úa2Úa3Úa4ÚxÚresr8   s                   r"   r'   zWaveRNN.forward  sˆ  € ð �=‰=˜Ó˜qÒ ÜÐIÓJÐJØ�=‰=˜Ó˜qÒ ÜÐIÓJÐJà%×-Ñ-¨aÓ0°(×2BÑ2BÀ1Ó2E�(ˆà—]‘] 1Ó%ˆ
Ü�[‰[˜˜J¨¯
©
¸(¿.¹.ÐQY×Q`ÑQ`ÔaˆÜ�[‰[˜˜J¨¯
©
¸(¿.¹.ÐQY×Q`ÑQ`Ôaˆð Ÿ™ hÓ/‰ˆ�#Ø×%Ñ% a¨Ó+ˆØ�m‰m˜A˜qÓ!ˆä+0°¬8Ó4©8 a�4—:‘: “>¨8ˆÐ4Ø’’A�w˜q‘z G¨A¡JÐ.Ð.Ñ/ˆØ’’A�w˜q‘z G¨A¡JÐ.Ð.Ñ/ˆØ’’A�w˜q‘z G¨A¡JÐ.Ð.Ñ/ˆØ’’A�w˜q‘z G¨A¡JÐ.Ð.Ñ/ˆä�I‰I�x×)Ñ)¨"Ó-¨x¸Ð<À"ÔEˆØ�G‰G�A‹JˆØˆØ�y‰y˜˜BÓ‰ˆˆ1à�‰GˆØˆÜ�I‰I�q˜"�g 2Ô&ˆØ�y‰y˜˜BÓ‰ˆˆ1à�‰GˆÜ�I‰I�q˜"�g 2Ô&ˆØ�H‰H�Q‹KˆØ�J‰J�q‹Mˆä�I‰I�q˜"�g 2Ô&ˆØ�H‰H�Q‹KˆØ�J‰J�q‹MˆØ�H‰H�Q‹Kˆð �{‰{˜1‹~Ðùò7 5s   Ä'J2Úlengthsc           	      ó€  — |j                   }|j                  }t        j                  j                  j                  || j                  | j                  f«      }| j                  |«      \  }}|�|| j                  j                  z  }g }|j                  «       \  }}}	t        j                  d|| j                  f||¬«      }
t        j                  d|| j                  f||¬«      }t        j                  |df||¬«      }t        d«      D �cg c]-  }|dd…| j                  |z  | j                  |dz   z  …dd…f   ‘Œ/ }}t        |	«      D �]¼  }|dd…dd…|f   }|D �cg c]  }|dd…dd…|f   ‘Œ c}\  }}}}t        j                  |||gd¬«      }| j                  |«      }| j!                  |j#                  d«      |
«      \  }}
||
d   z   }t        j                  ||gd¬«      }| j%                  |j#                  d«      |«      \  }}||d   z   }t        j                  ||gd¬«      }t'        j(                  | j+                  |«      «      }t        j                  ||gd¬«      }t'        j(                  | j-                  |«      «      }| j/                  |«      }t'        j0                  |d¬«      }t        j2                  |d«      j5                  «       }d|z  d| j6                  z  dz
  z  dz
  }|j9                  |«       �Œ¿ t        j:                  |«      j=                  ddd«      |fS c c}w c c}w )	a¾  Inference method of WaveRNN.

        This function currently only supports multinomial sampling, which assumes the
        network is trained on cross entropy loss.

        Args:
            specgram (Tensor):
                Batch of spectrograms. Shape: `(n_batch, n_freq, n_time)`.
            lengths (Tensor or None, optional):
                Indicates the valid length of each audio in the batch.
                Shape: `(batch, )`.
                When the ``specgram`` contains spectrograms with different durations,
                by providing ``lengths`` argument, the model will compute
                the corresponding valid output lengths.
                If ``None``, it is assumed that all the audio in ``waveforms``
                have valid length. Default: ``None``.

        Returns:
            (Tensor, Optional[Tensor]):
            Tensor
                The inferred waveform of size `(n_batch, 1, n_time)`.
                1 stands for a single channel.
            Tensor or None
                If ``lengths`` argument was provided, a Tensor of shape `(batch, )`
                is returned.
                It indicates the valid length in time axis of the output Tensor.
        Nr   )r~   r}   rh   r€   r   rJ   rL   )r~   r}   rR   r   Ú
functionalÚpadrj   rp   rM   r‚   rƒ   re   r6   rk   r…   rr   rt   r^   ru   ÚFÚrelurx   ry   rz   ÚsoftmaxÚmultinomialÚfloatrn   rV   ÚstackÚpermute)r    r$   r’   r~   r}   r‰   ÚoutputÚb_sizer8   Úseq_lenr‡   rˆ   r�   rŠ   Ú	aux_splitÚm_tÚaÚa1_tÚa2_tÚa3_tÚa4_tÚinpÚlogitsÚ	posteriors                           r"   ÚinferzWaveRNN.inferK  sÊ  € ð< —‘ˆØ—‘ˆä—8‘8×&Ñ&×*Ñ*¨8°d·i±iÀÇÁÐ5KÓLˆØŸ™ hÓ/‰ˆ�#ØÐØ §¡× 9Ñ 9Ñ9ˆGà!ˆØ%Ÿ]™]›_Ñˆ��7ä�[‰[˜!˜V T§Z¡ZÐ0¸ÀuÔMˆÜ�[‰[˜!˜V T§Z¡ZÐ0¸ÀuÔMˆÜ�K‰K˜ ˜¨F¸%Ô@ˆäOTÐUVÌxÓXÉxÈ!�Sš˜DŸJ™J¨™N¨T¯Z©Z¸1¸q¹5Ñ-AÐAÂ1ÐDÓEÈxˆ	ÐXä�w—ˆAàš1ša ˜7Ñ#ˆCá:CÓ%D¹)°Q aªª1¨a¨£j¸)Ñ%DÑ"ˆD�$˜˜dä—	‘	˜1˜c 4˜.¨aÔ0ˆAØ—‘˜“
ˆAØ—I‘I˜aŸk™k¨!›n¨bÓ1‰EˆAˆrà�B�q‘E‘	ˆAÜ—)‘)˜Q ˜I¨1Ô-ˆCØ—I‘I˜cŸm™m¨AÓ.°Ó3‰EˆAˆrà�B�q‘E‘	ˆAÜ—	‘	˜1˜d˜)¨Ô+ˆAÜ—‘�t—x‘x “{Ó#ˆAä—	‘	˜1˜d˜)¨Ô+ˆAÜ—‘�t—x‘x “{Ó#ˆAà—X‘X˜a“[ˆFäŸ	™	 &¨aÔ0ˆIä×!Ñ! )¨QÓ/×5Ñ5Ó7ˆAà�A‘˜˜DŸK™K™¨#Ñ-Ñ.°Ñ4ˆAà�M‰M˜!Öð;  ô> �{‰{˜6Ó"×*Ñ*¨1¨a°Ó3°WÐ<Ð<ùòC Yùò &Es   Ä2L6Å"L;)r<   é   r«   r=   r(   r(   r(   rB   )r*   r+   r,   r-   r   r.   r   r   r'   rR   ÚjitÚexportr   r   rª   r/   r0   s   @r"   r   r   Ç   s   ø„ ñðJ ØØØØØØñ(3à˜c™ð(3ð ð(3ð ð	(3ð
 ð(3ð ð(3ð ð(3ð ð(3ð ð(3ð ð(3ð ð(3ð 
õ(3ðT7 ð 7°&ð 7¸Vó 7ðr ‡Y�Y×ÑñM=˜fð M=¨x¸Ñ/?ð M=È5ÐQWÐYaÐbhÑYiÐQiÑKjò M=ó ôM=r#   r   )rl   Útypingr   r   r   rR   Útorch.nn.functionalr   r”   r–   r   Ú__all__ÚModuler   r	   r
   r   r   © r#   r"   Ú<module>r³      s{   ðÛ ß (Ñ (ã ß Ð ß ò€ô 8ˆr�y‰yô  8ôF(.�—	‘	ô (.ôVf�—	‘	ô fôBD0�b—i‘iô D0ôNR=ˆb�i‰iõ R=r#   