si_sdr.py

import torch


def _normalize(tensor: torch.Tensor, eps=1e-10) -> torch.Tensor:
    """
    Helper function to normalize a tensor
    Args:
        tensor (torch.Tensor): input tensor
        eps (float): small value to avoid division by zero
    Returns:
        normalized_tensor (torch.Tensor): normalized tensor
    """
    norm = torch.norm(tensor, dim=-1, keepdim=True)
    normalized_tensor = tensor / (norm + eps)
    return normalized_tensor


def _calculate_alpha(preds, targets, eps=1e-10) -> torch.Tensor:
    """
    Helper function to calculate alpha
    Args:
        preds (torch.Tensor): predicted sources
        targets (torch.Tensor): target sources
        eps (float): small value to avoid division by zero
    Returns:
        alpha (torch.Tensor): alpha value
    """
    dot = torch.sum(preds * targets, dim=-1, keepdim=True)
    target_energy = torch.sum(targets**2, dim=-1, keepdim=True)
    alpha = (dot + eps) / (target_energy + eps)
    return alpha


def _calculate_metric(numerator, denominator, eps=1e-10) -> torch.Tensor:
    """
    Helper function to calculate sdr and its variants
    Args:
        numerator (torch.Tensor): numerator tensor
        denominator (torch.Tensor): denominator tensor
        eps (float): small value to avoid division by zero
    Returns:
        dB (torch.Tensor): dB value
    """
    numerator = torch.sum(numerator, dim=-1) + eps
    denominator = torch.sum(denominator, dim=-1) + eps
    dB = 10 * torch.log10(numerator / denominator)
    return dB


def si_sdr(preds, targets, eps=1e-10) -> torch.Tensor:
    """
    Scale Invariant Signal Distortion Ratio (SI-SDR) metric
    Args:
        preds (torch.Tensor): predicted sources. (batch, time)
        targets (torch.Tensor): target sources. (batch, time)
        eps (float): small value to avoid division by zero
    Returns:
        si_sdr (torch.Tensor): SI-SDR value
    """
    preds = _normalize(preds, eps=eps)
    targets = _normalize(targets, eps=eps)

    alpha = _calculate_alpha(preds, targets, eps=eps)

    # compute SI-SDR (in dB)
    numerator = torch.square(alpha * targets)
    denominator = torch.square(preds - alpha * targets)
    return _calculate_metric(numerator, denominator, eps=eps)