SYMBOL INDEX (515 symbols across 66 files)

FILE: data/latent_code_dataset.py
  class LatentCodeDataset (line 14) | class LatentCodeDataset(data.Dataset):
    method __init__ (line 16) | def __init__(self, input_dir, subset_samples=None):
    method __getitem__ (line 42) | def __getitem__(self, index):
    method __len__ (line 46) | def __len__(self):

FILE: editing_quantitative.py
  function main (line 14) | def main():

FILE: editing_with_dialog.py
  function parse_args (line 18) | def parse_args():
  function main (line 26) | def main():

FILE: editing_wo_dialog.py
  function parse_args (line 18) | def parse_args():
  function main (line 29) | def main():

FILE: language/accuracy.py
  function head_accuracy (line 4) | def head_accuracy(output, target, unlabeled_value=999):

FILE: language/build_vocab.py
  function parse_args (line 13) | def parse_args():
  function main (line 31) | def main():

FILE: language/dataset.py
  class EncoderDataset (line 7) | class EncoderDataset(Dataset):
    method __init__ (line 9) | def __init__(self, preprocessed_dir):
    method __getitem__ (line 21) | def __getitem__(self, index):
    method __len__ (line 31) | def __len__(self):
  function main (line 35) | def main():

FILE: language/generate_feedback.py
  function parse_args (line 11) | def parse_args():
  function main (line 49) | def main():
  function instantiate_feedback (line 105) | def instantiate_feedback(args,

FILE: language/generate_training_request.py
  function parse_args (line 11) | def parse_args():
  function main (line 53) | def main():
  function instantiate_training_request (line 130) | def instantiate_training_request(

FILE: language/language_utils.py
  function build_vocab (line 15) | def build_vocab(text_list,
  function tokenize (line 54) | def tokenize(text,
  function encode (line 88) | def encode(text_tokens, token_to_idx, allow_unk=False):
  function decode (line 100) | def decode(seq_idx, idx_to_token, delim=None, stop_at_end=True):
  function reverse_dict (line 112) | def reverse_dict(input_dict):
  function to_long_tensor (line 121) | def to_long_tensor(dset):
  function proper_capitalize (line 127) | def proper_capitalize(text):

FILE: language/lstm.py
  class Encoder (line 22) | class Encoder(nn.Module):
    method __init__ (line 24) | def __init__(self,
    method forward (line 55) | def forward(self, text):
  class LSTM (line 71) | class LSTM(nn.Module):
    method __init__ (line 73) | def __init__(self,
    method forward (line 102) | def forward(self, x):
  class fc_block (line 142) | class fc_block(nn.Module):
    method __init__ (line 144) | def __init__(self, inplanes, planes, drop_rate=0.15):
    method forward (line 153) | def forward(self, x):
  function main (line 162) | def main():

FILE: language/preprocess_request.py
  function parse_args (line 15) | def parse_args():
  function main (line 63) | def main():

FILE: language/run_encoder.py
  function parse_args (line 11) | def parse_args():
  function main (line 60) | def main():
  function encode_request (line 66) | def encode_request(args, system_mode=None, dialog_logger=None):

FILE: language/train_encoder.py
  function parse_args (line 18) | def parse_args():
  function main (line 74) | def main():
  function train (line 203) | def train(args, phase, encoder, data_loader, criterion, optimizer, logger):

FILE: language/utils/eval.py
  function classification_accuracy (line 8) | def classification_accuracy(output,
  function regression_accuracy (line 68) | def regression_accuracy(output,
  function main (line 144) | def main():

FILE: language/utils/logger.py
  function savefig (line 19) | def savefig(fname, dpi=None):
  function plot_overlap (line 24) | def plot_overlap(logger, names=None):
  class Logger (line 33) | class Logger(object):
    method __init__ (line 36) | def __init__(self, fpath, title=None, resume=False):
    method set_names (line 58) | def set_names(self, names):
    method append (line 71) | def append(self, numbers):
    method plot (line 85) | def plot(self, out_file, names=None):
    method close (line 113) | def close(self):
    method get_numbers (line 117) | def get_numbers(self):
  class LoggerMonitor (line 124) | class LoggerMonitor(object):
    method __init__ (line 127) | def __init__(self, paths):
    method plot (line 134) | def plot(self, names=None):
  class MessageLogger (line 145) | class MessageLogger():
    method __init__ (line 158) | def __init__(self, opt, start_iter=1, tb_logger=None):
    method __call__ (line 169) | def __call__(self, log_vars):
  function init_tb_logger (line 215) | def init_tb_logger(log_dir):
  function get_root_logger (line 221) | def get_root_logger(logger_name='base', log_level=logging.INFO, log_file...
  function dict2str (line 255) | def dict2str(opt, indent_level=1):

FILE: language/utils/lr_schedule.py
  function adjust_learning_rate (line 6) | def adjust_learning_rate(args, optimizer, epoch):

FILE: language/utils/misc.py
  function get_mean_and_std (line 19) | def get_mean_and_std(dataset):
  function init_params (line 36) | def init_params(net):
  function mkdir_p (line 52) | def mkdir_p(path):
  function save_checkpoint (line 63) | def save_checkpoint(args,
  class AverageMeter (line 84) | class AverageMeter(object):
    method __init__ (line 91) | def __init__(self):
    method reset (line 94) | def reset(self):
    method update (line 100) | def update(self, val, n=1):

FILE: language/utils/numerical.py
  function get_weight (line 8) | def get_weight(args):
  function transpose_and_format (line 84) | def transpose_and_format(args, input):

FILE: language/utils/progress/progress/__init__.py
  class Infinite (line 27) | class Infinite(object):
    method __init__ (line 31) | def __init__(self, *args, **kwargs):
    method __getitem__ (line 40) | def __getitem__(self, key):
    method elapsed (line 46) | def elapsed(self):
    method elapsed_td (line 50) | def elapsed_td(self):
    method update_avg (line 53) | def update_avg(self, n, dt):
    method update (line 58) | def update(self):
    method start (line 61) | def start(self):
    method finish (line 64) | def finish(self):
    method next (line 67) | def next(self, n=1):
    method iter (line 75) | def iter(self, it):
  class Progress (line 84) | class Progress(Infinite):
    method __init__ (line 85) | def __init__(self, *args, **kwargs):
    method eta (line 90) | def eta(self):
    method eta_td (line 94) | def eta_td(self):
    method percent (line 98) | def percent(self):
    method progress (line 102) | def progress(self):
    method remaining (line 106) | def remaining(self):
    method start (line 109) | def start(self):
    method goto (line 112) | def goto(self, index):
    method iter (line 116) | def iter(self, it):

FILE: language/utils/progress/progress/bar.py
  class Bar (line 22) | class Bar(WritelnMixin, Progress):
    method update (line 32) | def update(self):
  class ChargingBar (line 45) | class ChargingBar(Bar):
  class FillingSquaresBar (line 53) | class FillingSquaresBar(ChargingBar):
  class FillingCirclesBar (line 58) | class FillingCirclesBar(ChargingBar):
  class IncrementalBar (line 63) | class IncrementalBar(Bar):
    method update (line 66) | def update(self):
  class PixelBar (line 83) | class PixelBar(IncrementalBar):
  class ShadyBar (line 87) | class ShadyBar(IncrementalBar):

FILE: language/utils/progress/progress/counter.py
  class Counter (line 22) | class Counter(WriteMixin, Infinite):
    method update (line 26) | def update(self):
  class Countdown (line 30) | class Countdown(WriteMixin, Progress):
    method update (line 33) | def update(self):
  class Stack (line 37) | class Stack(WriteMixin, Progress):
    method update (line 41) | def update(self):
  class Pie (line 47) | class Pie(Stack):

FILE: language/utils/progress/progress/helpers.py
  class WriteMixin (line 22) | class WriteMixin(object):
    method __init__ (line 25) | def __init__(self, message=None, **kwargs):
    method write (line 37) | def write(self, s):
    method finish (line 45) | def finish(self):
  class WritelnMixin (line 50) | class WritelnMixin(object):
    method __init__ (line 53) | def __init__(self, message=None, **kwargs):
    method clearln (line 61) | def clearln(self):
    method writeln (line 65) | def writeln(self, line):
    method finish (line 71) | def finish(self):
  class SigIntMixin (line 82) | class SigIntMixin(object):
    method __init__ (line 85) | def __init__(self, *args, **kwargs):
    method _sigint_handler (line 89) | def _sigint_handler(self, signum, frame):

FILE: language/utils/progress/progress/spinner.py
  class Spinner (line 22) | class Spinner(WriteMixin, Infinite):
    method update (line 27) | def update(self):
  class PieSpinner (line 32) | class PieSpinner(Spinner):
  class MoonSpinner (line 36) | class MoonSpinner(Spinner):
  class LineSpinner (line 40) | class LineSpinner(Spinner):
  class PixelSpinner (line 43) | class PixelSpinner(Spinner):

FILE: language/utils/progress/test_progress.py
  function sleep (line 16) | def sleep():

FILE: language/utils/setup_logger.py
  function setup_logger (line 11) | def setup_logger(work_dir=None,

FILE: language/utils/visualize.py
  function make_image (line 12) | def make_image(img, mean=(0,0,0), std=(1,1,1)):
  function gauss (line 18) | def gauss(x,a,b,c):
  function colorize (line 21) | def colorize(x):
  function show_batch (line 38) | def show_batch(images, Mean=(2, 2, 2), Std=(0.5,0.5,0.5)):
  function show_mask_single (line 44) | def show_mask_single(images, mask, Mean=(2, 2, 2), Std=(0.5,0.5,0.5)):
  function show_mask (line 73) | def show_mask(images, masklist, Mean=(2, 2, 2), Std=(0.5,0.5,0.5)):

FILE: models/__init__.py
  function create_model (line 21) | def create_model(opt):

FILE: models/archs/attribute_predictor_arch.py
  function conv3x3 (line 17) | def conv3x3(in_planes, out_planes, stride=1):
  function conv1x1 (line 28) | def conv1x1(in_planes, out_planes, stride=1):
  class BasicBlock (line 34) | class BasicBlock(nn.Module):
    method __init__ (line 37) | def __init__(self, inplanes, planes, stride=1, downsample=None):
    method forward (line 47) | def forward(self, x):
  class Bottleneck (line 66) | class Bottleneck(nn.Module):
    method __init__ (line 69) | def __init__(self, inplanes, planes, stride=1, downsample=None):
    method forward (line 81) | def forward(self, x):
  class fc_block (line 104) | class fc_block(nn.Module):
    method __init__ (line 106) | def __init__(self, inplanes, planes, drop_rate=0.15):
    method forward (line 115) | def forward(self, x):
  class ResNet (line 124) | class ResNet(nn.Module):
    method __init__ (line 126) | def __init__(self,
    method _make_layer (line 179) | def _make_layer(self, block, planes, blocks, stride=1):
    method forward (line 195) | def forward(self, x):
  function resnet50 (line 220) | def resnet50(pretrained=True, **kwargs):
  function init_pretrained_weights (line 232) | def init_pretrained_weights(model, model_url):

FILE: models/archs/field_function_arch.py
  class FieldFunction (line 5) | class FieldFunction(nn.Module):
    method __init__ (line 7) | def __init__(
    method forward (line 43) | def forward(self, x):
  class LinearLayer (line 48) | class LinearLayer(nn.Module):
    method __init__ (line 50) | def __init__(
    method forward (line 68) | def forward(self, x):
  class Normalization (line 75) | class Normalization(nn.Module):
    method __init__ (line 77) | def __init__(self, ):
    method forward (line 87) | def forward(self, x):

FILE: models/archs/stylegan2/calc_inception.py
  class Inception3Feature (line 18) | class Inception3Feature(Inception3):
    method forward (line 19) | def forward(self, x):
  function load_patched_inception_v3 (line 51) | def load_patched_inception_v3():
  function extract_features (line 61) | def extract_features(loader, inception, device):

FILE: models/archs/stylegan2/convert_weight.py
  function convert_modconv (line 14) | def convert_modconv(vars, source_name, target_name, flip=False):
  function convert_conv (line 41) | def convert_conv(vars, source_name, target_name, bias=True, start=0):
  function convert_torgb (line 61) | def convert_torgb(vars, source_name, target_name):
  function convert_dense (line 82) | def convert_dense(vars, source_name, target_name):
  function update (line 96) | def update(state_dict, new):
  function discriminator_fill_statedict (line 108) | def discriminator_fill_statedict(statedict, vars, size):
  function fill_statedict (line 148) | def fill_statedict(state_dict, vars, size, n_mlp):

FILE: models/archs/stylegan2/dataset.py
  class MultiResolutionDataset (line 8) | class MultiResolutionDataset(Dataset):
    method __init__ (line 9) | def __init__(self, path, transform, resolution=256):
    method __len__ (line 28) | def __len__(self):
    method __getitem__ (line 31) | def __getitem__(self, index):

FILE: models/archs/stylegan2/distributed.py
  function get_rank (line 9) | def get_rank():
  function synchronize (line 19) | def synchronize():
  function get_world_size (line 34) | def get_world_size():
  function reduce_sum (line 44) | def reduce_sum(tensor):
  function gather_grad (line 57) | def gather_grad(params):
  function all_gather (line 69) | def all_gather(data):
  function reduce_loss_dict (line 104) | def reduce_loss_dict(loss_dict):

FILE: models/archs/stylegan2/fid.py
  function extract_feature_from_samples (line 15) | def extract_feature_from_samples(
  function calc_fid (line 34) | def calc_fid(sample_mean, sample_cov, real_mean, real_cov, eps=1e-6):

FILE: models/archs/stylegan2/generate.py
  function generate (line 14) | def generate(args, g_ema, device, mean_latent):

FILE: models/archs/stylegan2/inception.py
  class InceptionV3 (line 16) | class InceptionV3(nn.Module):
    method __init__ (line 31) | def __init__(self,
    method forward (line 129) | def forward(self, inp):
  function fid_inception_v3 (line 166) | def fid_inception_v3():
  class FIDInceptionA (line 193) | class FIDInceptionA(models.inception.InceptionA):
    method __init__ (line 195) | def __init__(self, in_channels, pool_features):
    method forward (line 198) | def forward(self, x):
  class FIDInceptionC (line 218) | class FIDInceptionC(models.inception.InceptionC):
    method __init__ (line 220) | def __init__(self, in_channels, channels_7x7):
    method forward (line 223) | def forward(self, x):
  class FIDInceptionE_1 (line 246) | class FIDInceptionE_1(models.inception.InceptionE):
    method __init__ (line 248) | def __init__(self, in_channels):
    method forward (line 251) | def forward(self, x):
  class FIDInceptionE_2 (line 279) | class FIDInceptionE_2(models.inception.InceptionE):
    method __init__ (line 281) | def __init__(self, in_channels):
    method forward (line 284) | def forward(self, x):

FILE: models/archs/stylegan2/inversion.py
  function noise_regularize (line 17) | def noise_regularize(noises):
  function noise_normalize_ (line 39) | def noise_normalize_(noises):
  function get_lr (line 47) | def get_lr(t, initial_lr, rampdown=0.25, rampup=0.05):
  function latent_noise (line 55) | def latent_noise(latent, strength):
  function make_image (line 61) | def make_image(tensor):

FILE: models/archs/stylegan2/lpips/__init__.py
  class PerceptualLoss (line 9) | class PerceptualLoss(torch.nn.Module):
    method __init__ (line 11) | def __init__(
    method forward (line 35) | def forward(self, pred, target, normalize=False):
  function normalize_tensor (line 52) | def normalize_tensor(in_feat, eps=1e-10):
  function l2 (line 57) | def l2(p0, p1, range=255.):
  function psnr (line 61) | def psnr(p0, p1, peak=255.):
  function dssim (line 65) | def dssim(p0, p1, range=255.):
  function rgb2lab (line 69) | def rgb2lab(in_img, mean_cent=False):
  function tensor2np (line 77) | def tensor2np(tensor_obj):
  function np2tensor (line 82) | def np2tensor(np_obj):
  function tensor2tensorlab (line 87) | def tensor2tensorlab(image_tensor, to_norm=True, mc_only=False):
  function tensorlab2tensor (line 102) | def tensorlab2tensor(lab_tensor, return_inbnd=False):
  function rgb2lab (line 122) | def rgb2lab(input):
  function tensor2im (line 127) | def tensor2im(image_tensor, imtype=np.uint8, cent=1., factor=255. / 2.):
  function im2tensor (line 133) | def im2tensor(image, imtype=np.uint8, cent=1., factor=255. / 2.):
  function tensor2vec (line 138) | def tensor2vec(vector_tensor):
  function voc_ap (line 142) | def voc_ap(rec, prec, use_07_metric=False):
  function tensor2im (line 176) | def tensor2im(image_tensor, imtype=np.uint8, cent=1., factor=255. / 2.):
  function im2tensor (line 183) | def im2tensor(image, imtype=np.uint8, cent=1., factor=255. / 2.):

FILE: models/archs/stylegan2/lpips/base_model.py
  class BaseModel (line 7) | class BaseModel():
    method __init__ (line 9) | def __init__(self):
    method name (line 12) | def name(self):
    method initialize (line 15) | def initialize(self, use_gpu=True, gpu_ids=[0]):
    method forward (line 19) | def forward(self):
    method get_image_paths (line 22) | def get_image_paths(self):
    method optimize_parameters (line 25) | def optimize_parameters(self):
    method get_current_visuals (line 28) | def get_current_visuals(self):
    method get_current_errors (line 31) | def get_current_errors(self):
    method save (line 34) | def save(self, label):
    method save_network (line 38) | def save_network(self, network, path, network_label, epoch_label):
    method load_network (line 44) | def load_network(self, network, network_label, epoch_label):
    method update_learning_rate (line 50) | def update_learning_rate():
    method get_image_paths (line 53) | def get_image_paths(self):
    method save_done (line 56) | def save_done(self, flag=False):

FILE: models/archs/stylegan2/lpips/dist_model.py
  class DistModel (line 17) | class DistModel(BaseModel):
    method name (line 19) | def name(self):
    method initialize (line 22) | def initialize(self,
    method forward (line 130) | def forward(self, in0, in1, retPerLayer=False):
    method optimize_parameters (line 141) | def optimize_parameters(self):
    method clamp_weights (line 148) | def clamp_weights(self):
    method set_input (line 153) | def set_input(self, data):
    method forward_train (line 169) | def forward_train(self):  # run forward pass
    method backward_train (line 184) | def backward_train(self):
    method compute_accuracy (line 187) | def compute_accuracy(self, d0, d1, judge):
    method get_current_errors (line 193) | def get_current_errors(self):
    method get_current_visuals (line 203) | def get_current_visuals(self):
    method save (line 217) | def save(self, path, label):
    method update_learning_rate (line 224) | def update_learning_rate(self, nepoch_decay):
  function score_2afc_dataset (line 235) | def score_2afc_dataset(data_loader, func, name=''):
  function score_jnd_dataset (line 273) | def score_jnd_dataset(data_loader, func, name=''):

FILE: models/archs/stylegan2/lpips/networks_basic.py
  function spatial_average (line 11) | def spatial_average(in_tens, keepdim=True):
  function upsample (line 15) | def upsample(in_tens, out_H=64):  # assumes scale factor is same for H a...
  class PNetLin (line 25) | class PNetLin(nn.Module):
    method __init__ (line 27) | def __init__(self,
    method forward (line 71) | def forward(self, in0, in1, retPerLayer=False):
  class ScalingLayer (line 121) | class ScalingLayer(nn.Module):
    method __init__ (line 123) | def __init__(self):
    method forward (line 132) | def forward(self, inp):
  class NetLinLayer (line 136) | class NetLinLayer(nn.Module):
    method __init__ (line 139) | def __init__(self, chn_in, chn_out=1, use_dropout=False):
  class Dist2LogitLayer (line 151) | class Dist2LogitLayer(nn.Module):
    method __init__ (line 154) | def __init__(self, chn_mid=32, use_sigmoid=True):
    method forward (line 178) | def forward(self, d0, d1, eps=0.1):
  class BCERankingLoss (line 184) | class BCERankingLoss(nn.Module):
    method __init__ (line 186) | def __init__(self, chn_mid=32):
    method forward (line 192) | def forward(self, d0, d1, judge):
  class FakeNet (line 199) | class FakeNet(nn.Module):
    method __init__ (line 201) | def __init__(self, use_gpu=True, colorspace='Lab'):
  class L2 (line 207) | class L2(FakeNet):
    method forward (line 209) | def forward(self, in0, in1, retPerLayer=None):
  class DSSIM (line 231) | class DSSIM(FakeNet):
    method forward (line 233) | def forward(self, in0, in1, retPerLayer=None):
  function print_network (line 252) | def print_network(net):

FILE: models/archs/stylegan2/lpips/pretrained_networks.py
  class squeezenet (line 7) | class squeezenet(torch.nn.Module):
    method __init__ (line 9) | def __init__(self, requires_grad=False, pretrained=True):
    method forward (line 38) | def forward(self, X):
  class alexnet (line 62) | class alexnet(torch.nn.Module):
    method __init__ (line 64) | def __init__(self, requires_grad=False, pretrained=True):
    method forward (line 88) | def forward(self, X):
  class vgg16 (line 106) | class vgg16(torch.nn.Module):
    method __init__ (line 108) | def __init__(self, requires_grad=False, pretrained=True):
    method forward (line 131) | def forward(self, X):
  class resnet (line 151) | class resnet(torch.nn.Module):
    method __init__ (line 153) | def __init__(self, requires_grad=False, pretrained=True, num=18):
    method forward (line 176) | def forward(self, X):

FILE: models/archs/stylegan2/model.py
  class PixelNorm (line 15) | class PixelNorm(nn.Module):
    method __init__ (line 17) | def __init__(self):
    method forward (line 20) | def forward(self, input):
  function make_kernel (line 25) | def make_kernel(k):
  class Upsample (line 36) | class Upsample(nn.Module):
    method __init__ (line 38) | def __init__(self, kernel, factor=2):
    method forward (line 52) | def forward(self, input):
  class Downsample (line 59) | class Downsample(nn.Module):
    method __init__ (line 61) | def __init__(self, kernel, factor=2):
    method forward (line 75) | def forward(self, input):
  class Blur (line 82) | class Blur(nn.Module):
    method __init__ (line 84) | def __init__(self, kernel, pad, upsample_factor=1):
    method forward (line 96) | def forward(self, input):
  class EqualConv2d (line 102) | class EqualConv2d(nn.Module):
    method __init__ (line 104) | def __init__(self,
    method forward (line 126) | def forward(self, input):
    method __repr__ (line 137) | def __repr__(self):
  class EqualLinear (line 144) | class EqualLinear(nn.Module):
    method __init__ (line 146) | def __init__(self,
    method forward (line 168) | def forward(self, input):
    method __repr__ (line 179) | def __repr__(self):
  class ModulatedConv2d (line 185) | class ModulatedConv2d(nn.Module):
    method __init__ (line 187) | def __init__(
    method __repr__ (line 235) | def __repr__(self):
    method forward (line 240) | def forward(self, input, style):
  class NoiseInjection (line 284) | class NoiseInjection(nn.Module):
    method __init__ (line 286) | def __init__(self):
    method forward (line 291) | def forward(self, image, noise=None):
  class ConstantInput (line 299) | class ConstantInput(nn.Module):
    method __init__ (line 301) | def __init__(self, channel, size=4):
    method forward (line 306) | def forward(self, input):
  class StyledConv (line 313) | class StyledConv(nn.Module):
    method __init__ (line 315) | def __init__(
    method forward (line 342) | def forward(self, input, style, noise=None):
  class ToRGB (line 351) | class ToRGB(nn.Module):
    method __init__ (line 353) | def __init__(self,
    method forward (line 367) | def forward(self, input, style, skip=None):
  class Generator (line 379) | class Generator(nn.Module):
    method __init__ (line 381) | def __init__(
    method make_noise (line 473) | def make_noise(self):
    method mean_latent (line 484) | def mean_latent(self, n_latent):
    method get_latent (line 491) | def get_latent(self, input):
    method style_forward (line 497) | def style_forward(self, input, skip_norm=False):
    method forward (line 505) | def forward(
  class ConvLayer (line 580) | class ConvLayer(nn.Sequential):
    method __init__ (line 582) | def __init__(
  class ResBlock (line 625) | class ResBlock(nn.Module):
    method __init__ (line 627) | def __init__(self, in_channel, out_channel, blur_kernel=[1, 3, 3, 1]):
    method forward (line 641) | def forward(self, input):
  class Discriminator (line 651) | class Discriminator(nn.Module):
    method __init__ (line 653) | def __init__(self, size, channel_multiplier=2, blur_kernel=[1, 3, 3, 1]):
    method forward (line 693) | def forward(self, input):

FILE: models/archs/stylegan2/non_leaking.py
  class AdaptiveAugment (line 10) | class AdaptiveAugment:
    method __init__ (line 11) | def __init__(self, ada_aug_target, ada_aug_len, update_every, device):
    method tune (line 21) | def tune(self, real_pred):
  function translate_mat (line 62) | def translate_mat(t_x, t_y):
  function rotate_mat (line 72) | def rotate_mat(theta):
  function scale_mat (line 84) | def scale_mat(s_x, s_y):
  function translate3d_mat (line 94) | def translate3d_mat(t_x, t_y, t_z):
  function rotate3d_mat (line 104) | def rotate3d_mat(axis, theta):
  function scale3d_mat (line 125) | def scale3d_mat(s_x, s_y, s_z):
  function luma_flip_mat (line 136) | def luma_flip_mat(axis, i):
  function saturation_mat (line 146) | def saturation_mat(axis, i):
  function lognormal_sample (line 157) | def lognormal_sample(size, mean=0, std=1):
  function category_sample (line 161) | def category_sample(size, categories):
  function uniform_sample (line 168) | def uniform_sample(size, low, high):
  function normal_sample (line 172) | def normal_sample(size, mean=0, std=1):
  function bernoulli_sample (line 176) | def bernoulli_sample(size, p):
  function random_mat_apply (line 180) | def random_mat_apply(p, transform, prev, eye):
  function sample_affine (line 188) | def sample_affine(p, size, height, width):
  function sample_color (line 247) | def sample_color(p, size):
  function make_grid (line 281) | def make_grid(shape, x0, x1, y0, y1, device):
  function affine_grid (line 291) | def affine_grid(grid, mat):
  function get_padding (line 296) | def get_padding(G, height, width):
  function try_sample_affine_and_pad (line 325) | def try_sample_affine_and_pad(img, p, pad_k, G=None):
  function random_apply_affine (line 353) | def random_apply_affine(img, p, G=None, antialiasing_kernel=SYM6):
  function apply_color (line 411) | def apply_color(img, mat):
  function random_apply_color (line 422) | def random_apply_color(img, p, C=None):
  function augment (line 431) | def augment(img, p, transform_matrix=(None, None)):

FILE: models/archs/stylegan2/op/fused_act.py
  class FusedLeakyReLUFunctionBackward (line 20) | class FusedLeakyReLUFunctionBackward(Function):
    method forward (line 22) | def forward(ctx, grad_output, out, bias, negative_slope, scale):
    method backward (line 47) | def backward(ctx, gradgrad_input, gradgrad_bias):
  class FusedLeakyReLUFunction (line 56) | class FusedLeakyReLUFunction(Function):
    method forward (line 58) | def forward(ctx, input, bias, negative_slope, scale):
    method backward (line 74) | def backward(ctx, grad_output):
  class FusedLeakyReLU (line 87) | class FusedLeakyReLU(nn.Module):
    method __init__ (line 88) | def __init__(self, channel, bias=True, negative_slope=0.2, scale=2 ** ...
    method forward (line 100) | def forward(self, input):
  function fused_leaky_relu (line 104) | def fused_leaky_relu(input, bias=None, negative_slope=0.2, scale=2 ** 0.5):

FILE: models/archs/stylegan2/op/fused_bias_act.cpp
  function fused_bias_act (line 11) | torch::Tensor fused_bias_act(const torch::Tensor& input, const torch::Te...
  function PYBIND11_MODULE (line 19) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: models/archs/stylegan2/op/upfirdn2d.cpp
  function upfirdn2d (line 12) | torch::Tensor upfirdn2d(const torch::Tensor& input, const torch::Tensor&...
  function PYBIND11_MODULE (line 21) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: models/archs/stylegan2/op/upfirdn2d.py
  class UpFirDn2dBackward (line 19) | class UpFirDn2dBackward(Function):
    method forward (line 21) | def forward(
    method backward (line 63) | def backward(ctx, gradgrad_input):
  class UpFirDn2d (line 88) | class UpFirDn2d(Function):
    method forward (line 90) | def forward(ctx, input, kernel, up, down, pad):
    method backward (line 127) | def backward(ctx, grad_output):
  function upfirdn2d (line 145) | def upfirdn2d(input, kernel, up=1, down=1, pad=(0, 0)):
  function upfirdn2d_native (line 159) | def upfirdn2d_native(

FILE: models/archs/stylegan2/ppl.py
  function normalize (line 12) | def normalize(x):
  function slerp (line 16) | def slerp(a, b, t):
  function lerp (line 27) | def lerp(a, b, t):

FILE: models/archs/stylegan2/train.py
  function data_sampler (line 33) | def data_sampler(dataset, shuffle, distributed):
  function requires_grad (line 44) | def requires_grad(model, flag=True):
  function accumulate (line 49) | def accumulate(model1, model2, decay=0.999):
  function sample_data (line 57) | def sample_data(loader):
  function d_logistic_loss (line 63) | def d_logistic_loss(real_pred, fake_pred):
  function d_r1_loss (line 70) | def d_r1_loss(real_pred, real_img):
  function g_nonsaturating_loss (line 79) | def g_nonsaturating_loss(fake_pred):
  function g_path_regularize (line 85) | def g_path_regularize(fake_img, latents, mean_path_length, decay=0.01):
  function make_noise (line 101) | def make_noise(batch, latent_dim, n_noise, device):
  function mixing_noise (line 110) | def mixing_noise(batch, latent_dim, prob, device):
  function set_grad_none (line 118) | def set_grad_none(model, targets):
  function train (line 124) | def train(args, loader, generator, discriminator, g_optim, d_optim, g_em...

FILE: models/base_model.py
  class BaseModel (line 22) | class BaseModel():
    method __init__ (line 26) | def __init__(self, opt):
    method init_training_settings (line 89) | def init_training_settings(self):
    method feed_data (line 114) | def feed_data(self, data):
    method optimize_parameters (line 121) | def optimize_parameters(self):
    method get_current_log (line 174) | def get_current_log(self):
    method update_learning_rate (line 177) | def update_learning_rate(self, epoch):
    method save_network (line 214) | def save_network(self, net, save_path):
    method load_network (line 225) | def load_network(self, pretrained_field):
    method synthesize_image (line 231) | def synthesize_image(self, sample_latent_code):
    method synthesize_and_predict (line 241) | def synthesize_and_predict(self, sample_latent_code):
    method inference (line 251) | def inference(self, batch_idx, epoch, save_dir):
    method continuous_editing (line 285) | def continuous_editing(self, latent_codes, save_dir, editing_logger):
    method continuous_editing_with_target (line 423) | def continuous_editing_with_target(self,

FILE: models/field_function_model.py
  class FieldFunctionModel (line 10) | class FieldFunctionModel(BaseModel):
    method __init__ (line 12) | def __init__(self, opt):
    method modify_latent_code (line 17) | def modify_latent_code(self, latent_code_w, latent_code_w_plus=None):
    method modify_latent_code_bidirection (line 42) | def modify_latent_code_bidirection(self,

FILE: models/losses/arcface_loss.py
  function conv3x3 (line 6) | def conv3x3(in_planes, out_planes, stride=1):
  class BasicBlock (line 17) | class BasicBlock(nn.Module):
    method __init__ (line 20) | def __init__(self, inplanes, planes, stride=1, downsample=None):
    method forward (line 30) | def forward(self, x):
  class IRBlock (line 49) | class IRBlock(nn.Module):
    method __init__ (line 52) | def __init__(self,
    method forward (line 71) | def forward(self, x):
  class Bottleneck (line 92) | class Bottleneck(nn.Module):
    method __init__ (line 95) | def __init__(self, inplanes, planes, stride=1, downsample=None):
    method forward (line 114) | def forward(self, x):
  class SEBlock (line 137) | class SEBlock(nn.Module):
    method __init__ (line 139) | def __init__(self, channel, reduction=16):
    method forward (line 146) | def forward(self, x):
  class ResNetFace (line 153) | class ResNetFace(nn.Module):
    method __init__ (line 155) | def __init__(self, block, layers, use_se=True):
    method _make_layer (line 183) | def _make_layer(self, block, planes, blocks, stride=1):
    method forward (line 205) | def forward(self, x):
  function resnet_face18 (line 224) | def resnet_face18(use_se=True, **kwargs):
  class ArcFaceLoss (line 229) | class ArcFaceLoss(nn.Module):
    method __init__ (line 231) | def __init__(self, pretrained_model, loss_type, use_se=False):
    method forward (line 250) | def forward(self, original_imgs, edited_imgs, resize=False):

FILE: models/losses/discriminator_loss.py
  class DiscriminatorLoss (line 7) | class DiscriminatorLoss(nn.Module):
    method __init__ (line 9) | def __init__(self, pretrained_model, img_res):
    method forward (line 24) | def forward(self, generated_images):

FILE: models/utils.py
  function postprocess (line 9) | def postprocess(images, channel_order='BGR', min_val=-1.0, max_val=1.0):
  function transform_image (line 46) | def transform_image(image, resize=False):
  function set_random_seed (line 65) | def set_random_seed(seed):
  function output_to_label (line 74) | def output_to_label(output):
  function predictor_to_label (line 101) | def predictor_to_label(predictor_output):
  function save_image (line 119) | def save_image(img, save_path, need_post_process=True):

FILE: quantitative_results.py
  function parse_args (line 21) | def parse_args():
  function get_edited_images_list (line 51) | def get_edited_images_list(img_dir, img_idx):
  function load_face_image (line 69) | def load_face_image(img_path):
  function load_image_predictor (line 83) | def load_image_predictor(img_path,
  function predictor_score (line 98) | def predictor_score(predictor_output, gt_label, target_attr_idx,
  function compute_num_metrics (line 117) | def compute_num_metrics(image_dir, image_num, target_attr_idx, logger):
  function main (line 185) | def main():

FILE: train.py
  function main (line 19) | def main():

FILE: utils/crop_img.py
  function crop_img (line 27) | def crop_img(img_size, input_img_path, cropped_output_path, device='cuda'):
  function crop_img_128 (line 36) | def crop_img_128(input_img_path, cropped_output_path, device='cuda'):
  function get_landmark (line 68) | def get_landmark(filepath):
  function crop_img_1024 (line 98) | def crop_img_1024(input_img_path, cropped_output_path):

FILE: utils/dialog_edit_utils.py
  function dialog_with_real_user (line 13) | def dialog_with_real_user(field_model,
  function decide_next_state (line 165) | def decide_next_state(state, system_mode, user_mode):
  function decide_next_edit (line 243) | def decide_next_edit(edit_log, system_labels, user_labels, state,
  function decide_next_feedback (line 360) | def decide_next_feedback(system_labels, user_labels, state, edit_labels,

FILE: utils/editing_utils.py
  function edit_target_attribute (line 1) | def edit_target_attribute(opt,

FILE: utils/inversion_utils.py
  function noise_regularize (line 15) | def noise_regularize(noises):
  function noise_normalize_ (line 37) | def noise_normalize_(noises):
  function get_lr (line 45) | def get_lr(t, initial_lr, rampdown=0.25, rampup=0.05):
  function latent_noise (line 53) | def latent_noise(latent, strength):
  function make_image (line 59) | def make_image(tensor):
  function inversion (line 64) | def inversion(opt, field_model):

FILE: utils/logger.py
  class MessageLogger (line 6) | class MessageLogger():
    method __init__ (line 19) | def __init__(self, opt, start_iter=1, tb_logger=None):
    method __call__ (line 29) | def __call__(self, log_vars):
  function init_tb_logger (line 74) | def init_tb_logger(log_dir):
  function get_root_logger (line 80) | def get_root_logger(logger_name='base', log_level=logging.INFO, log_file...

FILE: utils/numerical_metrics.py
  function parse_args (line 16) | def parse_args():
  function get_edited_images_list (line 69) | def get_edited_images_list(img_dir, img_idx):
  function load_image_predictor (line 87) | def load_image_predictor(img_path,
  function load_image_arcface (line 106) | def load_image_arcface(img_path):
  function cosin_metric (line 125) | def cosin_metric(x1, x2):
  function predictor_score (line 129) | def predictor_score(predictor_output, gt_label, target_attr_idx,
  function compute_num_metrics (line 148) | def compute_num_metrics(image_dir, image_num, pretrained_arcface, attr_f...

FILE: utils/options.py
  function ordered_yaml (line 8) | def ordered_yaml():
  function parse (line 33) | def parse(opt_path, is_train=True):
  function dict2str (line 116) | def dict2str(opt, indent_level=1):
  class NoneDict (line 137) | class NoneDict(dict):
    method __missing__ (line 140) | def __missing__(self, key):
  function dict_to_nonedict (line 144) | def dict_to_nonedict(opt):
  function parse_args_from_opt (line 164) | def parse_args_from_opt(args, opt):
  function parse_opt_wrt_resolution (line 178) | def parse_opt_wrt_resolution(opt):

FILE: utils/util.py
  function make_exp_dirs (line 14) | def make_exp_dirs(opt):
  function set_random_seed (line 25) | def set_random_seed(seed):
  class ProgressBar (line 34) | class ProgressBar(object):
    method __init__ (line 41) | def __init__(self, task_num=0, bar_width=50, start=True):
    method _get_max_bar_width (line 50) | def _get_max_bar_width(self):
    method start (line 60) | def start(self):
    method update (line 69) | def update(self, msg='In progress...'):