fakesound 0.0.0__tar.gz

fakesound-0.0.0/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2026 groma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.

fakesound-0.0.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: fakesound
+Version: 0.0.0
+Requires-Python: >=3.10
+License-File: LICENSE
+Dynamic: license-file

fakesound-0.0.0/README.md

@@ -0,0 +1,39 @@
+# fakesound
+
+fakesound is a python library for neural audio synthesis.
+
+## Description
+
+This library contains re-implementations of several classic neural audio synthesis algorithms. At the moment the following are implemented:
+
+
+- Wavenet
+- SampleRNN
+- GANSynth
+- HiFi-GAN
+- RAVE v1
+
+The library is still highly experimental, many of the models have been barely tested. Use at your own risk!
+
+## How to use
+Check the *examples* folder for some example training and generation scripts. This is all for now! 
+### Dependencies
+
+- scipy
+- numpy
+- pytorch
+- tensorboard
+- auraloss
+- python-soundfile
+
+
+## Authors
+
+Gerard Roma, 2026
+
+Some of the implementations are heavily based on the original implementation.
+
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE.md file for details

fakesound-0.0.0/pyproject.toml

@@ -0,0 +1,14 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fakesound"
+version = "0.0.0"
+requires-python = ">=3.10"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

fakesound-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fakesound-0.0.0/src/fakesound/data/dataset.py

@@ -0,0 +1,58 @@
+from collections.abc import Callable
+import numpy as np
+import glob, os
+import torch
+from scipy.io import wavfile
+from numpy.lib.stride_tricks import sliding_window_view
+from torch.utils.data import Dataset
+
+class AudioDataSet(Dataset[torch.Tensor]):
+    def __init__(self, folder_path:str, chunk_samples:int,
+                       hop_samples:int, transform:Callable = None,
+                       reset = False, pad_start:int = 0):
+        self.sample_rate = None # set when 1st loading audio
+        self.transform = transform
+        files = glob.glob(os.path.join(folder_path, "*.wav"))
+        arrays = []
+        self.reset_flags = []
+        # if reset is used, all files should be equal length
+        self.num_chunks = []
+        for f in files:
+            x = self.load_audio(f)
+            x = np.pad(x, (pad_start, 0))
+            chunks = sliding_window_view(x, chunk_samples)[::hop_samples,:]
+            self.num_chunks.append(len(chunks))
+            file_reset =  [False] *  self.num_chunks[-1]
+            if reset:
+                file_reset[0] = True
+            arrays.append(chunks)
+            self.reset_flags = self.reset_flags + file_reset
+        self.data = np.concatenate(arrays, 0)
+
+
+    def __len__(self):
+        return len(self.data)
+
+    # reset assumes no shuffling
+    def __getitem__(self, index:int):
+        sample = self.data[index]
+        reset = self.reset_flags[index]
+        sample = torch.from_numpy(sample).unsqueeze(0).float()
+        transformed = sample
+        if self.transform is not None:
+            transformed = self.transform(sample)
+        return transformed, sample, reset
+
+    def load_audio(self, file_path:str):
+        samplerate, data = wavfile.read(file_path)
+        if self.sample_rate is None:
+            self.sample_rate = samplerate
+        if samplerate != self.sample_rate:
+            raise Exception("Different sample rates in dataset")
+        if data.dtype == np.int16:
+            data = data / 2**15
+        if data.dtype == np.int32:
+            data = data / 2**31
+        if len(data.shape) > 1:
+            data = data[:,0]
+        return data

fakesound-0.0.0/src/fakesound/data/mel_bands.py

@@ -0,0 +1,34 @@
+import numpy as np
+import torch
+
+def mel2hz(mel):
+  return 700. * (np.exp(mel / 1127.) - 1.0)
+
+def hz2mel(hz):
+    return 1127. * np.log(1.0 + (hz / 700.0))
+
+def linear2mel(bin_freqs:np.ndarray, n_mels:int, fmin:float, fmax:float):
+    return get_mel_matrix(bin_freqs, n_mels, fmin, fmax)
+
+def mel2linear(bin_freqs:np.ndarray, n_mels:int, fmin:float, fmax:float):
+    M = get_mel_matrix(bin_freqs, n_mels, fmin, fmax)
+    Mt = M.T
+    S = np.sum(np.dot(M, Mt), 0)
+    d = np.divide(1.0, S, out=np.zeros_like(S), where = S!=0)
+    return np.dot(Mt, np.diag(d))
+
+def get_mel_matrix(bin_freqs:np.ndarray, n_mels:int, fmin:float, fmax:float):
+    # based on https://librosa.org/doc/main/_modules/librosa/filters.html#mel
+    N = bin_freqs.shape[0]
+    M = np.zeros((n_mels,N))
+    mels =  np.linspace(hz2mel(fmin), hz2mel(fmax), n_mels+2)
+    mel_freqs = mel2hz(mels)
+    fdiff = np.diff(mel_freqs)
+    ramps = np.subtract.outer(mel_freqs, bin_freqs)
+    for i in range(n_mels):
+        rising = -ramps[i, :] / fdiff[i]
+        falling = ramps[i + 2, :] / fdiff[i + 1]
+        M[i, :] = np.maximum(0, np.minimum(rising, falling))
+    norm = 2.0 / (mel_freqs[2 : n_mels + 2] - mel_freqs[:n_mels])
+    M = M * norm[:, None]
+    return M

fakesound-0.0.0/src/fakesound/data/pqmf.py

@@ -0,0 +1,21 @@
+import numpy as np
+import torch
+import torch.nn.functional as F
+from scipy import signal
+
+def get_pqmf_filter( n_bands:int = 16, atten:float=100, analysis = True):
+    cutoff = 1  / (2 * n_bands)
+    n_taps, beta = signal.kaiserord(atten, cutoff)
+    h = signal.firwin(n_taps + 1, cutoff,
+        window=('kaiser', beta), scale = False )
+    k = torch.arange(n_bands).reshape(-1, 1)
+    alpha = (2 * k + 1) * (torch.pi /
+            (2 * n_bands)) * (torch.arange( n_taps + 1)-(( n_taps - 1) / 2))
+    phase = (-1)**k * np.pi / 4
+    if analysis:
+        f = 2 * torch.from_numpy(h) * torch.cos(alpha + phase)
+        f = f[:, None, :].float()
+    else:
+        f = 2 * torch.from_numpy(h) * torch.cos(alpha - phase)
+        f = f[None, :, :].float()
+    return f

fakesound-0.0.0/src/fakesound/data/transforms.py

@@ -0,0 +1,168 @@
+import numpy as np
+import torch
+from torch import nn
+import torch.nn.functional as F
+from .mel_bands import linear2mel
+from .pqmf import get_pqmf_filter
+
+class muLawEncoder(nn.Module):
+    def __init__(self, n_levels:int = 256):
+        super().__init__()
+        self.num_levels:int = n_levels
+        bins:torch.Tensor = torch.linspace(-1, 1, n_levels)
+        mu:torch.Tensor = torch.Tensor([n_levels - 1])
+        self.register_buffer('bins', bins)
+        self.register_buffer('mu', mu)
+
+    def forward(self, x:torch.Tensor) -> torch.Tensor:
+        x = x.clone()
+        compressed = torch.sign(x) * torch.log1p(self.mu * torch.abs(x)) / torch.log1p(self.mu)
+        return  torch.bucketize(compressed, self.bins)
+
+class muLawDecoder(nn.Module):
+    def __init__(self, n_levels:int = 256):
+        super().__init__()
+        mu:torch.Tensor = torch.Tensor([n_levels - 1])
+        self.register_buffer('mu', mu)
+
+    def forward(self, x:torch.Tensor) -> torch.Tensor:
+        x = x / (1 + self.mu) * 2 - 1
+        return torch.sign(x) * (torch.pow(self.mu + 1, torch.abs(x)) - 1) / self.mu
+
+class Wave2LogMagIF(nn.Module):
+    def __init__(self, fft_size:int, hop_size:int):
+        super().__init__()
+        self.fft_size = fft_size
+        self.hop_size = hop_size
+        self.epsilon = 1e-7
+        window = torch.hann_window(fft_size)
+        self.register_buffer('window', window)
+
+    def forward(self, x:torch.Tensor, remove_nyquist:bool = True) -> tuple[torch.Tensor, torch.Tensor]:
+         x = x.squeeze(1)
+         spec = torch.stft(x,
+             n_fft = self.fft_size,
+             hop_length = self.hop_size,
+             win_length = self.fft_size,
+             window = self.window,
+             center = True,
+             pad_mode = 'reflect',
+             normalized = False,
+             onesided =  True,
+             return_complex = True).squeeze(0)
+         logmag = torch.log(torch.abs(spec).clip(min = self.epsilon))
+         phase = torch.angle(spec)
+         dphase = torch.diff(phase)
+         dphase = torch.where(dphase >  np.pi, dphase - 2 * np.pi, dphase)
+         dphase = torch.where(dphase < -np.pi, dphase + 2 * np.pi, dphase)
+         dphase = torch.hstack((phase[:,0, None], dphase))
+         if remove_nyquist:
+             return (logmag[:-1,:], dphase[:-1,:])
+         else:
+             return (logmag, dphase)
+
+class LogMagIF2Wave(nn.Module):
+        def __init__(self, fft_size:int, hop_size:int):
+            super().__init__()
+            self.fft_size = fft_size
+            self.hop_size = hop_size
+            window = torch.hann_window(fft_size)
+            self.register_buffer('window', window)
+
+        def forward(self, logmag:torch.Tensor, instfreq: torch.Tensor, add_nyquist:bool = True) -> torch.Tensor:
+            mag = torch.exp(logmag)
+            phase = torch.cumsum(instfreq, 1)
+            spec = torch.polar(mag, phase)
+            if add_nyquist:
+                new_spec = torch.empty(
+                    logmag.shape[0]+1, logmag.shape[1] ,
+                    dtype = spec.dtype).to(logmag.device)
+                new_spec[:logmag.shape[0], :] = spec
+                spec = new_spec
+            audio = torch.istft(spec,
+                n_fft = self.fft_size,
+                hop_length = self.hop_size,
+                win_length = self.fft_size,
+                window = self.window,
+                center = True,
+                normalized = False,
+                onesided =  True,
+                return_complex = False
+                )
+            return audio
+
+
+class Wave2LogMelIF(nn.Module):
+    def __init__(self, sr:float, fft_size:int, hop_size:int,
+                        n_mels:int, fmin:float, fmax:float,
+                        pad_amount:int = None, return_phase:bool = True):
+        super().__init__()
+        self.fft_size = fft_size
+        self.hop_size = hop_size
+        self.n_mels = n_mels
+        self.return_phase = return_phase
+        self.epsilon = 1e-7
+        if pad_amount is None:
+            self.pad_amount = fft_size //2
+        else:
+            self.pad_amount = pad_amount
+        dF = sr/fft_size
+        n_bins = fft_size / 2 + 1
+        ff = np.arange(0, dF * n_bins, dF)
+        mel_matrix =  torch.from_numpy(linear2mel(ff, n_mels, fmin, fmax)).float()
+        window = torch.hann_window(fft_size)
+        self.register_buffer('mel_matrix', mel_matrix)
+        self.register_buffer('window', window)
+
+    def forward(self, x:torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+         x = torch.nn.functional.pad(
+              x.unsqueeze(1), (self.pad_amount, self.pad_amount),
+              mode='reflect'
+          )
+         x = x.squeeze(1)
+         spec = torch.stft(x,
+             n_fft = self.fft_size,
+             hop_length = self.hop_size,
+             win_length = self.fft_size,
+             window = self.window,
+             center= False,
+             pad_mode = 'reflect',
+             normalized = False,
+             onesided =  True,
+             return_complex = True).squeeze(0)
+         mel_mag = torch.matmul(self.mel_matrix, torch.abs(spec))
+         mel_logmag =  torch.log(mel_mag.clip(min = self.epsilon))
+         if not self.return_phase: return (mel_logmag, torch.empty(0))
+         mel_phase = torch.matmul(self.mel_matrix, torch.angle(spec))
+         dphase = torch.diff(mel_phase)
+         dphase = torch.where(dphase >  np.pi, dphase - 2 * np.pi, dphase)
+         dphase = torch.where(dphase < -np.pi, dphase + 2 * np.pi, dphase)
+         dphase = torch.hstack((mel_phase[:,0, None], dphase))
+         return (mel_logmag, dphase)
+
+class Wave2PQMF(nn.Module):
+    def __init__(self, n_bands:int = 16, atten:float = 100):
+        super().__init__()
+        h = get_pqmf_filter(n_bands, atten)
+        self.n_taps = h.shape[-1]-1
+        self.n_bands = n_bands
+        self.register_buffer("h", h)
+    def forward(self, x:torch.Tensor)-> torch.Tensor:
+        return F.conv1d(x, self.h, padding = self.n_taps // 2, stride=self.n_bands)
+
+class PQMF2Wave(nn.Module):
+    def __init__(self, n_bands:int = 16, atten:float = 100):
+        super().__init__()
+        h = get_pqmf_filter(n_bands, atten, False)
+        self.n_taps = h.shape[-1]-1
+        self.n_bands = n_bands
+        self.register_buffer("h", h)
+        updown_filter = torch.zeros((n_bands, n_bands, n_bands)).float()
+        updown_filter[range(n_bands), range(n_bands), 0] = 1
+        self.register_buffer("updown_filter", updown_filter)
+        self.pad_fn = torch.nn.ConstantPad1d(self.n_taps // 2, 0.0)
+
+    def forward(self, x:torch.Tensor)-> torch.Tensor:
+        x = F.conv_transpose1d(x, self.updown_filter * self.n_bands,stride=self.n_bands)
+        x = F.conv1d(x, self.h, padding = self.n_taps // 2)
+        return x

fakesound-0.0.0/src/fakesound/gansynth/dataset.py

@@ -0,0 +1,46 @@
+import numpy as np
+import glob, os
+import torch
+from fakesound.data.dataset import AudioDataSet
+from fakesound.data.transforms import Wave2LogMagIF
+
+# Lazy dataset for NSynth training set including pitch
+
+class NSynthDataset(AudioDataSet):
+    def __init__(self, folder_path:str, sample_rate:int,
+                       fft_size:int, hop_size:int, pad_start:int):
+        self.sample_rate = None
+        self.fft_size = fft_size
+        self.n_mels = fft_size // 2
+        self.pad_start = pad_start
+        self.transform = Wave2LogMagIF(fft_size, hop_size)
+
+        self.files = glob.glob(os.path.join(folder_path, "*.wav"))[:16]
+
+        self.max_mag = np.log(fft_size//4)
+        self.min_mag = np.log(self.transform.epsilon)
+        self.max_phase = np.pi
+        self.min_phase = -np.pi
+    def __len__(self):
+        return len(self.files)
+
+    def normalise_mag(self, x:torch.Tensor)-> torch.Tensor:
+        return 2 * (x - self.min_mag) / (self.max_mag - self.min_mag) -1
+    def normalise_phase(self, x:torch.Tensor)-> torch.Tensor:
+        return 2 * (x - self.min_phase) / (self.max_phase - self.min_phase) -1
+    def denormalise_mag(self, x:torch.Tensor)-> torch.Tensor:
+        return (x + 1)* (self.max_mag - self.min_mag) / 2 + self.min_mag
+    def denormalise_phase(self, x:torch.Tensor)-> torch.Tensor:
+        return (x + 1)* (self.max_phase - self.min_phase) / 2 + self.min_phase
+
+    # reset assumes no shuffling
+    def __getitem__(self, index:int):
+        filename = self.files[index]
+        pitch = int(filename.split("_")[-1].split("-")[1])
+        sample = self.load_audio(filename)
+        sample = np.pad(sample, (self.pad_start, 0))
+        sample = torch.from_numpy(sample).unsqueeze(0).float()
+        logmag, phase = self.transform(sample)
+        logmag = self.normalise_mag(logmag)
+        phase = self.normalise_phase(phase)
+        return torch.stack((logmag, phase)), pitch

fakesound-0.0.0/src/fakesound/gansynth/models.py

@@ -0,0 +1,89 @@
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+class PixelNorm(nn.Module):
+    def forward(self, x):
+        n_chan = x.shape[1]
+        return x  / (1/ n_chan * (x ** 2).sum(dim = 1, keepdims = True)).sqrt()
+
+class Generator(nn.Module):
+    def __init__(self, input_size:int = 317):
+        super().__init__()
+        self.input_size = input_size
+        self.input_block = nn.Sequential(
+                nn.Conv2d(input_size, 256, (16, 2)),
+                PixelNorm(), nn.LeakyReLU(),
+                nn.Conv2d(256, 256, 3, padding="same"),
+                PixelNorm(), nn.LeakyReLU())
+        self.upsample2x2 =  lambda c:  nn.ConvTranspose2d(c, c, (2,2),(2,2))
+        self.conv_block = lambda in_c, out_c: nn.Sequential(
+                nn.Conv2d(in_c, out_c, 3, padding="same"),
+                PixelNorm(), nn.LeakyReLU(),
+                nn.Conv2d(out_c, out_c, 3, padding="same"),
+                PixelNorm(), nn.LeakyReLU())
+        self.output = nn.Sequential(
+            nn.Conv2d(32, 2, 1),
+            nn.Tanh()
+        )
+
+        self.network = nn.Sequential(
+            self.input_block,
+            self.upsample2x2(256),
+            self.conv_block(256, 256),
+            self.upsample2x2(256),
+            self.conv_block(256, 256),
+            self.upsample2x2(256),
+            self.conv_block(256, 256),
+            self.upsample2x2(256),
+            self.conv_block(256, 128),
+            self.upsample2x2(128),
+            self.conv_block(128, 64),
+            self.upsample2x2(64),
+            self.conv_block(64, 32),
+            self.output
+        )
+    def forward(self, x:torch.Tensor)-> torch.Tensor:
+        x = F.pad(x,(1, 1, 15, 15))
+        return self.network(x)
+
+class Discriminator(nn.Module):
+    def __init__(self, num_classes:int):
+        super().__init__()
+        self.input = nn.Conv2d(2, 32, 1)
+        self.downsample2x2 =  lambda c:  nn.Conv2d(c, c, (2,2),(2,2))
+        self.conv_block = lambda in_c, out_c: nn.Sequential(
+                nn.Conv2d(in_c, out_c, 3, padding = "same"),
+                nn.LeakyReLU(),
+                nn.Conv2d(out_c, out_c, 3, padding = "same"),
+                nn.LeakyReLU()
+        )
+        self.last_conv = nn.Sequential(
+            nn.Conv2d(256, 256, 3, padding="same"),
+            nn.LeakyReLU(),
+            nn.Conv2d(256, 256, (16,2), padding="valid"),
+            nn.LeakyReLU()
+        )
+        self.disc_out = nn.Linear(256, 1)
+        self.classifier_out = nn.Linear(256, num_classes)
+
+        self.network = nn.Sequential(
+                    self.input,
+                    self.conv_block(32, 32),
+                    self.downsample2x2(32),
+                    self.conv_block(32, 64),
+                    self.downsample2x2(64),
+                    self.conv_block(64, 128),
+                    self.downsample2x2(128),
+                    self.conv_block(128, 256),
+                    self.downsample2x2(256),
+                    self.conv_block(256, 256),
+                    self.downsample2x2(256),
+                    self.conv_block(256, 256),
+                    self.downsample2x2(256),
+                    self.conv_block(256, 256),
+                    self.last_conv
+                )
+    def forward(self, x:torch.Tensor)-> torch.Tensor:
+        x =  self.network(x).flatten(1)
+        return  self.disc_out(x),  self.classifier_out(x)

fakesound-0.0.0/src/fakesound/gansynth/utils.py

@@ -0,0 +1,31 @@
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+gp_beta = 10
+pitch_beta = 10
+crossentropy = nn.CrossEntropyLoss()
+
+# https://github.com/EmilienDupont/wgan-gp/
+def gradient_penalty(real_data, fake_data, batch_size, disc, device):
+    alpha = torch.rand(batch_size, 1, 1, 1)
+    alpha = alpha.expand_as(real_data).to(device)
+    interpolated = alpha * real_data.detach() + (1 - alpha) * fake_data.detach()
+    interpolated = torch.autograd.Variable(interpolated, requires_grad=True)
+    prob, _ = disc(interpolated)
+    gradients = torch.autograd.grad(outputs = prob,
+                           inputs = interpolated,
+                           grad_outputs = torch.ones_like(prob),
+                           create_graph = True, retain_graph = True)[0]
+
+    gradients = gradients.view(batch_size, -1)
+    gradient_penalty = ((gradients.norm(2, dim=1) - 1) ** 2).mean()
+    return gradient_penalty
+
+def create_fake_data(generator, config):
+    fake_pitch = torch.randint( 0, 61, (config.batch_size,)).unsqueeze(1).to(config.device)
+    fake_pitch_vector = torch.zeros(config.batch_size, 61).to(config.device).scatter_(1, fake_pitch, 1).unsqueeze(2).unsqueeze(3).to(config.device)
+    noise = torch.randn(config.batch_size, config.latent_size, 1, 1).to(config.device)
+    gen_input =  torch.cat((noise, fake_pitch_vector), 1)
+    fake_mel = generator(gen_input)
+    return fake_pitch, fake_mel

fakesound-0.0.0/src/fakesound/hifigan/blocks.py

@@ -0,0 +1,57 @@
+# based on https://github.com/jik876/hifi-gan
+# only v1 implemented
+
+import torch
+from torch import nn
+from torch.nn.utils import remove_weight_norm
+from torch.nn.utils.parametrizations import weight_norm
+
+
+class ResidualBlock(torch.nn.Module):
+    def __init__(self, channels:int, kernel_size:int = 3, dilations:list[int] = [1, 3, 5]):
+        super().__init__()
+        self.conv = lambda d: weight_norm(
+            nn.Conv1d(channels, channels, kernel_size, 1,
+                dilation = d, padding = (kernel_size * d - d) // 2)
+        )
+        self.convs = nn.Sequential()
+        for d in dilations:
+            self.convs.extend(nn.Sequential(*[
+                nn.LeakyReLU(0.1), self.conv(d), nn.LeakyReLU(0.1), self.conv(1)
+            ]))
+    def forward(self, x:torch.Tensor)->torch.Tensor:
+        return x + self.convs(x)
+
+    def remove_weight_norm(self):
+        for l in self.convs:
+            if type(l) == nn.Conv1d:
+                remove_weight_norm(l)
+
+
+class UpsamplingBlock(torch.nn.Module):
+    def __init__(self, in_channels:int, out_channels:int, kernel_size:int, stride:int,
+                 res_channels:int, res_kernels:list[int], res_dilations:list[int]):
+        assert(len(res_kernels) == len(res_dilations))
+        super().__init__()
+        self.num_res_blocks = len(res_kernels)
+        self.relu = nn.LeakyReLU(0.1)
+        self.conv_transpose = nn.ConvTranspose1d(
+                            in_channels,out_channels, kernel_size, stride,
+                            (kernel_size - stride ) // 2)
+        self.res_blocks = nn.ModuleList(
+                [ResidualBlock(res_channels, res_kernels[i], res_dilations)
+                    for i in range(self.num_res_blocks)]
+        )
+
+    def forward(self, x:torch.Tensor)->torch.Tensor:
+        x = self.conv_transpose(self.relu(x))
+        xs = 0
+        for res_block in self.res_blocks:
+             xs += res_block(x)
+        x = xs / self.num_res_blocks
+        return x
+
+    def remove_weight_norm(self):
+        remove_weight_norm(self.conv_transpose)
+        for res_block in self.res_blocks:
+            res_block.remove_weight_norm()

fakesound-0.0.0/src/fakesound/hifigan/loss_funcs.py

@@ -0,0 +1,29 @@
+import torch
+
+def feature_loss(fmap_real:list, fmap_fake:list):
+    loss = 0
+    for disc_real, disc_fake  in zip(fmap_real, fmap_fake):
+        for layer_real, layer_fake in zip(disc_real, disc_fake):
+            loss += torch.mean(torch.abs(layer_real - layer_fake))
+    return loss * 2
+
+def discriminator_loss(disc_real:list, disc_fake:list):
+    loss = 0
+    real_losses = []
+    fake_losses = []
+    for subdisc_real, subdisc_fake in zip(disc_real, disc_fake):
+        real_loss = torch.mean((1 - subdisc_real) ** 2)
+        fake_loss = torch.mean(subdisc_fake ** 2)
+        loss += (real_loss + fake_loss)
+        real_losses.append(real_loss.item())
+        fake_losses.append(fake_loss.item())
+    return loss, real_losses, fake_losses
+
+def generator_loss(disc_outputs:list):
+    loss = 0
+    generator_losses = []
+    for subdisc_fake in disc_outputs:
+        l = torch.mean((1 - subdisc_fake) ** 2)
+        generator_losses.append(l)
+        loss += l
+    return loss, generator_losses