id int64 0 190k | prompt stringlengths 21 13.4M | docstring stringlengths 1 12k ⌀ |
|---|---|---|
13,989 | import os
import glob
import re
import sys
import argparse
import logging
import json
import subprocess
import warnings
import functools
import numpy as np
from scipy.io.wavfile import read
import torch
def summarize(writer, global_step, scalars={}, histograms={}, images={}, audios={}, audio_sampling_rate=22050):
... | null |
13,990 | import os
import glob
import re
import sys
import argparse
import logging
import json
import subprocess
import warnings
import functools
import numpy as np
from scipy.io.wavfile import read
import torch
def latest_checkpoint_path(dir_path, regex="G_*.pth"):
f_list = glob.glob(os.path.join(dir_path, regex))
f_l... | null |
13,991 | import os
import glob
import re
import sys
import argparse
import logging
import json
import subprocess
import warnings
import functools
import numpy as np
from scipy.io.wavfile import read
import torch
MATPLOTLIB_FLAG = False
def plot_spectrogram_to_numpy(spectrogram):
global MATPLOTLIB_FLAG
if not MATPLOTLIB... | null |
13,992 | import os
import glob
import re
import sys
import argparse
import logging
import json
import subprocess
import warnings
import functools
import numpy as np
from scipy.io.wavfile import read
import torch
MATPLOTLIB_FLAG = False
def plot_alignment_to_numpy(alignment, info=None):
global MATPLOTLIB_FLAG
if not MAT... | null |
13,993 | import os
import glob
import re
import sys
import argparse
import logging
import json
import subprocess
import warnings
import functools
import numpy as np
from scipy.io.wavfile import read
import torch
def load_wav_to_torch(full_path):
sampling_rate, data = read(full_path)
return torch.FloatTensor(data.astype... | null |
13,994 | import os
import glob
import re
import sys
import argparse
import logging
import json
import subprocess
import warnings
import functools
import numpy as np
from scipy.io.wavfile import read
import torch
def load_filepaths_and_text(filename, split="|"):
with open(filename, encoding="utf-8") as f:
filepaths_... | null |
13,995 | import os
import glob
import re
import sys
import argparse
import logging
import json
import subprocess
import warnings
import functools
import numpy as np
from scipy.io.wavfile import read
import torch
class HParams:
def __init__(self, **kwargs):
def keys(self):
def items(self):
def values(self):
... | null |
13,996 | import os
import glob
import re
import sys
import argparse
import logging
import json
import subprocess
import warnings
import functools
import numpy as np
from scipy.io.wavfile import read
import torch
class HParams:
def __init__(self, **kwargs):
for k, v in kwargs.items():
if type(v) == dict:
... | null |
13,997 | import os
import glob
import re
import sys
import argparse
import logging
import json
import subprocess
import warnings
import functools
import numpy as np
from scipy.io.wavfile import read
import torch
class HParams:
def __init__(self, **kwargs):
for k, v in kwargs.items():
if type(v) == dict:
... | null |
13,998 | import os
import glob
import re
import sys
import argparse
import logging
import json
import subprocess
import warnings
import functools
import numpy as np
from scipy.io.wavfile import read
import torch
logger = logging
def check_git_hash(model_dir):
source_dir = os.path.dirname(os.path.realpath(__file__))
if ... | null |
13,999 | import os
import glob
import re
import sys
import argparse
import logging
import json
import subprocess
import warnings
import functools
import numpy as np
from scipy.io.wavfile import read
import torch
logger = logging
def get_logger(model_dir, filename="train.log"):
global logger
logger = logging.getLogger(o... | null |
14,000 | import os
import glob
import re
import sys
import argparse
import logging
import json
import subprocess
import warnings
import functools
import numpy as np
from scipy.io.wavfile import read
import torch
def repeat_expand_2d(content, target_len):
# content : [h, t]
src_len = content.shape[-1]
target = torc... | null |
14,001 | import os
from pathlib import Path
import torch
import logging
import argparse
import numpy as np
from sklearn.cluster import KMeans, MiniBatchKMeans
import tqdm
logger = logging.getLogger(__name__)
import time
def train_cluster(in_dir, n_clusters, use_minibatch=True, verbose=False):
logger.info(f"Loading features... | null |
14,002 | import glob
import os
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def plot_spectrogram(spectrogram):
fig, ax = plt.subplots(figsize=(10, 2))
im = ax.imshow(spectrogram, aspect="auto", origin="lower", interpolation="none")
plt.colorbar(im, ax=ax)
fig.canvas.draw()... | null |
14,003 | import glob
import os
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def init_weights(m, mean=0.0, std=0.01):
classname = m.__class__.__name__
if classname.find("Conv") != -1:
m.weight.data.normal_(mean, std) | null |
14,004 | import glob
import os
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def apply_weight_norm(m):
classname = m.__class__.__name__
if classname.find("Conv") != -1:
weight_norm(m) | null |
14,005 | import glob
import os
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def get_padding(kernel_size, dilation=1):
return int((kernel_size * dilation - dilation) / 2) | null |
14,006 | import glob
import os
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def load_checkpoint(filepath, device):
assert os.path.isfile(filepath)
print("Loading '{}'".format(filepath))
checkpoint_dict = torch.load(filepath, map_location=device)
print("Complete.")
retur... | null |
14,007 | import glob
import os
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def save_checkpoint(filepath, obj):
print("Saving checkpoint to {}".format(filepath))
torch.save(obj, filepath)
print("Complete.") | null |
14,008 | import glob
import os
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def del_old_checkpoints(cp_dir, prefix, n_models=2):
pattern = os.path.join(cp_dir, prefix + "????????")
cp_list = glob.glob(pattern) # get checkpoint paths
cp_list = sorted(cp_list) # sort by iter
... | null |
14,009 | import glob
import os
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def scan_checkpoint(cp_dir, prefix):
pattern = os.path.join(cp_dir, prefix + "????????")
cp_list = glob.glob(pattern)
if len(cp_list) == 0:
return None
return sorted(cp_list)[-1] | null |
14,010 | import os
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import soundfile as sf
def load_wav_to_torch(full_path, target_sr=None, return_empty_on_exception=False):
sampling_rate = None
try:
data, sampling_rate = sf.read(full_path,... | null |
14,011 | import os
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import soundfile as sf
def dynamic_range_compression(x, C=1, clip_val=1e-5):
return np.log(np.clip(x, a_min=clip_val, a_max=None) * C) | null |
14,012 | import os
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import soundfile as sf
def dynamic_range_decompression(x, C=1):
return np.exp(x) / C | null |
14,013 | import os
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import soundfile as sf
def dynamic_range_compression_torch(x, C=1, clip_val=1e-5):
return torch.log(torch.clamp(x, min=clip_val) * C) | null |
14,014 | import os
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import soundfile as sf
def dynamic_range_decompression_torch(x, C=1):
return torch.exp(x) / C | null |
14,015 | import os
import json
from .env import AttrDict
import numpy as np
import torch
import torch.nn.functional as F
import torch.nn as nn
from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
from .utils import init_weights, get_padding
cla... | null |
14,016 | import os
import json
from .env import AttrDict
import numpy as np
import torch
import torch.nn.functional as F
import torch.nn as nn
from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
from .utils import init_weights, get_padding
de... | null |
14,017 | import os
import json
from .env import AttrDict
import numpy as np
import torch
import torch.nn.functional as F
import torch.nn as nn
from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
from .utils import init_weights, get_padding
de... | null |
14,018 | import os
import json
from .env import AttrDict
import numpy as np
import torch
import torch.nn.functional as F
import torch.nn as nn
from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
from .utils import init_weights, get_padding
de... | null |
14,019 | import os
import json
from .env import AttrDict
import numpy as np
import torch
import torch.nn.functional as F
import torch.nn as nn
from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
from .utils import init_weights, get_padding
de... | null |
14,020 | import os
import shutil
def build_env(config, config_name, path):
t_path = os.path.join(path, config_name)
if config != t_path:
os.makedirs(path, exist_ok=True)
shutil.copyfile(config, os.path.join(path, config_name)) | null |
14,021 | import glob
import os
import matplotlib
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def plot_spectrogram(spectrogram):
fig, ax = plt.subplots(figsize=(10, 2))
im = ax.imshow(spectrogram, aspect="auto", origin="lower", interpolation="none")
plt.colorbar(im, ax=ax)
... | null |
14,022 | import glob
import os
import matplotlib
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def init_weights(m, mean=0.0, std=0.01):
classname = m.__class__.__name__
if classname.find("Conv") != -1:
m.weight.data.normal_(mean, std) | null |
14,023 | import glob
import os
import matplotlib
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def apply_weight_norm(m):
classname = m.__class__.__name__
if classname.find("Conv") != -1:
weight_norm(m) | null |
14,024 | import glob
import os
import matplotlib
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def get_padding(kernel_size, dilation=1):
return int((kernel_size * dilation - dilation) / 2) | null |
14,025 | import glob
import os
import matplotlib
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def load_checkpoint(filepath, device):
assert os.path.isfile(filepath)
print("Loading '{}'".format(filepath))
checkpoint_dict = torch.load(filepath, map_location=device)
print("Com... | null |
14,026 | import glob
import os
import matplotlib
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def save_checkpoint(filepath, obj):
print("Saving checkpoint to {}".format(filepath))
torch.save(obj, filepath)
print("Complete.") | null |
14,027 | import glob
import os
import matplotlib
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def del_old_checkpoints(cp_dir, prefix, n_models=2):
pattern = os.path.join(cp_dir, prefix + "????????")
cp_list = glob.glob(pattern) # get checkpoint paths
cp_list = sorted(cp_list) ... | null |
14,028 | import glob
import os
import matplotlib
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def scan_checkpoint(cp_dir, prefix):
pattern = os.path.join(cp_dir, prefix + "????????")
cp_list = glob.glob(pattern)
if len(cp_list) == 0:
return None
return sorted(cp_lis... | null |
14,029 | import os
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import soundfile as sf
import torch.nn.functional as F
def load_wav_to_torch(full_path, target_sr=None, return_empty_on_exception=False):
sampling_rate = None
try:
data, sa... | null |
14,030 | import os
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import soundfile as sf
import torch.nn.functional as F
def dynamic_range_compression(x, C=1, clip_val=1e-5):
return np.log(np.clip(x, a_min=clip_val, a_max=None) * C) | null |
14,031 | import os
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import soundfile as sf
import torch.nn.functional as F
def dynamic_range_decompression(x, C=1):
return np.exp(x) / C | null |
14,032 | import os
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import soundfile as sf
import torch.nn.functional as F
def dynamic_range_compression_torch(x, C=1, clip_val=1e-5):
return torch.log(torch.clamp(x, min=clip_val) * C) | null |
14,033 | import os
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.filters import mel as librosa_mel_fn
import soundfile as sf
import torch.nn.functional as F
def dynamic_range_decompression_torch(x, C=1):
return torch.exp(x) / C | null |
14,034 | import os
import json
from .env import AttrDict
import numpy as np
import torch
import torch.nn.functional as F
import torch.nn as nn
from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
from .utils import init_weights, get_padding
cla... | null |
14,039 | import sys
import os
from dataclasses import asdict
import numpy as np
import torch
from data.ModelSlot import DDSPSVCModelSlot
from voice_changer.DDSP_SVC.deviceManager.DeviceManager import DeviceManager
from voice_changer.VoiceChangerParamsManager import VoiceChangerParamsManager
from .models.diffusion.infer_gt_mel i... | null |
14,040 | import copy
from typing import Optional, Tuple
import random
from sklearn.cluster import KMeans
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.modules.utils import consume_prefix_in_state_dict_if_present
def _compute_mask(
shape: Tuple[int, int],
mask_prob: float,
mask_len... | null |
14,041 | import copy
from typing import Optional, Tuple
import random
from sklearn.cluster import KMeans
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.modules.utils import consume_prefix_in_state_dict_if_present
URLS = {
"hubert-discrete": "https://github.com/bshall/hubert/releases/downloa... | r"""HuBERT-Discrete from `"A Comparison of Discrete and Soft Speech Units for Improved Voice Conversion"`. Args: pretrained (bool): load pretrained weights into the model progress (bool): show progress bar when downloading model |
14,042 | import copy
from typing import Optional, Tuple
import random
from sklearn.cluster import KMeans
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.modules.utils import consume_prefix_in_state_dict_if_present
URLS = {
"hubert-discrete": "https://github.com/bshall/hubert/releases/downloa... | r"""HuBERT-Soft from `"A Comparison of Discrete and Soft Speech Units for Improved Voice Conversion"`. Args: pretrained (bool): load pretrained weights into the model progress (bool): show progress bar when downloading model |
14,043 | import os
import time
import numpy as np
import torch
import librosa
from logger.saver import Saver
from logger import utils
from torch import autocast
from torch.cuda.amp import GradScaler
def test(args, model, vocoder, loader_test, saver):
def train(args, initial_global_step, model, optimizer, scheduler, vocoder, lo... | null |
14,044 | import torch
import torch.nn.functional as F
import math
The provided code snippet includes necessary dependencies for implementing the `model_wrapper` function. Write a Python function `def model_wrapper( model, noise_schedule, model_type="noise", model_kwargs={}, guidance_type="uncond", condi... | Create a wrapper function for the noise prediction model. |
14,045 | import torch
import torch.nn.functional as F
import math
The provided code snippet includes necessary dependencies for implementing the `interpolate_fn` function. Write a Python function `def interpolate_fn(x, xp, yp)` to solve the following problem:
A piecewise linear function y = f(x), using xp and yp as keypoints. ... | A piecewise linear function y = f(x), using xp and yp as keypoints. We implement f(x) in a differentiable way (i.e. applicable for autograd). The function f(x) is well-defined for all x-axis. (For x beyond the bounds of xp, we use the outmost points of xp to define the linear function.) Args: x: PyTorch tensor with sha... |
14,046 | import torch
import torch.nn.functional as F
import math
The provided code snippet includes necessary dependencies for implementing the `expand_dims` function. Write a Python function `def expand_dims(v, dims)` to solve the following problem:
Expand the tensor `v` to the dim `dims`. Args: `v`: a PyTorch tensor with sh... | Expand the tensor `v` to the dim `dims`. Args: `v`: a PyTorch tensor with shape [N]. `dim`: a `int`. Returns: a PyTorch tensor with shape [N, 1, 1, ..., 1] and the total dimension is `dims`. |
14,047 | from collections import deque
from functools import partial
from inspect import isfunction
import torch.nn.functional as F
import numpy as np
from torch.nn import Conv1d
from torch.nn import Mish
import torch
from torch import nn
from tqdm import tqdm
import math
def exists(x):
def default(val, d):
if exists(val):... | null |
14,048 | from collections import deque
from functools import partial
from inspect import isfunction
import torch.nn.functional as F
import numpy as np
from torch.nn import Conv1d
from torch.nn import Mish
import torch
from torch import nn
from tqdm import tqdm
import math
def extract(a, t):
return a[t].reshape((1, 1, 1, 1)... | null |
14,049 | from collections import deque
from functools import partial
from inspect import isfunction
import torch.nn.functional as F
import numpy as np
from torch.nn import Conv1d
from torch.nn import Mish
import torch
from torch import nn
from tqdm import tqdm
import math
def noise_like(shape, device, repeat=False):
repeat... | null |
14,050 | from collections import deque
from functools import partial
from inspect import isfunction
import torch.nn.functional as F
import numpy as np
from torch.nn import Conv1d
from torch.nn import Mish
import torch
from torch import nn
from tqdm import tqdm
import math
The provided code snippet includes necessary dependenci... | linear schedule |
14,051 | from collections import deque
from functools import partial
from inspect import isfunction
import torch.nn.functional as F
import numpy as np
from torch.nn import Conv1d
from torch.nn import Mish
import torch
from torch import nn
from tqdm import tqdm
import math
The provided code snippet includes necessary dependenci... | cosine schedule as proposed in https://openreview.net/forum?id=-NEXDKk8gZ |
14,052 | from collections import deque
from functools import partial
from inspect import isfunction
import torch.nn.functional as F
import numpy as np
from torch.nn import Conv1d
from torch.nn import Mish
import torch
from torch import nn
from tqdm import tqdm
import math
def extract_1(a, t):
return a[t].reshape((1, 1, 1, ... | null |
14,053 | from collections import deque
from functools import partial
from inspect import isfunction
import torch.nn.functional as F
import numpy as np
from torch.nn import Conv1d
from torch.nn import Mish
import torch
from torch import nn
from tqdm import tqdm
import math
def predict_stage0(noise_pred, noise_pred_prev):
re... | null |
14,054 | from collections import deque
from functools import partial
from inspect import isfunction
import torch.nn.functional as F
import numpy as np
from torch.nn import Conv1d
from torch.nn import Mish
import torch
from torch import nn
from tqdm import tqdm
import math
def predict_stage1(noise_pred, noise_list):
return ... | null |
14,055 | from collections import deque
from functools import partial
from inspect import isfunction
import torch.nn.functional as F
import numpy as np
from torch.nn import Conv1d
from torch.nn import Mish
import torch
from torch import nn
from tqdm import tqdm
import math
def predict_stage2(noise_pred, noise_list):
return ... | null |
14,056 | from collections import deque
from functools import partial
from inspect import isfunction
import torch.nn.functional as F
import numpy as np
from torch.nn import Conv1d
from torch.nn import Mish
import torch
from torch import nn
from tqdm import tqdm
import math
def predict_stage3(noise_pred, noise_list):
return ... | null |
14,057 | import os
import random
import re
import numpy as np
import librosa
import torch
from tqdm import tqdm
from torch.utils.data import Dataset
def traverse_dir(root_dir, extensions, amount=None, str_include=None, str_exclude=None, is_pure=False, is_sort=False, is_ext=True):
file_list = []
cnt = 0
for root, _,... | null |
14,058 | import os
import random
import re
import numpy as np
import librosa
import torch
from tqdm import tqdm
from torch.utils.data import Dataset
class AudioDataset(Dataset):
def __init__(
self,
path_root,
waveform_sec,
hop_size,
sample_rate,
load_a... | null |
14,059 | from collections import deque
from functools import partial
from inspect import isfunction
import torch.nn.functional as F
import numpy as np
import torch
from torch import nn
from tqdm import tqdm
def exists(x):
def default(val, d):
if exists(val):
return val
return d() if isfunction(d) else d | null |
14,060 | from collections import deque
from functools import partial
from inspect import isfunction
import torch.nn.functional as F
import numpy as np
import torch
from torch import nn
from tqdm import tqdm
def extract(a, t, x_shape):
b, *_ = t.shape
out = a.gather(-1, t)
return out.reshape(b, *((1,) * (len(x_shape... | null |
14,061 | from collections import deque
from functools import partial
from inspect import isfunction
import torch.nn.functional as F
import numpy as np
import torch
from torch import nn
from tqdm import tqdm
def noise_like(shape, device, repeat=False):
repeat_noise = lambda: torch.randn((1, *shape[1:]), device=device).repea... | null |
14,062 | from collections import deque
from functools import partial
from inspect import isfunction
import torch.nn.functional as F
import numpy as np
import torch
from torch import nn
from tqdm import tqdm
The provided code snippet includes necessary dependencies for implementing the `linear_beta_schedule` function. Write a P... | linear schedule |
14,063 | from collections import deque
from functools import partial
from inspect import isfunction
import torch.nn.functional as F
import numpy as np
import torch
from torch import nn
from tqdm import tqdm
The provided code snippet includes necessary dependencies for implementing the `cosine_beta_schedule` function. Write a P... | cosine schedule as proposed in https://openreview.net/forum?id=-NEXDKk8gZ |
14,064 | from diffusion_onnx import GaussianDiffusion
import os
import yaml
import torch
import torch.nn as nn
import numpy as np
from wavenet import WaveNet
import torch.nn.functional as F
import diffusion
class DotDict(dict):
def __getattr__(*args):
val = dict.get(*args)
return DotDict(va... | null |
14,065 | import os
import yaml
import torch
import torch.nn as nn
import numpy as np
from .diffusion import GaussianDiffusion
from .wavenet import WaveNet
from .vocoder import Vocoder
class DotDict(dict):
def __getattr__(*args): # type: ignore
val = dict.get(*args)
return DotDict(val) if type(val) is dict ... | null |
14,066 | import torch
def expand_dims(v, dims):
"""
Expand the tensor `v` to the dim `dims`.
Args:
`v`: a PyTorch tensor with shape [N].
`dim`: a `int`.
Returns:
a PyTorch tensor with shape [N, 1, 1, ..., 1] and the total dimension is `dims`.
"""
return v[(...,) + (None,) * (dims ... | Create a wrapper function for the noise prediction model. DPM-Solver needs to solve the continuous-time diffusion ODEs. For DPMs trained on discrete-time labels, we need to firstly wrap the model function to a noise prediction model that accepts the continuous time as the input. We support four types of the diffusion m... |
14,067 | import torch
The provided code snippet includes necessary dependencies for implementing the `interpolate_fn` function. Write a Python function `def interpolate_fn(x, xp, yp)` to solve the following problem:
A piecewise linear function y = f(x), using xp and yp as keypoints. We implement f(x) in a differentiable way (i... | A piecewise linear function y = f(x), using xp and yp as keypoints. We implement f(x) in a differentiable way (i.e. applicable for autograd). The function f(x) is well-defined for all x-axis. (For x beyond the bounds of xp, we use the outmost points of xp to define the linear function.) Args: x: PyTorch tensor with sha... |
14,068 | import torch
import torch.nn as nn
from torch.nn import functional as F
import math
import numpy as np
def MaskedAvgPool1d(x, kernel_size):
x = x.unsqueeze(1)
x = F.pad(x, ((kernel_size - 1) // 2, kernel_size // 2), mode="reflect")
mask = ~torch.isnan(x)
masked_x = torch.where(mask, x, torch.zeros_like... | null |
14,069 | import torch
import torch.nn as nn
from torch.nn import functional as F
import math
import numpy as np
def MedianPool1d(x, kernel_size):
x = x.unsqueeze(1)
x = F.pad(x, ((kernel_size - 1) // 2, kernel_size // 2), mode="reflect")
x = x.squeeze(1)
x = x.unfold(1, kernel_size, 1)
x, _ = torch.sort(x, ... | null |
14,070 | import torch
import torch.nn as nn
from torch.nn import functional as F
import math
import numpy as np
def upsample(signal, factor):
signal = signal.permute(0, 2, 1)
signal = nn.functional.interpolate(torch.cat((signal,signal[:,:,-1:]),2), size=signal.shape[-1] * factor + 1, mode='linear', align_corners=True)
... | null |
14,071 | import torch
import torch.nn as nn
from torch.nn import functional as F
import math
import numpy as np
def remove_above_fmax(amplitudes, pitch, fmax, level_start=1):
n_harm = amplitudes.shape[-1]
pitches = pitch * torch.arange(level_start, n_harm + level_start).to(pitch)
aa = (pitches < fmax).float() + 1e-... | null |
14,072 | import torch
import torch.nn as nn
from torch.nn import functional as F
import math
import numpy as np
def fft_convolve(audio,
impulse_response):
def frequency_impulse_response(magnitudes,
hann_window = True,
half_width_frames = None):
def ... | null |
14,073 | import torch
from torch import nn
import math
from functools import partial
from einops import rearrange, repeat
from local_attention import LocalAttention
import torch.nn.functional as F
def softmax_kernel(data, *, projection_matrix, is_query, normalize_data=True, eps=1e-4, device = None):
b, h, *_ = data.shape
... | null |
14,074 | import torch
from torch import nn
import math
from functools import partial
from einops import rearrange, repeat
from local_attention import LocalAttention
import torch.nn.functional as F
def empty(tensor):
return tensor.numel() == 0 | null |
14,075 | import torch
from torch import nn
import math
from functools import partial
from einops import rearrange, repeat
from local_attention import LocalAttention
import torch.nn.functional as F
def exists(val):
return val is not None
def default(val, d):
return val if exists(val) else d | null |
14,076 | import torch
from torch import nn
import math
from functools import partial
from einops import rearrange, repeat
from local_attention import LocalAttention
import torch.nn.functional as F
def cast_tuple(val):
return (val,) if not isinstance(val, tuple) else val | null |
14,077 | import torch
from torch import nn
import math
from functools import partial
from einops import rearrange, repeat
from local_attention import LocalAttention
import torch.nn.functional as F
def calc_same_padding(kernel_size):
pad = kernel_size // 2
return (pad, pad - (kernel_size + 1) % 2) | null |
14,078 | import torch
from torch import nn
import math
from functools import partial
from einops import rearrange, repeat
from local_attention import LocalAttention
import torch.nn.functional as F
def linear_attention(q, k, v):
if v is None:
#print (k.size(), q.size())
out = torch.einsum('...ed,...nd->...ne... | null |
14,079 | import torch
from torch import nn
import math
from functools import partial
from einops import rearrange, repeat
from local_attention import LocalAttention
import torch.nn.functional as F
def orthogonal_matrix_chunk(cols, qr_uniform_q = False, device = None):
unstructured_block = torch.randn((cols, cols), device = ... | null |
14,080 | import os
import numpy as np
import yaml
import torch
import torch.nn.functional as F
import pyworld as pw
import parselmouth
import torchcrepe
from transformers import HubertModel, Wav2Vec2FeatureExtractor
from fairseq import checkpoint_utils
from torch.nn.modules.utils import consume_prefix_in_state_dict_if_present
... | null |
14,081 | import gin
import numpy as np
import torch
import torch.nn as nn
from torch.nn.utils import weight_norm
from .pcmer import PCmer
The provided code snippet includes necessary dependencies for implementing the `split_to_dict` function. Write a Python function `def split_to_dict(tensor, tensor_splits)` to solve the follo... | Split a tensor into a dictionary of multiple tensors. |
14,082 | import glob
import os
import matplotlib
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def plot_spectrogram(spectrogram):
fig, ax = plt.subplots(figsize=(10, 2))
im = ax.imshow(spectrogram, aspect="auto", origin="lower",
interpolation='none')
plt.color... | null |
14,085 | import glob
import os
import matplotlib
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def get_padding(kernel_size, dilation=1):
return int((kernel_size*dilation - dilation)/2) | null |
14,088 | import glob
import os
import matplotlib
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def del_old_checkpoints(cp_dir, prefix, n_models=2):
pattern = os.path.join(cp_dir, prefix + '????????')
cp_list = glob.glob(pattern) # get checkpoint paths
cp_list = sorted(cp_list)# ... | null |
14,089 | import glob
import os
import matplotlib
import torch
from torch.nn.utils import weight_norm
import matplotlib.pylab as plt
def scan_checkpoint(cp_dir, prefix):
pattern = os.path.join(cp_dir, prefix + '????????')
cp_list = glob.glob(pattern)
if len(cp_list) == 0:
return None
return sorted(cp_lis... | null |
14,090 | import math
import os
import random
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.util import normalize
from librosa.filters import mel as librosa_mel_fn
from scipy.io.wavfile import read
import soundfile as sf
import torch.nn.functional as F
def load_wav_to_torch(full_path, targe... | null |
14,091 | import math
import os
import random
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.util import normalize
from librosa.filters import mel as librosa_mel_fn
from scipy.io.wavfile import read
import soundfile as sf
import torch.nn.functional as F
def dynamic_range_compression(x, C=1, ... | null |
14,092 | import math
import os
import random
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.util import normalize
from librosa.filters import mel as librosa_mel_fn
from scipy.io.wavfile import read
import soundfile as sf
import torch.nn.functional as F
def dynamic_range_decompression(x, C=1... | null |
14,093 | import math
import os
import random
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.util import normalize
from librosa.filters import mel as librosa_mel_fn
from scipy.io.wavfile import read
import soundfile as sf
import torch.nn.functional as F
def dynamic_range_compression_torch(x,... | null |
14,094 | import math
import os
import random
import torch
import torch.utils.data
import numpy as np
import librosa
from librosa.util import normalize
from librosa.filters import mel as librosa_mel_fn
from scipy.io.wavfile import read
import soundfile as sf
import torch.nn.functional as F
def dynamic_range_decompression_torch(... | null |
14,095 | import os
import json
from .env import AttrDict
import numpy as np
import torch
import torch.nn.functional as F
import torch.nn as nn
from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
from .utils import init_weights, get_padding
def... | null |
14,097 | import os
import json
from .env import AttrDict
import numpy as np
import torch
import torch.nn.functional as F
import torch.nn as nn
from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
from .utils import init_weights, get_padding
de... | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.