Code Improvements

.gitignore

@@ -1,6 +1,134 @@
-*.pyc
-__pycache__/
-*/__pycache__/
-alias_free_cuda/build/
+# BigVGAN
+alias_free_activation/cuda/build/
 exp/
-tmp/
+tmp/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+.idea/

LICENSE

@@ -10,12 +10,12 @@ 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. 
+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.
+SOFTWARE.

activations.py

@@ -7,7 +7,7 @@
 
 
 class Snake(nn.Module):
-    '''
+    """
     Implementation of a sine-based periodic activation function
     Shape:
         - Input: (B, C, T)
@@ -21,37 +21,40 @@ class Snake(nn.Module):
         >>> a1 = snake(256)
         >>> x = torch.randn(256)
         >>> x = a1(x)
-    '''
-    def __init__(self, in_features, alpha=1.0, alpha_trainable=True, alpha_logscale=False):
-        '''
+    """
+
+    def __init__(
+        self, in_features, alpha=1.0, alpha_trainable=True, alpha_logscale=False
+    ):
+        """
         Initialization.
         INPUT:
             - in_features: shape of the input
             - alpha: trainable parameter
             alpha is initialized to 1 by default, higher values = higher-frequency.
             alpha will be trained along with the rest of your model.
-        '''
+        """
         super(Snake, self).__init__()
         self.in_features = in_features
 
-        # initialize alpha
+        # Initialize alpha
         self.alpha_logscale = alpha_logscale
-        if self.alpha_logscale: # log scale alphas initialized to zeros
+        if self.alpha_logscale:  # Log scale alphas initialized to zeros
             self.alpha = Parameter(torch.zeros(in_features) * alpha)
-        else: # linear scale alphas initialized to ones
+        else:  # Linear scale alphas initialized to ones
             self.alpha = Parameter(torch.ones(in_features) * alpha)
 
         self.alpha.requires_grad = alpha_trainable
 
         self.no_div_by_zero = 0.000000001
 
     def forward(self, x):
-        '''
+        """
         Forward pass of the function.
         Applies the function to the input elementwise.
         Snake ∶= x + 1/a * sin^2 (xa)
-        '''
-        alpha = self.alpha.unsqueeze(0).unsqueeze(-1) # line up with x to [B, C, T]
+        """
+        alpha = self.alpha.unsqueeze(0).unsqueeze(-1)  # Line up with x to [B, C, T]
         if self.alpha_logscale:
             alpha = torch.exp(alpha)
         x = x + (1.0 / (alpha + self.no_div_by_zero)) * pow(sin(x * alpha), 2)
@@ -60,7 +63,7 @@ def forward(self, x):
 
 
 class SnakeBeta(nn.Module):
-    '''
+    """
     A modified Snake function which uses separate parameters for the magnitude of the periodic components
     Shape:
         - Input: (B, C, T)
@@ -75,9 +78,12 @@ class SnakeBeta(nn.Module):
         >>> a1 = snakebeta(256)
         >>> x = torch.randn(256)
         >>> x = a1(x)
-    '''
-    def __init__(self, in_features, alpha=1.0, alpha_trainable=True, alpha_logscale=False):
-        '''
+    """
+
+    def __init__(
+        self, in_features, alpha=1.0, alpha_trainable=True, alpha_logscale=False
+    ):
+        """
         Initialization.
         INPUT:
             - in_features: shape of the input
@@ -86,16 +92,16 @@ def __init__(self, in_features, alpha=1.0, alpha_trainable=True, alpha_logscale=
             alpha is initialized to 1 by default, higher values = higher-frequency.
             beta is initialized to 1 by default, higher values = higher-magnitude.
             alpha will be trained along with the rest of your model.
-        '''
+        """
         super(SnakeBeta, self).__init__()
         self.in_features = in_features
 
-        # initialize alpha
+        # Initialize alpha
         self.alpha_logscale = alpha_logscale
-        if self.alpha_logscale: # log scale alphas initialized to zeros
+        if self.alpha_logscale:  # Log scale alphas initialized to zeros
             self.alpha = Parameter(torch.zeros(in_features) * alpha)
             self.beta = Parameter(torch.zeros(in_features) * alpha)
-        else: # linear scale alphas initialized to ones
+        else:  # Linear scale alphas initialized to ones
             self.alpha = Parameter(torch.ones(in_features) * alpha)
             self.beta = Parameter(torch.ones(in_features) * alpha)
 
@@ -105,16 +111,16 @@ def __init__(self, in_features, alpha=1.0, alpha_trainable=True, alpha_logscale=
         self.no_div_by_zero = 0.000000001
 
     def forward(self, x):
-        '''
+        """
         Forward pass of the function.
         Applies the function to the input elementwise.
         SnakeBeta ∶= x + 1/b * sin^2 (xa)
-        '''
-        alpha = self.alpha.unsqueeze(0).unsqueeze(-1) # line up with x to [B, C, T]
+        """
+        alpha = self.alpha.unsqueeze(0).unsqueeze(-1)  # Line up with x to [B, C, T]
         beta = self.beta.unsqueeze(0).unsqueeze(-1)
         if self.alpha_logscale:
             alpha = torch.exp(alpha)
             beta = torch.exp(beta)
         x = x + (1.0 / (beta + self.no_div_by_zero)) * pow(sin(x * alpha), 2)
 
-        return x
+        return x

alias_free_cuda/activation1d.py → alias_free_activation/cuda/activation1d.py

@@ -3,19 +3,26 @@
 
 import torch
 import torch.nn as nn
-from alias_free_torch.resample import UpSample1d, DownSample1d
+from alias_free_activation.torch.resample import UpSample1d, DownSample1d
+
 # load fused CUDA kernel: this enables importing anti_alias_activation_cuda
-from alias_free_cuda import load
+from cuda import load
+
 load.load()
 
+
 class FusedAntiAliasActivation(torch.autograd.Function):
     """
     Assumes filter size 12, replication padding on upsampling, and logscale alpha/beta parameters as inputs
     """
+
     @staticmethod
     def forward(ctx, inputs, ftr, alpha, beta):
-        import anti_alias_activation_cuda
-        activation_results = anti_alias_activation_cuda.forward(inputs, ftr, alpha, beta)
+        from load import anti_alias_activation_cuda
+
+        activation_results = anti_alias_activation_cuda.forward(
+            inputs, ftr, alpha, beta
+        )
         return activation_results
 
     @staticmethod
@@ -24,24 +31,25 @@ def backward(ctx, output_grads):
         raise NotImplementedError
         return output_grads, None, None
 
+
 class Activation1d(nn.Module):
-    def __init__(self,
-                 activation,
-                 up_ratio: int = 2,
-                 down_ratio: int = 2,
-                 up_kernel_size: int = 12,
-                 down_kernel_size: int = 12,
-                 fused: bool = True
-                 ):
+    def __init__(
+        self,
+        activation,
+        up_ratio: int = 2,
+        down_ratio: int = 2,
+        up_kernel_size: int = 12,
+        down_kernel_size: int = 12,
+        fused: bool = True,
+    ):
         super().__init__()
         self.up_ratio = up_ratio
         self.down_ratio = down_ratio
         self.act = activation
         self.upsample = UpSample1d(up_ratio, up_kernel_size)
         self.downsample = DownSample1d(down_ratio, down_kernel_size)
 
-        self.fused = fused # whether to use fused CUDA kernel or not
-
+        self.fused = fused  # Whether to use fused CUDA kernel or not
 
     def forward(self, x):
         if not self.fused:
@@ -51,11 +59,15 @@ def forward(self, x):
             return x
         else:
             if self.act.__class__.__name__ == "Snake":
-                beta = self.act.alpha.data # snake uses same params for alpha and beta
+                beta = self.act.alpha.data  # Snake uses same params for alpha and beta
             else:
-                beta = self.act.beta.data # snakebeta uses different params for alpha and beta
+                beta = (
+                    self.act.beta.data
+                )  # Snakebeta uses different params for alpha and beta
             alpha = self.act.alpha.data
-            if not self.act.alpha_logscale: # exp baked into cuda kernel, cancel it out with a log
+            if (
+                not self.act.alpha_logscale
+            ):  # Exp baked into cuda kernel, cancel it out with a log
                 alpha = torch.log(alpha)
                 beta = torch.log(beta)
             x = FusedAntiAliasActivation.apply(x, self.upsample.filter, alpha, beta)