SYMBOL INDEX (500 symbols across 32 files)

FILE: semanticodec/config.py
  function get_config (line 2) | def get_config(token_rate=100, vocab_size=None, checkpoint_path=None):

FILE: semanticodec/main.py
  class SemantiCodec (line 26) | class SemantiCodec(nn.Module):
    method __init__ (line 27) | def __init__(
    method load_audio (line 87) | def load_audio(self, filepath):
    method encode (line 139) | def encode(self, filepath):
    method decode (line 145) | def decode(self, tokens):
    method forward (line 179) | def forward(self, filepath):

FILE: semanticodec/modules/audiomae/AudioMAE.py
  class PatchEmbed_new (line 13) | class PatchEmbed_new(nn.Module):
    method __init__ (line 16) | def __init__(
    method get_output_shape (line 38) | def get_output_shape(self, img_size):
    method forward (line 42) | def forward(self, x):
  class Vanilla_AudioMAE (line 52) | class Vanilla_AudioMAE(nn.Module):
    method __init__ (line 55) | def __init__(
    method forward (line 72) | def forward(self, x, mask_ratio=0.0, no_mask=False, no_average=False):

FILE: semanticodec/modules/audiomae/models_mae.py
  class MaskedAutoencoderViT (line 27) | class MaskedAutoencoderViT(nn.Module):
    method __init__ (line 30) | def __init__(
    method initialize_weights (line 201) | def initialize_weights(self):
    method _init_weights (line 243) | def _init_weights(self, m):
    method patchify (line 253) | def patchify(self, imgs):
    method unpatchify (line 288) | def unpatchify(self, x):
    method random_masking (line 301) | def random_masking(self, x, mask_ratio):
    method random_masking_2d (line 330) | def random_masking_2d(self, x, mask_t_prob, mask_f_prob):
    method forward_encoder (line 396) | def forward_encoder(self, x, mask_ratio, mask_2d=False):
    method forward_encoder_no_random_mask_no_average (line 422) | def forward_encoder_no_random_mask_no_average(self, x):
    method forward_encoder_no_mask (line 446) | def forward_encoder_no_mask(self, x):
    method forward_decoder (line 471) | def forward_decoder(self, x, ids_restore):
    method forward_loss (line 518) | def forward_loss(self, imgs, pred, mask, norm_pix_loss=False):
    method forward (line 536) | def forward(self, imgs, mask_ratio=0.8):
  function mae_vit_small_patch16_dec512d8b (line 548) | def mae_vit_small_patch16_dec512d8b(**kwargs):
  function mae_vit_base_patch16_dec512d8b (line 563) | def mae_vit_base_patch16_dec512d8b(**kwargs):
  function mae_vit_large_patch16_dec512d8b (line 578) | def mae_vit_large_patch16_dec512d8b(**kwargs):
  function mae_vit_huge_patch14_dec512d8b (line 593) | def mae_vit_huge_patch14_dec512d8b(**kwargs):

FILE: semanticodec/modules/audiomae/patch_embed.py
  class PatchEmbed_org (line 6) | class PatchEmbed_org(nn.Module):
    method __init__ (line 9) | def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=...
    method forward (line 23) | def forward(self, x):
  class PatchEmbed_new (line 33) | class PatchEmbed_new(nn.Module):
    method __init__ (line 36) | def __init__(
    method get_output_shape (line 58) | def get_output_shape(self, img_size):
    method forward (line 62) | def forward(self, x):
  class PatchEmbed3D_new (line 74) | class PatchEmbed3D_new(nn.Module):
    method __init__ (line 77) | def __init__(
    method get_output_shape (line 98) | def get_output_shape(self, video_size):
    method forward (line 104) | def forward(self, x):

FILE: semanticodec/modules/audiomae/pos_embed.py
  function get_2d_sincos_pos_embed (line 21) | def get_2d_sincos_pos_embed(embed_dim, grid_size, cls_token=False):
  function get_2d_sincos_pos_embed_flexible (line 39) | def get_2d_sincos_pos_embed_flexible(embed_dim, grid_size, cls_token=Fal...
  function get_2d_sincos_pos_embed_from_grid (line 57) | def get_2d_sincos_pos_embed_from_grid(embed_dim, grid):
  function get_1d_sincos_pos_embed_from_grid (line 68) | def get_1d_sincos_pos_embed_from_grid(embed_dim, pos):
  function interpolate_pos_embed (line 95) | def interpolate_pos_embed(model, checkpoint_model):
  function interpolate_pos_embed_img2audio (line 128) | def interpolate_pos_embed_img2audio(model, checkpoint_model, orig_size, ...
  function interpolate_pos_embed_audio (line 161) | def interpolate_pos_embed_audio(model, checkpoint_model, orig_size, new_...
  function interpolate_patch_embed_audio (line 189) | def interpolate_patch_embed_audio(

FILE: semanticodec/modules/decoder/hifigan/__init__.py
  class AttrDict (line 5) | class AttrDict(dict):
    method __init__ (line 6) | def __init__(self, *args, **kwargs):

FILE: semanticodec/modules/decoder/hifigan/models.py
  function init_weights (line 10) | def init_weights(m, mean=0.0, std=0.01):
  function get_padding (line 16) | def get_padding(kernel_size, dilation=1):
  class ResBlock (line 20) | class ResBlock(torch.nn.Module):
    method __init__ (line 21) | def __init__(self, h, channels, kernel_size=3, dilation=(1, 3, 5)):
    method forward (line 96) | def forward(self, x):
    method remove_weight_norm (line 105) | def remove_weight_norm(self):
  class Generator (line 112) | class Generator(torch.nn.Module):
    method __init__ (line 113) | def __init__(self, h):
    method forward (line 149) | def forward(self, x):
    method remove_weight_norm (line 167) | def remove_weight_norm(self):

FILE: semanticodec/modules/decoder/hifigan/models_v2.py
  function init_weights (line 10) | def init_weights(m, mean=0.0, std=0.01):
  function get_padding (line 16) | def get_padding(kernel_size, dilation=1):
  class ResBlock1 (line 20) | class ResBlock1(torch.nn.Module):
    method __init__ (line 21) | def __init__(self, h, channels, kernel_size=3, dilation=(1, 3, 5)):
    method forward (line 96) | def forward(self, x):
    method remove_weight_norm (line 105) | def remove_weight_norm(self):
  class ResBlock2 (line 112) | class ResBlock2(torch.nn.Module):
    method __init__ (line 113) | def __init__(self, h, channels, kernel_size=3, dilation=(1, 3)):
    method forward (line 142) | def forward(self, x):
    method remove_weight_norm (line 149) | def remove_weight_norm(self):
  class Generator (line 154) | class Generator(torch.nn.Module):
    method __init__ (line 155) | def __init__(self, h):
    method forward (line 192) | def forward(self, x):
    method remove_weight_norm (line 211) | def remove_weight_norm(self):

FILE: semanticodec/modules/decoder/latent_diffusion/models/ddim.py
  class DDIMSampler (line 15) | class DDIMSampler(object):
    method __init__ (line 16) | def __init__(self, model, schedule="linear", device=torch.device("cuda...
    method register_buffer (line 23) | def register_buffer(self, name, attr):
    method make_schedule (line 29) | def make_schedule(
    method sample (line 96) | def sample(
    method ddim_sampling (line 167) | def ddim_sampling(
    method p_sample_ddim (line 265) | def p_sample_ddim(
    method encode (line 358) | def encode(
    method stochastic_encode (line 434) | def stochastic_encode(self, x0, t, use_original_steps=False, noise=None):
    method decode (line 452) | def decode(

FILE: semanticodec/modules/decoder/latent_diffusion/models/ddpm.py
  class DDPM (line 27) | class DDPM(nn.Module):
    method __init__ (line 29) | def __init__(
    method register_schedule (line 89) | def register_schedule(
    method ema_scope (line 194) | def ema_scope(self, context=None):
    method q_mean_variance (line 208) | def q_mean_variance(self, x_start, t):
    method predict_start_from_noise (line 222) | def predict_start_from_noise(self, x_t, t, noise):
    method q_posterior (line 229) | def q_posterior(self, x_start, x_t, t):
    method p_mean_variance (line 240) | def p_mean_variance(self, x, t, clip_denoised: bool):
    method p_sample (line 255) | def p_sample(self, x, t, clip_denoised=True, repeat_noise=False):
    method p_sample_loop (line 268) | def p_sample_loop(self, shape):
    method sample (line 285) | def sample(self, batch_size=16, return_intermediates=False):
    method q_sample (line 290) | def q_sample(self, x_start, t, noise=None):
    method predict_start_from_z_and_v (line 298) | def predict_start_from_z_and_v(self, x_t, t, v):
    method predict_eps_from_z_and_v (line 306) | def predict_eps_from_z_and_v(self, x_t, t, v):
    method get_v (line 313) | def get_v(self, x, noise, t):
  class LatentDiffusion (line 320) | class LatentDiffusion(DDPM):
    method __init__ (line 323) | def __init__(
    method make_cond_schedule (line 371) | def make_cond_schedule(
    method register_schedule (line 384) | def register_schedule(
    method instantiate_first_stage (line 401) | def instantiate_first_stage(self, config):
    method decode_first_stage (line 408) | def decode_first_stage(self, z):
    method mel_spectrogram_to_waveform (line 414) | def mel_spectrogram_to_waveform(self, mel):
    method encode_first_stage (line 423) | def encode_first_stage(self, x):
    method sample_log (line 428) | def sample_log(
    method apply_model (line 459) | def apply_model(self, x_noisy, t, cond, return_ids=False):
    method generate_sample (line 468) | def generate_sample(
  class DiffusionWrapper (line 537) | class DiffusionWrapper(nn.Module):
    method __init__ (line 538) | def __init__(self, diff_model_config, conditioning_key):
    method forward (line 543) | def forward(self, x, t, cond_dict: dict = {}):
  function extract_encoder_state_dict (line 560) | def extract_encoder_state_dict(checkpoint_path):
  function overlap_add_waveform (line 572) | def overlap_add_waveform(windowed_waveforms, overlap_duration=0.64):

FILE: semanticodec/modules/decoder/latent_diffusion/models/dpm_solver/dpm_solver.py
  class NoiseScheduleVP (line 6) | class NoiseScheduleVP:
    method __init__ (line 7) | def __init__(
    method marginal_log_mean_coeff (line 144) | def marginal_log_mean_coeff(self, t):
    method marginal_alpha (line 163) | def marginal_alpha(self, t):
    method marginal_std (line 169) | def marginal_std(self, t):
    method marginal_lambda (line 175) | def marginal_lambda(self, t):
    method inverse_lambda (line 183) | def inverse_lambda(self, lamb):
  function model_wrapper (line 220) | def model_wrapper(
  class DPM_Solver (line 405) | class DPM_Solver:
    method __init__ (line 406) | def __init__(
    method noise_prediction_fn (line 441) | def noise_prediction_fn(self, x, t):
    method data_prediction_fn (line 447) | def data_prediction_fn(self, x, t):
    method model_fn (line 466) | def model_fn(self, x, t):
    method get_time_steps (line 475) | def get_time_steps(self, skip_type, t_T, t_0, N, device):
    method get_orders_and_timesteps_for_singlestep_solver (line 514) | def get_orders_and_timesteps_for_singlestep_solver(
    method denoise_to_zero_fn (line 604) | def denoise_to_zero_fn(self, x, s):
    method dpm_solver_first_update (line 610) | def dpm_solver_first_update(self, x, s, t, model_s=None, return_interm...
    method singlestep_dpm_solver_second_update (line 659) | def singlestep_dpm_solver_second_update(
    method singlestep_dpm_solver_third_update (line 770) | def singlestep_dpm_solver_third_update(
    method multistep_dpm_solver_second_update (line 925) | def multistep_dpm_solver_second_update(
    method multistep_dpm_solver_third_update (line 996) | def multistep_dpm_solver_third_update(
    method singlestep_dpm_solver_update (line 1056) | def singlestep_dpm_solver_update(
    method multistep_dpm_solver_update (line 1109) | def multistep_dpm_solver_update(
    method dpm_solver_adaptive (line 1141) | def dpm_solver_adaptive(
    method sample (line 1233) | def sample(
  function interpolate_fn (line 1457) | def interpolate_fn(x, xp, yp):
  function expand_dims (line 1509) | def expand_dims(v, dims):

FILE: semanticodec/modules/decoder/latent_diffusion/modules/attention.py
  function exists (line 13) | def exists(val):
  function uniq (line 17) | def uniq(arr):
  function default (line 21) | def default(val, d):
  function max_neg_value (line 27) | def max_neg_value(t):
  function init_ (line 31) | def init_(tensor):
  class GEGLU (line 39) | class GEGLU(nn.Module):
    method __init__ (line 40) | def __init__(self, dim_in, dim_out):
    method forward (line 44) | def forward(self, x):
  class FeedForward (line 49) | class FeedForward(nn.Module):
    method __init__ (line 50) | def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0.0):
    method forward (line 64) | def forward(self, x):
  function zero_module (line 68) | def zero_module(module):
  function Normalize (line 77) | def Normalize(in_channels):
  class LinearAttention (line 83) | class LinearAttention(nn.Module):
    method __init__ (line 84) | def __init__(self, dim, heads=4, dim_head=32):
    method forward (line 91) | def forward(self, x):
  class SpatialSelfAttention (line 106) | class SpatialSelfAttention(nn.Module):
    method __init__ (line 107) | def __init__(self, in_channels):
    method forward (line 125) | def forward(self, x):
  class CrossAttention (line 328) | class CrossAttention(nn.Module):
    method __init__ (line 329) | def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, ...
    method forward (line 345) | def forward(self, x, context=None, mask=None):
  class BasicTransformerBlock (line 372) | class BasicTransformerBlock(nn.Module):
    method __init__ (line 373) | def __init__(
    method forward (line 400) | def forward(self, x, context=None, mask=None):
    method _forward (line 408) | def _forward(self, x, context=None, mask=None):
  class SpatialTransformer (line 415) | class SpatialTransformer(nn.Module):
    method __init__ (line 424) | def __init__(
    method forward (line 458) | def forward(self, x, context=None, mask=None):

FILE: semanticodec/modules/decoder/latent_diffusion/modules/diffusionmodules/model.py
  function get_timestep_embedding (line 14) | def get_timestep_embedding(timesteps, embedding_dim):
  function nonlinearity (line 35) | def nonlinearity(x):
  function Normalize (line 40) | def Normalize(in_channels, num_groups=32):
  class Upsample (line 46) | class Upsample(nn.Module):
    method __init__ (line 47) | def __init__(self, in_channels, with_conv):
    method forward (line 55) | def forward(self, x):
  class UpsampleTimeStride4 (line 62) | class UpsampleTimeStride4(nn.Module):
    method __init__ (line 63) | def __init__(self, in_channels, with_conv):
    method forward (line 71) | def forward(self, x):
  class Downsample (line 78) | class Downsample(nn.Module):
    method __init__ (line 79) | def __init__(self, in_channels, with_conv):
    method forward (line 89) | def forward(self, x):
  class DownsampleTimeStride4 (line 99) | class DownsampleTimeStride4(nn.Module):
    method __init__ (line 100) | def __init__(self, in_channels, with_conv):
    method forward (line 110) | def forward(self, x):
  class ResnetBlock (line 120) | class ResnetBlock(nn.Module):
    method __init__ (line 121) | def __init__(
    method forward (line 157) | def forward(self, x, temb):
  class LinAttnBlock (line 180) | class LinAttnBlock(LinearAttention):
    method __init__ (line 183) | def __init__(self, in_channels):
  class AttnBlock (line 187) | class AttnBlock(nn.Module):
    method __init__ (line 188) | def __init__(self, in_channels):
    method forward (line 206) | def forward(self, x):
  function make_attn (line 235) | def make_attn(in_channels, attn_type="vanilla"):
  class Model (line 245) | class Model(nn.Module):
    method __init__ (line 246) | def __init__(
    method forward (line 367) | def forward(self, x, t=None, context=None):
    method get_last_layer (line 416) | def get_last_layer(self):
  class Encoder (line 420) | class Encoder(nn.Module):
    method __init__ (line 421) | def __init__(
    method forward (line 520) | def forward(self, x):
  class Decoder (line 547) | class Decoder(nn.Module):
    method __init__ (line 548) | def __init__(
    method forward (line 654) | def forward(self, z):
  class SimpleDecoder (line 690) | class SimpleDecoder(nn.Module):
    method __init__ (line 691) | def __init__(self, in_channels, out_channels, *args, **kwargs):
    method forward (line 724) | def forward(self, x):
  class UpsampleDecoder (line 737) | class UpsampleDecoder(nn.Module):
    method __init__ (line 738) | def __init__(
    method forward (line 781) | def forward(self, x):
  class LatentRescaler (line 795) | class LatentRescaler(nn.Module):
    method __init__ (line 796) | def __init__(self, factor, in_channels, mid_channels, out_channels, de...
    method forward (line 833) | def forward(self, x):
  class MergedRescaleEncoder (line 851) | class MergedRescaleEncoder(nn.Module):
    method __init__ (line 852) | def __init__(
    method forward (line 889) | def forward(self, x):
  class MergedRescaleDecoder (line 895) | class MergedRescaleDecoder(nn.Module):
    method __init__ (line 896) | def __init__(
    method forward (line 932) | def forward(self, x):
  class Upsampler (line 938) | class Upsampler(nn.Module):
    method __init__ (line 939) | def __init__(self, in_size, out_size, in_channels, out_channels, ch_mu...
    method forward (line 964) | def forward(self, x):
  class Resize (line 970) | class Resize(nn.Module):
    method __init__ (line 971) | def __init__(self, in_channels=None, learned=False, mode="bilinear"):
    method forward (line 986) | def forward(self, x, scale_factor=1.0):
  class FirstStagePostProcessor (line 996) | class FirstStagePostProcessor(nn.Module):
    method __init__ (line 997) | def __init__(
    method instantiate_pretrained (line 1044) | def instantiate_pretrained(self, config):
    method encode_with_pretrained (line 1052) | def encode_with_pretrained(self, x):
    method forward (line 1058) | def forward(self, x):

FILE: semanticodec/modules/decoder/latent_diffusion/modules/diffusionmodules/openaimodel.py
  function convert_module_to_f16 (line 26) | def convert_module_to_f16(x):
  function convert_module_to_f32 (line 30) | def convert_module_to_f32(x):
  class AttentionPool2d (line 35) | class AttentionPool2d(nn.Module):
    method __init__ (line 40) | def __init__(
    method forward (line 56) | def forward(self, x):
  class TimestepBlock (line 67) | class TimestepBlock(nn.Module):
    method forward (line 73) | def forward(self, x, emb):
  class TimestepEmbedSequential (line 79) | class TimestepEmbedSequential(nn.Sequential, TimestepBlock):
    method forward (line 85) | def forward(self, x, emb, context_list=None, mask_list=None):
  class Upsample (line 110) | class Upsample(nn.Module):
    method __init__ (line 119) | def __init__(self, channels, use_conv, dims=2, out_channels=None, padd...
    method forward (line 130) | def forward(self, x):
  class TransposedUpsample (line 143) | class TransposedUpsample(nn.Module):
    method __init__ (line 146) | def __init__(self, channels, out_channels=None, ks=5):
    method forward (line 155) | def forward(self, x):
  class Downsample (line 159) | class Downsample(nn.Module):
    method __init__ (line 168) | def __init__(self, channels, use_conv, dims=2, out_channels=None, padd...
    method forward (line 188) | def forward(self, x):
  class ResBlock (line 193) | class ResBlock(TimestepBlock):
    method __init__ (line 209) | def __init__(
    method forward (line 273) | def forward(self, x, emb):
    method _forward (line 284) | def _forward(self, x, emb):
  class AttentionBlock (line 307) | class AttentionBlock(nn.Module):
    method __init__ (line 314) | def __init__(
    method forward (line 343) | def forward(self, x):
    method _forward (line 349) | def _forward(self, x):
  function count_flops_attn (line 358) | def count_flops_attn(model, _x, y):
  class QKVAttentionLegacy (line 378) | class QKVAttentionLegacy(nn.Module):
    method __init__ (line 383) | def __init__(self, n_heads):
    method forward (line 387) | def forward(self, qkv):
    method count_flops (line 408) | def count_flops(model, _x, y):
  class QKVAttention (line 412) | class QKVAttention(nn.Module):
    method __init__ (line 417) | def __init__(self, n_heads):
    method forward (line 421) | def forward(self, qkv):
    method count_flops (line 446) | def count_flops(model, _x, y):
  class UNetModel (line 450) | class UNetModel(nn.Module):
    method __init__ (line 480) | def __init__(
    method convert_to_fp16 (line 825) | def convert_to_fp16(self):
    method convert_to_fp32 (line 833) | def convert_to_fp32(self):
    method forward (line 841) | def forward(
  class EncoderUNetModel (line 891) | class EncoderUNetModel(nn.Module):
    method __init__ (line 897) | def __init__(
    method convert_to_fp16 (line 1070) | def convert_to_fp16(self):
    method convert_to_fp32 (line 1077) | def convert_to_fp32(self):
    method forward (line 1084) | def forward(self, x, timesteps):

FILE: semanticodec/modules/decoder/latent_diffusion/modules/diffusionmodules/util.py
  function make_beta_schedule (line 21) | def make_beta_schedule(
  function make_ddim_timesteps (line 56) | def make_ddim_timesteps(
  function make_ddim_sampling_parameters (line 79) | def make_ddim_sampling_parameters(alphacums, ddim_timesteps, eta, verbos...
  function betas_for_alpha_bar (line 99) | def betas_for_alpha_bar(num_diffusion_timesteps, alpha_bar, max_beta=0.9...
  function extract_into_tensor (line 118) | def extract_into_tensor(a, t, x_shape):
  function checkpoint (line 124) | def checkpoint(func, inputs, params, flag):
  class CheckpointFunction (line 141) | class CheckpointFunction(torch.autograd.Function):
    method forward (line 143) | def forward(ctx, run_function, length, *args):
    method backward (line 153) | def backward(ctx, *output_grads):
  function timestep_embedding (line 173) | def timestep_embedding(timesteps, dim, max_period=10000, repeat_only=Fal...
  function zero_module (line 200) | def zero_module(module):
  function scale_module (line 209) | def scale_module(module, scale):
  function mean_flat (line 218) | def mean_flat(tensor):
  function normalization (line 225) | def normalization(channels):
  class SiLU (line 235) | class SiLU(nn.Module):
    method forward (line 236) | def forward(self, x):
  class GroupNorm32 (line 240) | class GroupNorm32(nn.GroupNorm):
    method forward (line 241) | def forward(self, x):
  function conv_nd (line 245) | def conv_nd(dims, *args, **kwargs):
  function linear (line 258) | def linear(*args, **kwargs):
  function avg_pool_nd (line 265) | def avg_pool_nd(dims, *args, **kwargs):
  class HybridConditioner (line 278) | class HybridConditioner(nn.Module):
    method __init__ (line 279) | def __init__(self, c_concat_config, c_crossattn_config):
    method forward (line 284) | def forward(self, c_concat, c_crossattn):
  function noise_like (line 290) | def noise_like(shape, device, repeat=False):

FILE: semanticodec/modules/decoder/latent_diffusion/modules/distributions/distributions.py
  class AbstractDistribution (line 5) | class AbstractDistribution:
    method sample (line 6) | def sample(self):
    method mode (line 9) | def mode(self):
  class DiracDistribution (line 13) | class DiracDistribution(AbstractDistribution):
    method __init__ (line 14) | def __init__(self, value):
    method sample (line 17) | def sample(self):
    method mode (line 20) | def mode(self):
  class DiagonalGaussianDistribution (line 24) | class DiagonalGaussianDistribution(object):
    method __init__ (line 25) | def __init__(self, parameters, deterministic=False):
    method sample (line 37) | def sample(self):
    method kl (line 43) | def kl(self, other=None):
    method nll (line 62) | def nll(self, sample, dims=[1, 2, 3]):
    method mode (line 71) | def mode(self):
  function normal_kl (line 75) | def normal_kl(mean1, logvar1, mean2, logvar2):

FILE: semanticodec/modules/decoder/latent_diffusion/modules/ema.py
  class LitEma (line 5) | class LitEma(nn.Module):
    method __init__ (line 6) | def __init__(self, model, decay=0.9999, use_num_upates=True):
    method forward (line 29) | def forward(self, model):
    method copy_to (line 52) | def copy_to(self, model):
    method store (line 61) | def store(self, parameters):
    method restore (line 70) | def restore(self, parameters):

FILE: semanticodec/modules/decoder/latent_diffusion/modules/mamba.py
  function count_parameters (line 6) | def count_parameters(model):
  class MambaBlocks (line 19) | class MambaBlocks(nn.Module):
    method __init__ (line 20) | def __init__(self, dim, n_block=4):
    method forward (line 38) | def forward(self, x):

FILE: semanticodec/modules/decoder/latent_diffusion/modules/nn.py
  class GroupNorm32 (line 12) | class GroupNorm32(nn.GroupNorm):
    method __init__ (line 13) | def __init__(self, num_groups, num_channels, swish, eps=1e-5):
    method forward (line 17) | def forward(self, x):
  function conv_nd (line 26) | def conv_nd(dims, *args, **kwargs):
  function linear (line 39) | def linear(*args, **kwargs):
  function avg_pool_nd (line 46) | def avg_pool_nd(dims, *args, **kwargs):
  function update_ema (line 59) | def update_ema(target_params, source_params, rate=0.99):
  function zero_module (line 72) | def zero_module(module):
  function scale_module (line 81) | def scale_module(module, scale):
  function mean_flat (line 90) | def mean_flat(tensor):
  function normalization (line 97) | def normalization(channels, swish=0.0):
  function timestep_embedding (line 128) | def timestep_embedding(timesteps, dim, max_period=10000, repeat_only=Fal...
  function checkpoint (line 153) | def checkpoint(func, inputs, params, flag):
  class CheckpointFunction (line 172) | class CheckpointFunction(th.autograd.Function):
    method forward (line 174) | def forward(ctx, run_function, length, *args):
    method backward (line 183) | def backward(ctx, *output_grads):

FILE: semanticodec/modules/decoder/latent_diffusion/modules/x_transformer.py
  class AbsolutePositionalEmbedding (line 19) | class AbsolutePositionalEmbedding(nn.Module):
    method __init__ (line 20) | def __init__(self, dim, max_seq_len):
    method init_ (line 25) | def init_(self):
    method forward (line 28) | def forward(self, x):
  class FixedPositionalEmbedding (line 33) | class FixedPositionalEmbedding(nn.Module):
    method __init__ (line 34) | def __init__(self, dim):
    method forward (line 39) | def forward(self, x, seq_dim=1, offset=0):
  function exists (line 52) | def exists(val):
  function default (line 56) | def default(val, d):
  function always (line 62) | def always(val):
  function not_equals (line 69) | def not_equals(val):
  function equals (line 76) | def equals(val):
  function max_neg_value (line 83) | def max_neg_value(tensor):
  function pick_and_pop (line 90) | def pick_and_pop(keys, d):
  function group_dict_by_key (line 95) | def group_dict_by_key(cond, d):
  function string_begins_with (line 104) | def string_begins_with(prefix, str):
  function group_by_key_prefix (line 108) | def group_by_key_prefix(prefix, d):
  function groupby_prefix_and_trim (line 112) | def groupby_prefix_and_trim(prefix, d):
  class Scale (line 123) | class Scale(nn.Module):
    method __init__ (line 124) | def __init__(self, value, fn):
    method forward (line 129) | def forward(self, x, **kwargs):
  class Rezero (line 134) | class Rezero(nn.Module):
    method __init__ (line 135) | def __init__(self, fn):
    method forward (line 140) | def forward(self, x, **kwargs):
  class ScaleNorm (line 145) | class ScaleNorm(nn.Module):
    method __init__ (line 146) | def __init__(self, dim, eps=1e-5):
    method forward (line 152) | def forward(self, x):
  class RMSNorm (line 157) | class RMSNorm(nn.Module):
    method __init__ (line 158) | def __init__(self, dim, eps=1e-8):
    method forward (line 164) | def forward(self, x):
  class Residual (line 169) | class Residual(nn.Module):
    method forward (line 170) | def forward(self, x, residual):
  class GRUGating (line 174) | class GRUGating(nn.Module):
    method __init__ (line 175) | def __init__(self, dim):
    method forward (line 179) | def forward(self, x, residual):
  class GEGLU (line 190) | class GEGLU(nn.Module):
    method __init__ (line 191) | def __init__(self, dim_in, dim_out):
    method forward (line 195) | def forward(self, x):
  class FeedForward (line 200) | class FeedForward(nn.Module):
    method __init__ (line 201) | def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0.0):
    method forward (line 215) | def forward(self, x):
  class Attention (line 220) | class Attention(nn.Module):
    method __init__ (line 221) | def __init__(
    method forward (line 279) | def forward(
  class AttentionLayers (line 393) | class AttentionLayers(nn.Module):
    method __init__ (line 394) | def __init__(
    method forward (line 514) | def forward(
  class Encoder (line 587) | class Encoder(AttentionLayers):
    method __init__ (line 588) | def __init__(self, **kwargs):
  class TransformerWrapper (line 593) | class TransformerWrapper(nn.Module):
    method __init__ (line 594) | def __init__(
    method init_ (line 649) | def init_(self):
    method forward (line 652) | def forward(

FILE: semanticodec/modules/decoder/latent_diffusion/util.py
  function disabled_train (line 17) | def disabled_train(self, mode=True):
  function get_unconditional_condition (line 23) | def get_unconditional_condition(batchsize, downsampling_rate, device):
  function log_txt_as_img (line 31) | def log_txt_as_img(wh, xc, size=10):
  function ismap (line 57) | def ismap(x):
  function isimage (line 63) | def isimage(x):
  function int16_to_float32 (line 69) | def int16_to_float32(x):
  function float32_to_int16 (line 73) | def float32_to_int16(x):
  function exists (line 78) | def exists(x):
  function default (line 82) | def default(val, d):
  function mean_flat (line 88) | def mean_flat(tensor):
  function count_params (line 96) | def count_params(model, verbose=False):
  function instantiate_from_config (line 103) | def instantiate_from_config(config):
  function get_obj_from_str (line 113) | def get_obj_from_str(string, reload=False):
  function _do_parallel_data_prefetch (line 121) | def _do_parallel_data_prefetch(func, Q, data, idx, idx_to_fn=False):
  function parallel_data_prefetch (line 133) | def parallel_data_prefetch(

FILE: semanticodec/modules/decoder/latent_encoder/autoencoder.py
  class AutoencoderKL (line 21) | class AutoencoderKL(nn.Module):
    method __init__ (line 22) | def __init__(
    method get_log_dir (line 83) | def get_log_dir(self):
    method set_log_dir (line 88) | def set_log_dir(self, save_dir, exp_group_name, exp_name):
    method init_from_ckpt (line 93) | def init_from_ckpt(self, path, ignore_keys=list()):
    method encode (line 104) | def encode(self, x):
    method decode (line 112) | def decode(self, z):
    method decode_to_waveform (line 120) | def decode_to_waveform(self, dec):
    method forward (line 131) | def forward(self, input, sample_posterior=True):
    method freq_split_subband (line 146) | def freq_split_subband(self, fbank):
    method freq_merge_subband (line 161) | def freq_merge_subband(self, subband_fbank):
    method save_wave (line 168) | def save_wave(self, batch_wav, fname, save_dir):
    method get_last_layer (line 176) | def get_last_layer(self):
    method log_images (line 180) | def log_images(self, batch, train=True, only_inputs=False, waveform=No...
    method tensor2numpy (line 192) | def tensor2numpy(self, tensor):
    method to_rgb (line 195) | def to_rgb(self, x):
  class IdentityFirstStage (line 204) | class IdentityFirstStage(torch.nn.Module):
    method __init__ (line 205) | def __init__(self, *args, vq_interface=False, **kwargs):
    method encode (line 209) | def encode(self, x, *args, **kwargs):
    method decode (line 212) | def decode(self, x, *args, **kwargs):
    method quantize (line 215) | def quantize(self, x, *args, **kwargs):
    method forward (line 220) | def forward(self, x, *args, **kwargs):

FILE: semanticodec/modules/decoder/utilities/audio/audio_processing.py
  function window_sumsquare (line 7) | def window_sumsquare(
  function griffin_lim (line 66) | def griffin_lim(magnitudes, stft_fn, n_iters=30):
  function dynamic_range_compression (line 85) | def dynamic_range_compression(x, normalize_fun=torch.log, C=1, clip_val=...
  function dynamic_range_decompression (line 94) | def dynamic_range_decompression(x, C=1):

FILE: semanticodec/modules/decoder/utilities/audio/stft.py
  class STFT (line 15) | class STFT(torch.nn.Module):
    method __init__ (line 18) | def __init__(self, filter_length, hop_length, win_length, window="hann"):
    method transform (line 52) | def transform(self, input_data):
    method inverse (line 83) | def inverse(self, magnitude, phase):
    method forward (line 124) | def forward(self, input_data):
  class TacotronSTFT (line 130) | class TacotronSTFT(torch.nn.Module):
    method __init__ (line 131) | def __init__(
    method spectral_normalize (line 151) | def spectral_normalize(self, magnitudes, normalize_fun):
    method spectral_de_normalize (line 155) | def spectral_de_normalize(self, magnitudes):
    method mel_spectrogram (line 159) | def mel_spectrogram(self, y, normalize_fun=torch.log):

FILE: semanticodec/modules/decoder/utilities/audio/tools.py
  function get_mel_from_wav (line 9) | def get_mel_from_wav(audio, _stft):
  function inv_mel_spec (line 19) | def inv_mel_spec(mel, out_filename, _stft, griffin_iters=60):

FILE: semanticodec/modules/decoder/utilities/model.py
  function get_available_checkpoint_keys (line 10) | def get_available_checkpoint_keys(model, ckpt):
  function get_param_num (line 30) | def get_param_num(model):
  function torch_version_orig_mod_remove (line 35) | def torch_version_orig_mod_remove(state_dict):
  function get_vocoder (line 48) | def get_vocoder(config, device, mel_bins):
  function vocoder_infer (line 87) | def vocoder_infer(mels, vocoder, lengths=None):

FILE: semanticodec/modules/decoder/utilities/tools.py
  function load_json (line 41) | def load_json(fname):
  function read_json (line 47) | def read_json(dataset_json_file):
  function copy_test_subset_data (line 53) | def copy_test_subset_data(metadata, testset_copy_target_path):
  function listdir_nohidden (line 72) | def listdir_nohidden(path):
  function get_restore_step (line 77) | def get_restore_step(path):
  function download (line 98) | def download(url, local_path, chunk_size=1024):
  function md5_hash (line 110) | def md5_hash(path):
  function get_ckpt_path (line 116) | def get_ckpt_path(name, root, check=False):
  class KeyNotFoundError (line 127) | class KeyNotFoundError(Exception):
    method __init__ (line 128) | def __init__(self, cause, keys=None, visited=None):
  function retrieve (line 142) | def retrieve(
  function to_device (line 225) | def to_device(data, device):
  function log (line 276) | def log(logger, step=None, fig=None, audio=None, sampling_rate=22050, ta...
  function get_mask_from_lengths (line 304) | def get_mask_from_lengths(lengths, max_len=None):
  function expand (line 315) | def expand(values, durations):
  function synth_one_sample (line 322) | def synth_one_sample(mel_input, mel_prediction, labels, vocoder):
  function pad_1D (line 340) | def pad_1D(inputs, PAD=0):
  function pad_2D (line 353) | def pad_2D(inputs, maxlen=None):
  function pad (line 374) | def pad(input_ele, mel_max_length=None):

FILE: semanticodec/modules/encoder/encoder.py
  class AudioMAEConditionQuantResEncoder (line 17) | class AudioMAEConditionQuantResEncoder(nn.Module):
    method __init__ (line 18) | def __init__(
    method mark_out_padding (line 97) | def mark_out_padding(self, feature, padding_cutoff_index):
    method get_unconditional_condition (line 106) | def get_unconditional_condition(self, batchsize):
    method quant_mem_efficient (line 124) | def quant_mem_efficient(
    method unquant (line 162) | def unquant(self, tokens):
    method indices_utilization_statistic (line 174) | def indices_utilization_statistic(self, indices):
    method concate (line 232) | def concate(self, representation):
    method get_unconditional_condition (line 247) | def get_unconditional_condition(self, batchsize):
    method long_token_split_window (line 281) | def long_token_split_window(self, tokens, window_length=512, overlap=0...
    method forward (line 302) | def forward(self, batch):
    method _forward (line 326) | def _forward(self, batch):
    method token_to_quantized_feature (line 462) | def token_to_quantized_feature(self, tokens):
    method wrap_return_dict (line 471) | def wrap_return_dict(self, crossattn_audiomae_pooled, tokens):

FILE: semanticodec/utils.py
  function concat_1x2 (line 8) | def concat_1x2(tensor):
  function concat_2x2 (line 22) | def concat_2x2(tensor):
  function extract_kaldi_fbank_feature (line 35) | def extract_kaldi_fbank_feature(waveform, sampling_rate, target_length=1...
  class PositionalEncoding (line 76) | class PositionalEncoding:
    method __init__ (line 77) | def __init__(self, seq_length=512, embedding_dim=192):
    method __call__ (line 93) | def __call__(self, x):

FILE: setup.py
  class UploadCommand (line 67) | class UploadCommand(Command):
    method status (line 74) | def status(s):
    method initialize_options (line 78) | def initialize_options(self):
    method finalize_options (line 81) | def finalize_options(self):
    method run (line 84) | def run(self):

FILE: test/test_all_settings.py
  function test_semanticodec (line 4) | def test_semanticodec(token_rate, semantic_vocab_size, test_id):