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

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/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/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/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/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/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.dist-info → flamo-0.1.5.dist-info}/METADATA

@@ -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.dist-info → flamo-0.1.5.dist-info}/RECORD

@@ -1,23 +1,23 @@
 flamo/__init__.py,sha256=ujezWOJfD7DUoj4q1meeMUnB97rOEtNR7mYw_PE9LMg,49
-flamo/functional.py,sha256=oFVgab3uqXw2bKwwUOzWUCXjVLmLbZjBfL1wJ7PYgGQ,33100
+flamo/functional.py,sha256=9wl6fHkc8KMB5IMvbd_K7-z8Z2Miw0qOsNxWPItliPU,35138
 flamo/utils.py,sha256=ypGKSABZMphgIrjCKgCH-zgR7BaupRbyzuUhsZFqAAM,3350
 flamo/auxiliary/__init__.py,sha256=7lVNh8OxHloZ4KPmp-iTUJnUbi8XbuRzGaQ3Z-NKXio,42
-flamo/auxiliary/eq.py,sha256=dkULcVlQrL3LKi4ejFnWb6VSWSmEb4PYSNLrOQMvGws,6767
+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=Rmv5oCW49MsfuJnM7ujZnJRQB6y1hQa1KAn1Hki2Bwk,31611
+flamo/auxiliary/reverb.py,sha256=9iKSuyuqRiHGGvaj0eizqVpu2V7plsX13OWiB6o1whU,31636
 flamo/auxiliary/scattering.py,sha256=ITPT0TTOAROy3G0_kpykffRSqjoA9dFJ2LnaLxtUMF4,9482
-flamo/auxiliary/config/config.py,sha256=7WYQsk3rfzb-OOY5JyRv6GzXPv8deLL_Viv1EbAUwu4,2859
+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
-flamo/optimize/loss.py,sha256=d5SJLlhXOhSSMWFRQFTyPkgHCSnLdInrvPZJ0VIVNQQ,33426
+flamo/optimize/loss.py,sha256=h6EeqjdX5P1SqDBKBavSxV25VBgnYK8tuX91wk6lw_g,33466
 flamo/optimize/surface.py,sha256=uvsgxLFSvJ18s8kPcb22G3W1rgycXP1nNX0q48Pda2g,26135
 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=Adb6pWyLHYO1mlMKPt8QnwC2oXkhjO4VrW-34jvUpyY,118696
+flamo/processor/dsp.py,sha256=w5BT3lWAJ0kOC7rjVl1dgYFcGdQ6214pa_NyAL-K9QI,119983
 flamo/processor/system.py,sha256=9XwLtaGEVs9glVOFvyiPnQpsnR_Wjrv6k1i1qCs8D1Q,42516
-flamo-0.1.3.dist-info/METADATA,sha256=4by0jhNq-p5kPZxs3WXFREJk25J7KuOFgNVPgsArb6w,7803
-flamo-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flamo-0.1.3.dist-info/licenses/LICENSE,sha256=smMocRH7xdPT5RvFNqSLtbSNzohXJM5G_rX1Qaej6vg,1120
-flamo-0.1.3.dist-info/RECORD,,
+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,,