flamo 0.1.5__py3-none-any.whl → 0.1.6__py3-none-any.whl

flamo/auxiliary/scattering.py

@@ -245,13 +245,11 @@ def get_random_shifts(N, sparsity_vect, pulse_size):
 
 def hadamard_matrix(N):
     """Generate a hadamard matrix of size N"""
-    X = np.array([[1]])
+    X = np.array([[1]]) 
     # Create a Hadamard matrix of the specified order
-    # TODO remove for loop becuase all matrices look the same
     while X.shape[0] < N:
         # Kronecker product to generate a larger Hadamard matrix
         X = np.kron(X, np.array([[1, 1], [1, -1]])) / np.sqrt(2)
-
     return X
 
 

flamo/auxiliary/velvet.py

@@ -0,0 +1,114 @@
+"""
+Velvet Noise implementations for FLAMO
+
+Velvet noise is a sparse pseudo-random noise used in artificial reverberation.
+It consists of sample values of +1, -1, and 0, with the non-zero samples 
+occurring at pseudo-random locations.
+
+References:
+    Välimäki, V., & Prawda, K. (2021). Late-Reverberation Synthesis Using 
+    Interleaved Velvet-Noise Sequences. IEEE/ACM Transactions on Audio, 
+    Speech, and Language Processing, 29, 1149-1160.
+"""
+
+import torch
+import torch.nn as nn
+import math
+from typing import Optional
+from flamo.processor.dsp import Filter, parallelFilter
+
+
+class VelvetNoiseFilter(Filter):
+    """
+    TODO 
+    Args:
+        size: Size of the filter parameters (length, output_channels, input_channels)
+        density: Number of impulses per second
+        delta: Scaling factor for impulse range (0 < delta <= 1)
+               When delta=0.25, impulses only appear in first 25% of each grid
+        sample_rate: Sample rate in Hz (default: 48000)
+        nfft: Number of FFT points required to compute the frequency response
+        requires_grad: Whether the filter parameters require gradients
+        alias_decay_db: The decaying factor in dB for the time anti-aliasing envelope
+        device: The device of the constructed tensors
+    """
+    
+    def __init__(
+        self,
+        size: tuple = (1, 1, 1),
+        density: float = 1000.0,
+        delta: float = 1.0,
+        sample_rate: int = 48000,
+        nfft: int = 2**11,
+        requires_grad: bool = False,
+        alias_decay_db: float = 0.0,
+        device: Optional[str] = None,
+    ):
+        self.density = density
+        self.sample_rate = sample_rate
+        self.Td = sample_rate / density  # Average distance between impulses
+        if not 0 < delta <= 1:
+            raise ValueError("Delta must be in range (0, 1]")
+            
+        self.delta = delta
+        # Create mapping function that generates velvet noise
+        map = lambda x: self._generate_velvet_impulse_response(x)
+        super().__init__(
+            size=size,
+            nfft=nfft,
+            map=map,
+            requires_grad=requires_grad,
+            alias_decay_db=alias_decay_db,
+            device=device,
+        )
+    
+    def _generate_velvet_impulse_response(self, param: torch.Tensor) -> torch.Tensor:
+        """Generate velvet noise impulse response from parameters."""        
+        # Calculate grid size (average distance between impulses)
+
+        
+        result = torch.zeros_like(param)
+        
+        for out_ch in range(self.param.shape[1]):
+            for in_ch in range(self.param.shape[2]):
+                # Extract parameters for this channel pair
+                result[:, out_ch, in_ch] = self._generate_velvet_sequence()
+                
+        return result
+    
+    def _generate_velvet_sequence(
+        self, 
+    ) -> torch.Tensor:
+        """Generate a single velvet noise sequence."""
+        
+        # Add random jitter to each position (uniform distribution)
+        jitter_factors = torch.rand(self.floor_impulses)
+        impulse_indices = torch.ceil(self.grid + self.delta *  jitter_factors * (self.Td - 1)).long()
+
+        # first impulse is at position 0 and all indices are within bounds
+        impulse_indices[0] = 0
+        impulse_indices = torch.clamp(impulse_indices, max=self.param.shape[0] - 1)
+        
+        # Generate random signs (+1 or -1)
+        signs = 2 * torch.randint(0, 2, (self.floor_impulses,)) - 1
+        
+        # Construct sparse signal
+        sequence = torch.zeros(self.size[0], device=self.device)
+        sequence[impulse_indices] = signs.float()
+
+        return sequence
+
+    def initialize_class(self):
+        r"""
+        Initializes the Filter module.
+
+        This method checks the shape of the gain parameters, computes the frequency response of the filter,
+        and computes the frequency convolution function.
+        """
+        self.check_param_shape()
+        self.get_io()
+        num_impulses = self.param.shape[0] / self.Td
+        self.floor_impulses = math.floor(num_impulses)
+        self.grid = torch.arange(self.floor_impulses) * self.Td
+        self.get_freq_response()
+        self.get_freq_convolve()

flamo/processor/dsp.py

@@ -1,4 +1,5 @@
 import torch
+import math
 from typing import Optional
 import torch.nn as nn
 import torch.nn.functional as F
@@ -16,7 +17,8 @@ from flamo.auxiliary.eq import (
     geq, 
     accurate_geq)
 from flamo.auxiliary.scattering import (
-    ScatteringMapping)
+    ScatteringMapping, 
+    hadamard_matrix)
 # ============================= TRANSFORMS ================================
 
 
@@ -928,7 +930,7 @@ class parallelFilter(Filter):
 
 class ScatteringMatrix(Filter):
     r"""
-    A class representing a set of Scattering Filter matrix.
+    A class representing a Scattering Filter matrix.
 
     The :class:`ScatteringMatrix` was designed as filter feedback matrix of the
      Feedback Delay Network (FDN) reverberator structure.
@@ -1075,6 +1077,145 @@ class ScatteringMatrix(Filter):
         self.get_freq_response()
         self.get_freq_convolve()
 
+class VelvetNoiseMatrix(Filter):
+    r"""
+    A class representing a Velvet Noise Filter matrix.
+
+    The :class:`VelvetNoiseMatrix` was designed as filter feedback matrix of the
+     Feedback Delay Network (FDN) reverberator structure.
+    NOTE: It is not learnable. 
+
+    The input tensor is expected to be a complex-valued tensor representing the
+    frequency response of the input signal. The input tensor is then convolved in
+    frequency domain with the filter frequency responses to produce the output tensor.
+
+    Shape:
+        - input: :math:`(B, M, N_{in}, ...)`
+        - param: :math:`(N_{taps}, N_{out}, N_{in})`
+        - output: :math:`(B, M, N_{out}, ...)`
+
+    where :math:`B` is the batch size, :math:`M` is the number of frequency bins,
+    :math:`N_{in}` is the number of input channels, :math:`N_{out}` is the number of output channels,
+    and :math:`N_{taps}` is the number of filter parameters per input-output channel pair. By default, :math:`N_{taps}`
+    correspond to the length of the FIR filters.
+    Ellipsis :math:`(...)` represents additional dimensions.
+
+        **Arguments / Attributes**:
+            - **size** (tuple): The size of the filter parameters. Default: (1, 1, 1).
+            - **nfft** (int): The number of FFT points required to compute the frequency response. Default: 2 ** 11.
+            - **density** (float): Average number of pulses per sample. Default: 0.03.
+            - **gain_per_sample** (float): The gain per sample. This is useful when ensuring homogeneous decay in FDNs Default: 0.9999.
+            - **m_L** (torch.tensor): The leftmost delay vector. Default: None.
+            - **m_R** (torch.tensor): The rightmost delay vector. Default: None.
+            - **requires_grad** (bool): Whether the filter parameters require gradients. Default: False.
+            - **alias_decay_db** (float): The decaying factor in dB for the time anti-aliasing envelope. The decay refers to the attenuation after nfft samples. Default: 0.
+            - **device** (str): The device of the constructed tensors. Default: None.
+
+        **Attributes**:
+            - **param** (nn.Parameter): The parameters of the Filter module.
+            - **map** (function): Mapping function to ensure orthogonality of :math:`\mathbf{U}_k`.
+            - **map_filter** (ScatteringMapping): Mapping function to generate the filter matrix.
+            - **fft** (function): The FFT function. Calls the torch.fft.rfft function.
+            - **ifft** (function): The Inverse FFT function. Calls the torch.fft.irfft.
+            - **gamma** (torch.Tensor): The gamma value used for time anti-aliasing envelope.
+            - **new_value** (int): Flag indicating if new values have been assigned.
+            - **freq_response** (torch.Tensor): The frequency response of the filter.
+            - **freq_convolve** (function): The frequency convolution function.
+            - **input_channels** (int): The number of input channels.
+            - **output_channels** (int): The number of output channels.
+
+    Refereces:
+        - Schlecht, S. J., & Habets, E. A. (2020). Scattering in feedback delay networks. IEEE/ACM Transactions on Audio, Speech, and Language Processing, 28, 1915-1924.
+
+    """
+
+    def __init__(
+        self,
+        size: tuple = (1, 1, 1),
+        nfft: int = 2**11,
+        density: float = 0.03,
+        gain_per_sample: float = 0.9999,
+        m_L: torch.tensor = None,
+        m_R: torch.tensor = None,
+        alias_decay_db: float = 0.0,
+        device: Optional[str] = None,
+    ):
+        self.sparsity = 1/density
+        self.gain_per_sample = gain_per_sample
+        self.pulse_size = 1
+        self.m_L = m_L
+        self.m_R = m_R
+        map = lambda x: x
+        assert size[1] == size[2], "Matrix must be square"
+        assert (size[1] & (size[1] - 1)) == 0, "At the moment the Matrix must have dimensions which are powers of 2"
+        super().__init__(
+            size=size,
+            nfft=nfft,
+            map=map,
+            requires_grad=False,
+            alias_decay_db=alias_decay_db,
+            device=device,
+        )
+        self.assign_value(torch.tensor(hadamard_matrix(self.size[-1]), device=self.device).unsqueeze(0).repeat(self.size[0], 1, 1))
+
+    def get_freq_convolve(self):
+        r"""
+        Computes the frequency convolution function.
+
+        The frequency convolution is computed using the :func:`torch.einsum` function.
+
+            **Arguments**:
+                **x** (torch.Tensor): Input tensor.
+
+            **Returns**:
+                torch.Tensor: Output tensor after frequency convolution.
+        """
+        self.freq_convolve = lambda x, param: torch.einsum(
+            "fmn,bfn...->bfm...", self.freq_response(param), x
+        )
+
+    def get_freq_response(self):
+        r"""
+        Computes the frequency response of the filter.
+
+        The mapping function is applied to the filter parameters to obtain the filter impulse responses.
+        Then, the time anti-aliasing envelope is computed and applied to the impulse responses. Finally,
+        the frequency response is obtained by computing the FFT of the filter impulse responses.
+        """
+        L = (
+            (sum(self.map_filter.shifts).max() + 1).item()
+            + self.m_L.max().item()
+            + self.m_R.max().item()
+        )
+        self.freq_response = lambda param: self.fft(
+            self.map_filter(self.map(param))
+            * (self.gamma ** torch.arange(0, L, device=self.device)).view(
+                -1, *tuple([1 for i in self.size[1:]])
+            )
+        )
+
+    def initialize_class(self):
+        r"""
+        Initializes the ScatteringMatrix module.
+
+        This method creates the mapping to generate the filter matrix, checks the shape of the gain parameters, computes the frequency response of the filter,
+        and computes the frequency convolution function.
+        """
+        self.map_filter = ScatteringMapping(
+            self.size[-1],
+            n_stages=self.size[0] - 1,
+            sparsity=math.floor(self.sparsity),
+            gain_per_sample=self.gain_per_sample,
+            pulse_size=self.pulse_size,
+            m_L=self.m_L,
+            m_R=self.m_R,
+            device=self.device,
+        )
+        self.check_param_shape()
+        self.get_io()
+        self.get_freq_response()
+        self.get_freq_convolve()
+
 
 class Biquad(Filter):
     r"""
@@ -2410,7 +2551,7 @@ class AccurateGEQ(Filter):
     :math:`N_{in}` is the number of input channels, :math:`N_{out}` is the number of output channels,
     The :attr:'param' attribute represent the command gains of each band + shelving filters. The first dimension of the :attr:'param' tensor corresponds to the number of command gains/filters :math:`K`.
     Ellipsis :math:`(...)` represents additional dimensions (not tested).   
-    NOTE I: It is not differentiable 
+    NOTE I: It is not learnable 
     NOTE II: To avoid NaN or Inf values in the frequency response, the operations 
     performed in the frequency domain are done in double precision. The original 
     data type is restored at the end of the computation.
@@ -2531,7 +2672,7 @@ class parallelAccurateGEQ(AccurateGEQ):
     r"""
     Parallel counterpart of the :class:`GEQ` class
     For information about **attributes** and **methods** see :class:`flamo.processor.dsp.GEQ`.
-    NOTE: It is not differentiable 
+    NOTE: It is not learnable. 
 
     Shape:
         - input: :math:`(B, M, N, ...)`

{flamo-0.1.5.dist-info → flamo-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamo
-Version: 0.1.5
+Version: 0.1.6
 Summary: An Open-Source Library for Frequency-Domain Differentiable Audio Processing
 Project-URL: Homepage, https://github.com/gdalsanto/flamo
 Project-URL: Issues, https://github.com/gdalsanto/flamo/issues
@@ -71,7 +71,7 @@ Utilities, system designers, and optimization - in `flamo.processor.system`:
 - **Shell**: Container class for safe interaction between system, dataset, and loss functions
 
 Optimization - in `flamo.optimize`:
-- **Trianer** : Handling of the training and validation steps 
+- **Trainer** : Handling of the training and validation steps 
 - **Dataset** : Customizable dataset class and helper methods 
 
 --- 

{flamo-0.1.5.dist-info → flamo-0.1.6.dist-info}/RECORD

@@ -6,7 +6,8 @@ flamo/auxiliary/eq.py,sha256=eIWMIq0ggizXLhTdeWWbgBXWUFXCJyoEbkBH7Gzasao,6779
 flamo/auxiliary/filterbank.py,sha256=02w8dI8HoNDtKpdVhSJkIkd-h-KNXvZtivf3l4_ozzU,9866
 flamo/auxiliary/minimize.py,sha256=fMTAAAk9yD7Y4luKS4XA1-HTq44xo2opq_dRPRrhlIY,2474
 flamo/auxiliary/reverb.py,sha256=9iKSuyuqRiHGGvaj0eizqVpu2V7plsX13OWiB6o1whU,31636
-flamo/auxiliary/scattering.py,sha256=ITPT0TTOAROy3G0_kpykffRSqjoA9dFJ2LnaLxtUMF4,9482
+flamo/auxiliary/scattering.py,sha256=qlK8cynrpde56yLlbPuScC0Y1VmsPb0SFXl6Xisv6hA,9420
+flamo/auxiliary/velvet.py,sha256=B4pYEnhaQPkh02pxqiGdAhLRX2g-eWtHezphi0_h4Qs,4201
 flamo/auxiliary/config/config.py,sha256=CxXj-8sLq0_m9KyLg1a6NwLoK1UvTz3i0jZOLraq14I,2893
 flamo/optimize/__init__.py,sha256=grgxLmQ7m-c9MvRdIejmEAaaajfBwgeaZAv2qjHIvPw,65
 flamo/optimize/dataset.py,sha256=2mfzsnyX_bzavXouII9ee_pd6ti4lv215ieGJHscceI,5829
@@ -15,9 +16,9 @@ flamo/optimize/surface.py,sha256=uvsgxLFSvJ18s8kPcb22G3W1rgycXP1nNX0q48Pda2g,261
 flamo/optimize/trainer.py,sha256=he4nUjLC-3RTlxxBIw33r5k8mQfgAGvN1wpPBAWCjVo,12045
 flamo/optimize/utils.py,sha256=R5-KoZagRho3eykY88pC3UB2mc5SsE4Yv9X-ogskXdA,1610
 flamo/processor/__init__.py,sha256=paGdxGVZgA2VAs0tBwRd0bobzGxeyK79DS7ZGO8drkI,41
-flamo/processor/dsp.py,sha256=w5BT3lWAJ0kOC7rjVl1dgYFcGdQ6214pa_NyAL-K9QI,119983
+flamo/processor/dsp.py,sha256=n92YJPrES-ydwHgXmZ9RkFevIC3n-Wh4X8I1QNZqcV0,126378
 flamo/processor/system.py,sha256=9XwLtaGEVs9glVOFvyiPnQpsnR_Wjrv6k1i1qCs8D1Q,42516
-flamo-0.1.5.dist-info/METADATA,sha256=hTn11LzrhyQUm4JbHD_JiSmDfpOLbvgrGgzPezvegVo,7825
-flamo-0.1.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flamo-0.1.5.dist-info/licenses/LICENSE,sha256=smMocRH7xdPT5RvFNqSLtbSNzohXJM5G_rX1Qaej6vg,1120
-flamo-0.1.5.dist-info/RECORD,,
+flamo-0.1.6.dist-info/METADATA,sha256=n7uiBeQ1bqIP4Xwpmyx7Ah3FxCl2Xowucprz00lk2BM,7825
+flamo-0.1.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flamo-0.1.6.dist-info/licenses/LICENSE,sha256=smMocRH7xdPT5RvFNqSLtbSNzohXJM5G_rX1Qaej6vg,1120
+flamo-0.1.6.dist-info/RECORD,,