SYMBOL INDEX (1379 symbols across 146 files)

FILE: apex/apex/RNN/RNNBackend.py
  function is_iterable (line 10) | def is_iterable(maybe_iterable):
  function flatten_list (line 14) | def flatten_list(tens_list):
  class bidirectionalRNN (line 25) | class bidirectionalRNN(nn.Module):
    method __init__ (line 29) | def __init__(self, inputRNN, num_layers=1, dropout = 0):
    method forward (line 37) | def forward(self, input, collect_hidden=False):
    method reset_parameters (line 52) | def reset_parameters(self):
    method init_hidden (line 59) | def init_hidden(self, bsz):
    method detach_hidden (line 66) | def detach_hidden(self):
    method reset_hidden (line 73) | def reset_hidden(self, bsz):
    method init_inference (line 80) | def init_inference(self, bsz):
  class stackedRNN (line 90) | class stackedRNN(nn.Module):
    method __init__ (line 94) | def __init__(self, inputRNN, num_layers=1, dropout=0):
    method forward (line 122) | def forward(self, input, collect_hidden=False, reverse=False):
    method reset_parameters (line 197) | def reset_parameters(self):
    method init_hidden (line 204) | def init_hidden(self, bsz):
    method detach_hidden (line 211) | def detach_hidden(self):
    method reset_hidden (line 218) | def reset_hidden(self, bsz):
    method init_inference (line 225) | def init_inference(self, bsz):
  class RNNCell (line 232) | class RNNCell(nn.Module):
    method __init__ (line 242) | def __init__(self, gate_multiplier, input_size, hidden_size, cell, n_h...
    method new_like (line 274) | def new_like(self, new_input_size=None):
    method reset_parameters (line 291) | def reset_parameters(self, gain=1):
    method init_hidden (line 309) | def init_hidden(self, bsz):
    method reset_hidden (line 330) | def reset_hidden(self, bsz):
    method detach_hidden (line 338) | def detach_hidden(self):
    method forward (line 348) | def forward(self, input):

FILE: apex/apex/RNN/cells.py
  class mLSTMRNNCell (line 12) | class mLSTMRNNCell(RNNCell):
    method __init__ (line 17) | def __init__(self, input_size, hidden_size, bias = False, output_size ...
    method forward (line 26) | def forward(self, input):
    method new_like (line 45) | def new_like(self, new_input_size=None):
  function mLSTMCell (line 55) | def mLSTMCell(input, hidden, w_ih, w_hh, w_mih, w_mhh, b_ih=None, b_hh=N...

FILE: apex/apex/RNN/models.py
  function toRNNBackend (line 8) | def toRNNBackend(inputRNN, num_layers, bidirectional=False, dropout = 0):
  function LSTM (line 19) | def LSTM(input_size, hidden_size, num_layers, bias=True, batch_first=Fal...
  function GRU (line 26) | def GRU(input_size, hidden_size, num_layers, bias=True, batch_first=Fals...
  function ReLU (line 33) | def ReLU(input_size, hidden_size, num_layers, bias=True, batch_first=Fal...
  function Tanh (line 40) | def Tanh(input_size, hidden_size, num_layers, bias=True, batch_first=Fal...
  function mLSTM (line 47) | def mLSTM(input_size, hidden_size, num_layers, bias=True, batch_first=Fa...

FILE: apex/apex/amp/_amp_state.py
  class AmpState (line 17) | class AmpState(object):
    method __init__ (line 18) | def __init__(self):
  function warn_or_err (line 28) | def warn_or_err(msg):
  function maybe_print (line 43) | def maybe_print(msg, rank0=False):
  function master_params (line 61) | def master_params(optimizer):

FILE: apex/apex/amp/_initialize.py
  function to_type (line 18) | def to_type(dtype, t):
  function applier (line 36) | def applier(value, fn):
  function check_models (line 61) | def check_models(models):
  function check_params_fp32 (line 76) | def check_params_fp32(models):
  function check_optimizers (line 116) | def check_optimizers(optimizers):
  function wrap_fused_adam (line 134) | def wrap_fused_adam(optimizer, properties):
  function _initialize (line 150) | def _initialize(models, optimizers, properties, num_losses=1, cast_model...

FILE: apex/apex/amp/_process_optimizer.py
  class AmpOptimizerState (line 8) | class AmpOptimizerState(object):
    method __init__ (line 9) | def __init__(self):
  function lazy_init_with_master_weights (line 13) | def lazy_init_with_master_weights(self):
  function prepare_backward_with_master_weights (line 76) | def prepare_backward_with_master_weights(self):
  function post_backward_with_master_weights (line 96) | def post_backward_with_master_weights(self, scaler):
  function lazy_init_no_master_weights (line 165) | def lazy_init_no_master_weights(self):
  function prepare_backward_no_master_weights (line 184) | def prepare_backward_no_master_weights(self):
  function post_backward_no_master_weights (line 202) | def post_backward_no_master_weights(self, scaler):
  function _master_params_to_model_params (line 242) | def _master_params_to_model_params(self):
  function _process_optimizer (line 256) | def _process_optimizer(optimizer, properties):

FILE: apex/apex/amp/amp.py
  function _decorator_helper (line 18) | def _decorator_helper(orig_fn, cast_fn, wrap_fn):
  function half_function (line 30) | def half_function(fn):
  function float_function (line 35) | def float_function(fn):
  function promote_function (line 40) | def promote_function(fn):
  function register_half_function (line 46) | def register_half_function(module, name):
  function register_float_function (line 53) | def register_float_function(module, name):
  function register_promote_function (line 60) | def register_promote_function(module, name):
  function init (line 68) | def init(enabled=True, loss_scale="dynamic", enable_caching=True, verbos...

FILE: apex/apex/amp/compat.py
  function variable_is_tensor (line 4) | def variable_is_tensor():
  function tensor_is_variable (line 8) | def tensor_is_variable():
  function tensor_is_float_tensor (line 13) | def tensor_is_float_tensor():
  function is_tensor_like (line 19) | def is_tensor_like(x):
  function is_floating_point (line 24) | def is_floating_point(x):
  function scalar_python_val (line 35) | def scalar_python_val(x):

FILE: apex/apex/amp/frontend.py
  class Properties (line 6) | class Properties(object):
    method __init__ (line 12) | def __init__(self):
    method _update_options_dict (line 32) | def _update_options_dict(new_options):
    method __getattr__ (line 42) | def __getattr__(self, name):
    method __setattr__ (line 50) | def __setattr__(self, name, value):
  class O3 (line 101) | class O3:
    method __call__ (line 110) | def __call__(self, properties):
  class O2 (line 123) | class O2:
    method __call__ (line 133) | def __call__(self, properties):
  class O1 (line 146) | class O1:
    method __call__ (line 155) | def __call__(self, properties):
  class O0 (line 168) | class O0:
    method __call__ (line 174) | def __call__(self, properties):
  function initialize (line 194) | def initialize(

FILE: apex/apex/amp/handle.py
  function scale_loss (line 16) | def scale_loss(loss,
  function disable_casts (line 163) | def disable_casts():
  class AmpHandle (line 169) | class AmpHandle(object):
    method __init__ (line 170) | def __init__(self, loss_scale="dynamic", enable_caching=True, verbose=...
    method is_active (line 178) | def is_active(self):
    method _disable_casts (line 182) | def _disable_casts(self):
    method wrap_optimizer (line 187) | def wrap_optimizer(self, optimizer, num_loss=1):
    method scale_loss (line 192) | def scale_loss(self, loss, optimizer):
    method _clear_cache (line 225) | def _clear_cache(self):
    method _save_func (line 229) | def _save_func(self, mod, fn, func):
    method _deactivate (line 232) | def _deactivate(self):
    method has_cache (line 238) | def has_cache(self):
    method cache (line 242) | def cache(self):
    method remove_cache (line 245) | def remove_cache(self, param):
    method verbose (line 250) | def verbose(self):
  class NoOpHandle (line 253) | class NoOpHandle(object):
    method is_active (line 254) | def is_active(self):
    method _disable_casts (line 258) | def _disable_casts(self):
    method wrap_optimizer (line 261) | def wrap_optimizer(self, optimizer, num_loss=1):
    method scale_loss (line 265) | def scale_loss(self, loss, optimizer):
    method has_cache (line 269) | def has_cache(self):
    method verbose (line 273) | def verbose(self):
    method _clear_cache (line 276) | def _clear_cache(self):
    method _deactivate (line 279) | def _deactivate(self):

FILE: apex/apex/amp/opt.py
  class OptimWrapper (line 9) | class OptimWrapper(object):
    method __init__ (line 10) | def __init__(self, optimizer, amp_handle, num_loss):
    method scale_loss (line 19) | def scale_loss(self, loss):
    method _cur_loss_scaler (line 55) | def _cur_loss_scaler(self):
    method step (line 59) | def step(self, closure=None):
    method __getattr__ (line 80) | def __getattr__(self, attr):
    method __getstate__ (line 84) | def __getstate__(self):
    method __setstate__ (line 87) | def __setstate__(self):
    method __repr__ (line 90) | def __repr__(self):
    method state_dict (line 93) | def state_dict(self):
    method load_state_dict (line 96) | def load_state_dict(self, state_dict):
    method zero_grad (line 99) | def zero_grad(self):
    method add_param_group (line 102) | def add_param_group(self, param_group):

FILE: apex/apex/amp/rnn_compat.py
  function _gen_VF_wrapper (line 7) | def _gen_VF_wrapper(name):
  class VariableFunctionsShim (line 17) | class VariableFunctionsShim(object):
    method __init__ (line 18) | def __init__(self):
  function has_old_rnns (line 24) | def has_old_rnns():
  function whitelist_rnn_cells (line 31) | def whitelist_rnn_cells(handle, verbose):

FILE: apex/apex/amp/scaler.py
  function scale_check_overflow_python (line 6) | def scale_check_overflow_python(model_grad, master_grad, scale, check_ov...
  function axpby_check_overflow_python (line 19) | def axpby_check_overflow_python(model_grad, stashed_grad, master_grad, s...
  class LossScaler (line 34) | class LossScaler(object):
    method __init__ (line 39) | def __init__(self,
    method loss_scale (line 74) | def loss_scale(self):
    method unscale_python (line 77) | def unscale_python(self, model_grads, master_grads, scale):
    method unscale (line 95) | def unscale(self, model_grads, master_grads, unused_scale, models_are_...
    method unscale_with_stashed_python (line 125) | def unscale_with_stashed_python(self,
    method unscale_with_stashed (line 149) | def unscale_with_stashed(self,
    method clear_overflow_state (line 184) | def clear_overflow_state(self):
    method update_scale (line 190) | def update_scale(self):

FILE: apex/apex/amp/utils.py
  function get_cuda_version (line 8) | def get_cuda_version():
  function is_fp_tensor (line 11) | def is_fp_tensor(x):
  function is_nested (line 20) | def is_nested(x):
  function should_cache (line 23) | def should_cache(x):
  function collect_fp_tensor_types (line 33) | def collect_fp_tensor_types(args, kwargs):
  function type_string (line 48) | def type_string(x):
  function maybe_half (line 51) | def maybe_half(x, name='', verbose=False):
  function maybe_float (line 62) | def maybe_float(x, name='', verbose=False):
  function casted_args (line 74) | def casted_args(cast_fn, args, kwargs):
  function cached_cast (line 87) | def cached_cast(cast_fn, x, cache):
  function verbosify (line 121) | def verbosify(cast_fn, fn_name, verbose):
  function as_inplace (line 127) | def as_inplace(fns):
  function has_func (line 131) | def has_func(mod, fn):
  function get_func (line 139) | def get_func(mod, fn):
  function set_func (line 147) | def set_func(mod, fn, new_fn):
  function set_func_save (line 155) | def set_func_save(handle, mod, fn, new_fn):
  function synthesize_flattened_rnn_weights (line 174) | def synthesize_flattened_rnn_weights(fp32_weights,
  function new_synthesize_flattened_rnn_weights (line 197) | def new_synthesize_flattened_rnn_weights(fp32_weights,

FILE: apex/apex/amp/wrap.py
  function make_cast_wrapper (line 10) | def make_cast_wrapper(orig_fn, cast_fn, handle,
  function cached_cast (line 31) | def cached_cast(mod, fn, cast_fn, handle,
  function make_promote_wrapper (line 44) | def make_promote_wrapper(orig_fn, cast_fn, handle=None):
  function promote (line 65) | def promote(mod, fn, handle, verbose=False):
  function sequence_promote (line 71) | def sequence_promote(mod, fn, handle, verbose=False):
  function promote_match_arg0 (line 92) | def promote_match_arg0(mod, fn, handle, verbose=False):
  function err_if_any_half (line 114) | def err_if_any_half(mod, fn, handle, custom_err_msg=None):
  function err_if_arg0_half (line 132) | def err_if_arg0_half(mod, fn, handle, verbose=False):
  function rnn_cast (line 157) | def rnn_cast(backend, fn, handle, verbose=False):
  function new_rnn_cast (line 222) | def new_rnn_cast(fn, handle, verbose=False):
  function disable_casts (line 267) | def disable_casts(mod, fn, handle):

FILE: apex/apex/fp16_utils/fp16_optimizer.py
  class FP16_Optimizer (line 13) | class FP16_Optimizer(object):
    method __init__ (line 107) | def __init__(self,
    method maybe_print (line 199) | def maybe_print(self, msg):
    method __getstate__ (line 203) | def __getstate__(self):
    method __setstate__ (line 206) | def __setstate__(self, state):
    method zero_grad (line 209) | def zero_grad(self, set_grads_to_None=False):
    method _master_params_to_model_params (line 249) | def _master_params_to_model_params(self):
    method clip_master_grads (line 274) | def clip_master_grads(self, max_norm, norm_type=2):
    method state_dict (line 298) | def state_dict(self):
    method load_state_dict (line 319) | def load_state_dict(self, state_dict):
    method step (line 361) | def step(self, closure=None): # could add clip option.
    method _step_with_closure (line 423) | def _step_with_closure(self, closure):
    method backward (line 462) | def backward(self, loss, update_master_grads=True, retain_graph=False):
    method update_master_grads (line 525) | def update_master_grads(self):
    method inspect_master_grad_data (line 582) | def inspect_master_grad_data(self):
    method _get_loss_scale (line 617) | def _get_loss_scale(self):
    method _set_loss_scale (line 620) | def _set_loss_scale(self, value):
    method _get_state (line 626) | def _get_state(self):
    method _set_state (line 629) | def _set_state(self, value):
    method _get_param_groups (line 636) | def _get_param_groups(self):
    method _set_param_groups (line 639) | def _set_param_groups(self, value):

FILE: apex/apex/fp16_utils/fp16util.py
  class tofp16 (line 7) | class tofp16(nn.Module):
    method __init__ (line 15) | def __init__(self):
    method forward (line 18) | def forward(self, input):
  function BN_convert_float (line 22) | def BN_convert_float(module):
  function network_to_half (line 35) | def network_to_half(network):
  function convert_module (line 44) | def convert_module(module, dtype):
  function convert_network (line 60) | def convert_network(network, dtype):
  class FP16Model (line 73) | class FP16Model(nn.Module):
    method __init__ (line 78) | def __init__(self, network):
    method forward (line 82) | def forward(self, *inputs):
  function backwards_debug_hook (line 87) | def backwards_debug_hook(grad):
  function prep_param_lists (line 90) | def prep_param_lists(model, flat_master=False):
  function model_grads_to_master_grads (line 136) | def model_grads_to_master_grads(model_params, master_params, flat_master...
  function master_params_to_model_params (line 158) | def master_params_to_model_params(model_params, master_params, flat_mast...
  function to_python_float (line 176) | def to_python_float(t):

FILE: apex/apex/fp16_utils/loss_scaler.py
  function to_python_float (line 4) | def to_python_float(t):
  class LossScaler (line 10) | class LossScaler:
    method __init__ (line 22) | def __init__(self, scale=1):
    method has_overflow (line 26) | def has_overflow(self, params):
    method _has_inf_or_nan (line 30) | def _has_inf_or_nan(x):
    method update_scale (line 33) | def update_scale(self, overflow):
    method loss_scale (line 37) | def loss_scale(self):
    method scale_gradient (line 40) | def scale_gradient(self, module, grad_in, grad_out):
    method backward (line 43) | def backward(self, loss, retain_graph=False):
  class DynamicLossScaler (line 47) | class DynamicLossScaler:
    method __init__ (line 73) | def __init__(self,
    method has_overflow (line 84) | def has_overflow(self, params):
    method _has_inf_or_nan (line 92) | def _has_inf_or_nan(x):
    method update_scale (line 113) | def update_scale(self, overflow):
    method loss_scale (line 124) | def loss_scale(self):
    method scale_gradient (line 127) | def scale_gradient(self, module, grad_in, grad_out):
    method backward (line 130) | def backward(self, loss, retain_graph=False):

FILE: apex/apex/multi_tensor_apply/multi_tensor_apply.py
  class MultiTensorApply (line 3) | class MultiTensorApply(object):
    method __init__ (line 7) | def __init__(self, chunk_size):
    method check_avail (line 16) | def check_avail(self):
    method __call__ (line 24) | def __call__(self, op, noop_flag_buffer, tensor_lists, *args):

FILE: apex/apex/normalization/fused_layer_norm.py
  class FusedLayerNormAffineFunction (line 9) | class FusedLayerNormAffineFunction(torch.autograd.Function):
    method __init__ (line 10) | def __init__(self, normalized_shape, eps=1e-6):
    method forward (line 17) | def forward(self, input, weight, bias):
    method backward (line 26) | def backward(self, grad_output):
  class FusedLayerNormFunction (line 35) | class FusedLayerNormFunction(torch.autograd.Function):
    method __init__ (line 36) | def __init__(self, normalized_shape, eps=1e-6):
    method forward (line 42) | def forward(self, input):
    method backward (line 49) | def backward(self, grad_output):
  function fused_layer_norm_affine (line 58) | def fused_layer_norm_affine(input, normalized_shape, weight, bias, eps=1...
  function fused_layer_norm (line 61) | def fused_layer_norm(input, normalized_shape, eps=1e-6):
  class FusedLayerNorm (line 64) | class FusedLayerNorm(torch.nn.Module):
    method __init__ (line 123) | def __init__(self, normalized_shape, eps=1e-5, elementwise_affine=True):
    method reset_parameters (line 142) | def reset_parameters(self):
    method forward (line 147) | def forward(self, input):
    method extra_repr (line 158) | def extra_repr(self):

FILE: apex/apex/optimizers/fp16_optimizer.py
  class FP16_Optimizer (line 4) | class FP16_Optimizer(object):
    method __init__ (line 31) | def __init__(self,
    method zero_grad (line 88) | def zero_grad(self, set_grads_to_None=True):
    method _compute_grad_norm (line 103) | def _compute_grad_norm(self, fp16_grads_flat, norm_type=2):
    method step (line 130) | def step(self, closure=None):
    method backward (line 163) | def backward(self, loss):
    method _update_scale (line 174) | def _update_scale(self, skip):
    method _get_state (line 193) | def _get_state(self):
    method _set_state (line 196) | def _set_state(self, value):
    method _get_param_groups (line 203) | def _get_param_groups(self):
    method _set_param_groups (line 206) | def _set_param_groups(self, value):
    method state_dict (line 211) | def state_dict(self):
    method load_state_dict (line 234) | def load_state_dict(self, state_dict):

FILE: apex/apex/optimizers/fused_adam.py
  class FusedAdam (line 5) | class FusedAdam(torch.optim.Optimizer):
    method __init__ (line 35) | def __init__(self, params,
    method step (line 50) | def step(self, closure=None, grads=None, output_params=None, scale=1.,...

FILE: apex/apex/parallel/LARC.py
  class LARC (line 6) | class LARC(object):
    method __init__ (line 40) | def __init__(self, optimizer, trust_coefficient=0.02, clip=True, eps=1...
    method __getstate__ (line 47) | def __getstate__(self):
    method __setstate__ (line 50) | def __setstate__(self, state):
    method __repr__ (line 53) | def __repr__(self):
    method state_dict (line 56) | def state_dict(self):
    method load_state_dict (line 59) | def load_state_dict(self, state_dict):
    method zero_grad (line 62) | def zero_grad(self):
    method add_param_group (line 65) | def add_param_group(self, param_group):
    method step (line 68) | def step(self):

FILE: apex/apex/parallel/__init__.py
  function convert_syncbn_model (line 21) | def convert_syncbn_model(module, process_group=None, channel_last=False):
  function create_syncbn_process_group (line 55) | def create_syncbn_process_group(group_size):

FILE: apex/apex/parallel/distributed.py
  function import_flatten_impl (line 13) | def import_flatten_impl():
  function flatten (line 25) | def flatten(bucket):
  function unflatten (line 30) | def unflatten(coalesced, bucket):
  function apply_flat_dist_call (line 36) | def apply_flat_dist_call(bucket, call, extra_args=None):
  function split_half_float_double (line 51) | def split_half_float_double(tensors):
  function split_by_type (line 60) | def split_by_type(tensors):
  function flat_dist_call (line 70) | def flat_dist_call(tensors, call, extra_args=None):
  function extract_tensors (line 78) | def extract_tensors(maybe_tensor, tensor_list):
  class Reducer (line 89) | class Reducer(object):
    method __init__ (line 111) | def __init__(self, module_or_grads_list):
    method reduce (line 121) | def reduce(self):
  class DistributedDataParallel (line 129) | class DistributedDataParallel(Module):
    method __init__ (line 162) | def __init__(self,
    method __setstate__ (line 237) | def __setstate__(self, state):
    method __getstate__ (line 243) | def __getstate__(self):
    method enable_allreduce (line 250) | def enable_allreduce(self):
    method disable_allreduce (line 253) | def disable_allreduce(self):
    method sync_bucket_structure (line 258) | def sync_bucket_structure(self):
    method create_hooks (line 294) | def create_hooks(self):
    method allreduce_bucket (line 378) | def allreduce_bucket(self, bucket):
    method allreduce_maybe_retain (line 401) | def allreduce_maybe_retain(self, bucket, bucket_idx=-1):
    method allreduce_fallback (line 420) | def allreduce_fallback(self):
    method comm_ready_buckets (line 435) | def comm_ready_buckets(self, param):
    method forward (line 475) | def forward(self, *inputs, **kwargs):

FILE: apex/apex/parallel/multiproc.py
  function docstring_hack (line 5) | def docstring_hack():

FILE: apex/apex/parallel/optimized_sync_batchnorm.py
  class SyncBatchNorm (line 9) | class SyncBatchNorm(_BatchNorm):
    method __init__ (line 58) | def __init__(self, num_features, eps=1e-5, momentum=0.1, affine=True, ...
    method _specify_process_group (line 63) | def _specify_process_group(self, process_group):
    method _specify_channel_last (line 66) | def _specify_channel_last(self, channel_last):
    method forward (line 69) | def forward(self, input):

FILE: apex/apex/parallel/optimized_sync_batchnorm_kernel.py
  class SyncBatchnormFunction (line 7) | class SyncBatchnormFunction(Function):
    method forward (line 10) | def forward(ctx, input, weight, bias, running_mean, running_variance, ...
    method backward (line 70) | def backward(ctx, grad_output):

FILE: apex/apex/parallel/sync_batchnorm.py
  class SyncBatchNorm (line 9) | class SyncBatchNorm(_BatchNorm):
    method __init__ (line 51) | def __init__(self, num_features, eps=1e-5, momentum=0.1, affine=True, ...
    method _specify_process_group (line 62) | def _specify_process_group(self, process_group):
    method forward (line 65) | def forward(self, input):

FILE: apex/apex/parallel/sync_batchnorm_kernel.py
  class SyncBatchnormFunction (line 7) | class SyncBatchnormFunction(Function):
    method forward (line 10) | def forward(ctx, input, weight, bias, running_mean, running_variance, ...
    method backward (line 33) | def backward(ctx, grad_output):

FILE: apex/apex/reparameterization/__init__.py
  function apply_weight_norm (line 4) | def apply_weight_norm(module, name='', dim=0, hook_child=True):
  function remove_weight_norm (line 50) | def remove_weight_norm(module, name='', remove_all=False):
  function apply_reparameterization (line 64) | def apply_reparameterization(module, reparameterization=None, name='', d...
  function remove_reparameterization (line 96) | def remove_reparameterization(module, reparameterization=Reparameterizat...

FILE: apex/apex/reparameterization/reparameterization.py
  class Reparameterization (line 4) | class Reparameterization(object):
    method __init__ (line 19) | def __init__(self, name, dim, module, retain_forward=True):
    method compute_weight (line 28) | def compute_weight(self, module=None, name=None):
    method reparameterize (line 40) | def reparameterize(self, name, weight, dim):
    method apply (line 57) | def apply(module, name, dim, reparameterization=None, hook_child=True):
    method get_module_and_name (line 105) | def get_module_and_name(module, name):
    method get_params (line 123) | def get_params(self, module):
    method remove (line 127) | def remove(self, module):
    method __call__ (line 139) | def __call__(self, module, inputs):
    method backward_hook (line 147) | def backward_hook(self, module, grad_input, grad_output):

FILE: apex/apex/reparameterization/weight_norm.py
  function _norm (line 8) | def _norm(p, dim):
  class WeightNorm (line 22) | class WeightNorm(Reparameterization):
    method compute_weight (line 39) | def compute_weight(self, module=None, name=None):
    method reparameterize (line 62) | def reparameterize(self, name, weight, dim):

FILE: apex/csrc/amp_C_frontend.cpp
  function PYBIND11_MODULE (line 43) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: apex/csrc/flatten_unflatten.cpp
  function flatten (line 5) | at::Tensor flatten(std::vector<at::Tensor> tensors)
  function unflatten (line 10) | std::vector<at::Tensor> unflatten(at::Tensor flat, std::vector<at::Tenso...
  function PYBIND11_MODULE (line 15) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: apex/csrc/fused_adam_cuda.cpp
  function adam (line 11) | void adam(at::Tensor & p, at::Tensor & p_copy, at::Tensor & m, at::Tenso...
  function PYBIND11_MODULE (line 26) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: apex/csrc/layer_norm_cuda.cpp
  function compute_n1_n2 (line 6) | void compute_n1_n2(
  function check_args (line 42) | void check_args(
  function check_args (line 82) | void check_args(
  function layer_norm (line 120) | std::vector<at::Tensor> layer_norm(
  function layer_norm_affine (line 138) | std::vector<at::Tensor> layer_norm_affine(
  function layer_norm_gradient (line 181) | at::Tensor layer_norm_gradient(
  function layer_norm_gradient_affine (line 204) | std::vector<at::Tensor> layer_norm_gradient_affine(
  function PYBIND11_MODULE (line 234) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: apex/csrc/syncbn.cpp
  function PYBIND11_MODULE (line 85) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: apex/docs/source/conf.py
  function patched_make_field (line 206) | def patched_make_field(self, types, domain, items, **kw):

FILE: apex/examples/imagenet/main_amp.py
  function fast_collate (line 77) | def fast_collate(batch):
  function main (line 108) | def main():
  class data_prefetcher (line 256) | class data_prefetcher():
    method __init__ (line 257) | def __init__(self, loader):
    method preload (line 268) | def preload(self):
    method next (line 299) | def next(self):
  function train (line 309) | def train(train_loader, model, criterion, optimizer, epoch):
  function validate (line 393) | def validate(val_loader, model, criterion):
  function save_checkpoint (line 455) | def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):
  class AverageMeter (line 461) | class AverageMeter(object):
    method __init__ (line 463) | def __init__(self):
    method reset (line 466) | def reset(self):
    method update (line 472) | def update(self, val, n=1):
  function adjust_learning_rate (line 479) | def adjust_learning_rate(optimizer, epoch, step, len_epoch):
  function accuracy (line 499) | def accuracy(output, target, topk=(1,)):
  function reduce_tensor (line 515) | def reduce_tensor(tensor):

FILE: apex/setup.py
  function check_cuda_torch_binary_vs_bare_metal (line 36) | def check_cuda_torch_binary_vs_bare_metal(cuda_dir):

FILE: apex/tests/L0/run_amp/test_add_param_group.py
  class MyModel (line 16) | class MyModel(torch.nn.Module):
    method __init__ (line 17) | def __init__(self, unique):
    method ops (line 24) | def ops(input, weight0, weight1):
    method forward (line 27) | def forward(self, input):
  class TestAddParamGroup (line 34) | class TestAddParamGroup(unittest.TestCase):
    method setUp (line 35) | def setUp(self):
    method tearDown (line 39) | def tearDown(self):
    method zero_grad (line 42) | def zero_grad(self, models, optimizer, how_to_zero):
    method test_add_param_group (line 53) | def test_add_param_group(self):

FILE: apex/tests/L0/run_amp/test_basic_casts.py
  function run_layer_test (line 14) | def run_layer_test(test_case, fns, expected, input_shape, test_backward=...
  class TestBasicCasts (line 23) | class TestBasicCasts(unittest.TestCase):
    method setUp (line 24) | def setUp(self):
    method tearDown (line 28) | def tearDown(self):
    method test_linear_is_half (line 31) | def test_linear_is_half(self):
    method test_conv2d_is_half (line 36) | def test_conv2d_is_half(self):
    method test_softmax_is_float (line 41) | def test_softmax_is_float(self):
    method test_group_norm_is_float (line 46) | def test_group_norm_is_float(self):
    method test_mse_loss_is_float (line 50) | def test_mse_loss_is_float(self):
    method test_relu_is_match (line 58) | def test_relu_is_match(self):
    method test_batch_norm_is_match (line 61) | def test_batch_norm_is_match(self):
  class TestBannedMethods (line 74) | class TestBannedMethods(unittest.TestCase):
    method setUp (line 75) | def setUp(self):
    method tearDown (line 79) | def tearDown(self):
    method bce_common (line 82) | def bce_common(self, assertion):
    method test_bce_raises_by_default (line 92) | def test_bce_raises_by_default(self):
    method test_bce_is_float_with_allow_banned (line 96) | def test_bce_is_float_with_allow_banned(self):
  class TestTensorCasts (line 102) | class TestTensorCasts(unittest.TestCase):
    method setUp (line 103) | def setUp(self):
    method tearDown (line 107) | def tearDown(self):
    method test_matmul_method_is_half (line 110) | def test_matmul_method_is_half(self):
    method test_matmul_op_is_half (line 116) | def test_matmul_op_is_half(self):
    method test_pow_method_is_float (line 122) | def test_pow_method_is_float(self):
    method test_pow_op_is_float (line 126) | def test_pow_op_is_float(self):
    method test_cpu_is_float (line 130) | def test_cpu_is_float(self):
    method test_sum_is_float (line 136) | def test_sum_is_float(self):
  class TestDisabledCasts (line 140) | class TestDisabledCasts(unittest.TestCase):
    method setUp (line 141) | def setUp(self):
    method test_disabled_linear (line 145) | def test_disabled_linear(self):

FILE: apex/tests/L0/run_amp/test_cache.py
  function get_reference_grad (line 15) | def get_reference_grad(i, w, ops):
  class WhitelistModule (line 24) | class WhitelistModule(torch.nn.Module):
    method __init__ (line 25) | def __init__(self, dtype):
    method ops (line 30) | def ops(input, weight):
    method forward (line 33) | def forward(self, input):
  class BlacklistModule (line 37) | class BlacklistModule(torch.nn.Module):
    method __init__ (line 38) | def __init__(self, dtype):
    method ops (line 43) | def ops(input, weight):
    method forward (line 46) | def forward(self, input):
  class PromoteModule (line 50) | class PromoteModule(torch.nn.Module):
    method __init__ (line 51) | def __init__(self, dtype):
    method ops (line 56) | def ops(input, weight):
    method forward (line 59) | def forward(self, input):
  class TestCache (line 62) | class TestCache(unittest.TestCase):
    method setUp (line 63) | def setUp(self):
    method tearDown (line 67) | def tearDown(self):
    method train_eval_train_test (line 70) | def train_eval_train_test(self, module, t):
    method test_whitelist_module_fp16_weight (line 117) | def test_whitelist_module_fp16_weight(self):
    method test_whitelist_module_fp32_weight (line 120) | def test_whitelist_module_fp32_weight(self):
    method test_blacklist_module_fp16_weight (line 123) | def test_blacklist_module_fp16_weight(self):
    method test_blacklist_module_fp32_weight (line 126) | def test_blacklist_module_fp32_weight(self):
    method test_promote_module_fp16_weight (line 129) | def test_promote_module_fp16_weight(self):
    method test_promote_module_fp32_weight (line 132) | def test_promote_module_fp32_weight(self):

FILE: apex/tests/L0/run_amp/test_multi_tensor_axpby.py
  class TestMultiTensorAxpby (line 24) | class TestMultiTensorAxpby(unittest.TestCase):
    method setUp (line 26) | def setUp(self):
    method tearDown (line 36) | def tearDown(self):
    method axpby (line 40) | def axpby(self, sizea, sizeb, applier, repeat_tensors,
    method test_fuzz (line 88) | def test_fuzz(self):

FILE: apex/tests/L0/run_amp/test_multi_tensor_l2norm.py
  class TestMultiTensorL2Norm (line 24) | class TestMultiTensorL2Norm(unittest.TestCase):
    method setUp (line 26) | def setUp(self):
    method tearDown (line 31) | def tearDown(self):
    method l2norm (line 35) | def l2norm(self, sizea, sizeb, applier, repeat_tensors, in_type, per_t...
    method test_fuzz (line 59) | def test_fuzz(self):

FILE: apex/tests/L0/run_amp/test_multi_tensor_scale.py
  class TestMultiTensorScale (line 24) | class TestMultiTensorScale(unittest.TestCase):
    method setUp (line 26) | def setUp(self):
    method tearDown (line 32) | def tearDown(self):
    method downscale (line 36) | def downscale(self, sizea, sizeb, applier, repeat_tensors, in_type, ou...
    method find_inf (line 55) | def find_inf(self, sizea, sizeb, applier, repeat_tensors, in_type, out...
    method test_fuzz (line 88) | def test_fuzz(self):

FILE: apex/tests/L0/run_amp/test_multiple_models_optimizers_losses.py
  class MyModel (line 16) | class MyModel(torch.nn.Module):
    method __init__ (line 17) | def __init__(self, unique):
    method ops (line 24) | def ops(input, weight0, weight1):
    method forward (line 27) | def forward(self, input):
  class TestMultipleModelsOptimizersLosses (line 37) | class TestMultipleModelsOptimizersLosses(unittest.TestCase):
    method setUp (line 38) | def setUp(self):
    method tearDown (line 42) | def tearDown(self):
    method test_2models2losses1optimizer (line 45) | def test_2models2losses1optimizer(self):
    method test_3models2losses1optimizer (line 170) | def test_3models2losses1optimizer(self):
    method test_2models2losses2optimizers (line 326) | def test_2models2losses2optimizers(self):
    method test_3models2losses2optimizers (line 516) | def test_3models2losses2optimizers(self):

FILE: apex/tests/L0/run_amp/test_promotion.py
  class TestPromotion (line 12) | class TestPromotion(unittest.TestCase):
    method setUp (line 13) | def setUp(self):
    method tearDown (line 17) | def tearDown(self):
    method run_binary_promote_test (line 20) | def run_binary_promote_test(self, fns, input_shape, x_inplace=False):
    method test_atan2_matches_widest (line 42) | def test_atan2_matches_widest(self):
    method test_mul_matches_widest (line 47) | def test_mul_matches_widest(self):
    method test_cat_matches_widest (line 52) | def test_cat_matches_widest(self):
    method test_inplace_exp_is_error_for_half (line 62) | def test_inplace_exp_is_error_for_half(self):
    method test_inplace_add_matches_self (line 70) | def test_inplace_add_matches_self(self):

FILE: apex/tests/L0/run_amp/test_rnn.py
  class TestRnnCells (line 10) | class TestRnnCells(unittest.TestCase):
    method setUp (line 11) | def setUp(self):
    method tearDown (line 15) | def tearDown(self):
    method run_cell_test (line 18) | def run_cell_test(self, cell, state_tuple=False):
    method test_rnn_cell_is_half (line 42) | def test_rnn_cell_is_half(self):
    method test_gru_cell_is_half (line 46) | def test_gru_cell_is_half(self):
    method test_lstm_cell_is_half (line 50) | def test_lstm_cell_is_half(self):
  class TestRnns (line 54) | class TestRnns(unittest.TestCase):
    method setUp (line 55) | def setUp(self):
    method tearDown (line 59) | def tearDown(self):
    method run_rnn_test (line 62) | def run_rnn_test(self, rnn, layers, bidir, state_tuple=False):
    method test_rnn_is_half (line 76) | def test_rnn_is_half(self):
    method test_gru_is_half (line 83) | def test_gru_is_half(self):
    method test_lstm_is_half (line 90) | def test_lstm_is_half(self):
    method test_rnn_packed_sequence (line 97) | def test_rnn_packed_sequence(self):

FILE: apex/tests/L0/run_amp/utils.py
  function common_init (line 15) | def common_init(test_case):

FILE: apex/tests/L0/run_fp16util/test_fp16util.py
  class DummyBlock (line 9) | class DummyBlock(nn.Module):
    method __init__ (line 10) | def __init__(self):
    method forward (line 16) | def forward(self, x):
  class DummyNet (line 20) | class DummyNet(nn.Module):
    method __init__ (line 21) | def __init__(self):
    method forward (line 29) | def forward(self, x):
  class DummyNetWrapper (line 38) | class DummyNetWrapper(nn.Module):
    method __init__ (line 39) | def __init__(self):
    method forward (line 45) | def forward(self, x):
  class TestFP16Model (line 49) | class TestFP16Model(unittest.TestCase):
    method setUp (line 50) | def setUp(self):
    method test_params_and_buffers (line 59) | def test_params_and_buffers(self):
    method test_output_is_half (line 72) | def test_output_is_half(self):

FILE: apex/tests/L0/run_fused_layer_norm/test_fused_layer_norm.py
  class TestFusedLayerNorm (line 9) | class TestFusedLayerNorm(unittest.TestCase):
    method setUp (line 10) | def setUp(self):
    method forward_cpu (line 15) | def forward_cpu(self, input_):
    method forward_cuda (line 19) | def forward_cuda(self, input_):
    method test_forward_cuda (line 23) | def test_forward_cuda(self):
    method test_forward_cpu (line 27) | def test_forward_cpu(self):
    method test_same_output (line 31) | def test_same_output(self):
  class TestFusedLayerNormElemWise (line 37) | class TestFusedLayerNormElemWise(TestFusedLayerNorm):
    method setUp (line 38) | def setUp(self):

FILE: apex/tests/L0/run_mixed_adam/test_fp16_optimizer.py
  class TestFP16Optimizer (line 5) | class TestFP16Optimizer(unittest.TestCase):
    method setUp (line 6) | def setUp(self, max_abs_diff=1e-3, max_rel_diff=1, iters=7):
    method get_max_diff (line 22) | def get_max_diff(self, ref_param, tst_param):
    method test_fp16_optimizer (line 33) | def test_fp16_optimizer(self):
    method test_loss_scaling (line 55) | def test_loss_scaling(self):
    method test_parameter_groups (line 76) | def test_parameter_groups(self):
    method test_grad_clip (line 99) | def test_grad_clip(self):
    method test_grad_None (line 121) | def test_grad_None(self):
    method test_weight_decay (line 125) | def test_weight_decay(self):
    method test_group_empty (line 129) | def test_group_empty(self):

FILE: apex/tests/L0/run_mixed_adam/test_mixed_adam.py
  class TestFusedAdam (line 8) | class TestFusedAdam(unittest.TestCase):
    method setUp (line 9) | def setUp(self, max_abs_diff=1e-3, max_rel_diff=1, iters=7):
    method tearDown (line 15) | def tearDown(self):
    method gen_param_optim (line 18) | def gen_param_optim(self, tensors, adam_option):
    method gen_grad (line 30) | def gen_grad(self, ref_param, tst_param):
    method gen_mixed_grad (line 35) | def gen_mixed_grad(self, ref_param, tst_param, scale=1.0):
    method get_max_diff (line 42) | def get_max_diff(self, ref_param, tst_param):
    method gen_single_type_test (line 53) | def gen_single_type_test(self, param_type=torch.float):
    method test_double (line 71) | def test_double(self):
    method test_float (line 74) | def test_float(self):
    method test_half (line 77) | def test_half(self):
    method test_multi_params (line 95) | def test_multi_params(self):
    method test_scale (line 114) | def test_scale(self):
    method test_fp16_output (line 133) | def test_fp16_output(self):
    method test_adam_option (line 158) | def test_adam_option(self):

FILE: apex/tests/L1/common/main_amp.py
  function fast_collate (line 81) | def fast_collate(batch):
  function main (line 117) | def main():
  class data_prefetcher (line 263) | class data_prefetcher():
    method __init__ (line 264) | def __init__(self, loader):
    method preload (line 275) | def preload(self):
    method next (line 292) | def next(self):
  function train (line 300) | def train(train_loader, model, criterion, optimizer, epoch):
  function validate (line 398) | def validate(val_loader, model, criterion):
  function save_checkpoint (line 459) | def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):
  class AverageMeter (line 465) | class AverageMeter(object):
    method __init__ (line 467) | def __init__(self):
    method reset (line 470) | def reset(self):
    method update (line 476) | def update(self, val, n=1):
  function adjust_learning_rate (line 483) | def adjust_learning_rate(optimizer, epoch, step, len_epoch):
  function accuracy (line 503) | def accuracy(output, target, topk=(1,)):
  function reduce_tensor (line 519) | def reduce_tensor(tensor):

FILE: apex/tests/distributed/DDP/ddp_race_condition_test.py
  class Model (line 28) | class Model(Module):
    method __init__ (line 29) | def __init__(self):
    method forward (line 33) | def forward(self, input):
  function info (line 57) | def info(name, param, val):

FILE: apex/tests/distributed/synced_batchnorm/single_gpu_unit_test.py
  function compare (line 12) | def compare(desc, inp1, inp2, error):

FILE: apex/tests/distributed/synced_batchnorm/test_groups.py
  function compare (line 9) | def compare(desc, inp1, inp2, error):

FILE: apex/tests/distributed/synced_batchnorm/two_gpu_unit_test.py
  function compare (line 9) | def compare(desc, inp1, inp2, error):

FILE: jukebox/align.py
  function get_alignment (line 15) | def get_alignment(x, zs, labels, prior, fp16, hps):
  function save_alignment (line 85) | def save_alignment(model, device, hps):
  function run (line 100) | def run(model, port=29500, **kwargs):

FILE: jukebox/data/artist_genre_processor.py
  function norm (line 10) | def norm(s):
  function create_reverse_lookup (line 15) | def create_reverse_lookup(atoi):
  class ArtistGenreProcessor (line 27) | class ArtistGenreProcessor():
    method __init__ (line 28) | def __init__(self, v3=False):
    method get_artist_id (line 40) | def get_artist_id(self, artist):
    method get_genre_ids (line 51) | def get_genre_ids(self, genre):
    method get_artist (line 64) | def get_artist(self, artist_id):
    method get_genre (line 67) | def get_genre(self, genre_ids):
    method load_artists (line 75) | def load_artists(self):
    method load_genres (line 84) | def load_genres(self):

FILE: jukebox/data/data_processor.py
  class OffsetDataset (line 9) | class OffsetDataset(Dataset):
    method __init__ (line 10) | def __init__(self, dataset, start, end, test=False):
    method __len__ (line 18) | def __len__(self):
    method __getitem__ (line 21) | def __getitem__(self, item):
  class DataProcessor (line 24) | class DataProcessor():
    method __init__ (line 25) | def __init__(self, hps):
    method set_epoch (line 34) | def set_epoch(self, epoch):
    method create_datasets (line 38) | def create_datasets(self, hps):
    method create_samplers (line 43) | def create_samplers(self, hps):
    method create_data_loaders (line 51) | def create_data_loaders(self, hps):
    method print_stats (line 66) | def print_stats(self, hps):

FILE: jukebox/data/files_dataset.py
  class FilesAudioDataset (line 10) | class FilesAudioDataset(Dataset):
    method __init__ (line 11) | def __init__(self, hps):
    method filter (line 23) | def filter(self, files, durations):
    method init_dataset (line 38) | def init_dataset(self, hps):
    method get_index_offset (line 49) | def get_index_offset(self, item):
    method get_metadata (line 67) | def get_metadata(self, filename, test):
    method get_song_chunk (line 80) | def get_song_chunk(self, index, offset, test=False):
    method get_item (line 91) | def get_item(self, item, test=False):
    method __len__ (line 95) | def __len__(self):
    method __getitem__ (line 98) | def __getitem__(self, item):

FILE: jukebox/data/labels.py
  function get_relevant_lyric_tokens (line 7) | def get_relevant_lyric_tokens(full_tokens, n_tokens, total_length, offse...
  class EmptyLabeller (line 22) | class EmptyLabeller():
    method get_label (line 23) | def get_label(self, artist=None, genre=None, lyrics=None, total_length...
    method get_batch_labels (line 28) | def get_batch_labels(self, metas, device='cpu'):
  class Labeller (line 41) | class Labeller():
    method __init__ (line 42) | def __init__(self, max_genre_words, n_tokens, sample_length, v3=False):
    method get_label (line 50) | def get_label(self, artist, genre, lyrics, total_length, offset):
    method get_y_from_ids (line 65) | def get_y_from_ids(self, artist_id, genre_ids, lyric_tokens, total_len...
    method get_batch_labels (line 76) | def get_batch_labels(self, metas, device='cpu'):
    method set_y_lyric_tokens (line 89) | def set_y_lyric_tokens(self, ys, labels):
    method describe_label (line 107) | def describe_label(self, y):

FILE: jukebox/data/text_processor.py
  class TextProcessor (line 4) | class TextProcessor():
    method __init__ (line 5) | def __init__(self, v3=False):
    method clean (line 19) | def clean(self, text):
    method tokenise (line 25) | def tokenise(self, text):
    method textise (line 28) | def textise(self, tokens):
    method characterise (line 31) | def characterise(self, tokens):

FILE: jukebox/hparams.py
  class Hyperparams (line 4) | class Hyperparams(dict):
    method __getattr__ (line 5) | def __getattr__(self, attr):
    method __setattr__ (line 8) | def __setattr__(self, attr, value):
  function setup_hparams (line 11) | def setup_hparams(hparam_set_names, kwargs):

FILE: jukebox/make_models.py
  function load_checkpoint (line 24) | def load_checkpoint(path):
  function save_checkpoint (line 41) | def save_checkpoint(logger, name, model, opt, metrics, hps):
  function restore_model (line 52) | def restore_model(hps, model, checkpoint_path):
  function restore_opt (line 64) | def restore_opt(opt, shd, checkpoint_path):
  function make_vqvae (line 73) | def make_vqvae(hps, device='cuda'):
  function make_prior (line 112) | def make_prior(hps, vqvae, device='cuda'):
  function make_model (line 189) | def make_model(model, device, hps, levels=None):
  function save_outputs (line 198) | def save_outputs(model, device, hps):
  function run (line 245) | def run(model, port=29500, **kwargs):

FILE: jukebox/prior/autoregressive.py
  function get_normal (line 11) | def get_normal(*shape, std=0.01):
  function roll (line 16) | def roll(x, n):
  function split_chunks (line 19) | def split_chunks(length, chunk_size):
  class PositionEmbedding (line 25) | class PositionEmbedding(nn.Module):
    method __init__ (line 26) | def __init__(self, input_shape, width, init_scale=1.0, pos_init=False):
    method forward (line 41) | def forward(self):
  class ConditionalAutoregressive2D (line 48) | class ConditionalAutoregressive2D(nn.Module):
    method __init__ (line 49) | def __init__(self, input_shape, bins,
    method preprocess (line 101) | def preprocess(self, x):
    method postprocess (line 107) | def postprocess(self, x, sample_tokens=None):
    method forward (line 116) | def forward(self, x, x_cond=None, y_cond=None, encoder_kv=None, fp16=F...
    method get_emb (line 177) | def get_emb(self, sample_t, n_samples, x, x_cond, y_cond):
    method sample (line 199) | def sample(self, n_samples, x_cond=None, y_cond=None, encoder_kv=None,...
    method primed_sample (line 251) | def primed_sample(self, n_samples, x, x_cond=None, y_cond=None, encode...
    method check_sample (line 361) | def check_sample(self, chunk_size):
  function test_prior (line 391) | def test_prior(input_shape, encoder_dims, blocks, heads, chunk_size):

FILE: jukebox/prior/conditioners.py
  class Conditioner (line 8) | class Conditioner(nn.Module):
    method __init__ (line 9) | def __init__(self, input_shape, bins, down_t, stride_t, out_width, ini...
    method preprocess (line 22) | def preprocess(self, x):
    method postprocess (line 26) | def postprocess(self, x):
    method forward (line 30) | def forward(self, x, x_cond=None):
  function flip (line 50) | def flip(x):
  class SimpleEmbedding (line 57) | class SimpleEmbedding(nn.Module):
    method __init__ (line 58) | def __init__(self, bins, out_width, init_scale):
    method forward (line 64) | def forward(self, y):
  class RangeEmbedding (line 70) | class RangeEmbedding(nn.Module):
    method __init__ (line 79) | def __init__(self, n_time, bins, range, out_width, init_scale, clamp=F...
    method forward (line 88) | def forward(self, pos_start, pos_end=None):
  class LabelConditioner (line 113) | class LabelConditioner(nn.Module):
    method __init__ (line 114) | def __init__(self, y_bins, t_bins, sr, min_duration, max_duration, n_t...
    method forward (line 134) | def forward(self, y):

FILE: jukebox/prior/prior.py
  class SimplePrior (line 27) | class SimplePrior(nn.Module):
    method __init__ (line 28) | def __init__(self, z_shapes, l_bins, encoder, decoder, level,
    method get_y (line 140) | def get_y(self, labels, start, get_indices=False):
    method get_z_conds (line 158) | def get_z_conds(self, zs, start, end):
    method prior_preprocess (line 168) | def prior_preprocess(self, xs, conds):
    method prior_postprocess (line 187) | def prior_postprocess(self, z):
    method x_emb (line 205) | def x_emb(self, z_conds):
    method encode (line 213) | def encode(self, x, start_level=None, end_level=None, bs_chunks=1):
    method decode (line 223) | def decode(self, zs, start_level=None, end_level=None, bs_chunks=1):
    method get_cond (line 234) | def get_cond(self, z_conds, y):
    method sample (line 245) | def sample(self, n_samples, z=None, z_conds=None, y=None, fp16=False, ...
    method get_encoder_kv (line 285) | def get_encoder_kv(self, prime, fp16=False, sample=False):
    method get_prime_loss (line 303) | def get_prime_loss(self, encoder_kv, prime_t):
    method z_forward (line 312) | def z_forward(self, z, z_conds=[], y=None, fp16=False, get_preds=False...
    method forward (line 346) | def forward(self, x, y=None, fp16=False, decode=False, get_preds=False):

FILE: jukebox/sample.py
  function sample_partial_window (line 17) | def sample_partial_window(zs, labels, sampling_kwargs, level, prior, tok...
  function sample_single_window (line 31) | def sample_single_window(zs, labels, sampling_kwargs, level, prior, star...
  function sample_level (line 81) | def sample_level(zs, labels, sampling_kwargs, level, prior, total_length...
  function _sample (line 91) | def _sample(zs, labels, sampling_kwargs, priors, sample_levels, hps):
  function ancestral_sample (line 124) | def ancestral_sample(labels, sampling_kwargs, priors, hps):
  function continue_sample (line 131) | def continue_sample(zs, labels, sampling_kwargs, priors, hps):
  function upsample (line 137) | def upsample(zs, labels, sampling_kwargs, priors, hps):
  function primed_sample (line 143) | def primed_sample(x, labels, sampling_kwargs, priors, hps):
  function load_prompts (line 150) | def load_prompts(audio_files, duration, hps):
  function load_codes (line 164) | def load_codes(codes_file, duration, priors, hps):
  function save_samples (line 178) | def save_samples(model, device, hps, sample_hps):
  function run (line 269) | def run(model, mode='ancestral', codes_file=None, audio_file=None, promp...

FILE: jukebox/save_html.py
  function save_html (line 7) | def save_html(logdir, x, zs, labels, alignments, hps):
  function _save_item_html (line 28) | def _save_item_html(item_dir, item_id, item_name, data):

FILE: jukebox/tests/test_sample.py
  function repeat (line 7) | def repeat(x, n, dim):
  class DummyPrior (line 13) | class DummyPrior:
    method __init__ (line 14) | def __init__(self, n_ctx, level, levels):
    method get_y (line 25) | def get_y(self, labels, start):
    method get_z_conds (line 33) | def get_z_conds(self, zs, start, end):
    method ancestral_sample (line 43) | def ancestral_sample(self, n_samples, z_conds=None, y=None):
    method primed_sample (line 53) | def primed_sample(self, n_samples, z, z_conds=None, y=None):
  function _sample (line 67) | def _sample(zs, labels,  priors, sample_levels, hps):
  function test_ancestral_sample (line 77) | def test_ancestral_sample(labels, priors, hps):
  function test_primed_sample (line 90) | def test_primed_sample(labels, priors, hps):
  function check_sample (line 120) | def check_sample():

FILE: jukebox/train.py
  function prepare_aud (line 24) | def prepare_aud(x, hps):
  function log_aud (line 28) | def log_aud(logger, tag, x, hps):
  function log_labels (line 32) | def log_labels(logger, labeller, tag, y, hps):
  function get_ddp (line 42) | def get_ddp(model, hps):
  function get_ema (line 48) | def get_ema(model, hps):
  function get_lr_scheduler (line 62) | def get_lr_scheduler(opt, hps):
  function get_optimizer (line 78) | def get_optimizer(model, hps):
  function log_inputs (line 103) | def log_inputs(orig_model, logger, x_in, y, x_out, hps, tag="train"):
  function sample_prior (line 118) | def sample_prior(orig_model, ema, logger, x_in, y, hps):
  function evaluate (line 153) | def evaluate(model, orig_model, logger, metrics, data_processor, hps):
  function train (line 203) | def train(model, orig_model, opt, shd, scalar, ema, logger, metrics, dat...
  function run (line 294) | def run(hps="teeny", port=29500, **kwargs):

FILE: jukebox/transformer/factored_attention.py
  function repeat (line 10) | def repeat(x, n, dim):
  function get_mask (line 15) | def get_mask(mask, q_l, kv_l, blocks, spread, device, sample, sample_t):
  class FactoredAttention (line 30) | class FactoredAttention(nn.Module):
    method __init__ (line 31) | def __init__(self, n_in, n_ctx, n_state, n_head,
    method _attn (line 82) | def _attn(self, q, k, v, sample):
    method merge_heads (line 110) | def merge_heads(self, x):
    method split_heads (line 115) | def split_heads(self, x, k=False):
    method dense_attn (line 123) | def dense_attn(self, query, key, value, sample):
    method block_attn (line 135) | def block_attn(self, q, k, v, sample):
    method transpose_block_attn (line 152) | def transpose_block_attn(self, q, k, v, sample):
    method prev_block_attn (line 167) | def prev_block_attn(self, q, k, v, sample):
    method summary_attn (line 195) | def summary_attn(self, q, k, v, sample):
    method summary_spread_attn (line 207) | def summary_spread_attn(self, q, k, v, sample):
    method prime_attn (line 220) | def prime_attn(self, q, k, v, sample):
    method decode_attn (line 226) | def decode_attn(self, q, k, v, sample):
    method factored_qkv (line 230) | def factored_qkv(self, x, encoder_kv=None, sample=False):
    method prime_qkv (line 255) | def prime_qkv(self, x, encoder_kv=None, sample=False):
    method decode_qkv (line 273) | def decode_qkv(self, x, encoder_kv=None, sample=False):
    method forward (line 289) | def forward(self, x, encoder_kv=None, sample=False):
    method _prime_len (line 304) | def _prime_len(self):
    method _offset (line 310) | def _offset(self, curr_ctx):
    method _pad_to_block_ctx (line 315) | def _pad_to_block_ctx(self, x, query=False):
    method _cache_len (line 325) | def _cache_len(self):
    method _suff_cache_len (line 328) | def _suff_cache_len(self):
    method _slice_cache (line 355) | def _slice_cache(self, start, end=None):
    method _append_cache (line 359) | def _append_cache(self, key, value):
    method del_cache (line 375) | def del_cache(self):
    method check (line 383) | def check(self):
    method check_cache (line 412) | def check_cache(self, n_samples, sample_t, fp16):
    method check_sample (line 424) | def check_sample(self):
    method check_chunks (line 457) | def check_chunks(self, chunk_size):

FILE: jukebox/transformer/ops.py
  class LayerNorm (line 14) | class LayerNorm(FusedLayerNorm):
    method __init__ (line 15) | def __init__(self, normalized_shape, eps=1e-5, elementwise_affine=True):
    method forward (line 20) | def forward(self, input):
  function gelu (line 26) | def gelu(x):
  function swish (line 30) | def swish(x):
  function quick_gelu (line 34) | def quick_gelu(x):
  function quick_gelu_bwd (line 38) | def quick_gelu_bwd(x, grad_output):
  class QuickGelu (line 42) | class QuickGelu(t.autograd.Function):
    method forward (line 44) | def forward(ctx, x):
    method backward (line 49) | def backward(ctx, grad_output):
  function memory_efficient_quick_gelu (line 52) | def memory_efficient_quick_gelu(x):
  function _move_to_gpu_and_convert_conv_weights_to_fp16 (line 62) | def _move_to_gpu_and_convert_conv_weights_to_fp16(l):
  function _convert_conv_weights_to_fp32 (line 67) | def _convert_conv_weights_to_fp32(l):
  function _convert_conv_weights_to_fp16 (line 71) | def _convert_conv_weights_to_fp16(l):
  function _convert_embedding_weights_to_fp16 (line 75) | def _convert_embedding_weights_to_fp16(l):
  function _convert_embedding_weights_to_fp32 (line 79) | def _convert_embedding_weights_to_fp32(l):
  class Conv1D (line 83) | class Conv1D(nn.Module):
    method __init__ (line 84) | def __init__(self, n_in, n_out, zero_out=False, init_scale=1.0):
    method forward (line 97) | def forward(self, x):
  class Mask (line 104) | class Mask(nn.Module):
    method __init__ (line 105) | def __init__(self, n_ctx):
    method forward (line 109) | def forward(self, w):
  function filter_logits (line 113) | def filter_logits(logits, top_k=0, top_p=0.0, filter_value=-float('Inf')):

FILE: jukebox/transformer/transformer.py
  function _convert_mlp_traced (line 11) | def _convert_mlp_traced(l):
  function _convert_mlp_traced_fp16 (line 15) | def _convert_mlp_traced_fp16(l):
  class MLP (line 19) | class MLP(nn.Module):
    method __init__ (line 20) | def __init__(self, n_in, n_state, resid_dropout=0.0, afn='quick_gelu',...
    method forward (line 27) | def forward(self, x):
  class ResAttnBlock (line 32) | class ResAttnBlock(nn.Module):
    method __init__ (line 33) | def __init__(self, n_in, n_ctx, n_head,
    method forward (line 62) | def forward(self, x, encoder_kv, sample=False):
  class Transformer (line 88) | class Transformer(nn.Module):
    method __init__ (line 89) | def __init__(self, n_in, n_ctx, n_head, n_depth,
    method set_record_attn (line 146) | def set_record_attn(self, record_attn):
    method forward (line 169) | def forward(self, x, encoder_kv=None, sample=False, fp16=False, fp16_o...
    method check_cache (line 194) | def check_cache(self, n_samples, sample_t, fp16):
    method del_cache (line 198) | def del_cache(self):
    method check_sample (line 202) | def check_sample(self):

FILE: jukebox/utils/audio_utils.py
  class DefaultSTFTValues (line 8) | class DefaultSTFTValues:
    method __init__ (line 9) | def __init__(self, hps):
  class STFTValues (line 15) | class STFTValues:
    method __init__ (line 16) | def __init__(self, hps, n_fft, hop_length, window_size):
  function calculate_bandwidth (line 22) | def calculate_bandwidth(dataset, hps, duration=600):
  function audio_preprocess (line 58) | def audio_preprocess(x, hps):
  function audio_postprocess (line 79) | def audio_postprocess(x, hps):
  function stft (line 82) | def stft(sig, hps):
  function spec (line 85) | def spec(x, hps):
  function norm (line 88) | def norm(x):
  function squeeze (line 91) | def squeeze(x):
  function spectral_loss (line 99) | def spectral_loss(x_in, x_out, hps):
  function multispectral_loss (line 105) | def multispectral_loss(x_in, x_out, hps):
  function spectral_convergence (line 118) | def spectral_convergence(x_in, x_out, hps, epsilon=2e-3):
  function log_magnitude_loss (line 128) | def log_magnitude_loss(x_in, x_out, hps, epsilon=1e-4):
  function load_audio (line 134) | def load_audio(file, sr, offset, duration, mono=False):
  function save_wav (line 142) | def save_wav(fname, aud, sr):

FILE: jukebox/utils/checkpoint.py
  function checkpoint (line 4) | def checkpoint(func, inputs, params, flag):
  class CheckpointFunction (line 11) | class CheckpointFunction(t.autograd.Function):
    method forward (line 13) | def forward(ctx, run_function, length, *args):
    method backward (line 22) | def backward(ctx, *output_grads):

FILE: jukebox/utils/dist_adapter.py
  class ReduceOp (line 4) | class ReduceOp(Enum):
    method ToDistOp (line 10) | def ToDistOp(self):
  function is_available (line 18) | def is_available():
  function get_rank (line 21) | def get_rank():
  function get_world_size (line 27) | def get_world_size():
  function barrier (line 33) | def barrier():
  function all_gather (line 38) | def all_gather(tensor_list, tensor):
  function all_reduce (line 44) | def all_reduce(tensor, op=ReduceOp.SUM):
  function reduce (line 49) | def reduce(tensor, dst, op=ReduceOp.SUM):
  function broadcast (line 54) | def broadcast(tensor, src):
  function init_process_group (line 59) | def init_process_group(backend, init_method):
  function _get_rank (line 64) | def _get_rank():
  function _barrier (line 67) | def _barrier():
  function _get_world_size (line 70) | def _get_world_size():
  function _all_gather (line 73) | def _all_gather(tensor_list, tensor):
  function _all_reduce (line 76) | def _all_reduce(tensor, op):
  function _reduce (line 79) | def _reduce(tensor, dst, op):
  function _broadcast (line 82) | def _broadcast(tensor, src):
  function _init_process_group (line 85) | def _init_process_group(backend, init_method):

FILE: jukebox/utils/dist_utils.py
  function print_once (line 6) | def print_once(msg):
  function print_all (line 10) | def print_all(msg):
  function allgather (line 16) | def allgather(x):
  function allreduce (line 22) | def allreduce(x, op=dist.ReduceOp.SUM):
  function allgather_lists (line 27) | def allgather_lists(xs):
  function setup_dist_from_mpi (line 42) | def setup_dist_from_mpi(
  function _setup_dist_from_mpi (line 59) | def _setup_dist_from_mpi(master_addr, backend, port, n_attempts, verbose):

FILE: jukebox/utils/ema.py
  class EMA (line 6) | class EMA:
    method __init__ (line 7) | def __init__(self, params, mu=0.999):
    method get_model_state (line 11) | def get_model_state(self, p):
    method step (line 14) | def step(self):
    method swap (line 18) | def swap(self):
  class CPUEMA (line 26) | class CPUEMA:
    method __init__ (line 27) | def __init__(self, params, mu=0.999, freq=1):
    method get_model_state (line 33) | def get_model_state(self, p):
    method step (line 38) | def step(self):
    method swap (line 48) | def swap(self):
  class FusedEMA (line 56) | class FusedEMA:
    method __init__ (line 57) | def __init__(self, params, mu=0.999):
    method get_model_state (line 68) | def get_model_state(self, group):
    method step (line 76) | def step(self):
    method swap (line 80) | def swap(self):

FILE: jukebox/utils/fp16.py
  function adam_step (line 12) | def adam_step(p: torch.Tensor, out_p: torch.Tensor, exp_avg: torch.Tenso...
  function backward (line 39) | def backward(loss, params, scalar, fp16, logger):
  class LossScalar (line 68) | class LossScalar(object):
    method __init__ (line 69) | def __init__(self,
    method get_scale (line 87) | def get_scale(self):
    method update_scale (line 90) | def update_scale(self, overflow):
  function check_overflow (line 101) | def check_overflow(val):
  function grad_norm (line 104) | def grad_norm(params, scale, flat=False):
  function clipped_grad_scale (line 122) | def clipped_grad_scale(grad_norm, max_grad_norm, scale):
  class FP16FusedAdam (line 128) | class FP16FusedAdam(Optimizer):
    method __init__ (line 129) | def __init__(
    method init_state (line 150) | def init_state(self):
    method step (line 165) | def step(self, closure=None, scale=1.0):
  class FusedAdam (line 229) | class FusedAdam(Optimizer):
    method __init__ (line 230) | def __init__(
    method step (line 249) | def step(self, closure=None, scale=1.0):

FILE: jukebox/utils/io.py
  function get_duration_sec (line 6) | def get_duration_sec(file, cache=False):
  function load_audio (line 20) | def load_audio(file, sr, offset, duration, resample=True, approx=False, ...
  function test_simple_loader (line 59) | def test_simple_loader():
  function test_dataset_loader (line 87) | def test_dataset_loader():

FILE: jukebox/utils/logger.py
  function def_tqdm (line 8) | def def_tqdm(x):
  function get_range (line 11) | def get_range(x):
  function init_logging (line 17) | def init_logging(hps, local_rank, rank):
  function get_name (line 30) | def get_name(hps):
  function average_metrics (line 36) | def average_metrics(_metrics):
  class Metrics (line 45) | class Metrics:
    method __init__ (line 46) | def __init__(self):
    method update (line 50) | def update(self, tag, val, batch):
    method avg (line 63) | def avg(self, tag):
    method reset (line 69) | def reset(self):
  class Logger (line 73) | class Logger:
    method __init__ (line 74) | def __init__(self, logdir, rank):
    method step (line 83) | def step(self):
    method flush (line 86) | def flush(self):
    method add_text (line 90) | def add_text(self, tag, text):
    method add_audios (line 94) | def add_audios(self, tag, auds, sample_rate=22050, max_len=None, max_l...
    method add_audio (line 102) | def add_audio(self, tag, aud, sample_rate=22050):
    method add_images (line 106) | def add_images(self, tag, img, dataformats="NHWC"):
    method add_image (line 110) | def add_image(self, tag, img):
    method add_scalar (line 114) | def add_scalar(self, tag, val):
    method get_range (line 118) | def get_range(self, loader):
    method close_range (line 125) | def close_range(self):
    method set_postfix (line 129) | def set_postfix(self, *args, **kwargs):
    method add_reduce_scalar (line 134) | def add_reduce_scalar(self, tag, layer, val):
    method finish_reduce (line 141) | def finish_reduce(self):

FILE: jukebox/utils/remote_utils.py
  function download (line 4) | def download(remote_path, local_path, async_download=False):
  function gs_download (line 13) | def gs_download(gs_path, local_path, async_download=False):
  function gs_upload (line 24) | def gs_upload(local_path, gs_path, async_upload=False):
  function ls (line 37) | def ls(regex):

FILE: jukebox/utils/sample_utils.py
  function split_batch (line 3) | def split_batch(obj, n_samples, split_size):
  function get_starts (line 15) | def get_starts(total_length, n_ctx, hop_length):

FILE: jukebox/utils/torch_utils.py
  function freeze_model (line 4) | def freeze_model(model):
  function unfreeze_model (line 10) | def unfreeze_model(model):
  function zero_grad (line 15) | def zero_grad(model):
  function empty_cache (line 20) | def empty_cache():
  function assert_shape (line 24) | def assert_shape(x, exp_shape):
  function count_parameters (line 27) | def count_parameters(model):
  function count_state (line 30) | def count_state(model):

FILE: jukebox/vqvae/bottleneck.py
  class BottleneckBlock (line 7) | class BottleneckBlock(nn.Module):
    method __init__ (line 8) | def __init__(self, k_bins, emb_width, mu):
    method reset_k (line 16) | def reset_k(self):
    method _tile (line 22) | def _tile(self, x):
    method init_k (line 31) | def init_k(self, x):
    method restore_k (line 43) | def restore_k(self, num_tokens=None, threshold=1.0):
    method update_k (line 55) | def update_k(self, x, x_l):
    method preprocess (line 88) | def preprocess(self, x):
    method postprocess (line 105) | def postprocess(self, x_l, x_d, x_shape):
    method quantise (line 112) | def quantise(self, x):
    method dequantise (line 121) | def dequantise(self, x_l):
    method encode (line 125) | def encode(self, x):
    method decode (line 138) | def decode(self, x_l):
    method forward (line 149) | def forward(self, x, update_k=True):
  class Bottleneck (line 182) | class Bottleneck(nn.Module):
    method __init__ (line 183) | def __init__(self, l_bins, emb_width, mu, levels):
    method encode (line 191) | def encode(self, xs):
    method decode (line 195) | def decode(self, zs, start_level=0, end_level=None):
    method forward (line 201) | def forward(self, xs):
  class NoBottleneckBlock (line 218) | class NoBottleneckBlock(nn.Module):
    method restore_k (line 219) | def restore_k(self):
  class NoBottleneck (line 222) | class NoBottleneck(nn.Module):
    method __init__ (line 223) | def __init__(self, levels):
    method encode (line 230) | def encode(self, xs):
    method decode (line 233) | def decode(self, zs, start_level=0, end_level=None):
    method forward (line 238) | def forward(self, xs):

FILE: jukebox/vqvae/encdec.py
  class EncoderConvBlock (line 6) | class EncoderConvBlock(nn.Module):
    method __init__ (line 7) | def __init__(self, input_emb_width, output_emb_width, down_t,
    method forward (line 25) | def forward(self, x):
  class DecoderConvBock (line 28) | class DecoderConvBock(nn.Module):
    method __init__ (line 29) | def __init__(self, input_emb_width, output_emb_width, down_t,
    method forward (line 45) | def forward(self, x):
  class Encoder (line 48) | class Encoder(nn.Module):
    method __init__ (line 49) | def __init__(self, input_emb_width, output_emb_width, levels, downs_t,
    method forward (line 70) | def forward(self, x):
  class Decoder (line 87) | class Decoder(nn.Module):
    method __init__ (line 88) | def __init__(self, input_emb_width, output_emb_width, levels, downs_t,
    method forward (line 110) | def forward(self, xs, all_levels=True):

FILE: jukebox/vqvae/resnet.py
  class ResConvBlock (line 6) | class ResConvBlock(nn.Module):
    method __init__ (line 7) | def __init__(self, n_in, n_state):
    method forward (line 16) | def forward(self, x):
  class Resnet (line 19) | class Resnet(nn.Module):
    method __init__ (line 20) | def __init__(self, n_in, n_depth, m_conv=1.0):
    method forward (line 24) | def forward(self, x):
  class ResConv1DBlock (line 27) | class ResConv1DBlock(nn.Module):
    method __init__ (line 28) | def __init__(self, n_in, n_state, dilation=1, zero_out=False, res_scal...
    method forward (line 43) | def forward(self, x):
  class Resnet1D (line 46) | class Resnet1D(nn.Module):
    method __init__ (line 47) | def __init__(self, n_in, n_depth, m_conv=1.0, dilation_growth_rate=1, ...
    method forward (line 69) | def forward(self, x):

FILE: jukebox/vqvae/vqvae.py
  function dont_update (line 10) | def dont_update(params):
  function update (line 14) | def update(params):
  function calculate_strides (line 18) | def calculate_strides(strides, downs):
  function _loss_fn (line 21) | def _loss_fn(loss_fn, x_target, x_pred, hps):
  class VQVAE (line 42) | class VQVAE(nn.Module):
    method __init__ (line 43) | def __init__(self, input_shape, levels, downs_t, strides_t,
    method preprocess (line 90) | def preprocess(self, x):
    method postprocess (line 96) | def postprocess(self, x):
    method _decode (line 101) | def _decode(self, zs, start_level=0, end_level=None):
    method decode (line 115) | def decode(self, zs, start_level=0, end_level=None, bs_chunks=1):
    method _encode (line 124) | def _encode(self, x, start_level=0, end_level=None):
    method encode (line 137) | def encode(self, x, start_level=0, end_level=None, bs_chunks=1):
    method sample (line 146) | def sample(self, n_samples):
    method forward (line 150) | def forward(self, x, hps, loss_fn='l1'):

FILE: tensorboardX/examples/chainer/extension_logger/net.py
  function add_noise (line 13) | def add_noise(h, sigma=0.2):
  class Generator (line 21) | class Generator(chainer.Chain):
    method __init__ (line 23) | def __init__(self, n_hidden, bottom_width=4, ch=512, wscale=0.02):
    method make_hidden (line 42) | def make_hidden(self, batchsize):
    method __call__ (line 46) | def __call__(self, z):
  class Discriminator (line 56) | class Discriminator(chainer.Chain):
    method __init__ (line 58) | def __init__(self, bottom_width=4, ch=512, wscale=0.02):
    method __call__ (line 77) | def __call__(self, x):

FILE: tensorboardX/examples/chainer/extension_logger/train_dcgan.py
  function main (line 19) | def main():

FILE: tensorboardX/examples/chainer/extension_logger/updater.py
  class DCGANUpdater (line 10) | class DCGANUpdater(chainer.training.StandardUpdater):
    method __init__ (line 12) | def __init__(self, *args, **kwargs):
    method loss_dis (line 16) | def loss_dis(self, dis, y_fake, y_real):
    method loss_gen (line 24) | def loss_gen(self, gen, y_fake):
    method update_core (line 30) | def update_core(self):

FILE: tensorboardX/examples/chainer/extension_logger/visualize.py
  function out_generated_image (line 13) | def out_generated_image(gen, dis, rows, cols, seed, dst, writer):

FILE: tensorboardX/examples/chainer/extension_logger/writetensorboard.py
  class LogTensorboard (line 13) | class LogTensorboard(extension.Extension):
    method __init__ (line 56) | def __init__(self, keys=None, trigger=(1, 'epoch'), postprocess=None,
    method __call__ (line 66) | def __call__(self, trainer):
    method log (line 111) | def log(self):
    method serialize (line 115) | def serialize(self, serializer):
    method _init_summary (line 128) | def _init_summary(self):

FILE: tensorboardX/examples/chainer/plain_logger/data.py
  function load_mnist (line 18) | def load_mnist(images, labels, num):
  function download_mnist_data (line 34) | def download_mnist_data():
  function load_mnist_data (line 64) | def load_mnist_data():

FILE: tensorboardX/examples/chainer/plain_logger/net.py
  class VAE (line 9) | class VAE(chainer.Chain):
    method __init__ (line 12) | def __init__(self, n_in, n_latent, n_h):
    method __call__ (line 23) | def __call__(self, x, sigmoid=True):
    method encode (line 27) | def encode(self, x):
    method decode (line 33) | def decode(self, z, sigmoid=True):
    method get_loss_func (line 41) | def get_loss_func(self, C=1.0, k=1):

FILE: tensorboardX/examples/chainer/plain_logger/train_vae.py
  function save_images (line 148) | def save_images(x, filename):

FILE: tensorboardX/examples/demo_beholder.py
  function beholder_pytorch (line 35) | def beholder_pytorch():

FILE: tensorboardX/examples/demo_caffe2.py
  function DownloadResource (line 28) | def DownloadResource(url, path):
  function AddInput (line 88) | def AddInput(model, batch_size, db, db_type):
  function AddLeNetModel (line 102) | def AddLeNetModel(model, data):
  function AddAccuracy (line 130) | def AddAccuracy(model, softmax, label):
  function AddTrainingOperators (line 136) | def AddTrainingOperators(model, softmax, label):
  function AddBookkeepingOperators (line 163) | def AddBookkeepingOperators(model):

FILE: tensorboardX/examples/demo_embedding.py
  class M (line 14) | class M(nn.Module):
    method __init__ (line 15) | def __init__(self):
    method forward (line 21) | def forward(self, i):
  function get_data (line 36) | def get_data(value, shape):

FILE: tensorboardX/examples/demo_graph.py
  class LinearInLinear (line 11) | class LinearInLinear(nn.Module):
    method __init__ (line 12) | def __init__(self):
    method forward (line 16) | def forward(self, x):
  class MultipleInput (line 23) | class MultipleInput(nn.Module):
    method __init__ (line 24) | def __init__(self):
    method forward (line 29) | def forward(self, x, y):
  class MultipleOutput (line 35) | class MultipleOutput(nn.Module):
    method __init__ (line 36) | def __init__(self):
    method forward (line 41) | def forward(self, x):
  class MultipleOutput_shared (line 48) | class MultipleOutput_shared(nn.Module):
    method __init__ (line 49) | def __init__(self):
    method forward (line 53) | def forward(self, x):
  class SimpleModel (line 60) | class SimpleModel(nn.Module):
    method __init__ (line 61) | def __init__(self):
    method forward (line 64) | def forward(self, x):
  function conv3x3 (line 75) | def conv3x3(in_planes, out_planes, stride=1):
  class BasicBlock (line 81) | class BasicBlock(nn.Module):
    method __init__ (line 84) | def __init__(self, inplanes, planes, stride=1, downsample=None):
    method forward (line 93) | def forward(self, x):
  class Net1 (line 115) | class Net1(nn.Module):
    method __init__ (line 116) | def __init__(self):
    method forward (line 125) | def forward(self, x):
  class Net2 (line 138) | class Net2(nn.Module):
    method __init__ (line 139) | def __init__(self):
    method forward (line 147) | def forward(self, x):
  class SiameseNetwork (line 169) | class SiameseNetwork(nn.Module):
    method __init__ (line 170) | def __init__(self):
    method forward_once (line 174) | def forward_once(self, x):
    method forward (line 178) | def forward(self, input1, input2):
  class RNN (line 208) | class RNN(nn.Module):
    method __init__ (line 209) | def __init__(self, input_size, hidden_size, output_size):
    method forward (line 226) | def forward(self, category, input, hidden):
    method initHidden (line 236) | def initHidden(self):

FILE: tensorboardX/examples/demo_hparams.py
  function train (line 12) | def train(lr, bsize, n_hidden):

FILE: tensorboardX/examples/demo_multiple_embedding.py
  function main (line 6) | def main():

FILE: tensorboardX/setup.py
  function compileProtoBuf (line 11) | def compileProtoBuf():
  class PostDevelopCommand (line 15) | class PostDevelopCommand(develop):
    method run (line 17) | def run(self):
  class PostInstallCommand (line 22) | class PostInstallCommand(install):
    method run (line 24) | def run(self):

FILE: tensorboardX/tensorboardX/beholder/beholder.py
  class Beholder (line 39) | class Beholder(object):
    method __init__ (line 41) | def __init__(self, logdir):
    method _get_config (line 60) | def _get_config(self):
    method _write_summary (line 74) | def _write_summary(self, frame):
    method stats (line 92) | def stats(tensor_and_name):
    method _get_final_image (line 109) | def _get_final_image(self, config, trainable=None, arrays=None, frame=...
    method _enough_time_has_passed (line 130) | def _enough_time_has_passed(self, FPS):
    method _update_frame (line 138) | def _update_frame(self, trainable, arrays, frame, config):
    method _update_recording (line 145) | def _update_recording(self, frame, config):
    method update (line 163) | def update(self, trainable=None, arrays=None, frame=None):
  class BeholderHook (line 201) | class BeholderHook():

FILE: tensorboardX/tensorboardX/beholder/file_system_tools.py
  function write_file (line 25) | def write_file(contents, path, mode='wb'):
  function write_pickle (line 30) | def write_pickle(obj, path):
  function read_pickle (line 35) | def read_pickle(path, default=None):

FILE: tensorboardX/tensorboardX/beholder/video_writing.py
  class VideoWriter (line 27) | class VideoWriter(object):
    method __init__ (line 34) | def __init__(self, directory, outputs):
    method current_output (line 44) | def current_output(self):
    method write_frame (line 47) | def write_frame(self, np_array):
    method finish (line 75) | def finish(self):
  class VideoOutput (line 84) | class VideoOutput(object):
    method available (line 91) | def available(cls):
    method name (line 95) | def name(cls):
    method emit_frame (line 99) | def emit_frame(self, np_array):
    method close (line 103) | def close(self):
  class PNGVideoOutput (line 107) | class PNGVideoOutput(VideoOutput):
    method available (line 111) | def available(cls):
    method __init__ (line 114) | def __init__(self, directory, frame_shape):
    method emit_frame (line 120) | def emit_frame(self, np_array):
    method _write_image (line 125) | def _write_image(self, im, filename):
    method close (line 129) | def close(self):
  class FFmpegVideoOutput (line 133) | class FFmpegVideoOutput(VideoOutput):
    method available (line 137) | def available(cls):
    method __init__ (line 147) | def __init__(self, directory, frame_shape):
    method _handle_error (line 183) | def _handle_error(self):
    method emit_frame (line 189) | def emit_frame(self, np_array):
    method close (line 197) | def close(self):

FILE: tensorboardX/tensorboardX/caffe2_graph.py
  function _make_unique_name (line 21) | def _make_unique_name(seen, name, min_version=0):
  function _rename_tensorflow_style (line 45) | def _rename_tensorflow_style(shapes, blob_name_tracker, ops):
  function _convert_to_ssa (line 84) | def _convert_to_ssa(shapes, blob_name_tracker, ops):
  function _get_blob_names (line 138) | def _get_blob_names(ops):
  function _remap_keys (line 155) | def _remap_keys(old_dict, rename_fn):
  function _rename_all (line 173) | def _rename_all(shapes, blob_name_tracker, ops, rename_fn):
  function _add_gradient_scope (line 221) | def _add_gradient_scope(shapes, blob_name_tracker, ops):
  function _replace_colons (line 245) | def _replace_colons(shapes, blob_name_tracker, ops, repl):
  function _fill_missing_operator_names (line 267) | def _fill_missing_operator_names(ops):
  function _tf_device (line 299) | def _tf_device(device_option):
  function _add_tf_shape (line 323) | def _add_tf_shape(attr_dict, ints):
  function _set_tf_attr (line 343) | def _set_tf_attr(attr_dict, arg):
  function _operator_to_node (line 389) | def _operator_to_node(shapes, op):
  function _operator_to_node_simp (line 417) | def _operator_to_node_simp(op, inter_blobs, seen):
  function _blob_to_node (line 478) | def _blob_to_node(producing_ops, shapes, name):
  function _clear_debug_info (line 513) | def _clear_debug_info(ops, perform_clear):
  function _check_if_forward (line 536) | def _check_if_forward(blob):
  function _check_if_cpu (line 551) | def _check_if_cpu(blob):
  function _compute_in_out (line 564) | def _compute_in_out(ops):
  function _filter_ops (line 593) | def _filter_ops(ops, filter_fn, perform_filter):
  function _operators_to_graph_def (line 628) | def _operators_to_graph_def(
  function _propagate_device_option (line 717) | def _propagate_device_option(net_def):
  function _try_get_shapes (line 738) | def _try_get_shapes(nets):
  function model_to_graph_def (line 760) | def model_to_graph_def(model, **kwargs):
  function nets_to_graph_def (line 778) | def nets_to_graph_def(nets, shapes=None, **kwargs):
  function protos_to_graph_def (line 801) | def protos_to_graph_def(net_defs, shapes=None, **kwargs):

FILE: tensorboardX/tensorboardX/crc32c.py
  function crc_update (line 85) | def crc_update(crc, data):
  function crc_finalize (line 108) | def crc_finalize(crc):
  function _crc32c (line 122) | def _crc32c(data):

FILE: tensorboardX/tensorboardX/embedding.py
  function make_tsv (line 4) | def make_tsv(metadata, save_path, metadata_header=None):
  function make_sprite (line 24) | def make_sprite(label_img, save_path):
  function append_pbtxt (line 53) | def append_pbtxt(metadata, label_img, save_path, subdir, global_step, tag):
  function make_mat (line 73) | def make_mat(matlist, save_path):

FILE: tensorboardX/tensorboardX/event_file_writer.py
  class EventsWriter (line 32) | class EventsWriter(object):
    method __init__ (line 35) | def __init__(self, file_prefix, filename_suffix=''):
    method write_event (line 51) | def write_event(self, event):
    method _write_serialized_event (line 60) | def _write_serialized_event(self, event_str):
    method flush (line 65) | def flush(self):
    method close (line 72) | def close(self):
  class EventFileWriter (line 80) | class EventFileWriter(object):
    method __init__ (line 88) | def __init__(self, logdir, max_queue_size=10, flush_secs=120, filename...
    method get_logdir (line 115) | def get_logdir(self):
    method reopen (line 119) | def reopen(self):
    method add_event (line 132) | def add_event(self, event):
    method flush (line 141) | def flush(self):
    method close (line 151) | def close(self):
  class _EventLoggerThread (line 163) | class _EventLoggerThread(threading.Thread):
    method __init__ (line 166) | def __init__(self, queue, record_writer, flush_secs):
    method stop (line 185) | def stop(self):
    method run (line 189) | def run(self):

FILE: tensorboardX/tensorboardX/onnx_graph.py
  function load_onnx_graph (line 8) | def load_onnx_graph(fname):
  function parse (line 15) | def parse(graph):

FILE: tensorboardX/tensorboardX/proto_graph.py
  function attr_value_proto (line 8) | def attr_value_proto(dtype, shape, s):
  function tensor_shape_proto (line 23) | def tensor_shape_proto(outputsize):
  function node_proto (line 30) | def node_proto(name,

FILE: tensorboardX/tensorboardX/pytorch_graph.py
  class NodeBase (line 18) | class NodeBase(object):
    method __init__ (line 19) | def __init__(self,
    method __repr__ (line 34) | def __repr__(self):
  class NodePy (line 43) | class NodePy(NodeBase):
    method __init__ (line 44) | def __init__(self, node_cpp, valid_methods):
  class NodePyIO (line 75) | class NodePyIO(NodePy):
    method __init__ (line 76) | def __init__(self, node_cpp, input_or_output=None):
  class NodePyOP (line 93) | class NodePyOP(NodePy):
    method __init__ (line 94) | def __init__(self, node_cpp):
  class GraphPy (line 102) | class GraphPy(object):
    method __init__ (line 123) | def __init__(self):
    method append (line 130) | def append(self, x):
    method printall (line 144) | def printall(self):
    method find_common_root (line 151) | def find_common_root(self):
    method populate_namespace_from_OP_to_IO (line 156) | def populate_namespace_from_OP_to_IO(self):
    method to_proto (line 178) | def to_proto(self):
  function parse (line 207) | def parse(graph, args=None, omit_useless_nodes=True):
  function graph (line 247) | def graph(model, args, verbose=False, **kwargs):

FILE: tensorboardX/tensorboardX/record_writer.py
  function register_writer_factory (line 30) | def register_writer_factory(prefix, factory):
  function directory_check (line 36) | def directory_check(path):
  function open_file (line 47) | def open_file(path):
  class S3RecordWriter (line 57) | class S3RecordWriter(object):
    method __init__ (line 60) | def __init__(self, path):
    method __del__ (line 66) | def __del__(self):
    method bucket_and_path (line 69) | def bucket_and_path(self):
    method write (line 78) | def write(self, val):
    method flush (line 81) | def flush(self):
    method close (line 88) | def close(self):
  class S3RecordWriterFactory (line 92) | class S3RecordWriterFactory(object):
    method open (line 95) | def open(self, path):
    method directory_check (line 98) | def directory_check(self, path):
  class RecordWriter (line 107) | class RecordWriter(object):
    method __init__ (line 108) | def __init__(self, path):
    method write (line 115) | def write(self, data):
    method flush (line 123) | def flush(self):
    method close (line 126) | def close(self):
  function masked_crc32c (line 130) | def masked_crc32c(data):
  function u32 (line 135) | def u32(x):
  function make_valid_tf_name (line 139) | def make_valid_tf_name(name):

FILE: tensorboardX/tensorboardX/summary.py
  function _clean_tag (line 28) | def _clean_tag(name):
  function _draw_single_box (line 46) | def _draw_single_box(image, xmin, ymin, xmax, ymax, display_str, color='...
  function hparams (line 69) | def hparams(hparam_dict=None, metric_dict=None):
  function scalar (line 124) | def scalar(name, scalar, collections=None):
  function histogram_raw (line 145) | def histogram_raw(name, min, max, num, sum, sum_squares, bucket_limits, ...
  function histogram (line 175) | def histogram(name, values, bins, max_bins=None):
  function make_histogram (line 197) | def make_histogram(values, bins, max_bins=None):
  function image (line 243) | def image(tag, tensor, rescale=1, dataformats='CHW'):
  function image_boxes (line 275) | def image_boxes(tag, tensor_image, tensor_boxes, rescale=1, dataformats=...
  function draw_boxes (line 290) | def draw_boxes(disp_image, boxes, labels=None):
  function make_image (line 305) | def make_image(tensor, rescale=1, rois=None, labels=None):
  function video (line 326) | def video(tag, tensor, fps=4):
  function make_video (line 338) | def make_video(tensor, fps):
  function audio (line 374) | def audio(tag, tensor, sample_rate=44100):
  function custom_scalars (line 394) | def custom_scalars(layout):
  function text (line 423) | def text(tag, text):
  function pr_curve_raw (line 434) | def pr_curve_raw(tag, tp, fp, tn, fn, precision, recall, num_thresholds=...
  function pr_curve (line 450) | def pr_curve(tag, labels, predictions, num_thresholds=127, weights=None):
  function compute_curve (line 468) | def compute_curve(labels, predictions, num_thresholds=None, weights=None):
  function _get_tensor_summary (line 499) | def _get_tensor_summary(tag, tensor, content_type, json_config):
  function mesh (line 528) | def mesh(tag, vertices, colors, faces, config_dict=None):

FILE: tensorboardX/tensorboardX/torchvis.py
  class TorchVis (line 19) | class TorchVis:
    method __init__ (line 20) | def __init__(self, *args, **init_kwargs):
    method register (line 32) | def register(self, *args, **init_kwargs):
    method unregister (line 39) | def unregister(self, *args):
    method __getattr__ (line 45) | def __getattr__(self, attr):
    method __del__ (line 55) | def __del__(self):

FILE: tensorboardX/tensorboardX/utils.py
  function figure_to_image (line 2) | def figure_to_image(figures, close=True):
  function graphviz_to_image (line 40) | def graphviz_to_image():
  function _prepare_video (line 44) | def _prepare_video(V):
  function make_grid (line 70) | def make_grid(I, ncols=8):
  function convert_to_HWC (line 98) | def convert_to_HWC(tensor, input_format):  # tensor: numpy array

FILE: tensorboardX/tensorboardX/visdom_writer.py
  function _check_connection (line 13) | def _check_connection(fn):
  class VisdomWriter (line 23) | class VisdomWriter:
    method __init__ (line 24) | def __init__(self, *args, **kwargs):
    method _try_connect (line 38) | def _try_connect(self):
    method add_scalar (line 48) | def add_scalar(self, tag, scalar_value, global_step=None, main_tag='de...
    method add_scalars (line 90) | def add_scalars(self, main_tag, tag_scalar_dict, global_step=None):
    method export_scalars_to_json (line 116) | def export_scalars_to_json(self, path):
    method add_histogram (line 128) | def add_histogram(self, tag, values, global_step=None, bins='tensorflo...
    method add_image (line 142) | def add_image(self, tag, img_tensor, global_step=None, caption=None):
    method add_figure (line 159) | def add_figure(self, tag, figure, global_step=None, close=True):
    method add_video (line 173) | def add_video(self, tag, vid_tensor, global_step=None, fps=4):
    method add_audio (line 213) | def add_audio(self, tag, snd_tensor, global_step=None, sample_rate=441...
    method add_text (line 230) | def add_text(self, tag, text_string, global_step=None):
    method add_onnx_graph (line 247) | def add_onnx_graph(self, prototxt):
    method add_graph (line 252) | def add_graph(self, model, input_to_model=None, verbose=False, **kwargs):
    method add_embedding (line 257) | def add_embedding(self, mat, metadata=None, label_img=None, global_ste...
    method add_pr_curve (line 262) | def add_pr_curve(self, tag, labels, predictions, global_step=None, num...
    method add_pr_curve_raw (line 293) | def add_pr_curve_raw(self, tag, true_positive_counts,
    method close (line 325) | def close(self):

FILE: tensorboardX/tensorboardX/writer.py
  class DummyFileWriter (line 28) | class DummyFileWriter(object):
    method __init__ (line 31) | def __init__(self, logdir):
    method get_logdir (line 34) | def get_logdir(self):
    method add_event (line 38) | def add_event(self, event, step=None, walltime=None):
    method add_summary (line 41) | def add_summary(self, summary, global_step=None, walltime=None):
    method add_graph (line 44) | def add_graph(self, graph_profile, walltime=None):
    method add_onnx_graph (line 47) | def add_onnx_graph(self, graph, walltime=None):
    method flush (line 50) | def flush(self):
    method close (line 53) | def close(self):
    method reopen (line 56) | def reopen(self):
  class FileWriter (line 60) | class FileWriter(object):
    method __init__ (line 70) | def __init__(self, logdir, max_queue=10, flush_secs=120, filename_suff...
    method get_logdir (line 95) | def get_logdir(self):
    method add_event (line 99) | def add_event(self, event, step=None, walltime=None):
    method add_summary (line 115) | def add_summary(self, summary, global_step=None, walltime=None):
    method add_graph (line 130) | def add_graph(self, graph_profile, walltime=None):
    method add_onnx_graph (line 148) | def add_onnx_graph(self, graph, walltime=None):
    method flush (line 159) | def flush(self):
    method close (line 166) | def close(self):
    method reopen (line 172) | def reopen(self):
  class SummaryWriter (line 181) | class SummaryWriter(object):
    method __init__ (line 192) | def __init__(self, logdir=None, comment='', purge_step=None, max_queue...
    method __append_to_scalar_dict (line 271) | def __append_to_scalar_dict(self, tag, scalar_value, global_step,
    method _check_caffe2_blob (line 282) | def _check_caffe2_blob(self, item):
    method _get_file_writer (line 297) | def _get_file_writer(self):
    method add_hparams (line 325) | def add_hparams(self, hparam_dict=None, metric_dict=None):
    method add_scalar (line 361) | def add_scalar(self, tag, scalar_value, global_step=None, walltime=None):
    method add_scalars (line 390) | def add_scalars(self, main_tag, tag_scalar_dict, global_step=None, wal...
    method export_scalars_to_json (line 436) | def export_scalars_to_json(self, path):
    method add_histogram (line 447) | def add_histogram(self, tag, values, global_step=None, bins='tensorflo...
    method add_histogram_raw (line 481) | def add_histogram_raw(self, tag, min, max, num, sum, sum_squares,
    method add_image (line 536) | def add_image(self, tag, img_tensor, global_step=None, walltime=None, ...
    method add_images (line 586) | def add_images(self, tag, img_tensor, global_step=None, walltime=None,...
    method add_image_with_boxes (line 642) | def add_image_with_boxes(self, tag, img_tensor, box_tensor, global_ste...
    method add_figure (line 674) | def add_figure(self, tag, figure, global_step=None, close=True, wallti...
    method add_video (line 691) | def add_video(self, tag, vid_tensor, global_step=None, fps=4, walltime...
    method add_audio (line 709) | def add_audio(self, tag, snd_tensor, global_step=None, sample_rate=441...
    method add_text (line 726) | def add_text(self, tag, text_string, global_step=None, walltime=None):
    method add_onnx_graph (line 742) | def add_onnx_graph(self, prototxt):
    method add_graph (line 745) | def add_graph(self, model, input_to_model=None, verbose=False, **kwargs):
    method _encode (line 798) | def _encode(rawstr):
    method add_embedding (line 806) | def add_embedding(self, mat, metadata=None, label_img=None, global_ste...
    method add_pr_curve (line 868) | def add_pr_curve(self, tag, labels, predictions, global_step=None,
    method add_pr_curve_raw (line 905) | def add_pr_curve_raw(self, tag, true_positive_counts,
    method add_custom_scalars_multilinechart (line 943) | def add_custom_scalars_multilinechart(self, tags, category='default', ...
    method add_custom_scalars_marginchart (line 957) | def add_custom_scalars_marginchart(self, tags, category='default', tit...
    method add_custom_scalars (line 972) | def add_custom_scalars(self, layout):
    method add_mesh (line 993) | def add_mesh(self, tag, vertices, colors=None, faces=None, config_dict...
    method close (line 1047) | def close(self):
    method flush (line 1055) | def flush(self):
    method __enter__ (line 1061) | def __enter__(self):
    method __exit__ (line 1064) | def __exit__(self, exc_type, exc_val, exc_tb):

FILE: tensorboardX/tensorboardX/x2num.py
  function check_nan (line 11) | def check_nan(array):
  function make_np (line 18) | def make_np(x):
  function prepare_pytorch (line 37) | def prepare_pytorch(x):
  function prepare_theano (line 45) | def prepare_theano(x):
  function prepare_caffe2 (line 50) | def prepare_caffe2(x):
  function prepare_mxnet (line 56) | def prepare_mxnet(x):
  function prepare_chainer (line 61) | def prepare_chainer(x):

FILE: tensorboardX/tests/event_file_writer_test.py
  class EventFileWriterTest (line 36) | class EventFileWriterTest(unittest.TestCase):
    method get_temp_dir (line 37) | def get_temp_dir(self):
    method test_event_file_writer_roundtrip (line 41) | def test_event_file_writer_roundtrip(self):
    method test_setting_filename_suffix_works (line 57) | def test_setting_filename_suffix_works(self):
    method test_async_writer_without_write (line 65) | def test_async_writer_without_write(self):
  class AsyncWriterTest (line 78) | class AsyncWriterTest(): #unittest.TestCase):
    method get_temp_dir (line 79) | def get_temp_dir(self):
    method test_async_writer_write_once (line 83) | def test_async_writer_write_once(self):
    method test_async_writer_write_queue_full (line 93) | def test_async_writer_write_queue_full(self):
    method test_async_writer_write_one_slot_queue (line 104) | def test_async_writer_write_one_slot_queue(self):
    method test_async_writer_close_triggers_flush (line 115) | def test_async_writer_close_triggers_flush(self):
    method test_write_after_async_writer_closed (line 124) | def test_write_after_async_writer_closed(self):

FILE: tensorboardX/tests/expect_reader.py
  function removeWhiteChar (line 6) | def removeWhiteChar(string):
  function compare_proto (line 10) | def compare_proto(str_to_compare, function_ptr):
  function write_proto (line 27) | def write_proto(str_to_compare, function_ptr):

FILE: tensorboardX/tests/record_writer_test.py
  class RecordWriterTest (line 29) | class RecordWriterTest(unittest.TestCase):
    method get_temp_dir (line 30) | def get_temp_dir(self):
    method test_expect_bytes_written (line 34) | def test_expect_bytes_written(self):
    method test_empty_record (line 44) | def test_empty_record(self):
    method test_record_writer_roundtrip (line 54) | def test_record_writer_roundtrip(self):

FILE: tensorboardX/tests/test_beholder.py
  class BeholderTest (line 14) | class BeholderTest(unittest.TestCase):
    method test_beholder (line 15) | def test_beholder(self):
    method test_beholder_video (line 27) | def test_beholder_video(self):

FILE: tensorboardX/tests/test_caffe2.py
  class Caffe2Test (line 23) | class Caffe2Test(unittest.TestCase):
    method test_caffe2_np (line 24) | def test_caffe2_np(self):
    method test_that_operators_gets_non_colliding_names (line 29) | def test_that_operators_gets_non_colliding_names(self):
    method test_that_replacing_colons_gives_non_colliding_names (line 37) | def test_that_replacing_colons_gives_non_colliding_names(self):
    method test_that_adding_gradient_scope_does_no_fancy_renaming (line 56) | def test_that_adding_gradient_scope_does_no_fancy_renaming(self):
    method test_that_auto_ssa_gives_non_colliding_names (line 75) | def test_that_auto_ssa_gives_non_colliding_names(self):
    method test_renaming_tensorflow_style (line 99) | def test_renaming_tensorflow_style(self):
    method test_filter_ops (line 176) | def test_filter_ops(self):
    method test_simple_cnnmodel (line 215) | def test_simple_cnnmodel(self):
    method test_simple_model (line 242) | def test_simple_model(self):

FILE: tensorboardX/tests/test_chainer_np.py
  class ChainerTest (line 23) | class ChainerTest(unittest.TestCase):
    method test_chainer_np (line 24) | def test_chainer_np(self):
    method test_chainer_img (line 33) | def test_chainer_img(self):
    method test_chainer_write (line 39) | def test_chainer_write(self):

FILE: tensorboardX/tests/test_crc32c.py
  class CRC32CTest (line 5) | class CRC32CTest(unittest.TestCase):
    method test_crc32c (line 6) | def test_crc32c(self):
    method test_crc32c_python (line 10) | def test_crc32c_python(self):
    method test_crc32c_native (line 14) | def test_crc32c_native(self):

FILE: tensorboardX/tests/test_embedding.py
  class EmbeddingTest (line 6) | class EmbeddingTest(unittest.TestCase):
    method test_embedding (line 7) | def test_embedding(self):
    method test_embedding_64 (line 27) | def test_embedding_64(self):
    method test_embedding_square (line 46) | def test_embedding_square(self):
    method test_embedding_fail (line 56) | def test_embedding_fail(self):

FILE: tensorboardX/tests/test_figure.py
  class FigureTest (line 12) | class FigureTest(unittest.TestCase):
    method test_figure (line 13) | def test_figure(self):
    method test_figure_list (line 32) | def test_figure_list(self):

FILE: tensorboardX/tests/test_numpy.py
  class NumpyTest (line 12) | class NumpyTest(unittest.TestCase):
    method test_scalar (line 13) | def test_scalar(self):
    method test_make_grid (line 25) | def test_make_grid(self):
    method test_numpy_vid (line 28) | def test_numpy_vid(self):
    method test_numpy_vid_uint8 (line 34) | def test_numpy_vid_uint8(self):

FILE: tensorboardX/tests/test_onnx_graph.py
  class ONNXGraphTest (line 6) | class ONNXGraphTest(unittest.TestCase):
    method test_onnx_graph (line 7) | def test_onnx_graph(self):

FILE: tensorboardX/tests/test_pr_curve.py
  class PRCurveTest (line 17) | class PRCurveTest(unittest.TestCase):
    method test_smoke (line 18) | def test_smoke(self):
    method test_pr_purve (line 31) | def test_pr_purve(self):
    method test_pr_purve_raw (line 59) | def test_pr_purve_raw(self):

FILE: tensorboardX/tests/test_pytorch_graph.py
  class PytorchGraphTest (line 7) | class PytorchGraphTest(unittest.TestCase):
    method test_pytorch_graph (line 8) | def test_pytorch_graph(self):
    method test_wrong_input_size (line 22) | def test_wrong_input_size(self):

FILE: tensorboardX/tests/test_pytorch_np.py
  class PyTorchNumpyTest (line 12) | class PyTorchNumpyTest(unittest.TestCase):
    method test_pytorch_np (line 13) | def test_pytorch_np(self):
    method test_pytorch_write (line 34) | def test_pytorch_write(self):
    method test_pytorch_histogram (line 38) | def test_pytorch_histogram(self):
    method test_pytorch_histogram_raw (line 43) | def test_pytorch_histogram_raw(self):

FILE: tensorboardX/tests/test_record_writer.py
  class RecordWriterTest (line 12) | class RecordWriterTest(unittest.TestCase):
    method test_record_writer_s3 (line 14) | def test_record_writer_s3(self):
    method test_make_valid_tf_name (line 24) | def test_make_valid_tf_name(self):

FILE: tensorboardX/tests/test_summary.py
  function tensor_N (line 9) | def tensor_N(shape, dtype=float):
  class SummaryTest (line 14) | class SummaryTest(unittest.TestCase):
    method test_uint8_image (line 15) | def test_uint8_image(self):
    method test_float32_image (line 22) | def test_float32_image(self):
    method test_float_1_converts_to_uint8_255 (line 30) | def test_float_1_converts_to_uint8_255(self):
    method test_list_input (line 38) | def test_list_input(self):
    method test_empty_input (line 42) | def test_empty_input(self):
    method test_image_with_boxes (line 47) | def test_image_with_boxes(self):
    method test_image_with_one_channel (line 52) | def test_image_with_one_channel(self):
    method test_image_with_four_channel (line 55) | def test_image_with_four_channel(self):
    method test_image_with_one_channel_batched (line 58) | def test_image_with_one_channel_batched(self):
    method test_image_with_3_channel_batched (line 61) | def test_image_with_3_channel_batched(self):
    method test_image_with_four_channel_batched (line 64) | def test_image_with_four_channel_batched(self):
    method test_image_without_channel (line 67) | def test_image_without_channel(self):
    method test_video (line 70) | def test_video(self):
    method test_audio (line 79) | def test_audio(self):
    method test_text (line 82) | def test_text(self):
    method test_histogram_auto (line 85) | def test_histogram_auto(self):
    method test_histogram_fd (line 88) | def test_histogram_fd(self):
    method test_histogram_doane (line 91) | def test_histogram_doane(self):
    method test_custom_scalars (line 94) | def test_custom_scalars(self):
    method test_mesh (line 100) | def test_mesh(self):
    method test_hparams (line 122) | def test_hparams(self):
    method test_hparams_smoke (line 127) | def test_hparams_smoke(self):

FILE: tensorboardX/tests/test_summary_writer.py
  class SummaryWriterTest (line 5) | class SummaryWriterTest(unittest.TestCase):
    method test_summary_writer_ctx (line 6) | def test_summary_writer_ctx(self):
    method test_summary_writer_backcomapt (line 12) | def test_summary_writer_backcomapt(self):
    method test_summary_writer_close (line 16) | def test_summary_writer_close(self):
    method test_windowsPath (line 28) | def test_windowsPath(self):
    method test_pathlib (line 35) | def test_pathlib(self):

FILE: tensorboardX/tests/test_test.py
  function test_linting (line 1) | def test_linting():

FILE: tensorboardX/tests/test_utils.py
  class UtilsTest (line 8) | class UtilsTest(unittest.TestCase):
    method test_to_HWC (line 9) | def test_to_HWC(self):
    method test_prepare_video (line 21) | def test_prepare_video(self):

FILE: tensorboardX/tests/test_visdom.py
  class VisdomTest (line 15) | class VisdomTest(unittest.TestCase):
    method test_TorchVis (line 16) | def test_TorchVis(self):

FILE: tensorboardX/tests/test_writer.py
  class WriterTest (line 19) | class WriterTest(unittest.TestCase):
    method test_flush (line 20) | def test_flush(self):
    method test_flush_timer_is_long_so_data_is_not_there (line 32) | def test_flush_timer_is_long_so_data_is_not_there(self):
    method test_flush_after_close (line 45) | def test_flush_after_close(self):
    method test_flush (line 58) | def test_flush(self):
    method test_auto_close (line 71) | def test_auto_close(self):
    method test_writer (line 74) | def test_writer(self):