SYMBOL INDEX (318 symbols across 21 files)

FILE: datasets/lsun_bedroom.py
  function read_images (line 14) | def read_images(lmdb_path, image_size):
  function dump_images (line 34) | def dump_images(out_dir, images, prefix):
  function main (line 41) | def main():

FILE: evaluations/evaluator.py
  function main (line 27) | def main():
  class InvalidFIDException (line 63) | class InvalidFIDException(Exception):
  class FIDStatistics (line 67) | class FIDStatistics:
    method __init__ (line 68) | def __init__(self, mu: np.ndarray, sigma: np.ndarray):
    method frechet_distance (line 72) | def frechet_distance(self, other, eps=1e-6):
  class Evaluator (line 118) | class Evaluator:
    method __init__ (line 119) | def __init__(
    method warmup (line 135) | def warmup(self):
    method read_activations (line 138) | def read_activations(self, npz_path: str) -> Tuple[np.ndarray, np.ndar...
    method compute_activations (line 142) | def compute_activations(self, batches: Iterable[np.ndarray]) -> Tuple[...
    method read_statistics (line 164) | def read_statistics(
    method compute_statistics (line 174) | def compute_statistics(self, activations: np.ndarray) -> FIDStatistics:
    method compute_inception_score (line 179) | def compute_inception_score(self, activations: np.ndarray, split_size:...
    method compute_prec_recall (line 194) | def compute_prec_recall(
  class ManifoldEstimator (line 205) | class ManifoldEstimator:
    method __init__ (line 212) | def __init__(
    method warmup (line 241) | def warmup(self):
    method manifold_radii (line 248) | def manifold_radii(self, features: np.ndarray) -> np.ndarray:
    method evaluate (line 283) | def evaluate(self, features: np.ndarray, radii: np.ndarray, eval_featu...
    method evaluate_pr (line 325) | def evaluate_pr(
  class DistanceBlock (line 362) | class DistanceBlock:
    method __init__ (line 369) | def __init__(self, session):
    method pairwise_distances (line 393) | def pairwise_distances(self, U, V):
    method less_thans (line 402) | def less_thans(self, batch_1, radii_1, batch_2, radii_2):
  function _batch_pairwise_distances (line 414) | def _batch_pairwise_distances(U, V):
  class NpzArrayReader (line 433) | class NpzArrayReader(ABC):
    method read_batch (line 435) | def read_batch(self, batch_size: int) -> Optional[np.ndarray]:
    method remaining (line 439) | def remaining(self) -> int:
    method read_batches (line 442) | def read_batches(self, batch_size: int) -> Iterable[np.ndarray]:
  class BatchIterator (line 455) | class BatchIterator:
    method __init__ (line 456) | def __init__(self, gen_fn, length):
    method __len__ (line 460) | def __len__(self):
    method __iter__ (line 463) | def __iter__(self):
  class StreamingNpzArrayReader (line 467) | class StreamingNpzArrayReader(NpzArrayReader):
    method __init__ (line 468) | def __init__(self, arr_f, shape, dtype):
    method read_batch (line 474) | def read_batch(self, batch_size: int) -> Optional[np.ndarray]:
    method remaining (line 489) | def remaining(self) -> int:
  class MemoryNpzArrayReader (line 493) | class MemoryNpzArrayReader(NpzArrayReader):
    method __init__ (line 494) | def __init__(self, arr):
    method load (line 499) | def load(cls, path: str, arr_name: str):
    method read_batch (line 504) | def read_batch(self, batch_size: int) -> Optional[np.ndarray]:
    method remaining (line 512) | def remaining(self) -> int:
  function open_npz_array (line 517) | def open_npz_array(path: str, arr_name: str) -> NpzArrayReader:
  function _read_bytes (line 534) | def _read_bytes(fp, size, error_template="ran out of data"):
  function _open_npy_file (line 564) | def _open_npy_file(path: str, arr_name: str):
  function _download_inception_model (line 573) | def _download_inception_model():
  function _create_feature_graph (line 586) | def _create_feature_graph(input_batch):
  function _create_softmax_graph (line 603) | def _create_softmax_graph(input_batch):
  function _update_shapes (line 617) | def _update_shapes(pool3):
  function _numpy_partition (line 636) | def _numpy_partition(arr, kth, **kwargs):

FILE: guided_diffusion/dist_util.py
  function setup_dist (line 21) | def setup_dist():
  function dev (line 45) | def dev():
  function load_state_dict (line 54) | def load_state_dict(path, **kwargs):
  function sync_params (line 77) | def sync_params(params):
  function _find_free_port (line 86) | def _find_free_port():

FILE: guided_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: guided_diffusion/gaussian_diffusion.py
  function get_named_beta_schedule (line 18) | def get_named_beta_schedule(schedule_name, num_diffusion_timesteps):
  function betas_for_alpha_bar (line 45) | def betas_for_alpha_bar(num_diffusion_timesteps, alpha_bar, max_beta=0.9...
  class ModelMeanType (line 65) | class ModelMeanType(enum.Enum):
  class ModelVarType (line 75) | class ModelVarType(enum.Enum):
  class LossType (line 89) | class LossType(enum.Enum):
    method is_vb (line 97) | def is_vb(self):
  class GaussianDiffusion (line 101) | class GaussianDiffusion:
    method __init__ (line 118) | def __init__(
    method q_mean_variance (line 171) | def q_mean_variance(self, x_start, t):
    method q_sample (line 188) | def q_sample(self, x_start, t, noise=None):
    method q_posterior_mean_variance (line 208) | def q_posterior_mean_variance(self, x_start, x_t, t):
    method p_mean_variance (line 232) | def p_mean_variance(
    method _predict_xstart_from_eps (line 328) | def _predict_xstart_from_eps(self, x_t, t, eps):
    method _predict_xstart_from_xprev (line 335) | def _predict_xstart_from_xprev(self, x_t, t, xprev):
    method _predict_eps_from_xstart (line 345) | def _predict_eps_from_xstart(self, x_t, t, pred_xstart):
    method _scale_timesteps (line 351) | def _scale_timesteps(self, t):
    method condition_mean (line 356) | def condition_mean(self, cond_fn, p_mean_var, x, t, model_kwargs=None):
    method condition_score (line 371) | def condition_score(self, cond_fn, p_mean_var, x, t, model_kwargs=None):
    method p_sample (line 395) | def p_sample(
    method p_sample_loop (line 441) | def p_sample_loop(
    method p_sample_loop_progressive (line 487) | def p_sample_loop_progressive(
    method ddim_sample (line 537) | def ddim_sample(
    method ddim_reverse_sample (line 587) | def ddim_reverse_sample(
    method ddim_sample_loop (line 625) | def ddim_sample_loop(
    method ddim_sample_loop_progressive (line 659) | def ddim_sample_loop_progressive(
    method _vb_terms_bpd (line 709) | def _vb_terms_bpd(
    method training_losses (line 744) | def training_losses(self, model, x_start, t, model_kwargs=None, noise=...
    method _prior_bpd (line 819) | def _prior_bpd(self, x_start):
    method calc_bpd_loop (line 837) | def calc_bpd_loop(self, model, x_start, clip_denoised=True, model_kwar...
  function _extract_into_tensor (line 895) | def _extract_into_tensor(arr, timesteps, broadcast_shape):

FILE: guided_diffusion/image_datasets.py
  function load_data (line 11) | def load_data(
  function _list_image_files_recursively (line 70) | def _list_image_files_recursively(data_dir):
  class ImageDataset (line 82) | class ImageDataset(Dataset):
    method __init__ (line 83) | def __init__(
    method __len__ (line 100) | def __len__(self):
    method __getitem__ (line 103) | def __getitem__(self, idx):
  function center_crop_arr (line 126) | def center_crop_arr(pil_image, image_size):
  function random_crop_arr (line 146) | def random_crop_arr(pil_image, image_size, min_crop_frac=0.8, max_crop_f...

FILE: guided_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: guided_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: guided_diffusion/nn.py
  class SiLU (line 12) | class SiLU(nn.Module):
    method forward (line 13) | def forward(self, x):
  class GroupNorm32 (line 17) | class GroupNorm32(nn.GroupNorm):
    method forward (line 18) | def forward(self, x):
  function conv_nd (line 22) | def conv_nd(dims, *args, **kwargs):
  function linear (line 35) | def linear(*args, **kwargs):
  function avg_pool_nd (line 42) | def avg_pool_nd(dims, *args, **kwargs):
  function update_ema (line 55) | def update_ema(target_params, source_params, rate=0.99):
  function zero_module (line 68) | def zero_module(module):
  function scale_module (line 77) | def scale_module(module, scale):
  function mean_flat (line 86) | def mean_flat(tensor):
  function normalization (line 93) | def normalization(channels):
  function timestep_embedding (line 103) | def timestep_embedding(timesteps, dim, max_period=10000):
  function checkpoint (line 124) | def checkpoint(func, inputs, params, flag):
  class CheckpointFunction (line 142) | class CheckpointFunction(th.autograd.Function):
    method forward (line 144) | def forward(ctx, run_function, length, *args):
    method backward (line 153) | def backward(ctx, *output_grads):

FILE: guided_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: guided_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: guided_diffusion/script_util.py
  function diffusion_defaults (line 11) | def diffusion_defaults():
  function classifier_defaults (line 27) | def classifier_defaults():
  function model_and_diffusion_defaults (line 43) | def model_and_diffusion_defaults():
  function classifier_and_diffusion_defaults (line 68) | def classifier_and_diffusion_defaults():
  function create_model_and_diffusion (line 74) | def create_model_and_diffusion(
  function create_model (line 130) | def create_model(
  function create_classifier_and_diffusion (line 187) | def create_classifier_and_diffusion(
  function create_classifier (line 228) | def create_classifier(
  function sr_model_and_diffusion_defaults (line 269) | def sr_model_and_diffusion_defaults():
  function sr_create_model_and_diffusion (line 280) | def sr_create_model_and_diffusion(
  function sr_create_model (line 334) | def sr_create_model(
  function create_gaussian_diffusion (line 386) | def create_gaussian_diffusion(
  function add_dict_to_argparser (line 427) | def add_dict_to_argparser(parser, default_dict):
  function args_to_dict (line 437) | def args_to_dict(args, keys):
  function str2bool (line 441) | def str2bool(v):

FILE: guided_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 172) | def run_step(self, batch, cond):
    method forward_backward (line 180) | def forward_backward(self, batch, cond):
    method _update_ema (line 216) | def _update_ema(self):
    method _anneal_lr (line 220) | def _anneal_lr(self):
    method log_step (line 228) | def log_step(self):
    method save (line 232) | def save(self):
  function parse_resume_step_from_filename (line 258) | def parse_resume_step_from_filename(filename):
  function get_blob_logdir (line 273) | def get_blob_logdir():
  function find_resume_checkpoint (line 279) | def find_resume_checkpoint():
  function find_ema_checkpoint (line 285) | def find_ema_checkpoint(main_checkpoint, step, rate):
  function log_loss_dict (line 295) | def log_loss_dict(diffusion, ts, losses):

FILE: guided_diffusion/unet.py
  class AttentionPool2d (line 22) | class AttentionPool2d(nn.Module):
    method __init__ (line 27) | def __init__(
    method forward (line 43) | def forward(self, x):
  class TimestepBlock (line 54) | class TimestepBlock(nn.Module):
    method forward (line 60) | def forward(self, x, emb):
  class TimestepEmbedSequential (line 66) | class TimestepEmbedSequential(nn.Sequential, TimestepBlock):
    method forward (line 72) | def forward(self, x, emb):
  class Upsample (line 81) | class Upsample(nn.Module):
    method __init__ (line 91) | def __init__(self, channels, use_conv, dims=2, out_channels=None):
    method forward (line 100) | def forward(self, x):
  class Downsample (line 113) | class Downsample(nn.Module):
    method __init__ (line 123) | def __init__(self, channels, use_conv, dims=2, out_channels=None):
    method forward (line 138) | def forward(self, x):
  class ResBlock (line 143) | class ResBlock(TimestepBlock):
    method __init__ (line 160) | def __init__(
    method forward (line 224) | def forward(self, x, emb):
    method _forward (line 236) | def _forward(self, x, emb):
  class AttentionBlock (line 259) | class AttentionBlock(nn.Module):
    method __init__ (line 267) | def __init__(
    method forward (line 296) | def forward(self, x):
    method _forward (line 299) | def _forward(self, x):
  function count_flops_attn (line 308) | def count_flops_attn(model, _x, y):
  class QKVAttentionLegacy (line 328) | class QKVAttentionLegacy(nn.Module):
    method __init__ (line 333) | def __init__(self, n_heads):
    method forward (line 337) | def forward(self, qkv):
    method count_flops (line 357) | def count_flops(model, _x, y):
  class QKVAttention (line 361) | class QKVAttention(nn.Module):
    method __init__ (line 366) | def __init__(self, n_heads):
    method forward (line 370) | def forward(self, qkv):
    method count_flops (line 392) | def count_flops(model, _x, y):
  class UNetModel (line 396) | class UNetModel(nn.Module):
    method __init__ (line 427) | def __init__(
    method convert_to_fp16 (line 618) | def convert_to_fp16(self):
    method convert_to_fp32 (line 626) | def convert_to_fp32(self):
    method forward (line 634) | def forward(self, x, timesteps, y=None):
  class SuperResModel (line 666) | class SuperResModel(UNetModel):
    method __init__ (line 673) | def __init__(self, image_size, in_channels, *args, **kwargs):
    method forward (line 676) | def forward(self, x, timesteps, low_res=None, **kwargs):
  class EncoderUNetModel (line 683) | class EncoderUNetModel(nn.Module):
    method __init__ (line 690) | def __init__(
    method convert_to_fp16 (line 857) | def convert_to_fp16(self):
    method convert_to_fp32 (line 864) | def convert_to_fp32(self):
    method forward (line 871) | def forward(self, x, timesteps):

FILE: scripts/classifier_sample.py
  function main (line 26) | def main():
  function create_argparser (line 113) | def create_argparser():

FILE: scripts/classifier_train.py
  function main (line 28) | def main():
  function set_annealed_lr (line 170) | def set_annealed_lr(opt, base_lr, frac_done):
  function save_model (line 176) | def save_model(mp_trainer, opt, step):
  function compute_top_k (line 185) | def compute_top_k(logits, labels, k, reduction="mean"):
  function split_microbatches (line 193) | def split_microbatches(microbatch, *args):
  function create_argparser (line 202) | def create_argparser():

FILE: scripts/image_nll.py
  function main (line 21) | def main():
  function run_bpd_evaluation (line 50) | def run_bpd_evaluation(model, diffusion, data, num_samples, clip_denoised):
  function create_argparser (line 85) | def create_argparser():

FILE: scripts/image_sample.py
  function main (line 23) | def main():
  function create_argparser (line 93) | def create_argparser():

FILE: scripts/image_train.py
  function main (line 19) | def main():
  function create_argparser (line 60) | def create_argparser():

FILE: scripts/super_res_sample.py
  function main (line 23) | def main():
  function load_data_for_worker (line 77) | def load_data_for_worker(base_samples, batch_size, class_cond):
  function create_argparser (line 103) | def create_argparser():

FILE: scripts/super_res_train.py
  function main (line 21) | def main():
  function load_superres_data (line 63) | def load_superres_data(data_dir, batch_size, large_size, small_size, cla...
  function create_argparser (line 75) | def create_argparser():