SYMBOL INDEX (411 symbols across 71 files)

FILE: examples/librimix/tse/v1/local/prepare_librimix_enroll.py
  function prepare_librimix_enroll (line 9) | def prepare_librimix_enroll(wav_scp,
  function prepare_librimix_enroll_v2 (line 46) | def prepare_librimix_enroll_v2(wav_scp,

FILE: examples/librimix/tse/v1/local/prepare_spk2enroll_librispeech.py
  function get_spk2utt (line 9) | def get_spk2utt(paths, audio_format="flac"):
  function get_spk2utt_librimix (line 21) | def get_spk2utt_librimix(paths, audio_format="flac"):

FILE: examples/librimix/tse/v2/local/prepare_librimix_enroll.py
  function prepare_librimix_enroll (line 9) | def prepare_librimix_enroll(wav_scp,
  function prepare_librimix_enroll_v2 (line 46) | def prepare_librimix_enroll_v2(wav_scp,

FILE: examples/librimix/tse/v2/local/prepare_spk2enroll_librispeech.py
  function get_spk2utt (line 9) | def get_spk2utt(paths, audio_format="flac"):
  function get_spk2utt_librimix (line 21) | def get_spk2utt_librimix(paths, audio_format="flac"):

FILE: examples/voxceleb1/v2/local/prepare_librimix_enroll.py
  function prepare_librimix_enroll (line 9) | def prepare_librimix_enroll(wav_scp,
  function prepare_librimix_enroll_v2 (line 46) | def prepare_librimix_enroll_v2(wav_scp,

FILE: examples/voxceleb1/v2/local/prepare_spk2enroll_librispeech.py
  function get_spk2utt_vox1 (line 9) | def get_spk2utt_vox1(paths, audio_format="flac"):
  function get_spk2utt (line 22) | def get_spk2utt(paths, audio_format="flac"):
  function get_spk2utt_librimix (line 34) | def get_spk2utt_librimix(paths, audio_format="flac"):

FILE: examples/voxceleb1/v2/local/prepare_spk2enroll_vox.py
  function get_spk2utt_from_wavscp (line 6) | def get_spk2utt_from_wavscp(wav_scp_path):

FILE: runtime/bin/separate_main.cc
  function main (line 36) | int main(int argc, char* argv[]) {

FILE: runtime/frontend/fbank.h
  function namespace (line 27) | namespace wenet {

FILE: runtime/frontend/feature_pipeline.cc
  type wenet (line 20) | namespace wenet {

FILE: runtime/frontend/feature_pipeline.h
  function namespace (line 27) | namespace wenet {
  function class (line 56) | class FeaturePipeline {

FILE: runtime/frontend/fft.cc
  type wenet (line 9) | namespace wenet {
    function make_sintbl (line 11) | void make_sintbl(int n, float* sintbl) {
    function make_bitrev (line 37) | void make_bitrev(int n, int* bitrev) {
    function fft (line 59) | int fft(const int* bitrev, const float* sintbl, float* x, float* y, in...

FILE: runtime/frontend/fft.h
  function namespace (line 13) | namespace wenet {

FILE: runtime/frontend/wav.h
  function namespace (line 34) | namespace wenet {

FILE: runtime/separate/separate_engine.cc
  type wesep (line 29) | namespace wesep {

FILE: runtime/separate/separate_engine.h
  function namespace (line 27) | namespace wesep {

FILE: runtime/utils/blocking_queue.h
  function namespace (line 24) | namespace wenet {

FILE: runtime/utils/timer.h
  function namespace (line 20) | namespace wenet {

FILE: runtime/utils/utils.cc
  type wesep (line 26) | namespace wesep {
    function Ltrim (line 28) | std::string Ltrim(const std::string& str) {
    function Rtrim (line 33) | std::string Rtrim(const std::string& str) {
    function Trim (line 38) | std::string Trim(const std::string& str) { return Rtrim(Ltrim(str)); }
    function SplitString (line 40) | void SplitString(const std::string& str, std::vector<std::string>* str...
    function SplitStringToVector (line 44) | void SplitStringToVector(const std::string& full, const char* delim,
    function ToWString (line 59) | std::wstring ToWString(const std::string& str) {

FILE: runtime/utils/utils.h
  function namespace (line 22) | namespace wesep {

FILE: tools/extract_embed_depreciated.py
  function get_args (line 26) | def get_args():
  function compute_fbank (line 37) | def compute_fbank(wav_path,
  function main (line 62) | def main():

FILE: tools/make_lmdb.py
  function get_args (line 23) | def get_args():
  function main (line 31) | def main():

FILE: tools/make_shard_list_premix.py
  function write_tar_file (line 29) | def write_tar_file(data_list, tar_file, index=0, total=1):
  function get_args (line 76) | def get_args():
  function main (line 101) | def main():

FILE: tools/make_shard_online.py
  function write_tar_file (line 28) | def write_tar_file(data_list, tar_file, index=0, total=1):
  function get_args (line 65) | def get_args():
  function main (line 90) | def main():

FILE: tools/test_dataset.py
  function test_premixed_dataset (line 8) | def test_premixed_dataset():
  function test_online_dataset (line 31) | def test_online_dataset():

FILE: wesep/bin/average_model.py
  function get_args (line 25) | def get_args():
  function main (line 64) | def main():

FILE: wesep/bin/export_jit.py
  function get_args (line 13) | def get_args():
  function main (line 22) | def main():

FILE: wesep/bin/infer.py
  function infer (line 27) | def infer(config="confs/conf.yaml", **kwargs):

FILE: wesep/bin/score.py
  function get_readers (line 19) | def get_readers(scps: List[str], dtype: str):
  function read_audio (line 25) | def read_audio(reader, key, audio_format="sound"):
  function scoring (line 32) | def scoring(
  function get_parser (line 218) | def get_parser():
  function main (line 316) | def main(cmd=None):

FILE: wesep/bin/train.py
  function train (line 51) | def train(config="conf/config.yaml", **kwargs):

FILE: wesep/bin/train_gan.py
  function train (line 51) | def train(config="conf/config.yaml", **kwargs):

FILE: wesep/cli/extractor.py
  class Extractor (line 18) | class Extractor:
    method __init__ (line 20) | def __init__(self, model_dir: str):
    method set_wavform_norm (line 47) | def set_wavform_norm(self, wavform_norm: bool):
    method set_resample_rate (line 50) | def set_resample_rate(self, resample_rate: int):
    method set_vad (line 53) | def set_vad(self, apply_vad: bool):
    method set_device (line 56) | def set_device(self, device: str):
    method set_output_norm (line 60) | def set_output_norm(self, output_norm: bool):
    method compute_fbank (line 63) | def compute_fbank(
    method extract_speech (line 83) | def extract_speech(self, audio_path: str, audio_path_2: str):
    method extract_speech_from_pcm (line 95) | def extract_speech_from_pcm(self,
  function load_model (line 162) | def load_model(language: str) -> Extractor:
  function load_model_local (line 167) | def load_model_local(model_dir: str) -> Extractor:
  function main (line 171) | def main():

FILE: wesep/cli/hub.py
  function download (line 27) | def download(url: str, dest: str, only_child=True):
  class Hub (line 87) | class Hub(object):
    method __init__ (line 99) | def __init__(self) -> None:
    method get_model (line 103) | def get_model(lang: str) -> str:

FILE: wesep/cli/utils.py
  function get_args (line 4) | def get_args():

FILE: wesep/dataset/FRAM_RIR.py
  function calc_cos (line 26) | def calc_cos(orientation_rad):
  function freq_invariant_decay_func (line 43) | def freq_invariant_decay_func(cos_theta, pattern="cardioid"):
  function freq_invariant_src_decay_func (line 73) | def freq_invariant_src_decay_func(mic_pos,
  function freq_invariant_mic_decay_func (line 99) | def freq_invariant_mic_decay_func(mic_pos,
  function FRAM_RIR (line 126) | def FRAM_RIR(
  function sample_mic_arch (line 358) | def sample_mic_arch(n_mic, mic_spacing=None, bounding_box=None):
  function sample_src_pos (line 390) | def sample_src_pos(
  function sample_mic_array_pos (line 414) | def sample_mic_array_pos(mic_arch, room_dim, min_dis_wall=None):
  function sample_a_config (line 482) | def sample_a_config(simu_config):
  function single_channel (line 514) | def single_channel(simu_config):
  function multi_channel_array (line 526) | def multi_channel_array(simu_config):
  function multi_channel_adhoc (line 539) | def multi_channel_adhoc(simu_config):
  function multi_channel_src_orientation (line 554) | def multi_channel_src_orientation():
  function multi_channel_mic_orientation (line 592) | def multi_channel_mic_orientation():

FILE: wesep/dataset/dataset.py
  class Processor (line 26) | class Processor(IterableDataset):
    method __init__ (line 28) | def __init__(self, source, f, *args, **kw):
    method set_epoch (line 35) | def set_epoch(self, epoch):
    method __iter__ (line 38) | def __iter__(self):
    method apply (line 46) | def apply(self, f):
  class DistributedSampler (line 51) | class DistributedSampler:
    method __init__ (line 53) | def __init__(self, shuffle=True, partition=True):
    method update (line 59) | def update(self):
    method set_epoch (line 81) | def set_epoch(self, epoch):
    method sample (line 84) | def sample(self, data):
  class DataList (line 106) | class DataList(IterableDataset):
    method __init__ (line 108) | def __init__(self,
    method set_epoch (line 117) | def set_epoch(self, epoch):
    method __iter__ (line 120) | def __iter__(self):
  function tse_collate_fn_2spk (line 139) | def tse_collate_fn_2spk(batch, mode="min"):
  function tse_collate_fn (line 206) | def tse_collate_fn(batch, mode="min"):
  function Dataset (line 267) | def Dataset(

FILE: wesep/dataset/lmdb_data.py
  class LmdbData (line 21) | class LmdbData:
    method __init__ (line 23) | def __init__(self, lmdb_file):
    method random_one (line 34) | def random_one(self):
    method __del__ (line 43) | def __del__(self):

FILE: wesep/dataset/processor.py
  function url_opener (line 32) | def url_opener(data):
  function tar_file_and_group (line 63) | def tar_file_and_group(data):
  function tar_file_and_group_single_spk (line 128) | def tar_file_and_group_single_spk(data):
  function parse_raw_single_spk (line 180) | def parse_raw_single_spk(data):
  function mix_speakers (line 210) | def mix_speakers(data, num_speaker=2, shuffle_size=1000):
  function snr_mixer (line 277) | def snr_mixer(data, use_random_snr: bool = False):
  function shuffle (line 323) | def shuffle(data, shuffle_size=2500):
  function spk_to_id (line 347) | def spk_to_id(data, spk2id):
  function resample (line 367) | def resample(data, resample_rate=16000):
  function sample_spk_embedding (line 391) | def sample_spk_embedding(data, spk_embeds):
  function sample_fix_spk_embedding (line 407) | def sample_fix_spk_embedding(data, spk2embed_dict, spk1_embed, spk2_embed):
  function sample_enrollment (line 428) | def sample_enrollment(data, spk_embeds, dict_spk):
  function sample_fix_spk_enrollment (line 450) | def sample_fix_spk_enrollment(data,
  function compute_fbank (line 480) | def compute_fbank(data,
  function apply_cmvn (line 515) | def apply_cmvn(data, norm_mean=True, norm_var=False):
  function get_random_chunk (line 538) | def get_random_chunk(data_list, chunk_len):
  function filter_len (line 581) | def filter_len(
  function random_chunk (line 612) | def random_chunk(data, chunk_len):
  function fix_chunk (line 631) | def fix_chunk(data, chunk_len):
  function add_noise (line 650) | def add_noise(
  function add_reverb (line 746) | def add_reverb(data, reverb_prob=0):
  function add_noise_on_enroll (line 785) | def add_noise_on_enroll(
  function add_reverb_on_enroll (line 892) | def add_reverb_on_enroll(data, reverb_enroll_prob=0):
  function spec_aug (line 928) | def spec_aug(data, num_t_mask=1, num_f_mask=1, max_t=10, max_f=8, prob=0):

FILE: wesep/dataset/vad.py
  class VoiceActivityDetection (line 5) | class VoiceActivityDetection:
    method __init__ (line 7) | def __init__(self, wave):
    method segmentation (line 10) | def segmentation(self, overlap, slice_len):
    method calc_energy (line 31) | def calc_energy(self, audio):
    method select (line 42) | def select(self):

FILE: wesep/models/__init__.py
  function get_model (line 10) | def get_model(model_name: str):

FILE: wesep/models/bsrnn.py
  class ResRNN (line 16) | class ResRNN(nn.Module):
    method __init__ (line 18) | def __init__(self, input_size, hidden_size, bidirectional=True):
    method forward (line 38) | def forward(self, input):
  class BSNet (line 55) | class BSNet(nn.Module):
    method __init__ (line 57) | def __init__(self, in_channel, nband=7, bidirectional=True):
    method forward (line 69) | def forward(self, input, dummy: Optional[torch.Tensor] = None):
  class FuseSeparation (line 86) | class FuseSeparation(nn.Module):
    method __init__ (line 88) | def __init__(
    method forward (line 125) | def forward(self, x, spk_embedding, nch: torch.Tensor = torch.tensor(1)):
  class BSRNN (line 151) | class BSRNN(nn.Module):
    method __init__ (line 154) | def __init__(
    method pad_input (line 284) | def pad_input(self, input, window, stride):
    method forward (line 300) | def forward(self, input, embeddings):

FILE: wesep/models/bsrnn_feats.py
  class ResRNN (line 18) | class ResRNN(nn.Module):
    method __init__ (line 20) | def __init__(self, input_size, hidden_size, bidirectional=True):
    method forward (line 40) | def forward(self, input):
  class BSNet (line 57) | class BSNet(nn.Module):
    method __init__ (line 59) | def __init__(self, in_channel, nband=7, bidirectional=True):
    method forward (line 71) | def forward(self, input, dummy: Optional[torch.Tensor] = None):
  class CrossAtt (line 87) | class CrossAtt(nn.Module):
    method __init__ (line 88) | def __init__(self, embed_dim, num_heads, *args, **kwargs):
    method forward (line 93) | def forward(self, query, key, value):
  class FuseSeparation (line 110) | class FuseSeparation(nn.Module):
    method __init__ (line 112) | def __init__(
    method forward (line 160) | def forward(self, x, spk_embedding, nch: torch.Tensor = torch.tensor(1)):
  class BSRNN_Feats (line 201) | class BSRNN_Feats(nn.Module):
    method __init__ (line 204) | def __init__(
    method pad_input (line 340) | def pad_input(self, input, window, stride):
    method forward (line 356) | def forward(self, input, embeddings):

FILE: wesep/models/bsrnn_multi_optim.py
  class ResRNN (line 15) | class ResRNN(nn.Module):
    method __init__ (line 17) | def __init__(self, input_size, hidden_size, bidirectional=True):
    method forward (line 38) | def forward(self, input):
  class BSNet (line 55) | class BSNet(nn.Module):
    method __init__ (line 57) | def __init__(self, in_channel, nband=7, bidirectional=True):
    method forward (line 69) | def forward(self, input, dummy: Optional[torch.Tensor] = None):
  class FuseSeparation (line 91) | class FuseSeparation(nn.Module):
    method __init__ (line 93) | def __init__(
    method forward (line 132) | def forward(self, x, spk_embedding, nch: torch.Tensor = torch.tensor(1)):
  class BSRNN_Multi (line 156) | class BSRNN_Multi(nn.Module):
    method __init__ (line 159) | def __init__(
    method pad_input (line 290) | def pad_input(self, input, window, stride):
    method forward (line 306) | def forward(self, input, embeddings):

FILE: wesep/models/convtasnet.py
  class ConvTasNet (line 14) | class ConvTasNet(nn.Module):
    method __init__ (line 16) | def __init__(
    method forward (line 162) | def forward(self, x, embeddings):
  function check_parameters (line 222) | def check_parameters(net):
  function test_convtasnet (line 230) | def test_convtasnet():

FILE: wesep/models/dpccn.py
  class DPCCN (line 16) | class DPCCN(nn.Module):
    method __init__ (line 18) | def __init__(
    method _build_encoder (line 131) | def _build_encoder(self, **enc_kargs):
    method _build_decoder (line 151) | def _build_decoder(self, **dec_kargs):
    method _build_tcn_blocks (line 174) | def _build_tcn_blocks(self, tcn_blocks, **tcn_kargs):
    method _build_tcn_layers (line 184) | def _build_tcn_layers(self, tcn_layers, tcn_blocks, **tcn_kargs):
    method _build_avg_pool (line 195) | def _build_avg_pool(self, pool_size):
    method forward (line 206) | def forward(self, input, aux):

FILE: wesep/models/sep_model.py
  function get_model (line 7) | def get_model(model_name: str):

FILE: wesep/models/tfgridnet.py
  class TFGridNet (line 29) | class TFGridNet(nn.Module):
    method __init__ (line 76) | def __init__(
    method forward (line 197) | def forward(
    method num_spk (line 305) | def num_spk(self):
    method pad2 (line 309) | def pad2(input_tensor, target_len):

FILE: wesep/modules/common/norm.py
  class GlobalChannelLayerNorm (line 7) | class GlobalChannelLayerNorm(nn.Module):
    method __init__ (line 18) | def __init__(self, dim, eps=1e-05, elementwise_affine=True):
    method forward (line 31) | def forward(self, x):
  class ChannelWiseLayerNorm (line 51) | class ChannelWiseLayerNorm(nn.LayerNorm):
    method __init__ (line 56) | def __init__(self, *args, **kwargs):
    method forward (line 59) | def forward(self, x):
  function select_norm (line 69) | def select_norm(norm, dim):
  class FiLM (line 84) | class FiLM(nn.Module):
    method __init__ (line 89) | def __init__(self,
    method init_weights (line 111) | def init_weights(self):
    method forward (line 118) | def forward(self, embed, x):
  class ConditionalLayerNorm (line 142) | class ConditionalLayerNorm(nn.Module):
    method __init__ (line 147) | def __init__(self,
    method reset_parameters (line 172) | def reset_parameters(self):
    method forward (line 176) | def forward(self, input, embed):
    method extra_repr (line 189) | def extra_repr(self):

FILE: wesep/modules/common/speaker.py
  class PreEmphasis (line 10) | class PreEmphasis(torch.nn.Module):
    method __init__ (line 12) | def __init__(self, coef: float = 0.97):
    method forward (line 20) | def forward(self, input: torch.tensor) -> torch.tensor:
  class SpeakerTransform (line 26) | class SpeakerTransform(nn.Module):
    method __init__ (line 28) | def __init__(self, embed_dim=256, num_layers=3, hid_dim=128):
    method forward (line 45) | def forward(self, x):
  class LinearLayer (line 52) | class LinearLayer(nn.Module):
    method __init__ (line 54) | def __init__(self, in_features, out_features, bias=True):
    method forward (line 59) | def forward(self, x, dummy: Optional[torch.Tensor] = None):
  class SpeakerFuseLayer (line 63) | class SpeakerFuseLayer(nn.Module):
    method __init__ (line 65) | def __init__(self, embed_dim=256, feat_dim=512, fuse_type="concat"):
    method forward (line 81) | def forward(self, x, embed):
  function test_speaker_fuse (line 128) | def test_speaker_fuse():

FILE: wesep/modules/dpccn/convs.py
  class Conv1D (line 7) | class Conv1D(nn.Conv1d):
    method __init__ (line 12) | def __init__(self, *args, **kwargs):
    method forward (line 15) | def forward(self, x, squeeze=False):
  class Conv2dBlock (line 28) | class Conv2dBlock(nn.Module):
    method __init__ (line 30) | def __init__(
    method forward (line 44) | def forward(self, x: torch.Tensor) -> torch.Tensor:
  class ConvTrans2dBlock (line 50) | class ConvTrans2dBlock(nn.Module):
    method __init__ (line 52) | def __init__(
    method forward (line 67) | def forward(self, x: torch.Tensor) -> torch.Tensor:
  class DenseBlock (line 73) | class DenseBlock(nn.Module):
    method __init__ (line 75) | def __init__(self, in_dims, out_dims, mode="enc", **kargs):
    method forward (line 97) | def forward(self, x: torch.Tensor) -> torch.Tensor:
  class TCNBlock (line 106) | class TCNBlock(nn.Module):
    method __init__ (line 112) | def __init__(
    method forward (line 144) | def forward(self, x: torch.Tensor) -> torch.Tensor:

FILE: wesep/modules/metric_gan/discriminator.py
  class LearnableSigmoid (line 6) | class LearnableSigmoid(nn.Module):
    method __init__ (line 8) | def __init__(self, in_features, beta=1):
    method forward (line 14) | def forward(self, x):
  class CMGAN_Discriminator (line 19) | class CMGAN_Discriminator(nn.Module):
    method __init__ (line 21) | def __init__(
    method forward (line 106) | def forward(self, ref_wav, est_wav):
  function test_CMGAN_Discriminator (line 145) | def test_CMGAN_Discriminator():

FILE: wesep/modules/tasnet/convs.py
  class Conv1D (line 9) | class Conv1D(nn.Conv1d):
    method __init__ (line 11) | def __init__(self, *args, **kwargs):
    method forward (line 14) | def forward(self, x, squeeze=False):
  class ConvTrans1D (line 25) | class ConvTrans1D(nn.ConvTranspose1d):
    method __init__ (line 27) | def __init__(self, *args, **kwargs):
    method forward (line 30) | def forward(self, x, squeeze=False):
  class Conv1DBlock (line 43) | class Conv1DBlock(nn.Module):
    method __init__ (line 48) | def __init__(
    method forward (line 84) | def forward(self, x):
  class Conv1DBlock4Fuse (line 107) | class Conv1DBlock4Fuse(nn.Module):
    method __init__ (line 113) | def __init__(
    method forward (line 148) | def forward(self, x, aux):

FILE: wesep/modules/tasnet/decoder.py
  class DeepDecoder (line 7) | class DeepDecoder(nn.Module):
    method __init__ (line 9) | def __init__(self, N, kernel_size=16, stride=16 // 2):
    method forward (line 47) | def forward(self, x):
  class MultiDecoder (line 60) | class MultiDecoder(nn.Module):
    method __init__ (line 62) | def __init__(self, in_channels, middle_channels, out_channels, kernel_...
    method forward (line 92) | def forward(self, x, w1, w2, w3, actLayer):

FILE: wesep/modules/tasnet/encoder.py
  class DeepEncoder (line 9) | class DeepEncoder(nn.Module):
    method __init__ (line 11) | def __init__(self, in_channels, out_channels, kernel_size, stride):
    method forward (line 53) | def forward(self, x):
  class MultiEncoder (line 63) | class MultiEncoder(nn.Module):
    method __init__ (line 65) | def __init__(self, in_channels, middle_channels, out_channels, kernel_...
    method forward (line 95) | def forward(self, x):

FILE: wesep/modules/tasnet/separation.py
  class Separation (line 8) | class Separation(nn.Module):
    method __init__ (line 10) | def __init__(
    method forward (line 41) | def forward(self, x):
  class FuseSeparation (line 60) | class FuseSeparation(nn.Module):
    method __init__ (line 62) | def __init__(
    method forward (line 166) | def forward(self, x, spk_embedding):

FILE: wesep/modules/tasnet/separator.py
  class Separation (line 6) | class Separation(nn.Module):
    method __init__ (line 18) | def __init__(self, R, X, B, H, P, norm="gln", causal=False, skip_con=T...
    method forward (line 27) | def forward(self, x):

FILE: wesep/modules/tasnet/speaker.py
  class ResBlock (line 7) | class ResBlock(nn.Module):
    method __init__ (line 15) | def __init__(self, in_dims, out_dims):
    method forward (line 34) | def forward(self, x):
  class ResNet4SpExplus (line 48) | class ResNet4SpExplus(nn.Module):
    method __init__ (line 50) | def __init__(self, in_channel=256, C_embedding=256):
    method forward (line 61) | def forward(self, x):

FILE: wesep/modules/tfgridnet/gridnet_block.py
  class GridNetBlock (line 26) | class GridNetBlock(nn.Module):
    method __getitem__ (line 28) | def __getitem__(self, key):
    method __init__ (line 31) | def __init__(
    method forward (line 118) | def forward(self, x):
  class LayerNormalization4DCF (line 230) | class LayerNormalization4DCF(nn.Module):
    method __init__ (line 232) | def __init__(self, input_dimension, eps=1e-5):
    method forward (line 242) | def forward(self, x):
  class AllHeadPReLULayerNormalization4DCF (line 256) | class AllHeadPReLULayerNormalization4DCF(nn.Module):
    method __init__ (line 258) | def __init__(self, input_dimension, eps=1e-5):
    method forward (line 273) | def forward(self, x):

FILE: wesep/utils/abs_loss.py
  class AbsEnhLoss (line 8) | class AbsEnhLoss(torch.nn.Module, ABC):
    method name (line 13) | def name(self) -> str:
    method only_for_test (line 19) | def only_for_test(self) -> bool:
    method forward (line 23) | def forward(

FILE: wesep/utils/checkpoint.py
  function load_pretrained_model (line 8) | def load_pretrained_model(model: torch.nn.Module,
  function load_checkpoint (line 30) | def load_checkpoint(
  function save_checkpoint (line 81) | def save_checkpoint(

FILE: wesep/utils/datadir_writer.py
  class DatadirWriter (line 8) | class DatadirWriter:
    method __init__ (line 21) | def __init__(self, p: Union[Path, str]):
    method __enter__ (line 28) | def __enter__(self):
    method __getitem__ (line 31) | def __getitem__(self, key: str) -> "DatadirWriter":
    method __setitem__ (line 43) | def __setitem__(self, key: str, value: str):
    method __exit__ (line 56) | def __exit__(self, exc_type, exc_val, exc_tb):
    method close (line 59) | def close(self):

FILE: wesep/utils/dnsmos.py
  function poly1d (line 18) | def poly1d(coefficients, use_numpy=False):
  class DNSMOS_web (line 29) | class DNSMOS_web:
    method __init__ (line 32) | def __init__(self, auth_key):
    method __call__ (line 35) | def __call__(self, aud, input_fs, fname="", method="p808"):
  class DNSMOS_local (line 60) | class DNSMOS_local:
    method __init__ (line 63) | def __init__(
    method audio_melspec (line 121) | def audio_melspec(
    method get_polyfit_val (line 157) | def get_polyfit_val(self, sig, bak, ovr, is_personalized_MOS):
    method __call__ (line 177) | def __call__(self, aud, input_fs, is_personalized_MOS=False):

FILE: wesep/utils/executor.py
  class Executor (line 27) | class Executor:
    method __init__ (line 29) | def __init__(self):
    method train (line 32) | def train(
    method cv (line 154) | def cv(

FILE: wesep/utils/executor_gan.py
  class ExecutorGAN (line 28) | class ExecutorGAN:
    method __init__ (line 30) | def __init__(self):
    method train (line 33) | def train(
    method cv (line 191) | def cv(
    method mse_loss (line 274) | def mse_loss(self, output, target):
    method _calculate_discriminator_loss (line 277) | def _calculate_discriminator_loss(

FILE: wesep/utils/file_utils.py
  function read_lists (line 11) | def read_lists(list_file):
  function read_vec_scp_file (line 20) | def read_vec_scp_file(scp_file):
  function norm_embeddings (line 35) | def norm_embeddings(embeddings, kaldi_style=True):
  function read_label_file (line 50) | def read_label_file(label_file):
  function load_speaker_embeddings (line 64) | def load_speaker_embeddings(scp_file, utt2spk_file):
  function read_2columns_text (line 86) | def read_2columns_text(path: Union[Path, str]) -> Dict[str, str]:
  function read_multi_columns_text (line 116) | def read_multi_columns_text(
  function soundfile_read (line 164) | def soundfile_read(
  class SoundScpReader (line 233) | class SoundScpReader(collections.abc.Mapping):
    method __init__ (line 270) | def __init__(
    method __getitem__ (line 289) | def __getitem__(self, key) -> Tuple[int, np.ndarray]:
    method get_path (line 301) | def get_path(self, key):
    method __contains__ (line 304) | def __contains__(self, item):
    method __len__ (line 307) | def __len__(self):
    method __iter__ (line 310) | def __iter__(self):
    method keys (line 313) | def keys(self):

FILE: wesep/utils/funcs.py
  function overlap_and_add (line 10) | def overlap_and_add(signal, frame_step):
  function remove_pad (line 59) | def remove_pad(inputs, inputs_lengths):
  function clip_gradients (line 79) | def clip_gradients(model, clip):
  function compute_fbank (line 91) | def compute_fbank(
  function apply_cmvn (line 119) | def apply_cmvn(data, norm_mean=True, norm_var=False):

FILE: wesep/utils/losses.py
  function parse_loss (line 34) | def parse_loss(loss):

FILE: wesep/utils/schedulers.py
  class MarginScheduler (line 20) | class MarginScheduler:
    method __init__ (line 22) | def __init__(
    method init_margin (line 54) | def init_margin(self):
    method get_increase_margin (line 58) | def get_increase_margin(self):
    method step (line 73) | def step(self, current_iter=None):
    method get_margin (line 90) | def get_margin(self):
  class BaseClass (line 99) | class BaseClass:
    method __init__ (line 104) | def __init__(
    method get_multi_process_coeff (line 130) | def get_multi_process_coeff(self):
    method get_current_lr (line 142) | def get_current_lr(self):
    method get_lr (line 148) | def get_lr(self):
    method set_lr (line 151) | def set_lr(self):
    method step (line 156) | def step(self, current_iter=None):
    method step_return_lr (line 163) | def step_return_lr(self, current_iter=None):
    method state_dict (line 172) | def state_dict(self):
    method load_state_dict (line 183) | def load_state_dict(self, state_dict):
  class ExponentialDecrease (line 193) | class ExponentialDecrease(BaseClass):
    method __init__ (line 195) | def __init__(
    method get_current_lr (line 217) | def get_current_lr(self):
  class TriAngular2 (line 225) | class TriAngular2(BaseClass):
    method __init__ (line 230) | def __init__(
    method get_current_lr (line 260) | def get_current_lr(self):
  function show_lr_curve (line 280) | def show_lr_curve(scheduler):

FILE: wesep/utils/score.py
  function cal_SISNR (line 7) | def cal_SISNR(est, ref, eps=1e-8):
  function cal_SISNRi (line 24) | def cal_SISNRi(est, ref, mix, eps=1e-8):
  function cal_PESQ (line 39) | def cal_PESQ(est, ref):
  function cal_PESQ_norm (line 46) | def cal_PESQ_norm(est, ref):
  function cal_PESQi (line 58) | def cal_PESQi(est, ref, mix):
  function cal_STOI (line 73) | def cal_STOI(est, ref):
  function cal_STOIi (line 79) | def cal_STOIi(est, ref, mix):
  function batch_evaluation (line 94) | def batch_evaluation(metric, est, ref, lengths=None, parallel=False, n_j...

FILE: wesep/utils/signal.py
  function init_kernels (line 8) | def init_kernels(win_len, win_inc, fft_len, win_type=None, invers=False):
  class ConvSTFT (line 38) | class ConvSTFT(nn.Module):
    method __init__ (line 40) | def __init__(
    method forward (line 62) | def forward(self, inputs):
  class ConviSTFT (line 80) | class ConviSTFT(nn.Module):
    method __init__ (line 82) | def __init__(
    method forward (line 110) | def forward(self, inputs, phase=None):

FILE: wesep/utils/utils.py
  function str2bool (line 31) | def str2bool(value: str) -> bool:
  function get_logger (line 35) | def get_logger(outdir, fname):
  function setup_logger (line 50) | def setup_logger(rank, exp_dir, device_ids, MAX_NUM_LOG_FILES: int = 100):
  function parse_config_or_kwargs (line 73) | def parse_config_or_kwargs(config_file, **kwargs):
  function validate_path (line 93) | def validate_path(dir_name):
  function set_seed (line 103) | def set_seed(seed=42):
  function generate_enahnced_scp (line 115) | def generate_enahnced_scp(directory: str, extension: str = "wav"):
  function get_commandline_args (line 139) | def get_commandline_args():
  class ArgumentParser (line 176) | class ArgumentParser(argparse.ArgumentParser):
    method __init__ (line 189) | def __init__(self, *args, **kwargs):
    method parse_known_args (line 193) | def parse_known_args(self, args=None, namespace=None):
  function get_layer (line 221) | def get_layer(l_name, library=torch.nn):