SYMBOL INDEX (348 symbols across 21 files)

FILE: config.py
  function MyParser (line 4) | def MyParser():

FILE: data/gigaspeech.py
  class dataset (line 8) | class dataset(torch.utils.data.Dataset):
    method __init__ (line 9) | def __init__(self, args, split):
    method __len__ (line 38) | def __len__(self):
    method _load_phn_enc (line 41) | def _load_phn_enc(self, index):
    method __getitem__ (line 64) | def __getitem__(self, index):
    method collate (line 131) | def collate(self, batch):

FILE: data/phonemize_encodec_encode_hf.py
  function parse_args (line 2) | def parse_args():
  function sort_by_audio_len (line 42) | def sort_by_audio_len(lens):
  function write_array_to_txt_file (line 50) | def write_array_to_txt_file(array, filename):
  class mydataset (line 127) | class mydataset(torch.utils.data.Dataset):
    method __init__ (line 128) | def __init__(self, split):
    method __len__ (line 131) | def __len__(self):
    method __getitem__ (line 133) | def __getitem__(self, ind):
    method collate (line 140) | def collate(self, batch):

FILE: data/tokenizer.py
  class TextTokenizer (line 33) | class TextTokenizer:
    method __init__ (line 36) | def __init__(
    method to_list (line 61) | def to_list(self, phonemized: str) -> List[str]:
    method __call__ (line 75) | def __call__(self, text, strip=True) -> List[List[str]]:
  function tokenize_text (line 85) | def tokenize_text(tokenizer: TextTokenizer, text: str) -> List[str]:
  function convert_audio (line 89) | def convert_audio(wav: torch.Tensor, sr: int, target_sr: int, target_cha...
  class AudioTokenizer (line 101) | class AudioTokenizer:
    method __init__ (line 104) | def __init__(
    method device (line 124) | def device(self):
    method encode (line 127) | def encode(self, wav: torch.Tensor) -> torch.Tensor:
    method decode (line 131) | def decode(self, frames: torch.Tensor) -> torch.Tensor:
  function tokenize_audio (line 137) | def tokenize_audio(tokenizer: AudioTokenizer, audio_path: str, offset = ...

FILE: edit_utils.py
  function get_span (line 1) | def get_span(orig, new, editType):

FILE: gradio_app.py
  function get_random_string (line 26) | def get_random_string():
  function seed_everything (line 30) | def seed_everything(seed):
  class WhisperxAlignModel (line 41) | class WhisperxAlignModel:
    method __init__ (line 42) | def __init__(self):
    method align (line 46) | def align(self, segments, audio_path):
  class WhisperModel (line 52) | class WhisperModel:
    method __init__ (line 53) | def __init__(self, model_name):
    method transcribe (line 65) | def transcribe(self, audio_path):
  class WhisperxModel (line 69) | class WhisperxModel:
    method __init__ (line 70) | def __init__(self, model_name, align_model: WhisperxAlignModel):
    method transcribe (line 75) | def transcribe(self, audio_path):
  function load_models (line 82) | def load_models(whisper_backend_name, whisper_model_name, alignment_mode...
  function get_transcribe_state (line 125) | def get_transcribe_state(segments):
  function transcribe (line 139) | def transcribe(seed, audio_path):
  function align_segments (line 156) | def align_segments(transcript, audio_path):
  function align (line 178) | def align(seed, transcript, audio_path):
  function get_output_audio (line 201) | def get_output_audio(audio_tensors, codec_audio_sr):
  function replace_numbers_with_words (line 208) | def replace_numbers_with_words(sentence):
  function run (line 218) | def run(seed, left_margin, right_margin, codec_audio_sr, codec_sr, top_k...
  function update_input_audio (line 324) | def update_input_audio(audio_path):
  function change_mode (line 337) | def change_mode(mode):
  function load_sentence (line 348) | def load_sentence(selected_sentence, codec_audio_sr, audio_tensors):
  function update_bound_word (line 356) | def update_bound_word(is_first_word, selected_word, edit_word_mode):
  function update_bound_words (line 372) | def update_bound_words(from_selected_word, to_selected_word, edit_word_m...
  function update_demo (line 417) | def update_demo(mode, smart_transcript, edit_word_mode, transcript, edit...
  function get_app (line 433) | def get_app():

FILE: inference_speech_editing_scale.py
  function get_args (line 19) | def get_args():
  function inference_one_sample (line 41) | def inference_one_sample(model, model_args, phn2num, text_tokenizer, aud...
  function get_model (line 86) | def get_model(exp_dir, device=None):
  function get_mask_interval (line 107) | def get_mask_interval(ali_fn, word_span_ind, editType):
  function seed_everything (line 130) | def seed_everything(seed):

FILE: inference_tts_scale.py
  function get_args (line 20) | def get_args():
  function inference_one_sample (line 43) | def inference_one_sample(model, model_args, phn2num, text_tokenizer, aud...
  function get_model (line 107) | def get_model(exp_dir, device=None):
  function seed_everything (line 128) | def seed_everything(seed):

FILE: models/codebooks_patterns.py
  class Pattern (line 21) | class Pattern:
    method __post_init__ (line 49) | def __post_init__(self):
    method _validate_layout (line 57) | def _validate_layout(self):
    method num_sequence_steps (line 79) | def num_sequence_steps(self):
    method max_delay (line 83) | def max_delay(self):
    method valid_layout (line 91) | def valid_layout(self):
    method get_sequence_coords_with_timestep (line 95) | def get_sequence_coords_with_timestep(self, t: int, q: tp.Optional[int...
    method get_steps_with_timestep (line 110) | def get_steps_with_timestep(self, t: int, q: tp.Optional[int] = None) ...
    method get_first_step_with_timesteps (line 113) | def get_first_step_with_timesteps(self, t: int, q: tp.Optional[int] = ...
    method _build_pattern_sequence_scatter_indexes (line 117) | def _build_pattern_sequence_scatter_indexes(self, timesteps: int, n_q:...
    method build_pattern_sequence (line 151) | def build_pattern_sequence(self, z: torch.Tensor, special_token: int, ...
    method _build_reverted_sequence_scatter_indexes (line 178) | def _build_reverted_sequence_scatter_indexes(self, sequence_steps: int...
    method revert_pattern_sequence (line 222) | def revert_pattern_sequence(self, s: torch.Tensor, special_token: int,...
    method revert_pattern_logits (line 247) | def revert_pattern_logits(self, logits: torch.Tensor, special_token: f...
  class CodebooksPatternProvider (line 269) | class CodebooksPatternProvider(ABC):
    method __init__ (line 287) | def __init__(self, n_q: int, cached: bool = True):
    method get_pattern (line 293) | def get_pattern(self, timesteps: int) -> Pattern:
  class DelayedPatternProvider (line 302) | class DelayedPatternProvider(CodebooksPatternProvider):
    method __init__ (line 325) | def __init__(self, n_q: int, delays: tp.Optional[tp.List[int]] = None,
    method get_pattern (line 336) | def get_pattern(self, timesteps: int) -> Pattern:
  class ParallelPatternProvider (line 355) | class ParallelPatternProvider(DelayedPatternProvider):
    method __init__ (line 363) | def __init__(self, n_q: int):
  class UnrolledPatternProvider (line 367) | class UnrolledPatternProvider(CodebooksPatternProvider):
    method __init__ (line 418) | def __init__(self, n_q: int, flattening: tp.Optional[tp.List[int]] = N...
    method _build_flattened_codebooks (line 432) | def _build_flattened_codebooks(self, delays: tp.List[int], flattening:...
    method _num_inner_steps (line 452) | def _num_inner_steps(self):
    method num_virtual_steps (line 457) | def num_virtual_steps(self, timesteps: int) -> int:
    method get_pattern (line 460) | def get_pattern(self, timesteps: int) -> Pattern:
  class VALLEPattern (line 488) | class VALLEPattern(CodebooksPatternProvider):
    method __init__ (line 497) | def __init__(self, n_q: int, delays: tp.Optional[tp.List[int]] = None):
    method get_pattern (line 505) | def get_pattern(self, timesteps: int) -> Pattern:
  class MusicLMPattern (line 520) | class MusicLMPattern(CodebooksPatternProvider):
    method __init__ (line 528) | def __init__(self, n_q: int, group_by: int = 2):
    method get_pattern (line 532) | def get_pattern(self, timesteps: int) -> Pattern:

FILE: models/modules/activation.py
  function _canonical_mask (line 20) | def _canonical_mask(
  function _in_projection_packed (line 48) | def _in_projection_packed(
  function _none_or_dtype (line 110) | def _none_or_dtype(input: Optional[Tensor]) -> Optional[DType]:
  class MultiheadAttention (line 116) | class MultiheadAttention(Module):
    method __init__ (line 176) | def __init__(
    method _reset_parameters (line 280) | def _reset_parameters(self):
    method __setstate__ (line 297) | def __setstate__(self, state):
    method forward (line 304) | def forward(

FILE: models/modules/embedding.py
  class TokenEmbedding (line 22) | class TokenEmbedding(nn.Module):
    method __init__ (line 23) | def __init__(
    method weight (line 38) | def weight(self) -> torch.Tensor:
    method embedding (line 41) | def embedding(self, index: int) -> torch.Tensor:
    method forward (line 44) | def forward(self, x: torch.Tensor):
  class SinePositionalEmbedding (line 51) | class SinePositionalEmbedding(nn.Module):
    method __init__ (line 52) | def __init__(
    method extend_pe (line 69) | def extend_pe(self, x):
    method forward (line 94) | def forward(self, x: torch.Tensor) -> torch.Tensor:

FILE: models/modules/sampling.py
  function top_k_top_p_filtering (line 4) | def top_k_top_p_filtering(
  function topk_sampling (line 48) | def topk_sampling(logits, top_k=10, top_p=1.0, temperature=1.0):

FILE: models/modules/scaling.py
  class Transpose (line 35) | class Transpose(nn.Identity):
    method forward (line 38) | def forward(self, input: torch.Tensor) -> torch.Tensor:
  class ActivationBalancerFunction (line 41) | class ActivationBalancerFunction(torch.autograd.Function):
    method forward (line 43) | def forward(
    method backward (line 61) | def backward(ctx, x_grad: Tensor) -> Tuple[Tensor, None, None, None]:
  function _compute_scale_factor (line 82) | def _compute_scale_factor(
  function _compute_sign_factor (line 111) | def _compute_sign_factor(
  class ActivationScaleBalancerFunction (line 147) | class ActivationScaleBalancerFunction(torch.autograd.Function):
    method forward (line 155) | def forward(
    method backward (line 170) | def backward(ctx, x_grad: Tensor) -> Tuple[Tensor, None, None, None]:
  class RandomClampFunction (line 186) | class RandomClampFunction(torch.autograd.Function):
    method forward (line 188) | def forward(
    method backward (line 207) | def backward(
  function random_clamp (line 218) | def random_clamp(
  function random_cast_to_half (line 228) | def random_cast_to_half(x: Tensor, min_abs: float = 5.0e-06) -> Tensor:
  class RandomGradFunction (line 243) | class RandomGradFunction(torch.autograd.Function):
    method forward (line 250) | def forward(ctx, x: Tensor, min_abs: float) -> Tensor:
    method backward (line 255) | def backward(ctx, ans_grad: Tensor) -> Tuple[Tensor, None]:
  class RandomGrad (line 267) | class RandomGrad(torch.nn.Module):
    method __init__ (line 273) | def __init__(self, min_abs: float = 5.0e-06):
    method forward (line 277) | def forward(self, x: Tensor):
  class SoftmaxFunction (line 288) | class SoftmaxFunction(torch.autograd.Function):
    method forward (line 295) | def forward(ctx, x: Tensor, dim: int):
    method backward (line 308) | def backward(ctx, ans_grad: Tensor):
  function softmax (line 318) | def softmax(x: Tensor, dim: int):
  class MaxEigLimiterFunction (line 325) | class MaxEigLimiterFunction(torch.autograd.Function):
    method forward (line 327) | def forward(
    method backward (line 341) | def backward(ctx, x_grad, *args):
  class BasicNorm (line 366) | class BasicNorm(torch.nn.Module):
    method __init__ (line 396) | def __init__(
    method forward (line 415) | def forward(self, x: Tensor) -> Tensor:
  function ScaledLinear (line 432) | def ScaledLinear(*args, initial_scale: float = 1.0, **kwargs) -> nn.Linear:
  function ScaledConv1d (line 457) | def ScaledConv1d(
  function TransposeScaledConv1d (line 488) | def TransposeScaledConv1d(
  function ScaledConv1dTranspose (line 510) | def ScaledConv1dTranspose(
  function TransposeConv1d (line 532) | def TransposeConv1d(
  function Conv1dTranspose (line 544) | def Conv1dTranspose(
  class SRLinear (line 556) | class SRLinear(nn.Linear):
    method __init__ (line 561) | def __init__(self, in_features, out_features, bias=True, **kwargs):
    method get_sigma (line 571) | def get_sigma(self):
    method get_weight (line 581) | def get_weight(self):
    method forward (line 588) | def forward(self, x):
  class SRConv1d (line 592) | class SRConv1d(SRLinear):
    method __init__ (line 593) | def __init__(
    method forward (line 610) | def forward(self, x):
  function TransposeSRConv1d (line 620) | def TransposeSRConv1d(
  function SRConv1dTranspose (line 632) | def SRConv1dTranspose(
  class ActivationBalancer (line 644) | class ActivationBalancer(torch.nn.Module):
    method __init__ (line 684) | def __init__(
    method forward (line 715) | def forward(self, x: Tensor) -> Tensor:
  function penalize_abs_values_gt (line 769) | def penalize_abs_values_gt(x: Tensor, limit: float, penalty: float) -> T...
  function _diag (line 797) | def _diag(x: Tensor):  # like .diag(), but works for tensors with 3 dims.
  function _whitening_metric (line 808) | def _whitening_metric(x: Tensor, num_groups: int):
  class WhiteningPenaltyFunction (line 846) | class WhiteningPenaltyFunction(torch.autograd.Function):
    method forward (line 848) | def forward(
    method backward (line 862) | def backward(ctx, x_grad: Tensor):
  class Whiten (line 887) | class Whiten(nn.Module):
    method __init__ (line 888) | def __init__(
    method forward (line 929) | def forward(self, x: Tensor) -> Tensor:
  class WithLoss (line 970) | class WithLoss(torch.autograd.Function):
    method forward (line 972) | def forward(ctx, x: Tensor, y: Tensor):
    method backward (line 977) | def backward(ctx, ans_grad: Tensor):
  function with_loss (line 983) | def with_loss(x, y):
  function _no_op (line 990) | def _no_op(x: Tensor) -> Tensor:
  class Identity (line 999) | class Identity(torch.nn.Module):
    method __init__ (line 1000) | def __init__(self):
    method forward (line 1003) | def forward(self, x):
  class MaxEig (line 1007) | class MaxEig(torch.nn.Module):
    method __init__ (line 1028) | def __init__(
    method forward (line 1058) | def forward(self, x: Tensor) -> Tensor:
    method _set_direction (line 1116) | def _set_direction(self, direction: Tensor):
    method _find_direction_coeffs (line 1131) | def _find_direction_coeffs(
  class DoubleSwishFunction (line 1161) | class DoubleSwishFunction(torch.autograd.Function):
    method forward (line 1178) | def forward(ctx, x: Tensor) -> Tensor:
    method backward (line 1211) | def backward(ctx, y_grad: Tensor) -> Tensor:
  class DoubleSwish (line 1220) | class DoubleSwish(torch.nn.Module):
    method forward (line 1221) | def forward(self, x: Tensor) -> Tensor:
  function BalancedDoubleSwish (line 1230) | def BalancedDoubleSwish(
  function _test_max_eig (line 1245) | def _test_max_eig():
  function _test_whiten (line 1272) | def _test_whiten():
  function _test_activation_balancer_sign (line 1299) | def _test_activation_balancer_sign():
  function _test_activation_balancer_magnitude (line 1325) | def _test_activation_balancer_magnitude():
  function _test_basic_norm (line 1353) | def _test_basic_norm():
  function _test_double_swish_deriv (line 1370) | def _test_double_swish_deriv():
  function _test_softmax (line 1384) | def _test_softmax():

FILE: models/modules/transformer.py
  class LayerNorm (line 18) | class LayerNorm(nn.Module):
    method __init__ (line 24) | def __init__(
    method reset_parameters (line 53) | def reset_parameters(self) -> None:
    method forward (line 58) | def forward(self, input: Tensor, embedding: Any = None) -> Tensor:
    method extra_repr (line 77) | def extra_repr(self) -> str:
  class AdaptiveLayerNorm (line 84) | class AdaptiveLayerNorm(nn.Module):
    method __init__ (line 87) | def __init__(self, d_model, norm) -> None:
    method forward (line 94) | def forward(self, input: Tensor, embedding: Tensor = None) -> Tensor:
  class BasicNorm (line 112) | class BasicNorm(_BasicNorm):
    method __init__ (line 113) | def __init__(
    method forward (line 122) | def forward(self, input: Tensor, embedding: Any = None) -> Tensor:
  class BalancedBasicNorm (line 134) | class BalancedBasicNorm(nn.Module):
    method __init__ (line 135) | def __init__(
    method forward (line 152) | def forward(self, input: Tensor, embedding: Any = None) -> Tensor:
  class IdentityNorm (line 161) | class IdentityNorm(nn.Module):
    method __init__ (line 162) | def __init__(
    method forward (line 171) | def forward(self, input: Tensor, embedding: Any = None) -> Tensor:
  class TransformerEncoderLayer (line 179) | class TransformerEncoderLayer(nn.Module):
    method __init__ (line 182) | def __init__(
    method __setstate__ (line 261) | def __setstate__(self, state):
    method forward (line 266) | def forward(
    method _sa_block (line 346) | def _sa_block(
    method _sa_block_attn (line 366) | def _sa_block_attn(
    method _ff_block (line 386) | def _ff_block(self, x: Tensor) -> Tensor:
  class TransformerEncoder (line 391) | class TransformerEncoder(nn.Module):
    method __init__ (line 411) | def __init__(self, encoder_layer, num_layers, norm=None):
    method forward (line 417) | def forward(
  class TransformerDecoderLayer (line 491) | class TransformerDecoderLayer(nn.Module):
    method __init__ (line 494) | def __init__(
    method forward (line 587) | def forward(
    method _sa_block (line 646) | def _sa_block(
    method _mha_block (line 663) | def _mha_block(
    method _ff_block (line 681) | def _ff_block(self, x: Tensor) -> Tensor:
  function _get_clones (line 686) | def _get_clones(module, N):
  function _get_activation_fn (line 690) | def _get_activation_fn(activation: str) -> Callable[[Tensor], Tensor]:

FILE: models/modules/utils.py
  function make_pad_mask (line 5) | def make_pad_mask(lengths: torch.Tensor, max_len: int = 0) -> torch.Tensor:
  function generate_partial_autoregressive_mask (line 32) | def generate_partial_autoregressive_mask(sz, start, end):

FILE: models/voicecraft.py
  function top_k_top_p_filtering (line 26) | def top_k_top_p_filtering(
  function topk_sampling (line 71) | def topk_sampling(logits, top_k=10, top_p=1.0, temperature=1.0):
  class VoiceCraft (line 90) | class VoiceCraft(
    method __new__ (line 97) | def __new__(cls, args: Optional[Namespace] = None, config: Optional[Di...
    method __init__ (line 106) | def __init__(self, args: Optional[Namespace] = None, config: Optional[...
    method prepare_mask_intervals (line 198) | def prepare_mask_intervals(self, y_lens):
    method rearrange (line 239) | def rearrange(self, y, non_mask_intervals, mask_intervals):
    method shift (line 254) | def shift(self, rearranged_y):
    method insert_mask (line 264) | def insert_mask(self, shifted_y):
    method cat_y (line 290) | def cat_y(self, inserted_y, mask_position, y_lens):
    method embed_y (line 311) | def embed_y(self, cated_y, mask_position, mask_value):
    method prepare_input_target (line 322) | def prepare_input_target(self, y, y_lens):
    method remove_mask (line 376) | def remove_mask(self, logits, mask_position, new_y_lens):
    method revert_pattern (line 387) | def revert_pattern(self, patterns, logits_use):
    method dec_forward (line 406) | def dec_forward(
    method forward (line 472) | def forward(self, batch):
    method inference (line 561) | def inference(
    method inference_tts (line 908) | def inference_tts(
    method inference_tts_batch (line 1156) | def inference_tts_batch(

FILE: predict.py
  class ModelOutput (line 33) | class ModelOutput(BaseModel):
  class WhisperxAlignModel (line 38) | class WhisperxAlignModel:
    method __init__ (line 39) | def __init__(self):
    method align (line 46) | def align(self, segments, audio_path):
  class WhisperxModel (line 60) | class WhisperxModel:
    method __init__ (line 61) | def __init__(self, model_name, align_model: WhisperxAlignModel, device...
    method transcribe (line 77) | def transcribe(self, audio_path):
  function download_weights (line 84) | def download_weights(url, dest):
  class Predictor (line 92) | class Predictor(BasePredictor):
    method setup (line 93) | def setup(self):
    method predict (line 130) | def predict(
  function seed_everything (line 336) | def seed_everything(seed):
  function get_transcribe_state (line 346) | def get_transcribe_state(segments):
  function find_closest_cut_off_word (line 357) | def find_closest_cut_off_word(word_bounds, cut_off_sec):
  function get_mask_interval_from_word_bounds (line 372) | def get_mask_interval_from_word_bounds(word_bounds, word_span_ind, editT...

FILE: steps/optim.py
  class BatchedOptimizer (line 29) | class BatchedOptimizer(Optimizer):
    method __init__ (line 40) | def __init__(self, params, defaults):
    method batched_params (line 44) | def batched_params(self, param_group, group_params_names):
  class ScaledAdam (line 129) | class ScaledAdam(BatchedOptimizer):
    method __init__ (line 172) | def __init__(
    method __setstate__ (line 212) | def __setstate__(self, state):
    method step (line 216) | def step(self, closure=None):
    method _init_state (line 265) | def _init_state(self, group: dict, p: Tensor, state: dict):
    method _get_clipping_scale (line 316) | def _get_clipping_scale(
    method _show_gradient_dominating_parameter (line 414) | def _show_gradient_dominating_parameter(
    method _step_one_batch (line 479) | def _step_one_batch(
    method _size_update (line 531) | def _size_update(
    method _step (line 598) | def _step(self, group: dict, p: Tensor, state: dict):
    method _step_scalar (line 639) | def _step_scalar(self, group: dict, p: Tensor, state: dict):
  class LRScheduler (line 664) | class LRScheduler(object):
    method __init__ (line 670) | def __init__(self, optimizer: Optimizer, verbose: bool = False):
    method state_dict (line 687) | def state_dict(self):
    method load_state_dict (line 699) | def load_state_dict(self, state_dict):
    method get_last_lr (line 708) | def get_last_lr(self) -> List[float]:
    method get_lr (line 712) | def get_lr(self):
    method step_batch (line 718) | def step_batch(self, batch: Optional[int] = None) -> None:
    method step_epoch (line 730) | def step_epoch(self, epoch: Optional[int] = None):
    method _set_lrs (line 740) | def _set_lrs(self):
    method print_lr (line 750) | def print_lr(self, is_verbose, group, lr):
  class Eden (line 759) | class Eden(LRScheduler):
    method __init__ (line 781) | def __init__(
    method get_lr (line 794) | def get_lr(self):
  function _test_eden (line 810) | def _test_eden():
  class Eve (line 836) | class Eve(Optimizer):
    method __init__ (line 872) | def __init__(
    method __setstate__ (line 908) | def __setstate__(self, state):
    method step (line 912) | def step(self, closure=None):
  function ScaledLinear (line 987) | def ScaledLinear(*args, initial_scale: float = 1.0, **kwargs) -> nn.Linear:
  function _test_scaled_adam (line 1010) | def _test_scaled_adam(hidden_dim: int):

FILE: steps/trainer.py
  class Trainer (line 21) | class Trainer:
    method __init__ (line 23) | def __init__(self, args, world_size, rank):
    method train (line 55) | def train(self):
    method validate_and_save (line 198) | def validate_and_save(self):
    method validate (line 244) | def validate(self, valid_loader=None, hide_progress=True):
    method _setup_meters (line 295) | def _setup_meters(self):
    method _setup_progress (line 304) | def _setup_progress(self):
    method _save_progress (line 327) | def _save_progress(self):
    method _setup_dataloader (line 332) | def _setup_dataloader(self):
    method _setup_models (line 371) | def _setup_models(self):
    method _setup_optimizer (line 420) | def _setup_optimizer(self):
    method seed_everything (line 461) | def seed_everything(self, seed=1):

FILE: steps/trainer_utils.py
  class StatefulDistributedSampler (line 12) | class StatefulDistributedSampler(Sampler[int]):
    method __init__ (line 13) | def __init__(self, dataset, batch_size, num_replicas = None, rank = No...
    method __len__ (line 48) | def __len__(self):
    method set_epoch (line 51) | def set_epoch(self, epoch):
    method __iter__ (line 92) | def __iter__(self):
    method set_epoch_resume (line 96) | def set_epoch_resume(self, epoch, cur_step):
  class StatefulSampler (line 102) | class StatefulSampler(Sampler):
    method __init__ (line 103) | def __init__(self, data_source_length, batch_size, use_random=True, se...
    method __len__ (line 113) | def __len__(self):
    method __iter__ (line 116) | def __iter__(self):
    method set_epoch (line 121) | def set_epoch(self, epoch):
    method set_epoch_resume (line 136) | def set_epoch_resume(self, epoch, cur_step):
  class AverageMeter (line 142) | class AverageMeter:
    method __init__ (line 144) | def __init__(self):
    method reset (line 147) | def reset(self):
    method update (line 153) | def update(self, val, n=1):
  function print_model_info (line 159) | def print_model_info(model, print_model = False, print_params = True):
  class DistributedDynamicBatchSampler (line 175) | class DistributedDynamicBatchSampler(Sampler):
    method __init__ (line 283) | def __init__(
    method get_durations (line 404) | def get_durations(self, batch):
    method _get_boundaries_through_warping (line 408) | def _get_boundaries_through_warping(
    method _permute_batches (line 439) | def _permute_batches(self):
    method _generate_batches (line 467) | def _generate_batches(self):
    method __iter__ (line 593) | def __iter__(self):
    method set_epoch (line 605) | def set_epoch(self, epoch):
    method __len__ (line 622) | def __len__(self):
    method set_epoch_resume (line 625) | def set_epoch_resume(self, epoch, cur_step):

FILE: tts_demo.py
  function parse_arguments (line 23) | def parse_arguments():
  function find_closest_word_boundary (line 145) | def find_closest_word_boundary(alignments, cut_off_sec, margin, cutoff_t...
  function seed_everything (line 184) | def seed_everything(seed):