remove dead code

.gitignore

@@ -1,3 +1,2 @@
 __pycache__/
 *.pyc
-DEPLOY.md

networks/ncsnpp.py

@@ -273,11 +273,6 @@ class NCSNpp(nn.Module):
 
         self.all_modules = nn.ModuleList(modules)
 
-    @staticmethod
-    def add_argparse_args(parser):
-        # parser.add_argument("--no-centered", dest="centered", action="store_false", help="The data is not centered")
-        return parser
-
     def forward(self, x, time_cond=None):
         """
         - x: b,2*D,F,T: contains x and y OR x: b,D,F,T contains only x

networks/ncsnpp_utils/utils.py

@@ -1,225 +0,0 @@
-# coding=utf-8
-# Copyright 2020 The Google Research Authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""All functions and modules related to model definition.
-"""
-
-import torch
-#import sde_lib
-import numpy as np
-from ...sdes import *
-
-
-_MODELS = {}
-
-
-def variance_scaling(scale, mode, distribution,
-                     in_axis=1, out_axis=0,
-                     dtype=torch.float32,
-                     device='cpu'):
-  """Ported from JAX. """
-
-  def _compute_fans(shape, in_axis=1, out_axis=0):
-    receptive_field_size = np.prod(shape) / shape[in_axis] / shape[out_axis]
-    fan_in = shape[in_axis] * receptive_field_size
-    fan_out = shape[out_axis] * receptive_field_size
-    return fan_in, fan_out
-
-  def init(shape, dtype=dtype, device=device):
-    fan_in, fan_out = _compute_fans(shape, in_axis, out_axis)
-    if mode == "fan_in":
-      denominator = fan_in
-    elif mode == "fan_out":
-      denominator = fan_out
-    elif mode == "fan_avg":
-      denominator = (fan_in + fan_out) / 2
-    else:
-      raise ValueError(
-        "invalid mode for variance scaling initializer: {}".format(mode))
-    variance = scale / denominator
-    if distribution == "normal":
-      return torch.randn(*shape, dtype=dtype, device=device) * np.sqrt(variance)
-    elif distribution == "uniform":
-      return (torch.rand(*shape, dtype=dtype, device=device) * 2. - 1.) * np.sqrt(3 * variance)
-    else:
-      raise ValueError("invalid distribution for variance scaling initializer")
-
-  return init
-  
-
-def register_model(cls=None, *, name=None):
-  """A decorator for registering model classes."""
-
-  def _register(cls):
-    if name is None:
-      local_name = cls.__name__
-    else:
-      local_name = name
-    if local_name in _MODELS:
-      raise ValueError(f'Already registered model with name: {local_name}')
-    _MODELS[local_name] = cls
-    return cls
-
-  if cls is None:
-    return _register
-  else:
-    return _register(cls)
-
-
-def get_model(name):
-  return _MODELS[name]
-
-
-def get_sigmas(sigma_min, sigma_max, num_scales):
-  """Get sigmas --- the set of noise levels for SMLD from config files.
-  Args:
-    config: A ConfigDict object parsed from the config file
-  Returns:
-    sigmas: a jax numpy arrary of noise levels
-  """
-  sigmas = np.exp(
-    np.linspace(np.log(sigma_max), np.log(sigma_min), num_scales))
-
-  return sigmas
-
-
-def get_ddpm_params(config):
-  """Get betas and alphas --- parameters used in the original DDPM paper."""
-  num_diffusion_timesteps = 1000
-  # parameters need to be adapted if number of time steps differs from 1000
-  beta_start = config.model.beta_min / config.model.num_scales
-  beta_end = config.model.beta_max / config.model.num_scales
-  betas = np.linspace(beta_start, beta_end, num_diffusion_timesteps, dtype=np.float64)
-
-  alphas = 1. - betas
-  alphas_cumprod = np.cumprod(alphas, axis=0)
-  sqrt_alphas_cumprod = np.sqrt(alphas_cumprod)
-  sqrt_1m_alphas_cumprod = np.sqrt(1. - alphas_cumprod)
-
-  return {
-    'betas': betas,
-    'alphas': alphas,
-    'alphas_cumprod': alphas_cumprod,
-    'sqrt_alphas_cumprod': sqrt_alphas_cumprod,
-    'sqrt_1m_alphas_cumprod': sqrt_1m_alphas_cumprod,
-    'beta_min': beta_start * (num_diffusion_timesteps - 1),
-    'beta_max': beta_end * (num_diffusion_timesteps - 1),
-    'num_diffusion_timesteps': num_diffusion_timesteps
-  }
-
-
-def create_model(config):
-  """Create the score model."""
-  model_name = config.model.name
-  score_model = get_model(model_name)(config)
-  score_model = score_model.to(config.device)
-  score_model = torch.nn.DataParallel(score_model)
-  return score_model
-
-
-def get_model_fn(model, train=False):
-  """Create a function to give the output of the score-based model.
-
-  Args:
-    model: The score model.
-    train: `True` for training and `False` for evaluation.
-
-  Returns:
-    A model function.
-  """
-
-  def model_fn(x, labels):
-    """Compute the output of the score-based model.
-
-    Args:
-      x: A mini-batch of input data.
-      labels: A mini-batch of conditioning variables for time steps. Should be interpreted differently
-        for different models.
-
-    Returns:
-      A tuple of (model output, new mutable states)
-    """
-    if not train:
-      model.eval()
-      return model(x, labels)
-    else:
-      model.train()
-      return model(x, labels)
-
-  return model_fn
-
-
-def get_score_fn(sde, model, train=False, continuous=False):
-  """Wraps `score_fn` so that the model output corresponds to a real time-dependent score function.
-
-  Args:
-    sde: An `sde_lib.SDE` object that represents the forward SDE.
-    model: A score model.
-    train: `True` for training and `False` for evaluation.
-    continuous: If `True`, the score-based model is expected to directly take continuous time steps.
-
-  Returns:
-    A score function.
-  """
-  model_fn = get_model_fn(model, train=train)
-
-  #if isinstance(sde, sde_lib.VPSDE) or isinstance(sde, sde_lib.subVPSDE):
-  if isinstance(sde, OUVPSDE):
-    def score_fn(x, t):
-      # Scale neural network output by standard deviation and flip sign
-      if continuous or isinstance(sde, sde_lib.subVPSDE):
-        # For VP-trained models, t=0 corresponds to the lowest noise level
-        # The maximum value of time embedding is assumed to 999 for
-        # continuously-trained models.
-        labels = t * 999
-        score = model_fn(x, labels)
-        std = sde.marginal_prob(torch.zeros_like(x), t)[1]
-      else:
-        # For VP-trained models, t=0 corresponds to the lowest noise level
-        labels = t * (sde.N - 1)
-        score = model_fn(x, labels)
-        std = sde.sqrt_1m_alphas_cumprod.to(labels.device)[labels.long()]
-
-      score = -score / std[:, None, None, None]
-      return score
-
-  #elif isinstance(sde, sde_lib.VESDE):
-  elif isinstance(sde, OUVESDE):
-    def score_fn(x, t):
-      if continuous:
-        labels = sde.marginal_prob(torch.zeros_like(x), t)[1]
-      else:
-        # For VE-trained models, t=0 corresponds to the highest noise level
-        labels = sde.T - t
-        labels *= sde.N - 1
-        labels = torch.round(labels).long()
-
-      score = model_fn(x, labels)
-      return score
-
-  else:
-    raise NotImplementedError(f"SDE class {sde.__class__.__name__} not yet supported.")
-
-  return score_fn
-
-
-def to_flattened_numpy(x):
-  """Flatten a torch tensor `x` and convert it to numpy."""
-  return x.detach().cpu().numpy().reshape((-1,))
-
-
-def from_flattened_numpy(x, shape):
-  """Form a torch tensor with the given `shape` from a flattened numpy array `x`."""
-  return torch.from_numpy(x.reshape(shape))

testing/Sampler.py

@@ -1,5 +1,4 @@
 
-from tqdm import tqdm
 import torch
 import abc
 
@@ -71,16 +70,3 @@ class Sampler():
         x_hat = self.diff_params.denoiser(x.unsqueeze(1), self.model, t_i).squeeze(1)
         return x_hat
 
-class NoSampler(Sampler):
-
-    def predict(self, *args, **kwargs):
-        return None
-
-    def predict_unconditional(self, *args, **kwargs):
-        return None
-
-    def predict_conditional(self, *args, **kwargs):
-        return None
-
-    def step(self, *args, **kwargs):
-        return None

utils/reverb_utils.py

@@ -22,40 +22,3 @@ def minimum_phase_version(h):
     minimum_phase_h = minimum_phase_h[: -T_orig]
     return minimum_phase_h
 
-def fast_apply_RIR(y, filter, rm_delay=False, zero_pad=False):
-
-    if rm_delay:
-        filter = filter[ torch.argmax(filter): ]
-
-    filter = filter.unsqueeze(0).unsqueeze(0)
-    B = filter.to(y.device)
-    y = y.unsqueeze(1)
-    
-    # Get the size of the input signal and filter
-    N = y.size(2)
-    M = filter.size(2)
-    
-    # Compute the size of the FFT
-    if zero_pad:
-        fft_size=torch.tensor(2*N+2*M-1)
-    else:
-        fft_size=torch.tensor(N+M-1)
-    fft_size=int(2**torch.ceil(torch.log2(fft_size)))
-    
-    # Perform FFT on the input signal and filter
-    Y = torch.fft.fft(y, fft_size, dim=2)
-    H = torch.fft.fft(B, fft_size, dim=2)
-    
-    # Perform element-wise multiplication in the frequency domain
-    Y_conv = Y * H
-    
-    # Perform inverse FFT to get the convolution result
-    y_conv = torch.fft.ifft(Y_conv, fft_size, dim=2)
-    
-    # Take the real part of the result
-    y_conv = y_conv[:, :, :N].real
-    
-    # Squeeze the unnecessary dimensions
-    y_conv = y_conv.squeeze(1)
-
-    return y_conv