torch-l1-snr 0.0.1__tar.gz

torch_l1_snr-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Christopher Landschoot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

torch_l1_snr-0.0.1/PKG-INFO

@@ -0,0 +1,201 @@
+Metadata-Version: 2.4
+Name: torch-l1-snr
+Version: 0.0.1
+Summary: L1-SNR loss functions for audio source separation in PyTorch
+Home-page: https://github.com/crlandsc/torch-l1-snr
+Author: Christopher Landscaping
+Author-email: crlandschoot@gmail.com
+License: MIT
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch
+Requires-Dist: torchaudio
+Requires-Dist: numpy>=1.21.0
+Dynamic: license-file
+
+![torch-l1-snr-logo](https://raw.githubusercontent.com/crlandsc/torch-l1-snr/main/images/logo.png) -->
+
+# NOTE: Repo is currently a work-in-progress and not ready for installation & use.
+
+[![LICENSE](https://img.shields.io/github/license/crlandsc/torch-l1snr)](https://github.com/crlandsc/torch-l1snr/blob/main/LICENSE) [![GitHub Repo stars](https://img.shields.io/github/stars/crlandsc/torch-l1snr)](https://github.com/crlandsc/torch-l1snr/stargazers)
+
+# torch-l1-snr
+
+A PyTorch implementation of L1-based Signal-to-Noise Ratio (SNR) loss functions for audio source separation. This package provides implementations and novel extensions based on concepts from recent academic papers, offering flexible and robust loss functions that can be easily integrated into any PyTorch-based audio separation pipeline.
+
+The core `L1SNRLoss` is based on the loss function described in [1], while `L1SNRDBLoss` and `STFTL1SNRDBLoss` are extensions of the adaptive level-matching regularization technique proposed in [2].
+
+## Features
+
+- **Time-Domain L1SNR Loss**: A basic, time-domain L1-SNR loss, based on [1].
+- **Regularized Time-Domain L1SNRDBLoss**: An extension of the L1SNR loss with adaptive level-matching regularization from [2], plus an optional L1 loss component.
+- **Multi-Resolution STFT L1SNRDBLoss**: A spectrogram-domain version of the loss from [2], calculated over multiple STFT resolutions.
+- **Modular Stem-based Loss**: A wrapper that combines time and spectrogram domain losses and can be configured to run on specific stems.
+- **Efficient & Robust**: Includes optimizations for pure L1 loss calculation and robust handling of `NaN`/`inf` values and short audio segments.
+
+## Installation
+
+<!-- Add PyPI badges once the package is published -->
+<!-- [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/torch-l1snr)](https://pypi.org/project/torch-l1snr/) -->
+<!-- [![PyPI - Version](https://img.shields.io/pypi/v/torch-l1snr)](https://pypi.org/project/torch-l1snr/) -->
+<!-- [![Number of downloads from PyPI per month](https://img.shields.io/pypi/dm/torch-l1snr)](https://pypi.org/project/torch-l1snr/) -->
+
+You can install the package directly from GitHub:
+
+```bash
+pip install git+https://github.com/crlandsc/torch-l1snr.git
+```
+
+Or, you can clone the repository and install it in editable mode for development:
+
+```bash
+git clone https://github.com/crlandsc/torch-l1snr.git
+cd torch-l1snr
+pip install -e .
+```
+
+## Dependencies
+
+- [PyTorch](https://pytorch.org/)
+- [torchaudio](https://pytorch.org/audio/stable/index.html)
+
+## Supported Tensor Shapes
+
+All loss functions in this package (`L1SNRLoss`, `L1SNRDBLoss`, `STFTL1SNRDBLoss`, and `MultiL1SNRDBLoss`) accept standard audio tensors of shape `(batch, samples)` or `(batch, channels, samples)`. For 3D tensors, the channel and sample dimensions are flattened before the time-domain losses are calculated. For the spectrogram-domain loss, a separate STFT is computed for each channel.
+
+## Usage
+
+The loss functions can be imported directly from the `torch_l1snr` package.
+
+### Example: `L1SNRDBLoss` (Time Domain)
+
+```python
+import torch
+from torch_l1snr import L1SNRDBLoss
+
+# Create dummy audio signals
+estimates = torch.randn(4, 32000)  # Batch of 4, 32000 samples
+actuals = torch.randn(4, 32000)
+
+# Initialize the loss function
+# l1_weight=0.1 blends L1SNR with 10% L1 loss
+loss_fn = L1SNRDBLoss(l1_weight=0.1)
+
+# Calculate loss
+loss = loss_fn(estimates, actuals)
+loss.backward()
+
+print(f"L1SNRDBLoss: {loss.item()}")
+```
+
+### Example: `STFTL1SNRDBLoss` (Spectrogram Domain)
+
+```python
+import torch
+from torch_l1snr import STFTL1SNRDBLoss
+
+# Create dummy audio signals
+estimates = torch.randn(4, 32000)
+actuals = torch.randn(4, 32000)
+
+# Initialize the loss function
+# Uses multiple STFT resolutions by default
+loss_fn = STFTL1SNRDBLoss(l1_weight=0.0) # Pure L1SNR + Regularization
+
+# Calculate loss
+loss = loss_fn(estimates, actuals)
+loss.backward()
+
+print(f"STFTL1SNRDBLoss: {loss.item()}")
+```
+
+### Example: `MultiL1SNRDBLoss` for a Combined Time+Spectrogram Loss
+
+This loss combines the time-domain and spectrogram-domain losses into a single, weighted objective function.
+
+```python
+import torch
+from torch_l1snr import MultiL1SNRDBLoss
+
+# Create dummy audio signals
+# Shape: (batch, channels, samples)
+estimates = torch.randn(2, 2, 44100) # Batch of 2, stereo
+actuals = torch.randn(2, 2, 44100)
+
+# --- Configuration ---
+loss_fn = MultiL1SNRDBLoss(
+    weight=1.0,               # Overall weight for this loss
+    spec_weight=0.7,          # 70% spectrogram loss, 30% time-domain loss
+    l1_weight=0.1,           # Use 10% L1, 90% L1SNR+Reg
+)
+loss = loss_fn(estimates, actuals)
+print(f"Multi-domain Loss: {loss.item()}")
+```
+
+## Motivation
+
+The goal of these loss functions is to provide a perceptually-informed and robust alternative to common audio losses like L1, L2 (MSE), and SI-SDR for training audio source separation models.
+
+- **Robustness**: The L1 norm is less sensitive to large outliers than the L2 norm, making it more suitable for audio signals which can have sharp transients.
+- **Perceptual Relevance**: The loss is scaled to decibels (dB), which more closely aligns with human perception of loudness.
+- **Adaptive Regularization**: Prevents the model from collapsing to silent outputs by penalizing mismatches in the overall loudness (dBRMS) between the estimate and the target.
+
+#### Level-Matching Regularization
+
+A key feature of `L1SNRDBLoss` is the adaptive regularization term, as described in [2]. This component calculates the difference in decibel-scaled root-mean-square (dBRMS) levels between the estimated and actual signals. An adaptive weight (`lambda`) is applied to this difference, which increases when the model incorrectly silences a non-silent target. This encourages the model to learn the correct output level and specifically avoids the model collapsing to a trivial silent solution when uncertain.
+
+#### Multi-Resolution Spectrogram Analysis
+
+The `STFTL1SNRDBLoss` module applies the L1SNRDB loss across multiple time-frequency resolutions. By analyzing the signal with different STFT window sizes and hop lengths, the loss function can capture a wider range of artifacts—from short, transient errors to longer, tonal discrepancies. This provides a more comprehensive error signal to the model during training.
+
+#### "All-or-Nothing" Behavior and `l1_weight`
+
+A characteristic of SNR-style losses is that they encourage the model to make definitive, "all-or-nothing" separation decisions. This can be highly effective for well-defined sources, as it pushes the model to be confident in its estimations. However, this can also lead to "confident errors," where the model completely removes a signal component it should have kept.
+
+While the Level-Matching Regularization prevents a *total collapse to silence*, it does not by itself solve this issue of overly confident, hard-boundary separation. To provide a tunable solution, this implementation introduces a novel `l1_weight` hyperparameter. This allows you to create a hybrid loss, blending the decisive L1SNR objective with a standard L1 loss to soften its "all-or-nothing"-style behavior and allow for more nuanced separation.
+
+-   `l1_weight=0.0` (Default): Pure L1SNR (+ regularization).
+-   `l1_weight=1.0`: Pure L1 loss.
+-   `0.0 < l1_weight < 1.0`: A weighted combination of the two.
+
+The implementation is optimized for efficiency: if `l1_weight` is `0.0` or `1.0`, the unused loss component is not computed, saving computational resources.
+
+**Note on Gradient Balancing:** When blending losses (`0.0 < l1_weight < 1.0`), you may need to tune `l1_scale_time` and `l1_scale_spec`. This is to ensure the gradients of the L1 and L1SNR components are balanced, which is crucial for stable training. The default values provide a reasonable starting point, but monitoring the loss components is recommended to ensure they are scaled appropriately.
+
+## Limitations
+
+- The L1SNR loss is not scale-invariant. Unlike SI-SNR, it requires the model's output to be correctly scaled relative to the target.
+- While the dB scaling and regularization are psychoacoustically motivated, the loss does not model more complex perceptual phenomena like auditory masking.
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request if you have any improvements or new features to suggest.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+The loss functions implemented here are based on the work of the authors of the referenced papers.
+
+## References
+
+[1] K. N. Watcharasupat, C.-W. Wu, Y. Ding, I. Orife, A. J. Hipple, P. A. Williams, S. Kramer, A. Lerch, and W. Wolcott, "A Generalized Bandsplit Neural Network for Cinematic Audio Source Separation," IEEE Open Journal of Signal Processing, 2023. (arXiv:2309.02539)
+
+[2] K. N. Watcharasupat and A. Lerch, "Separate This, and All of these Things Around It: Music Source Separation via Hyperellipsoidal Queries," arXiv:2501.16171.
+
+[3] K. N. Watcharasupat and A. Lerch, "A Stem-Agnostic Single-Decoder System for Music Source Separation Beyond Four Stems," Proceedings of the 25th International Society for Music Information Retrieval Conference, 2024. (arXiv:2406.18747) 

torch_l1_snr-0.0.1/README.md

@@ -0,0 +1,173 @@
+![torch-l1-snr-logo](https://raw.githubusercontent.com/crlandsc/torch-l1-snr/main/images/logo.png) -->
+
+# NOTE: Repo is currently a work-in-progress and not ready for installation & use.
+
+[![LICENSE](https://img.shields.io/github/license/crlandsc/torch-l1snr)](https://github.com/crlandsc/torch-l1snr/blob/main/LICENSE) [![GitHub Repo stars](https://img.shields.io/github/stars/crlandsc/torch-l1snr)](https://github.com/crlandsc/torch-l1snr/stargazers)
+
+# torch-l1-snr
+
+A PyTorch implementation of L1-based Signal-to-Noise Ratio (SNR) loss functions for audio source separation. This package provides implementations and novel extensions based on concepts from recent academic papers, offering flexible and robust loss functions that can be easily integrated into any PyTorch-based audio separation pipeline.
+
+The core `L1SNRLoss` is based on the loss function described in [1], while `L1SNRDBLoss` and `STFTL1SNRDBLoss` are extensions of the adaptive level-matching regularization technique proposed in [2].
+
+## Features
+
+- **Time-Domain L1SNR Loss**: A basic, time-domain L1-SNR loss, based on [1].
+- **Regularized Time-Domain L1SNRDBLoss**: An extension of the L1SNR loss with adaptive level-matching regularization from [2], plus an optional L1 loss component.
+- **Multi-Resolution STFT L1SNRDBLoss**: A spectrogram-domain version of the loss from [2], calculated over multiple STFT resolutions.
+- **Modular Stem-based Loss**: A wrapper that combines time and spectrogram domain losses and can be configured to run on specific stems.
+- **Efficient & Robust**: Includes optimizations for pure L1 loss calculation and robust handling of `NaN`/`inf` values and short audio segments.
+
+## Installation
+
+<!-- Add PyPI badges once the package is published -->
+<!-- [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/torch-l1snr)](https://pypi.org/project/torch-l1snr/) -->
+<!-- [![PyPI - Version](https://img.shields.io/pypi/v/torch-l1snr)](https://pypi.org/project/torch-l1snr/) -->
+<!-- [![Number of downloads from PyPI per month](https://img.shields.io/pypi/dm/torch-l1snr)](https://pypi.org/project/torch-l1snr/) -->
+
+You can install the package directly from GitHub:
+
+```bash
+pip install git+https://github.com/crlandsc/torch-l1snr.git
+```
+
+Or, you can clone the repository and install it in editable mode for development:
+
+```bash
+git clone https://github.com/crlandsc/torch-l1snr.git
+cd torch-l1snr
+pip install -e .
+```
+
+## Dependencies
+
+- [PyTorch](https://pytorch.org/)
+- [torchaudio](https://pytorch.org/audio/stable/index.html)
+
+## Supported Tensor Shapes
+
+All loss functions in this package (`L1SNRLoss`, `L1SNRDBLoss`, `STFTL1SNRDBLoss`, and `MultiL1SNRDBLoss`) accept standard audio tensors of shape `(batch, samples)` or `(batch, channels, samples)`. For 3D tensors, the channel and sample dimensions are flattened before the time-domain losses are calculated. For the spectrogram-domain loss, a separate STFT is computed for each channel.
+
+## Usage
+
+The loss functions can be imported directly from the `torch_l1snr` package.
+
+### Example: `L1SNRDBLoss` (Time Domain)
+
+```python
+import torch
+from torch_l1snr import L1SNRDBLoss
+
+# Create dummy audio signals
+estimates = torch.randn(4, 32000)  # Batch of 4, 32000 samples
+actuals = torch.randn(4, 32000)
+
+# Initialize the loss function
+# l1_weight=0.1 blends L1SNR with 10% L1 loss
+loss_fn = L1SNRDBLoss(l1_weight=0.1)
+
+# Calculate loss
+loss = loss_fn(estimates, actuals)
+loss.backward()
+
+print(f"L1SNRDBLoss: {loss.item()}")
+```
+
+### Example: `STFTL1SNRDBLoss` (Spectrogram Domain)
+
+```python
+import torch
+from torch_l1snr import STFTL1SNRDBLoss
+
+# Create dummy audio signals
+estimates = torch.randn(4, 32000)
+actuals = torch.randn(4, 32000)
+
+# Initialize the loss function
+# Uses multiple STFT resolutions by default
+loss_fn = STFTL1SNRDBLoss(l1_weight=0.0) # Pure L1SNR + Regularization
+
+# Calculate loss
+loss = loss_fn(estimates, actuals)
+loss.backward()
+
+print(f"STFTL1SNRDBLoss: {loss.item()}")
+```
+
+### Example: `MultiL1SNRDBLoss` for a Combined Time+Spectrogram Loss
+
+This loss combines the time-domain and spectrogram-domain losses into a single, weighted objective function.
+
+```python
+import torch
+from torch_l1snr import MultiL1SNRDBLoss
+
+# Create dummy audio signals
+# Shape: (batch, channels, samples)
+estimates = torch.randn(2, 2, 44100) # Batch of 2, stereo
+actuals = torch.randn(2, 2, 44100)
+
+# --- Configuration ---
+loss_fn = MultiL1SNRDBLoss(
+    weight=1.0,               # Overall weight for this loss
+    spec_weight=0.7,          # 70% spectrogram loss, 30% time-domain loss
+    l1_weight=0.1,           # Use 10% L1, 90% L1SNR+Reg
+)
+loss = loss_fn(estimates, actuals)
+print(f"Multi-domain Loss: {loss.item()}")
+```
+
+## Motivation
+
+The goal of these loss functions is to provide a perceptually-informed and robust alternative to common audio losses like L1, L2 (MSE), and SI-SDR for training audio source separation models.
+
+- **Robustness**: The L1 norm is less sensitive to large outliers than the L2 norm, making it more suitable for audio signals which can have sharp transients.
+- **Perceptual Relevance**: The loss is scaled to decibels (dB), which more closely aligns with human perception of loudness.
+- **Adaptive Regularization**: Prevents the model from collapsing to silent outputs by penalizing mismatches in the overall loudness (dBRMS) between the estimate and the target.
+
+#### Level-Matching Regularization
+
+A key feature of `L1SNRDBLoss` is the adaptive regularization term, as described in [2]. This component calculates the difference in decibel-scaled root-mean-square (dBRMS) levels between the estimated and actual signals. An adaptive weight (`lambda`) is applied to this difference, which increases when the model incorrectly silences a non-silent target. This encourages the model to learn the correct output level and specifically avoids the model collapsing to a trivial silent solution when uncertain.
+
+#### Multi-Resolution Spectrogram Analysis
+
+The `STFTL1SNRDBLoss` module applies the L1SNRDB loss across multiple time-frequency resolutions. By analyzing the signal with different STFT window sizes and hop lengths, the loss function can capture a wider range of artifacts—from short, transient errors to longer, tonal discrepancies. This provides a more comprehensive error signal to the model during training.
+
+#### "All-or-Nothing" Behavior and `l1_weight`
+
+A characteristic of SNR-style losses is that they encourage the model to make definitive, "all-or-nothing" separation decisions. This can be highly effective for well-defined sources, as it pushes the model to be confident in its estimations. However, this can also lead to "confident errors," where the model completely removes a signal component it should have kept.
+
+While the Level-Matching Regularization prevents a *total collapse to silence*, it does not by itself solve this issue of overly confident, hard-boundary separation. To provide a tunable solution, this implementation introduces a novel `l1_weight` hyperparameter. This allows you to create a hybrid loss, blending the decisive L1SNR objective with a standard L1 loss to soften its "all-or-nothing"-style behavior and allow for more nuanced separation.
+
+-   `l1_weight=0.0` (Default): Pure L1SNR (+ regularization).
+-   `l1_weight=1.0`: Pure L1 loss.
+-   `0.0 < l1_weight < 1.0`: A weighted combination of the two.
+
+The implementation is optimized for efficiency: if `l1_weight` is `0.0` or `1.0`, the unused loss component is not computed, saving computational resources.
+
+**Note on Gradient Balancing:** When blending losses (`0.0 < l1_weight < 1.0`), you may need to tune `l1_scale_time` and `l1_scale_spec`. This is to ensure the gradients of the L1 and L1SNR components are balanced, which is crucial for stable training. The default values provide a reasonable starting point, but monitoring the loss components is recommended to ensure they are scaled appropriately.
+
+## Limitations
+
+- The L1SNR loss is not scale-invariant. Unlike SI-SNR, it requires the model's output to be correctly scaled relative to the target.
+- While the dB scaling and regularization are psychoacoustically motivated, the loss does not model more complex perceptual phenomena like auditory masking.
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request if you have any improvements or new features to suggest.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+The loss functions implemented here are based on the work of the authors of the referenced papers.
+
+## References
+
+[1] K. N. Watcharasupat, C.-W. Wu, Y. Ding, I. Orife, A. J. Hipple, P. A. Williams, S. Kramer, A. Lerch, and W. Wolcott, "A Generalized Bandsplit Neural Network for Cinematic Audio Source Separation," IEEE Open Journal of Signal Processing, 2023. (arXiv:2309.02539)
+
+[2] K. N. Watcharasupat and A. Lerch, "Separate This, and All of these Things Around It: Music Source Separation via Hyperellipsoidal Queries," arXiv:2501.16171.
+
+[3] K. N. Watcharasupat and A. Lerch, "A Stem-Agnostic Single-Decoder System for Music Source Separation Beyond Four Stems," Proceedings of the 25th International Society for Music Information Retrieval Conference, 2024. (arXiv:2406.18747) 

torch_l1_snr-0.0.1/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta" 

torch_l1_snr-0.0.1/setup.cfg

@@ -0,0 +1,36 @@
+[metadata]
+name = torch-l1-snr
+version = 0.0.1
+author = Christopher Landscaping
+author_email = crlandschoot@gmail.com
+description = L1-SNR loss functions for audio source separation in PyTorch
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://github.com/crlandsc/torch-l1-snr
+license = MIT
+classifiers = 
+	Intended Audience :: Developers
+	Intended Audience :: Science/Research
+	License :: OSI Approved :: MIT License
+	Programming Language :: Python :: 3
+	Programming Language :: Python :: 3.8
+	Programming Language :: Python :: 3.9
+	Programming Language :: Python :: 3.10
+	Programming Language :: Python :: 3.11
+	Programming Language :: Python :: 3.12
+	Operating System :: OS Independent
+	Topic :: Scientific/Engineering :: Artificial Intelligence
+	Topic :: Multimedia :: Sound/Audio :: Analysis
+
+[options]
+packages = find:
+python_requires = >=3.8
+install_requires = 
+	torch
+	torchaudio
+	numpy>=1.21.0
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

torch_l1_snr-0.0.1/tests/test_losses.py

@@ -0,0 +1,143 @@
+import torch
+import pytest
+from torch_l1snr import (
+    dbrms,
+    L1SNRLoss,
+    L1SNRDBLoss,
+    STFTL1SNRDBLoss,
+    MultiL1SNRDBLoss,
+)
+
+# --- Test Fixtures ---
+@pytest.fixture
+def dummy_audio():
+    """Provides a batch of dummy audio signals."""
+    estimates = torch.randn(2, 16000)
+    actuals = torch.randn(2, 16000)
+    # Ensure actuals are not all zero to avoid division by zero in loss
+    actuals[0, :100] += 0.1 
+    return estimates, actuals
+
+@pytest.fixture
+def dummy_stems():
+    """Provides a batch of dummy multi-stem signals."""
+    estimates = torch.randn(2, 4, 1, 16000) # batch, stems, channels, samples
+    actuals = torch.randn(2, 4, 1, 16000)
+    actuals[:, 0, :, :100] += 0.1 # Ensure not all zero
+    return estimates, actuals
+
+# --- Test Functions ---
+
+def test_dbrms():
+    signal = torch.ones(2, 1000) * 0.1
+    # RMS of 0.1 is -20 dB
+    assert torch.allclose(dbrms(signal), torch.tensor([-20.0, -20.0]), atol=1e-4)
+    
+    zeros = torch.zeros(2, 1000)
+    # dbrms of zero should be -80dB with default eps=1e-8
+    assert torch.allclose(dbrms(zeros), torch.tensor([-80.0, -80.0]), atol=1e-4)
+
+def test_l1snr_loss(dummy_audio):
+    estimates, actuals = dummy_audio
+    loss_fn = L1SNRLoss(name="test")
+    loss = loss_fn(estimates, actuals)
+    
+    assert isinstance(loss, torch.Tensor)
+    assert loss.ndim == 0
+    assert not torch.isnan(loss)
+    assert not torch.isinf(loss)
+
+def test_l1snrdb_loss_time(dummy_audio):
+    estimates, actuals = dummy_audio
+    
+    # Test with default settings (L1SNR + Regularization)
+    loss_fn = L1SNRDBLoss(name="test", use_regularization=True, l1_weight=0.0)
+    loss = loss_fn(estimates, actuals)
+    assert loss.ndim == 0 and not torch.isnan(loss)
+
+    # Test without regularization
+    loss_fn_no_reg = L1SNRDBLoss(name="test_no_reg", use_regularization=False, l1_weight=0.0)
+    loss_no_reg = loss_fn_no_reg(estimates, actuals)
+    assert loss_no_reg.ndim == 0 and not torch.isnan(loss_no_reg)
+
+    # Test with L1 loss component
+    loss_fn_l1 = L1SNRDBLoss(name="test_l1", l1_weight=0.2)
+    loss_l1 = loss_fn_l1(estimates, actuals)
+    assert loss_l1.ndim == 0 and not torch.isnan(loss_l1)
+    
+    # Test pure L1 loss mode
+    loss_fn_pure_l1 = L1SNRDBLoss(name="test_pure_l1", l1_weight=1.0)
+    pure_l1_loss = loss_fn_pure_l1(estimates, actuals)
+    # Pure L1 mode uses torch.nn.L1Loss, so compare with manual L1 calculation
+    l1_loss_manual = torch.nn.L1Loss()(
+        estimates.reshape(estimates.shape[0], -1),
+        actuals.reshape(actuals.shape[0], -1)
+    )
+    assert torch.allclose(pure_l1_loss, l1_loss_manual)
+
+def test_stft_l1snrdb_loss(dummy_audio):
+    estimates, actuals = dummy_audio
+    
+    # Test with default settings
+    loss_fn = STFTL1SNRDBLoss(name="test", l1_weight=0.0)
+    loss = loss_fn(estimates, actuals)
+    assert loss.ndim == 0 and not torch.isnan(loss) and not torch.isinf(loss)
+    
+    # Test pure L1 mode
+    loss_fn_pure_l1 = STFTL1SNRDBLoss(name="test_pure_l1", l1_weight=1.0)
+    l1_loss = loss_fn_pure_l1(estimates, actuals)
+    assert l1_loss.ndim == 0 and not torch.isnan(l1_loss) and not torch.isinf(l1_loss)
+
+    # Test with very short audio
+    short_estimates = estimates[:, :500]
+    short_actuals = actuals[:, :500]
+    loss_short = loss_fn(short_estimates, short_actuals)
+    # min_audio_length is 512, so this should fallback to time-domain loss
+    assert loss_short.ndim == 0 and not torch.isnan(loss_short)
+
+def test_stem_multi_loss(dummy_stems):
+    estimates, actuals = dummy_stems
+
+    # Test with a specific stem - users now manage stems manually by slicing
+    # Extract stem 1 (second stem) manually
+    est_stem = estimates[:, 1, ...]  # Shape: [batch, channels, samples]
+    act_stem = actuals[:, 1, ...]
+    loss_fn_stem = MultiL1SNRDBLoss(
+        name="test_loss_stem",
+        spec_weight=0.5,
+        l1_weight=0.1
+    )
+    loss = loss_fn_stem(est_stem, act_stem)
+    assert loss.ndim == 0 and not torch.isnan(loss)
+
+    # Test with all stems jointly - flatten all stems together
+    # Reshape to [batch, -1] to process all stems at once
+    est_all = estimates.reshape(estimates.shape[0], -1)
+    act_all = actuals.reshape(actuals.shape[0], -1)
+    loss_fn_all = MultiL1SNRDBLoss(
+        name="test_loss_all",
+        spec_weight=0.5,
+        l1_weight=0.1
+    )
+    loss_all = loss_fn_all(est_all, act_all)
+    assert loss_all.ndim == 0 and not torch.isnan(loss_all)
+    
+    # Test pure L1 mode on all stems
+    loss_fn_l1 = MultiL1SNRDBLoss(name="l1_only", l1_weight=1.0)
+    l1_loss = loss_fn_l1(est_all, act_all)
+    
+    # Can't easily compute multi-res STFT L1 here, but can check it's not nan
+    assert l1_loss.ndim == 0 and not torch.isnan(l1_loss)
+
+@pytest.mark.parametrize("l1_weight", [0.0, 0.5, 1.0])
+def test_loss_variants(dummy_audio, l1_weight):
+    """Test L1SNRDBLoss and STFTL1SNRDBLoss with different l1_weights."""
+    estimates, actuals = dummy_audio
+    
+    time_loss_fn = L1SNRDBLoss(name=f"test_time_{l1_weight}", l1_weight=l1_weight)
+    time_loss = time_loss_fn(estimates, actuals)
+    assert not torch.isnan(time_loss) and not torch.isinf(time_loss)
+
+    spec_loss_fn = STFTL1SNRDBLoss(name=f"test_spec_{l1_weight}", l1_weight=l1_weight)
+    spec_loss = spec_loss_fn(estimates, actuals)
+    assert not torch.isnan(spec_loss) and not torch.isinf(spec_loss)