torchaudio 2.8.0__cp311-cp311-win_amd64.whl → 2.9.0__cp311-cp311-win_amd64.whl

torchaudio/_torchcodec.py

@@ -17,28 +17,29 @@ def load_with_torchcodec(
     backend: Optional[str] = None,
 ) -> Tuple[torch.Tensor, int]:
     """Load audio data from source using TorchCodec's AudioDecoder.
-    
+
     .. note::
-        
+
         This function supports the same API as :func:`~torchaudio.load`, and
         relies on TorchCodec's decoding capabilities under the hood. It is
         provided for convenience, but we do recommend that you port your code to
         natively use ``torchcodec``'s ``AudioDecoder`` class for better
         performance:
         https://docs.pytorch.org/torchcodec/stable/generated/torchcodec.decoders.AudioDecoder.
-        In TorchAudio 2.9, :func:`~torchaudio.load` will be relying on
+        As of TorchAudio 2.9, :func:`~torchaudio.load` relies on
         :func:`~torchaudio.load_with_torchcodec`. Note that some parameters of
         :func:`~torchaudio.load`, like ``normalize``, ``buffer_size``, and
         ``backend``, are ignored by :func:`~torchaudio.load_with_torchcodec`.
-    
-    
+        To install torchcodec, follow the instructions at https://github.com/pytorch/torchcodec#installing-torchcodec.
+
+
     Args:
         uri (path-like object or file-like object):
             Source of audio data. The following types are accepted:
-            
+
             * ``path-like``: File path or URL.
             * ``file-like``: Object with ``read(size: int) -> bytes`` method.
-            
+
         frame_offset (int, optional):
             Number of samples to skip before start reading data.
         num_frames (int, optional):
@@ -58,17 +59,17 @@ def load_with_torchcodec(
             Not used by TorchCodec AudioDecoder. Provided for API compatibility.
         backend (str or None, optional):
             Not used by TorchCodec AudioDecoder. Provided for API compatibility.
-            
+
     Returns:
         (torch.Tensor, int): Resulting Tensor and sample rate.
         Always returns float32 tensors. If ``channels_first=True``, shape is
         `[channel, time]`, otherwise `[time, channel]`.
-        
+
     Raises:
         ImportError: If torchcodec is not available.
         ValueError: If unsupported parameters are used.
         RuntimeError: If TorchCodec fails to decode the audio.
-        
+
     Note:
         - TorchCodec always returns normalized float32 samples, so the ``normalize``
           parameter has no effect.
@@ -81,64 +82,55 @@ def load_with_torchcodec(
         from torchcodec.decoders import AudioDecoder
     except ImportError as e:
         raise ImportError(
-            "TorchCodec is required for load_with_torchcodec. "
-            "Please install torchcodec to use this function."
+            "TorchCodec is required for load_with_torchcodec. " "Please install torchcodec to use this function."
         ) from e
-    
+
     # Parameter validation and warnings
     if not normalize:
         import warnings
+
         warnings.warn(
             "TorchCodec AudioDecoder always returns normalized float32 samples. "
             "The 'normalize=False' parameter is ignored.",
             UserWarning,
-            stacklevel=2
+            stacklevel=2,
         )
-    
+
     if buffer_size != 4096:
         import warnings
-        warnings.warn(
-            "The 'buffer_size' parameter is not used by TorchCodec AudioDecoder.",
-            UserWarning,
-            stacklevel=2
-        )
-        
+
+        warnings.warn("The 'buffer_size' parameter is not used by TorchCodec AudioDecoder.", UserWarning, stacklevel=2)
+
     if backend is not None:
         import warnings
-        warnings.warn(
-            "The 'backend' parameter is not used by TorchCodec AudioDecoder.",
-            UserWarning,
-            stacklevel=2
-        )
-    
+
+        warnings.warn("The 'backend' parameter is not used by TorchCodec AudioDecoder.", UserWarning, stacklevel=2)
+
     if format is not None:
         import warnings
-        warnings.warn(
-            "The 'format' parameter is not supported by TorchCodec AudioDecoder.",
-            UserWarning,
-            stacklevel=2
-        )
-    
+
+        warnings.warn("The 'format' parameter is not supported by TorchCodec AudioDecoder.", UserWarning, stacklevel=2)
+
     # Create AudioDecoder
     try:
         decoder = AudioDecoder(uri)
     except Exception as e:
         raise RuntimeError(f"Failed to create AudioDecoder for {uri}: {e}") from e
-    
+
     # Get sample rate from metadata
     sample_rate = decoder.metadata.sample_rate
     if sample_rate is None:
         raise RuntimeError("Unable to determine sample rate from audio metadata")
-    
+
     # Decode the entire file first, then subsample manually
     # This is the simplest approach since torchcodec uses time-based indexing
     try:
         audio_samples = decoder.get_all_samples()
     except Exception as e:
         raise RuntimeError(f"Failed to decode audio samples: {e}") from e
-        
+
     data = audio_samples.data
-    
+
     # Apply frame_offset and num_frames (which are actually sample offsets)
     if frame_offset > 0:
         if frame_offset >= data.shape[1]:
@@ -146,19 +138,19 @@ def load_with_torchcodec(
             empty_shape = (data.shape[0], 0) if channels_first else (0, data.shape[0])
             return torch.zeros(empty_shape, dtype=torch.float32), sample_rate
         data = data[:, frame_offset:]
-    
+
     if num_frames == 0:
         # Return empty tensor if num_frames is 0
         empty_shape = (data.shape[0], 0) if channels_first else (0, data.shape[0])
         return torch.zeros(empty_shape, dtype=torch.float32), sample_rate
     elif num_frames > 0:
         data = data[:, :num_frames]
-    
+
     # TorchCodec returns data in [channel, time] format by default
     # Handle channels_first parameter
     if not channels_first:
         data = data.transpose(0, 1)  # [channel, time] -> [time, channel]
-    
+
     return data, sample_rate
 
 
@@ -177,70 +169,71 @@ def save_with_torchcodec(
     """Save audio data to file using TorchCodec's AudioEncoder.
 
     .. note::
-        
+
         This function supports the same API as :func:`~torchaudio.save`, and
         relies on TorchCodec's encoding capabilities under the hood. It is
         provided for convenience, but we do recommend that you port your code to
         natively use ``torchcodec``'s ``AudioEncoder`` class for better
         performance:
         https://docs.pytorch.org/torchcodec/stable/generated/torchcodec.encoders.AudioEncoder.
-        In TorchAudio 2.9, :func:`~torchaudio.save` will be relying on
+        As of TorchAudio 2.9, :func:`~torchaudio.save` relies on
         :func:`~torchaudio.save_with_torchcodec`. Note that some parameters of
         :func:`~torchaudio.save`, like ``format``, ``encoding``,
         ``bits_per_sample``, ``buffer_size``, and ``backend``, are ignored by
         are ignored by :func:`~torchaudio.save_with_torchcodec`.
-    
+        To install torchcodec, follow the instructions at https://github.com/pytorch/torchcodec#installing-torchcodec.
+
     This function provides a TorchCodec-based alternative to torchaudio.save
     with the same API. TorchCodec's AudioEncoder provides efficient encoding
     with FFmpeg under the hood.
-    
+
     Args:
         uri (path-like object):
             Path to save the audio file. The file extension determines the format.
-            
+
         src (torch.Tensor):
             Audio data to save. Must be a 1D or 2D tensor with float32 values
             in the range [-1, 1]. If 2D, shape should be [channel, time] when
             channels_first=True, or [time, channel] when channels_first=False.
-            
+
         sample_rate (int):
             Sample rate of the audio data.
-            
+
         channels_first (bool, optional):
             Indicates whether the input tensor has channels as the first dimension.
             If True, expects [channel, time]. If False, expects [time, channel].
             Default: True.
-            
+
         format (str or None, optional):
             Audio format hint. Not used by TorchCodec (format is determined by
             file extension). A warning is issued if provided.
             Default: None.
-            
+
         encoding (str or None, optional):
             Audio encoding. Not fully supported by TorchCodec AudioEncoder.
             A warning is issued if provided. Default: None.
-            
+
         bits_per_sample (int or None, optional):
             Bits per sample. Not directly supported by TorchCodec AudioEncoder.
             A warning is issued if provided. Default: None.
-            
+
         buffer_size (int, optional):
             Not used by TorchCodec AudioEncoder. Provided for API compatibility.
             A warning is issued if not default value. Default: 4096.
-            
+
         backend (str or None, optional):
             Not used by TorchCodec AudioEncoder. Provided for API compatibility.
             A warning is issued if provided. Default: None.
-            
+
         compression (float, int or None, optional):
             Compression level or bit rate. Maps to bit_rate parameter in
             TorchCodec AudioEncoder. Default: None.
-            
+
     Raises:
         ImportError: If torchcodec is not available.
         ValueError: If input parameters are invalid.
         RuntimeError: If TorchCodec fails to encode the audio.
-        
+
     Note:
         - TorchCodec AudioEncoder expects float32 samples in [-1, 1] range.
         - Some parameters (format, encoding, bits_per_sample, buffer_size, backend)
@@ -253,62 +246,56 @@ def save_with_torchcodec(
         from torchcodec.encoders import AudioEncoder
     except ImportError as e:
         raise ImportError(
-            "TorchCodec is required for save_with_torchcodec. "
-            "Please install torchcodec to use this function."
+            "TorchCodec is required for save_with_torchcodec. " "Please install torchcodec to use this function."
         ) from e
-    
+
     # Parameter validation and warnings
     if format is not None:
         import warnings
+
         warnings.warn(
             "The 'format' parameter is not used by TorchCodec AudioEncoder. "
             "Format is determined by the file extension.",
             UserWarning,
-            stacklevel=2
+            stacklevel=2,
         )
-    
+
     if encoding is not None:
         import warnings
+
         warnings.warn(
-            "The 'encoding' parameter is not fully supported by TorchCodec AudioEncoder.",
-            UserWarning,
-            stacklevel=2
+            "The 'encoding' parameter is not fully supported by TorchCodec AudioEncoder.", UserWarning, stacklevel=2
         )
-    
+
     if bits_per_sample is not None:
         import warnings
+
         warnings.warn(
             "The 'bits_per_sample' parameter is not directly supported by TorchCodec AudioEncoder.",
             UserWarning,
-            stacklevel=2
+            stacklevel=2,
         )
-    
+
     if buffer_size != 4096:
         import warnings
-        warnings.warn(
-            "The 'buffer_size' parameter is not used by TorchCodec AudioEncoder.",
-            UserWarning,
-            stacklevel=2
-        )
-        
+
+        warnings.warn("The 'buffer_size' parameter is not used by TorchCodec AudioEncoder.", UserWarning, stacklevel=2)
+
     if backend is not None:
         import warnings
-        warnings.warn(
-            "The 'backend' parameter is not used by TorchCodec AudioEncoder.",
-            UserWarning,
-            stacklevel=2
-        )
-    
+
+        warnings.warn("The 'backend' parameter is not used by TorchCodec AudioEncoder.", UserWarning, stacklevel=2)
+
     # Input validation
     if not isinstance(src, torch.Tensor):
         raise ValueError(f"Expected src to be a torch.Tensor, got {type(src)}")
-    
+
     if src.dtype != torch.float32:
         src = src.float()
-    
+
     if sample_rate <= 0:
         raise ValueError(f"sample_rate must be positive, got {sample_rate}")
-    
+
     # Handle tensor shape and channels_first
     if src.ndim == 1:
         # Convert to 2D: [1, time] for channels_first=True
@@ -324,13 +311,13 @@ def save_with_torchcodec(
             data = src.transpose(0, 1)  # [time, channel] -> [channel, time]
     else:
         raise ValueError(f"Expected 1D or 2D tensor, got {src.ndim}D tensor")
-    
+
     # Create AudioEncoder
     try:
         encoder = AudioEncoder(data, sample_rate=sample_rate)
     except Exception as e:
         raise RuntimeError(f"Failed to create AudioEncoder: {e}") from e
-    
+
     # Determine bit_rate from compression parameter
     bit_rate = None
     if compression is not None:
@@ -338,13 +325,14 @@ def save_with_torchcodec(
             bit_rate = int(compression)
         else:
             import warnings
+
             warnings.warn(
                 f"Unsupported compression type {type(compression)}. "
                 "TorchCodec AudioEncoder expects int or float for bit_rate.",
                 UserWarning,
-                stacklevel=2
+                stacklevel=2,
             )
-    
+
     # Save to file
     try:
         encoder.to_file(uri, bit_rate=bit_rate)

torchaudio/datasets/cmuarctic.py

@@ -129,7 +129,7 @@ class CMUARCTIC(Dataset):
         self._text = os.path.join(self._path, self._folder_text, self._file_text)
 
         with open(self._text, "r") as text:
-            walker = csv.reader(text, delimiter="\n")
+            walker = csv.reader(text)
             self._walker = list(walker)
 
     def __getitem__(self, n: int) -> Tuple[Tensor, int, str, str]:

torchaudio/datasets/utils.py

@@ -2,7 +2,7 @@ import logging
 import os
 import tarfile
 import zipfile
-from typing import Any, List, Optional
+from typing import Any, List, Optional  # noqa: F401
 
 import torchaudio
 

torchaudio/functional/__init__.py

@@ -32,7 +32,6 @@ from .functional import (
     add_noise,
     amplitude_to_DB,
     apply_beamforming,
-    apply_codec,
     compute_deltas,
     convolve,
     create_dct,
@@ -111,7 +110,6 @@ __all__ = [
     "riaa_biquad",
     "treble_biquad",
     "vad",
-    "apply_codec",
     "resample",
     "edit_distance",
     "pitch_shift",

torchaudio/functional/_alignment.py

@@ -70,7 +70,7 @@ def forced_align(
     assert target_lengths is not None
 
     paths, scores = torch.ops.torchaudio.forced_align(log_probs, targets, input_lengths, target_lengths, blank)
-    return paths, scores
+    return paths, scores[:, torch.arange(scores.shape[1]), paths[0]]
 
 
 @dataclass

torchaudio/functional/filtering.py

@@ -3,6 +3,7 @@ import warnings
 from typing import Optional
 
 import torch
+import torch.nn.functional as F
 from torch import Tensor
 
 from torchaudio._extension import _IS_TORCHAUDIO_EXT_AVAILABLE
@@ -932,69 +933,83 @@ def _lfilter_core_generic_loop(input_signal_windows: Tensor, a_coeffs_flipped: T
 
 
 if _IS_TORCHAUDIO_EXT_AVAILABLE:
-    _lfilter_core_cpu_loop = torch.ops.torchaudio._lfilter_core_loop
+    _lfilter_core_loop = torch.ops.torchaudio._lfilter_core_loop
 else:
-    _lfilter_core_cpu_loop = _lfilter_core_generic_loop
+    _lfilter_core_loop = _lfilter_core_generic_loop
+
+
+class DifferentiableFIR(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, waveform, b_coeffs):
+        n_order = b_coeffs.size(1)
+        n_channel = b_coeffs.size(0)
+        b_coeff_flipped = b_coeffs.flip(1).contiguous()
+        padded_waveform = F.pad(waveform, (n_order - 1, 0))
+        output = F.conv1d(padded_waveform, b_coeff_flipped.unsqueeze(1), groups=n_channel)
+        ctx.save_for_backward(waveform, b_coeffs, output)
+        return output
+
+    @staticmethod
+    def backward(ctx, dy):
+        x, b_coeffs, y = ctx.saved_tensors
+        n_batch = x.size(0)
+        n_channel = x.size(1)
+        n_order = b_coeffs.size(1)
+        db = (
+            F.conv1d(
+                F.pad(x, (n_order - 1, 0)).view(1, n_batch * n_channel, -1),
+                dy.view(n_batch * n_channel, 1, -1),
+                groups=n_batch * n_channel,
+            )
+            .view(n_batch, n_channel, -1)
+            .sum(0)
+            .flip(1)
+            if b_coeffs.requires_grad
+            else None
+        )
+        dx = F.conv1d(F.pad(dy, (0, n_order - 1)), b_coeffs.unsqueeze(1), groups=n_channel) if x.requires_grad else None
+        return (dx, db)
 
 
-def _lfilter_core(
-    waveform: Tensor,
-    a_coeffs: Tensor,
-    b_coeffs: Tensor,
-) -> Tensor:
+class DifferentiableIIR(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, waveform, a_coeffs_normalized):
+        n_batch, n_channel, n_sample = waveform.shape
+        n_order = a_coeffs_normalized.size(1)
+        n_sample_padded = n_sample + n_order - 1
 
-    if a_coeffs.size() != b_coeffs.size():
-        raise ValueError(
-            "Expected coeffs to be the same size."
-            f"Found a_coeffs size: {a_coeffs.size()}, b_coeffs size: {b_coeffs.size()}"
+        a_coeff_flipped = a_coeffs_normalized.flip(1).contiguous()
+        padded_output_waveform = torch.zeros(
+            n_batch, n_channel, n_sample_padded, device=waveform.device, dtype=waveform.dtype
         )
-    if waveform.ndim != 3:
-        raise ValueError(f"Expected waveform to be 3 dimensional. Found: {waveform.ndim}")
-    if not (waveform.device == a_coeffs.device == b_coeffs.device):
-        raise ValueError(
-            "Expected waveform and coeffs to be on the same device."
-            f"Found: waveform device:{waveform.device}, a_coeffs device: {a_coeffs.device}, "
-            f"b_coeffs device: {b_coeffs.device}"
+        _lfilter_core_loop(waveform, a_coeff_flipped, padded_output_waveform)
+        output = padded_output_waveform[:, :, n_order - 1 :]
+        ctx.save_for_backward(waveform, a_coeffs_normalized, output)
+        return output
+
+    @staticmethod
+    def backward(ctx, dy):
+        x, a_coeffs_normalized, y = ctx.saved_tensors
+        n_channel = x.size(1)
+        n_order = a_coeffs_normalized.size(1)
+        tmp = DifferentiableIIR.apply(dy.flip(2).contiguous(), a_coeffs_normalized).flip(2)
+        dx = tmp if x.requires_grad else None
+        da = (
+            -(
+                tmp.transpose(0, 1).reshape(n_channel, 1, -1)
+                @ F.pad(y, (n_order - 1, 0)).unfold(2, n_order, 1).transpose(0, 1).reshape(n_channel, -1, n_order)
+            )
+            .squeeze(1)
+            .flip(1)
+            if a_coeffs_normalized.requires_grad
+            else None
         )
+        return (dx, da)
 
-    n_batch, n_channel, n_sample = waveform.size()
-    n_order = a_coeffs.size(1)
-    if n_order <= 0:
-        raise ValueError(f"Expected n_order to be positive. Found: {n_order}")
-
-    # Pad the input and create output
 
-    padded_waveform = torch.nn.functional.pad(waveform, [n_order - 1, 0])
-    padded_output_waveform = torch.zeros_like(padded_waveform)
-
-    # Set up the coefficients matrix
-    # Flip coefficients' order
-    a_coeffs_flipped = a_coeffs.flip(1)
-    b_coeffs_flipped = b_coeffs.flip(1)
-
-    # calculate windowed_input_signal in parallel using convolution
-    input_signal_windows = torch.nn.functional.conv1d(padded_waveform, b_coeffs_flipped.unsqueeze(1), groups=n_channel)
-
-    input_signal_windows.div_(a_coeffs[:, :1])
-    a_coeffs_flipped.div_(a_coeffs[:, :1])
-
-    if (
-        input_signal_windows.device == torch.device("cpu")
-        and a_coeffs_flipped.device == torch.device("cpu")
-        and padded_output_waveform.device == torch.device("cpu")
-    ):
-        _lfilter_core_cpu_loop(input_signal_windows, a_coeffs_flipped, padded_output_waveform)
-    else:
-        _lfilter_core_generic_loop(input_signal_windows, a_coeffs_flipped, padded_output_waveform)
-
-    output = padded_output_waveform[:, :, n_order - 1 :]
-    return output
-
-
-if _IS_TORCHAUDIO_EXT_AVAILABLE:
-    _lfilter = torch.ops.torchaudio._lfilter
-else:
-    _lfilter = _lfilter_core
+def _lfilter(waveform, a_coeffs, b_coeffs):
+    filtered_waveform = DifferentiableFIR.apply(waveform, b_coeffs / a_coeffs[:, 0:1])
+    return DifferentiableIIR.apply(filtered_waveform, a_coeffs / a_coeffs[:, 0:1])
 
 
 def lfilter(waveform: Tensor, a_coeffs: Tensor, b_coeffs: Tensor, clamp: bool = True, batching: bool = True) -> Tensor: