SYMBOL INDEX (188 symbols across 29 files)

FILE: condensa/compressor.py
  class Compressor (line 17) | class Compressor(object):
    method __init__ (line 19) | def __init__(self,
    method statistics (line 54) | def statistics(self):
    method run (line 63) | def run(self):

FILE: condensa/data.py
  function fast_collate (line 21) | def fast_collate(batch):
  class GPUDataLoader (line 37) | class GPUDataLoader(object):
    method __init__ (line 40) | def __init__(self,
    method __len__ (line 81) | def __len__(self):
    method __iter__ (line 84) | def __iter__(self):
    method __next__ (line 89) | def __next__(self):
    method preload (line 100) | def preload(self):

FILE: condensa/delta.py
  function dequantize (line 17) | def dequantize(module, dtype):

FILE: condensa/dtypes.py
  class DType (line 19) | class DType(object):
    method __init__ (line 21) | def __init__(self, dtype):
    method name (line 25) | def name(self):
    method as_numpy_dtype (line 29) | def as_numpy_dtype(self):
    method as_dtype_enum (line 33) | def as_dtype_enum(self):
    method __int__ (line 36) | def __int__(self):
    method __str__ (line 39) | def __str__(self):

FILE: condensa/finetune.py
  class FineTuner (line 29) | class FineTuner(object):
    method __init__ (line 32) | def __init__(self, w, layer_types=None, biases=True):
    method _compute_mask_inplace (line 38) | def _compute_mask_inplace(self):
    method _apply_mask (line 49) | def _apply_mask(self):
    method run (line 57) | def run(self,

FILE: condensa/functional.py
  function l2norm (line 17) | def l2norm(tensor, dim, keepdim):
  function max (line 31) | def max(tensor, dim, keepdim):
  function min (line 45) | def min(tensor, dim, keepdim):
  function mean (line 59) | def mean(tensor, dim, keepdim):
  function sum (line 73) | def sum(tensor, dim, keepdim):

FILE: condensa/lr.py
  class IntervalLR (line 17) | class IntervalLR(object):
    method __init__ (line 19) | def __init__(self, begin, end, n):
    method step (line 33) | def step(self):
    method learning_rate (line 38) | def learning_rate(self):
  class DecayedLR (line 42) | class DecayedLR(object):
    method __init__ (line 44) | def __init__(self, begin, schedule, gamma=0.1):
    method step (line 60) | def step(self):
    method learning_rate (line 67) | def learning_rate(self):
  class ExpDecayedLR (line 71) | class ExpDecayedLR(object):
    method __init__ (line 73) | def __init__(self, begin, gamma):
    method step (line 86) | def step(self):
    method learning_rate (line 91) | def learning_rate(self):

FILE: condensa/opt/direct/dc.py
  class DC (line 20) | class DC(object):
    method compress (line 22) | def compress(self,

FILE: condensa/opt/lc/adam.py
  class Adam (line 20) | class Adam(object):
    method __init__ (line 22) | def __init__(self,
    method zero_grad (line 53) | def zero_grad(self):
    method reset_state (line 60) | def reset_state(self):
    method _step (line 72) | def _step(self, p, condense=False, mu=None, p_theta=None, p_lm=None):
    method step (line 126) | def step(self, lr, mu, theta, lm, closure=None):

FILE: condensa/opt/lc/lc.py
  class record_mode (line 34) | class record_mode(object):
    method __enter__ (line 35) | def __enter__(self):
    method __exit__ (line 38) | def __exit__(self, *args):
  class LC (line 42) | class LC(object):
    method __init__ (line 44) | def __init__(self,
    method zero_ (line 135) | def zero_(self, model):
    method compress (line 147) | def compress(self, w, pi, delta, trainloader, testloader, valloader,
    method _update_mu (line 397) | def _update_mu(self, mu, mu_init, mu_multiplier, mu_cap):

FILE: condensa/opt/lc/sgd.py
  class SGD (line 18) | class SGD(object):
    method __init__ (line 20) | def __init__(self, w, lr=None, momentum=None, weight_decay=0):
    method zero_grad (line 54) | def zero_grad(self):
    method reset_state (line 61) | def reset_state(self):
    method _step (line 67) | def _step(self, p, condense=False, mu=None, p_theta=None, p_lm=None):
    method step (line 88) | def step(self, lr, mu, theta, lm, closure=None):

FILE: condensa/pi.py
  function __precheck (line 22) | def __precheck(module):
  function quantize (line 32) | def quantize(module, dtype):
  function prune (line 55) | def prune(module, threshold, parameter='weight'):
  function blockprune (line 83) | def blockprune(module,
  function neuron_prune (line 128) | def neuron_prune(module, threshold, criteria, align=None, prune_bias=True):
  function filter_prune (line 167) | def filter_prune(module, threshold, criteria, align=None, prune_bias=True):

FILE: condensa/schemes.py
  class Compose (line 21) | class Compose(object):
    method __init__ (line 23) | def __init__(self, schemes):
    method pi (line 34) | def pi(self, module):
    method delta (line 44) | def delta(self, module):
    method __repr__ (line 54) | def __repr__(self):
  class Prune (line 57) | class Prune(object):
    method __init__ (line 59) | def __init__(self, density):
    method threshold (line 69) | def threshold(self, module):
    method pi (line 83) | def pi(self, module):
    method delta (line 96) | def delta(self, module):
    method __repr__ (line 105) | def __repr__(self):
  class Quantize (line 108) | class Quantize(object):
    method __init__ (line 110) | def __init__(self, dtype=condensa.float16):
    method pi (line 119) | def pi(self, module):
    method delta (line 131) | def delta(self, module):
    method __repr__ (line 143) | def __repr__(self):
  class NeuronPrune (line 146) | class NeuronPrune(object):
    method __init__ (line 148) | def __init__(self, density, align=None, criteria=F.l2norm,
    method threshold (line 167) | def threshold(self, module):
    method pi (line 182) | def pi(self, module):
    method delta (line 199) | def delta(self, module):
    method __repr__ (line 208) | def __repr__(self):
  class FilterPrune (line 212) | class FilterPrune(object):
    method __init__ (line 214) | def __init__(self, density, align=None, criteria=F.l2norm,
    method threshold (line 233) | def threshold(self, module):
    method pi (line 248) | def pi(self, module):
    method delta (line 265) | def delta(self, module):
    method __repr__ (line 274) | def __repr__(self):
  class StructurePrune (line 278) | class StructurePrune(object):
    method __init__ (line 280) | def __init__(self, density, align=None, criteria=F.l2norm,
    method threshold (line 299) | def threshold(self, module):
    method pi (line 318) | def pi(self, module):
    method delta (line 342) | def delta(self, module):
    method __repr__ (line 351) | def __repr__(self):
  class BlockPrune (line 355) | class BlockPrune(object):
    method __init__ (line 357) | def __init__(self, density, block_size, criteria=F.l2norm):
    method threshold (line 373) | def threshold(self, module):
    method pi (line 389) | def pi(self, module):
    method delta (line 405) | def delta(self, module):
    method __repr__ (line 414) | def __repr__(self):

FILE: condensa/tensor.py
  function density (line 18) | def density(tensor):
  function sparsity (line 30) | def sparsity(tensor):
  function threshold (line 41) | def threshold(tensor, density):
  function aggregate (line 60) | def aggregate(tensor, blocksize, criteria):
  function aggregate_neurons (line 93) | def aggregate_neurons(tensor, criteria):
  function aggregate_filters (line 106) | def aggregate_filters(tensor, criteria):
  function simple_mask (line 119) | def simple_mask(tensor, threshold, align=None):
  function block_mask (line 148) | def block_mask(tensor, threshold, blocksize, criteria, align=None):
  function apply_mask (line 195) | def apply_mask(tensor, mask):
  function apply_mask_inplace (line 209) | def apply_mask_inplace(tensor, mask):

FILE: condensa/util.py
  class AverageMeter (line 29) | class AverageMeter(object):
    method __init__ (line 31) | def __init__(self):
    method reset (line 34) | def reset(self):
    method update (line 40) | def update(self, val, n=1):
  function to_python_float (line 46) | def to_python_float(t):
  function is_leaf_node (line 52) | def is_leaf_node(module):
  function magnitude_threshold (line 63) | def magnitude_threshold(module, density):
  function empty_stat_fn (line 77) | def empty_stat_fn(model, criterion, dataloader):
  function accuracy (line 90) | def accuracy(output, target, topk=(1, )):
  function loss (line 116) | def loss(model, criterion, dataloader):
  function cnn_statistics (line 147) | def cnn_statistics(model, criterion, dataloader):
  function compressed_model_stats (line 186) | def compressed_model_stats(w, wc):
  function pretrain (line 218) | def pretrain(epochs, model, trainloader, criterion, optimizer):
  class EventTimer (line 262) | class EventTimer(object):
    method __init__ (line 264) | def __init__(self):
    method reset (line 268) | def reset(self):
    method elapsed_seconds (line 273) | def elapsed_seconds(self):

FILE: docs/source/_static/ga_tracker.js
  function gtag (line 2) | function gtag(){dataLayer.push(arguments);}

FILE: docs/source/conf.py
  function setup (line 177) | def setup(app):

FILE: examples/cifar/models/alexnet.py
  class AlexNet (line 21) | class AlexNet(nn.Module):
    method __init__ (line 22) | def __init__(self, num_classes=10):
    method forward (line 41) | def forward(self, x):
  function alexnet (line 47) | def alexnet(**kwargs):

FILE: examples/cifar/models/resnet.py
  function conv3x3 (line 22) | def conv3x3(in_planes, out_planes, stride=1):
  class BasicBlock (line 31) | class BasicBlock(nn.Module):
    method __init__ (line 34) | def __init__(self, inplanes, planes, stride=1, downsample=None):
    method forward (line 44) | def forward(self, x):
  class Bottleneck (line 62) | class Bottleneck(nn.Module):
    method __init__ (line 65) | def __init__(self, inplanes, planes, stride=1, downsample=None):
    method forward (line 82) | def forward(self, x):
  class ResNet (line 104) | class ResNet(nn.Module):
    method __init__ (line 105) | def __init__(self, block, depth, num_classes=10):
    method _make_layer (line 128) | def _make_layer(self, block, planes, blocks, stride=1):
    method forward (line 149) | def forward(self, x):
  function resnet20 (line 164) | def resnet20(**kwargs):
  function resnet56 (line 167) | def resnet56(**kwargs):
  function resnet110 (line 170) | def resnet110(**kwargs):

FILE: examples/cifar/models/vgg.py
  class VGG (line 25) | class VGG(nn.Module):
    method __init__ (line 26) | def __init__(self, features, num_classes=10):
    method forward (line 32) | def forward(self, x):
    method _initialize_weights (line 38) | def _initialize_weights(self):
  function make_layers (line 53) | def make_layers(cfg, batch_norm=False):
  function vgg11 (line 78) | def vgg11(**kwargs):
  function vgg11_bn (line 82) | def vgg11_bn(**kwargs):
  function vgg13 (line 86) | def vgg13(**kwargs):
  function vgg13_bn (line 90) | def vgg13_bn(**kwargs):
  function vgg16 (line 94) | def vgg16(**kwargs):
  function vgg16_bn (line 98) | def vgg16_bn(**kwargs):
  function vgg19 (line 102) | def vgg19(**kwargs):
  function vgg19_bn (line 106) | def vgg19_bn(**kwargs):

FILE: examples/cifar/util.py
  function cifar_train_val_loader (line 29) | def cifar_train_val_loader(dataset,
  function cifar_test_loader (line 76) | def cifar_test_loader(dataset, batch_size, root='./data'):

FILE: notebooks/util.py
  function cifar_train_val_loader (line 29) | def cifar_train_val_loader(dataset,
  function cifar_test_loader (line 76) | def cifar_test_loader(dataset, batch_size, root='./data'):

FILE: setup.py
  function build_deps (line 22) | def build_deps():

FILE: test/schemes/test_prune.py
  function test_prune (line 22) | def test_prune(device):
  function test_filter_prune (line 32) | def test_filter_prune(device):
  function test_neuron_prune (line 55) | def test_neuron_prune(device):
  function test_block_prune (line 73) | def test_block_prune(device, blocksize=(10,10)):

FILE: test/schemes/test_qz.py
  function test_float16 (line 20) | def test_float16(device):

FILE: test/tensor/test_mask_apply.py
  function test_apply_mask (line 20) | def test_apply_mask(device):

FILE: test/tensor/test_maskgen.py
  function test_simple_mask (line 20) | def test_simple_mask(device):
  function test_block_mask (line 29) | def test_block_mask(device):

FILE: test/tensor/test_util.py
  function test_density (line 20) | def test_density(device):
  function test_sparsity (line 27) | def test_sparsity(device):
  function test_threshold (line 34) | def test_threshold(device):

FILE: test/test_lr.py
  function test_interval_lr (line 20) | def test_interval_lr():
  function test_decayed_lr (line 27) | def test_decayed_lr():
  function test_exp_decayed_lr (line 34) | def test_exp_decayed_lr():