SYMBOL INDEX (366 symbols across 32 files)

FILE: dataset/carla_dataset.py
  class CarlaDataset (line 10) | class CarlaDataset(Dataset):
    method __init__ (line 11) | def __init__(self, args, imageset='train', get_query=True):
    method __len__ (line 46) | def __len__(self):
    method __getitem__ (line 49) | def __getitem__(self, index):

FILE: dataset/dataset_builder.py
  function dataset_builder (line 4) | def dataset_builder(args):

FILE: dataset/kitti_dataset.py
  class SemKITTI (line 10) | class SemKITTI(data.Dataset):
    method __init__ (line 11) | def __init__(self, args, imageset='train', get_query=True, folder = 'v...
    method unpack (line 62) | def unpack(self, compressed):
    method __len__ (line 75) | def __len__(self):
    method __getitem__ (line 79) | def __getitem__(self, index):
  function get_query (line 109) | def get_query(voxel_label, num_class=20, grid_size = (256,256,32), max_p...
  function compute_tdf (line 149) | def compute_tdf(voxel_label: np.ndarray, trunc_distance: float = 3, trun...
  function flip (line 160) | def flip(voxel, invalid, flip_dim=0):

FILE: dataset/tri_dataset_builder.py
  class TriplaneDataset (line 9) | class TriplaneDataset(torch.utils.data.Dataset):
    method __init__ (line 10) | def __init__(self, args, imageset):
    method __len__ (line 44) | def __len__(self):
    method __getitem__ (line 47) | def __getitem__(self, index):

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 210) | def _optimize_normal(self, opt: th.optim.Optimizer):
    method _compute_norms (line 217) | def _compute_norms(self, grad_scale=1.0):
    method master_params_to_state_dict (line 227) | def master_params_to_state_dict(self, master_params):
    method state_dict_to_master_params (line 232) | def state_dict_to_master_params(self, state_dict):
  function check_overflow (line 236) | def check_overflow(value):

FILE: diffusion/gaussian_diffusion.py
  function get_named_beta_schedule (line 16) | def get_named_beta_schedule(schedule_name, num_diffusion_timesteps):
  function betas_for_alpha_bar (line 43) | def betas_for_alpha_bar(num_diffusion_timesteps, alpha_bar, max_beta=0.9...
  class ModelMeanType (line 63) | class ModelMeanType(enum.Enum):
  class ModelVarType (line 73) | class ModelVarType(enum.Enum):
  class LossType (line 87) | class LossType(enum.Enum):
    method is_vb (line 95) | def is_vb(self):
  class GaussianDiffusion (line 99) | class GaussianDiffusion:
    method __init__ (line 116) | def __init__(
    method undo (line 174) | def undo(self, img_out, t, debug=False):
    method q_mean_variance (line 183) | def q_mean_variance(self, x_start, t):
    method q_sample (line 200) | def q_sample(self, x_start, t, noise=None):
    method q_posterior_mean_variance (line 220) | def q_posterior_mean_variance(self, x_start, x_t, t):
    method p_mean_variance (line 244) | def p_mean_variance(
    method _predict_xstart_from_eps (line 340) | def _predict_xstart_from_eps(self, x_t, t, eps):
    method _predict_xstart_from_xprev (line 347) | def _predict_xstart_from_xprev(self, x_t, t, xprev):
    method _predict_eps_from_xstart (line 357) | def _predict_eps_from_xstart(self, x_t, t, pred_xstart):
    method _scale_timesteps (line 363) | def _scale_timesteps(self, t):
    method condition_mean (line 368) | def condition_mean(self, cond_fn, p_mean_var, x, t, model_kwargs=None):
    method condition_score (line 383) | def condition_score(self, cond_fn, p_mean_var, x, t, model_kwargs=None):
    method p_sample (line 407) | def p_sample(
    method p_sample_loop (line 455) | def p_sample_loop(
    method p_sample_loop_progressive (line 513) | def p_sample_loop_progressive(
    method p_sample_loop_scene_repaint (line 563) | def p_sample_loop_scene_repaint(
    method p_sample_loop_scene (line 606) | def p_sample_loop_scene(
    method ddim_sample (line 644) | def ddim_sample(
    method ddim_reverse_sample (line 708) | def ddim_reverse_sample(
    method ddim_sample_loop (line 746) | def ddim_sample_loop(
    method ddim_sample_loop_progressive (line 786) | def ddim_sample_loop_progressive(
    method _vb_terms_bpd (line 842) | def _vb_terms_bpd(
    method merge_features (line 877) | def merge_features(self, xy_feat, xz_feat, yz_feat):
    method training_losses (line 895) | def training_losses(self, model, x_start, t, model_kwargs=None, noise=...
    method _prior_bpd (line 989) | def _prior_bpd(self, x_start):
    method calc_bpd_loop (line 1007) | def calc_bpd_loop(self, model, x_start, clip_denoised=True, model_kwar...
  function _extract_into_tensor (line 1065) | def _extract_into_tensor(arr, timesteps, broadcast_shape):

FILE: diffusion/logger.py
  class KVWriter (line 25) | class KVWriter(object):
    method writekvs (line 26) | def writekvs(self, kvs):
  class SeqWriter (line 30) | class SeqWriter(object):
    method writeseq (line 31) | def writeseq(self, seq):
  class HumanOutputFormat (line 35) | class HumanOutputFormat(KVWriter, SeqWriter):
    method __init__ (line 36) | def __init__(self, filename_or_file):
    method writekvs (line 47) | def writekvs(self, kvs):
    method _truncate (line 79) | def _truncate(self, s):
    method writeseq (line 83) | def writeseq(self, seq):
    method close (line 92) | def close(self):
  class JSONOutputFormat (line 97) | class JSONOutputFormat(KVWriter):
    method __init__ (line 98) | def __init__(self, filename):
    method writekvs (line 101) | def writekvs(self, kvs):
    method close (line 108) | def close(self):
  class CSVOutputFormat (line 112) | class CSVOutputFormat(KVWriter):
    method __init__ (line 113) | def __init__(self, filename):
    method writekvs (line 118) | def writekvs(self, kvs):
    method close (line 145) | def close(self):
  class TensorBoardOutputFormat (line 149) | class TensorBoardOutputFormat(KVWriter):
    method __init__ (line 154) | def __init__(self, dir):
    method writekvs (line 170) | def writekvs(self, kvs):
    method close (line 184) | def close(self):
  function make_output_format (line 190) | def make_output_format(format, ev_dir, log_suffix=""):
  function logkv (line 211) | def logkv(key, val):
  function logkv_mean (line 220) | def logkv_mean(key, val):
  function logkvs (line 227) | def logkvs(d):
  function dumpkvs (line 235) | def dumpkvs():
  function getkvs (line 242) | def getkvs():
  function log (line 246) | def log(*args, level=INFO):
  function debug (line 253) | def debug(*args):
  function info (line 257) | def info(*args):
  function warn (line 261) | def warn(*args):
  function error (line 265) | def error(*args):
  function set_level (line 269) | def set_level(level):
  function set_comm (line 276) | def set_comm(comm):
  function get_dir (line 280) | def get_dir():
  function profile_kv (line 293) | def profile_kv(scopename):
  function profile (line 302) | def profile(n):
  function get_current (line 324) | def get_current():
  class Logger (line 331) | class Logger(object):
    method __init__ (line 336) | def __init__(self, dir, output_formats, comm=None):
    method logkv (line 346) | def logkv(self, key, val):
    method logkv_mean (line 349) | def logkv_mean(self, key, val):
    method dumpkvs (line 354) | def dumpkvs(self):
    method log (line 375) | def log(self, *args, level=INFO):
    method set_level (line 381) | def set_level(self, level):
    method set_comm (line 384) | def set_comm(self, comm):
    method get_dir (line 387) | def get_dir(self):
    method close (line 390) | def close(self):
    method _do_log (line 396) | def _do_log(self, args):
  function get_rank_without_mpi_import (line 402) | def get_rank_without_mpi_import():
  function mpi_weighted_mean (line 411) | def mpi_weighted_mean(comm, local_name2valcount):
  function configure (line 441) | def configure(dir=None, format_strs=None, comm=None, log_suffix=""):
  function _configure_default_logger (line 473) | def _configure_default_logger():
  function reset (line 478) | def reset():
  function scoped_configure (line 486) | 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
  function mask_img (line 10) | def mask_img(img, cond, mode, overlap, H=[128]):
  function compose_featmaps (line 43) | def compose_featmaps(feat_xy, feat_xz, feat_yz, tri_size=(128,128,16) , ...
  function decompose_featmaps (line 57) | def decompose_featmaps(composed_map, tri_size=(128,128,16) , transpose=T...
  class SiLU (line 68) | class SiLU(nn.Module):
    method forward (line 69) | def forward(self, x):
  class GroupNorm32 (line 73) | class GroupNorm32(nn.GroupNorm):
    method forward (line 74) | def forward(self, x):
  function conv_nd (line 78) | def conv_nd(dims, *args, **kwargs):
  function linear (line 91) | def linear(*args, **kwargs):
  function avg_pool_nd (line 98) | def avg_pool_nd(dims, *args, **kwargs):
  function update_ema (line 111) | def update_ema(target_params, source_params, rate=0.99):
  function zero_module (line 124) | def zero_module(module):
  function scale_module (line 133) | def scale_module(module, scale):
  function mean_flat (line 142) | def mean_flat(tensor):
  function normalization (line 150) | def normalization(channels):
  function timestep_embedding (line 160) | def timestep_embedding(timesteps, dim, max_period=10000):
  function checkpoint (line 181) | def checkpoint(func, inputs, params, flag):
  class CheckpointFunction (line 199) | class CheckpointFunction(th.autograd.Function):
    method forward (line 201) | def forward(ctx, run_function, length, *args):
    method backward (line 210) | 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, H, W, D, y):

FILE: diffusion/scheduler.py
  function get_schedule_jump (line 2) | def get_schedule_jump(t_T, jump_length, jump_n_sample):
  function _check_times (line 25) | def _check_times(times, t_0, t_T):

FILE: diffusion/script_util.py
  function create_model_and_diffusion_from_args (line 5) | def create_model_and_diffusion_from_args(args):
  function create_gaussian_diffusion (line 14) | def create_gaussian_diffusion(args):

FILE: diffusion/train_util.py
  class TrainLoop (line 22) | class TrainLoop:
    method __init__ (line 23) | def __init__(
    method _load_and_sync_parameters (line 110) | def _load_and_sync_parameters(self):
    method _load_ema_parameters (line 125) | def _load_ema_parameters(self, rate):
    method _load_optimizer_state (line 141) | def _load_optimizer_state(self):
    method run_loop (line 153) | def run_loop(self):
    method run_step (line 174) | def run_step(self, batch, cond):
    method _sample_and_visualize (line 186) | def _sample_and_visualize(self):
    method forward_backward (line 219) | def forward_backward(self, batch, cond):
    method _update_ema (line 263) | def _update_ema(self):
    method _anneal_lr (line 267) | def _anneal_lr(self):
    method log_step (line 275) | def log_step(self):
    method save (line 284) | def save(self):
    method log_loss_dict (line 309) | def log_loss_dict(self, diffusion, ts, losses):
  function parse_resume_step_from_filename (line 322) | def parse_resume_step_from_filename(filename):
  function get_blob_logdir (line 331) | def get_blob_logdir():
  function find_resume_checkpoint (line 337) | def find_resume_checkpoint():
  function find_ema_checkpoint (line 343) | def find_ema_checkpoint(main_checkpoint, step, rate):

FILE: diffusion/triplane_util.py
  function augment (line 11) | def augment(triplane, p, tri_size=(128,128,32)):
  function build_sampling_model (line 45) | def build_sampling_model(args):

FILE: diffusion/unet_triplane.py
  class TriplaneConv (line 17) | class TriplaneConv(nn.Module):
    method __init__ (line 18) | def __init__(self, channels, out_channels, kernel_size, padding, is_ro...
    method forward (line 27) | def forward(self, featmaps):
  class TriplaneNorm (line 69) | class TriplaneNorm(nn.Module):
    method __init__ (line 70) | def __init__(self, channels) -> None:
    method forward (line 76) | def forward(self, featmaps):
  class TriplaneSiLU (line 93) | class TriplaneSiLU(nn.Module):
    method __init__ (line 94) | def __init__(self) -> None:
    method forward (line 98) | def forward(self, featmaps):
  class TriplaneUpsample2x (line 103) | class TriplaneUpsample2x(nn.Module):
    method __init__ (line 104) | def __init__(self, tri_z_down, conv_up, channels=None) -> None:
    method forward (line 118) | def forward(self, featmaps):
  class TriplaneDownsample2x (line 139) | class TriplaneDownsample2x(nn.Module):
    method __init__ (line 140) | def __init__(self, tri_z_down, conv_down, channels=None) -> None:
    method forward (line 155) | def forward(self, featmaps):
  class BeVplaneNorm (line 175) | class BeVplaneNorm(nn.Module):
    method __init__ (line 176) | def __init__(self, channels) -> None:
    method forward (line 180) | def forward(self, tpl_xy):
  class BeVplaneSiLU (line 184) | class BeVplaneSiLU(nn.Module):
    method __init__ (line 185) | def __init__(self) -> None:
    method forward (line 189) | def forward(self, tpl_xy):
  class BeVplaneUpsample2x (line 193) | class BeVplaneUpsample2x(nn.Module):
    method __init__ (line 194) | def __init__(self, tri_z_down, conv_up, channels=None, voxelfea=False)...
    method forward (line 205) | def forward(self, tpl_xy):
  class BeVplaneDownsample2x (line 217) | class BeVplaneDownsample2x(nn.Module):
    method __init__ (line 218) | def __init__(self, tri_z_down, conv_down, channels=None, voxelfea=Fals...
    method forward (line 229) | def forward(self, tpl_xy):
  class BeVplaneConv (line 240) | class BeVplaneConv(nn.Module):
    method __init__ (line 241) | def __init__(self, channels, out_channels, kernel_size, padding, voxel...
    method forward (line 249) | def forward(self, tpl_xy):
  class TimestepBlock (line 255) | class TimestepBlock(nn.Module):
    method forward (line 261) | def forward(self, x, emb):
  class TimestepEmbedSequential (line 267) | class TimestepEmbedSequential(nn.Sequential, TimestepBlock):
    method forward (line 273) | def forward(self, x, emb):
  class TriplaneResBlock (line 281) | class TriplaneResBlock(TimestepBlock):
    method __init__ (line 298) | def __init__(
    method forward (line 362) | def forward(self, x, emb):
    method _forward (line 374) | def _forward(self, x, emb):
  class BeVplaneResBlock (line 413) | class BeVplaneResBlock(TimestepBlock):
    method __init__ (line 415) | def __init__(
    method forward (line 471) | def forward(self, x, emb):
    method _forward (line 483) | def _forward(self, x, emb):
  class BEVUNetModel (line 508) | class BEVUNetModel(nn.Module):
    method __init__ (line 509) | def __init__(
    method convert_to_fp16 (line 647) | def convert_to_fp16(self):
    method convert_to_fp32 (line 654) | def convert_to_fp32(self):
    method forward (line 661) | def forward(self, x, timesteps, H=128, W=128, D=16, y=None):
  class TriplaneUNetModel (line 709) | class TriplaneUNetModel(nn.Module):
    method __init__ (line 710) | def __init__(
    method convert_to_fp16 (line 858) | def convert_to_fp16(self):
    method convert_to_fp32 (line 865) | def convert_to_fp32(self):
    method forward (line 872) | def forward(self, x, timesteps, H=128, W=128, D=16, y=None):

FILE: encoding/blocks.py
  class SinusoidalEncoder (line 7) | class SinusoidalEncoder(nn.Module):
    method __init__ (line 10) | def __init__(self, x_dim, min_deg, max_deg, use_identity: bool = True):
    method latent_dim (line 21) | def latent_dim(self) -> int:
    method forward (line 26) | def forward(self, x: torch.Tensor) -> torch.Tensor:
  class DecoderMLPSkipConcat (line 44) | class DecoderMLPSkipConcat(nn.Module):
    method __init__ (line 45) | def __init__(self, in_channels, out_channels, hidden_channels, num_hid...
    method forward (line 64) | def forward(self, x):
  class SiLU (line 73) | class SiLU(nn.Module):
    method forward (line 74) | def forward(self, x):
  function zero_module (line 78) | def zero_module(module):
  function compose_triplane_channelwise (line 87) | def compose_triplane_channelwise(feat_maps):
  function decompose_triplane_channelwise (line 103) | def decompose_triplane_channelwise(composed_map, sizes):
  class TriplaneGroupResnetBlock (line 112) | class TriplaneGroupResnetBlock(nn.Module):
    method __init__ (line 113) | def __init__(self, in_channels, out_channels, up=False, ks=3, input_no...
    method forward (line 160) | def forward(self, feat_maps):
  class BeVplaneGroupResnetBlock (line 181) | class BeVplaneGroupResnetBlock(nn.Module):
    method __init__ (line 182) | def __init__(self, in_channels, out_channels, up=False, ks=3, input_no...
    method forward (line 229) | def forward(self, feat_maps):

FILE: encoding/lovasz.py
  function dice_coef (line 14) | def dice_coef(y_true, y_pred, smooth=1e-6):
  function dice_coef_multilabel (line 20) | def dice_coef_multilabel(y_true, y_pred, numLabels=11):
  function lovasz_grad (line 31) | def lovasz_grad(gt_sorted):
  function lovasz_softmax (line 48) | def lovasz_softmax(probas, labels, classes='present', per_image=False, i...
  function lovasz_softmax_flat (line 66) | def lovasz_softmax_flat(probas, labels, classes='present'):
  function flatten_probas (line 97) | def flatten_probas(probas, labels, ignore=None):
  function isnan (line 121) | def isnan(x):
  function mean (line 125) | def mean(l, ignore_nan=False, empty=0):

FILE: encoding/networks.py
  class Encoder (line 6) | class Encoder(nn.Module):
    method __init__ (line 7) | def __init__(self, geo_feat_channels, z_down, padding_mode, kernel_siz...
    method forward (line 36) | def forward(self, x):  # [b, geo_feat_channels, X, Y, Z]
  class AutoEncoderGroupSkip (line 50) | class AutoEncoderGroupSkip(nn.Module):
    method __init__ (line 51) | def __init__(self, args) -> None:
    method geo_parameters (line 92) | def geo_parameters(self):
    method tex_parameters (line 95) | def tex_parameters(self):
    method encode (line 98) | def encode(self, vol):
    method sample_feature_plane2D (line 119) | def sample_feature_plane2D(self, feat_map, x):
    method sample_feature_plane3D (line 129) | def sample_feature_plane3D(self, vol_feat, x):
    method decode (line 139) | def decode(self, feat_maps, query):
    method forward (line 172) | def forward(self, vol, query):

FILE: encoding/ssc_metrics.py
  function compose_featmaps (line 5) | def compose_featmaps(feat_xy, feat_xz, feat_yz):
  function decompose_featmaps (line 16) | def decompose_featmaps(composed_map):
  function visualization (line 23) | def visualization(args, coords, preds, folder, idx, learning_map_inv, tr...
  class SSCMetrics (line 73) | class SSCMetrics:
    method __init__ (line 74) | def __init__(self, n_classes, ignore=None):
    method num_classes (line 87) | def num_classes(self):
    method get_eval_mask (line 90) | def get_eval_mask(self, labels, invalid_voxels):  # from samantickitti...
    method reset (line 102) | def reset(self):
    method one_stats (line 107) | def one_stats(self, x, y):
    method addBatch (line 127) | def addBatch(self, x, y):  # x=preds, y=targets
    method getStats (line 144) | def getStats(self):
    method getIoU (line 155) | def getIoU(self):
    method getacc (line 163) | def getacc(self):
    method get_confusion (line 170) | def get_confusion(self):

FILE: encoding/train_ae.py
  class Trainer (line 13) | class Trainer:
    method __init__ (line 14) | def __init__(self, args):
    method train (line 46) | def train(self):
    method _loss (line 61) | def _loss(self, vox, query, label, losses, coord):
    method _train_model (line 79) | def _train_model(self):
    method _eval_and_save_model (line 154) | def _eval_and_save_model(self):
  function get_pred_mask (line 212) | def get_pred_mask(model_output, separate_decoder=False):

FILE: sampling/generation.py
  function sample (line 11) | def sample(args):
  function sample_parser (line 31) | def sample_parser():

FILE: sampling/inpainting.py
  function inpainting (line 9) | def inpainting(scene, cond_1, cond_2, cond_3, cond_4, Generate_Scene):
  function edit (line 16) | def edit(args):
  function sample_parser (line 37) | def sample_parser():

FILE: sampling/outpainting.py
  function city_generate (line 10) | def city_generate(m, scene, Generate_Scene, overlap, out_shape, H=128):
  class edit_scene (line 69) | class edit_scene(torch.nn.Module):
    method __init__ (line 70) | def __init__(self, args, ae, model, sample_fn, coords, query, out_shap...
    method encode (line 82) | def encode(self, condition):
    method decode (line 87) | def decode(self, samples):
    method forward (line 94) | def forward(self, condition, m, encode=True, decode=True):
  function outpaint (line 108) | def outpaint(args):
  function sample_parser (line 126) | def sample_parser():

FILE: sampling/ssc_refine.py
  function sample (line 18) | def sample(args, tb):
  function sample_parser (line 66) | def sample_parser():

FILE: scripts/save_triplane.py
  function get_args (line 13) | def get_args():
  function save (line 38) | def save(args):
  function main (line 79) | def main():

FILE: scripts/train_ae_main.py
  function get_args (line 5) | def get_args():
  function main (line 33) | def main():

FILE: scripts/train_diffusion_main.py
  function train_diffusion (line 13) | def train_diffusion(args) :

FILE: utils/common_util.py
  function seed_all (line 7) | def seed_all(seed):
  function draw_scalar_field2D (line 16) | def draw_scalar_field2D(arr, vmin=None, vmax=None, cmap=None, title=None):
  function get_result (line 26) | def get_result(evaluator, class_name):

FILE: utils/dist_util.py
  function setup_dist (line 19) | def setup_dist(device=0):
  function dev (line 25) | def dev():
  function load_state_dict (line 35) | def load_state_dict(path, **kwargs):
  function sync_params (line 42) | def sync_params(params):

FILE: utils/parser_util.py
  function add_encoding_training_options (line 9) | def add_encoding_training_options(parser):
  function add_diffusion_training_options (line 20) | def add_diffusion_training_options(parser):
  function add_generation_options (line 42) | def add_generation_options(parser):
  function add_refine_options (line 54) | def add_refine_options(parser):
  function add_in_out_sampling (line 66) | def add_in_out_sampling(parser):
  function get_gen_args (line 80) | def get_gen_args(args):
  function diffusion_defaults (line 112) | def diffusion_defaults():
  function diffusion_model_defaults (line 123) | def diffusion_model_defaults():
  function get_args_by_group (line 135) | def get_args_by_group(parser, args, group_name):
  function load_and_overwrite_args (line 143) | def load_and_overwrite_args(args, path, ignore_keys=[]):
  function add_dict_to_argparser (line 152) | def add_dict_to_argparser(parser, default_dict):
  function args_to_dict (line 162) | def args_to_dict(args, keys):
  function str2bool (line 166) | def str2bool(v):

FILE: utils/utils.py
  function read_semantickitti_yaml (line 9) | def read_semantickitti_yaml():
  function unpack (line 22) | def unpack(compressed):
  function load_label (line 35) | def load_label(path, learning_map, grid_size):
  function write_result (line 42) | def write_result(args):
  function point2voxel (line 51) | def point2voxel(args, preds, coords):
  function visualization (line 60) | def visualization(args, coords, preds, folder, idx, learning_map_inv, tr...
  function save_remap_lut (line 64) | def save_remap_lut(args, pred, folder, idx, learning_map_inv, training, ...
  function cycle (line 95) | def cycle(dl):
  function voxel_coord (line 101) | def voxel_coord(voxel_shape):
  function make_query (line 110) | def make_query(grid_size):