flamo 0.1.4__tar.gz → 0.1.6__tar.gz

{flamo-0.1.4 → flamo-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamo
-Version: 0.1.4
+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
@@ -38,6 +38,7 @@ Requires-Dist: numpy
 Requires-Dist: pydantic
 Requires-Dist: pyfar
 Requires-Dist: pysoundfile
+Requires-Dist: pyyaml
 Requires-Dist: scipy
 Requires-Dist: torch
 Requires-Dist: torchaudio
@@ -70,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.4 → flamo-0.1.6}/README.md

@@ -24,7 +24,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.6/examples/e1_vn.py

@@ -0,0 +1,63 @@
+"""
+Example usage of velvet noise filters integrated with FLAMO Filter system.
+
+This example shows how to use the new Filter-based velvet noise classes
+that are differentiable and can be used within the FLAMO processing chain.
+"""
+
+import torch.nn as nn   
+
+import matplotlib.pyplot as plt
+from flamo.auxiliary.velvet import (
+    VelvetNoiseFilter,
+)
+from flamo.functional import signal_gallery
+from flamo.processor import dsp
+
+def example_velvet_noise_filter():
+    """Example using VelvetNoiseFilter."""
+    print("=== VelvetNoiseFilter Example ===")
+    
+    in_ch, out_ch = 1, 1
+    nfft = 2048  # FFT size for the filter
+    length = nfft # Length of the filter
+
+    # Create a velvet noise filter
+    # size = (length, output_channels, input_channels)
+    velvet_filter = VelvetNoiseFilter(
+        size=(length, out_ch, in_ch),  # 1024 samples, 1x1 matrix
+        density=1000.0,     # 1000 impulses per second
+        sample_rate=48000,
+        requires_grad=True  # Make it differentiable
+    )
+    
+    input_layer = dsp.FFT(nfft=nfft)
+    output_layer = dsp.iFFT(nfft=nfft)
+
+    my_dsp = nn.Sequential(input_layer, velvet_filter, output_layer)
+
+    # -------------- Apply unit impulse to DSP --------------
+
+    # Input signal
+    input_sig = signal_gallery(
+        signal_type="impulse",
+        batch_size=1,
+        n_samples=nfft,  
+        n=in_ch,
+        fs=48000,
+        device="cpu",
+    )
+
+    output_vn = my_dsp(input_sig)
+    # plot the sequence 
+    plt.figure(figsize=(12, 4))
+    plt.plot(output_vn[0, :, 0].squeeze().numpy())
+    for pos in velvet_filter.grid:
+        plt.axvline(x=pos.item(), color='r', linestyle='--', alpha=0.5)
+    plt.title('Output Velvet Noise Signal')
+    plt.xlabel('Samples')
+    plt.ylabel('Amplitude')
+    plt.grid(True, alpha=0.3)
+    plt.tight_layout()
+    
+    return 

{flamo-0.1.4 → flamo-0.1.6}/examples/e8_colorless_fdn.py

@@ -26,8 +26,8 @@ def example_fdn(args):
 
     # FDN parameters
     N = 6  # number of delays
-    alias_decay_db = 0  # alias decay in dB
-    delay_lengths = torch.tensor([997, 1153, 1327, 1559, 1801, 2099])
+    alias_decay_db = 30  # alias decay in dB
+    delay_lengths = torch.tensor([887, 911, 941, 1699, 1951, 2053])
 
     ## ---------------- CONSTRUCT FDN ---------------- ##
 
@@ -35,19 +35,17 @@ def example_fdn(args):
     input_gain = dsp.Gain(
         size=(N, 1),
         nfft=args.nfft,
-        requires_grad=False,
+        requires_grad=True,
         alias_decay_db=alias_decay_db,
         device=args.device,
     )
-    input_gain.assign_value(torch.ones((N, 1), device=args.device) / torch.tensor(N))
     output_gain = dsp.Gain(
         size=(1, N),
         nfft=args.nfft,
-        requires_grad=False,
+        requires_grad=True,
         alias_decay_db=alias_decay_db,
         device=args.device,
     )
-    output_gain.assign_value(torch.ones((1, N), device=args.device) )
     # Feedback loop with delays
     delays = dsp.parallelDelay(
         size=(N,),
@@ -60,7 +58,7 @@ def example_fdn(args):
     )
     delays.assign_value(delays.sample2s(delay_lengths))
     # Feedback path with orthogonal matrix
-    mixing_matrix = dsp.Matrix(
+    feedback = dsp.Matrix(
         size=(N, N),
         nfft=args.nfft,
         matrix_type="orthogonal",
@@ -68,16 +66,6 @@ def example_fdn(args):
         alias_decay_db=alias_decay_db,
         device=args.device,
     )
-    attenuation = dsp.parallelGain(
-        size=(N,),
-        nfft=args.nfft,
-        requires_grad=False,
-        alias_decay_db=alias_decay_db,
-        device=args.device,
-        )
-    attenuation.map = map_gamma(delay_lengths)
-    gamma = 6
-    attenuation.assign_value(gamma * torch.ones((N,), device=args.device,))
 
     # # Feedback path with scattering matrix
     # m_L =  torch.randint(low=1, high=int(torch.floor(min(delay_lengths)/2)), size=[N])
@@ -93,14 +81,6 @@ def example_fdn(args):
     #     requires_grad=True,
     #     device=args.device,
     # )
-    feedback = system.Series(
-        OrderedDict(
-            {
-                "attenuation": attenuation,
-                "mixing_matrix": mixing_matrix,
-            }
-        )
-    )
 
     # Recursion
     feedback_loop = system.Recursion(fF=delays, fB=feedback)
@@ -118,42 +98,9 @@ def example_fdn(args):
 
     # Create the model with Shell
     input_layer = dsp.FFT(args.nfft)
-    output_layer = dsp.iFFT(args.nfft)
+    output_layer = dsp.Transform(transform=lambda x: torch.abs(x))
     model = system.Shell(core=FDN, input_layer=input_layer, output_layer=output_layer)
 
-    ir_init = model.get_time_response(identity=False, fs=args.samplerate)
-
-    time_axis = torch.arange(0, args.nfft) / args.samplerate
-
-    out = torch.flip(ir_init, dims=[1])
-    out = torch.cumsum(out**2, dim=1)
-    out = torch.flip(out, dims=[1])
-
-    # Normalize to 1
-    norm_vals = torch.max(out, dim=1, keepdim=True)[0]  # per channel
-
-
-    edc = out / norm_vals
-    
-    core = model.get_core()
-
-    # generate a decaying sinusoid
-    sine = torch.sin(
-        2 * torch.pi * 1000 * time_axis
-    ) * torch.exp(-time_axis / 0.01)  # 1000 Hz, decay time of 0.1 seconds
-    sine = sine.unsqueeze(0).unsqueeze(-1)  # add batch and channel dimensions
- 
-    out = torch.flip(model(sine), dims=[1])
-    out = torch.cumsum(out**2, dim=1)
-    out = torch.flip(out, dims=[1])
-
-    # Normalize to 1
-    norm_vals = torch.max(out, dim=1, keepdim=True)[0]  # per channel
-
-
-    edc_sine = out / norm_vals
-    
-
     # Get initial impulse response
     with torch.no_grad():
         ir_init = model.get_time_response(identity=False, fs=args.samplerate).squeeze()
@@ -218,7 +165,7 @@ def save_fdn_params(net, filename="parameters"):
 
     core = net.get_core()
     param = {}
-    param["A"] = core.feedback_loop.feedback.mixing_matrix.param.squeeze().detach().cpu().numpy()
+    param["A"] = core.feedback_loop.feedback.param.squeeze().detach().cpu().numpy()
     param["B"] = core.input_gain.param.squeeze().detach().cpu().numpy()
     param["C"] = core.output_gain.param.squeeze().detach().cpu().numpy()
     param["m"] = (
@@ -236,20 +183,6 @@ def save_fdn_params(net, filename="parameters"):
     return param
 
 
-class map_gamma(torch.nn.Module):
-
-    def __init__(self, delays):
-        super().__init__()
-        self.delays = delays.double()
-        self.g_min = torch.tensor(0.99, dtype=torch.double, device=delays.device)
-        self.g_max = torch.tensor(1, dtype=torch.double, device=delays.device)
-
-    def forward(self, x):
-        return (
-            ((1 / (1 + torch.exp(-x[0]))) * (self.g_max - self.g_min) + self.g_min)
-            ** self.delays
-        ).type_as(x)
-
 if __name__ == "__main__":
 
     parser = argparse.ArgumentParser()

{flamo-0.1.4 → flamo-0.1.6}/examples/e8_fdn.py

@@ -490,8 +490,8 @@ if __name__ == "__main__":
 
     parser = argparse.ArgumentParser()
 
-    parser.add_argument("--nfft", type=int, default=44100*2, help="FFT size")
-    parser.add_argument("--samplerate", type=int, default=44100, help="sampling rate")
+    parser.add_argument("--nfft", type=int, default=96000, help="FFT size")
+    parser.add_argument("--samplerate", type=int, default=48000, help="sampling rate")
     parser.add_argument("--num", type=int, default=100, help="dataset size")
     parser.add_argument(
         "--device", type=str, default="cuda", help="device to use for computation"
@@ -541,6 +541,6 @@ if __name__ == "__main__":
             )
         )
 
-    example_fdn(args)
+    # example_fdn(args)
     # example_fdn_accurate_geq(args)
-    # example_fdn_direct(args)
+    example_fdn_direct(args)

{flamo-0.1.4 → flamo-0.1.6}/examples/e9_loss_profile.py

@@ -6,7 +6,7 @@ import argparse
 import yaml
 from flamo.auxiliary.reverb import HomogeneousFDN, map_gamma, inverse_map_gamma
 from flamo.auxiliary.config.config import HomogeneousFDNConfig
-from flamo.optimize.loss import mse_loss
+from flamo.optimize.loss import mse_loss, mel_mss_loss
 from flamo.optimize.surface import LossProfile, LossConfig, ParameterConfig, LossSurface
 from flamo.functional import signal_gallery, get_magnitude
 
@@ -59,7 +59,7 @@ def example_loss_profile(args):
 
     loss_profile = LossProfile(FDN.model, loss_config)
     loss = loss_profile.compute_loss(input_signal, target_signal)
-    loss_profile.plot_loss(loss, criterion_name=["MSE"])
+    loss_profile.plot_loss(loss)
 
 
 def example_loss_surface(args):
@@ -103,7 +103,7 @@ def example_loss_surface(args):
 
     # define config structures
     loss_config = LossConfig(
-        criteria=[mse_loss(), torch.nn.L1Loss()],
+        criteria=[mse_loss(), mel_mss_loss()],
         param_config=[attenuation_config, input_gain_config],
         # perturb_param=None,#"output_gain",
         perturb_map=lambda x: x,
@@ -124,7 +124,7 @@ def example_loss_surface(args):
 
     loss_profile = LossSurface(FDN.model, loss_config)
     loss = loss_profile.compute_loss(input_signal, target_signal)
-    loss_profile.plot_loss(loss, criterion_name=["MSE", "MAE"])
+    loss_profile.plot_loss(loss)
 
 if __name__ == "__main__":
 

{flamo-0.1.4 → flamo-0.1.6}/flamo/auxiliary/config/config.py

@@ -33,7 +33,8 @@ class HomogeneousFDNConfig(BaseModel):
     delays_grad: bool = False
     mixing_matrix_grad: bool = True
     attenuation_grad: bool = True
-
+    is_delay_int: bool = True
+    
     def __init__(self, **data):
         super().__init__(**data)
         if self.delays is None:

{flamo-0.1.4 → flamo-0.1.6}/flamo/auxiliary/eq.py

@@ -86,7 +86,8 @@ def geq(
 
     for band in range(num_bands):
         if band == 0:
-            b = torch.tensor([db2mag(gain_db[band]), 0, 0], device=device)
+            b = torch.zeros(3, device=device)
+            b[0] = db2mag(gain_db[band])
             a = torch.tensor([1, 0, 0], device=device)
         elif band == 1:
             b, a = shelving_filter(

{flamo-0.1.4 → flamo-0.1.6}/flamo/auxiliary/reverb.py

@@ -129,7 +129,7 @@ class HomogeneousFDN:
             size=(self.N,),
             max_len=delay_lines.max(),
             nfft=self.config_dict.nfft,
-            isint=True,
+            isint=self.config_dict.is_delay_int,
             requires_grad=self.config_dict.delays_grad,
             alias_decay_db=self.config_dict.alias_decay_db,
             device=self.config_dict.device,

{flamo-0.1.4 → flamo-0.1.6}/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-0.1.6/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-0.1.4 → flamo-0.1.6}/flamo/optimize/loss.py

@@ -77,6 +77,7 @@ class mse_loss(nn.Module):
         self.nfft = nfft
         self.device = device
         self.mse_loss = nn.MSELoss()
+        self.name = "MSE"
 
     def forward(self, y_pred, y_true):
         """