A quick update of docstrings of kaldi.py and transforms.py (#163)

torchaudio/compliance/kaldi.py

@@ -31,25 +31,25 @@ WINDOWS = [HAMMING, HANNING, POVEY, RECTANGULAR, BLACKMAN]
 
 
 def _next_power_of_2(x):
-    """ Returns the smallest power of 2 that is greater than x
+    r"""Returns the smallest power of 2 that is greater than x
     """
     return 1 if x == 0 else 2**(x - 1).bit_length()
 
 
 def _get_strided(waveform, window_size, window_shift, snip_edges):
-    """ Given a waveform (1D tensor of size num_samples), it returns a 2D tensor (m, window_size)
+    r"""Given a waveform (1D tensor of size `num_samples`), it returns a 2D tensor (m, `window_size`)
     representing how the window is shifted along the waveform. Each row is a frame.
 
-    Inputs:
-        sig (Tensor): Tensor of size num_samples
+    Args:
+        waveform (torch.Tensor): Tensor of size `num_samples`
         window_size (int): Frame length
         window_shift (int): Frame shift
         snip_edges (bool): If True, end effects will be handled by outputting only frames that completely fit
             in the file, and the number of frames depends on the frame_length.  If False, the number of frames
             depends only on the frame_shift, and we reflect the data at the ends.
 
-    Output:
-        Tensor: 2D tensor of size (m, window_size) where each row is a frame
+    Returns:
+        torch.Tensor: 2D tensor of size (m, `window_size`) where each row is a frame
     """
     assert waveform.dim() == 1
     num_samples = waveform.size(0)
@@ -79,7 +79,7 @@ def _get_strided(waveform, window_size, window_shift, snip_edges):
 
 
 def _feature_window_function(window_type, window_size, blackman_coeff):
-    """ Returns a window function with the given type and size
+    r"""Returns a window function with the given type and size
     """
     if window_type == HANNING:
         return torch.hann_window(window_size, periodic=False)
@@ -101,7 +101,7 @@ def _feature_window_function(window_type, window_size, blackman_coeff):
 
 
 def _get_log_energy(strided_input, epsilon, energy_floor):
-    """ Returns the log energy of size (m) for a strided_input (m,*)
+    r"""Returns the log energy of size (m) for a strided_input (m,*)
     """
     log_energy = torch.max(strided_input.pow(2).sum(1), epsilon).log()  # size (m)
     if energy_floor == 0.0:
@@ -111,11 +111,11 @@ def _get_log_energy(strided_input, epsilon, energy_floor):
                          torch.tensor(math.log(energy_floor), dtype=torch.get_default_dtype()))
 
 
-def _get_waveform_and_window_properties(sig, channel, sample_frequency, frame_shift,
+def _get_waveform_and_window_properties(waveform, channel, sample_frequency, frame_shift,
                                         frame_length, round_to_power_of_two, preemphasis_coefficient):
-    """Gets the waveform and window properties
+    r"""Gets the waveform and window properties
     """
-    waveform = sig[max(channel, 0), :]  # size (n)
+    waveform = waveform[max(channel, 0), :]  # size (n)
     window_shift = int(sample_frequency * frame_shift * MILLISECONDS_TO_SECONDS)
     window_size = int(sample_frequency * frame_length * MILLISECONDS_TO_SECONDS)
     padded_window_size = _next_power_of_2(window_size) if round_to_power_of_two else window_size
@@ -131,10 +131,11 @@ def _get_waveform_and_window_properties(sig, channel, sample_frequency, frame_sh
 
 def _get_window(waveform, padded_window_size, window_size, window_shift, window_type, blackman_coeff,
                 snip_edges, raw_energy, energy_floor, dither, remove_dc_offset, preemphasis_coefficient):
-    """Gets a window and its log energy
-    Outputs:
-        strided_input (Tensor): size (m, padded_window_size)
-        signal_log_energy (Tensor): size (m)
+    r"""Gets a window and its log energy
+
+    Returns:
+        strided_input (torch.Tensor): size (m, `padded_window_size`)
+        signal_log_energy (torch.Tensor): size (m)
     """
     # size (m, window_size)
     strided_input = _get_strided(waveform, window_size, window_shift, snip_edges)
@@ -180,7 +181,7 @@ def _get_window(waveform, padded_window_size, window_size, window_shift, window_
 
 
 def spectrogram(
-        sig, blackman_coeff=0.42, channel=-1, dither=1.0, energy_floor=0.0,
+        waveform, blackman_coeff=0.42, channel=-1, dither=1.0, energy_floor=0.0,
         frame_length=25.0, frame_shift=10.0, min_duration=0.0,
         preemphasis_coefficient=0.97, raw_energy=True, remove_dc_offset=True,
         round_to_power_of_two=True, sample_frequency=16000.0, snip_edges=True,
@@ -189,37 +190,37 @@ def spectrogram(
     compute-spectrogram-feats.
 
     Args:
-        sig (Tensor): Tensor of audio of size (c, n) where c is in the range [0,2)
-        blackman_coeff (float): Constant coefficient for generalized Blackman window. (default = 0.42)
-        channel (int): Channel to extract (-1 -> expect mono, 0 -> left, 1 -> right) (default = -1)
+        waveform (torch.Tensor): Tensor of audio of size (c, n) where c is in the range [0,2)
+        blackman_coeff (float): Constant coefficient for generalized Blackman window. (Default: 0.42)
+        channel (int): Channel to extract (-1 -> expect mono, 0 -> left, 1 -> right) (Default: -1)
         dither (float): Dithering constant (0.0 means no dither). If you turn this off, you should set
-            the energy_floor option, e.g. to 1.0 or 0.1 (default = 1.0)
+            the energy_floor option, e.g. to 1.0 or 0.1 (Default: 1.0)
         energy_floor (float): Floor on energy (absolute, not relative) in Spectrogram computation.  Caution:
             this floor is applied to the zeroth component, representing the total signal energy.  The floor on the
-            individual spectrogram elements is fixed at std::numeric_limits<float>::epsilon(). (default = 0.0)
-        frame_length (float): Frame length in milliseconds (default = 25.0)
-        frame_shift (float): Frame shift in milliseconds (default = 10.0)
-        min_duration (float): Minimum duration of segments to process (in seconds). (default = 0.0)
-        preemphasis_coefficient (float): Coefficient for use in signal preemphasis (default = 0.97)
-        raw_energy (bool): If True, compute energy before preemphasis and windowing (default = True)
-        remove_dc_offset: Subtract mean from waveform on each frame (default = True)
+            individual spectrogram elements is fixed at std::numeric_limits<float>::epsilon(). (Default: 0.0)
+        frame_length (float): Frame length in milliseconds (Default: 25.0)
+        frame_shift (float): Frame shift in milliseconds (Default: 10.0)
+        min_duration (float): Minimum duration of segments to process (in seconds). (Default: 0.0)
+        preemphasis_coefficient (float): Coefficient for use in signal preemphasis (Default: 0.97)
+        raw_energy (bool): If True, compute energy before preemphasis and windowing (Default: True)
+        remove_dc_offset: Subtract mean from waveform on each frame (Default: True)
         round_to_power_of_two (bool): If True, round window size to power of two by zero-padding input
-            to FFT. (default = True)
+            to FFT. (Default: True)
         sample_frequency (float): Waveform data sample frequency (must match the waveform file, if
-            specified there) (default = 16000.0)
+            specified there) (Default: 16000.0)
         snip_edges (bool): If True, end effects will be handled by outputting only frames that completely fit
             in the file, and the number of frames depends on the frame_length.  If False, the number of frames
-            depends only on the frame_shift, and we reflect the data at the ends. (default = True)
+            depends only on the frame_shift, and we reflect the data at the ends. (Default: True)
         subtract_mean (bool): Subtract mean of each feature file [CMS]; not recommended to do
-            it this way.  (default = False)
-        window_type (str): Type of window ('hamming'|'hanning'|'povey'|'rectangular'|'blackman') (default = 'povey')
+            it this way.  (Default: False)
+        window_type (str): Type of window ('hamming'|'hanning'|'povey'|'rectangular'|'blackman') (Default: 'povey')
 
     Returns:
-        Tensor: a spectrogram identical to what Kaldi would output. The shape is
+        torch.Tensor: A spectrogram identical to what Kaldi would output. The shape is
         (m, `padded_window_size` // 2 + 1) where m is calculated in _get_strided
     """
     waveform, window_shift, window_size, padded_window_size = _get_waveform_and_window_properties(
-        sig, channel, sample_frequency, frame_shift, frame_length, round_to_power_of_two, preemphasis_coefficient)
+        waveform, channel, sample_frequency, frame_shift, frame_length, round_to_power_of_two, preemphasis_coefficient)
 
     if len(waveform) < min_duration * sample_frequency:
         # signal is too short
@@ -263,8 +264,7 @@ def mel_scale(freq):
 
 def vtln_warp_freq(vtln_low_cutoff, vtln_high_cutoff, low_freq, high_freq,
                    vtln_warp_factor, freq):
-    """
-    This computes a VTLN warping function that is not the same as HTK's one,
+    r"""This computes a VTLN warping function that is not the same as HTK's one,
     but has similar inputs (this function has the advantage of never producing
     empty bins).
 
@@ -289,15 +289,16 @@ def vtln_warp_freq(vtln_low_cutoff, vtln_high_cutoff, low_freq, high_freq,
         frequency) is at l, then min(l, F(l)) == vtln_low_cutoff
         This implies that l = vtln_low_cutoff / min(1, 1/vtln_warp_factor)
                             = vtln_low_cutoff * max(1, vtln_warp_factor)
-    Inputs:
-        vtln_low_cutoff (float): lower frequency cutoffs for VTLN
-        vtln_high_cutoff (float): upper frequency cutoffs for VTLN
-        low_freq (float): lower frequency cutoffs in mel computation
-        high_freq (float): upper frequency cutoffs in mel computation
+    Args:
+        vtln_low_cutoff (float): Lower frequency cutoffs for VTLN
+        vtln_high_cutoff (float): Upper frequency cutoffs for VTLN
+        low_freq (float): Lower frequency cutoffs in mel computation
+        high_freq (float): Upper frequency cutoffs in mel computation
         vtln_warp_factor (float): Vtln warp factor
-        freq (Tensor): given frequency in Hz
-    Outputs:
-        Tensor: freq after vtln warp
+        freq (torch.Tensor): given frequency in Hz
+
+    Returns:
+        torch.Tensor: Freq after vtln warp
     """
     assert vtln_low_cutoff > low_freq, 'be sure to set the vtln_low option higher than low_freq'
     assert vtln_high_cutoff < high_freq, 'be sure to set the vtln_high option lower than high_freq [or negative]'
@@ -332,16 +333,17 @@ def vtln_warp_freq(vtln_low_cutoff, vtln_high_cutoff, low_freq, high_freq,
 
 def vtln_warp_mel_freq(vtln_low_cutoff, vtln_high_cutoff, low_freq, high_freq,
                        vtln_warp_factor, mel_freq):
-    """
-    Inputs:
-        vtln_low_cutoff (float): lower frequency cutoffs for VTLN
-        vtln_high_cutoff (float): upper frequency cutoffs for VTLN
-        low_freq (float): lower frequency cutoffs in mel computation
-        high_freq (float): upper frequency cutoffs in mel computation
+    r"""
+    Args:
+        vtln_low_cutoff (float): Lower frequency cutoffs for VTLN
+        vtln_high_cutoff (float): Upper frequency cutoffs for VTLN
+        low_freq (float): Lower frequency cutoffs in mel computation
+        high_freq (float): Upper frequency cutoffs in mel computation
         vtln_warp_factor (float): Vtln warp factor
-        mel_freq (Tensor): given frequency in Mel
-    Outputs:
-        Tensor: mel_freq after vtln warp
+        mel_freq (torch.Tensor): Given frequency in Mel
+
+    Returns:
+        torch.Tensor: `mel_freq` after vtln warp
     """
     return mel_scale(vtln_warp_freq(vtln_low_cutoff, vtln_high_cutoff, low_freq, high_freq,
                                     vtln_warp_factor, inverse_mel_scale(mel_freq)))
@@ -351,9 +353,10 @@ def get_mel_banks(num_bins, window_length_padded, sample_freq,
                   low_freq, high_freq, vtln_low, vtln_high, vtln_warp_factor):
     # type: (int, int, float, float, float, float, float)
     """
-    Outputs:
-        bins (Tensor): melbank of size (num_bins, num_fft_bins)
-        center_freqs (Tensor): center frequencies of bins of size (num_bins)
+    Returns:
+        Tuple[torch.Tensor, torch.Tensor]: The tuple consists of `bins` (which is
+        Melbank of size (`num_bins`, `num_fft_bins`)) and `center_freqs` (which is
+        Center frequencies of bins of size (`num_bins`)).
     """
     assert num_bins > 3, 'Must have at least 3 mel bins'
     assert window_length_padded % 2 == 0
@@ -416,59 +419,59 @@ def get_mel_banks(num_bins, window_length_padded, sample_freq,
 
 
 def fbank(
-        sig, blackman_coeff=0.42, channel=-1, dither=1.0, energy_floor=0.0,
+        waveform, blackman_coeff=0.42, channel=-1, dither=1.0, energy_floor=0.0,
         frame_length=25.0, frame_shift=10.0, high_freq=0.0, htk_compat=False, low_freq=20.0,
         min_duration=0.0, num_mel_bins=23, preemphasis_coefficient=0.97, raw_energy=True,
         remove_dc_offset=True, round_to_power_of_two=True, sample_frequency=16000.0,
         snip_edges=True, subtract_mean=False, use_energy=False, use_log_fbank=True, use_power=True,
-        vtln_high=-500.0, vtln_low=100.0, vtln_warp=1.0, window_type='povey'):
+        vtln_high=-500.0, vtln_low=100.0, vtln_warp=1.0, window_type=POVEY):
     r"""Create a fbank from a raw audio signal. This matches the input/output of Kaldi's
     compute-fbank-feats.
 
     Args:
-        sig (Tensor): Tensor of audio of size (c, n) where c is in the range [0,2)
-        blackman_coeff (float): Constant coefficient for generalized Blackman window. (default = 0.42)
-        channel (int): Channel to extract (-1 -> expect mono, 0 -> left, 1 -> right) (default = -1)
+        waveform (torch.Tensor): Tensor of audio of size (c, n) where c is in the range [0,2)
+        blackman_coeff (float): Constant coefficient for generalized Blackman window. (Default: 0.42)
+        channel (int): Channel to extract (-1 -> expect mono, 0 -> left, 1 -> right) (Default: -1)
         dither (float): Dithering constant (0.0 means no dither). If you turn this off, you should set
-            the energy_floor option, e.g. to 1.0 or 0.1 (default = 1.0)
+            the energy_floor option, e.g. to 1.0 or 0.1 (Default: 1.0)
         energy_floor (float): Floor on energy (absolute, not relative) in Spectrogram computation.  Caution:
             this floor is applied to the zeroth component, representing the total signal energy.  The floor on the
-            individual spectrogram elements is fixed at std::numeric_limits<float>::epsilon(). (default = 0.0)
-        frame_length (float): Frame length in milliseconds (default = 25.0)
-        frame_shift (float): Frame shift in milliseconds (default = 10.0)
-        high_freq (float): High cutoff frequency for mel bins (if <= 0, offset from Nyquist) (default = 0.0)
+            individual spectrogram elements is fixed at std::numeric_limits<float>::epsilon(). (Default: 0.0)
+        frame_length (float): Frame length in milliseconds (Default: 25.0)
+        frame_shift (float): Frame shift in milliseconds (Default: 10.0)
+        high_freq (float): High cutoff frequency for mel bins (if <= 0, offset from Nyquist) (Default: 0.0)
         htk_compat (bool): If true, put energy last.  Warning: not sufficient to get HTK compatible features (need
-            to change other parameters). (default = False)
-        low_freq (float): Low cutoff frequency for mel bins (default = 20.0)
-        min_duration (float): Minimum duration of segments to process (in seconds). (default = 0.0)
-        num_mel_bins (int): Number of triangular mel-frequency bins (default = 23)
-        preemphasis_coefficient (float): Coefficient for use in signal preemphasis (default = 0.97)
-        raw_energy (bool): If True, compute energy before preemphasis and windowing (default = True)
-        remove_dc_offset: Subtract mean from waveform on each frame (default = True)
+            to change other parameters). (Default: False)
+        low_freq (float): Low cutoff frequency for mel bins (Default: 20.0)
+        min_duration (float): Minimum duration of segments to process (in seconds). (Default: 0.0)
+        num_mel_bins (int): Number of triangular mel-frequency bins (Default: 23)
+        preemphasis_coefficient (float): Coefficient for use in signal preemphasis (Default: 0.97)
+        raw_energy (bool): If True, compute energy before preemphasis and windowing (Default: True)
+        remove_dc_offset: Subtract mean from waveform on each frame (Default: True)
         round_to_power_of_two (bool): If True, round window size to power of two by zero-padding input
-            to FFT. (default = True)
+            to FFT. (Default: True)
         sample_frequency (float): Waveform data sample frequency (must match the waveform file, if
-            specified there) (default = 16000.0)
+            specified there) (Default: 16000.0)
         snip_edges (bool): If True, end effects will be handled by outputting only frames that completely fit
             in the file, and the number of frames depends on the frame_length.  If False, the number of frames
-            depends only on the frame_shift, and we reflect the data at the ends. (default = True)
+            depends only on the frame_shift, and we reflect the data at the ends. (Default: True)
         subtract_mean (bool): Subtract mean of each feature file [CMS]; not recommended to do
-            it this way.  (default = False)
-        use_energy (bool): Add an extra dimension with energy to the FBANK output. (default = False)
-        use_log_fbank (bool):If true, produce log-filterbank, else produce linear. (default = True)
-        use_power (bool): If true, use power, else use magnitude. (default = True)
+            it this way.  (Default: False)
+        use_energy (bool): Add an extra dimension with energy to the FBANK output. (Default: False)
+        use_log_fbank (bool):If true, produce log-filterbank, else produce linear. (Default: True)
+        use_power (bool): If true, use power, else use magnitude. (Default: True)
         vtln_high (float): High inflection point in piecewise linear VTLN warping function (if
-            negative, offset from high-mel-freq (default = -500.0)
-        vtln_low (float): Low inflection point in piecewise linear VTLN warping function (float, default = 100.0)
-        vtln_warp (float): Vtln warp factor (only applicable if vtln_map not specified) (float, default = 1.0)
-        window_type (str): Type of window ('hamming'|'hanning'|'povey'|'rectangular'|'blackman') (default = 'povey')
+            negative, offset from high-mel-freq (Default: -500.0)
+        vtln_low (float): Low inflection point in piecewise linear VTLN warping function (Default: 100.0)
+        vtln_warp (float): Vtln warp factor (only applicable if vtln_map not specified) (Default: 1.0)
+        window_type (str): Type of window ('hamming'|'hanning'|'povey'|'rectangular'|'blackman') (Default: 'povey')
 
     Returns:
-        Tensor: a fbank identical to what Kaldi would output. The shape is (m, `num_mel_bins` + `use_energy`)
+        torch.Tensor: A fbank identical to what Kaldi would output. The shape is (m, `num_mel_bins` + `use_energy`)
         where m is calculated in _get_strided
     """
     waveform, window_shift, window_size, padded_window_size = _get_waveform_and_window_properties(
-        sig, channel, sample_frequency, frame_shift, frame_length, round_to_power_of_two, preemphasis_coefficient)
+        waveform, channel, sample_frequency, frame_shift, frame_length, round_to_power_of_two, preemphasis_coefficient)
 
     if len(waveform) < min_duration * sample_frequency:
         # signal is too short
@@ -517,7 +520,7 @@ def fbank(
 
 def _get_LR_indices_and_weights(orig_freq, new_freq, output_samples_in_unit, window_width,
                                 lowpass_cutoff, lowpass_filter_width):
-    """Based on LinearResample::SetIndexesAndWeights where it retrieves the weights for
+    r"""Based on LinearResample::SetIndexesAndWeights where it retrieves the weights for
     resampling as well as the indices in which they are valid. LinearResample (LR) means
     that the output signal is at linearly spaced intervals (i.e the output signal has a
     frequency of `new_freq`). It uses sinc/bandlimited interpolation to upsample/downsample
@@ -548,20 +551,20 @@ def _get_LR_indices_and_weights(orig_freq, new_freq, output_samples_in_unit, win
     [1] Chapter 16: Windowed-Sinc Filters, https://www.dspguide.com/ch16/1.htm
 
     Args:
-        orig_freq (float): the original frequency of the signal
-        new_freq (float): the desired frequency
-        output_samples_in_unit (int): the number of output samples in the smallest repeating unit:
+        orig_freq (float): The original frequency of the signal
+        new_freq (float): The desired frequency
+        output_samples_in_unit (int): The number of output samples in the smallest repeating unit:
             num_samp_out = new_freq / Gcd(orig_freq, new_freq)
-        window_width (float): the width of the window which is nonzero
-        lowpass_cutoff (float): the filter cutoff in Hz. The filter cutoff needs to be less
+        window_width (float): The width of the window which is nonzero
+        lowpass_cutoff (float): The filter cutoff in Hz. The filter cutoff needs to be less
             than samp_rate_in_hz/2 and less than samp_rate_out_hz/2.
-        lowpass_filter_width (int): controls the sharpness of the filter, more == sharper but less
+        lowpass_filter_width (int): Controls the sharpness of the filter, more == sharper but less
             efficient. We suggest around 4 to 10 for normal use
 
     Returns:
-        min_input_index (Tensor): the minimum indices where the window is valid. size (output_samples_in_unit)
-        weights (Tensor): the weights which correspond with min_input_index. size (
-            output_samples_in_unit, max_weight_width)
+        Tuple[torch.Tensor, torch.Tensor]: A tuple of `min_input_index` (which is the minimum indices
+        where the window is valid, size (`output_samples_in_unit`)) and `weights` (which is the weights
+        which correspond with min_input_index, size (`output_samples_in_unit`, `max_weight_width`)).
     """
     assert lowpass_cutoff < min(orig_freq, new_freq) / 2
     output_t = torch.arange(0, output_samples_in_unit, dtype=torch.get_default_dtype()) / new_freq
@@ -601,18 +604,18 @@ def _lcm(a, b):
 
 
 def _get_num_LR_output_samples(input_num_samp, samp_rate_in, samp_rate_out):
-    """ Based on LinearResample::GetNumOutputSamples. LinearResample (LR) means that
+    r"""Based on LinearResample::GetNumOutputSamples. LinearResample (LR) means that
     the output signal is at linearly spaced intervals (i.e the output signal has a
     frequency of `new_freq`). It uses sinc/bandlimited interpolation to upsample/downsample
     the signal.
 
     Args:
-        input_num_samp (int): the number of samples in the input
-        samp_rate_in (float): the original frequency of the signal
-        samp_rate_out (float): the desired frequency
+        input_num_samp (int): The number of samples in the input
+        samp_rate_in (float): The original frequency of the signal
+        samp_rate_out (float): The desired frequency
 
     Returns:
-        int: the number of output samples
+        int: The number of output samples
     """
     # For exact computation, we measure time in "ticks" of 1.0 / tick_freq,
     # where tick_freq is the least common multiple of samp_rate_in and
@@ -644,8 +647,8 @@ def _get_num_LR_output_samples(input_num_samp, samp_rate_in, samp_rate_out):
     return num_output_samp
 
 
-def resample_waveform(wave, orig_freq, new_freq, lowpass_filter_width=6):
-    r"""Resamples the wave at the new frequency. This matches Kaldi's OfflineFeatureTpl ResampleWaveform
+def resample_waveform(waveform, orig_freq, new_freq, lowpass_filter_width=6):
+    r"""Resamples the waveform at the new frequency. This matches Kaldi's OfflineFeatureTpl ResampleWaveform
     which uses a LinearResample (resample a signal at linearly spaced intervals to upsample/downsample
     a signal). LinearResample (LR) means that the output signal is at linearly spaced intervals (i.e
     the output signal has a frequency of `new_freq`). It uses sinc/bandlimited interpolation to
@@ -655,16 +658,16 @@ def resample_waveform(wave, orig_freq, new_freq, lowpass_filter_width=6):
     https://github.com/kaldi-asr/kaldi/blob/master/src/feat/resample.h#L56
 
     Args:
-        wave (Tensor): the input signal of size (c, n)
-        orig_freq (float): the original frequency of the signal
-        new_freq (float): the desired frequency
-        lowpass_filter_width (int): controls the sharpness of the filter, more == sharper
-            but less efficient. We suggest around 4 to 10 for normal use
+        waveform (torch.Tensor): The input signal of size (c, n)
+        orig_freq (float): The original frequency of the signal
+        new_freq (float): The desired frequency
+        lowpass_filter_width (int): Controls the sharpness of the filter, more == sharper
+            but less efficient. We suggest around 4 to 10 for normal use. (Default: 6)
 
     Returns:
-        Tensor: the signal at the new frequency
+        torch.Tensor: The signal at the new frequency
     """
-    assert wave.dim() == 2
+    assert waveform.dim() == 2
     assert orig_freq > 0.0 and new_freq > 0.0
 
     min_freq = min(orig_freq, new_freq)
@@ -687,13 +690,13 @@ def resample_waveform(wave, orig_freq, new_freq, lowpass_filter_width=6):
     # doing a conv1d for that specific weight.
     conv_stride = input_samples_in_unit
     conv_transpose_stride = output_samples_in_unit
-    num_channels, wave_len = wave.size()
+    num_channels, wave_len = waveform.size()
     window_size = weights.size(1)
     tot_output_samp = _get_num_LR_output_samples(wave_len, orig_freq, new_freq)
     output = torch.zeros((num_channels, tot_output_samp))
     eye = torch.eye(num_channels).unsqueeze(2)  # size (num_channels, num_channels, 1)
     for i in range(first_indices.size(0)):
-        wave_to_conv = wave
+        wave_to_conv = waveform
         first_index = int(first_indices[i].item())
         if first_index >= 0:
             # trim the signal as the filter will not be applied before the first_index

torchaudio/transforms.py

@@ -275,7 +275,7 @@ class MuLawEncoding(torch.jit.ScriptModule):
     returns a signal encoded with values from 0 to quantization_channels - 1
 
     Args:
-        quantization_channels (int): Number of channels. default: 256
+        quantization_channels (int): Number of channels (Default: 256)
     """
     __constants__ = ['quantization_channels']
 
@@ -303,7 +303,7 @@ class MuLawDecoding(torch.jit.ScriptModule):
     and returns a signal scaled between -1 and 1.
 
     Args:
-        quantization_channels (int): Number of channels. default: 256
+        quantization_channels (int): Number of channels (Default: 256)
     """
     __constants__ = ['quantization_channels']
 
@@ -328,10 +328,9 @@ class Resample(torch.nn.Module):
     be given.
 
     Args:
-        orig_freq (float): the original frequency of the signal
-        new_freq (float): the desired frequency
-        resampling_method (str): the resampling method (Default: 'kaldi' which uses
-            sinc interpolation)
+        orig_freq (float): The original frequency of the signal
+        new_freq (float): The desired frequency
+        resampling_method (str): The resampling method (Default: 'sinc_interpolation')
     """
     def __init__(self, orig_freq, new_freq, resampling_method='sinc_interpolation'):
         super(Resample, self).__init__()