flamo 0.1.3__tar.gz → 0.1.5__tar.gz

{flamo-0.1.3 → flamo-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamo
-Version: 0.1.3
+Version: 0.1.5
 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

{flamo-0.1.3 → flamo-0.1.5}/examples/e1_mimo.py

@@ -19,6 +19,65 @@ from flamo.optimize.trainer import Trainer
 
 torch.manual_seed(1)
 
+def example_matrix(args) -> None:
+    """
+    Test all the different types of matrices available in dsp.Matrix.
+    We will create different matrix types and apply them to a multi-channel input signal.
+    """
+    # ------------------- Signal Definition --------------------
+    in_ch = 4
+    out_ch = 4
+    
+    # Input signal - multi-channel noise
+    input_sig = signal_gallery(
+        signal_type="noise",
+        batch_size=1,
+        n_samples=args.nfft,
+        n=in_ch,
+        fs=args.samplerate,
+        device=args.device,
+    )
+    
+    # Test different matrix types
+    matrix_types = ["random", "identity", "orthogonal", "hadamard", "rotation"]
+    
+    fig, axes = plt.subplots(len(matrix_types), out_ch, figsize=(12, 2*len(matrix_types)))
+    if len(matrix_types) == 1:
+        axes = axes.reshape(1, -1)
+    
+    for i, matrix_type in enumerate(matrix_types):
+        print(f"Testing matrix type: {matrix_type}")
+        
+        # ------------------- DSP Definition --------------------
+        matrix_filter = dsp.Matrix(
+            size=(out_ch, in_ch),
+            matrix_type=matrix_type,
+            nfft=args.nfft,
+            device=args.device,
+        )
+        
+        input_layer = dsp.FFT(nfft=args.nfft)
+        output_layer = dsp.iFFT(nfft=args.nfft)
+        
+        my_dsp = nn.Sequential(input_layer, matrix_filter, output_layer)
+        
+        # -------------- Apply signal to DSP --------------
+        output_sig = my_dsp(input_sig)
+        
+        # ----------------------- Plot ------------------------
+        for j in range(out_ch):
+            ax = axes[i, j] if out_ch > 1 else axes[i]
+            ax.plot(output_sig.squeeze()[:1000, j].cpu().numpy())  # Plot first 1000 samples
+            ax.set_xlabel("Samples")
+            ax.set_ylabel("Amplitude")
+            ax.grid(True)
+            ax.set_title(f"{matrix_type.capitalize()} Matrix - Output Ch {j+1}")
+            
+    plt.tight_layout()
+    plt.show()
+
+    return None
+
 
 def example_delays(args) -> None:
     """
@@ -239,5 +298,6 @@ if __name__ == "__main__":
         )
 
     # Run examples
+    example_matrix(args)
     example_delays(args)
     example_biquads(args)

{flamo-0.1.3 → flamo-0.1.5}/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.3 → flamo-0.1.5}/examples/e8_fdn.py

@@ -542,5 +542,5 @@ if __name__ == "__main__":
         )
 
     # example_fdn(args)
-    example_fdn_accurate_geq(args)
-    # example_fdn_direct(args)
+    # example_fdn_accurate_geq(args)
+    example_fdn_direct(args)

{flamo-0.1.3 → flamo-0.1.5}/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.3 → flamo-0.1.5}/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.3 → flamo-0.1.5}/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.3 → flamo-0.1.5}/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.3 → flamo-0.1.5}/flamo/functional.py

@@ -1,6 +1,8 @@
 import torch
+import torch.nn as nn
 import numpy as np
 import scipy.signal
+from typing import Optional
 from flamo.utils import RegularGridInterpolator
 
 
@@ -69,6 +71,68 @@ def get_frequency_samples(num: int, device: str | torch.device = None):
     return torch.polar(abs, angle * np.pi)
 
 
+class HadamardMatrix(nn.Module):
+    """
+    Generate a Hadamard matrix of size N as a nn.Module.
+    """
+
+    def __init__(self, N, device: Optional[str] = None):
+        super().__init__()
+        self.N = N
+        self.device = device
+
+    def forward(self, x):
+        U = torch.tensor([[1.0]], device=self.device)
+        while U.shape[0] < self.N:
+            U = torch.kron(
+                U, torch.tensor([[1, 1], [1, -1]], dtype=U.dtype, device=U.device)
+            ) / torch.sqrt(torch.tensor(2.0, device=U.device))
+        return U
+
+
+class RotationMatrix(nn.Module):
+    """
+    Generate a rotation matrix of size N as a nn.Module from a given angle.
+    """
+
+    def __init__(
+        self,
+        N: int,
+        min_angle: float = 0,
+        max_angle: float = torch.pi / 4,
+        iter: Optional[int] = None,
+        device: Optional[str] = None,
+    ):
+
+        super().__init__()
+        self.N = N
+        self.min_angle = min_angle
+        self.max_angle = max_angle
+        self.iter = iter
+        self.device = device
+
+    def create_submatrix(self, angles: torch.Tensor, iters: int = 1):
+        """Create a submatrix for each group."""
+        X = torch.zeros(2, 2, device=self.device)
+        angles[0] = torch.clamp(angles[0], self.min_angle, self.max_angle)
+        X.fill_diagonal_(torch.cos(angles[0]))
+        X[1, 0] = -torch.sin(torch.tensor(angles[0], device=self.device))
+        X[0, 1] = torch.sin(torch.tensor(angles[0], device=self.device))
+
+        if iters is None:
+            iters = torch.log2(torch.tensor(self.N)).int().item() - 1
+        for i in range(iters):
+            if len(angles) > 1:
+                X = torch.kron(X, self.create_submatrix([angles[i]]))
+            else:
+                X = torch.kron(X, X)
+        return X
+
+    def forward(self, theta):
+
+        return self.create_submatrix(theta, self.iter)
+
+
 def biquad2tf(b: torch.Tensor, a: torch.Tensor, nfft: int):
     r"""
     Converts a biquad filter representation to a transfer function.
@@ -133,10 +197,11 @@ def signal_gallery(
         "wgn",
         "exp",
         "reference",
+        "noise",
     }
 
     if signal_type not in signal_types:
-        raise ValueError(f"Matrix type {signal_type} not recognized.")
+        raise ValueError(f"Signal type {signal_type} not recognized.")
     match signal_type:
         case "impulse":
             x = torch.zeros(batch_size, n_samples, n)
@@ -185,6 +250,8 @@ def signal_gallery(
                 return torch.tensor(reference, device=device).expand(
                     batch_size, n_samples, n
                 )
+        case "noise":
+            return torch.randn((batch_size, n_samples, n), device=device)
 
 
 def hertz2rad(hertz: torch.Tensor, fs: int):

{flamo-0.1.3 → flamo-0.1.5}/flamo/optimize/loss.py

@@ -38,7 +38,7 @@ class sparsity_loss(nn.Module):
             A = core.feedback_loop.feedback.map(core.feedback_loop.feedback.param)
         except:
             try:
-                A = core.feedback_loop.feedback.map(
+                A = core.feedback_loop.feedback.mixing_matrix.map(
                     core.feedback_loop.feedback.mixing_matrix.param
                 )
             except:
@@ -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):
         """

{flamo-0.1.3 → flamo-0.1.5}/flamo/processor/dsp.py

@@ -8,7 +8,9 @@ from flamo.functional import (
     lowpass_filter,
     highpass_filter,
     bandpass_filter,
-    rad2hertz )
+    rad2hertz, 
+    HadamardMatrix, 
+    RotationMatrix)
 from flamo.auxiliary.eq import (
     eq_freqs,
     geq, 
@@ -535,11 +537,13 @@ class Matrix(Gain):
         nfft: int = 2**11,
         map: callable = lambda x: x,
         matrix_type: str = "random",
+        iter: int = 1,
         requires_grad: bool = False,
         alias_decay_db: float = 0.0,
         device: Optional[str] = None,
     ):
         self.matrix_type = matrix_type
+        self.iter = iter # iterations number for the rotation matrix 
         super().__init__(
             size=size,
             nfft=nfft,
@@ -557,14 +561,31 @@ class Matrix(Gain):
         Warning(
             f"you asked for {self.matrix_type} matrix type, map will be overwritten"
         )
+        N = self.size[0]
         match self.matrix_type:
             case "random":
                 self.map = lambda x: x
             case "orthogonal":
                 assert (
-                    self.size[0] == self.size[1]
+                    N == self.size[1]
                 ), "Matrix must be square to be orthogonal"
                 self.map = lambda x: torch.matrix_exp(skew_matrix(x))
+            case "hadamard":
+                assert (
+                    N == self.size[1]
+                ), "Matrix must be square to be Hadamard"
+                assert (
+                    N % 2 == 0
+                ), "Matrix must have even dimensions to be Hadamard"
+                self.map = lambda x: HadamardMatrix(self.size[0], device=self.device)(x)
+            case "rotation":
+                assert (
+                    N == self.size[1]
+                ), "Matrix must be square to be a rotation matrix"
+                assert (
+                    N % 2 == 0
+                ), "Matrix must have even dimensions to be a rotation matrix"
+                self.map = lambda x: RotationMatrix(self.size[0], self.iter, device=self.device)([x[0][0]])
 
     def initialize_class(self):
         r"""
@@ -2722,7 +2743,7 @@ class Delay(DSP):
         """
         m = self.get_delays()
         if self.isint:
-            self.freq_response = lambda param: (self.gamma ** m(param)) * torch.exp(
+            self.freq_response = lambda param: (self.gamma ** m(param).round()) * torch.exp(
                 -1j
                 * torch.einsum(
                     "fo, omn -> fmn",
@@ -2859,14 +2880,24 @@ class parallelDelay(Delay):
         Computes the frequency response of the delay module.
         """
         m = self.get_delays()
-        self.freq_response = lambda param: (self.gamma ** m(param)) * torch.exp(
-            -1j
-            * torch.einsum(
-                "fo, on -> fn",
-                self.omega,
-                m(param).unsqueeze(0),
+        if self.isint:
+            self.freq_response = lambda param: (self.gamma ** m(param).round()) * torch.exp(
+                -1j
+                * torch.einsum(
+                     "fo, on -> fn",
+                    self.omega,
+                    m(param).round().unsqueeze(0),
+                )
+            )
+        else:
+            self.freq_response = lambda param: (self.gamma ** m(param)) * torch.exp(
+                -1j
+                * torch.einsum(
+                    "fo, on -> fn",
+                    self.omega,
+                    m(param).unsqueeze(0),
+                )
             )
-        )
 
     def get_io(self):
         r"""

{flamo-0.1.3 → flamo-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flamo"
-version = "0.1.3"
+version = "0.1.5"
 authors = [
   { name="Gloria Dal Santo", email="gloria.dalsanto@aalto.fi" },
   { name="Gian Marco De Bortoli", email="gian.debortoli@aalto.fi"},
@@ -34,6 +34,7 @@ dependencies = [
     "pydantic",
     "nnAudio",
     "pyfar",
+    "pyyaml"
 ]
 
 [project.urls]