SYMBOL INDEX (288 symbols across 15 files)

FILE: src/ae.py
  class Encoder (line 29) | class Encoder(nn.Module):
    method __init__ (line 33) | def __init__(self, image_size, hidden_dim):
    method forward (line 38) | def forward(self, x):
  class Decoder (line 42) | class Decoder(nn.Module):
    method __init__ (line 46) | def __init__(self, hidden_dim, image_size):
    method forward (line 51) | def forward(self, encoder_output):
  class Autoencoder (line 55) | class Autoencoder(nn.Module):
    method __init__ (line 58) | def __init__(self, image_size=784, hidden_dim=32):
    method forward (line 66) | def forward(self, x):
  class AutoencoderTrainer (line 70) | class AutoencoderTrainer:
    method __init__ (line 71) | def __init__(self, model, train_iter, val_iter, test_iter, viz=False):
    method train (line 87) | def train(self, num_epochs, lr=1e-3, weight_decay=1e-5):
    method compute_batch (line 147) | def compute_batch(self, batch):
    method evaluate (line 162) | def evaluate(self, iterator):
    method reconstruct_images (line 166) | def reconstruct_images(self, images, epoch, save=True):
    method viz_loss (line 195) | def viz_loss(self):
    method save_model (line 211) | def save_model(self, savepath):
    method load_model (line 215) | def load_model(self, loadpath):

FILE: src/be_gan.py
  class Generator (line 48) | class Generator(nn.Module):
    method __init__ (line 51) | def __init__(self, image_size, hidden_dim, z_dim):
    method forward (line 57) | def forward(self, x):
  class Discriminator (line 63) | class Discriminator(nn.Module):
    method __init__ (line 67) | def __init__(self, image_size, hidden_dim):
    method forward (line 73) | def forward(self, x):
  class BEGAN (line 79) | class BEGAN(nn.Module):
    method __init__ (line 82) | def __init__(self, image_size, hidden_dim, z_dim):
  class BEGANTrainer (line 93) | class BEGANTrainer:
    method __init__ (line 94) | def __init__(self, model, train_iter, val_iter, test_iter, viz=False):
    method train (line 109) | def train(self, num_epochs, G_lr=1e-4, D_lr=1e-4, D_steps=1,
    method train_D (line 212) | def train_D(self, images, K):
    method train_G (line 240) | def train_G(self, images):
    method compute_noise (line 260) | def compute_noise(self, batch_size, z_dim):
    method process_batch (line 264) | def process_batch(self, iterator):
    method generate_images (line 270) | def generate_images(self, epoch, num_outputs=36, save=True):
    method viz_loss (line 307) | def viz_loss(self):
    method save_model (line 329) | def save_model(self, savepath):
    method load_model (line 333) | def load_model(self, loadpath):

FILE: src/bir_vae.py
  class Encoder (line 37) | class Encoder(nn.Module):
    method __init__ (line 41) | def __init__(self, image_size, hidden_dim, z_dim):
    method forward (line 47) | def forward(self, x):
  class Decoder (line 53) | class Decoder(nn.Module):
    method __init__ (line 57) | def __init__(self, z_dim, hidden_dim, image_size):
    method forward (line 63) | def forward(self, z):
  class BIRVAE (line 69) | class BIRVAE(nn.Module):
    method __init__ (line 73) | def __init__(self, image_size=784, hidden_dim=400, z_dim=20, I=13.3):
    method forward (line 84) | def forward(self, x):
    method reparameterize (line 90) | def reparameterize(self, mu):
  class BIRVAETrainer (line 99) | class BIRVAETrainer:
    method __init__ (line 100) | def __init__(self, model, train_iter, val_iter, test_iter, viz=False):
    method train (line 117) | def train(self, num_epochs, lr=1e-3, weight_decay=1e-5):
    method compute_batch (line 180) | def compute_batch(self, batch, LAMBDA=1000.):
    method maximum_mean_discrepancy (line 201) | def maximum_mean_discrepancy(self, z):
    method compute_kernel (line 210) | def compute_kernel(self, x, y):
    method evaluate (line 223) | def evaluate(self, iterator):
    method reconstruct_images (line 234) | def reconstruct_images(self, images, epoch, save=True):
    method sample_images (line 265) | def sample_images(self, epoch=-100, num_images=36, save=True):
    method sample_interpolated_images (line 290) | def sample_interpolated_images(self):
    method explore_latent_space (line 307) | def explore_latent_space(self, num_epochs=3):
    method make_all (line 348) | def make_all(self):
    method viz_loss (line 360) | def viz_loss(self):
    method save_model (line 381) | def save_model(self, savepath):
    method load_model (line 385) | def load_model(self, loadpath):

FILE: src/dra_gan.py
  class Generator (line 32) | class Generator(nn.Module):
    method __init__ (line 35) | def __init__(self, image_size, hidden_dim, z_dim):
    method forward (line 41) | def forward(self, x):
  class Discriminator (line 47) | class Discriminator(nn.Module):
    method __init__ (line 51) | def __init__(self, image_size, hidden_dim, output_dim):
    method forward (line 57) | def forward(self, x):
  class DRAGAN (line 63) | class DRAGAN(nn.Module):
    method __init__ (line 66) | def __init__(self, image_size, hidden_dim, z_dim, output_dim=1):
  class DRAGANTrainer (line 77) | class DRAGANTrainer:
    method __init__ (line 80) | def __init__(self, model, train_iter, val_iter, test_iter, viz=False):
    method train (line 94) | def train(self, num_epochs, G_lr=1e-4, D_lr=1e-4, D_steps=5):
    method train_D (line 174) | def train_D(self, images, LAMBDA=10, K=1, C=1):
    method train_G (line 227) | def train_G(self, images):
    method compute_noise (line 247) | def compute_noise(self, batch_size, z_dim):
    method process_batch (line 251) | def process_batch(self, iterator):
    method generate_images (line 257) | def generate_images(self, epoch, num_outputs=36, save=True):
    method viz_loss (line 293) | def viz_loss(self):
    method save_model (line 314) | def save_model(self, savepath):
    method load_model (line 318) | def load_model(self, loadpath):

FILE: src/f_gan.py
  class Generator (line 42) | class Generator(nn.Module):
    method __init__ (line 45) | def __init__(self, image_size, hidden_dim, z_dim):
    method forward (line 50) | def forward(self, x):
  class Discriminator (line 56) | class Discriminator(nn.Module):
    method __init__ (line 60) | def __init__(self, image_size, hidden_dim, output_dim):
    method forward (line 65) | def forward(self, x):
  class fGAN (line 71) | class fGAN(nn.Module):
    method __init__ (line 74) | def __init__(self, image_size, hidden_dim, z_dim, output_dim=1):
  class Divergence (line 85) | class Divergence:
    method __init__ (line 89) | def __init__(self, method):
    method D_loss (line 99) | def D_loss(self, DX_score, DG_score):
    method G_loss (line 123) | def G_loss(self, DG_score):
  class fGANTrainer (line 145) | class fGANTrainer:
    method __init__ (line 148) | def __init__(self, model, train_iter, val_iter, test_iter, viz=False):
    method train (line 162) | def train(self, num_epochs, method, G_lr=1e-4, D_lr=1e-4, D_steps=1):
    method train_D (line 244) | def train_D(self, images):
    method train_G (line 267) | def train_G(self, images):
    method compute_noise (line 286) | def compute_noise(self, batch_size, z_dim):
    method process_batch (line 290) | def process_batch(self, iterator):
    method generate_images (line 296) | def generate_images(self, epoch, num_outputs=36, save=True):
    method viz_loss (line 332) | def viz_loss(self):
    method save_model (line 353) | def save_model(self, savepath):
    method load_model (line 357) | def load_model(self, loadpath):

FILE: src/fisher_gan.py
  class Generator (line 41) | class Generator(nn.Module):
    method __init__ (line 44) | def __init__(self, image_size, hidden_dim, z_dim):
    method forward (line 49) | def forward(self, x):
  class Discriminator (line 55) | class Discriminator(nn.Module):
    method __init__ (line 59) | def __init__(self, image_size, hidden_dim, output_dim):
    method forward (line 64) | def forward(self, x):
  class FisherGAN (line 70) | class FisherGAN(nn.Module):
    method __init__ (line 73) | def __init__(self, image_size, hidden_dim, z_dim, output_dim=1):
  class FisherGANTrainer (line 84) | class FisherGANTrainer:
    method __init__ (line 87) | def __init__(self, model, train_iter, val_iter, test_iter, viz=False):
    method train (line 101) | def train(self, num_epochs, G_lr=1e-4, D_lr=1e-4, D_steps=1, RHO=1e-6):
    method train_D (line 193) | def train_D(self, images):
    method train_G (line 231) | def train_G(self, images):
    method compute_noise (line 250) | def compute_noise(self, batch_size, z_dim):
    method process_batch (line 254) | def process_batch(self, iterator):
    method generate_images (line 260) | def generate_images(self, epoch, num_outputs=36, save=True):
    method viz_loss (line 296) | def viz_loss(self):
    method save_model (line 317) | def save_model(self, savepath):
    method load_model (line 321) | def load_model(self, loadpath):

FILE: src/info_gan.py
  class Generator (line 45) | class Generator(nn.Module):
    method __init__ (line 49) | def __init__(self, image_size, hidden_dim, z_dim, disc_dim, cont_dim):
    method forward (line 54) | def forward(self, x):
  class Discriminator (line 60) | class Discriminator(nn.Module):
    method __init__ (line 64) | def __init__(self, image_size, hidden_dim, output_dim):
    method forward (line 72) | def forward(self, x):
  class Q (line 78) | class Q(nn.Module):
    method __init__ (line 82) | def __init__(self, image_size, hidden_dim, disc_dim, cont_dim):
    method forward (line 90) | def forward(self, x):
  class InfoGAN (line 97) | class InfoGAN(nn.Module):
    method __init__ (line 100) | def __init__(self, image_size, hidden_dim, z_dim, disc_dim, cont_dim, ...
  class InfoGANTrainer (line 112) | class InfoGANTrainer:
    method __init__ (line 115) | def __init__(self, model, train_iter, val_iter, test_iter, viz=False):
    method train (line 130) | def train(self, num_epochs, G_lr=2e-4, D_lr=2e-4, D_steps=1):
    method train_D (line 223) | def train_D(self, images):
    method train_G (line 248) | def train_G(self, images):
    method train_Q (line 269) | def train_Q(self, images, LAMBDA=1):
    method compute_noise (line 306) | def compute_noise(self, batch_size, z_dim, disc_dim, cont_dim, c=None):
    method process_batch (line 327) | def process_batch(self, iterator):
    method generate_images (line 333) | def generate_images(self, epoch, num_outputs=36, save=True, c=None):
    method viz_loss (line 367) | def viz_loss(self):
    method save_model (line 388) | def save_model(self, savepath):
    method load_model (line 392) | def load_model(self, loadpath):

FILE: src/ls_gan.py
  class Generator (line 33) | class Generator(nn.Module):
    method __init__ (line 36) | def __init__(self, image_size, hidden_dim, z_dim):
    method forward (line 42) | def forward(self, x):
  class Discriminator (line 48) | class Discriminator(nn.Module):
    method __init__ (line 52) | def __init__(self, image_size, hidden_dim, output_dim):
    method forward (line 58) | def forward(self, x):
  class LSGAN (line 64) | class LSGAN(nn.Module):
    method __init__ (line 67) | def __init__(self, image_size, hidden_dim, z_dim, output_dim=1):
  class LSGANTrainer (line 78) | class LSGANTrainer:
    method __init__ (line 81) | def __init__(self, model, train_iter, val_iter, test_iter, viz=False):
    method train (line 95) | def train(self, num_epochs, G_lr=1e-4, D_lr=1e-4, D_steps=1):
    method train_D (line 173) | def train_D(self, images, a=0, b=1):
    method train_G (line 197) | def train_G(self, images, c=1):
    method compute_noise (line 217) | def compute_noise(self, batch_size, z_dim):
    method process_batch (line 221) | def process_batch(self, iterator):
    method generate_images (line 227) | def generate_images(self, epoch, num_outputs=36, save=True):
    method viz_loss (line 263) | def viz_loss(self):
    method save_model (line 284) | def save_model(self, savepath):
    method load_model (line 288) | def load_model(self, loadpath):

FILE: src/mm_gan.py
  class Generator (line 35) | class Generator(nn.Module):
    method __init__ (line 38) | def __init__(self, image_size, hidden_dim, z_dim):
    method forward (line 44) | def forward(self, x):
  class Discriminator (line 50) | class Discriminator(nn.Module):
    method __init__ (line 54) | def __init__(self, image_size, hidden_dim, output_dim):
    method forward (line 60) | def forward(self, x):
  class MMGAN (line 66) | class MMGAN(nn.Module):
    method __init__ (line 69) | def __init__(self, image_size, hidden_dim, z_dim, output_dim=1):
  class MMGANTrainer (line 80) | class MMGANTrainer:
    method __init__ (line 83) | def __init__(self, model, train_iter, val_iter, test_iter, viz=False):
    method train (line 97) | def train(self, num_epochs, G_lr=2e-4, D_lr=2e-4, D_steps=1, G_init=5):
    method train_D (line 195) | def train_D(self, images):
    method train_G (line 220) | def train_G(self, images):
    method compute_noise (line 239) | def compute_noise(self, batch_size, z_dim):
    method process_batch (line 243) | def process_batch(self, iterator):
    method generate_images (line 249) | def generate_images(self, epoch, num_outputs=36, save=True):
    method viz_loss (line 282) | def viz_loss(self):
    method save_model (line 303) | def save_model(self, savepath):
    method load_model (line 307) | def load_model(self, loadpath):

FILE: src/ns_gan.py
  class Generator (line 35) | class Generator(nn.Module):
    method __init__ (line 38) | def __init__(self, image_size, hidden_dim, z_dim):
    method forward (line 43) | def forward(self, x):
  class Discriminator (line 49) | class Discriminator(nn.Module):
    method __init__ (line 52) | def __init__(self, image_size, hidden_dim, output_dim):
    method forward (line 57) | def forward(self, x):
  class NSGAN (line 63) | class NSGAN(nn.Module):
    method __init__ (line 66) | def __init__(self, image_size, hidden_dim, z_dim, output_dim=1):
  class NSGANTrainer (line 77) | class NSGANTrainer:
    method __init__ (line 80) | def __init__(self, model, train_iter, val_iter, test_iter, viz=False):
    method train (line 94) | def train(self, num_epochs, G_lr=2e-4, D_lr=2e-4, D_steps=1):
    method train_D (line 172) | def train_D(self, images):
    method train_G (line 196) | def train_G(self, images):
    method compute_noise (line 218) | def compute_noise(self, batch_size, z_dim):
    method process_batch (line 222) | def process_batch(self, iterator):
    method generate_images (line 228) | def generate_images(self, epoch, num_outputs=36, save=True):
    method viz_loss (line 264) | def viz_loss(self):
    method save_model (line 283) | def save_model(self, savepath):
    method load_model (line 287) | def load_model(self, loadpath):

FILE: src/ra_gan.py
  class Generator (line 46) | class Generator(nn.Module):
    method __init__ (line 49) | def __init__(self, image_size, hidden_dim, z_dim):
    method forward (line 54) | def forward(self, x):
  class Discriminator (line 60) | class Discriminator(nn.Module):
    method __init__ (line 64) | def __init__(self, image_size, hidden_dim, output_dim):
    method forward (line 69) | def forward(self, x):
  class RaNSGAN (line 75) | class RaNSGAN(nn.Module):
    method __init__ (line 78) | def __init__(self, image_size, hidden_dim, z_dim, output_dim=1):
  class RaNSGANTrainer (line 89) | class RaNSGANTrainer:
    method __init__ (line 92) | def __init__(self, model, train_iter, val_iter, test_iter, viz=False):
    method train (line 106) | def train(self, num_epochs, G_lr=2e-4, D_lr=2e-4, D_steps=1):
    method train_D (line 183) | def train_D(self, images):
    method train_G (line 209) | def train_G(self, images):
    method compute_noise (line 231) | def compute_noise(self, batch_size, z_dim):
    method process_batch (line 235) | def process_batch(self, iterator):
    method generate_images (line 241) | def generate_images(self, epoch, num_outputs=36, save=True):
    method viz_loss (line 277) | def viz_loss(self):
    method save_model (line 298) | def save_model(self, savepath):
    method load_model (line 302) | def load_model(self, loadpath):

FILE: src/utils.py
  function to_var (line 6) | def to_var(x):
  function to_cuda (line 10) | def to_cuda(x):
  function get_data (line 16) | def get_data(BATCH_SIZE=100):

FILE: src/vae.py
  class Encoder (line 47) | class Encoder(nn.Module):
    method __init__ (line 51) | def __init__(self, image_size, hidden_dim, z_dim):
    method forward (line 58) | def forward(self, x):
  class Decoder (line 64) | class Decoder(nn.Module):
    method __init__ (line 68) | def __init__(self, z_dim, hidden_dim, image_size):
    method forward (line 74) | def forward(self, z):
  class VAE (line 80) | class VAE(nn.Module):
    method __init__ (line 84) | def __init__(self, image_size=784, hidden_dim=400, z_dim=20):
    method forward (line 94) | def forward(self, x):
    method reparameterize (line 100) | def reparameterize(self, mu, log_var):
  class VAETrainer (line 109) | class VAETrainer:
    method __init__ (line 110) | def __init__(self, model, train_iter, val_iter, test_iter, viz=False):
    method train (line 127) | def train(self, num_epochs, lr=1e-3, weight_decay=1e-5):
    method compute_batch (line 193) | def compute_batch(self, batch):
    method kl_divergence (line 210) | def kl_divergence(self, mu, log_var):
    method evaluate (line 214) | def evaluate(self, iterator):
    method reconstruct_images (line 225) | def reconstruct_images(self, images, epoch, save=True):
    method sample_images (line 254) | def sample_images(self, epoch=-100, num_images=36, save=True):
    method sample_interpolated_images (line 278) | def sample_interpolated_images(self):
    method explore_latent_space (line 295) | def explore_latent_space(self, num_epochs=3):
    method make_all (line 336) | def make_all(self):
    method viz_loss (line 348) | def viz_loss(self):
    method save_model (line 367) | def save_model(self, savepath):
    method load_model (line 371) | def load_model(self, loadpath):

FILE: src/w_gan.py
  class Generator (line 43) | class Generator(nn.Module):
    method __init__ (line 46) | def __init__(self, image_size, hidden_dim, z_dim):
    method forward (line 52) | def forward(self, x):
  class Discriminator (line 58) | class Discriminator(nn.Module):
    method __init__ (line 62) | def __init__(self, image_size, hidden_dim, output_dim):
    method forward (line 68) | def forward(self, x):
  class WGAN (line 74) | class WGAN(nn.Module):
    method __init__ (line 77) | def __init__(self, image_size, hidden_dim, z_dim, output_dim=1):
  class WGANTrainer (line 88) | class WGANTrainer:
    method __init__ (line 91) | def __init__(self, model, train_iter, val_iter, test_iter, viz=False):
    method train (line 105) | def train(self, num_epochs, G_lr=5e-5, D_lr=5e-5, D_steps=5, clip=0.01):
    method train_D (line 190) | def train_D(self, images):
    method train_G (line 212) | def train_G(self, images):
    method compute_noise (line 231) | def compute_noise(self, batch_size, z_dim):
    method process_batch (line 235) | def process_batch(self, iterator):
    method clip_D_weights (line 241) | def clip_D_weights(self, clip):
    method generate_images (line 245) | def generate_images(self, epoch, num_outputs=36, save=True):
    method viz_loss (line 281) | def viz_loss(self):
    method save_model (line 302) | def save_model(self, savepath):
    method load_model (line 306) | def load_model(self, loadpath):

FILE: src/w_gp_gan.py
  class Generator (line 34) | class Generator(nn.Module):
    method __init__ (line 37) | def __init__(self, image_size, hidden_dim, z_dim):
    method forward (line 43) | def forward(self, x):
  class Discriminator (line 49) | class Discriminator(nn.Module):
    method __init__ (line 53) | def __init__(self, image_size, hidden_dim, output_dim):
    method forward (line 59) | def forward(self, x):
  class WGPGAN (line 65) | class WGPGAN(nn.Module):
    method __init__ (line 68) | def __init__(self, image_size, hidden_dim, z_dim, output_dim=1):
  class WGPGANTrainer (line 79) | class WGPGANTrainer:
    method __init__ (line 82) | def __init__(self, model, train_iter, val_iter, test_iter, viz=False):
    method train (line 96) | def train(self, num_epochs, G_lr=1e-4, D_lr=1e-4, D_steps=5):
    method train_D (line 177) | def train_D(self, images, LAMBDA=10):
    method train_G (line 222) | def train_G(self, images):
    method compute_noise (line 241) | def compute_noise(self, batch_size, z_dim):
    method process_batch (line 245) | def process_batch(self, iterator):
    method generate_images (line 251) | def generate_images(self, epoch, num_outputs=36, save=True):
    method viz_loss (line 287) | def viz_loss(self):
    method save_model (line 308) | def save_model(self, savepath):
    method load_model (line 312) | def load_model(self, loadpath):