SYMBOL INDEX (739 symbols across 49 files)

FILE: __main__.py
  function parse_args (line 10) | def parse_args():
  function shutdown (line 23) | async def shutdown(bot):
  function main (line 26) | def main():

FILE: src/bot/shanghai.py
  class Shanghai (line 10) | class Shanghai(commands.Bot, ABC):
    method __init__ (line 11) | def __init__(self, args):
    method on_ready (line 19) | async def on_ready(self):
    method on_message (line 24) | async def on_message(self, message):
    method on_raw_reaction_add (line 33) | async def on_raw_reaction_add(self, ctx):

FILE: src/bot/stablecog.py
  class QueueObject (line 21) | class QueueObject:
    method __init__ (line 22) | def __init__(self, ctx, prompt, height, width, guidance_scale, steps, ...
  class StableCog (line 38) | class StableCog(commands.Cog, name='Stable Diffusion', description='Crea...
    method __init__ (line 39) | def __init__(self, bot):
    method dream_handler (line 112) | async def dream_handler(self, ctx: discord.ApplicationContext, *, prom...
    method process_dream (line 152) | async def process_dream(self, queue_object: QueueObject):
    method dream (line 157) | def dream(self, event_loop: AbstractEventLoop, queue_object: QueueObje...
  function setup (line 213) | def setup(bot):

FILE: src/core/logging.py
  function get_logger (line 7) | def get_logger(name):

FILE: src/stablediffusion/dream.py
  class StableDiffusionPipeline (line 16) | class StableDiffusionPipeline(DiffusionPipeline):
    method __init__ (line 17) | def __init__(
    method __call__ (line 36) | def __call__(

FILE: src/stablediffusion/inpaint.py
  function preprocess (line 13) | def preprocess(image):
  function preprocess_mask (line 22) | def preprocess_mask(mask):
  class StableDiffusionInpaintingPipeline (line 32) | class StableDiffusionInpaintingPipeline(DiffusionPipeline):
    method __init__ (line 33) | def __init__(
    method __call__ (line 52) | def __call__(

FILE: src/stablediffusion/ldm/data/base.py
  class Txt2ImgIterableBaseDataset (line 10) | class Txt2ImgIterableBaseDataset(IterableDataset):
    method __init__ (line 15) | def __init__(self, num_records=0, valid_ids=None, size=256):
    method __len__ (line 26) | def __len__(self):
    method __iter__ (line 30) | def __iter__(self):

FILE: src/stablediffusion/ldm/data/imagenet.py
  function synset2idx (line 28) | def synset2idx(path_to_yaml='data/index_synset.yaml'):
  class ImageNetBase (line 34) | class ImageNetBase(Dataset):
    method __init__ (line 35) | def __init__(self, config=None):
    method __len__ (line 49) | def __len__(self):
    method __getitem__ (line 52) | def __getitem__(self, i):
    method _prepare (line 55) | def _prepare(self):
    method _filter_relpaths (line 58) | def _filter_relpaths(self, relpaths):
    method _prepare_synset_to_human (line 82) | def _prepare_synset_to_human(self):
    method _prepare_idx_to_synset (line 92) | def _prepare_idx_to_synset(self):
    method _prepare_human_to_integer_label (line 98) | def _prepare_human_to_integer_label(self):
    method _load (line 113) | def _load(self):
  class ImageNetTrain (line 161) | class ImageNetTrain(ImageNetBase):
    method __init__ (line 172) | def __init__(self, process_images=True, data_root=None, **kwargs):
    method _prepare (line 177) | def _prepare(self):
  class ImageNetValidation (line 231) | class ImageNetValidation(ImageNetBase):
    method __init__ (line 245) | def __init__(self, process_images=True, data_root=None, **kwargs):
    method _prepare (line 250) | def _prepare(self):
  class ImageNetSR (line 315) | class ImageNetSR(Dataset):
    method __init__ (line 316) | def __init__(
    method __len__ (line 398) | def __len__(self):
    method __getitem__ (line 401) | def __getitem__(self, i):
  class ImageNetSRTrain (line 443) | class ImageNetSRTrain(ImageNetSR):
    method __init__ (line 444) | def __init__(self, **kwargs):
    method get_base (line 447) | def get_base(self):
  class ImageNetSRValidation (line 456) | class ImageNetSRValidation(ImageNetSR):
    method __init__ (line 457) | def __init__(self, **kwargs):
    method get_base (line 460) | def get_base(self):

FILE: src/stablediffusion/ldm/data/lsun.py
  class LSUNBase (line 9) | class LSUNBase(Dataset):
    method __init__ (line 10) | def __init__(
    method __len__ (line 39) | def __len__(self):
    method __getitem__ (line 42) | def __getitem__(self, i):
  class LSUNChurchesTrain (line 72) | class LSUNChurchesTrain(LSUNBase):
    method __init__ (line 73) | def __init__(self, **kwargs):
  class LSUNChurchesValidation (line 81) | class LSUNChurchesValidation(LSUNBase):
    method __init__ (line 82) | def __init__(self, flip_p=0.0, **kwargs):
  class LSUNBedroomsTrain (line 91) | class LSUNBedroomsTrain(LSUNBase):
    method __init__ (line 92) | def __init__(self, **kwargs):
  class LSUNBedroomsValidation (line 100) | class LSUNBedroomsValidation(LSUNBase):
    method __init__ (line 101) | def __init__(self, flip_p=0.0, **kwargs):
  class LSUNCatsTrain (line 110) | class LSUNCatsTrain(LSUNBase):
    method __init__ (line 111) | def __init__(self, **kwargs):
  class LSUNCatsValidation (line 119) | class LSUNCatsValidation(LSUNBase):
    method __init__ (line 120) | def __init__(self, flip_p=0.0, **kwargs):

FILE: src/stablediffusion/ldm/data/personalized.py
  class PersonalizedBase (line 100) | class PersonalizedBase(Dataset):
    method __init__ (line 101) | def __init__(
    method __len__ (line 152) | def __len__(self):
    method __getitem__ (line 155) | def __getitem__(self, i):

FILE: src/stablediffusion/ldm/data/personalized_style.py
  class PersonalizedBase (line 78) | class PersonalizedBase(Dataset):
    method __init__ (line 79) | def __init__(
    method __len__ (line 125) | def __len__(self):
    method __getitem__ (line 128) | def __getitem__(self, i):

FILE: src/stablediffusion/ldm/dream/conditioning.py
  function get_uc_and_c (line 15) | def get_uc_and_c(prompt, model, log_tokens=False, skip_normalize=False):
  function split_weighted_subprompts (line 39) | def split_weighted_subprompts(text, skip_normalize=False)->list:
  function log_tokenization (line 75) | def log_tokenization(text, model, log=False):

FILE: src/stablediffusion/ldm/dream/devices.py
  function choose_torch_device (line 5) | def choose_torch_device() -> str:
  function choose_autocast_device (line 13) | def choose_autocast_device(device):

FILE: src/stablediffusion/ldm/dream/generator/base.py
  class Generator (line 16) | class Generator():
    method __init__ (line 17) | def __init__(self,model):
    method get_make_image (line 26) | def get_make_image(self,prompt,**kwargs):
    method set_variation (line 33) | def set_variation(self, seed, variation_amount, with_variations):
    method generate (line 38) | def generate(self,prompt,init_image,width,height,iterations=1,seed=None,
    method sample_to_image (line 77) | def sample_to_image(self,samples):
    method generate_initial_noise (line 92) | def generate_initial_noise(self, seed, width, height):
    method get_noise (line 111) | def get_noise(self,width,height):
    method new_seed (line 118) | def new_seed(self):
    method slerp (line 122) | def slerp(self, t, v0, v1, DOT_THRESHOLD=0.9995):

FILE: src/stablediffusion/ldm/dream/generator/img2img.py
  class Img2Img (line 11) | class Img2Img(Generator):
    method __init__ (line 12) | def __init__(self,model):
    method get_make_image (line 17) | def get_make_image(self,prompt,sampler,steps,cfg_scale,ddim_eta,
    method get_noise (line 65) | def get_noise(self,width,height):

FILE: src/stablediffusion/ldm/dream/generator/inpaint.py
  class Inpaint (line 12) | class Inpaint(Img2Img):
    method __init__ (line 13) | def __init__(self,model):
    method get_make_image (line 18) | def get_make_image(self,prompt,sampler,steps,cfg_scale,ddim_eta,

FILE: src/stablediffusion/ldm/dream/generator/txt2img.py
  class Txt2Img (line 9) | class Txt2Img(Generator):
    method __init__ (line 10) | def __init__(self,model):
    method get_make_image (line 14) | def get_make_image(self,prompt,sampler,steps,cfg_scale,ddim_eta,
    method get_noise (line 48) | def get_noise(self,width,height):

FILE: src/stablediffusion/ldm/dream/image_util.py
  class InitImageResizer (line 4) | class InitImageResizer():
    method __init__ (line 6) | def __init__(self,Image):
    method resize (line 9) | def resize(self,width=None,height=None) -> Image:
  function make_grid (line 52) | def make_grid(image_list, rows=None, cols=None):

FILE: src/stablediffusion/ldm/dream/pngwriter.py
  class PngWriter (line 16) | class PngWriter:
    method __init__ (line 17) | def __init__(self, outdir):
    method unique_prefix (line 22) | def unique_prefix(self):
    method save_image_and_prompt_to_png (line 35) | def save_image_and_prompt_to_png(self, image, prompt, name):
  class PromptFormatter (line 43) | class PromptFormatter:
    method __init__ (line 44) | def __init__(self, t2i, opt):
    method normalize_prompt (line 50) | def normalize_prompt(self):

FILE: src/stablediffusion/ldm/dream/readline.py
  class Completer (line 17) | class Completer:
    method __init__ (line 18) | def __init__(self, options):
    method complete (line 22) | def complete(self, text, state):
    method _path_completions (line 49) | def _path_completions(self, text, state, extensions):

FILE: src/stablediffusion/ldm/dream/server.py
  function build_opt (line 10) | def build_opt(post_data, seed, gfpgan_model_exists):
  class CanceledException (line 57) | class CanceledException(Exception):
  class DreamServer (line 60) | class DreamServer(BaseHTTPRequestHandler):
    method do_GET (line 65) | def do_GET(self):
    method do_POST (line 122) | def do_POST(self):
  class ThreadingDreamServer (line 241) | class ThreadingDreamServer(ThreadingHTTPServer):
    method __init__ (line 242) | def __init__(self, server_address):

FILE: src/stablediffusion/ldm/generate.py
  class Generate (line 97) | class Generate:
    method __init__ (line 102) | def __init__(
    method prompt2png (line 156) | def prompt2png(self, prompt, outdir, **kwargs):
    method txt2img (line 173) | def txt2img(self, prompt, **kwargs):
    method img2img (line 177) | def img2img(self, prompt, **kwargs):
    method prompt2image (line 184) | def prompt2image(
    method _make_images (line 377) | def _make_images(self, img_path, mask_path, width, height, fit=False):
    method _make_img2img (line 402) | def _make_img2img(self):
    method _make_txt2img (line 408) | def _make_txt2img(self):
    method _make_inpaint (line 414) | def _make_inpaint(self):
    method load_model (line 420) | def load_model(self):
    method upscale_and_reconstruct (line 447) | def upscale_and_reconstruct(self,
    method sample_to_image (line 490) | def sample_to_image(self,samples):
    method _sample_to_image (line 493) | def _sample_to_image(self,samples):
    method _set_sampler (line 499) | def _set_sampler(self):
    method _load_model_from_config (line 527) | def _load_model_from_config(self, config, ckpt):
    method _load_img (line 569) | def _load_img(self, path, width, height, fit=False):
    method _create_init_image (line 584) | def _create_init_image(self,image):
    method _create_init_mask (line 596) | def _create_init_mask(self, image):
    method _image_to_mask (line 616) | def _image_to_mask(self, mask_image, invert=False) -> Image:
    method _has_transparency (line 624) | def _has_transparency(self,image):
    method _check_for_erasure (line 639) | def _check_for_erasure(self,image):
    method _squeeze_image (line 652) | def _squeeze_image(self,image):
    method _fit_image (line 659) | def _fit_image(self,image,max_dimensions):
    method _resolution_check (line 676) | def _resolution_check(self, width, height, log=False):

FILE: src/stablediffusion/ldm/gfpgan/gfpgan_tools.py
  function run_gfpgan (line 15) | def run_gfpgan(image, strength, seed, upsampler_scale=4):
  function _load_gfpgan_bg_upsampler (line 78) | def _load_gfpgan_bg_upsampler(bg_upsampler, upsampler_scale, bg_tile=400):
  function real_esrgan_upscale (line 130) | def real_esrgan_upscale(image, strength, upsampler_scale, seed):

FILE: src/stablediffusion/ldm/lr_scheduler.py
  class LambdaWarmUpCosineScheduler (line 4) | class LambdaWarmUpCosineScheduler:
    method __init__ (line 9) | def __init__(
    method schedule (line 26) | def schedule(self, n, **kwargs):
    method __call__ (line 49) | def __call__(self, n, **kwargs):
  class LambdaWarmUpCosineScheduler2 (line 53) | class LambdaWarmUpCosineScheduler2:
    method __init__ (line 59) | def __init__(
    method find_in_interval (line 84) | def find_in_interval(self, n):
    method schedule (line 91) | def schedule(self, n, **kwargs):
    method __call__ (line 117) | def __call__(self, n, **kwargs):
  class LambdaLinearScheduler (line 121) | class LambdaLinearScheduler(LambdaWarmUpCosineScheduler2):
    method schedule (line 122) | def schedule(self, n, **kwargs):

FILE: src/stablediffusion/ldm/models/autoencoder.py
  class VQModel (line 16) | class VQModel(pl.LightningModule):
    method __init__ (line 17) | def __init__(
    method ema_scope (line 77) | def ema_scope(self, context=None):
    method init_from_ckpt (line 91) | def init_from_ckpt(self, path, ignore_keys=list()):
    method on_train_batch_end (line 107) | def on_train_batch_end(self, *args, **kwargs):
    method encode (line 111) | def encode(self, x):
    method encode_to_prequant (line 117) | def encode_to_prequant(self, x):
    method decode (line 122) | def decode(self, quant):
    method decode_code (line 127) | def decode_code(self, code_b):
    method forward (line 132) | def forward(self, input, return_pred_indices=False):
    method get_input (line 139) | def get_input(self, batch, k):
    method training_step (line 163) | def training_step(self, batch, batch_idx, optimizer_idx):
    method validation_step (line 211) | def validation_step(self, batch, batch_idx):
    method _validation_step (line 219) | def _validation_step(self, batch, batch_idx, suffix=''):
    method configure_optimizers (line 268) | def configure_optimizers(self):
    method get_last_layer (line 309) | def get_last_layer(self):
    method log_images (line 312) | def log_images(self, batch, only_inputs=False, plot_ema=False, **kwargs):
    method to_rgb (line 335) | def to_rgb(self, x):
  class VQModelInterface (line 346) | class VQModelInterface(VQModel):
    method __init__ (line 347) | def __init__(self, embed_dim, *args, **kwargs):
    method encode (line 351) | def encode(self, x):
    method decode (line 356) | def decode(self, h, force_not_quantize=False):
  class AutoencoderKL (line 367) | class AutoencoderKL(pl.LightningModule):
    method __init__ (line 368) | def __init__(
    method init_from_ckpt (line 402) | def init_from_ckpt(self, path, ignore_keys=list()):
    method encode (line 413) | def encode(self, x):
    method decode (line 419) | def decode(self, z):
    method forward (line 424) | def forward(self, input, sample_posterior=True):
    method get_input (line 433) | def get_input(self, batch, k):
    method training_step (line 444) | def training_step(self, batch, batch_idx, optimizer_idx):
    method validation_step (line 505) | def validation_step(self, batch, batch_idx):
    method configure_optimizers (line 533) | def configure_optimizers(self):
    method get_last_layer (line 548) | def get_last_layer(self):
    method log_images (line 552) | def log_images(self, batch, only_inputs=False, **kwargs):
    method to_rgb (line 568) | def to_rgb(self, x):
  class IdentityFirstStage (line 579) | class IdentityFirstStage(torch.nn.Module):
    method __init__ (line 580) | def __init__(self, *args, vq_interface=False, **kwargs):
    method encode (line 584) | def encode(self, x, *args, **kwargs):
    method decode (line 587) | def decode(self, x, *args, **kwargs):
    method quantize (line 590) | def quantize(self, x, *args, **kwargs):
    method forward (line 595) | def forward(self, x, *args, **kwargs):

FILE: src/stablediffusion/ldm/models/diffusion/classifier.py
  function disabled_train (line 22) | def disabled_train(self, mode=True):
  class NoisyLatentImageClassifier (line 28) | class NoisyLatentImageClassifier(pl.LightningModule):
    method __init__ (line 29) | def __init__(
    method init_from_ckpt (line 82) | def init_from_ckpt(self, path, ignore_keys=list(), only_model=False):
    method load_diffusion (line 105) | def load_diffusion(self):
    method load_classifier (line 112) | def load_classifier(self, ckpt_path, pool):
    method get_x_noisy (line 135) | def get_x_noisy(self, x, t, noise=None):
    method forward (line 153) | def forward(self, x_noisy, t, *args, **kwargs):
    method get_input (line 157) | def get_input(self, batch, k):
    method get_conditioning (line 166) | def get_conditioning(self, batch, k=None):
    method compute_top_k (line 185) | def compute_top_k(self, logits, labels, k, reduction='mean'):
    method on_train_epoch_start (line 194) | def on_train_epoch_start(self):
    method write_logs (line 199) | def write_logs(self, loss, logits, targets):
    method shared_step (line 237) | def shared_step(self, batch, t=None):
    method training_step (line 265) | def training_step(self, batch, batch_idx):
    method reset_noise_accs (line 269) | def reset_noise_accs(self):
    method on_validation_start (line 279) | def on_validation_start(self):
    method validation_step (line 283) | def validation_step(self, batch, batch_idx):
    method configure_optimizers (line 297) | def configure_optimizers(self):
    method log_images (line 322) | def log_images(self, batch, N=8, *args, **kwargs):

FILE: src/stablediffusion/ldm/models/diffusion/ddim.py
  class DDIMSampler (line 17) | class DDIMSampler(object):
    method __init__ (line 18) | def __init__(self, model, schedule='linear', device=None, **kwargs):
    method register_buffer (line 25) | def register_buffer(self, name, attr):
    method make_schedule (line 31) | def make_schedule(
    method sample (line 110) | def sample(
    method ddim_sampling (line 176) | def ddim_sampling(
    method p_sample_ddim (line 276) | def p_sample_ddim(
    method stochastic_encode (line 357) | def stochastic_encode(self, x0, t, use_original_steps=False, noise=None):
    method decode (line 376) | def decode(

FILE: src/stablediffusion/ldm/models/diffusion/ddpm.py
  function disabled_train (line 59) | def disabled_train(self, mode=True):
  function uniform_on_device (line 65) | def uniform_on_device(r1, r2, shape, device):
  class DDPM (line 69) | class DDPM(pl.LightningModule):
    method __init__ (line 71) | def __init__(
    method register_schedule (line 159) | def register_schedule(
    method ema_scope (line 268) | def ema_scope(self, context=None):
    method init_from_ckpt (line 282) | def init_from_ckpt(self, path, ignore_keys=list(), only_model=False):
    method q_mean_variance (line 305) | def q_mean_variance(self, x_start, t):
    method predict_start_from_noise (line 324) | def predict_start_from_noise(self, x_t, t, noise):
    method q_posterior (line 334) | def q_posterior(self, x_start, x_t, t):
    method p_mean_variance (line 353) | def p_mean_variance(self, x, t, clip_denoised: bool):
    method p_sample (line 370) | def p_sample(self, x, t, clip_denoised=True, repeat_noise=False):
    method p_sample_loop (line 386) | def p_sample_loop(self, shape, return_intermediates=False):
    method sample (line 409) | def sample(self, batch_size=16, return_intermediates=False):
    method q_sample (line 417) | def q_sample(self, x_start, t, noise=None):
    method get_loss (line 428) | def get_loss(self, pred, target, mean=True):
    method p_losses (line 445) | def p_losses(self, x_start, t, noise=None):
    method forward (line 476) | def forward(self, x, *args, **kwargs):
    method get_input (line 484) | def get_input(self, batch, k):
    method shared_step (line 492) | def shared_step(self, batch):
    method training_step (line 497) | def training_step(self, batch, batch_idx):
    method validation_step (line 527) | def validation_step(self, batch, batch_idx):
    method on_train_batch_end (line 549) | def on_train_batch_end(self, *args, **kwargs):
    method _get_rows_from_list (line 553) | def _get_rows_from_list(self, samples):
    method log_images (line 561) | def log_images(
    method configure_optimizers (line 602) | def configure_optimizers(self):
  class LatentDiffusion (line 611) | class LatentDiffusion(DDPM):
    method __init__ (line 614) | def __init__(
    method make_cond_schedule (line 689) | def make_cond_schedule(
    method on_train_batch_start (line 704) | def on_train_batch_start(self, batch, batch_idx, dataloader_idx):
    method register_schedule (line 727) | def register_schedule(
    method instantiate_first_stage (line 749) | def instantiate_first_stage(self, config):
    method instantiate_cond_stage (line 756) | def instantiate_cond_stage(self, config):
    method instantiate_embedding_manager (line 784) | def instantiate_embedding_manager(self, config, embedder):
    method _get_denoise_row_from_list (line 794) | def _get_denoise_row_from_list(
    method get_first_stage_encoding (line 812) | def get_first_stage_encoding(self, encoder_posterior):
    method get_learned_conditioning (line 823) | def get_learned_conditioning(self, c):
    method meshgrid (line 840) | def meshgrid(self, h, w):
    method delta_border (line 847) | def delta_border(self, h, w):
    method get_weighting (line 863) | def get_weighting(self, h, w, Ly, Lx, device):
    method get_fold_unfold (line 886) | def get_fold_unfold(
    method get_input (line 976) | def get_input(
    method decode_first_stage (line 1036) | def decode_first_stage(
    method differentiable_decode_first_stage (line 1120) | def differentiable_decode_first_stage(
    method encode_first_stage (line 1204) | def encode_first_stage(self, x):
    method shared_step (line 1251) | def shared_step(self, batch, **kwargs):
    method forward (line 1256) | def forward(self, x, c, *args, **kwargs):
    method _rescale_annotations (line 1272) | def _rescale_annotations(
    method apply_model (line 1284) | def apply_model(self, x_noisy, t, cond, return_ids=False):
    method _predict_eps_from_xstart (line 1447) | def _predict_eps_from_xstart(self, x_t, t, pred_xstart):
    method _prior_bpd (line 1454) | def _prior_bpd(self, x_start):
    method p_losses (line 1472) | def p_losses(self, x_start, cond, t, noise=None):
    method p_mean_variance (line 1521) | def p_mean_variance(
    method p_sample (line 1583) | def p_sample(
    method progressive_denoising (line 1643) | def progressive_denoising(
    method p_sample_loop (line 1739) | def p_sample_loop(
    method sample (line 1819) | def sample(
    method sample_log (line 1867) | def sample_log(self, cond, batch_size, ddim, ddim_steps, **kwargs):
    method log_images (line 1887) | def log_images(
    method configure_optimizers (line 2064) | def configure_optimizers(self):
    method to_rgb (line 2097) | def to_rgb(self, x):
    method on_save_checkpoint (line 2106) | def on_save_checkpoint(self, checkpoint):
  class DiffusionWrapper (line 2127) | class DiffusionWrapper(pl.LightningModule):
    method __init__ (line 2128) | def __init__(self, diff_model_config, conditioning_key):
    method forward (line 2140) | def forward(self, x, t, c_concat: list = None, c_crossattn: list = None):
  class Layout2ImgDiffusion (line 2162) | class Layout2ImgDiffusion(LatentDiffusion):
    method __init__ (line 2164) | def __init__(self, cond_stage_key, *args, **kwargs):
    method log_images (line 2170) | def log_images(self, batch, N=8, *args, **kwargs):

FILE: src/stablediffusion/ldm/models/diffusion/ksampler.py
  class CFGDenoiser (line 7) | class CFGDenoiser(nn.Module):
    method __init__ (line 8) | def __init__(self, model):
    method forward (line 12) | def forward(self, x, sigma, uncond, cond, cond_scale):
  class KSampler (line 20) | class KSampler(object):
    method __init__ (line 21) | def __init__(self, model, schedule='lms', device=None, **kwargs):
    method sample (line 39) | def sample(

FILE: src/stablediffusion/ldm/models/diffusion/plms.py
  class PLMSSampler (line 16) | class PLMSSampler(object):
    method __init__ (line 17) | def __init__(self, model, schedule='linear', device=None, **kwargs):
    method register_buffer (line 24) | def register_buffer(self, name, attr):
    method make_schedule (line 30) | def make_schedule(
    method sample (line 111) | def sample(
    method plms_sampling (line 176) | def plms_sampling(
    method p_sample_plms (line 287) | def p_sample_plms(

FILE: src/stablediffusion/ldm/modules/attention.py
  function exists (line 12) | def exists(val):
  function uniq (line 16) | def uniq(arr):
  function default (line 20) | def default(val, d):
  function max_neg_value (line 26) | def max_neg_value(t):
  function init_ (line 30) | def init_(tensor):
  class GEGLU (line 38) | class GEGLU(nn.Module):
    method __init__ (line 39) | def __init__(self, dim_in, dim_out):
    method forward (line 43) | def forward(self, x):
  class FeedForward (line 48) | class FeedForward(nn.Module):
    method __init__ (line 49) | def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0.):
    method forward (line 64) | def forward(self, x):
  function zero_module (line 68) | def zero_module(module):
  function Normalize (line 77) | def Normalize(in_channels):
  class LinearAttention (line 81) | class LinearAttention(nn.Module):
    method __init__ (line 82) | def __init__(self, dim, heads=4, dim_head=32):
    method forward (line 89) | def forward(self, x):
  class SpatialSelfAttention (line 100) | class SpatialSelfAttention(nn.Module):
    method __init__ (line 101) | def __init__(self, in_channels):
    method forward (line 127) | def forward(self, x):
  class CrossAttention (line 153) | class CrossAttention(nn.Module):
    method __init__ (line 154) | def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, ...
    method einsum_op_v1 (line 184) | def einsum_op_v1(self, q, k, v, r1):
    method einsum_op_v2 (line 205) | def einsum_op_v2(self, q, k, v, r1):
    method einsum_op_v3 (line 217) | def einsum_op_v3(self, q, k, v, r1):
    method einsum_op_v4 (line 230) | def einsum_op_v4(self, q, k, v, r1):
    method forward (line 261) | def forward(self, x, context=None, mask=None):
  class BasicTransformerBlock (line 283) | class BasicTransformerBlock(nn.Module):
    method __init__ (line 284) | def __init__(self, dim, n_heads, d_head, dropout=0., context_dim=None,...
    method forward (line 295) | def forward(self, x, context=None):
    method _forward (line 298) | def _forward(self, x, context=None):
  class SpatialTransformer (line 306) | class SpatialTransformer(nn.Module):
    method __init__ (line 314) | def __init__(self, in_channels, n_heads, d_head,
    method forward (line 338) | def forward(self, x, context=None):

FILE: src/stablediffusion/ldm/modules/diffusionmodules/model.py
  function get_timestep_embedding (line 14) | def get_timestep_embedding(timesteps, embedding_dim):
  function nonlinearity (line 35) | def nonlinearity(x):
  function Normalize (line 40) | def Normalize(in_channels, num_groups=32):
  class Upsample (line 44) | class Upsample(nn.Module):
    method __init__ (line 45) | def __init__(self, in_channels, with_conv):
    method forward (line 55) | def forward(self, x):
  class Downsample (line 62) | class Downsample(nn.Module):
    method __init__ (line 63) | def __init__(self, in_channels, with_conv):
    method forward (line 74) | def forward(self, x):
  class ResnetBlock (line 84) | class ResnetBlock(nn.Module):
    method __init__ (line 85) | def __init__(self, *, in_channels, out_channels=None, conv_shortcut=Fa...
    method forward (line 123) | def forward(self, x, temb):
  class LinAttnBlock (line 157) | class LinAttnBlock(LinearAttention):
    method __init__ (line 159) | def __init__(self, in_channels):
  class AttnBlock (line 163) | class AttnBlock(nn.Module):
    method __init__ (line 164) | def __init__(self, in_channels):
    method forward (line 191) | def forward(self, x):
  function make_attn (line 264) | def make_attn(in_channels, attn_type="vanilla"):
  class Model (line 275) | class Model(nn.Module):
    method __init__ (line 276) | def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks,
    method forward (line 375) | def forward(self, x, t=None, context=None):
    method get_last_layer (line 423) | def get_last_layer(self):
  class Encoder (line 427) | class Encoder(nn.Module):
    method __init__ (line 428) | def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks,
    method forward (line 493) | def forward(self, x):
  class Decoder (line 521) | class Decoder(nn.Module):
    method __init__ (line 522) | def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks,
    method forward (line 594) | def forward(self, z):
  class SimpleDecoder (line 655) | class SimpleDecoder(nn.Module):
    method __init__ (line 656) | def __init__(self, in_channels, out_channels, *args, **kwargs):
    method forward (line 678) | def forward(self, x):
  class UpsampleDecoder (line 691) | class UpsampleDecoder(nn.Module):
    method __init__ (line 692) | def __init__(self, in_channels, out_channels, ch, num_res_blocks, reso...
    method forward (line 725) | def forward(self, x):
  class LatentRescaler (line 739) | class LatentRescaler(nn.Module):
    method __init__ (line 740) | def __init__(self, factor, in_channels, mid_channels, out_channels, de...
    method forward (line 764) | def forward(self, x):
  class MergedRescaleEncoder (line 776) | class MergedRescaleEncoder(nn.Module):
    method __init__ (line 777) | def __init__(self, in_channels, ch, resolution, out_ch, num_res_blocks,
    method forward (line 789) | def forward(self, x):
  class MergedRescaleDecoder (line 795) | class MergedRescaleDecoder(nn.Module):
    method __init__ (line 796) | def __init__(self, z_channels, out_ch, resolution, num_res_blocks, att...
    method forward (line 806) | def forward(self, x):
  class Upsampler (line 812) | class Upsampler(nn.Module):
    method __init__ (line 813) | def __init__(self, in_size, out_size, in_channels, out_channels, ch_mu...
    method forward (line 825) | def forward(self, x):
  class Resize (line 831) | class Resize(nn.Module):
    method __init__ (line 832) | def __init__(self, in_channels=None, learned=False, mode="bilinear"):
    method forward (line 847) | def forward(self, x, scale_factor=1.0):
  class FirstStagePostProcessor (line 854) | class FirstStagePostProcessor(nn.Module):
    method __init__ (line 856) | def __init__(self, ch_mult:list, in_channels,
    method instantiate_pretrained (line 891) | def instantiate_pretrained(self, config):
    method encode_with_pretrained (line 900) | def encode_with_pretrained(self,x):
    method forward (line 906) | def forward(self,x):

FILE: src/stablediffusion/ldm/modules/diffusionmodules/openaimodel.py
  function convert_module_to_f16 (line 24) | def convert_module_to_f16(x):
  function convert_module_to_f32 (line 28) | def convert_module_to_f32(x):
  class AttentionPool2d (line 33) | class AttentionPool2d(nn.Module):
    method __init__ (line 38) | def __init__(
    method forward (line 54) | def forward(self, x):
  class TimestepBlock (line 65) | class TimestepBlock(nn.Module):
    method forward (line 71) | def forward(self, x, emb):
  class TimestepEmbedSequential (line 77) | class TimestepEmbedSequential(nn.Sequential, TimestepBlock):
    method forward (line 83) | def forward(self, x, emb, context=None):
  class Upsample (line 94) | class Upsample(nn.Module):
    method __init__ (line 103) | def __init__(
    method forward (line 116) | def forward(self, x):
  class TransposedUpsample (line 129) | class TransposedUpsample(nn.Module):
    method __init__ (line 132) | def __init__(self, channels, out_channels=None, ks=5):
    method forward (line 141) | def forward(self, x):
  class Downsample (line 145) | class Downsample(nn.Module):
    method __init__ (line 154) | def __init__(
    method forward (line 176) | def forward(self, x):
  class ResBlock (line 181) | class ResBlock(TimestepBlock):
    method __init__ (line 197) | def __init__(
    method forward (line 267) | def forward(self, x, emb):
    method _forward (line 278) | def _forward(self, x, emb):
  class AttentionBlock (line 301) | class AttentionBlock(nn.Module):
    method __init__ (line 308) | def __init__(
    method forward (line 337) | def forward(self, x):
    method _forward (line 343) | def _forward(self, x):
  function count_flops_attn (line 352) | def count_flops_attn(model, _x, y):
  class QKVAttentionLegacy (line 372) | class QKVAttentionLegacy(nn.Module):
    method __init__ (line 377) | def __init__(self, n_heads):
    method forward (line 381) | def forward(self, qkv):
    method count_flops (line 402) | def count_flops(model, _x, y):
  class QKVAttention (line 406) | class QKVAttention(nn.Module):
    method __init__ (line 411) | def __init__(self, n_heads):
    method forward (line 415) | def forward(self, qkv):
    method count_flops (line 438) | def count_flops(model, _x, y):
  class UNetModel (line 442) | class UNetModel(nn.Module):
    method __init__ (line 472) | def __init__(
    method convert_to_fp16 (line 766) | def convert_to_fp16(self):
    method convert_to_fp32 (line 774) | def convert_to_fp32(self):
    method forward (line 782) | def forward(self, x, timesteps=None, context=None, y=None, **kwargs):
  class EncoderUNetModel (line 819) | class EncoderUNetModel(nn.Module):
    method __init__ (line 825) | def __init__(
    method convert_to_fp16 (line 998) | def convert_to_fp16(self):
    method convert_to_fp32 (line 1005) | def convert_to_fp32(self):
    method forward (line 1012) | def forward(self, x, timesteps):

FILE: src/stablediffusion/ldm/modules/diffusionmodules/util.py
  function make_beta_schedule (line 21) | def make_beta_schedule(
  function make_ddim_timesteps (line 62) | def make_ddim_timesteps(
  function make_ddim_sampling_parameters (line 92) | def make_ddim_sampling_parameters(
  function betas_for_alpha_bar (line 116) | def betas_for_alpha_bar(num_diffusion_timesteps, alpha_bar, max_beta=0.9...
  function extract_into_tensor (line 135) | def extract_into_tensor(a, t, x_shape):
  function checkpoint (line 141) | def checkpoint(func, inputs, params, flag):
  class CheckpointFunction (line 160) | class CheckpointFunction(torch.autograd.Function):
    method forward (line 162) | def forward(ctx, run_function, length, *args):
    method backward (line 172) | def backward(ctx, *output_grads):
  function timestep_embedding (line 194) | def timestep_embedding(timesteps, dim, max_period=10000, repeat_only=Fal...
  function zero_module (line 221) | def zero_module(module):
  function scale_module (line 230) | def scale_module(module, scale):
  function mean_flat (line 239) | def mean_flat(tensor):
  function normalization (line 246) | def normalization(channels):
  class SiLU (line 256) | class SiLU(nn.Module):
    method forward (line 257) | def forward(self, x):
  class GroupNorm32 (line 261) | class GroupNorm32(nn.GroupNorm):
    method forward (line 262) | def forward(self, x):
  function conv_nd (line 266) | def conv_nd(dims, *args, **kwargs):
  function linear (line 279) | def linear(*args, **kwargs):
  function avg_pool_nd (line 286) | def avg_pool_nd(dims, *args, **kwargs):
  class HybridConditioner (line 299) | class HybridConditioner(nn.Module):
    method __init__ (line 300) | def __init__(self, c_concat_config, c_crossattn_config):
    method forward (line 307) | def forward(self, c_concat, c_crossattn):
  function noise_like (line 313) | def noise_like(shape, device, repeat=False):

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

FILE: src/stablediffusion/ldm/modules/ema.py
  class LitEma (line 5) | class LitEma(nn.Module):
    method __init__ (line 6) | def __init__(self, model, decay=0.9999, use_num_upates=True):
    method forward (line 29) | def forward(self, model):
    method copy_to (line 56) | def copy_to(self, model):
    method store (line 67) | def store(self, parameters):
    method restore (line 76) | def restore(self, parameters):

FILE: src/stablediffusion/ldm/modules/embedding_manager.py
  function get_clip_token_for_string (line 16) | def get_clip_token_for_string(tokenizer, string):
  function get_bert_token_for_string (line 34) | def get_bert_token_for_string(tokenizer, string):
  function get_embedding_for_clip_token (line 43) | def get_embedding_for_clip_token(embedder, token):
  class EmbeddingManager (line 47) | class EmbeddingManager(nn.Module):
    method __init__ (line 48) | def __init__(
    method forward (line 134) | def forward(
    method save (line 210) | def save(self, ckpt_path):
    method load (line 219) | def load(self, ckpt_path, full=True):
    method get_embedding_norms_squared (line 243) | def get_embedding_norms_squared(self):
    method embedding_parameters (line 253) | def embedding_parameters(self):
    method embedding_to_coarse_loss (line 256) | def embedding_to_coarse_loss(self):

FILE: src/stablediffusion/ldm/modules/encoders/modules.py
  function _expand_mask (line 16) | def _expand_mask(mask, dtype, tgt_len=None):
  function _build_causal_attention_mask (line 34) | def _build_causal_attention_mask(bsz, seq_len, dtype):
  class AbstractEncoder (line 44) | class AbstractEncoder(nn.Module):
    method __init__ (line 45) | def __init__(self):
    method encode (line 48) | def encode(self, *args, **kwargs):
  class ClassEmbedder (line 52) | class ClassEmbedder(nn.Module):
    method __init__ (line 53) | def __init__(self, embed_dim, n_classes=1000, key='class'):
    method forward (line 58) | def forward(self, batch, key=None):
  class TransformerEmbedder (line 67) | class TransformerEmbedder(AbstractEncoder):
    method __init__ (line 70) | def __init__(
    method forward (line 86) | def forward(self, tokens):
    method encode (line 91) | def encode(self, x):
  class BERTTokenizer (line 95) | class BERTTokenizer(AbstractEncoder):
    method __init__ (line 98) | def __init__(
    method forward (line 123) | def forward(self, text):
    method encode (line 137) | def encode(self, text):
    method decode (line 143) | def decode(self, text):
  class BERTEmbedder (line 147) | class BERTEmbedder(AbstractEncoder):
    method __init__ (line 150) | def __init__(
    method forward (line 174) | def forward(self, text, embedding_manager=None):
    method encode (line 184) | def encode(self, text, **kwargs):
  class SpatialRescaler (line 189) | class SpatialRescaler(nn.Module):
    method __init__ (line 190) | def __init__(
    method forward (line 223) | def forward(self, x):
    method encode (line 231) | def encode(self, x):
  class FrozenCLIPEmbedder (line 235) | class FrozenCLIPEmbedder(AbstractEncoder):
    method __init__ (line 238) | def __init__(
    method freeze (line 434) | def freeze(self):
    method forward (line 439) | def forward(self, text, **kwargs):
    method encode (line 454) | def encode(self, text, **kwargs):
  class FrozenCLIPTextEmbedder (line 458) | class FrozenCLIPTextEmbedder(nn.Module):
    method __init__ (line 463) | def __init__(
    method freeze (line 478) | def freeze(self):
    method forward (line 483) | def forward(self, text):
    method encode (line 490) | def encode(self, text):
  class FrozenClipImageEmbedder (line 498) | class FrozenClipImageEmbedder(nn.Module):
    method __init__ (line 503) | def __init__(
    method preprocess (line 526) | def preprocess(self, x):
    method forward (line 540) | def forward(self, x):

FILE: src/stablediffusion/ldm/modules/image_degradation/bsrgan.py
  function modcrop_np (line 29) | def modcrop_np(img, sf):
  function analytic_kernel (line 49) | def analytic_kernel(k):
  function anisotropic_Gaussian (line 67) | def anisotropic_Gaussian(ksize=15, theta=np.pi, l1=6, l2=6):
  function gm_blur_kernel (line 93) | def gm_blur_kernel(mean, cov, size=15):
  function shift_pixel (line 106) | def shift_pixel(x, sf, upper_left=True):
  function blur (line 135) | def blur(x, k):
  function gen_kernel (line 154) | def gen_kernel(
  function fspecial_gaussian (line 205) | def fspecial_gaussian(hsize, sigma):
  function fspecial_laplacian (line 221) | def fspecial_laplacian(alpha):
  function fspecial (line 230) | def fspecial(filter_type, *args, **kwargs):
  function bicubic_degradation (line 248) | def bicubic_degradation(x, sf=3):
  function srmd_degradation (line 260) | def srmd_degradation(x, k, sf=3):
  function dpsr_degradation (line 284) | def dpsr_degradation(x, k, sf=3):
  function classical_degradation (line 306) | def classical_degradation(x, k, sf=3):
  function add_sharpening (line 321) | def add_sharpening(img, weight=0.5, radius=50, threshold=10):
  function add_blur (line 347) | def add_blur(img, sf=4):
  function add_resize (line 370) | def add_resize(img, sf=4):
  function add_Gaussian_noise (line 405) | def add_Gaussian_noise(img, noise_level1=2, noise_level2=25):
  function add_speckle_noise (line 428) | def add_speckle_noise(img, noise_level1=2, noise_level2=25):
  function add_Poisson_noise (line 452) | def add_Poisson_noise(img):
  function add_JPEG_noise (line 469) | def add_JPEG_noise(img):
  function random_crop (line 480) | def random_crop(lq, hq, sf=4, lq_patchsize=64):
  function degradation_bsrgan (line 495) | def degradation_bsrgan(img, sf=4, lq_patchsize=72, isp_model=None):
  function degradation_bsrgan_variant (line 604) | def degradation_bsrgan_variant(image, sf=4, isp_model=None):
  function degradation_bsrgan_plus (line 711) | def degradation_bsrgan_plus(

FILE: src/stablediffusion/ldm/modules/image_degradation/bsrgan_light.py
  function modcrop_np (line 29) | def modcrop_np(img, sf):
  function analytic_kernel (line 49) | def analytic_kernel(k):
  function anisotropic_Gaussian (line 67) | def anisotropic_Gaussian(ksize=15, theta=np.pi, l1=6, l2=6):
  function gm_blur_kernel (line 93) | def gm_blur_kernel(mean, cov, size=15):
  function shift_pixel (line 106) | def shift_pixel(x, sf, upper_left=True):
  function blur (line 135) | def blur(x, k):
  function gen_kernel (line 154) | def gen_kernel(
  function fspecial_gaussian (line 205) | def fspecial_gaussian(hsize, sigma):
  function fspecial_laplacian (line 221) | def fspecial_laplacian(alpha):
  function fspecial (line 230) | def fspecial(filter_type, *args, **kwargs):
  function bicubic_degradation (line 248) | def bicubic_degradation(x, sf=3):
  function srmd_degradation (line 260) | def srmd_degradation(x, k, sf=3):
  function dpsr_degradation (line 284) | def dpsr_degradation(x, k, sf=3):
  function classical_degradation (line 306) | def classical_degradation(x, k, sf=3):
  function add_sharpening (line 321) | def add_sharpening(img, weight=0.5, radius=50, threshold=10):
  function add_blur (line 347) | def add_blur(img, sf=4):
  function add_resize (line 374) | def add_resize(img, sf=4):
  function add_Gaussian_noise (line 409) | def add_Gaussian_noise(img, noise_level1=2, noise_level2=25):
  function add_speckle_noise (line 432) | def add_speckle_noise(img, noise_level1=2, noise_level2=25):
  function add_Poisson_noise (line 456) | def add_Poisson_noise(img):
  function add_JPEG_noise (line 473) | def add_JPEG_noise(img):
  function random_crop (line 484) | def random_crop(lq, hq, sf=4, lq_patchsize=64):
  function degradation_bsrgan (line 499) | def degradation_bsrgan(img, sf=4, lq_patchsize=72, isp_model=None):
  function degradation_bsrgan_variant (line 608) | def degradation_bsrgan_variant(image, sf=4, isp_model=None):

FILE: src/stablediffusion/ldm/modules/image_degradation/utils_image.py
  function is_image_file (line 42) | def is_image_file(filename):
  function get_timestamp (line 46) | def get_timestamp():
  function imshow (line 50) | def imshow(x, title=None, cbar=False, figsize=None):
  function surf (line 60) | def surf(Z, cmap='rainbow', figsize=None):
  function get_image_paths (line 80) | def get_image_paths(dataroot):
  function _get_paths_from_images (line 87) | def _get_paths_from_images(path):
  function patches_from_image (line 106) | def patches_from_image(img, p_size=512, p_overlap=64, p_max=800):
  function imssave (line 125) | def imssave(imgs, img_path):
  function split_imageset (line 141) | def split_imageset(
  function mkdir (line 179) | def mkdir(path):
  function mkdirs (line 184) | def mkdirs(paths):
  function mkdir_and_rename (line 192) | def mkdir_and_rename(path):
  function imread_uint (line 211) | def imread_uint(path, n_channels=3):
  function imsave (line 229) | def imsave(img, img_path):
  function imwrite (line 236) | def imwrite(img, img_path):
  function read_img (line 246) | def read_img(path):
  function uint2single (line 275) | def uint2single(img):
  function single2uint (line 280) | def single2uint(img):
  function uint162single (line 285) | def uint162single(img):
  function single2uint16 (line 290) | def single2uint16(img):
  function uint2tensor4 (line 301) | def uint2tensor4(img):
  function uint2tensor3 (line 314) | def uint2tensor3(img):
  function tensor2uint (line 326) | def tensor2uint(img):
  function single2tensor3 (line 339) | def single2tensor3(img):
  function single2tensor4 (line 344) | def single2tensor4(img):
  function tensor2single (line 354) | def tensor2single(img):
  function tensor2single3 (line 363) | def tensor2single3(img):
  function single2tensor5 (line 372) | def single2tensor5(img):
  function single32tensor5 (line 381) | def single32tensor5(img):
  function single42tensor4 (line 390) | def single42tensor4(img):
  function tensor2img (line 397) | def tensor2img(tensor, out_type=np.uint8, min_max=(0, 1)):
  function augment_img (line 444) | def augment_img(img, mode=0):
  function augment_img_tensor4 (line 464) | def augment_img_tensor4(img, mode=0):
  function augment_img_tensor (line 484) | def augment_img_tensor(img, mode=0):
  function augment_img_np3 (line 502) | def augment_img_np3(img, mode=0):
  function augment_imgs (line 530) | def augment_imgs(img_list, hflip=True, rot=True):
  function modcrop (line 555) | def modcrop(img_in, scale):
  function shave (line 571) | def shave(img_in, border=0):
  function rgb2ycbcr (line 590) | def rgb2ycbcr(img, only_y=True):
  function ycbcr2rgb (line 620) | def ycbcr2rgb(img):
  function bgr2ycbcr (line 646) | def bgr2ycbcr(img, only_y=True):
  function channel_convert (line 676) | def channel_convert(in_c, tar_type, img_list):
  function calculate_psnr (line 700) | def calculate_psnr(img1, img2, border=0):
  function calculate_ssim (line 721) | def calculate_ssim(img1, img2, border=0):
  function ssim (line 748) | def ssim(img1, img2):
  function cubic (line 780) | def cubic(x):
  function calculate_weights_indices (line 789) | def calculate_weights_indices(
  function imresize (line 850) | def imresize(img, scale, antialiasing=True):
  function imresize_np (line 935) | def imresize_np(img, scale, antialiasing=True):

FILE: src/stablediffusion/ldm/modules/losses/contperceptual.py
  class LPIPSWithDiscriminator (line 7) | class LPIPSWithDiscriminator(nn.Module):
    method __init__ (line 8) | def __init__(
    method calculate_adaptive_weight (line 46) | def calculate_adaptive_weight(self, nll_loss, g_loss, last_layer=None):
    method forward (line 67) | def forward(

FILE: src/stablediffusion/ldm/modules/losses/vqperceptual.py
  function hinge_d_loss_with_exemplar_weights (line 14) | def hinge_d_loss_with_exemplar_weights(logits_real, logits_fake, weights):
  function adopt_weight (line 24) | def adopt_weight(weight, global_step, threshold=0, value=0.0):
  function measure_perplexity (line 30) | def measure_perplexity(predicted_indices, n_embed):
  function l1 (line 42) | def l1(x, y):
  function l2 (line 46) | def l2(x, y):
  class VQLPIPSWithDiscriminator (line 50) | class VQLPIPSWithDiscriminator(nn.Module):
    method __init__ (line 51) | def __init__(
    method calculate_adaptive_weight (line 108) | def calculate_adaptive_weight(self, nll_loss, g_loss, last_layer=None):
    method forward (line 129) | def forward(

FILE: src/stablediffusion/ldm/modules/x_transformer.py
  class AbsolutePositionalEmbedding (line 23) | class AbsolutePositionalEmbedding(nn.Module):
    method __init__ (line 24) | def __init__(self, dim, max_seq_len):
    method init_ (line 29) | def init_(self):
    method forward (line 32) | def forward(self, x):
  class FixedPositionalEmbedding (line 37) | class FixedPositionalEmbedding(nn.Module):
    method __init__ (line 38) | def __init__(self, dim):
    method forward (line 43) | def forward(self, x, seq_dim=1, offset=0):
  function exists (line 58) | def exists(val):
  function default (line 62) | def default(val, d):
  function always (line 68) | def always(val):
  function not_equals (line 75) | def not_equals(val):
  function equals (line 82) | def equals(val):
  function max_neg_value (line 89) | def max_neg_value(tensor):
  function pick_and_pop (line 96) | def pick_and_pop(keys, d):
  function group_dict_by_key (line 101) | def group_dict_by_key(cond, d):
  function string_begins_with (line 110) | def string_begins_with(prefix, str):
  function group_by_key_prefix (line 114) | def group_by_key_prefix(prefix, d):
  function groupby_prefix_and_trim (line 118) | def groupby_prefix_and_trim(prefix, d):
  class Scale (line 132) | class Scale(nn.Module):
    method __init__ (line 133) | def __init__(self, value, fn):
    method forward (line 138) | def forward(self, x, **kwargs):
  class Rezero (line 143) | class Rezero(nn.Module):
    method __init__ (line 144) | def __init__(self, fn):
    method forward (line 149) | def forward(self, x, **kwargs):
  class ScaleNorm (line 154) | class ScaleNorm(nn.Module):
    method __init__ (line 155) | def __init__(self, dim, eps=1e-5):
    method forward (line 161) | def forward(self, x):
  class RMSNorm (line 166) | class RMSNorm(nn.Module):
    method __init__ (line 167) | def __init__(self, dim, eps=1e-8):
    method forward (line 173) | def forward(self, x):
  class Residual (line 178) | class Residual(nn.Module):
    method forward (line 179) | def forward(self, x, residual):
  class GRUGating (line 183) | class GRUGating(nn.Module):
    method __init__ (line 184) | def __init__(self, dim):
    method forward (line 188) | def forward(self, x, residual):
  class GEGLU (line 200) | class GEGLU(nn.Module):
    method __init__ (line 201) | def __init__(self, dim_in, dim_out):
    method forward (line 205) | def forward(self, x):
  class FeedForward (line 210) | class FeedForward(nn.Module):
    method __init__ (line 211) | def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0.0):
    method forward (line 225) | def forward(self, x):
  class Attention (line 230) | class Attention(nn.Module):
    method __init__ (line 231) | def __init__(
    method forward (line 289) | def forward(
  class AttentionLayers (line 414) | class AttentionLayers(nn.Module):
    method __init__ (line 415) | def __init__(
    method forward (line 539) | def forward(
  class Encoder (line 613) | class Encoder(AttentionLayers):
    method __init__ (line 614) | def __init__(self, **kwargs):
  class TransformerWrapper (line 619) | class TransformerWrapper(nn.Module):
    method __init__ (line 620) | def __init__(
    method init_ (line 679) | def init_(self):
    method forward (line 682) | def forward(

FILE: src/stablediffusion/ldm/simplet2i.py
  class T2I (line 10) | class T2I(Generate):
    method __init__ (line 11) | def __init__(self,**kwargs):

FILE: src/stablediffusion/ldm/util.py
  function log_txt_as_img (line 17) | def log_txt_as_img(wh, xc, size=10):
  function ismap (line 43) | def ismap(x):
  function isimage (line 49) | def isimage(x):
  function exists (line 55) | def exists(x):
  function default (line 59) | def default(val, d):
  function mean_flat (line 65) | def mean_flat(tensor):
  function count_params (line 73) | def count_params(model, verbose=False):
  function instantiate_from_config (line 82) | def instantiate_from_config(config, **kwargs):
  function get_obj_from_str (line 94) | def get_obj_from_str(string, reload=False):
  function _do_parallel_data_prefetch (line 102) | def _do_parallel_data_prefetch(func, Q, data, idx, idx_to_fn=False):
  function parallel_data_prefetch (line 114) | def parallel_data_prefetch(

FILE: src/stablediffusion/text2image_compvis.py
  function resize_image (line 16) | def resize_image(resize_mode, im, width, height):
  class Text2Image (line 52) | class Text2Image:
    method __init__ (line 53) | def __init__(self, model_path='models/model-epoch06-full.ckpt', use_gp...
    method dream (line 61) | def dream(self, prompt: str, ddim_steps: int, plms: bool, fixed_code: ...
    method translation (line 68) | def translation(self, prompt: str, init_img, ddim_steps: int, ddim_eta...
    method inpaint (line 78) | def inpaint(self, prompt: str, init_img, mask_img, ddim_steps: int, dd...

FILE: src/stablediffusion/text2image_diffusers.py
  function resize_image (line 18) | def resize_image(resize_mode, im, width, height):
  class Text2Image (line 54) | class Text2Image:
    method __init__ (line 55) | def __init__(self, use_gpu=True):
    method dream (line 109) | def dream(self, prompt: str, ddim_steps: int, plms: bool, fixed_code: ...
    method translation (line 117) | def translation(self, prompt: str, init_img, ddim_steps: int, ddim_eta...
    method inpaint (line 132) | def inpaint(self, prompt: str, init_img, mask_img, ddim_steps: int, dd...
    method vae_test (line 148) | def vae_test(self, image, height: int, width: int):

FILE: src/stablediffusion/translation.py
  function preprocess (line 14) | def preprocess(image):
  class StableDiffusionImg2ImgPipeline (line 24) | class StableDiffusionImg2ImgPipeline(DiffusionPipeline):
    method __init__ (line 25) | def __init__(
    method __call__ (line 44) | def __call__(