SYMBOL INDEX (635 symbols across 52 files)

FILE: AutoEncoder/data/dataset.py
  class UdfsDataset (line 14) | class UdfsDataset(Dataset):
    method __init__ (line 15) | def __init__(self, name: str, root: Path, split: str) -> None:
    method __len__ (line 63) | def __len__(self) -> int:
    method get_training_idxes (line 66) | def get_training_idxes(self):
    method update_training_idxes (line 69) | def update_training_idxes(self, new_idxes):
    method val_del_idxes (line 75) | def val_del_idxes(self):
    method __getitem__ (line 79) | def __getitem__(self, index: int) -> T_ITEM:
    method get_mesh (line 90) | def get_mesh(self, index: int) -> Tuple[Tensor, Tensor]:

FILE: AutoEncoder/encdec/DynamicSampler.py
  class DummyDataset (line 13) | class DummyDataset(Dataset):
    method __init__ (line 14) | def __init__(self):
    method __getitem__ (line 17) | def __getitem__(self, index):
    method __len__ (line 20) | def __len__(self):
    method get_training_idxes (line 23) | def get_training_idxes(self):
    method update_training_idxes (line 26) | def update_training_idxes(self, new_idxes):
  class SequenceSampler (line 29) | class SequenceSampler(Sampler):
    method __init__ (line 30) | def __init__(self, training_idxes, N):
    method __iter__ (line 34) | def __iter__(self) -> Iterator[int]:
    method __len__ (line 38) | def __len__(self) -> int:
    method update_training_idxes (line 41) | def update_training_idxes(self, new_add_idxes):
  class SequenceSampler_Train (line 44) | class SequenceSampler_Train(Sampler):
    method __init__ (line 45) | def __init__(self, training_idxes):
    method __iter__ (line 49) | def __iter__(self) -> Iterator[int]:
    method __len__ (line 53) | def __len__(self) -> int:
    method update_training_idxes (line 56) | def update_training_idxes(self, new_add_idxes):
  class WeightedDynamicSampler (line 59) | class WeightedDynamicSampler(WeightedRandomSampler):
    method __init__ (line 61) | def __init__(self, weights: Sequence[float], num_samples: int,
    method __iter__ (line 79) | def __iter__(self) -> Iterator[int]:
    method __len__ (line 83) | def __len__(self) -> int:
    method update_weights (line 86) | def update_weights(self, weights):
  class DynamicBatchSampler (line 90) | class DynamicBatchSampler(BatchSampler):
    method update_weights (line 92) | def update_weights(self, weights):
    method update_training_idxes (line 95) | def update_training_idxes(self, training_idxes):

FILE: AutoEncoder/encdec/export_meshes.py
  function main (line 39) | def main() -> None:

FILE: AutoEncoder/encdec/normalized_obj.py
  function obj_normalization (line 4) | def obj_normalization(input_mesh_file, output_file_path):
  function box_center_normalization (line 21) | def box_center_normalization(input_mesh_file, output_file_path):

FILE: AutoEncoder/encdec/preprocess_udfs.py
  function PrepareOneUDF (line 110) | def PrepareOneUDF(sub_id, split):

FILE: AutoEncoder/encdec/train_encdec.py
  function main (line 24) | def main() -> None:

FILE: AutoEncoder/models/cbndec.py
  class DecoderConditionalBatchNorm (line 4) | class DecoderConditionalBatchNorm(nn.Module):
    method __init__ (line 5) | def __init__(
    method forward (line 35) | def forward(self, points: Tensor, conditions: Tensor) -> Tensor:
  class ConditionalBatchNorm1d (line 50) | class ConditionalBatchNorm1d(nn.Module):
    method __init__ (line 51) | def __init__(self, c_dim: int, f_dim: int) -> None:
    method reset_parameters (line 62) | def reset_parameters(self) -> None:
    method forward (line 68) | def forward(self, x: Tensor, c: Tensor) -> Tensor:
  class ConditionalResnetBlock1d (line 85) | class ConditionalResnetBlock1d(nn.Module):
    method __init__ (line 86) | def __init__(self, c_dim: int, size_in: int) -> None:
    method forward (line 99) | def forward(self, x: Tensor, c: Tensor) -> Tensor:
  class CbnDecoder (line 106) | class CbnDecoder(nn.Module):
    method __init__ (line 107) | def __init__(
    method forward (line 127) | def forward(self, coords_emb, latent_codes) -> Tensor:

FILE: AutoEncoder/models/coordsenc.py
  class CoordsEncoder (line 7) | class CoordsEncoder:
    method __init__ (line 8) | def __init__(
    method create_encoding_fn (line 25) | def create_encoding_fn(self) -> None:
    method encode (line 50) | def encode(self, inputs: Tensor) -> Tensor:

FILE: AutoEncoder/models/dgcnn.py
  function get_graph_feature (line 9) | def get_graph_feature(x: Tensor, indices: Tensor) -> Tensor:
  class Dgcnn (line 27) | class Dgcnn(nn.Module):
    method __init__ (line 28) | def __init__(
    method block_forward (line 55) | def block_forward(
    method forward (line 77) | def forward(self, x: Tensor, latent_index=None) -> Tensor:

FILE: AutoEncoder/trainers/encdec.py
  class EncoderDecoderTrainer (line 35) | class EncoderDecoderTrainer:
    method __init__ (line 36) | def __init__(self) -> None:
    method train (line 115) | def train(self) -> None:
    method val (line 228) | def val(self) -> float:
    method save_ckpt (line 299) | def save_ckpt(self, all: bool = False, best=False) -> None:
    method restore_from_last_ckpt (line 325) | def restore_from_last_ckpt(self) -> None:

FILE: AutoEncoder/trainers/test.py
  class DynamicWeightedRandomSampler (line 10) | class DynamicWeightedRandomSampler(WeightedRandomSampler):
    method update_distribution (line 16) | def update_distribution(self, weights):
    method __len__ (line 19) | def __len__(self):
  class BatchSampler (line 22) | class BatchSampler(Sampler):
    method __init__ (line 23) | def __init__(self, sampler, batch_size, drop_last):
    method __iter__ (line 28) | def __iter__(self):
    method __len__ (line 37) | def __len__(self):

FILE: AutoEncoder/utils.py
  function read_mesh (line 13) | def read_mesh(
  function get_tensor_mesh_from_o3d (line 41) | def get_tensor_mesh_from_o3d(
  function get_o3d_mesh_from_tensors (line 81) | def get_o3d_mesh_from_tensors(
  function progress_bar (line 126) | def progress_bar(iterable: Iterable, desc: str = "", num_cols: int = 60)...
  function get_tensor_pcd_from_o3d (line 141) | def get_tensor_pcd_from_o3d(
  function sample_points_around_pcd (line 167) | def sample_points_around_pcd(
  function compute_udf_and_gradients (line 223) | def compute_udf_and_gradients(
  function compute_sdf_and_gradients (line 242) | def compute_sdf_and_gradients(
  function compute_udf_from_mesh (line 268) | def compute_udf_from_mesh(
  function compute_sdf_from_mesh (line 317) | def compute_sdf_from_mesh(
  function compute_gradients (line 365) | def compute_gradients(x: Tensor, y: Tensor) -> Tensor:
  function batchify (line 371) | def batchify(inputs: List[Tensor], required_dim: int) -> Tuple[bool, Lis...
  function unbatchify (line 393) | def unbatchify(inputs: List[Tensor]) -> List[Tensor]:
  function random_point_sampling (line 408) | def random_point_sampling(pcd: Tensor, num_points: int) -> Tensor:

FILE: CLIP/clip.py
  function _download (line 43) | def _download(url: str, root: str):
  function _convert_image_to_rgb (line 75) | def _convert_image_to_rgb(image):
  function _transform (line 79) | def _transform(n_px):
  function available_models (line 89) | def available_models() -> List[str]:
  function load (line 94) | def load(name: str, device: Union[str, torch.device] = "cuda" if torch.c...
  function tokenize (line 197) | def tokenize(texts: Union[str, List[str]], context_length: int = 77, tru...

FILE: CLIP/clip/clip.py
  function _download (line 43) | def _download(url: str, root: str):
  function _convert_image_to_rgb (line 75) | def _convert_image_to_rgb(image):
  function _transform (line 79) | def _transform(n_px):
  function available_models (line 89) | def available_models() -> List[str]:
  function load (line 94) | def load(name: str, device: Union[str, torch.device] = "cuda" if torch.c...
  function tokenize (line 197) | def tokenize(texts: Union[str, List[str]], context_length: int = 77, tru...

FILE: CLIP/clip/model.py
  class Bottleneck (line 10) | class Bottleneck(nn.Module):
    method __init__ (line 13) | def __init__(self, inplanes, planes, stride=1):
    method forward (line 42) | def forward(self, x: torch.Tensor):
  class AttentionPool2d (line 58) | class AttentionPool2d(nn.Module):
    method __init__ (line 59) | def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, o...
    method forward (line 68) | def forward(self, x):
  class ModifiedResNet (line 94) | class ModifiedResNet(nn.Module):
    method __init__ (line 102) | def __init__(self, layers, output_dim, heads, input_resolution=224, wi...
    method _make_layer (line 129) | def _make_layer(self, planes, blocks, stride=1):
    method forward (line 138) | def forward(self, x):
  class LayerNorm (line 157) | class LayerNorm(nn.LayerNorm):
    method forward (line 160) | def forward(self, x: torch.Tensor):
  class QuickGELU (line 166) | class QuickGELU(nn.Module):
    method forward (line 167) | def forward(self, x: torch.Tensor):
  class ResidualAttentionBlock (line 171) | class ResidualAttentionBlock(nn.Module):
    method __init__ (line 172) | def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor ...
    method attention (line 185) | def attention(self, x: torch.Tensor):
    method forward (line 189) | def forward(self, x: torch.Tensor):
  class Transformer (line 195) | class Transformer(nn.Module):
    method __init__ (line 196) | def __init__(self, width: int, layers: int, heads: int, attn_mask: tor...
    method forward (line 202) | def forward(self, x: torch.Tensor):
  class VisionTransformer (line 206) | class VisionTransformer(nn.Module):
    method __init__ (line 207) | def __init__(self, input_resolution: int, patch_size: int, width: int,...
    method forward (line 223) | def forward(self, x: torch.Tensor):
  class CLIP (line 243) | class CLIP(nn.Module):
    method __init__ (line 244) | def __init__(self,
    method initialize_parameters (line 299) | def initialize_parameters(self):
    method build_attention_mask (line 328) | def build_attention_mask(self):
    method dtype (line 337) | def dtype(self):
    method encode_image (line 340) | def encode_image(self, image):
    method encode_text (line 343) | def encode_text(self, text):
    method forward (line 358) | def forward(self, image, text):
  function convert_weights (line 375) | def convert_weights(model: nn.Module):
  function build_model (line 399) | def build_model(state_dict: dict):

FILE: CLIP/clip/simple_tokenizer.py
  function default_bpe (line 11) | def default_bpe():
  function bytes_to_unicode (line 16) | def bytes_to_unicode():
  function get_pairs (line 38) | def get_pairs(word):
  function basic_clean (line 50) | def basic_clean(text):
  function whitespace_clean (line 56) | def whitespace_clean(text):
  class SimpleTokenizer (line 62) | class SimpleTokenizer(object):
    method __init__ (line 63) | def __init__(self, bpe_path: str = default_bpe()):
    method bpe (line 80) | def bpe(self, token):
    method encode (line 121) | def encode(self, text):
    method decode (line 129) | def decode(self, tokens):

FILE: CLIP/hubconf.py
  function _create_hub_entrypoint (line 10) | def _create_hub_entrypoint(model):
  function tokenize (line 37) | def tokenize():

FILE: CLIP/model.py
  class Bottleneck (line 10) | class Bottleneck(nn.Module):
    method __init__ (line 13) | def __init__(self, inplanes, planes, stride=1):
    method forward (line 42) | def forward(self, x: torch.Tensor):
  class AttentionPool2d (line 58) | class AttentionPool2d(nn.Module):
    method __init__ (line 59) | def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, o...
    method forward (line 68) | def forward(self, x):
  class ModifiedResNet (line 94) | class ModifiedResNet(nn.Module):
    method __init__ (line 102) | def __init__(self, layers, output_dim, heads, input_resolution=224, wi...
    method _make_layer (line 129) | def _make_layer(self, planes, blocks, stride=1):
    method forward (line 138) | def forward(self, x):
  class LayerNorm (line 157) | class LayerNorm(nn.LayerNorm):
    method forward (line 160) | def forward(self, x: torch.Tensor):
  class QuickGELU (line 166) | class QuickGELU(nn.Module):
    method forward (line 167) | def forward(self, x: torch.Tensor):
  class ResidualAttentionBlock (line 171) | class ResidualAttentionBlock(nn.Module):
    method __init__ (line 172) | def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor ...
    method attention (line 185) | def attention(self, x: torch.Tensor):
    method forward (line 189) | def forward(self, x: torch.Tensor):
  class Transformer (line 195) | class Transformer(nn.Module):
    method __init__ (line 196) | def __init__(self, width: int, layers: int, heads: int, attn_mask: tor...
    method forward (line 202) | def forward(self, x: torch.Tensor):
  class VisionTransformer (line 206) | class VisionTransformer(nn.Module):
    method __init__ (line 207) | def __init__(self, input_resolution: int, patch_size: int, width: int,...
    method forward (line 223) | def forward(self, x: torch.Tensor):
  class CLIP (line 243) | class CLIP(nn.Module):
    method __init__ (line 244) | def __init__(self,
    method initialize_parameters (line 299) | def initialize_parameters(self):
    method build_attention_mask (line 328) | def build_attention_mask(self):
    method dtype (line 337) | def dtype(self):
    method encode_image (line 340) | def encode_image(self, image):
    method encode_text (line 343) | def encode_text(self, text):
    method forward (line 358) | def forward(self, image, text):
  function convert_weights (line 375) | def convert_weights(model: nn.Module):
  function build_model (line 399) | def build_model(state_dict: dict):

FILE: CLIP/simple_tokenizer.py
  function default_bpe (line 11) | def default_bpe():
  function bytes_to_unicode (line 16) | def bytes_to_unicode():
  function get_pairs (line 38) | def get_pairs(word):
  function basic_clean (line 50) | def basic_clean(text):
  function whitespace_clean (line 56) | def whitespace_clean(text):
  class SimpleTokenizer (line 62) | class SimpleTokenizer(object):
    method __init__ (line 63) | def __init__(self, bpe_path: str = default_bpe()):
    method bpe (line 80) | def bpe(self, token):
    method encode (line 121) | def encode(self, text):
    method decode (line 129) | def decode(self, tokens):

FILE: CLIP/tests/test_consistency.py
  function test_consistency (line 10) | def test_consistency(model_name):

FILE: data_loaders/dataset.py
  function mask2bbox (line 19) | def mask2bbox(mask):
  function crop_square (line 29) | def crop_square(img, bbox, img_size_h=256, img_size_w=256):
  function _convert_image_to_rgb (line 77) | def _convert_image_to_rgb(image):
  function _transform (line 80) | def _transform(n_px):
  function _transform_rgb (line 88) | def _transform_rgb(n_px):
  class UDFs3d (line 96) | class UDFs3d(Dataset):
    method __init__ (line 97) | def __init__(self, name: str, root: Path, split: str, cond: str) -> None:
    method __len__ (line 193) | def __len__(self) -> int:
    method __getitem__ (line 199) | def __getitem__(self, index: int) -> T_ITEM:
    method get_mesh (line 253) | def get_mesh(self, index: int) -> Tuple[Tensor, Tensor]:

FILE: diffusion/fp16_util.py
  function convert_module_to_f16 (line 15) | def convert_module_to_f16(l):
  function convert_module_to_f32 (line 25) | def convert_module_to_f32(l):
  function make_master_params (line 35) | def make_master_params(param_groups_and_shapes):
  function model_grads_to_master_grads (line 52) | def model_grads_to_master_grads(param_groups_and_shapes, master_params):
  function master_params_to_model_params (line 65) | def master_params_to_model_params(param_groups_and_shapes, master_params):
  function unflatten_master_params (line 78) | def unflatten_master_params(param_group, master_param):
  function get_param_groups_and_shapes (line 82) | def get_param_groups_and_shapes(named_model_params):
  function master_params_to_state_dict (line 95) | def master_params_to_state_dict(
  function state_dict_to_master_params (line 116) | def state_dict_to_master_params(model, state_dict, use_fp16):
  function zero_master_grads (line 128) | def zero_master_grads(master_params):
  function zero_grad (line 133) | def zero_grad(model_params):
  function param_grad_or_zeros (line 141) | def param_grad_or_zeros(param):
  class MixedPrecisionTrainer (line 148) | class MixedPrecisionTrainer:
    method __init__ (line 149) | def __init__(
    method zero_grad (line 173) | def zero_grad(self):
    method backward (line 176) | def backward(self, loss: th.Tensor):
    method optimize (line 183) | def optimize(self, opt: th.optim.Optimizer):
    method _optimize_fp16 (line 189) | def _optimize_fp16(self, opt: th.optim.Optimizer):
    method _optimize_normal (line 209) | def _optimize_normal(self, opt: th.optim.Optimizer):
    method _compute_norms (line 216) | def _compute_norms(self, grad_scale=1.0):
    method master_params_to_state_dict (line 226) | def master_params_to_state_dict(self, master_params):
    method state_dict_to_master_params (line 231) | def state_dict_to_master_params(self, state_dict):
  function check_overflow (line 235) | def check_overflow(value):

FILE: diffusion/gaussian_diffusion.py
  function get_named_beta_schedule (line 23) | def get_named_beta_schedule(schedule_name, num_diffusion_timesteps, scal...
  function betas_for_alpha_bar (line 50) | def betas_for_alpha_bar(num_diffusion_timesteps, alpha_bar, max_beta=0.9...
  class ModelMeanType (line 70) | class ModelMeanType(enum.Enum):
  class ModelVarType (line 80) | class ModelVarType(enum.Enum):
  class LossType (line 94) | class LossType(enum.Enum):
    method is_vb (line 102) | def is_vb(self):
  class GaussianDiffusion (line 106) | class GaussianDiffusion:
    method __init__ (line 123) | def __init__(
    method masked_l2 (line 184) | def masked_l2(self, a, b, mask):
    method q_mean_variance (line 195) | def q_mean_variance(self, x_start, t):
    method q_sample (line 212) | def q_sample(self, x_start, t, noise=None):
    method q_posterior_mean_variance (line 234) | def q_posterior_mean_variance(self, x_start, x_t, t):
    method p_mean_variance (line 258) | def p_mean_variance(
    method _predict_xstart_from_eps (line 365) | def _predict_xstart_from_eps(self, x_t, t, eps):
    method _predict_xstart_from_xprev (line 372) | def _predict_xstart_from_xprev(self, x_t, t, xprev):
    method _predict_eps_from_xstart (line 382) | def _predict_eps_from_xstart(self, x_t, t, pred_xstart):
    method _scale_timesteps (line 388) | def _scale_timesteps(self, t):
    method condition_mean (line 393) | def condition_mean(self, cond_fn, p_mean_var, x, t, model_kwargs=None):
    method condition_mean_with_grad (line 408) | def condition_mean_with_grad(self, cond_fn, p_mean_var, x, t, model_kw...
    method condition_score (line 423) | def condition_score(self, cond_fn, p_mean_var, x, t, model_kwargs=None):
    method condition_score_with_grad (line 447) | def condition_score_with_grad(self, cond_fn, p_mean_var, x, t, model_k...
    method p_sample (line 471) | def p_sample(
    method p_sample_with_grad (line 522) | def p_sample_with_grad(
    method p_sample_loop (line 570) | def p_sample_loop(
    method p_sample_loop_progressive (line 635) | def p_sample_loop_progressive(
    method ddim_sample (line 711) | def ddim_sample(
    method ddim_sample_with_grad (line 763) | def ddim_sample_with_grad(
    method ddim_reverse_sample (line 820) | def ddim_reverse_sample(
    method ddim_sample_loop (line 858) | def ddim_sample_loop(
    method ddim_sample_loop_progressive (line 907) | def ddim_sample_loop_progressive(
    method plms_sample (line 974) | def plms_sample(
    method plms_sample_loop (line 1058) | def plms_sample_loop(
    method plms_sample_loop_progressive (line 1100) | def plms_sample_loop_progressive(
    method _vb_terms_bpd (line 1171) | def _vb_terms_bpd(
    method training_losses (line 1206) | def training_losses(self, model, x_start, t, loss_L1, loss_args=None, ...
  function _extract_into_tensor (line 1329) | def _extract_into_tensor(arr, timesteps, broadcast_shape):

FILE: diffusion/logger.py
  class KVWriter (line 26) | class KVWriter(object):
    method writekvs (line 27) | def writekvs(self, kvs):
  class SeqWriter (line 31) | class SeqWriter(object):
    method writeseq (line 32) | def writeseq(self, seq):
  class HumanOutputFormat (line 36) | class HumanOutputFormat(KVWriter, SeqWriter):
    method __init__ (line 37) | def __init__(self, filename_or_file):
    method writekvs (line 48) | def writekvs(self, kvs):
    method _truncate (line 80) | def _truncate(self, s):
    method writeseq (line 84) | def writeseq(self, seq):
    method close (line 93) | def close(self):
  class JSONOutputFormat (line 98) | class JSONOutputFormat(KVWriter):
    method __init__ (line 99) | def __init__(self, filename):
    method writekvs (line 102) | def writekvs(self, kvs):
    method close (line 109) | def close(self):
  class CSVOutputFormat (line 113) | class CSVOutputFormat(KVWriter):
    method __init__ (line 114) | def __init__(self, filename):
    method writekvs (line 119) | def writekvs(self, kvs):
    method close (line 146) | def close(self):
  class TensorBoardOutputFormat (line 150) | class TensorBoardOutputFormat(KVWriter):
    method __init__ (line 155) | def __init__(self, dir):
    method writekvs (line 171) | def writekvs(self, kvs):
    method close (line 185) | def close(self):
  function make_output_format (line 191) | def make_output_format(format, ev_dir, log_suffix=""):
  function logkv (line 212) | def logkv(key, val):
  function logkv_mean (line 221) | def logkv_mean(key, val):
  function logkvs (line 228) | def logkvs(d):
  function dumpkvs (line 236) | def dumpkvs():
  function getkvs (line 243) | def getkvs():
  function log (line 247) | def log(*args, level=INFO):
  function debug (line 254) | def debug(*args):
  function info (line 258) | def info(*args):
  function warn (line 262) | def warn(*args):
  function error (line 266) | def error(*args):
  function set_level (line 270) | def set_level(level):
  function set_comm (line 277) | def set_comm(comm):
  function get_dir (line 281) | def get_dir():
  function profile_kv (line 294) | def profile_kv(scopename):
  function profile (line 303) | def profile(n):
  function get_current (line 325) | def get_current():
  class Logger (line 332) | class Logger(object):
    method __init__ (line 337) | def __init__(self, dir, output_formats, comm=None):
    method logkv (line 347) | def logkv(self, key, val):
    method logkv_mean (line 350) | def logkv_mean(self, key, val):
    method dumpkvs (line 355) | def dumpkvs(self):
    method log (line 376) | def log(self, *args, level=INFO):
    method set_level (line 382) | def set_level(self, level):
    method set_comm (line 385) | def set_comm(self, comm):
    method get_dir (line 388) | def get_dir(self):
    method close (line 391) | def close(self):
    method _do_log (line 397) | def _do_log(self, args):
  function get_rank_without_mpi_import (line 403) | def get_rank_without_mpi_import():
  function mpi_weighted_mean (line 412) | def mpi_weighted_mean(comm, local_name2valcount):
  function configure (line 442) | def configure(dir=None, format_strs=None, comm=None, log_suffix=""):
  function _configure_default_logger (line 474) | def _configure_default_logger():
  function reset (line 479) | def reset():
  function scoped_configure (line 487) | def scoped_configure(dir=None, format_strs=None, comm=None):

FILE: diffusion/losses.py
  function normal_kl (line 12) | def normal_kl(mean1, logvar1, mean2, logvar2):
  function approx_standard_normal_cdf (line 42) | def approx_standard_normal_cdf(x):
  function discretized_gaussian_log_likelihood (line 50) | def discretized_gaussian_log_likelihood(x, *, means, log_scales):

FILE: diffusion/nn.py
  class SiLU (line 13) | class SiLU(nn.Module):
    method forward (line 14) | def forward(self, x):
  class GroupNorm32 (line 18) | class GroupNorm32(nn.GroupNorm):
    method forward (line 19) | def forward(self, x):
  function conv_nd (line 23) | def conv_nd(dims, *args, **kwargs):
  function linear (line 36) | def linear(*args, **kwargs):
  function avg_pool_nd (line 43) | def avg_pool_nd(dims, *args, **kwargs):
  function update_ema (line 56) | def update_ema(target_params, source_params, rate=0.99):
  function zero_module (line 69) | def zero_module(module):
  function scale_module (line 78) | def scale_module(module, scale):
  function mean_flat (line 87) | def mean_flat(tensor):
  function sum_flat (line 93) | def sum_flat(tensor):
  function normalization (line 100) | def normalization(channels):
  function timestep_embedding (line 110) | def timestep_embedding(timesteps, dim, max_period=10000):
  function checkpoint (line 131) | def checkpoint(func, inputs, params, flag):
  class CheckpointFunction (line 148) | class CheckpointFunction(th.autograd.Function):
    method forward (line 151) | def forward(ctx, run_function, length, *args):
    method backward (line 161) | def backward(ctx, *output_grads):

FILE: diffusion/resample.py
  function create_named_schedule_sampler (line 8) | def create_named_schedule_sampler(name, diffusion):
  class ScheduleSampler (line 23) | class ScheduleSampler(ABC):
    method weights (line 35) | def weights(self):
    method sample (line 42) | def sample(self, batch_size, device):
  class UniformSampler (line 61) | class UniformSampler(ScheduleSampler):
    method __init__ (line 62) | def __init__(self, diffusion):
    method weights (line 66) | def weights(self):
  class LossAwareSampler (line 70) | class LossAwareSampler(ScheduleSampler):
    method update_with_local_losses (line 71) | def update_with_local_losses(self, local_ts, local_losses):
    method update_with_all_losses (line 107) | def update_with_all_losses(self, ts, losses):
  class LossSecondMomentResampler (line 124) | class LossSecondMomentResampler(LossAwareSampler):
    method __init__ (line 125) | def __init__(self, diffusion, history_per_term=10, uniform_prob=0.001):
    method weights (line 134) | def weights(self):
    method update_with_all_losses (line 143) | def update_with_all_losses(self, ts, losses):
    method _warmed_up (line 153) | def _warmed_up(self):

FILE: diffusion/respace.py
  function space_timesteps (line 7) | def space_timesteps(num_timesteps, section_counts):
  class SpacedDiffusion (line 63) | class SpacedDiffusion(GaussianDiffusion):
    method __init__ (line 72) | def __init__(self, use_timesteps, **kwargs):
    method p_mean_variance (line 88) | def p_mean_variance(
    method training_losses (line 93) | def training_losses(
    method condition_mean (line 98) | def condition_mean(self, cond_fn, *args, **kwargs):
    method condition_score (line 101) | def condition_score(self, cond_fn, *args, **kwargs):
    method _wrap_model (line 104) | def _wrap_model(self, model):
    method _scale_timesteps (line 111) | def _scale_timesteps(self, t):
  class _WrappedModel (line 116) | class _WrappedModel:
    method __init__ (line 117) | def __init__(self, model, timestep_map, rescale_timesteps, original_nu...
    method __call__ (line 123) | def __call__(self, x, ts, **kwargs):

FILE: meshudf/_marching_cubes_lewiner.py
  function marching_cubes_lewiner (line 9) | def marching_cubes_lewiner(
  function udf_mc_lewiner (line 87) | def udf_mc_lewiner(
  function _to_array (line 157) | def _to_array(args):
  function _get_mc_luts (line 224) | def _get_mc_luts():

FILE: meshudf/meshudf.py
  class GridFiller (line 23) | class GridFiller:
    method __init__ (line 36) | def __init__(
    method fill_grid (line 123) | def fill_grid(
  function sample_udf (line 209) | def sample_udf(
  function sample_grads (line 231) | def sample_grads(
  function get_udf_and_grads (line 254) | def get_udf_and_grads(
  function get_mesh_from_udf (line 307) | def get_mesh_from_udf(

FILE: models/cfg_sampler.py
  class ClassifierFreeSampleModel (line 8) | class ClassifierFreeSampleModel(nn.Module):
    method __init__ (line 10) | def __init__(self, model):
    method forward (line 19) | def forward(self, x, timesteps, y=None):

FILE: models/mdm.py
  class MDM (line 9) | class MDM(nn.Module):
    method __init__ (line 11) | def __init__(self, modeltype, num_actions, dropout=0.1, activation="ge...
    method parameters_wo_clip (line 72) | def parameters_wo_clip(self):
    method load_and_freeze_clip (line 75) | def load_and_freeze_clip(self, clip_version):
    method encode_text (line 86) | def encode_text(self, raw_text):
    method forward (line 91) | def forward(self, x, timesteps, y=None):
    method train (line 112) | def train(self, *args, **kwargs):

FILE: models/models.py
  class LinearAttention (line 7) | class LinearAttention(nn.Module):
    method __init__ (line 8) | def __init__(self, dim, heads=4, dim_head=32):
    method forward (line 15) | def forward(self, x):
  class LinAttnBlock (line 25) | class LinAttnBlock(LinearAttention):
    method __init__ (line 27) | def __init__(self, in_channels):
  class Downsample (line 30) | class Downsample(nn.Module):
    method __init__ (line 31) | def __init__(self, in_channels, with_conv):
    method forward (line 42) | def forward(self, x):
  class Upsample (line 52) | class Upsample(nn.Module):
    method __init__ (line 53) | def __init__(self, in_channels, with_conv):
    method forward (line 63) | def forward(self, x):
  class AttnBlock (line 70) | class AttnBlock(nn.Module):
    method __init__ (line 71) | def __init__(self, in_channels):
    method forward (line 98) | def forward(self, x):
  function make_attn (line 126) | def make_attn(in_channels, attn_type="vanilla"):
  function Normalize (line 136) | def Normalize(in_channels, num_groups=4):
  function nonlinearity (line 139) | def nonlinearity(x):
  class ResnetBlock (line 145) | class ResnetBlock(nn.Module):
    method __init__ (line 146) | def __init__(self, *, in_channels, out_channels=None, conv_shortcut=Fa...
    method forward (line 184) | def forward(self, x, temb):
  class DoubleConv (line 213) | class DoubleConv(nn.Module):
    method __init__ (line 216) | def __init__(self, in_channels, out_channels, conv_type=nn.Conv3d, mid...
    method forward (line 230) | def forward(self, x):
  class Down (line 234) | class Down(nn.Module):
    method __init__ (line 237) | def __init__(self, in_channels, out_channels, conv_type=nn.Conv3d):
    method forward (line 244) | def forward(self, x):
  class Up (line 248) | class Up(nn.Module):
    method __init__ (line 251) | def __init__(self, in_channels, out_channels, trilinear=True):
    method forward (line 263) | def forward(self, x1):
  class DepthwiseSeparableConv3d (line 280) | class DepthwiseSeparableConv3d(nn.Module):
    method __init__ (line 281) | def __init__(self, nin, nout, kernel_size, padding, kernels_per_layer=1):
    method forward (line 286) | def forward(self, x):
  class Autoencoder_Old (line 292) | class Autoencoder_Old(nn.Module):
    method __init__ (line 293) | def __init__(self, n_channels=1, width_multiplier=1, trilinear=True, u...
    method encode (line 315) | def encode(self, x):
    method decode (line 323) | def decode(self, z):
    method forward (line 330) | def forward(self, input):

FILE: models/openaimodel.py
  function convert_module_to_f16 (line 24) | def convert_module_to_f16(x):
  function convert_module_to_f32 (line 27) | def convert_module_to_f32(x):
  class AttentionPool2d (line 32) | class AttentionPool2d(nn.Module):
    method __init__ (line 37) | def __init__(
    method forward (line 51) | def forward(self, x):
  class TimestepBlock (line 62) | class TimestepBlock(nn.Module):
    method forward (line 68) | def forward(self, x, emb):
  class TimestepEmbedSequential (line 74) | class TimestepEmbedSequential(nn.Sequential, TimestepBlock):
    method forward (line 80) | def forward(self, x, emb, context=None):
  class Upsample (line 91) | class Upsample(nn.Module):
    method __init__ (line 100) | def __init__(self, channels, use_conv, dims=3, out_channels=None, padd...
    method forward (line 109) | def forward(self, x):
  class TransposedUpsample (line 121) | class TransposedUpsample(nn.Module):
    method __init__ (line 123) | def __init__(self, channels, out_channels=None, ks=5):
    method forward (line 130) | def forward(self,x):
  class Downsample (line 134) | class Downsample(nn.Module):
    method __init__ (line 143) | def __init__(self, channels, use_conv, dims=3, out_channels=None,paddi...
    method forward (line 158) | def forward(self, x):
  class ResBlock (line 163) | class ResBlock(TimestepBlock):
    method __init__ (line 179) | def __init__(
    method forward (line 243) | def forward(self, x, emb):
    method _forward (line 255) | def _forward(self, x, emb):
  class AttentionBlock (line 278) | class AttentionBlock(nn.Module):
    method __init__ (line 285) | def __init__(
    method forward (line 314) | def forward(self, x):
    method _forward (line 318) | def _forward(self, x):
  function count_flops_attn (line 327) | def count_flops_attn(model, _x, y):
  class QKVAttentionLegacy (line 347) | class QKVAttentionLegacy(nn.Module):
    method __init__ (line 352) | def __init__(self, n_heads):
    method forward (line 356) | def forward(self, qkv):
    method count_flops (line 375) | def count_flops(model, _x, y):
  class QKVAttention (line 379) | class QKVAttention(nn.Module):
    method __init__ (line 384) | def __init__(self, n_heads):
    method forward (line 388) | def forward(self, qkv):
    method count_flops (line 409) | def count_flops(model, _x, y):
  class UNetModel (line 413) | class UNetModel(nn.Module):
    method __init__ (line 443) | def __init__(
    method convert_to_fp16 (line 694) | def convert_to_fp16(self):
    method convert_to_fp32 (line 702) | def convert_to_fp32(self):
    method forward (line 710) | def forward(self, x, timesteps=None, context=None, y=None, **kwargs):
  class EncoderUNetModel (line 752) | class EncoderUNetModel(nn.Module):
    method __init__ (line 758) | def __init__(
    method convert_to_fp16 (line 931) | def convert_to_fp16(self):
    method convert_to_fp32 (line 938) | def convert_to_fp32(self):
    method forward (line 945) | def forward(self, x, timesteps):

FILE: modules/attention.py
  function exists (line 11) | def exists(val):
  function uniq (line 15) | def uniq(arr):
  function default (line 19) | def default(val, d):
  function max_neg_value (line 25) | def max_neg_value(t):
  function init_ (line 29) | def init_(tensor):
  class GEGLU (line 37) | class GEGLU(nn.Module):
    method __init__ (line 38) | def __init__(self, dim_in, dim_out):
    method forward (line 42) | def forward(self, x):
  class FeedForward (line 47) | class FeedForward(nn.Module):
    method __init__ (line 48) | def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0.):
    method forward (line 63) | def forward(self, x):
  function zero_module (line 67) | def zero_module(module):
  function Normalize (line 76) | def Normalize(in_channels):
  class LinearAttention (line 80) | class LinearAttention(nn.Module):
    method __init__ (line 81) | def __init__(self, dim, heads=4, dim_head=32):
    method forward (line 88) | def forward(self, x):
  class SpatialSelfAttention (line 99) | class SpatialSelfAttention(nn.Module):
    method __init__ (line 100) | def __init__(self, in_channels):
    method forward (line 126) | def forward(self, x):
  class CrossAttention (line 152) | class CrossAttention(nn.Module):
    method __init__ (line 153) | def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, ...
    method forward (line 170) | def forward(self, x, context=None, mask=None):
  class BasicTransformerBlock (line 196) | class BasicTransformerBlock(nn.Module):
    method __init__ (line 197) | def __init__(self, dim, n_heads, d_head, dropout=0., context_dim=None,...
    method forward (line 208) | def forward(self, x, context=None):
    method _forward (line 211) | def _forward(self, x, context=None):
  class SpatialTransformer (line 218) | class SpatialTransformer(nn.Module):
    method __init__ (line 226) | def __init__(self, in_channels, n_heads, d_head,
    method forward (line 250) | def forward(self, x, context=None):

FILE: sample/generate_cat.py
  function main (line 31) | def main():

FILE: sample/generate_image.py
  function load_and_freeze_clip (line 37) | def load_and_freeze_clip(clip_version):
  function main (line 50) | def main():

FILE: sample/generate_sketch.py
  function _transform (line 31) | def _transform(n_px):
  function load_and_freeze_clip (line 40) | def load_and_freeze_clip(clip_version):
  function main (line 50) | def main():

FILE: sample/generate_text.py
  function load_and_freeze_clip (line 32) | def load_and_freeze_clip(clip_version):
  function main (line 45) | def main():

FILE: sample/generate_uncond.py
  function main (line 21) | def main():

FILE: train_diffcloth.py
  class TrainPlatform (line 24) | class TrainPlatform:
    method __init__ (line 25) | def __init__(self, save_dir):
    method report_scalar (line 28) | def report_scalar(self, name, value, iteration, group_name=None):
    method report_args (line 31) | def report_args(self, args, name):
    method close (line 34) | def close(self):
  class TensorboardPlatform (line 38) | class TensorboardPlatform(TrainPlatform):
    method __init__ (line 39) | def __init__(self, save_dir):
    method report_scalar (line 43) | def report_scalar(self, name, value, iteration, group_name=None):
    method close (line 46) | def close(self):
  class NoPlatform (line 50) | class NoPlatform(TrainPlatform):
    method __init__ (line 51) | def __init__(self, save_dir):
  function make_data_sampler (line 55) | def make_data_sampler(dataset, shuffle, distributed):
  class IterationBasedBatchSampler (line 65) | class IterationBasedBatchSampler(torch.utils.data.sampler.BatchSampler):
    method __init__ (line 71) | def __init__(self, batch_sampler, num_iterations, start_iter=0):
    method __iter__ (line 76) | def __iter__(self):
    method __len__ (line 90) | def __len__(self):
  function make_batch_data_sampler (line 93) | def make_batch_data_sampler(sampler, images_per_gpu, num_iters=None, sta...
  function main (line 99) | def main():

FILE: training_loop_single.py
  class TrainLoop (line 32) | class TrainLoop:
    method __init__ (line 33) | def __init__(self, args, model, diffusion, data, logger=None):
    method _load_and_sync_parameters (line 127) | def _load_and_sync_parameters(self):
    method load_and_freeze_clip (line 143) | def load_and_freeze_clip(self, clip_version):
    method worker_init_fn (line 154) | def worker_init_fn(self, worker_id):
    method _load_optimizer_state (line 158) | def _load_optimizer_state(self):
    method randbool (line 171) | def randbool(self, *size):
    method run_loop (line 173) | def run_loop(self, inds=None):
    method evaluate (line 249) | def evaluate(self):
    method run_step (line 254) | def run_step(self, batch, cond, loss_L1, loss_args=None):
    method forward_backward (line 260) | def forward_backward(self, batch, cond, loss_L1, loss_args=None):
    method _anneal_lr (line 299) | def _anneal_lr(self, gama=0.9):
    method log_step (line 311) | def log_step(self):
    method ckpt_file_name (line 316) | def ckpt_file_name(self):
    method save_distributed (line 320) | def save_distributed(self):
    method save (line 341) | def save(self):
  function parse_resume_step_from_filename (line 359) | def parse_resume_step_from_filename(filename):
  function get_blob_logdir (line 374) | def get_blob_logdir():
  function find_resume_checkpoint (line 380) | def find_resume_checkpoint():
  function log_loss_dict (line 386) | def log_loss_dict(diffusion, ts, losses):

FILE: utils/comm.py
  function get_world_size (line 16) | def get_world_size():
  function get_rank (line 24) | def get_rank():
  function is_main_process (line 32) | def is_main_process():
  function synchronize (line 36) | def synchronize():
  function gather_on_master (line 51) | def gather_on_master(data):
  function all_gather (line 104) | def all_gather(data):
  function reduce_dict (line 147) | def reduce_dict(input_dict, average=True):

FILE: utils/dist_util.py
  function setup_dist (line 18) | def setup_dist(device=0):
  function dev (line 44) | def dev():
  function load_state_dict (line 54) | def load_state_dict(path, **kwargs):
  function sync_params (line 61) | def sync_params(params):
  function _find_free_port (line 70) | def _find_free_port():

FILE: utils/fixseed.py
  function fixseed (line 6) | def fixseed(seed):

FILE: utils/ldm_utils.py
  function instantiate_from_config (line 19) | def instantiate_from_config(config):
  function get_obj_from_str (line 28) | def get_obj_from_str(string, reload=False):
  function make_beta_schedule (line 35) | def make_beta_schedule(schedule, n_timestep, linear_start=1e-4, linear_e...
  function make_ddim_timesteps (line 60) | def make_ddim_timesteps(ddim_discr_method, num_ddim_timesteps, num_ddpm_...
  function make_ddim_sampling_parameters (line 77) | def make_ddim_sampling_parameters(alphacums, ddim_timesteps, eta, verbos...
  function betas_for_alpha_bar (line 91) | def betas_for_alpha_bar(num_diffusion_timesteps, alpha_bar, max_beta=0.9...
  function extract_into_tensor (line 110) | def extract_into_tensor(a, t, x_shape):
  function checkpoint (line 116) | def checkpoint(func, inputs, params, flag):
  class CheckpointFunction (line 133) | class CheckpointFunction(torch.autograd.Function):
    method forward (line 135) | def forward(ctx, run_function, length, *args):
    method backward (line 145) | def backward(ctx, *output_grads):
  function timestep_embedding (line 165) | def timestep_embedding(timesteps, dim, max_period=10000, repeat_only=Fal...
  function zero_module (line 188) | def zero_module(module):
  function scale_module (line 197) | def scale_module(module, scale):
  function mean_flat (line 206) | def mean_flat(tensor):
  function normalization (line 213) | def normalization(channels):
  class SiLU (line 223) | class SiLU(nn.Module):
    method forward (line 224) | def forward(self, x):
  class GroupNorm32 (line 228) | class GroupNorm32(nn.GroupNorm):
    method forward (line 229) | def forward(self, x):
  function conv_nd (line 232) | def conv_nd(dims, *args, **kwargs):
  function linear (line 245) | def linear(*args, **kwargs):
  function avg_pool_nd (line 252) | def avg_pool_nd(dims, *args, **kwargs):
  class HybridConditioner (line 265) | class HybridConditioner(nn.Module):
    method __init__ (line 267) | def __init__(self, c_concat_config, c_crossattn_config):
    method forward (line 272) | def forward(self, c_concat, c_crossattn):
  function noise_like (line 278) | def noise_like(shape, device, repeat=False):

FILE: utils/logger.py
  class FileHandler (line 12) | class FileHandler(StreamHandler):
    method __init__ (line 16) | def __init__(self, filename, mode='a', encoding=None, delay=False):
    method close (line 36) | def close(self):
    method _open (line 58) | def _open(self):
    method emit (line 65) | def emit(self, record):
    method __repr__ (line 77) | def __repr__(self):
  function setup_logger (line 82) | def setup_logger(name, save_dir, distributed_rank, filename="log.txt"):

FILE: utils/misc.py
  function to_numpy (line 4) | def to_numpy(tensor):
  function to_torch (line 13) | def to_torch(ndarray):
  function cleanexit (line 22) | def cleanexit():
  function load_model_wo_clip (line 30) | def load_model_wo_clip(model, state_dict):
  function freeze_joints (line 35) | def freeze_joints(x, joints_to_freeze):

FILE: utils/miscellaneous.py
  function mkdir (line 15) | def mkdir(path):
  function save_config (line 27) | def save_config(cfg, path):
  function config_iteration (line 33) | def config_iteration(output_dir, max_iter):
  function get_matching_parameters (line 50) | def get_matching_parameters(model, regexp, none_on_empty=True):
  function freeze_weights (line 65) | def freeze_weights(model, regexp):
  function unfreeze_weights (line 73) | def unfreeze_weights(model, regexp, backbone_freeze_at=-1,
  function delete_tsv_files (line 91) | def delete_tsv_files(tsvs):
  function concat_files (line 100) | def concat_files(ins, out):
  function concat_tsv_files (line 111) | def concat_tsv_files(tsvs, out_tsv):
  function load_list_file (line 126) | def load_list_file(fname):
  function try_once (line 135) | def try_once(func):
  function try_delete (line 145) | def try_delete(f):
  function set_seed (line 149) | def set_seed(seed, n_gpu):
  function print_and_run_cmd (line 157) | def print_and_run_cmd(cmd):
  function write_to_yaml_file (line 162) | def write_to_yaml_file(context, file_name):
  function load_from_yaml_file (line 167) | def load_from_yaml_file(yaml_file):

FILE: utils/model_util.py
  function load_model_wo_clip (line 6) | def load_model_wo_clip(model, state_dict):
  function create_model_and_diffusion (line 12) | def create_model_and_diffusion(args):
  function get_model_args (line 19) | def get_model_args(args):
  function create_gaussian_diffusion (line 32) | def create_gaussian_diffusion(args):

FILE: utils/parser_util.py
  function parse_and_load_from_model (line 7) | def parse_and_load_from_model(parser):
  function get_args_per_group_name (line 23) | def get_args_per_group_name(parser, args, group_name):
  function get_model_path_from_args (line 30) | def get_model_path_from_args():
  function add_base_options (line 40) | def add_base_options(parser):
  function add_diffusion_options (line 50) | def add_diffusion_options(parser):
  function add_model_options (line 59) | def add_model_options(parser):
  function add_data_options (line 74) | def add_data_options(parser):
  function add_training_options (line 83) | def add_training_options(parser):
  function add_sampling_options (line 113) | def add_sampling_options(parser):
  function add_generate_options (line 131) | def add_generate_options(parser):
  function train_args (line 153) | def train_args():
  function generate_args (line 164) | def generate_args():
  function evaluation_parser (line 173) | def evaluation_parser():

FILE: utils/utils.py
  function batchify (line 8) | def batchify(inputs: List[Tensor], required_dim: int) -> Tuple[bool, Lis...
  function unbatchify (line 30) | def unbatchify(inputs: List[Tensor]) -> List[Tensor]:
  function random_point_sampling (line 44) | def random_point_sampling(pcd: Tensor, num_points: int, inds=None) -> Te...
  function get_o3d_mesh_from_tensors (line 79) | def get_o3d_mesh_from_tensors(
  function compute_gradients (line 123) | def compute_gradients(x: Tensor, y: Tensor) -> Tensor:
  function sample_udf (line 128) | def sample_udf(
  class GridFiller (line 151) | class GridFiller:
    method __init__ (line 164) | def __init__(
    method fill_grid (line 252) | def fill_grid(