SYMBOL INDEX (462 symbols across 63 files)

FILE: 2d_mix/config.py
  function get_models (line 8) | def get_models(model_type, conditioning, k_value, d_act_dim, device):
  function get_optimizers (line 20) | def get_optimizers(generator, discriminator, lr=1e-4, beta1=0.8, beta2=0...
  function get_test (line 30) | def get_test(get_data, batch_size, variance, k_value, device):
  function get_dataset (line 37) | def get_dataset(get_data, batch_size, npts, variance, k_value):

FILE: 2d_mix/evaluation.py
  function warn (line 1) | def warn(*args, **kwargs):
  function percent_good_grid (line 11) | def percent_good_grid(x_fake, var=0.0025, nrows=5, ncols=5):
  function percent_good_ring (line 24) | def percent_good_ring(x_fake, var=0.0001, n_clusters=8, radius=2.0):
  function percent_good_pts (line 35) | def percent_good_pts(x_fake, means, threshold):

FILE: 2d_mix/inputs.py
  function map_labels (line 6) | def map_labels(labels):
  function get_data_ring (line 10) | def get_data_ring(batch_size, radius=2.0, var=0.0001, n_clusters=8):
  function get_data_grid (line 25) | def get_data_grid(batch_size, radius=2.0, var=0.0025, nrows=5, ncols=5):

FILE: 2d_mix/models/cluster.py
  class G (line 13) | class G(nn.Module):
    method __init__ (line 14) | def __init__(self,
    method forward (line 41) | def forward(self, z, y=None):
  class D (line 50) | class D(nn.Module):
    class Maxout (line 51) | class Maxout(nn.Module):
      method __init__ (line 53) | def __init__(self, d_in, d_out, pool_size=5):
      method forward (line 58) | def forward(self, inputs):
    method max (line 67) | def max(self, out, dim=5):
    method __init__ (line 70) | def __init__(self, conditioning, k_value, act_dim=200, x_dim=2):
    method forward (line 83) | def forward(self, x, y=None, get_features=False):

FILE: 2d_mix/train.py
  function main (line 66) | def main(outdir):

FILE: 2d_mix/visualizations.py
  function visualize_generated (line 40) | def visualize_generated(fake, real, y, it, outdir):
  function visualize_clusters (line 63) | def visualize_clusters(x, y, it, outdir):

FILE: cluster_metrics.py
  function main (line 28) | def main():

FILE: clusterers/base_clusterer.py
  class BaseClusterer (line 6) | class BaseClusterer():
    method __init__ (line 7) | def __init__(self,
    method get_labels (line 23) | def get_labels(self, x, y):
    method recluster (line 26) | def recluster(self, discriminator, **kwargs):
    method get_features (line 29) | def get_features(self, x):
    method get_cluster_batch_features (line 33) | def get_cluster_batch_features(self):
    method get_discriminator_output (line 47) | def get_discriminator_output(self, x):
    method get_label_distribution (line 53) | def get_label_distribution(self, x=None):
    method sample_y (line 61) | def sample_y(self, batch_size):
    method print_label_distribution (line 69) | def print_label_distribution(self, x=None):

FILE: clusterers/kmeans.py
  class Clusterer (line 7) | class Clusterer(base_clusterer.BaseClusterer):
    method __init__ (line 8) | def __init__(self, **kwargs):
    method kmeans_fit_predict (line 12) | def kmeans_fit_predict(self, features, init='k-means++', n_init=10):
    method get_labels (line 19) | def get_labels(self, x, y):

FILE: clusterers/online.py
  class Clusterer (line 9) | class Clusterer(kmeans.Clusterer):
    method __init__ (line 10) | def __init__(self, **kwargs):
    method get_initialization (line 14) | def get_initialization(self, features, labels):
    method recluster (line 32) | def recluster(self, discriminator, x_batch=None, **kwargs):

FILE: clusterers/random_labels.py
  class Clusterer (line 5) | class Clusterer(base_clusterer.BaseClusterer):
    method __init__ (line 6) | def __init__(self, **kwargs):
    method get_labels (line 9) | def get_labels(self, x, y):

FILE: clusterers/selfcondgan.py
  class Clusterer (line 10) | class Clusterer(kmeans.Clusterer):
    method __init__ (line 11) | def __init__(self, initialization=True, matching=True, **kwargs):
    method get_initialization (line 17) | def get_initialization(self, features, labels):
    method fit_means (line 35) | def fit_means(self):
    method recluster (line 57) | def recluster(self, discriminator, **kwargs):
    method hungarian_match (line 61) | def hungarian_match(self, flat_preds, flat_targets, preds_k, targets_k):

FILE: gan_training/checkpoints.py
  class CheckpointIO (line 8) | class CheckpointIO(object):
    method __init__ (line 17) | def __init__(self, checkpoint_dir='./chkpts', **kwargs):
    method register_modules (line 23) | def register_modules(self, **kwargs):
    method save (line 28) | def save(self, filename, **kwargs):
    method load (line 42) | def load(self, filename, pretrained={}):
    method load_file (line 55) | def load_file(self, filename):
    method load_url (line 74) | def load_url(self, url):
    method parse_state_dict (line 85) | def parse_state_dict(self, state_dict):
    method load_clusterer (line 102) | def load_clusterer(self, it, load_samples, pretrained={}):
    method load_models (line 129) | def load_models(self, it, pretrained={}, load_samples=False):
    method save_clusterer (line 153) | def save_clusterer(self, clusterer, it):
  function is_url (line 161) | def is_url(url):

FILE: gan_training/config.py
  function load_config (line 10) | def load_config(path, default_path):
  function update_recursive (line 40) | def update_recursive(dict1, dict2):
  function get_clusterer (line 59) | def get_clusterer(config):
  function build_models (line 63) | def build_models(config):
  function build_optimizers (line 83) | def build_optimizers(generator, discriminator, config):
  function get_parameter_groups (line 111) | def get_parameter_groups(parameters, gradient_scales, base_lr):

FILE: gan_training/distributions.py
  function get_zdist (line 5) | def get_zdist(dist_name, dim, device=None):
  function get_ydist (line 24) | def get_ydist(nlabels, device=None):
  function interpolate_sphere (line 34) | def interpolate_sphere(z1, z2, t):

FILE: gan_training/eval.py
  class Evaluator (line 7) | class Evaluator(object):
    method __init__ (line 8) | def __init__(self,
    method sample_z (line 26) | def sample_z(self, batch_size):
    method get_y (line 29) | def get_y(self, x, y):
    method get_fake_real_samples (line 32) | def get_fake_real_samples(self, N):
    method compute_inception_score (line 54) | def compute_inception_score(self):
    method create_samples (line 64) | def create_samples(self, z, y=None):

FILE: gan_training/inputs.py
  function get_dataset (line 15) | def get_dataset(name,
  class CachedImageFolder (line 75) | class CachedImageFolder(data.Dataset):
    method __init__ (line 84) | def __init__(self, root, transform=None, loader=default_loader):
    method __getitem__ (line 95) | def __getitem__(self, index):
    method __len__ (line 102) | def __len__(self):
  class StackedMNIST (line 105) | class StackedMNIST(data.Dataset):
    method __init__ (line 106) | def __init__(self, data_dir, transform, batch_size=100000):
    method __getitem__ (line 130) | def __getitem__(self, index):
    method __len__ (line 137) | def __len__(self):
  function is_npy_file (line 141) | def is_npy_file(path):
  function walk_image_files (line 145) | def walk_image_files(rootdir):
  function find_classes (line 181) | def find_classes(dir):
  function make_class_dataset (line 190) | def make_class_dataset(source_root, class_to_idx):
  function npy_loader (line 202) | def npy_loader(path):

FILE: gan_training/logger.py
  class Logger (line 7) | class Logger(object):
    method __init__ (line 8) | def __init__(self,
    method setup_monitoring (line 29) | def setup_monitoring(self, monitoring, monitoring_dir=None):
    method add (line 45) | def add(self, category, k, v, it):
    method add_imgs (line 60) | def add_imgs(self, imgs, class_name, it):
    method get_last (line 73) | def get_last(self, category, k, default=0.):
    method save_stats (line 81) | def save_stats(self, filename):
    method load_stats (line 86) | def load_stats(self, filename):

FILE: gan_training/metrics/clustering_metrics.py
  function warn (line 1) | def warn(*args, **kwargs):
  function nmi (line 14) | def nmi(inferred, gt):
  function acc (line 18) | def acc(inferred, gt):
  function purity_score (line 30) | def purity_score(y_true, y_pred):
  function ari (line 36) | def ari(inferred, gt):
  function homogeneity (line 40) | def homogeneity(inferred, gt):

FILE: gan_training/metrics/fid.py
  function check_or_download_inception (line 13) | def check_or_download_inception(inception_path):
  function create_inception_graph (line 31) | def create_inception_graph(pth):
  function calculate_activation_statistics (line 40) | def calculate_activation_statistics(images,
  function _get_inception_layer (line 67) | def _get_inception_layer(sess):
  function get_activations (line 90) | def get_activations(images, sess, batch_size=200, verbose=False):
  function calculate_frechet_distance (line 137) | def calculate_frechet_distance(mu1, sigma1, mu2, sigma2, eps=1e-6):
  function compute_fid_from_npz (line 190) | def compute_fid_from_npz(path):
  function compute_fid_from_imgs (line 231) | def compute_fid_from_imgs(fake_imgs, real_imgs):
  function compute_stats (line 244) | def compute_stats(exp_path):

FILE: gan_training/metrics/inception_score.py
  function inception_score (line 12) | def inception_score(imgs, device=None, batch_size=32, resize=False, spli...

FILE: gan_training/metrics/tf_is/inception_score.py
  function inception_logits (line 33) | def inception_logits(images = inception_images, num_splits = 1):
  function get_inception_probs (line 57) | def get_inception_probs(inps):
  function preds2score (line 66) | def preds2score(preds, splits=10):
  function get_inception_score (line 75) | def get_inception_score(images, splits=10):
  function compute_is_from_npz (line 87) | def compute_is_from_npz(path):

FILE: gan_training/models/blocks.py
  class ResnetBlock (line 7) | class ResnetBlock(nn.Module):
    method __init__ (line 8) | def __init__(self,
    method forward (line 43) | def forward(self, x, y):
    method _shortcut (line 51) | def _shortcut(self, x):
  function actvn (line 59) | def actvn(x):
  class LatentEmbeddingConcat (line 64) | class LatentEmbeddingConcat(nn.Module):
    method __init__ (line 67) | def __init__(self, nlabels, embed_dim):
    method forward (line 71) | def forward(self, z, y):
  class NormalizeLinear (line 79) | class NormalizeLinear(nn.Module):
    method __init__ (line 80) | def __init__(self, act_dim, k_value):
    method normalize (line 84) | def normalize(self):
    method forward (line 87) | def forward(self, x):
  class Identity (line 92) | class Identity(nn.Module):
    method __init__ (line 93) | def __init__(self, *args, **kwargs):
    method forward (line 96) | def forward(self, inp, *args, **kwargs):
  class LinearConditionalMaskLogits (line 100) | class LinearConditionalMaskLogits(nn.Module):
    method __init__ (line 103) | def __init__(self, nc, nlabels):
    method forward (line 107) | def forward(self, inp, y=None, take_best=False, get_features=False):
  class ProjectionDiscriminatorLogits (line 123) | class ProjectionDiscriminatorLogits(nn.Module):
    method __init__ (line 126) | def __init__(self, nc, nlabels):
    method forward (line 132) | def forward(self, x, y, take_best=False):
  class LinearUnconditionalLogits (line 152) | class LinearUnconditionalLogits(nn.Module):
    method __init__ (line 155) | def __init__(self, nc):
    method forward (line 159) | def forward(self, inp, y, take_best=False):
  class Reshape (line 166) | class Reshape(nn.Module):
    method __init__ (line 167) | def __init__(self, *shape):
    method forward (line 171) | def forward(self, x):
  class ConditionalBatchNorm2d (line 176) | class ConditionalBatchNorm2d(nn.Module):
    method __init__ (line 179) | def __init__(self, num_features, num_classes):
    method forward (line 189) | def forward(self, x, y):
  class BatchNorm2d (line 197) | class BatchNorm2d(nn.Module):
    method __init__ (line 200) | def __init__(self, nc, nchannels, **kwargs):
    method forward (line 204) | def forward(self, x, y):

FILE: gan_training/models/dcgan_deep.py
  class Generator (line 9) | class Generator(nn.Module):
    method __init__ (line 10) | def __init__(self,
    method forward (line 47) | def forward(self, input, y):
  class Discriminator (line 59) | class Discriminator(nn.Module):
    method __init__ (line 60) | def __init__(self,
    method stack (line 97) | def stack(self, x):
    method forward (line 109) | def forward(self, input, y=None, get_features=False):

FILE: gan_training/models/dcgan_shallow.py
  class Generator (line 9) | class Generator(nn.Module):
    method __init__ (line 10) | def __init__(self,
    method forward (line 47) | def forward(self, input, y):
  class Discriminator (line 60) | class Discriminator(nn.Module):
    method __init__ (line 61) | def __init__(self,
    method stack (line 100) | def stack(self, x):
    method forward (line 111) | def forward(self, input, y=None, get_features=False):

FILE: gan_training/models/resnet2.py
  class Generator (line 13) | class Generator(nn.Module):
    method __init__ (line 14) | def __init__(self,
    method forward (line 63) | def forward(self, z, y):
  class Discriminator (line 100) | class Discriminator(nn.Module):
    method __init__ (line 101) | def __init__(self,
    method forward (line 147) | def forward(self, x, y=None, get_features=False):
  function actvn (line 184) | def actvn(x):

FILE: gan_training/models/resnet2s.py
  class Reshape (line 10) | class Reshape(nn.Module):
    method __init__ (line 11) | def __init__(self, *shape):
    method forward (line 15) | def forward(self, x):
  class Generator (line 20) | class Generator(nn.Module):
    method __init__ (line 27) | def __init__(self,
    method forward (line 71) | def forward(self, z, y=None):
    method load_v2_state_dict (line 79) | def load_v2_state_dict(self, state_dict):
  class ConditionGen (line 93) | class ConditionGen(nn.Module):
    method __init__ (line 94) | def __init__(self, z_dim, nlabels, embed_size=256):
    method forward (line 102) | def forward(self, z, y):
  function convert_from_resnet2_generator (line 113) | def convert_from_resnet2_generator(gen):
  class ResnetBlock (line 133) | class ResnetBlock(nn.Module):
    method __init__ (line 134) | def __init__(self, fin, fout, fhidden=None, is_bias=True):
    method forward (line 166) | def forward(self, x):
    method _shortcut (line 174) | def _shortcut(self, x):
  function actvn (line 182) | def actvn(x):

FILE: gan_training/models/resnet3.py
  class Generator (line 9) | class Generator(nn.Module):
    method __init__ (line 15) | def __init__(self, z_dim, nlabels, size, embed_size=256, nfilter=64,
    method forward (line 55) | def forward(self, z, y=None):
    method load_v2_state_dict (line 63) | def load_v2_state_dict(self, state_dict):
  class Reshape (line 75) | class Reshape(nn.Module):
    method __init__ (line 76) | def __init__(self, *shape):
    method forward (line 79) | def forward(self, x):
  class ConditionGen (line 83) | class ConditionGen(nn.Module):
    method __init__ (line 84) | def __init__(self, z_dim, nlabels, embed_size=256):
    method forward (line 92) | def forward(self, z, y):
  function convert_from_resnet2_generator (line 102) | def convert_from_resnet2_generator(gen):
  class ResnetBlock (line 121) | class ResnetBlock(nn.Module):
    method __init__ (line 122) | def __init__(self, fin, fout, fhidden=None, is_bias=True):
    method forward (line 143) | def forward(self, x):
    method _shortcut (line 151) | def _shortcut(self, x):
  function actvn (line 159) | def actvn(x):

FILE: gan_training/train.py
  class Trainer (line 10) | class Trainer(object):
    method __init__ (line 11) | def __init__(self,
    method generator_trainstep (line 30) | def generator_trainstep(self, y, z):
    method discriminator_trainstep (line 48) | def discriminator_trainstep(self, x_real, y, z):
    method compute_loss (line 99) | def compute_loss(self, d_out, target):
    method wgan_gp_reg (line 111) | def wgan_gp_reg(self, x_real, x_fake, y, center=1.):
  function toggle_grad (line 125) | def toggle_grad(model, requires_grad):
  function compute_grad2 (line 130) | def compute_grad2(d_out, x_in):
  function update_average (line 143) | def update_average(model_tgt, model_src, beta):

FILE: gan_training/utils.py
  function save_images (line 9) | def save_images(imgs, outfile, nrow=8):
  function get_nsamples (line 14) | def get_nsamples(data_loader, N):
  function update_average (line 29) | def update_average(model_tgt, model_src, beta):
  function get_most_recent (line 38) | def get_most_recent(d, ext):

FILE: metrics.py
  function load_results (line 37) | def load_results(results_dir):
  function get_dataset_from_path (line 49) | def get_dataset_from_path(path):
  function pt_to_np (line 56) | def pt_to_np(imgs):
  function sample (line 61) | def sample(sampler):

FILE: seeded_sampler.py
  function get_most_recent (line 16) | def get_most_recent(models):
  class SeededSampler (line 24) | class SeededSampler():
    method __init__ (line 25) | def __init__(
    method sample (line 45) | def sample(self, nimgs):
    method conditional_sample (line 59) | def conditional_sample(self, yi, seed=None):
    method sample_with_seed (line 71) | def sample_with_seed(self, seeds):
    method get_zy (line 77) | def get_zy(self, seeds):
    method sample_with_zy (line 81) | def sample_with_zy(self, z, y):
    method get_generator (line 86) | def get_generator(self):
    method get_yz_dist (line 123) | def get_yz_dist(self):

FILE: seeing/frechet_distance.py
  function sample_frechet_distance (line 25) | def sample_frechet_distance(sample1, sample2, eps=1e-6,
  function calculate_frechet_distance (line 36) | def calculate_frechet_distance(mu1, sigma1, mu2, sigma2, eps=1e-6,
  function calculate_activation_statistics (line 98) | def calculate_activation_statistics(act):

FILE: seeing/fsd.py
  function main (line 11) | def main():
  function cached_tally_directory (line 68) | def cached_tally_directory(directory, size=10000, cachedir=None, seed=1):
  function tally_directory (line 83) | def tally_directory(directory, size=10000, seed=1):
  function tally_dataset_objects (line 127) | def tally_dataset_objects(dataset, size=10000):
  function tally_generated_objects (line 152) | def tally_generated_objects(model, size=10000):
  function diff_figure (line 176) | def diff_figure(ttally,

FILE: seeing/parallelfolder.py
  function grayscale_loader (line 14) | def grayscale_loader(path):
  class ndarray (line 18) | class ndarray(numpy.ndarray):
  function default_loader (line 25) | def default_loader(filename):
  class ParallelImageFolders (line 36) | class ParallelImageFolders(data.Dataset):
    method __init__ (line 48) | def __init__(self, image_roots,
    method __getattr__ (line 85) | def __getattr__(self, attr):
    method __getitem__ (line 91) | def __getitem__(self, index):
    method __len__ (line 121) | def __len__(self):
  function is_npy_file (line 126) | def is_npy_file(path):
  function is_image_file (line 129) | def is_image_file(path):
  function walk_image_files (line 132) | def walk_image_files(rootdir, verbose=None):
  function make_parallel_dataset (line 148) | def make_parallel_dataset(image_roots, classification=False,

FILE: seeing/pbar.py
  function post (line 17) | def post(**kwargs):
  function desc (line 27) | def desc(desc):
  function descnext (line 36) | def descnext(desc):
  function print (line 46) | def print(*args):
  function tqdm_terminal (line 59) | def tqdm_terminal(it, *args, **kwargs):
  function in_notebook (line 66) | def in_notebook():
  function innermost_tqdm (line 82) | def innermost_tqdm():
  function reporthook (line 91) | def reporthook(*args, **kwargs):
  function __call__ (line 117) | def __call__(x, *args, **kwargs):
  class VerboseContextManager (line 141) | class VerboseContextManager():
    method __init__ (line 142) | def __init__(self, v, entered=False):
    method __enter__ (line 147) | def __enter__(self):
    method __exit__ (line 155) | def __exit__(self, exc_type, exc_value, exc_traceback):
    method __call__ (line 158) | def __call__(self, v=True):
  class CallableModule (line 177) | class CallableModule(types.ModuleType):
    method __init__ (line 178) | def __init__(self):
    method __call__ (line 182) | def __call__(self, x, *args, **kwargs):

FILE: seeing/pidfile.py
  function exit_if_job_done (line 8) | def exit_if_job_done(directory, redo=False, force=False, verbose=True):
  function mark_job_done (line 25) | def mark_job_done(directory):
  function pidfile_taken (line 32) | def pidfile_taken(path, verbose=False, force=False):
  function delete_pidfile (line 83) | def delete_pidfile(lockfile, path):

FILE: seeing/sampler.py
  class FixedSubsetSampler (line 19) | class FixedSubsetSampler(Sampler):
    method __init__ (line 23) | def __init__(self, samples):
    method __iter__ (line 26) | def __iter__(self):
    method __len__ (line 29) | def __len__(self):
    method __getitem__ (line 32) | def __getitem__(self, key):
    method subset (line 35) | def subset(self, new_subset):
    method dereference (line 38) | def dereference(self, indices):
  class FixedRandomSubsetSampler (line 46) | class FixedRandomSubsetSampler(FixedSubsetSampler):
    method __init__ (line 53) | def __init__(self, data_source, start=None, end=None, seed=1):
    method class_subset (line 60) | def class_subset(self, class_filter):
  function coordinate_sample (line 71) | def coordinate_sample(shape, sample_size, seeds, grid=13, seed=1, flat=F...
  function main (line 104) | def main():
  function test (line 139) | def test():

FILE: seeing/segmenter.py
  class BaseSegmenter (line 9) | class BaseSegmenter:
    method get_label_and_category_names (line 10) | def get_label_and_category_names(self):
    method segment_batch (line 21) | def segment_batch(self, tensor_images, downsample=1):
  class UnifiedParsingSegmenter (line 34) | class UnifiedParsingSegmenter(BaseSegmenter):
    method __init__ (line 44) | def __init__(self, segsizes=None):
    method get_label_and_category_names (line 92) | def get_label_and_category_names(self, dataset=None):
    method raw_seg_prediction (line 114) | def raw_seg_prediction(self, tensor_images, downsample=1):
    method segment_batch (line 151) | def segment_batch(self, tensor_images, downsample=1):
  function load_unified_parsing_segmentation_model (line 186) | def load_unified_parsing_segmentation_model(segmodel_arch, segvocab, epo...
  function ensure_upp_segmenter_downloaded (line 212) | def ensure_upp_segmenter_downloaded(directory):
  function test_main (line 226) | def test_main():

FILE: seeing/upsegmodel/models.py
  class SegmentationModuleBase (line 12) | class SegmentationModuleBase(nn.Module):
    method __init__ (line 13) | def __init__(self):
    method pixel_acc (line 17) | def pixel_acc(pred, label, ignore_index=-1):
    method part_pixel_acc (line 26) | def part_pixel_acc(pred_part, gt_seg_part, gt_seg_object, object_label...
    method part_loss (line 37) | def part_loss(pred_part, gt_seg_part, gt_seg_object, object_label, val...
  class SegmentationModule (line 48) | class SegmentationModule(SegmentationModuleBase):
    method __init__ (line 49) | def __init__(self, net_enc, net_dec, labeldata, loss_scale=None):
    method forward (line 75) | def forward(self, feed_dict, *, seg_size=None):
  function conv3x3 (line 136) | def conv3x3(in_planes, out_planes, stride=1, has_bias=False):
  function conv3x3_bn_relu (line 142) | def conv3x3_bn_relu(in_planes, out_planes, stride=1):
  class ModelBuilder (line 150) | class ModelBuilder:
    method __init__ (line 151) | def __init__(self):
    method weights_init (line 156) | def weights_init(m):
    method build_encoder (line 166) | def build_encoder(self, arch='resnet50_dilated8', fc_dim=512, weights=...
    method build_decoder (line 187) | def build_decoder(self, nr_classes,
  class Resnet (line 213) | class Resnet(nn.Module):
    method __init__ (line 214) | def __init__(self, orig_resnet):
    method forward (line 233) | def forward(self, x, return_feature_maps=False):
  class UPerNet (line 252) | class UPerNet(nn.Module):
    method __init__ (line 253) | def __init__(self, nr_classes, fc_dim=4096,
    method forward (line 325) | def forward(self, conv_out, output_switch=None, seg_size=None):

FILE: seeing/upsegmodel/prroi_pool/functional.py
  class PrRoIPool2DFunction (line 30) | class PrRoIPool2DFunction(ag.Function):
    method forward (line 32) | def forward(ctx, features, rois, pooled_height, pooled_width, spatial_...
    method backward (line 55) | def backward(ctx, grad_output):

FILE: seeing/upsegmodel/prroi_pool/prroi_pool.py
  class PrRoIPool2D (line 19) | class PrRoIPool2D(nn.Module):
    method __init__ (line 20) | def __init__(self, pooled_height, pooled_width, spatial_scale):
    method forward (line 27) | def forward(self, features, rois):

FILE: seeing/upsegmodel/prroi_pool/src/prroi_pooling_gpu.c
  function output (line 28) | auto output = at::zeros({nr_rois, nr_channels, pooled_height, pooled_wid...

FILE: seeing/upsegmodel/prroi_pool/test_prroi_pooling2d.py
  class TestPrRoIPool2D (line 20) | class TestPrRoIPool2D(TorchTestCase):
    method test_forward (line 21) | def test_forward(self):
    method test_backward_shapeonly (line 37) | def test_backward_shapeonly(self):

FILE: seeing/upsegmodel/resnet.py
  function conv3x3 (line 26) | def conv3x3(in_planes, out_planes, stride=1):
  class BasicBlock (line 32) | class BasicBlock(nn.Module):
    method __init__ (line 35) | def __init__(self, inplanes, planes, stride=1, downsample=None):
    method forward (line 45) | def forward(self, x):
  class Bottleneck (line 64) | class Bottleneck(nn.Module):
    method __init__ (line 67) | def __init__(self, inplanes, planes, stride=1, downsample=None):
    method forward (line 80) | def forward(self, x):
  class ResNet (line 103) | class ResNet(nn.Module):
    method __init__ (line 105) | def __init__(self, block, layers, num_classes=1000):
    method _make_layer (line 134) | def _make_layer(self, block, planes, blocks, stride=1):
    method forward (line 151) | def forward(self, x):
  function resnet50 (line 193) | def resnet50(pretrained=False, **kwargs):
  function resnet101 (line 205) | def resnet101(pretrained=False, **kwargs):
  function load_url (line 227) | def load_url(url, model_dir='./pretrained', map_location=None):

FILE: seeing/upsegmodel/resnext.py
  function conv3x3 (line 26) | def conv3x3(in_planes, out_planes, stride=1):
  class GroupBottleneck (line 32) | class GroupBottleneck(nn.Module):
    method __init__ (line 35) | def __init__(self, inplanes, planes, stride=1, groups=1, downsample=No...
    method forward (line 48) | def forward(self, x):
  class ResNeXt (line 71) | class ResNeXt(nn.Module):
    method __init__ (line 73) | def __init__(self, block, layers, groups=32, num_classes=1000):
    method _make_layer (line 102) | def _make_layer(self, block, planes, blocks, stride=1, groups=1):
    method forward (line 119) | def forward(self, x):
  function resnext101 (line 151) | def resnext101(pretrained=False, **kwargs):
  function load_url (line 175) | def load_url(url, model_dir='./pretrained', map_location=None):

FILE: seeing/yz_dataset.py
  class YZDataset (line 4) | class YZDataset():
    method __init__ (line 5) | def __init__(self, zdim=256, nlabels=1, distribution=[1.], device='cpu'):
    method __call__ (line 12) | def __call__(self, seeds):

FILE: seeing/zdataset.py
  function z_dataset_for_model (line 4) | def z_dataset_for_model(model, size=100, seed=1):
  function z_sample_for_model (line 7) | def z_sample_for_model(model, size=100, seed=1):
  function standard_z_sample (line 26) | def standard_z_sample(size, depth, seed=1, device=None):

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

FILE: utils/classifiers/cifar.py
  class Classifier (line 6) | class Classifier():
    method __init__ (line 7) | def __init__(self):
    method get_predictions (line 10) | def get_predictions(self, x):

FILE: utils/classifiers/imagenet.py
  class Classifier (line 8) | class Classifier():
    method __init__ (line 9) | def __init__(self):
    method transform (line 21) | def transform(self, x):
    method get_name (line 26) | def get_name(self, class_id):
    method get_predictions_and_confidence (line 29) | def get_predictions_and_confidence(self, x):
    method get_predictions (line 35) | def get_predictions(self, x):

FILE: utils/classifiers/places.py
  class Classifier (line 8) | class Classifier():
    method __init__ (line 9) | def __init__(self):
    method get_name (line 45) | def get_name(self, id):
    method transform (line 48) | def transform(self, x):
    method get_predictions_and_confidence (line 53) | def get_predictions_and_confidence(self, x):
    method get_predictions (line 59) | def get_predictions(self, x):

FILE: utils/classifiers/pytorch_playground/cifar/dataset.py
  function get10 (line 6) | def get10(batch_size, data_root='/tmp/public_dataset/pytorch', train=Tru...
  function get100 (line 38) | def get100(batch_size, data_root='/tmp/public_dataset/pytorch', train=Tr...

FILE: utils/classifiers/pytorch_playground/cifar/model.py
  class CIFAR (line 13) | class CIFAR(nn.Module):
    method __init__ (line 14) | def __init__(self, features, n_channel, num_classes):
    method forward (line 24) | def forward(self, x):
  function make_layers (line 30) | def make_layers(cfg, batch_norm=False):
  function cifar10 (line 47) | def cifar10(n_channel=128):

FILE: utils/classifiers/pytorch_playground/quantize.py
  function main (line 8) | def main():

FILE: utils/classifiers/pytorch_playground/utee/misc.py
  class Logger (line 11) | class Logger(object):
    method __init__ (line 12) | def __init__(self):
    method init (line 15) | def init(self, logdir, name='log'):
    method info (line 30) | def info(self, str_info):
  function ensure_dir (line 36) | def ensure_dir(path, erase=False):
  function load_pickle (line 44) | def load_pickle(path):
  function dump_pickle (line 52) | def dump_pickle(obj, path):
  function auto_select_gpu (line 57) | def auto_select_gpu(mem_bound=500, utility_bound=0, gpus=(0, 1, 2, 3, 4,...
  function expand_user (line 94) | def expand_user(path):
  function model_snapshot (line 97) | def model_snapshot(model, new_file, old_file=None, verbose=False):
  function load_lmdb (line 117) | def load_lmdb(lmdb_file, n_records=None):
  function str2img (line 141) | def str2img(str_b):
  function img2str (line 144) | def img2str(img):
  function md5 (line 147) | def md5(s):
  function eval_model (line 152) | def eval_model(model, ds, n_sample=None, ngpu=1, is_imagenet=False):
  function load_state_dict (line 201) | def load_state_dict(model, model_urls, model_root):

FILE: utils/classifiers/pytorch_playground/utee/quant.py
  function compute_integral_part (line 8) | def compute_integral_part(input, overflow_rate):
  function linear_quantize (line 18) | def linear_quantize(input, sf, bits):
  function log_minmax_quantize (line 31) | def log_minmax_quantize(input, bits):
  function log_linear_quantize (line 42) | def log_linear_quantize(input, sf, bits):
  function min_max_quantize (line 53) | def min_max_quantize(input, bits):
  function tanh_quantize (line 71) | def tanh_quantize(input, bits):
  class LinearQuant (line 85) | class LinearQuant(nn.Module):
    method __init__ (line 86) | def __init__(self, name, bits, sf=None, overflow_rate=0.0, counter=10):
    method counter (line 96) | def counter(self):
    method forward (line 99) | def forward(self, input):
    method __repr__ (line 109) | def __repr__(self):
  class LogQuant (line 113) | class LogQuant(nn.Module):
    method __init__ (line 114) | def __init__(self, name, bits, sf=None, overflow_rate=0.0, counter=10):
    method counter (line 124) | def counter(self):
    method forward (line 127) | def forward(self, input):
    method __repr__ (line 138) | def __repr__(self):
  class NormalQuant (line 142) | class NormalQuant(nn.Module):
    method __init__ (line 143) | def __init__(self, name, bits, quant_func):
    method counter (line 150) | def counter(self):
    method forward (line 153) | def forward(self, input):
    method __repr__ (line 157) | def __repr__(self):
  function duplicate_model_with_quant (line 160) | def duplicate_model_with_quant(model, bits, overflow_rate=0.0, counter=1...

FILE: utils/classifiers/pytorch_playground/utee/selector.py
  function mnist (line 18) | def mnist(cuda=True, model_root=None):
  function svhn (line 26) | def svhn(cuda=True, model_root=None):
  function cifar10 (line 34) | def cifar10(cuda=True, model_root=None):
  function cifar100 (line 42) | def cifar100(cuda=True, model_root=None):
  function stl10 (line 50) | def stl10(cuda=True, model_root=None):
  function alexnet (line 58) | def alexnet(cuda=True, model_root=None):
  function vgg16 (line 66) | def vgg16(cuda=True, model_root=None):
  function vgg16_bn (line 74) | def vgg16_bn(cuda=True, model_root=None):
  function vgg19 (line 82) | def vgg19(cuda=True, model_root=None):
  function vgg19_bn (line 90) | def vgg19_bn(cuda=True, model_root=None):
  function inception_v3 (line 98) | def inception_v3(cuda=True, model_root=None):
  function resnet18 (line 106) | def resnet18(cuda=True, model_root=None):
  function resnet34 (line 114) | def resnet34(cuda=True, model_root=None):
  function resnet50 (line 122) | def resnet50(cuda=True, model_root=None):
  function resnet101 (line 130) | def resnet101(cuda=True, model_root=None):
  function resnet152 (line 138) | def resnet152(cuda=True, model_root=None):
  function squeezenet_v0 (line 146) | def squeezenet_v0(cuda=True, model_root=None):
  function squeezenet_v1 (line 154) | def squeezenet_v1(cuda=True, model_root=None):
  function select (line 162) | def select(model_name, **kwargs):

FILE: utils/classifiers/stacked_mnist.py
  class Classifier (line 11) | class Classifier():
    method __init__ (line 12) | def __init__(self):
    method get_predictions (line 22) | def get_predictions(self, x):
  function get_mnist_dataloader (line 29) | def get_mnist_dataloader(batch_size=100):
  class MNISTClassifier (line 46) | class MNISTClassifier(nn.Module):
    method __init__ (line 47) | def __init__(self, input_dims=1024, n_hiddens=[256, 256], n_class=10):
    method forward (line 63) | def forward(self, input):
    method get_predictions (line 68) | def get_predictions(self, input):
    method load (line 72) | def load(self, path):
    method train (line 76) | def train(self):

FILE: utils/get_empirical_distribution.py
  function get_empirical_distribution (line 12) | def get_empirical_distribution(path_to_samples):
  function get_kl (line 34) | def get_kl(fake, nclasses):

FILE: utils/get_gt_imgs.py
  function get_images (line 11) | def get_images(root, N):
  function pt_to_np (line 29) | def pt_to_np(imgs):
  function get_transform (line 34) | def get_transform(size):
  function get_gt_samples (line 43) | def get_gt_samples(dataset, nimgs=50000):

FILE: utils/np_to_pt_img.py
  function np_to_pt (line 4) | def np_to_pt(x):

FILE: visualize_clusters.py
  function main (line 27) | def main():