Full Code of yaroslavvb/stuff for AI

gitextract_ycct44t1/

├── .gitignore
├── README.md
├── akaitsuki-slow/
│   ├── config.py
│   ├── feed_dict.pbtxt
│   ├── feed_dict.py
│   └── main.py
├── autotune/
│   ├── README.md
│   ├── autograd_lib.py
│   ├── autograd_lib_test.py
│   ├── autograd_test.py
│   ├── ciresan_bench.py
│   ├── curvature_test.py
│   ├── eval_conv2d_approx.py
│   ├── factored_test.py
│   ├── globals.py
│   ├── hessian_test.py
│   ├── linalg_bench.py
│   ├── linesearch_test_disabled.py
│   ├── lyapunov_test.py
│   ├── mnist_end2end_test.py
│   ├── plotting_test.py
│   ├── pytorch_benchmark.py
│   ├── scipy_benchmark.py
│   ├── svd_benchmark.py
│   ├── test/
│   │   ├── bad_sigmas.pt
│   │   ├── factored.pt
│   │   └── gesvd_crash.txt
│   ├── train_ciresan.py
│   ├── train_ciresan_cca.py
│   ├── train_ciresan_factored.py
│   ├── train_ciresan_new.py
│   ├── train_medium.py
│   ├── train_small.py
│   ├── train_small_xent.py
│   ├── train_small_xent_factored.py
│   ├── train_tiny.py
│   ├── train_tiny_xent.py
│   ├── util.py
│   └── util_test.py
├── aws-recipes.ipynb
├── aws-scratch.ipynb
├── benchmark_huggingface_predict.py
├── bin/
│   └── tfversion
├── clipping-profile.ipynb
├── cluster/
│   ├── .gitignore
│   ├── README.md
│   ├── async_adder.py
│   ├── aws.py
│   ├── benchmark_grpc_recv.py
│   ├── benchmarks/
│   │   ├── .gitignore
│   │   ├── LICENSE
│   │   ├── README.md
│   │   ├── bower_components/
│   │   │   ├── d3/
│   │   │   │   ├── .bower.json
│   │   │   │   ├── .gitattributes
│   │   │   │   ├── CONTRIBUTING.md
│   │   │   │   ├── LICENSE
│   │   │   │   ├── README.md
│   │   │   │   ├── bower.json
│   │   │   │   ├── d3.js
│   │   │   │   └── package.js
│   │   │   └── plottable/
│   │   │       ├── .bower.json
│   │   │       ├── bower.json
│   │   │       ├── plottable.css
│   │   │       ├── plottable.d.ts
│   │   │       └── plottable.js
│   │   ├── dashboard_app/
│   │   │   ├── app.yaml
│   │   │   ├── main.py
│   │   │   ├── main_test.py
│   │   │   ├── requirements.txt
│   │   │   ├── static/
│   │   │   │   ├── css/
│   │   │   │   │   └── style.css
│   │   │   │   └── js/
│   │   │   │       └── benchmark_latency_chart.js
│   │   │   └── templates/
│   │   │       ├── index.html
│   │   │       └── test.html
│   │   ├── index.html
│   │   ├── js/
│   │   │   ├── csv_benchmark_chart.js
│   │   │   └── latency_chart.js
│   │   ├── scripts/
│   │   │   ├── Dockerfile.tf_cnn_benchmarks
│   │   │   ├── benchmark_configs.yml
│   │   │   ├── tf_cnn_benchmarks/
│   │   │   │   ├── README.md
│   │   │   │   ├── benchmark_cnn.py
│   │   │   │   ├── benchmark_storage.py
│   │   │   │   ├── cbuild_benchmark_storage.py
│   │   │   │   ├── cnn_util.py
│   │   │   │   ├── convnet_builder.py
│   │   │   │   ├── datasets.py
│   │   │   │   ├── models/
│   │   │   │   │   ├── __init__.py
│   │   │   │   │   ├── alexnet_model.py
│   │   │   │   │   ├── densenet_model.py
│   │   │   │   │   ├── googlenet_model.py
│   │   │   │   │   ├── inception_model.py
│   │   │   │   │   ├── lenet_model.py
│   │   │   │   │   ├── model.py
│   │   │   │   │   ├── model_config.py
│   │   │   │   │   ├── overfeat_model.py
│   │   │   │   │   ├── resnet_model.py
│   │   │   │   │   ├── trivial_model.py
│   │   │   │   │   └── vgg_model.py
│   │   │   │   ├── preprocessing.py
│   │   │   │   ├── tf_cnn_benchmarks.py
│   │   │   │   └── variable_mgr.py
│   │   │   └── util/
│   │   │       ├── __init__.py
│   │   │       ├── benchmark_util.py
│   │   │       ├── benchmark_util_test.py
│   │   │       ├── convert_csv_to_json.py
│   │   │       └── convert_csv_to_json_test.py
│   │   ├── soumith_benchmarks.html
│   │   └── tools/
│   │       ├── k8s_tensorflow_lib.py
│   │       ├── k8s_tensorflow_test.py
│   │       ├── kubectl_util.py
│   │       ├── kubectl_util_test.py
│   │       └── run_distributed_benchmarks.py
│   ├── client_transfer_benchmark.py
│   ├── cloud-formation-example/
│   │   ├── README.md
│   │   ├── iam.yaml
│   │   ├── tensorflow.yaml
│   │   └── zone.sh
│   ├── connect.py
│   ├── delete_placement_groups.py
│   ├── fill_efs.py
│   ├── imagenet64/
│   │   ├── README.md
│   │   ├── aws.py
│   │   ├── launch.py
│   │   ├── requirements.txt
│   │   └── variable_mgr.py
│   ├── instance_info.py
│   ├── launch_async_adder.py
│   ├── launch_micro.py
│   ├── launch_ray.py
│   ├── launch_simple_tf.py
│   ├── local_distributed_benchmark.py
│   ├── myutil.py
│   ├── ray_add.py
│   ├── simple_distributed.py
│   ├── terminate_instances.py
│   ├── test_aws.py
│   ├── tf-tools/
│   │   ├── .gitignore
│   │   ├── benchmark/
│   │   │   ├── multi_gpu/
│   │   │   │   ├── advanced_tweaks_compare.sh
│   │   │   │   ├── image_classification_bench_tests.sh
│   │   │   │   ├── stats_monitor.sh
│   │   │   │   ├── test_runner.sh
│   │   │   │   └── unit_test_stats_monitor.sh
│   │   │   └── runner/
│   │   │       ├── cluster_aws.py
│   │   │       ├── command_builder.py
│   │   │       ├── configs/
│   │   │       │   └── aws/
│   │   │       │       ├── multi_server.yaml
│   │   │       │       └── yaroslav.yaml
│   │   │       ├── instance_info.py
│   │   │       ├── launch_experiment.py
│   │   │       ├── test_cluster_aws.py
│   │   │       ├── test_command_builder.py
│   │   │       └── util.py
│   │   └── install/
│   │       ├── aws_amzlinux.md
│   │       └── aws_ubuntu16_04.md
│   ├── tmux.py
│   └── upload_test.txt
├── conditional_backprop.py
├── configure_tf.sh
├── configure_tf_cpu.sh
├── danjar_peek.py
├── distributed/
│   ├── README.md
│   ├── benchmark_grpc_recv.py
│   └── client_transfer_benchmark.py
├── double_memory_bug.py
├── dynamic_stitch_gpu.py
├── dynamic_stitch_gpu_profile.pbtxt
├── eager_lbfgs/
│   ├── .ipynb_checkpoints/
│   │   └── performance-checkpoint.ipynb
│   ├── common_gd.py
│   ├── data/
│   │   ├── short_batch.csv
│   │   ├── short_eager_batch.csv
│   │   ├── short_eager_loss.csv
│   │   ├── short_eager_time.csv
│   │   ├── short_pytorch_loss.csv
│   │   └── short_pytorch_time.csv
│   ├── eager_lbfgs.py
│   ├── performance.ipynb
│   ├── pytorch_lbfgs.py
│   ├── run_experiment.py
│   ├── torch_lbfgs.lua
│   └── util.py
├── enqueue_many_test.py
├── enqueue_many_test_singlerun.py
├── ericyue-slowreader/
│   ├── benchmark-batch-noqueuerunners-timeline.json
│   ├── benchmark-batch-noqueuerunners.profile
│   ├── benchmark-batch-noqueuerunners.py
│   ├── benchmark-batch.py
│   ├── benchmark-reader.py
│   ├── benchmark-synthetic-batch.py
│   ├── benchmark-synthetic.py
│   ├── benchmark.py
│   ├── data.zlib
│   └── profile-batch.py
├── free_gpus.py
├── github_pyfunc_slowness.py
├── gpu-memory-transfer.ipynb
├── gpu_oom.py
├── graph_template.py
├── imagenet15-scratch.ipynb
├── input_benchmarks/
│   ├── convert_to_records.py
│   ├── fully_connected_feed.py
│   ├── fully_connected_preloaded_var.py
│   ├── fully_connected_reader.py
│   ├── timeline.feed.json
│   ├── timeline.reader.json
│   └── timeline.var.json
├── inverse_segfault.py
├── keras_autoencoder/
│   ├── keras_large.py
│   ├── util.py
│   └── weightnorm.py
├── khatri_rao_benchmark.py
├── lazy_dog.py
├── linalg-benchmark/
│   ├── README.md
│   ├── bad_matrix.py
│   ├── benchmark.py
│   ├── environment.yml
│   ├── get_cores_per_socket.py
│   ├── launch.py
│   ├── launch_tensorflow_svd_crash.py
│   ├── requirements.txt
│   ├── results.txt
│   └── tensorflow_svd_crash.py
├── line_search_example/
│   ├── data/
│   │   └── step_lengths_ada.csv
│   ├── line_search_example.py
│   └── util.py
├── linearize/
│   ├── linearize.py
│   ├── linearize_test.py
│   └── memory_util.py
├── matmul_benchmark.py
├── matmul_benchmark_seq.py
├── matmul_times/
│   ├── 1080-float16.csv
│   ├── 1080-float32.csv
│   ├── g3-float16.csv
│   ├── g3-float32.csv
│   ├── nvidia-p3-float16.csv
│   ├── nvidia-p3-float32.csv
│   ├── p2-float16.csv
│   └── p2-float32.csv
├── mavelin/
│   ├── machine1.py
│   └── machine3.py
├── memory tracking.ipynb
├── memory-probe-examples.ipynb
├── memory-release-check.ipynb
├── natural_gradient_multilayer.py
├── node-merge.ipynb
├── notebook_util.py
├── numpy_initializers/
│   ├── kfac_cifar.py
│   └── util.py
├── parallel_dequeue_test.py
├── phantomjs-tryout.ipynb
├── phantomjs-tryout.js
├── pytorch-hessian.ipynb
├── queue_mismatch.py
├── queues_talk/
│   └── queues.ipynb
├── resnet_8_simple.pbtxt
├── resnet_leak_report.py
├── resnet_leak_report2.py
├── resource_variable_test.py
├── rotations_comparison.py
├── saving memory by using functions.ipynb
├── simple_rewiring.ipynb
├── simple_train.py
├── svd_benchmark.py
├── svd_noconverge.py
├── svd_test.py
├── tf_initializer_bug_report.py
├── tiny_runs/
│   ├── qr_test.py
│   └── tiny_tf.py
└── whitening_util.py

SYMBOL INDEX (3079 symbols across 142 files)

FILE: akaitsuki-slow/config.py
  function str2bool (line 4) | def str2bool(v):
  function get_args (line 8) | def get_args():

FILE: akaitsuki-slow/main.py
  function retrieve_seq_length_op2 (line 9) | def retrieve_seq_length_op2(data):
  function advanced_indexing_op (line 13) | def advanced_indexing_op(input, index):
  function bidirectional_dynamic_rnn (line 23) | def bidirectional_dynamic_rnn(inputs, cell_fn, n_hidden, sequence_length...
  function BilinearAttention (line 47) | def BilinearAttention(inputs, n_hidden, mask=None,
  function inference (line 63) | def inference(x1, x2, mask1, mask2, l, y,
  function main (line 122) | def main(args):

FILE: autotune/autograd_lib.py
  class LayerStats (line 61) | class LayerStats:
    method __iter__ (line 94) | def __iter__(self):
    method __init__ (line 97) | def __init__(self):
    method __getitem__ (line 100) | def __getitem__(self, item):
    method items (line 103) | def items(self):
  function add_hooks (line 107) | def add_hooks(model: nn.Module) -> None:
  function remove_hooks (line 137) | def remove_hooks(model: nn.Module) -> None:
  function disable_hooks (line 155) | def disable_hooks() -> None:
  function enable_hooks (line 164) | def enable_hooks() -> None:
  function is_supported (line 171) | def is_supported(layer: nn.Module) -> bool:
  function _layer_type (line 177) | def _layer_type(layer: nn.Module) -> str:
  function _capture_activations (line 181) | def _capture_activations(layer: nn.Module, input: List[torch.Tensor], ou...
  function _capture_output (line 190) | def _capture_output(layer: nn.Module, input: List[torch.Tensor], output:...
  function _capture_backprops (line 199) | def _capture_backprops(layer: nn.Module, _input, output):
  function clear_backprops (line 217) | def clear_backprops(model: nn.Module) -> None:
  function clear_hess_backprops (line 224) | def clear_hess_backprops(model: nn.Module) -> None:
  function compute_grad1 (line 231) | def compute_grad1(model: nn.Module, loss_type: str = 'mean') -> None:
  function compute_hess (line 286) | def compute_hess(model: nn.Module, method='exact', attr_name=None, vecr_...
  function backprop_hess (line 445) | def backprop_hess(output: torch.Tensor, hess_type: str, model: Optional[...
  class LayerCov (line 519) | class LayerCov:
    method __init__ (line 526) | def __init__(self):
  function compute_cov (line 532) | def compute_cov(model: nn.Module, loss_fn: Callable, stats_iter, batch_s...
  function update_cov (line 585) | def update_cov(model, a_attr, b_attr, target_attr):
  function compute_stats (line 642) | def compute_stats(model, attr_name='stats', factored=False, sigma_center...
  function compute_stats_factored (line 789) | def compute_stats_factored(model, attr_name='stats', sigma_centering=True):
  class SecondOrderCov (line 923) | class SecondOrderCov:
    method __init__ (line 926) | def __init__(self):
    method accumulate (line 935) | def accumulate(self, data_x, data_y):
    method zero_ (line 952) | def zero_(self):
  class SymmetricFourthOrderCov (line 959) | class SymmetricFourthOrderCov:
    method __init__ (line 971) | def __init__(self, rank=3):
    method accumulate (line 978) | def accumulate(self, data_x: torch.Tensor, data_y: torch.Tensor, cache...
    method zero_ (line 1001) | def zero_(self):
  class ModuleDict (line 1007) | class ModuleDict(dict):
    method __init__ (line 1009) | def __init__(self, defaultcreator=None, defaultvalue=None):
    method __getitem__ (line 1018) | def __getitem__(self, item):
  class Settings (line 1035) | class Settings(object):
    method __init__ (line 1043) | def __init__(self):
  function layer_cov_dict (line 1074) | def layer_cov_dict(model):
  function _forward_hook (line 1079) | def _forward_hook(layer: nn.Module, input: List[torch.Tensor], output: t...
  function _backward_hook (line 1085) | def _backward_hook(layer: nn.Module, _input: torch.Tensor, output: torch...
  function register (line 1090) | def register(model: nn.Module):
  function _hack_zero_gradient_norms_squared (line 1109) | def _hack_zero_gradient_norms_squared():
  function _hack_update_gradient_norms_squared (line 1116) | def _hack_update_gradient_norms_squared(layer: nn.Module, backprops: tor...
  function unregister (line 1129) | def unregister():
  function save_activations (line 1139) | def save_activations(storage: ModuleDict):
  function extend_backprops (line 1165) | def extend_backprops(storage: ModuleDict):
  function module_hook (line 1183) | def module_hook(hook: Callable):
  function save_activations2 (line 1215) | def save_activations2():
  function backward (line 1239) | def backward(tensor, backward_func, retain_graph=False):
  function backward_accum (line 1249) | def backward_accum(tensor, backward_func, storage: ModuleDict, retain_gr...
  function set_default_activations (line 1308) | def set_default_activations(A):
  function set_default_Acov (line 1316) | def set_default_Acov(Acov):
  function backward_xent (line 1322) | def backward_xent(output):
  function backward_identity (line 1326) | def backward_identity(tensor):
  function backprop_identity (line 1339) | def backprop_identity(output, retain_graph=False) -> None:
  function backward_ones (line 1360) | def backward_ones(output):
  function backward_jacobian (line 1369) | def backward_jacobian(output, sampled=False, retain_graph=False) -> None:
  function backward_hessian (line 1396) | def backward_hessian(output, loss='CrossEntropy', sampled=False, retain_...
  function grad_norms (line 1418) | def grad_norms(A, B, m=None, approx='zero_order'):
  function offset_losses (line 1463) | def offset_losses(A, B, alpha, offset, m, approx='zero_order'):
  function offset_cosines (line 1499) | def offset_cosines(A, B, offset=1):
  function offset_dotprod (line 1525) | def offset_dotprod(A, B, offset=1):
  function grad_curvs (line 1542) | def grad_curvs(A, B, metric):

FILE: autotune/autograd_lib_test.py
  function simple_model (line 20) | def simple_model(d, num_layers):
  function test_hooks (line 30) | def test_hooks():
  function _test_activations_contextmanager (line 72) | def _test_activations_contextmanager():
  function test_jacobian (line 115) | def test_jacobian():
  function create_toy_model (line 196) | def create_toy_model():
  function test_gradient_norms (line 214) | def test_gradient_norms():
  function test_full_hessian (line 245) | def test_full_hessian():
  function test_full_fisher (line 284) | def test_full_fisher():
  function test_full_fisher_multibatch (line 323) | def test_full_fisher_multibatch():
  function test_kfac_hessian (line 368) | def test_kfac_hessian():
  function test_full_hessian_multibatch (line 403) | def test_full_hessian_multibatch():
  function test_diagonal_hessian (line 436) | def test_diagonal_hessian():
  function test_full_hessian_xent (line 470) | def test_full_hessian_xent():
  function test_full_hessian_xent_multibatch (line 517) | def test_full_hessian_xent_multibatch():
  function test_full_hessian_xent_kfac (line 569) | def test_full_hessian_xent_kfac():
  function test_full_hessian_xent_kfac2 (line 631) | def test_full_hessian_xent_kfac2():
  function test_full_hessian_xent_mnist (line 687) | def test_full_hessian_xent_mnist():
  function test_full_hessian_xent_mnist_multilayer (line 731) | def test_full_hessian_xent_mnist_multilayer():
  function _test_kfac_hessian_xent_mnist (line 785) | def _test_kfac_hessian_xent_mnist():
  function test_kfac_jacobian_mnist (line 835) | def test_kfac_jacobian_mnist():
  function test_kfac_fisher_mnist (line 892) | def test_kfac_fisher_mnist():
  class MyList (line 946) | class MyList:
    method __init__ (line 947) | def __init__(self, *args, **kwargs):
    method __getattr__ (line 951) | def __getattr__(self, *_args, **_kwargs):
    method normal_form (line 954) | def normal_form(self):
    method value (line 957) | def value(self):
  function test_grad_norms (line 961) | def test_grad_norms():

FILE: autotune/autograd_test.py
  function test_autoencoder_minimize (line 26) | def test_autoencoder_minimize():
  function test_autoencoder_newton (line 65) | def test_autoencoder_newton():
  function test_main_autograd (line 109) | def test_main_autograd():
  function test_unfold (line 245) | def test_unfold():
  function test_cross_entropy_hessian_tiny (line 279) | def test_cross_entropy_hessian_tiny():
  function test_cross_entropy_hessian_mnist (line 323) | def test_cross_entropy_hessian_mnist():
  function test_hessian (line 372) | def test_hessian():
  function test_conv_grad (line 460) | def test_conv_grad():
  function test_conv_hessian (line 535) | def test_conv_hessian():
  class Net (line 607) | class Net(nn.Module):
    method __init__ (line 608) | def __init__(self):
    method forward (line 615) | def forward(self, x):
  class TinyNet (line 627) | class TinyNet(nn.Module):
    method __init__ (line 628) | def __init__(self):
    method forward (line 635) | def forward(self, x):            # 28x28
  function test_end2end_grad1 (line 647) | def test_end2end_grad1():
  function test_end2end_hess (line 673) | def test_end2end_hess():
  function subtest_hess_type (line 679) | def subtest_hess_type(hess_type):
  function test_kron_nano (line 720) | def test_kron_nano():
  function test_kron_tiny (line 776) | def test_kron_tiny():
  function test_kron_mnist (line 831) | def test_kron_mnist():
  function test_kron_conv_exact (line 890) | def test_kron_conv_exact():
  function test_kron_1x2_conv (line 962) | def test_kron_1x2_conv():
  function _test_kron_conv_golden (line 1020) | def _test_kron_conv_golden():

FILE: autotune/ciresan_bench.py
  class Net (line 32) | class Net(nn.Module):
    method __init__ (line 33) | def __init__(self, d):
    method forward (line 37) | def forward(self, x: torch.Tensor):
  class timeit (line 43) | class timeit:
    method __init__ (line 48) | def __init__(self, tag=""):
    method __enter__ (line 51) | def __enter__(self):
    method __exit__ (line 55) | def __exit__(self, *args):
  function get_mkl_version (line 64) | def get_mkl_version():
  function print_cpu_info (line 78) | def print_cpu_info():
  function linalg_bench (line 89) | def linalg_bench():

FILE: autotune/curvature_test.py
  class Net (line 14) | class Net(nn.Module):
    method __init__ (line 15) | def __init__(self, d):
    method forward (line 19) | def forward(self, x: torch.Tensor):
  function test_singlelayer (line 24) | def test_singlelayer():
  class Net2 (line 237) | class Net2(nn.Module):
    method __init__ (line 238) | def __init__(self, d1, d2):
    method forward (line 243) | def forward(self, X1: torch.Tensor):
  function test_multilayer (line 249) | def test_multilayer():

FILE: autotune/eval_conv2d_approx.py
  function compute_hess (line 48) | def compute_hess(n: int = 1, image_size: int = 1, kernel_size: int = 1, ...
  function main (line 102) | def main():

FILE: autotune/factored_test.py
  function test_factored_stats_golden_values (line 19) | def test_factored_stats_golden_values():
  function test_factored_vs_regular (line 116) | def test_factored_vs_regular():

FILE: autotune/globals.py
  function reset_global_step (line 33) | def reset_global_step():
  function increment_global_step (line 38) | def increment_global_step(incr: int):
  function get_global_step (line 43) | def get_global_step() -> int:

FILE: autotune/hessian_test.py
  class Net (line 11) | class Net(nn.Module):
    method __init__ (line 12) | def __init__(self, d):
    method forward (line 16) | def forward(self, x: torch.Tensor):
  function test_simple_hessian (line 21) | def test_simple_hessian():
  function test_explicit_hessian (line 96) | def test_explicit_hessian():
  function test_factored_hessian (line 185) | def test_factored_hessian():
  function test_hessian_multibatch (line 295) | def test_hessian_multibatch():
  function _test_refactored_stats (line 371) | def _test_refactored_stats():
  function test_hessian_conv (line 432) | def test_hessian_conv():
  function _test_explicit_hessian_refactored (line 511) | def _test_explicit_hessian_refactored():
  function _test_new_setup (line 602) | def _test_new_setup():

FILE: autotune/linalg_bench.py
  class Net (line 32) | class Net(nn.Module):
    method __init__ (line 33) | def __init__(self, d):
    method forward (line 37) | def forward(self, x: torch.Tensor):
  class timeit (line 42) | class timeit:
    method __init__ (line 47) | def __init__(self, tag=""):
    method __enter__ (line 50) | def __enter__(self):
    method __exit__ (line 54) | def __exit__(self, *args):
  function get_mkl_version (line 60) | def get_mkl_version():
  function print_cpu_info (line 74) | def print_cpu_info():
  function linalg_bench (line 85) | def linalg_bench():

FILE: autotune/linesearch_test_disabled.py
  function install_pdb_handler (line 44) | def install_pdb_handler():
  class FastMNIST (line 80) | class FastMNIST(datasets.MNIST):
    method __init__ (line 81) | def __init__(self, *args, **kwargs):
    method __getitem__ (line 93) | def __getitem__(self, index):
  class FastBinaryMNIST (line 106) | class FastBinaryMNIST(datasets.MNIST):
    method __init__ (line 107) | def __init__(self, *args, **kwargs):
    method __getitem__ (line 122) | def __getitem__(self, index):
  class SimpleMNIST (line 135) | class SimpleMNIST(datasets.MNIST):
    method __init__ (line 137) | def __init__(self, *args, **kwargs):
    method __getitem__ (line 152) | def __getitem__(self, index):
  function compute_loss (line 165) | def compute_loss(output, target):
  function log (line 173) | def log(metrics, step):
  function test_lineasearch (line 187) | def test_lineasearch():
  function train (line 373) | def train(model, device, train_loader, optimizer, epoch, args, logger):

FILE: autotune/lyapunov_test.py
  class Net (line 18) | class Net(nn.Module):
    method __init__ (line 19) | def __init__(self, d):
    method forward (line 23) | def forward(self, x: torch.Tensor):
  function lyap_newton_schulz (line 30) | def lyap_newton_schulz(z, dldz, numIters, dtype):
  function test_lyapunov (line 44) | def test_lyapunov():
  function test_stability (line 143) | def test_stability():
  function compare_impl (line 153) | def compare_impl():
  function lyapunov_svd (line 181) | def lyapunov_svd(A, C, rtol=1e-4, use_svd=False):
  class timeit (line 200) | class timeit:
    method __init__ (line 204) | def __init__(self, tag=""):
    method __enter__ (line 207) | def __enter__(self):
    method __exit__ (line 211) | def __exit__(self, *args):
  function get_mkl_version (line 217) | def get_mkl_version():
  function print_cpu_info (line 231) | def print_cpu_info():

FILE: autotune/mnist_end2end_test.py
  function test_main (line 25) | def test_main():

FILE: autotune/plotting_test.py
  function install_pdb_handler (line 53) | def install_pdb_handler():
  class FastMNIST (line 89) | class FastMNIST(datasets.MNIST):
    method __init__ (line 90) | def __init__(self, *args, **kwargs):
    method __getitem__ (line 102) | def __getitem__(self, index):
  class FastBinaryMNIST (line 115) | class FastBinaryMNIST(datasets.MNIST):
    method __init__ (line 116) | def __init__(self, *args, **kwargs):
    method __getitem__ (line 131) | def __getitem__(self, index):
  class SimpleMNIST (line 144) | class SimpleMNIST(datasets.MNIST):
    method __init__ (line 146) | def __init__(self, *args, **kwargs):
    method __getitem__ (line 160) | def __getitem__(self, index):
  function compute_loss (line 173) | def compute_loss(output, target):
  function log_scalars (line 181) | def log_scalars(metrics: Dict[str, Any], parent_tag: str = '') -> None:
  function main (line 191) | def main():
  function train (line 506) | def train(model, device, train_loader, optimizer, epoch, args, logger):
  function validate (line 580) | def validate(model, device, val_loader, optimizer):

FILE: autotune/pytorch_benchmark.py
  function empty_aligned (line 51) | def empty_aligned(n, align):
  function benchmark (line 59) | def benchmark(method):

FILE: autotune/scipy_benchmark.py
  function empty_aligned (line 30) | def empty_aligned(n, align):
  function benchmark (line 38) | def benchmark(method, d):

FILE: autotune/svd_benchmark.py
  function empty_aligned (line 33) | def empty_aligned(n, align):
  function benchmark (line 41) | def benchmark(method):

FILE: autotune/train_ciresan.py
  function main (line 37) | def main():
  function validate (line 312) | def validate(model, val_loader, tag='validation'):

FILE: autotune/train_ciresan_cca.py
  function main (line 41) | def main():
  function validate (line 230) | def validate(model, val_loader, tag='validation'):

FILE: autotune/train_ciresan_factored.py
  function main (line 41) | def main():
  function validate (line 202) | def validate(model, val_loader, tag='validation'):

FILE: autotune/train_ciresan_new.py
  function skip_nans (line 49) | def skip_nans(t): return t[torch.isfinite(t)]
  function erank (line 52) | def erank(vals): return vals.sum() / vals.max()
  function srank (line 54) | def srank(vals): return (vals * vals).sum() / (vals.max() ** 2)
  function main (line 58) | def main():
  function validate (line 622) | def validate(model, val_loader, tag='validation'):

FILE: autotune/train_medium.py
  function main (line 26) | def main():

FILE: autotune/train_small.py
  function main (line 22) | def main():

FILE: autotune/train_small_xent.py
  function main (line 29) | def main():

FILE: autotune/train_small_xent_factored.py
  function main (line 29) | def main():

FILE: autotune/train_tiny.py
  function main (line 20) | def main():

FILE: autotune/train_tiny_xent.py
  function main (line 29) | def main():

FILE: autotune/util.py
  function get_condition (line 39) | def get_condition(dtype):
  function v2c (line 48) | def v2c(vec):
  function v2c_np (line 55) | def v2c_np(vec):
  function v2r (line 61) | def v2r(vec: torch.Tensor) -> torch.Tensor:
  function c2v (line 68) | def c2v(col: torch.Tensor) -> torch.Tensor:
  function vec (line 76) | def vec(mat):
  function test_vec (line 83) | def test_vec():
  function test_kron_trace (line 88) | def test_kron_trace():
  function tvec (line 97) | def tvec(mat):
  function test_tvec (line 103) | def test_tvec():
  function unvec (line 108) | def unvec(a, rows):
  function untvec (line 117) | def untvec(a, rows):
  function kron (line 125) | def kron(a: Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]], b: O...
  function stable_kron (line 148) | def stable_kron(a, b):
  class SpecialForm (line 153) | class SpecialForm:
    method normal_form (line 154) | def normal_form(self):
  class Vec (line 158) | class Vec(SpecialForm):
    method __init__ (line 173) | def __init__(self, mat, shape: Tuple = None):
    method vec_form (line 189) | def vec_form(self):
    method matrix_form (line 192) | def matrix_form(self):
    method normal_form (line 195) | def normal_form(self):
    method __matmul__ (line 198) | def __matmul__(self, other):
    method __rmatmul__ (line 206) | def __rmatmul__(self, other):
    method __truediv__ (line 213) | def __truediv__(self, other):
    method norm (line 216) | def norm(self):
    method commute (line 219) | def commute(self):
    method __str__ (line 225) | def __str__(self):
  class Vecr (line 229) | class Vecr(SpecialForm):
    method __init__ (line 243) | def __init__(self, mat, shape: Tuple = None):
    method vec_form (line 259) | def vec_form(self):
    method matrix_form (line 262) | def matrix_form(self):
    method normal_form (line 265) | def normal_form(self):
    method __matmul__ (line 268) | def __matmul__(self, other):
    method __rmatmul__ (line 276) | def __rmatmul__(self, other):
    method __truediv__ (line 283) | def __truediv__(self, other):
    method norm (line 286) | def norm(self):
    method commute (line 289) | def commute(self):
    method __str__ (line 295) | def __str__(self):
  class Cov (line 299) | class Cov(SpecialForm):
  class FactoredCov (line 303) | class FactoredCov(SpecialForm):
  class KronFactoredCov (line 307) | class KronFactoredCov(SpecialForm):
    method __init__ (line 320) | def __init__(self, a_dim, b_dim):
    method add_samples (line 331) | def add_samples(self, A: torch.Tensor, B: torch.Tensor):
    method value (line 373) | def value(self) -> "Kron":
    method cross (line 376) | def cross(self) -> torch.Tensor:
    method wilks (line 380) | def wilks(self) -> torch.Tensor:
    method bartlett (line 392) | def bartlett(self):
    method prob_dep (line 401) | def prob_dep(self):
    method sigmas_indep (line 407) | def sigmas_indep(self):
    method __str__ (line 413) | def __str__(self):
  function square (line 417) | def square(a: torch.Tensor):
  class Kron (line 422) | class Kron(SpecialForm):
    method __init__ (line 431) | def __init__(self, LL, RR):
    method commute (line 447) | def commute(self):
    method normal_form (line 452) | def normal_form(self):
    method expand (line 455) | def expand(self):
    method expand_vec (line 459) | def expand_vec(self):
    method sym_l2_norm (line 463) | def sym_l2_norm(self):
    method symsqrt (line 466) | def symsqrt(self, cond=None, return_rank=False):
    method trace (line 476) | def trace(self):
    method frobenius_norm (line 479) | def frobenius_norm(self):
    method pinv (line 482) | def pinv(self):
    method inv (line 485) | def inv(self):
    method shape (line 489) | def shape(self):
    method qf (line 492) | def qf(self, G):
    method qf_vec (line 498) | def qf_vec(self, G):
    method __truediv__ (line 505) | def __truediv__(self, other):
    method __add__ (line 508) | def __add__(self, other):
    method __radd__ (line 512) | def __radd__(self, other):
    method __mul__ (line 516) | def __mul__(self, other):
    method __rmul__ (line 520) | def __rmul__(self, other):
    method __matmul__ (line 537) | def __matmul__(self, x):
    method __rmatmul__ (line 554) | def __rmatmul__(self, x):
    method __str__ (line 568) | def __str__(self):
    method __iter__ (line 571) | def __iter__(self):
  class MeanKronFactored (line 575) | class MeanKronFactored(SpecialForm):
    method __init__ (line 580) | def __init__(self, AA: torch.Tensor, BB: torch.Tensor):
    method expand (line 595) | def expand(self):
  function expand_hess (line 612) | def expand_hess(*v) -> Union[torch.Tensor, List[torch.Tensor]]:
  function test_kron (line 625) | def test_kron():
  function nan_check (line 634) | def nan_check(mat):
  function has_nan (line 642) | def has_nan(mat):
  function fro_norm (line 646) | def fro_norm(mat: torch.Tensor):
  function l2_norm (line 653) | def l2_norm(mat: torch.Tensor):
  function sym_l2_norm (line 667) | def sym_l2_norm(mat: torch.Tensor):
  function inv_square_root_numpy (line 685) | def inv_square_root_numpy(mat):
  function pinv_square_root_numpy (line 690) | def pinv_square_root_numpy(mat):
  function erank (line 696) | def erank(mat):
  function rank (line 701) | def rank(A):
  function sym_erank (line 709) | def sym_erank(mat):
  function lyapunov_spectral (line 714) | def lyapunov_spectral(A, B, cond=None):
  function lyapunov_svd (line 735) | def lyapunov_svd(A, C, rtol=1e-4, eps=1e-7, use_svd=False):
  function deleteme (line 761) | def deleteme():
  function lyapunov_svd2 (line 766) | def lyapunov_svd2(A, C, rtol=1e-4, eps=1e-7, use_svd=False):
  function lyapunov_truncated (line 795) | def lyapunov_truncated(A, C, use_svd=False, top_k=None, check_error=False):
  function lyapunov_lstsq (line 838) | def lyapunov_lstsq(A, C):
  function truncated_lyapunov_rho (line 847) | def truncated_lyapunov_rho(A, C):
  function outer (line 889) | def outer(x, y=None):
  function to_python_scalar (line 896) | def to_python_scalar(x):
  function is_scalar (line 905) | def is_scalar(x):
  function from_numpy (line 913) | def from_numpy(x) -> torch.Tensor:
  function pytorch_dtype_to_floating_numpy_dtype (line 934) | def pytorch_dtype_to_floating_numpy_dtype(dtype):
  function to_normal_form (line 947) | def to_normal_form(x):
  function to_pytorch (line 955) | def to_pytorch(x) -> torch.Tensor:
  function to_pytorches (line 966) | def to_pytorches(*xs) -> Tuple[torch.Tensor, ...]:
  function to_numpy (line 970) | def to_numpy(x, dtype: np.dtype = None) -> np.ndarray:
  function to_numpys (line 1007) | def to_numpys(*xs, dtype=np.float32):
  function khatri_rao (line 1011) | def khatri_rao(A: torch.Tensor, B: torch.Tensor):
  function khatri_rao_t (line 1022) | def khatri_rao_t(A: torch.Tensor, B: torch.Tensor):
  function jacobian (line 1034) | def jacobian(y: torch.Tensor, x: torch.Tensor, create_graph=False):
  function hessian (line 1046) | def hessian(y: torch.Tensor, x: torch.Tensor):
  function pinv (line 1050) | def pinv(mat: torch.Tensor, cond=None) -> torch.Tensor:
  function eig_real (line 1074) | def eig_real(mat: torch.Tensor) -> torch.Tensor:
  function pinv_square_root (line 1091) | def pinv_square_root(mat: torch.Tensor, eps=1e-4) -> torch.Tensor:
  function symeig_pos_evals (line 1100) | def symeig_pos_evals(mat: torch.Tensor) -> torch.Tensor:
  function svd_pos_svals (line 1107) | def svd_pos_svals(mat):
  function filter_evals (line 1114) | def filter_evals(vals, cond=None, remove_small=True, remove_negative=True):
  function isymsqrt (line 1130) | def isymsqrt(mat, *args):
  function symsqrt (line 1134) | def symsqrt(mat, cond=None, return_rank=False, inverse=False):
  function symsqrt_svd (line 1172) | def symsqrt_svd(mat: torch.Tensor):
  function robust_svd (line 1184) | def robust_svd(mat: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, t...
  function regularize_mat (line 1203) | def regularize_mat(mat, eps):
  function regularize_mat2 (line 1209) | def regularize_mat2(mat, eps):
  function symsqrt_dist (line 1227) | def symsqrt_dist(cov1: torch.Tensor, cov2: torch.Tensor) -> float:
  function check_symmetric (line 1237) | def check_symmetric(mat):
  function check_close (line 1245) | def check_close(a0, b0, rtol=1e-5, atol=1e-8, label: str = '') -> None:
  function check_equal (line 1251) | def check_equal(observed, truth, rtol=1e-9, atol=1e-12, label: str = '')...
  function get_param (line 1278) | def get_param(layer):  # TODO(y): deprecate?
  class timeit (line 1288) | class timeit:
    method __init__ (line 1292) | def __init__(self, tag=""):
    method __enter__ (line 1295) | def __enter__(self):
    method __exit__ (line 1299) | def __exit__(self, *args):
  function run_all_tests (line 1307) | def run_all_tests(module: nn.Module):
  function freeze (line 1333) | def freeze(layer: nn.Module):
  function unfreeze (line 1339) | def unfreeze(layer: nn.Module):
  function mark_expensive (line 1345) | def mark_expensive(layer: nn.Module):
  function nest_stats (line 1349) | def nest_stats(tag: str, stats) -> Dict:
  function seed_random (line 1357) | def seed_random(seed: int) -> None:
  class TinyMNIST (line 1366) | class TinyMNIST(datasets.MNIST):
    method __init__ (line 1375) | def __init__(self, dataset_root='/tmp/data', data_width=4, targets_wid...
    method __getitem__ (line 1430) | def __getitem__(self, index):
  class SimpleModel (line 1447) | class SimpleModel(nn.Module):
    method __init__ (line 1456) | def __init__(self, *args, **kwargs):
    method disable_hooks (line 1461) | def disable_hooks(self):
    method enable_hooks (line 1465) | def enable_hooks(self):
    method _finalize (line 1470) | def _finalize(self):
  function least_squares (line 1484) | def least_squares(data, targets=None, aggregation='mean'):
  function debug_least_squares (line 1495) | def debug_least_squares(data, targets=None):
  class SimpleModel2 (line 1507) | class SimpleModel2(nn.Module):
    method __init__ (line 1514) | def __init__(self, *args, **kwargs):
    method _finalize (line 1518) | def _finalize(self):
  function get_parent_model (line 1529) | def get_parent_model(module_or_param) -> Optional[nn.Module]:
  function capture_activations (line 1547) | def capture_activations(module: nn.Module, input: List[torch.Tensor], ou...
  function capture_backprops (line 1560) | def capture_backprops(module: nn.Module, _input, output):
  function save_grad (line 1578) | def save_grad(param: nn.Parameter) -> Callable[[torch.Tensor], None]:
  function clear_backprops (line 1589) | def clear_backprops(model: nn.Module) -> None:
  function register_hooks (line 1603) | def register_hooks(model: SimpleModel):
  class SimpleFullyConnected (line 1617) | class SimpleFullyConnected(SimpleModel):
    method __init__ (line 1620) | def __init__(self, d: List[int], nonlin=False, bias=False, dropout=Fal...
    method forward (line 1646) | def forward(self, x: torch.Tensor):
  class SimpleFullyConnected2 (line 1651) | class SimpleFullyConnected2(SimpleModel2):
    method __init__ (line 1654) | def __init__(self, d: List[int], nonlin=False, bias=False, last_layer_...
    method forward (line 1682) | def forward(self, x: torch.Tensor):
  class SimpleMLP (line 1687) | class SimpleMLP(nn.Module):
    method __init__ (line 1693) | def __init__(self, d: List[int], nonlin=False, bias=False):
    method forward (line 1715) | def forward(self, x: torch.Tensor):
  class RedundantFullyConnected2 (line 1720) | class RedundantFullyConnected2(SimpleModel2):
    method __init__ (line 1723) | def __init__(self, d: List[int], nonlin=False, bias=False, last_layer_...
    method forward (line 1758) | def forward(self, x: torch.Tensor):
  class SimpleConvolutional (line 1773) | class SimpleConvolutional(SimpleModel):
    method __init__ (line 1776) | def __init__(self, d: List[int], kernel_size=(2, 2), nonlin=False, bia...
    method forward (line 1797) | def forward(self, x: torch.Tensor):
  class SimpleConvolutional2 (line 1801) | class SimpleConvolutional2(SimpleModel2):
    method __init__ (line 1804) | def __init__(self, d: List[int], kernel_size=(2, 2), nonlin=False, bia...
    method forward (line 1830) | def forward(self, x: torch.Tensor):
  class ReshapedConvolutional2 (line 1834) | class ReshapedConvolutional2(SimpleConvolutional2):
    method __init__ (line 1837) | def __init__(self, *args, **kwargs):
    method forward (line 1845) | def forward(self, x: torch.Tensor):
  class PooledConvolutional2 (line 1850) | class PooledConvolutional2(SimpleConvolutional2):
    method __init__ (line 1853) | def __init__(self, *args, **kwargs):
    method forward (line 1861) | def forward(self, x: torch.Tensor):
  class StridedConvolutional2 (line 1867) | class StridedConvolutional2(SimpleModel2):
    method __init__ (line 1870) | def __init__(self, d: List[int], kernel_size=(2, 2), nonlin=False, bia...
    method forward (line 1898) | def forward(self, x: torch.Tensor):
  class GroupedConvolutional2 (line 1906) | class GroupedConvolutional2(SimpleModel2):
    method __init__ (line 1911) | def __init__(self, d: List[int], kernel_size=(2, 2), o=None, nonlin=Fa...
    method forward (line 1940) | def forward(self, x: torch.Tensor):
  class ReshapedConvolutional (line 1952) | class ReshapedConvolutional(SimpleConvolutional):
    method __init__ (line 1955) | def __init__(self, *args, **kwargs):
    method forward (line 1963) | def forward(self, x: torch.Tensor):
  function log_scalars (line 1968) | def log_scalars(metrics: Dict[str, Any]) -> None:
  function log_scalar (line 1977) | def log_scalar(**metrics) -> None:
  function log_spectrum (line 1991) | def log_spectrum(tag, vals: torch.Tensor, loglog=True, discard_tiny=False):
  function get_events (line 2015) | def get_events(fname, x_axis='step'):
  function infinite_iter (line 2054) | def infinite_iter(obj):
  function dump (line 2062) | def dump(result, fname):
  function print_version_info (line 2081) | def print_version_info():
  function print_cpu_info (line 2110) | def print_cpu_info():
  function move_to_gpu (line 2146) | def move_to_gpu(tensors):
  function fmt (line 2150) | def fmt(a):
  function to_logits (line 2157) | def to_logits(p: torch.Tensor) -> torch.Tensor:
  class CrossEntropySoft (line 2169) | class CrossEntropySoft(nn.Module):
    method __init__ (line 2178) | def __init__(self):
    method forward (line 2182) | def forward(self, inputs, target):
  function get_unique_logdir (line 2202) | def get_unique_logdir(root_logdir: str) -> str:
  function setup_logdir_and_event_writer (line 2214) | def setup_logdir_and_event_writer(run_name: str, init_wandb=False):
  class HessianBackprop (line 2244) | class HessianBackprop:
  class HessianExactSqrLoss (line 2248) | class HessianExactSqrLoss(HessianBackprop):
    method __init__ (line 2251) | def __init__(self):
    method __call__ (line 2254) | def __call__(self, output: torch.Tensor):
  class HessianSampledSqrLoss (line 2264) | class HessianSampledSqrLoss(HessianBackprop):
    method __init__ (line 2267) | def __init__(self, num_samples):
    method __call__ (line 2271) | def __call__(self, output: torch.Tensor):
  class HessianExactCrossEntropyLoss (line 2287) | class HessianExactCrossEntropyLoss(HessianBackprop):
    method __init__ (line 2290) | def __init__(self):
    method __call__ (line 2293) | def __call__(self, logits: torch.Tensor):
  function hessian_from_backprops (line 2314) | def hessian_from_backprops(A_t, Bh_t, bias=False):
  function per_example_hess (line 2342) | def per_example_hess(A_t, Bh_t, bias=False):
  function kl_div_cov (line 2395) | def kl_div_cov(mat1, mat2, eps=1e-3):
  function kron_quadratic_form (line 2414) | def kron_quadratic_form(H, dd):
  function kron_trace (line 2419) | def kron_trace(H: Tuple[torch.Tensor, torch.Tensor]):
  function kron_trace_matmul (line 2425) | def kron_trace_matmul(H, sigma):
  function kron_pinv (line 2434) | def kron_pinv(H: Tuple):
  function kron_nan_check (line 2439) | def kron_nan_check(H):
  function kron_fro_norm (line 2444) | def kron_fro_norm(H):
  function kron_sym_l2_norm (line 2448) | def kron_sym_l2_norm(H):
  function kron_inv (line 2452) | def kron_inv(H):
  function kron_sigma (line 2456) | def kron_sigma(G):
  function kron_batch_sum (line 2462) | def kron_batch_sum(G: Tuple):
  function chop (line 2468) | def chop(mat: torch.Tensor, eps=1e-10) -> torch.Tensor:
  function format_list (line 2476) | def format_list(ll: List) -> str:
  function create_local_logdir (line 2481) | def create_local_logdir(logdir) -> str:
  class NoOp (line 2490) | class NoOp:
    method __getattr__ (line 2493) | def __getattr__(self, *_args, **_kwargs):
  function install_pdb_handler (line 2499) | def install_pdb_handler():
  function randomly_rotate (line 2532) | def randomly_rotate(X: torch.Tensor) -> torch.Tensor:
  function random_cov (line 2544) | def random_cov(rank, d=None, n=20) -> torch.Tensor:
  function _to_mathematica (line 2564) | def _to_mathematica(x):
  function _from_mathematica (line 2575) | def _from_mathematica(x):
  function _dim_check (line 2582) | def _dim_check(d, rank=0):
  function random_cov_pair (line 2588) | def random_cov_pair(shared_rank, independent_rank, d, n=20, strength=1):
  function is_row_matrix (line 2604) | def is_row_matrix(dd):
  function is_col_matrix (line 2608) | def is_col_matrix(dd):
  function is_square_matrix (line 2612) | def is_square_matrix(dd):
  function is_vector (line 2616) | def is_vector(dd) -> bool:
  function is_matrix (line 2621) | def is_matrix(dd) -> bool:
  function eye (line 2626) | def eye(d: int) -> torch.Tensor:
  function eye_like (line 2630) | def eye_like(X: torch.Tensor) -> torch.Tensor:
  function rmul (line 2639) | def rmul(a: torch.Tensor, b):
  function matmul (line 2644) | def matmul(a, b):
  function rmatmul (line 2651) | def rmatmul(a: torch.Tensor, b):
  function norm_squared (line 2656) | def norm_squared(param):
  function dot_product (line 2660) | def dot_product(A, B):
  function copy_stats (line 2685) | def copy_stats(shared_stats, stats):
  function skip_nans (line 2692) | def skip_nans(t): return t[torch.isfinite(t)]
  class MyList (line 2696) | class MyList:
    method __init__ (line 2697) | def __init__(self, *args, **kwargs):
    method __getattr__ (line 2701) | def __getattr__(self, *_args, **_kwargs):
    method normal_form (line 2704) | def normal_form(self):
    method value (line 2707) | def value(self):
  function divide_attributes (line 2711) | def divide_attributes(d, n):

FILE: autotune/util_test.py
  function test_khatri_rao (line 17) | def test_khatri_rao():
  function test_khatri_rao_t (line 25) | def test_khatri_rao_t():
  function test_to_logits (line 38) | def test_to_logits():
  function test_cross_entropy_soft (line 46) | def test_cross_entropy_soft():
  function test_symsqrt (line 82) | def test_symsqrt():
  function atest_pinv (line 134) | def atest_pinv():
  function test_pinverse (line 162) | def test_pinverse():
  function test_l2_norm (line 186) | def test_l2_norm():
  function test_symsqrt_neg (line 193) | def test_symsqrt_neg():
  function test_truncated_lyapunov (line 245) | def test_truncated_lyapunov():
  function test_lyapunov_lstsq (line 258) | def test_lyapunov_lstsq():
  function test_robust_svd (line 280) | def test_robust_svd():
  function test_misc (line 288) | def test_misc():
  function test_kron (line 294) | def test_kron():
  function test_contiguous (line 400) | def test_contiguous():

FILE: benchmark_huggingface_predict.py
  function to_list (line 37) | def to_list(tensor):
  function predict (line 40) | def predict(line, max_predictions):
  class timeit (line 86) | class timeit:
    method __init__ (line 90) | def __init__(self, tag=""):
    method __enter__ (line 93) | def __enter__(self):
    method __exit__ (line 97) | def __exit__(self, *args):

FILE: cluster/async_adder.py
  function traced_run (line 50) | def traced_run(fetches):
  function sessrun (line 78) | def sessrun(fetches):
  function get_ps_device (line 84) | def get_ps_device(task=0, op_device_str=''):
  function get_worker_device (line 93) | def get_worker_device(task, op_device_str=''):
  function session_config (line 101) | def session_config():
  function write_event (line 109) | def write_event(tag, value, step):
  function make_params (line 123) | def make_params():
  function run_worker (line 132) | def run_worker():
  class MyClusterConfig (line 242) | class MyClusterConfig:
    method __init__ (line 243) | def __init__(self):
    method __str__ (line 248) | def __str__(self):
  function load_config (line 251) | def load_config():
  function run_ps (line 275) | def run_ps():
  function _get_master (line 296) | def _get_master():
  function main (line 343) | def main():

FILE: cluster/aws.py
  function _ExecuteCommandInThread (line 46) | def _ExecuteCommandInThread(ssh_client,
  function _StreamOutputToFile (line 76) | def _StreamOutputToFile(fd, file, line_extractor, cmd=None):
  function _ExecuteCommandAndStreamOutput (line 101) | def _ExecuteCommandAndStreamOutput(ssh_client,
  function lookup_aws_instances (line 140) | def lookup_aws_instances(name):
  function tf_job (line 165) | def tf_job(name, num_tasks, instance_type=None, placement_group=''):
  function terminate_job (line 209) | def terminate_job(name):
  function _ssh_to_host (line 225) | def _ssh_to_host(hostname,
  class Job (line 264) | class Job:
    method __init__ (line 265) | def __init__(self, name, instances):
    method wait_until_ready (line 272) | def wait_until_ready(self):
  function _encode_float (line 278) | def _encode_float(value):
  function _decode_float (line 282) | def _decode_float(b16):
  class Task (line 285) | class Task:
    method __init__ (line 286) | def __init__(self, instance, job, task_id):
    method wait_until_ready (line 297) | def wait_until_ready(self):
    method initialize (line 306) | def initialize(self):
    method run_sync (line 319) | def run_sync(self, cmd):
    method _setup_tasklogdir (line 329) | def _setup_tasklogdir(self):
    method run (line 333) | def run(self, cmd, mirror_output=False):
    method upload (line 360) | def upload(self, local_file, remote_file=None):
    method _upload_directory (line 371) | def _upload_directory(self, local_directory, remote_directory):
    method public_ip (line 375) | def public_ip(self):
    method port (line 380) | def port(self):
    method ip (line 384) | def ip(self):  # private ip

FILE: cluster/benchmark_grpc_recv.py
  function session_config (line 50) | def session_config():
  function clusterspec (line 59) | def clusterspec():
  function create_graph (line 64) | def create_graph(device0, device1):
  function create_done_queue (line 82) | def create_done_queue(i):
  function make_event (line 97) | def make_event(tag, value, step):
  function run_benchmark (line 106) | def run_benchmark(sess, init_op, add_op):
  function run_benchmark_local (line 134) | def run_benchmark_local():
  function run_benchmark_distributed (line 140) | def run_benchmark_distributed():

FILE: cluster/benchmarks/bower_components/d3/d3.js
  function d3_documentElement (line 9) | function d3_documentElement(node) {
  function d3_window (line 12) | function d3_window(node) {
  function d3_ascending (line 46) | function d3_ascending(a, b) {
  function d3_number (line 109) | function d3_number(x) {
  function d3_numeric (line 112) | function d3_numeric(x) {
  function d3_bisector (line 171) | function d3_bisector(compare) {
  function d3_zipLength (line 232) | function d3_zipLength(d) {
  function d3_range_integerScale (line 284) | function d3_range_integerScale(x) {
  function d3_class (line 289) | function d3_class(ctor, properties) {
  function d3_Map (line 311) | function d3_Map() {
  function d3_map_escape (line 344) | function d3_map_escape(key) {
  function d3_map_unescape (line 347) | function d3_map_unescape(key) {
  function d3_map_has (line 350) | function d3_map_has(key) {
  function d3_map_remove (line 353) | function d3_map_remove(key) {
  function d3_map_keys (line 356) | function d3_map_keys() {
  function d3_map_size (line 361) | function d3_map_size() {
  function d3_map_empty (line 366) | function d3_map_empty() {
  function map (line 372) | function map(mapType, array, depth) {
  function entries (line 396) | function entries(map, depth) {
  function d3_Set (line 438) | function d3_Set() {
  function d3_identity (line 456) | function d3_identity(d) {
  function d3_rebind (line 464) | function d3_rebind(target, source, method) {
  function d3_vendorSymbol (line 470) | function d3_vendorSymbol(object, name) {
  function d3_noop (line 479) | function d3_noop() {}
  function d3_dispatch (line 485) | function d3_dispatch() {}
  function d3_dispatch_event (line 500) | function d3_dispatch_event(dispatch) {
  function d3_eventPreventDefault (line 523) | function d3_eventPreventDefault() {
  function d3_eventSource (line 526) | function d3_eventSource() {
  function d3_eventDispatch (line 531) | function d3_eventDispatch(target) {
  function d3_selection (line 557) | function d3_selection(groups) {
  function d3_selection_selector (line 600) | function d3_selection_selector(selector) {
  function d3_selection_selectorAll (line 618) | function d3_selection_selectorAll(selector) {
  function d3_selection_attr (line 656) | function d3_selection_attr(name, value) {
  function d3_collapse (line 680) | function d3_collapse(s) {
  function d3_selection_classedRe (line 700) | function d3_selection_classedRe(name) {
  function d3_selection_classes (line 703) | function d3_selection_classes(name) {
  function d3_selection_classed (line 706) | function d3_selection_classed(name, value) {
  function d3_selection_classedName (line 719) | function d3_selection_classedName(name) {
  function d3_selection_style (line 748) | function d3_selection_style(name, value, priority) {
  function d3_selection_property (line 769) | function d3_selection_property(name, value) {
  function d3_selection_creator (line 808) | function d3_selection_creator(name) {
  function d3_selectionRemove (line 828) | function d3_selectionRemove() {
  function bind (line 843) | function bind(group, groupData) {
  function d3_selection_dataNode (line 911) | function d3_selection_dataNode(data) {
  function d3_selection_filter (line 933) | function d3_selection_filter(selector) {
  function d3_selection_sortComparator (line 954) | function d3_selection_sortComparator(comparator) {
  function d3_selection_each (line 965) | function d3_selection_each(groups, callback) {
  function d3_selection_enter (line 997) | function d3_selection_enter(selection) {
  function d3_selection_enterInsertBefore (line 1030) | function d3_selection_enterInsertBefore(enter) {
  function d3_selection_on (line 1075) | function d3_selection_on(type, listener, capture) {
  function d3_selection_onListener (line 1114) | function d3_selection_onListener(listener, argumentz) {
  function d3_selection_onFilter (line 1126) | function d3_selection_onFilter(listener, argumentz) {
  function d3_event_dragSuppress (line 1136) | function d3_event_dragSuppress(node) {
  function d3_mousePoint (line 1164) | function d3_mousePoint(container, e) {
  function drag (line 1203) | function drag() {
  function dragstart (line 1206) | function dragstart(id, position, subject, move, end) {
  function d3_behavior_dragTouchId (line 1250) | function d3_behavior_dragTouchId() {
  function d3_sgn (line 1262) | function d3_sgn(x) {
  function d3_cross2d (line 1265) | function d3_cross2d(a, b, c) {
  function d3_acos (line 1268) | function d3_acos(x) {
  function d3_asin (line 1271) | function d3_asin(x) {
  function d3_sinh (line 1274) | function d3_sinh(x) {
  function d3_cosh (line 1277) | function d3_cosh(x) {
  function d3_tanh (line 1280) | function d3_tanh(x) {
  function d3_haversin (line 1283) | function d3_haversin(x) {
  function interpolate (line 1290) | function interpolate(t) {
  function zoom (line 1316) | function zoom(g) {
  function location (line 1416) | function location(p) {
  function point (line 1419) | function point(l) {
  function scaleTo (line 1422) | function scaleTo(s) {
  function translateTo (line 1425) | function translateTo(p, l) {
  function zoomTo (line 1430) | function zoomTo(that, p, l, k) {
  function rescale (line 1442) | function rescale() {
  function zoomstarted (line 1450) | function zoomstarted(dispatch) {
  function zoomed (line 1455) | function zoomed(dispatch) {
  function zoomended (line 1463) | function zoomended(dispatch) {
  function mousedowned (line 1469) | function mousedowned() {
  function touchstarted (line 1484) | function touchstarted() {
  function mousewheeled (line 1554) | function mousewheeled() {
  function dblclicked (line 1567) | function dblclicked() {
  function d3_color (line 1575) | function d3_color() {}
  function d3_hsl (line 1580) | function d3_hsl(h, s, l) {
  function d3_hsl_rgb (line 1595) | function d3_hsl_rgb(h, s, l) {
  function d3_hcl (line 1615) | function d3_hcl(h, c, l) {
  function d3_hcl_lab (line 1628) | function d3_hcl_lab(h, c, l) {
  function d3_lab (line 1634) | function d3_lab(l, a, b) {
  function d3_lab_rgb (line 1649) | function d3_lab_rgb(l, a, b) {
  function d3_lab_hcl (line 1656) | function d3_lab_hcl(l, a, b) {
  function d3_lab_xyz (line 1659) | function d3_lab_xyz(x) {
  function d3_xyz_lab (line 1662) | function d3_xyz_lab(x) {
  function d3_xyz_rgb (line 1665) | function d3_xyz_rgb(r) {
  function d3_rgb (line 1669) | function d3_rgb(r, g, b) {
  function d3_rgbNumber (line 1672) | function d3_rgbNumber(value) {
  function d3_rgbString (line 1675) | function d3_rgbString(value) {
  function d3_rgb_hex (line 1698) | function d3_rgb_hex(v) {
  function d3_rgb_parse (line 1701) | function d3_rgb_parse(format, rgb, hsl) {
  function d3_rgb_hsl (line 1737) | function d3_rgb_hsl(r, g, b) {
  function d3_rgb_lab (line 1749) | function d3_rgb_lab(r, g, b) {
  function d3_rgb_xyz (line 1756) | function d3_rgb_xyz(r) {
  function d3_rgb_parseNumber (line 1759) | function d3_rgb_parseNumber(c) {
  function d3_functor (line 1916) | function d3_functor(v) {
  function d3_xhrType (line 1923) | function d3_xhrType(response) {
  function d3_xhr (line 1930) | function d3_xhr(url, mimeType, response, callback) {
  function d3_xhr_fixCallback (line 2005) | function d3_xhr_fixCallback(callback) {
  function d3_xhrHasResponse (line 2010) | function d3_xhrHasResponse(request) {
  function dsv (line 2016) | function dsv(url, row, callback) {
  function response (line 2024) | function response(request) {
  function typedResponse (line 2027) | function typedResponse(f) {
  function token (line 2046) | function token() {
  function formatRow (line 2108) | function formatRow(row) {
  function formatValue (line 2111) | function formatValue(text) {
  function d3_timer_step (line 2139) | function d3_timer_step() {
  function d3_timer_mark (line 2156) | function d3_timer_mark() {
  function d3_timer_sweep (line 2165) | function d3_timer_sweep() {
  function d3_format_precision (line 2178) | function d3_format_precision(x, p) {
  function d3_formatPrefix (line 2195) | function d3_formatPrefix(d, i) {
  function d3_locale_numberFormat (line 2206) | function d3_locale_numberFormat(locale) {
  function d3_format_typeDefault (line 2327) | function d3_format_typeDefault(x) {
  function d3_date_utc (line 2331) | function d3_date_utc() {
  function d3_time_interval (line 2397) | function d3_time_interval(local, step, number) {
  function d3_time_interval_utc (line 2445) | function d3_time_interval_utc(method) {
  function d3_locale_timeFormat (line 2505) | function d3_locale_timeFormat(locale) {
  function d3_time_formatPad (line 2725) | function d3_time_formatPad(value, fill, width) {
  function d3_time_formatRe (line 2729) | function d3_time_formatRe(names) {
  function d3_time_formatLookup (line 2732) | function d3_time_formatLookup(names) {
  function d3_time_parseWeekdayNumber (line 2737) | function d3_time_parseWeekdayNumber(date, string, i) {
  function d3_time_parseWeekNumberSunday (line 2742) | function d3_time_parseWeekNumberSunday(date, string, i) {
  function d3_time_parseWeekNumberMonday (line 2747) | function d3_time_parseWeekNumberMonday(date, string, i) {
  function d3_time_parseFullYear (line 2752) | function d3_time_parseFullYear(date, string, i) {
  function d3_time_parseYear (line 2757) | function d3_time_parseYear(date, string, i) {
  function d3_time_parseZone (line 2762) | function d3_time_parseZone(date, string, i) {
  function d3_time_expandYear (line 2766) | function d3_time_expandYear(d) {
  function d3_time_parseMonthNumber (line 2769) | function d3_time_parseMonthNumber(date, string, i) {
  function d3_time_parseDay (line 2774) | function d3_time_parseDay(date, string, i) {
  function d3_time_parseDayOfYear (line 2779) | function d3_time_parseDayOfYear(date, string, i) {
  function d3_time_parseHour24 (line 2784) | function d3_time_parseHour24(date, string, i) {
  function d3_time_parseMinutes (line 2789) | function d3_time_parseMinutes(date, string, i) {
  function d3_time_parseSeconds (line 2794) | function d3_time_parseSeconds(date, string, i) {
  function d3_time_parseMilliseconds (line 2799) | function d3_time_parseMilliseconds(date, string, i) {
  function d3_time_zone (line 2804) | function d3_time_zone(d) {
  function d3_time_parseLiteralPercent (line 2808) | function d3_time_parseLiteralPercent(date, string, i) {
  function d3_time_formatMulti (line 2813) | function d3_time_formatMulti(formats) {
  function d3_adder (line 2844) | function d3_adder() {}
  function d3_adderSum (line 2861) | function d3_adderSum(a, b, o) {
  function d3_geo_streamGeometry (line 2872) | function d3_geo_streamGeometry(geometry, listener) {
  function d3_geo_streamLine (line 2917) | function d3_geo_streamLine(coordinates, listener, closed) {
  function d3_geo_streamPolygon (line 2923) | function d3_geo_streamPolygon(coordinates, listener) {
  function d3_geo_areaRingStart (line 2952) | function d3_geo_areaRingStart() {
  function d3_geo_cartesian (line 2970) | function d3_geo_cartesian(spherical) {
  function d3_geo_cartesianDot (line 2974) | function d3_geo_cartesianDot(a, b) {
  function d3_geo_cartesianCross (line 2977) | function d3_geo_cartesianCross(a, b) {
  function d3_geo_cartesianAdd (line 2980) | function d3_geo_cartesianAdd(a, b) {
  function d3_geo_cartesianScale (line 2985) | function d3_geo_cartesianScale(vector, k) {
  function d3_geo_cartesianNormalize (line 2988) | function d3_geo_cartesianNormalize(d) {
  function d3_geo_spherical (line 2994) | function d3_geo_spherical(cartesian) {
  function d3_geo_sphericalEqual (line 2997) | function d3_geo_sphericalEqual(a, b) {
  function point (line 3022) | function point(λ, φ) {
  function linePoint (line 3027) | function linePoint(λ, φ) {
  function lineStart (line 3067) | function lineStart() {
  function lineEnd (line 3070) | function lineEnd() {
  function ringPoint (line 3075) | function ringPoint(λ, φ) {
  function ringStart (line 3083) | function ringStart() {
  function ringEnd (line 3086) | function ringEnd() {
  function angle (line 3093) | function angle(λ0, λ1) {
  function compareRanges (line 3096) | function compareRanges(a, b) {
  function withinRange (line 3099) | function withinRange(x, range) {
  function d3_geo_centroidPoint (line 3153) | function d3_geo_centroidPoint(λ, φ) {
  function d3_geo_centroidPointXYZ (line 3158) | function d3_geo_centroidPointXYZ(x, y, z) {
  function d3_geo_centroidLineStart (line 3164) | function d3_geo_centroidLineStart() {
  function d3_geo_centroidLineEnd (line 3185) | function d3_geo_centroidLineEnd() {
  function d3_geo_centroidRingStart (line 3188) | function d3_geo_centroidRingStart() {
  function d3_geo_compose (line 3218) | function d3_geo_compose(a, b) {
  function d3_true (line 3227) | function d3_true() {
  function d3_geo_clipPolygon (line 3230) | function d3_geo_clipPolygon(segments, compare, clipStartInside, interpol...
  function d3_geo_clipPolygonLinkCircular (line 3289) | function d3_geo_clipPolygonLinkCircular(array) {
  function d3_geo_clipPolygonIntersection (line 3300) | function d3_geo_clipPolygonIntersection(point, points, other, entry) {
  function d3_geo_clip (line 3308) | function d3_geo_clip(pointVisible, clipLine, interpolate, clipStart) {
  function d3_geo_clipSegmentLength1 (line 3400) | function d3_geo_clipSegmentLength1(segment) {
  function d3_geo_clipBufferListener (line 3403) | function d3_geo_clipBufferListener() {
  function d3_geo_clipSort (line 3424) | function d3_geo_clipSort(a, b) {
  function d3_geo_clipAntimeridianLine (line 3428) | function d3_geo_clipAntimeridianLine(listener) {
  function d3_geo_clipAntimeridianIntersect (line 3467) | function d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1) {
  function d3_geo_clipAntimeridianInterpolate (line 3471) | function d3_geo_clipAntimeridianInterpolate(from, to, direction, listene...
  function d3_geo_pointInPolygon (line 3494) | function d3_geo_pointInPolygon(point, polygon) {
  function d3_geo_clipCircle (line 3523) | function d3_geo_clipCircle(radius) {
  function d3_geom_clipLine (line 3619) | function d3_geom_clipLine(x0, y0, x1, y1) {
  function d3_geo_clipExtent (line 3691) | function d3_geo_clipExtent(x0, y0, x1, y1) {
  function d3_geo_conic (line 3825) | function d3_geo_conic(projectAt) {
  function d3_geo_conicEqualArea (line 3833) | function d3_geo_conicEqualArea(φ0, φ1) {
  function albersUsa (line 3860) | function albersUsa(coordinates) {
  function d3_geo_pathAreaRingStart (line 3942) | function d3_geo_pathAreaRingStart() {
  function d3_geo_pathBoundsPoint (line 3964) | function d3_geo_pathBoundsPoint(x, y) {
  function d3_geo_pathBuffer (line 3970) | function d3_geo_pathBuffer() {
  function d3_geo_pathBufferCircle (line 4015) | function d3_geo_pathBufferCircle(radius) {
  function d3_geo_pathCentroidPoint (line 4031) | function d3_geo_pathCentroidPoint(x, y) {
  function d3_geo_pathCentroidLineStart (line 4036) | function d3_geo_pathCentroidLineStart() {
  function d3_geo_pathCentroidLineEnd (line 4050) | function d3_geo_pathCentroidLineEnd() {
  function d3_geo_pathCentroidRingStart (line 4053) | function d3_geo_pathCentroidRingStart() {
  function d3_geo_pathContext (line 4074) | function d3_geo_pathContext(context) {
  function d3_geo_resample (line 4114) | function d3_geo_resample(project) {
  function path (line 4194) | function path(object) {
  function reset (line 4233) | function reset() {
  function d3_geo_pathProjectStream (line 4239) | function d3_geo_pathProjectStream(project) {
  function d3_geo_transform (line 4256) | function d3_geo_transform(stream) {
  function d3_geo_transformPoint (line 4279) | function d3_geo_transformPoint(stream, point) {
  function d3_geo_projection (line 4301) | function d3_geo_projection(project) {
  function d3_geo_projectionMutator (line 4306) | function d3_geo_projectionMutator(projectAt) {
  function d3_geo_projectionRadians (line 4378) | function d3_geo_projectionRadians(stream) {
  function d3_geo_equirectangular (line 4383) | function d3_geo_equirectangular(λ, φ) {
  function forward (line 4391) | function forward(coordinates) {
  function d3_geo_identityRotation (line 4401) | function d3_geo_identityRotation(λ, φ) {
  function d3_geo_rotation (line 4405) | function d3_geo_rotation(δλ, δφ, δγ) {
  function d3_geo_forwardRotationλ (line 4408) | function d3_geo_forwardRotationλ(δλ) {
  function d3_geo_rotationλ (line 4413) | function d3_geo_rotationλ(δλ) {
  function d3_geo_rotationφγ (line 4418) | function d3_geo_rotationφγ(δφ, δγ) {
  function circle (line 4432) | function circle() {
  function d3_geo_circleInterpolate (line 4462) | function d3_geo_circleInterpolate(radius, precision) {
  function d3_geo_circleAngle (line 4479) | function d3_geo_circleAngle(cr, point) {
  function graticule (line 4492) | function graticule() {
  function lines (line 4498) | function lines() {
  function d3_geo_graticuleX (line 4564) | function d3_geo_graticuleX(y0, y1, dy) {
  function d3_geo_graticuleY (line 4572) | function d3_geo_graticuleY(x0, x1, dx) {
  function d3_source (line 4580) | function d3_source(d) {
  function d3_target (line 4583) | function d3_target(d) {
  function greatArc (line 4588) | function greatArc() {
  function d3_geo_interpolate (line 4615) | function d3_geo_interpolate(x0, y0, x1, y1) {
  function d3_geo_lengthLineStart (line 4640) | function d3_geo_lengthLineStart() {
  function d3_geo_azimuthal (line 4655) | function d3_geo_azimuthal(scale, angle) {
  function d3_geo_conicConformal (line 4681) | function d3_geo_conicConformal(φ0, φ1) {
  function d3_geo_conicEquidistant (line 4704) | function d3_geo_conicEquidistant(φ0, φ1) {
  function d3_geo_mercator (line 4726) | function d3_geo_mercator(λ, φ) {
  function d3_geo_mercatorProjection (line 4732) | function d3_geo_mercatorProjection(project) {
  function d3_geo_transverseMercator (line 4773) | function d3_geo_transverseMercator(λ, φ) {
  function d3_geom_pointX (line 4791) | function d3_geom_pointX(d) {
  function d3_geom_pointY (line 4794) | function d3_geom_pointY(d) {
  function hull (line 4800) | function hull(data) {
  function d3_geom_hullUpper (line 4822) | function d3_geom_hullUpper(points) {
  function d3_geom_hullOrder (line 4830) | function d3_geom_hullOrder(a, b) {
  function d3_geom_polygonInside (line 4884) | function d3_geom_polygonInside(p, a, b) {
  function d3_geom_polygonIntersect (line 4887) | function d3_geom_polygonIntersect(c, d, a, b) {
  function d3_geom_polygonClosed (line 4891) | function d3_geom_polygonClosed(coordinates) {
  function d3_geom_voronoiBeach (line 4896) | function d3_geom_voronoiBeach() {
  function d3_geom_voronoiCreateBeach (line 4900) | function d3_geom_voronoiCreateBeach(site) {
  function d3_geom_voronoiDetachBeach (line 4905) | function d3_geom_voronoiDetachBeach(beach) {
  function d3_geom_voronoiRemoveBeach (line 4911) | function d3_geom_voronoiRemoveBeach(beach) {
  function d3_geom_voronoiAddBeach (line 4947) | function d3_geom_voronoiAddBeach(site) {
  function d3_geom_voronoiLeftBreakPoint (line 5001) | function d3_geom_voronoiLeftBreakPoint(arc, directrix) {
  function d3_geom_voronoiRightBreakPoint (line 5013) | function d3_geom_voronoiRightBreakPoint(arc, directrix) {
  function d3_geom_voronoiCell (line 5019) | function d3_geom_voronoiCell(site) {
  function d3_geom_voronoiCloseCells (line 5032) | function d3_geom_voronoiCloseCells(extent) {
  function d3_geom_voronoiHalfEdgeOrder (line 5062) | function d3_geom_voronoiHalfEdgeOrder(a, b) {
  function d3_geom_voronoiCircle (line 5065) | function d3_geom_voronoiCircle() {
  function d3_geom_voronoiAttachCircle (line 5069) | function d3_geom_voronoiAttachCircle(arc) {
  function d3_geom_voronoiDetachCircle (line 5102) | function d3_geom_voronoiDetachCircle(arc) {
  function d3_geom_voronoiClipEdges (line 5112) | function d3_geom_voronoiClipEdges(extent) {
  function d3_geom_voronoiConnectEdge (line 5122) | function d3_geom_voronoiConnectEdge(edge, extent) {
  function d3_geom_voronoiEdge (line 5196) | function d3_geom_voronoiEdge(lSite, rSite) {
  function d3_geom_voronoiCreateEdge (line 5201) | function d3_geom_voronoiCreateEdge(lSite, rSite, va, vb) {
  function d3_geom_voronoiCreateBorderEdge (line 5210) | function d3_geom_voronoiCreateBorderEdge(lSite, va, vb) {
  function d3_geom_voronoiSetEdgeEnd (line 5217) | function d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, vertex) {
  function d3_geom_voronoiHalfEdge (line 5228) | function d3_geom_voronoiHalfEdge(edge, lSite, rSite) {
  function d3_geom_voronoiRedBlackTree (line 5242) | function d3_geom_voronoiRedBlackTree() {
  function d3_geom_voronoiRedBlackNode (line 5245) | function d3_geom_voronoiRedBlackNode(node) {
  function d3_geom_voronoiRedBlackRotateLeft (line 5408) | function d3_geom_voronoiRedBlackRotateLeft(tree, node) {
  function d3_geom_voronoiRedBlackRotateRight (line 5421) | function d3_geom_voronoiRedBlackRotateRight(tree, node) {
  function d3_geom_voronoiRedBlackFirst (line 5434) | function d3_geom_voronoiRedBlackFirst(node) {
  function d3_geom_voronoi (line 5438) | function d3_geom_voronoi(sites, bbox) {
  function d3_geom_voronoiVertexOrder (line 5467) | function d3_geom_voronoiVertexOrder(a, b) {
  function voronoi (line 5473) | function voronoi(data) {
  function sites (line 5484) | function sites(data) {
  function d3_geom_voronoiTriangleArea (line 5537) | function d3_geom_voronoiTriangleArea(a, b, c) {
  function quadtree (line 5555) | function quadtree(data) {
  function d3_geom_quadtreeCompatX (line 5650) | function d3_geom_quadtreeCompatX(d) {
  function d3_geom_quadtreeCompatY (line 5653) | function d3_geom_quadtreeCompatY(d) {
  function d3_geom_quadtreeNode (line 5656) | function d3_geom_quadtreeNode() {
  function d3_geom_quadtreeVisit (line 5665) | function d3_geom_quadtreeVisit(f, node, x1, y1, x2, y2) {
  function d3_geom_quadtreeFind (line 5674) | function d3_geom_quadtreeFind(root, x, y, x0, y0, x3, y3) {
  function d3_interpolateRgb (line 5711) | function d3_interpolateRgb(a, b) {
  function d3_interpolateObject (line 5720) | function d3_interpolateObject(a, b) {
  function d3_interpolateNumber (line 5740) | function d3_interpolateNumber(a, b) {
  function d3_interpolateString (line 5747) | function d3_interpolateString(a, b) {
  function d3_interpolate (line 5781) | function d3_interpolate(a, b) {
  function d3_interpolateArray (line 5791) | function d3_interpolateArray(a, b) {
  function d3_ease_clamp (line 5842) | function d3_ease_clamp(f) {
  function d3_ease_reverse (line 5847) | function d3_ease_reverse(f) {
  function d3_ease_reflect (line 5852) | function d3_ease_reflect(f) {
  function d3_ease_quad (line 5857) | function d3_ease_quad(t) {
  function d3_ease_cubic (line 5860) | function d3_ease_cubic(t) {
  function d3_ease_cubicInOut (line 5863) | function d3_ease_cubicInOut(t) {
  function d3_ease_poly (line 5869) | function d3_ease_poly(e) {
  function d3_ease_sin (line 5874) | function d3_ease_sin(t) {
  function d3_ease_exp (line 5877) | function d3_ease_exp(t) {
  function d3_ease_circle (line 5880) | function d3_ease_circle(t) {
  function d3_ease_elastic (line 5883) | function d3_ease_elastic(a, p) {
  function d3_ease_back (line 5891) | function d3_ease_back(s) {
  function d3_ease_bounce (line 5897) | function d3_ease_bounce(t) {
  function d3_interpolateHcl (line 5901) | function d3_interpolateHcl(a, b) {
  function d3_interpolateHsl (line 5912) | function d3_interpolateHsl(a, b) {
  function d3_interpolateLab (line 5923) | function d3_interpolateLab(a, b) {
  function d3_interpolateRound (line 5932) | function d3_interpolateRound(a, b) {
  function d3_transform (line 5948) | function d3_transform(m) {
  function d3_transformDot (line 5964) | function d3_transformDot(a, b) {
  function d3_transformNormalize (line 5967) | function d3_transformNormalize(a) {
  function d3_transformCombine (line 5975) | function d3_transformCombine(a, b, k) {
  function d3_interpolateTransform (line 5989) | function d3_interpolateTransform(a, b) {
  function d3_uninterpolateNumber (line 6041) | function d3_uninterpolateNumber(a, b) {
  function d3_uninterpolateClamp (line 6047) | function d3_uninterpolateClamp(a, b) {
  function d3_layout_bundlePath (line 6061) | function d3_layout_bundlePath(link) {
  function d3_layout_bundleAncestors (line 6074) | function d3_layout_bundleAncestors(node) {
  function d3_layout_bundleLeastCommonAncestor (line 6084) | function d3_layout_bundleLeastCommonAncestor(a, b) {
  function relayout (line 6096) | function relayout() {
  function resort (line 6162) | function resort() {
  function repulse (line 6209) | function repulse(node) {
  function position (line 6381) | function position(dimension, size) {
  function dragmove (line 6410) | function dragmove(d) {
  function d3_layout_forceDragstart (line 6416) | function d3_layout_forceDragstart(d) {
  function d3_layout_forceDragend (line 6419) | function d3_layout_forceDragend(d) {
  function d3_layout_forceMouseover (line 6422) | function d3_layout_forceMouseover(d) {
  function d3_layout_forceMouseout (line 6426) | function d3_layout_forceMouseout(d) {
  function d3_layout_forceAccumulate (line 6429) | function d3_layout_forceAccumulate(quad, alpha, charges) {
  function hierarchy (line 6459) | function hierarchy(root) {
  function d3_layout_hierarchyRebind (line 6515) | function d3_layout_hierarchyRebind(object, hierarchy) {
  function d3_layout_hierarchyVisitBefore (line 6521) | function d3_layout_hierarchyVisitBefore(node, callback) {
  function d3_layout_hierarchyVisitAfter (line 6531) | function d3_layout_hierarchyVisitAfter(node, callback) {
  function d3_layout_hierarchyChildren (line 6544) | function d3_layout_hierarchyChildren(d) {
  function d3_layout_hierarchyValue (line 6547) | function d3_layout_hierarchyValue(d) {
  function d3_layout_hierarchySort (line 6550) | function d3_layout_hierarchySort(a, b) {
  function d3_layout_hierarchyLinks (line 6553) | function d3_layout_hierarchyLinks(nodes) {
  function position (line 6565) | function position(node, x, dx, dy) {
  function depth (line 6580) | function depth(node) {
  function partition (line 6588) | function partition(d, i) {
  function pie (line 6602) | function pie(data) {
  function stack (line 6652) | function stack(data, index) {
  function d3_layout_stackX (line 6707) | function d3_layout_stackX(d) {
  function d3_layout_stackY (line 6710) | function d3_layout_stackY(d) {
  function d3_layout_stackOut (line 6713) | function d3_layout_stackOut(d, y0, y) {
  function d3_layout_stackOrderDefault (line 6780) | function d3_layout_stackOrderDefault(data) {
  function d3_layout_stackOffsetZero (line 6783) | function d3_layout_stackOffsetZero(data) {
  function d3_layout_stackMaxIndex (line 6788) | function d3_layout_stackMaxIndex(array) {
  function d3_layout_stackReduceSum (line 6798) | function d3_layout_stackReduceSum(d) {
  function d3_layout_stackSum (line 6801) | function d3_layout_stackSum(p, d) {
  function histogram (line 6806) | function histogram(data, i) {
  function d3_layout_histogramBinSturges (line 6850) | function d3_layout_histogramBinSturges(range, values) {
  function d3_layout_histogramBinFixed (line 6853) | function d3_layout_histogramBinFixed(range, n) {
  function d3_layout_histogramRange (line 6858) | function d3_layout_histogramRange(values) {
  function pack (line 6863) | function pack(d, i) {
  function d3_layout_packSort (line 6902) | function d3_layout_packSort(a, b) {
  function d3_layout_packInsert (line 6905) | function d3_layout_packInsert(a, b) {
  function d3_layout_packSplice (line 6912) | function d3_layout_packSplice(a, b) {
  function d3_layout_packIntersects (line 6916) | function d3_layout_packIntersects(a, b) {
  function d3_layout_packSiblings (line 6920) | function d3_layout_packSiblings(node) {
  function d3_layout_packLink (line 6984) | function d3_layout_packLink(node) {
  function d3_layout_packUnlink (line 6987) | function d3_layout_packUnlink(node) {
  function d3_layout_packTransform (line 6991) | function d3_layout_packTransform(node, x, y, k) {
  function d3_layout_packPlace (line 7001) | function d3_layout_packPlace(a, b, c) {
  function tree (line 7017) | function tree(d, i) {
  function wrapTree (line 7036) | function wrapTree(root0) {
  function firstWalk (line 7060) | function firstWalk(v) {
  function secondWalk (line 7076) | function secondWalk(v) {
  function apportion (line 7080) | function apportion(v, w, ancestor) {
  function sizeNode (line 7110) | function sizeNode(node) {
  function d3_layout_treeSeparation (line 7131) | function d3_layout_treeSeparation(a, b) {
  function d3_layout_treeLeft (line 7134) | function d3_layout_treeLeft(v) {
  function d3_layout_treeRight (line 7138) | function d3_layout_treeRight(v) {
  function d3_layout_treeMove (line 7142) | function d3_layout_treeMove(wm, wp, shift) {
  function d3_layout_treeShift (line 7150) | function d3_layout_treeShift(v) {
  function d3_layout_treeAncestor (line 7159) | function d3_layout_treeAncestor(vim, v, ancestor) {
  function cluster (line 7164) | function cluster(d, i) {
  function d3_layout_clusterY (line 7204) | function d3_layout_clusterY(children) {
  function d3_layout_clusterX (line 7209) | function d3_layout_clusterX(children) {
  function d3_layout_clusterLeft (line 7214) | function d3_layout_clusterLeft(node) {
  function d3_layout_clusterRight (line 7218) | function d3_layout_clusterRight(node) {
  function scale (line 7224) | function scale(children, k) {
  function squarify (line 7231) | function squarify(node) {
  function stickify (line 7258) | function stickify(node) {
  function worst (line 7275) | function worst(row, u) {
  function position (line 7286) | function position(row, u, rect, flush) {
  function treemap (line 7316) | function treemap(d) {
  function padFunction (line 7335) | function padFunction(node) {
  function padConstant (line 7339) | function padConstant(node) {
  function d3_layout_treemapPadNull (line 7370) | function d3_layout_treemapPadNull(node) {
  function d3_layout_treemapPad (line 7378) | function d3_layout_treemapPad(node, padding) {
  function d3_scaleExtent (line 7430) | function d3_scaleExtent(domain) {
  function d3_scaleRange (line 7434) | function d3_scaleRange(scale) {
  function d3_scale_bilinear (line 7437) | function d3_scale_bilinear(domain, range, uninterpolate, interpolate) {
  function d3_scale_nice (line 7443) | function d3_scale_nice(domain, nice) {
  function d3_scale_niceStep (line 7453) | function d3_scale_niceStep(step) {
  function d3_scale_polylinear (line 7467) | function d3_scale_polylinear(domain, range, uninterpolate, interpolate) {
  function d3_scale_linear (line 7485) | function d3_scale_linear(domain, range, interpolate, clamp) {
  function d3_scale_linearRebind (line 7537) | function d3_scale_linearRebind(scale, linear) {
  function d3_scale_linearNice (line 7540) | function d3_scale_linearNice(domain, m) {
  function d3_scale_linearTickRange (line 7543) | function d3_scale_linearTickRange(domain, m) {
  function d3_scale_linearTicks (line 7552) | function d3_scale_linearTicks(domain, m) {
  function d3_scale_linearTickFormat (line 7555) | function d3_scale_linearTickFormat(domain, m, format) {
  function d3_scale_linearPrecision (line 7583) | function d3_scale_linearPrecision(value) {
  function d3_scale_linearFormatPrecision (line 7586) | function d3_scale_linearFormatPrecision(type, range) {
  function d3_scale_log (line 7593) | function d3_scale_log(linear, base, positive, domain) {
  function d3_scale_pow (line 7665) | function d3_scale_pow(linear, exponent, domain) {
  function d3_scale_powPow (line 7699) | function d3_scale_powPow(e) {
  function d3_scale_ordinal (line 7713) | function d3_scale_ordinal(domain, ranger) {
  function d3_scale_quantile (line 7821) | function d3_scale_quantile(domain, range) {
  function d3_scale_quantize (line 7857) | function d3_scale_quantize(x0, x1, range) {
  function d3_scale_threshold (line 7891) | function d3_scale_threshold(domain, range) {
  function d3_scale_identity (line 7917) | function d3_scale_identity(domain) {
  function d3_zero (line 7939) | function d3_zero() {
  function arc (line 7944) | function arc() {
  function circleSegment (line 8017) | function circleSegment(r1, cw) {
  function d3_svg_arcInnerRadius (line 8062) | function d3_svg_arcInnerRadius(d) {
  function d3_svg_arcOuterRadius (line 8065) | function d3_svg_arcOuterRadius(d) {
  function d3_svg_arcStartAngle (line 8068) | function d3_svg_arcStartAngle(d) {
  function d3_svg_arcEndAngle (line 8071) | function d3_svg_arcEndAngle(d) {
  function d3_svg_arcPadAngle (line 8074) | function d3_svg_arcPadAngle(d) {
  function d3_svg_arcSweep (line 8077) | function d3_svg_arcSweep(x0, y0, x1, y1) {
  function d3_svg_arcCornerTangents (line 8080) | function d3_svg_arcCornerTangents(p0, p1, r1, rc, cw) {
  function d3_svg_line (line 8085) | function d3_svg_line(projection) {
  function d3_svg_lineLinear (line 8152) | function d3_svg_lineLinear(points) {
  function d3_svg_lineLinearClosed (line 8155) | function d3_svg_lineLinearClosed(points) {
  function d3_svg_lineStep (line 8158) | function d3_svg_lineStep(points) {
  function d3_svg_lineStepBefore (line 8164) | function d3_svg_lineStepBefore(points) {
  function d3_svg_lineStepAfter (line 8169) | function d3_svg_lineStepAfter(points) {
  function d3_svg_lineCardinalOpen (line 8174) | function d3_svg_lineCardinalOpen(points, tension) {
  function d3_svg_lineCardinalClosed (line 8177) | function d3_svg_lineCardinalClosed(points, tension) {
  function d3_svg_lineCardinal (line 8181) | function d3_svg_lineCardinal(points, tension) {
  function d3_svg_lineHermite (line 8184) | function d3_svg_lineHermite(points, tangents) {
  function d3_svg_lineCardinalTangents (line 8211) | function d3_svg_lineCardinalTangents(points, tension) {
  function d3_svg_lineBasis (line 8221) | function d3_svg_lineBasis(points) {
  function d3_svg_lineBasisOpen (line 8237) | function d3_svg_lineBasisOpen(points) {
  function d3_svg_lineBasisClosed (line 8257) | function d3_svg_lineBasisClosed(points) {
  function d3_svg_lineBundle (line 8276) | function d3_svg_lineBundle(points, tension) {
  function d3_svg_lineDot4 (line 8289) | function d3_svg_lineDot4(a, b) {
  function d3_svg_lineBasisBezier (line 8293) | function d3_svg_lineBasisBezier(path, x, y) {
  function d3_svg_lineSlope (line 8296) | function d3_svg_lineSlope(p0, p1) {
  function d3_svg_lineFiniteDifferences (line 8299) | function d3_svg_lineFiniteDifferences(points) {
  function d3_svg_lineMonotoneTangents (line 8307) | function d3_svg_lineMonotoneTangents(points) {
  function d3_svg_lineMonotone (line 8331) | function d3_svg_lineMonotone(points) {
  function d3_svg_lineRadial (line 8340) | function d3_svg_lineRadial(points) {
  function d3_svg_area (line 8351) | function d3_svg_area(projection) {
  function chord (line 8441) | function chord(d, i) {
  function subgroup (line 8445) | function subgroup(self, f, d, i) {
  function equals (line 8455) | function equals(a, b) {
  function arc (line 8458) | function arc(r, p, a) {
  function curve (line 8461) | function curve(r0, p0, r1, p1) {
  function d3_svg_chordRadius (line 8491) | function d3_svg_chordRadius(d) {
  function diagonal (line 8496) | function diagonal(d, i) {
  function d3_svg_diagonalProjection (line 8524) | function d3_svg_diagonalProjection(d) {
  function d3_svg_diagonalRadialProjection (line 8534) | function d3_svg_diagonalRadialProjection(projection) {
  function symbol (line 8542) | function symbol(d, i) {
  function d3_svg_symbolSize (line 8557) | function d3_svg_symbolSize() {
  function d3_svg_symbolType (line 8560) | function d3_svg_symbolType() {
  function d3_svg_symbolCircle (line 8563) | function d3_svg_symbolCircle(size) {
  function d3_selection_interruptNS (line 8612) | function d3_selection_interruptNS(ns) {
  function d3_transition (line 8622) | function d3_transition(groups, ns, id) {
  function d3_transition_tween (line 8694) | function d3_transition_tween(groups, name, value, tween) {
  function attrNull (line 8708) | function attrNull() {
  function attrNullNS (line 8711) | function attrNullNS() {
  function attrTween (line 8714) | function attrTween(b) {
  function attrTweenNS (line 8722) | function attrTweenNS(b) {
  function attrTween (line 8734) | function attrTween(d, i) {
  function attrTweenNS (line 8740) | function attrTweenNS(d, i) {
  function styleNull (line 8758) | function styleNull() {
  function styleString (line 8761) | function styleString(b) {
  function styleTween (line 8773) | function styleTween(d, i) {
  function d3_transition_text (line 8784) | function d3_transition_text(b) {
  function d3_transitionNamespace (line 8864) | function d3_transitionNamespace(name) {
  function d3_transitionNode (line 8867) | function d3_transitionNode(node, i, ns, id, inherit) {
  function axis (line 8931) | function axis(g) {
  function d3_svg_axisX (line 9026) | function d3_svg_axisX(selection, x0, x1) {
  function d3_svg_axisY (line 9032) | function d3_svg_axisY(selection, y0, y1) {
  function brush (line 9040) | function brush(g) {
  function redraw (line 9126) | function redraw(g) {
  function redrawX (line 9131) | function redrawX(g) {
  function redrawY (line 9135) | function redrawY(g) {
  function brushstart (line 9139) | function brushstart() {
  function d3_time_formatIsoNative (line 9332) | function d3_time_formatIsoNative(date) {
  function d3_time_scale (line 9379) | function d3_time_scale(linear, methods, format) {
  function d3_time_scaleDate (line 9429) | function d3_time_scaleDate(t) {
  function d3_json (line 9488) | function d3_json(request) {
  function d3_html (line 9494) | function d3_html(request) {

FILE: cluster/benchmarks/bower_components/plottable/plottable.d.ts
  class Map (line 61) | class Map<K, V> {
  class Set (line 77) | class Set<T> {
  class CallbackSet (line 241) | class CallbackSet<CB extends Function> extends Set<CB> {
  type StackedDatum (line 246) | type StackedDatum = {
  type StackingResult (line 250) | type StackingResult = Utils.Map<Dataset, Utils.Map<string, StackedDatum>>;
  class ClientToSVGTranslator (line 306) | class ClientToSVGTranslator {
  type DatasetCallback (line 340) | type DatasetCallback = (dataset: Dataset) => void;
  class Dataset (line 341) | class Dataset {
  type RenderPolicy (line 400) | interface RenderPolicy {
  class Immediate (line 407) | class Immediate implements RenderPolicy {
  class AnimationFrame (line 414) | class AnimationFrame implements RenderPolicy {
  class Timeout (line 422) | class Timeout implements RenderPolicy {
  type Accessor (line 475) | interface Accessor<T> {
  type Projector (line 482) | type Projector = (datum: any, index: number, dataset: Dataset) => any;
  type AttributeToProjector (line 487) | type AttributeToProjector = {
  type AppliedProjector (line 494) | type AppliedProjector = (datum: any, index: number) => any;
  type AttributeToAppliedProjector (line 498) | type AttributeToAppliedProjector = {
  type SpaceRequest (line 507) | type SpaceRequest = {
  type Range (line 514) | type Range = {
  type Point (line 521) | type Point = {
  type Bounds (line 528) | type Bounds = {
  type Entity (line 535) | interface Entity<C extends Component> {
  type Formatter (line 543) | type Formatter = (d: any) => string;
  type SymbolFactory (line 635) | type SymbolFactory = (symbolSize: number) => string;
  type IncludedValuesProvider (line 652) | interface IncludedValuesProvider<D> {
  type PaddingExceptionsProvider (line 663) | interface PaddingExceptionsProvider<D> {
  type ScaleCallback (line 668) | interface ScaleCallback<S extends Scale<any, any>> {
  class Scale (line 671) | class Scale<D, R> {
  class QuantitativeScale (line 769) | class QuantitativeScale<D> extends Scale<D, number> {
  class Linear (line 891) | class Linear extends QuantitativeScale<number> {
  class ModifiedLog (line 911) | class ModifiedLog extends QuantitativeScale<number> {
  class Category (line 993) | class Category extends Scale<string, number> {
  class Color (line 1072) | class Color extends Scale<string, string> {
  class Time (line 1106) | class Time extends QuantitativeScale<Date> {
  class InterpolatedColor (line 1142) | class InterpolatedColor extends Scale<number, string> {
  type TickGenerator (line 1181) | interface TickGenerator<D> {
  type DrawStep (line 1207) | type DrawStep = {
  type AppliedDrawStep (line 1214) | type AppliedDrawStep = {
  class Drawer (line 1219) | class Drawer {
  class Line (line 1289) | class Line extends Drawer {
  class Area (line 1296) | class Area extends Drawer {
  class Rectangle (line 1303) | class Rectangle extends Drawer {
  class Arc (line 1308) | class Arc extends Drawer {
  class ArcOutline (line 1314) | class ArcOutline extends Drawer {
  class Symbol (line 1320) | class Symbol extends Drawer {
  class Segment (line 1325) | class Segment extends Drawer {
  type ComponentCallback (line 1330) | type ComponentCallback = (component: Component) => void;
  class Alignment (line 1332) | class Alignment {
  class Component (line 1340) | class Component {
  class ComponentContainer (line 1587) | class ComponentContainer extends Component {
  class Group (line 1619) | class Group extends ComponentContainer {
  class PlotGroup (line 1657) | class PlotGroup extends Group {
  class Axis (line 1667) | class Axis<D> extends Component {
  type TimeAxisTierConfiguration (line 1900) | type TimeAxisTierConfiguration = {
  type TimeAxisConfiguration (line 1910) | type TimeAxisConfiguration = TimeAxisTierConfiguration[];
  class Time (line 1911) | class Time extends Axis<Date> {
  class Numeric (line 1993) | class Numeric extends Axis<number> {
  class Category (line 2068) | class Category extends Axis<string> {
  class Label (line 2117) | class Label extends Component {
  class TitleLabel (line 2172) | class TitleLabel extends Label {
  class AxisLabel (line 2181) | class AxisLabel extends Label {
  class Legend (line 2192) | class Legend extends Component {
  class InterpolatedColorLegend (line 2319) | class InterpolatedColorLegend extends Component {
  class Gridlines (line 2394) | class Gridlines extends Component {
  class Table (line 2415) | class Table extends ComponentContainer {
  type PropertyMode (line 2551) | enum PropertyMode {
  class SelectionBoxLayer (line 2555) | class SelectionBoxLayer extends Component {
  class GuideLineLayer (line 2668) | class GuideLineLayer<D> extends Component {
  type PlotEntity (line 2738) | interface PlotEntity extends Entity<Plot> {
  type AccessorScaleBinding (line 2743) | interface AccessorScaleBinding<D, R> {
  class Plot (line 2753) | class Plot extends Component {
  class Pie (line 2908) | class Pie extends Plot {
  class XYPlot (line 3032) | class XYPlot<X, Y> extends Plot {
  class Rectangle (line 3143) | class Rectangle<X, Y> extends XYPlot<X, Y> {
  class Scatter (line 3296) | class Scatter<X, Y> extends XYPlot<X, Y> {
  class Bar (line 3367) | class Bar<X, Y> extends XYPlot<X, Y> {
  class Line (line 3518) | class Line<X> extends XYPlot<X, number> {
  class Area (line 3622) | class Area<X> extends Line<X> {
  class ClusteredBar (line 3665) | class ClusteredBar<X, Y> extends Bar<X, Y> {
  class StackedArea (line 3685) | class StackedArea<X> extends Area<X> {
  class StackedBar (line 3740) | class StackedBar<X, Y> extends Bar<X, Y> {
  class Segment (line 3770) | class Segment<X, Y> extends XYPlot<X, Y> {
  class Waterfall (line 3869) | class Waterfall<X, Y> extends Bar<X, number> {
  type Animator (line 3918) | interface Animator {
  class Null (line 3944) | class Null implements Animator {
  class Easing (line 3953) | class Easing implements Animator {
  class Dispatcher (line 4067) | class Dispatcher {
  type MouseCallback (line 4082) | type MouseCallback = (p: Point, event: MouseEvent) => void;
  class Mouse (line 4083) | class Mouse extends Dispatcher {
  type TouchCallback (line 4194) | type TouchCallback = (ids: number[], idToPoint: {
  class Touch (line 4197) | class Touch extends Dispatcher {
  type KeyCallback (line 4284) | type KeyCallback = (keyCode: number, event: KeyboardEvent) => void;
  class Key (line 4285) | class Key extends Dispatcher {
  class Interaction (line 4334) | class Interaction {
  type ClickCallback (line 4387) | type ClickCallback = (point: Point) => void;
  class Click (line 4390) | class Click extends Interaction {
  class DoubleClick (line 4421) | class DoubleClick extends Interaction {
  type KeyCallback (line 4458) | type KeyCallback = (keyCode: number) => void;
  class Key (line 4460) | class Key extends Interaction {
  type PointerCallback (line 4517) | type PointerCallback = (point: Point) => void;
  class Pointer (line 4520) | class Pointer extends Interaction {
  class PanZoom (line 4579) | class PanZoom extends Interaction {
  type DragCallback (line 4712) | type DragCallback = (start: Point, end: Point) => void;
  class Drag (line 4715) | class Drag extends Interaction {
  type DragBoxCallback (line 4804) | type DragBoxCallback = (bounds: Bounds) => void;
  class DragBoxLayer (line 4807) | class DragBoxLayer extends Components.SelectionBoxLayer {
  class XDragBoxLayer (line 4935) | class XDragBoxLayer extends DragBoxLayer {
  class YDragBoxLayer (line 4961) | class YDragBoxLayer extends DragBoxLayer {
  type DragLineCallback (line 4987) | interface DragLineCallback<D> {
  class DragLineLayer (line 4992) | class DragLineLayer<D> extends GuideLineLayer<D> {

FILE: cluster/benchmarks/bower_components/plottable/plottable.js
  function __ (line 25) | function __() { this.constructor = d; }
  function inRange (line 43) | function inRange(x, a, b) {
  function clamp (line 55) | function clamp(x, min, max) {
  function max (line 59) | function max(array, firstArg, secondArg) {
  function min (line 68) | function min(array, firstArg, secondArg) {
  function isNaN (line 80) | function isNaN(n) {
  function isValidNumber (line 88) | function isValidNumber(n) {
  function range (line 96) | function range(start, stop, step) {
  function distanceSquared (line 116) | function distanceSquared(p1, p2) {
  function degreesToRadians (line 120) | function degreesToRadians(degree) {
  function Map (line 136) | function Map() {
  function Set (line 220) | function Set() {
  function elementBBox (line 289) | function elementBBox(element) {
  function requestAnimationFramePolyfill (line 312) | function requestAnimationFramePolyfill(callback) {
  function elementWidth (line 328) | function elementWidth(element) {
  function elementHeight (line 344) | function elementHeight(element) {
  function translate (line 353) | function translate(selection, x, y) {
  function clientRectsOverlap (line 372) | function clientRectsOverlap(clientRectA, clientRectB) {
  function clientRectInside (line 395) | function clientRectInside(innerClientRect, outerClientRect) {
  function boundingSVG (line 408) | function boundingSVG(element) {
  function generateUniqueClipPathId (line 423) | function generateUniqueClipPathId() {
  function intersectsBBox (line 439) | function intersectsBBox(xValOrRange, yValOrRange, bbox, tolerance) {
  function _parseRange (line 460) | function _parseRange(input) {
  function _parseStyleValue (line 471) | function _parseStyleValue(style, property) {
  function contrast (line 493) | function contrast(a, b) {
  function lightenColor (line 503) | function lightenColor(color, factor) {
  function colorTest (line 516) | function colorTest(colorTester, className) {
  function luminance (line 544) | function luminance(color) {
  function add (line 572) | function add(aList, bList) {
  function uniq (line 586) | function uniq(arr) {
  function flatten (line 602) | function flatten(a) {
  function createFilledArray (line 613) | function createFilledArray(value, count) {
  function CallbackSet (line 635) | function CallbackSet() {
  function stack (line 669) | function stack(datasets, keyAccessor, valueAccessor) {
  function stackedExtent (line 706) | function stackedExtent(stackingResult, keyAccessor, filter) {
  function normalizeKey (line 728) | function normalizeKey(key) {
  function warn (line 746) | function warn(warning) {
  function setTimeout (line 770) | function setTimeout(f, time) {
  function deprecated (line 794) | function deprecated(callingMethod, version, message) {
  function ClientToSVGTranslator (line 808) | function ClientToSVGTranslator(svg) {
  function Dataset (line 903) | function Dataset(data, metadata) {
  function Immediate (line 963) | function Immediate() {
  function AnimationFrame (line 976) | function AnimationFrame() {
  function Timeout (line 990) | function Timeout() {
  function renderPolicy (line 1032) | function renderPolicy(renderPolicy) {
  function registerToRender (line 1056) | function registerToRender(component) {
  function registerToComputeLayout (line 1069) | function registerToComputeLayout(component) {
  function requestRender (line 1075) | function requestRender() {
  function flush (line 1088) | function flush() {
  function currency (line 1128) | function currency(precision, symbol, prefix) {
  function fixed (line 1157) | function fixed(precision) {
  function general (line 1171) | function general(maxNumberOfDecimalPlaces) {
  function identity (line 1190) | function identity() {
  function percentage (line 1202) | function percentage(precision) {
  function siSuffix (line 1223) | function siSuffix(numberOfSignificantFigures) {
  function shortScale (line 1244) | function shortScale(precision) {
  function multiTime (line 1287) | function multiTime() {
  function time (line 1342) | function time(specifier) {
  function verifyPrecision (line 1346) | function verifyPrecision(precision) {
  function circle (line 1360) | function circle() {
  function square (line 1364) | function square() {
  function cross (line 1368) | function cross() {
  function diamond (line 1372) | function diamond() {
  function triangleUp (line 1376) | function triangleUp() {
  function triangleDown (line 1380) | function triangleDown() {
  function Scale (line 1394) | function Scale() {
  function QuantitativeScale (line 1543) | function QuantitativeScale() {
  function Linear (line 1775) | function Linear() {
  function ModifiedLog (line 1857) | function ModifiedLog(base) {
  function Category (line 2034) | function Category() {
  function Color (line 2144) | function Color(scaleType) {
  function Time (line 2258) | function Time() {
  function InterpolatedColor (line 2369) | function InterpolatedColor(scaleType) {
  function intervalTickGenerator (line 2524) | function intervalTickGenerator(interval) {
  function integerTickGenerator (line 2546) | function integerTickGenerator() {
  function Drawer (line 2565) | function Drawer(dataset) {
  function Line (line 2695) | function Line(dataset) {
  function Area (line 2718) | function Area(dataset) {
  function Rectangle (line 2741) | function Rectangle(dataset) {
  function Arc (line 2756) | function Arc(dataset) {
  function ArcOutline (line 2776) | function ArcOutline(dataset) {
  function Symbol (line 2796) | function Symbol(dataset) {
  function Segment (line 2812) | function Segment(dataset) {
  function Alignment (line 2826) | function Alignment() {
  function Component (line 2838) | function Component() {
  function ComponentContainer (line 3359) | function ComponentContainer() {
  function Group (line 3440) | function Group(components) {
  function PlotGroup (line 3522) | function PlotGroup() {
  function Axis (line 3569) | function Axis(scale, orientation) {
  function Time (line 4132) | function Time(scale, orientation) {
  function Numeric (line 4593) | function Numeric(scale, orientation) {
  function Category (line 4921) | function Category(scale, orientation) {
  function Label (line 5127) | function Label(displayText, angle) {
  function TitleLabel (line 5238) | function TitleLabel(text, angle) {
  function AxisLabel (line 5253) | function AxisLabel(text, angle) {
  function Legend (line 5275) | function Legend(colorScale) {
  function InterpolatedColorLegend (line 5555) | function InterpolatedColorLegend(interpolatedColorScale) {
  function Gridlines (line 5793) | function Gridlines(xScale, yScale) {
  function Table (line 5897) | function Table(rows) {
  function SelectionBoxLayer (line 6276) | function SelectionBoxLayer() {
  function GuideLineLayer (line 6493) | function GuideLineLayer(orientation) {
  function Plot (line 6645) | function Plot() {
  function Pie (line 7090) | function Pie() {
  function XYPlot (line 7414) | function XYPlot() {
  function Rectangle (line 7718) | function Rectangle() {
  function Scatter (line 8059) | function Scatter() {
  function Bar (line 8191) | function Bar(orientation) {
  function Line (line 8792) | function Line() {
  function Area (line 9189) | function Area() {
  function ClusteredBar (line 9360) | function ClusteredBar(orientation) {
  function StackedArea (line 9413) | function StackedArea() {
  function StackedBar (line 9598) | function StackedBar(orientation) {
  function Segment (line 9708) | function Segment() {
  function Waterfall (line 9875) | function Waterfall() {
  function Null (line 10075) | function Null() {
  function Easing (line 10101) | function Easing() {
  function Dispatcher (line 10204) | function Dispatcher() {
  function Mouse (line 10278) | function Mouse(svg) {
  function Touch (line 10465) | function Touch(svg) {
  function Key (line 10627) | function Key() {
  function Interaction (line 10703) | function Interaction() {
  function Click (line 10799) | function Click() {
  function DoubleClick (line 10881) | function DoubleClick() {
  function Key (line 10980) | function Key() {
  function Pointer (line 11092) | function Pointer() {
  function PanZoom (line 11217) | function PanZoom(xScale, yScale) {
  function Drag (line 11526) | function Drag() {
  function DragBoxLayer (line 11686) | function DragBoxLayer() {
  function XDragBoxLayer (line 12051) | function XDragBoxLayer() {
  function YDragBoxLayer (line 12105) | function YDragBoxLayer() {
  function DragLineLayer (line 12157) | function DragLineLayer(orientation) {
  function arrayEq (line 12343) | function arrayEq(a, b) {
  function objEq (line 12367) | function objEq(a, b) {
  function transform (line 12388) | function transform(s, x, y) {
  function getBBox (line 12402) | function getBBox(element) {
  function Cache (line 12436) | function Cache(compute, valueEq) {
  function Tokenizer (line 12476) | function Tokenizer() {
  function combineWhitespace (line 12521) | function combineWhitespace(str) {
  function isNotEmptyString (line 12525) | function isNotEmptyString(str) {
  function trimStart (line 12529) | function trimStart(str, c) {
  function trimEnd (line 12538) | function trimEnd(str, c) {
  function BaseAnimator (line 12559) | function BaseAnimator() {
  function __ (line 12638) | function __() { this.constructor = d; }
  function UnveilAnimator (line 12648) | function UnveilAnimator() {
  function __ (line 12704) | function __() { this.constructor = d; }
  function OpacityAnimator (line 12714) | function OpacityAnimator() {
  function Wrapper (line 12738) | function Wrapper() {
  function __ (line 12947) | function __() { this.constructor = d; }
  function SingleLineWrapper (line 12957) | function SingleLineWrapper() {
  function Writer (line 13003) | function Writer(measurer, wrapper) {
  function AbstractMeasurer (line 13128) | function AbstractMeasurer(area, className) {
  function __ (line 13186) | function __() { this.constructor = d; }
  function Measurer (line 13196) | function Measurer(area, className, useGuards) {
  function __ (line 13239) | function __() { this.constructor = d; }
  function CharacterMeasurer (line 13249) | function CharacterMeasurer() {
  function __ (line 13272) | function __() { this.constructor = d; }
  function CacheCharacterMeasurer (line 13282) | function CacheCharacterMeasurer(area, className) {

FILE: cluster/benchmarks/dashboard_app/main.py
  function argument_name (line 41) | def argument_name(argument):
  function index (line 59) | def index(pattern=None):
  function test (line 86) | def test(test_id):
  function benchmark_data (line 133) | def benchmark_data():
  function server_error (line 153) | def server_error(e):

FILE: cluster/benchmarks/dashboard_app/main_test.py
  class TestMain (line 21) | class TestMain(unittest.TestCase):
    method testArgumentInvalidFormat (line 23) | def testArgumentInvalidFormat(self):
    method testArgumentValidFormat (line 31) | def testArgumentValidFormat(self):
    method testIndexPage (line 35) | def testIndexPage(self):
    method testTestPage_InvalidTest (line 43) | def testTestPage_InvalidTest(self):
    method testTestPage_SampleTest (line 51) | def testTestPage_SampleTest(self):
    method testFetchBenchmarkData_InvalidTest (line 62) | def testFetchBenchmarkData_InvalidTest(self):
    method testFetchBenchmarkData_SampleTest (line 70) | def testFetchBenchmarkData_SampleTest(self):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/benchmark_cnn.py
  function define_flags (line 375) | def define_flags():
  class GlobalStepWatcher (line 394) | class GlobalStepWatcher(threading.Thread):
    method __init__ (line 401) | def __init__(self, sess, global_step_op,
    method run (line 414) | def run(self):
    method done (line 432) | def done(self):
    method num_steps (line 435) | def num_steps(self):
    method elapsed_time (line 438) | def elapsed_time(self):
  class CheckpointNotFoundException (line 442) | class CheckpointNotFoundException(Exception):
  function get_data_type (line 446) | def get_data_type(params):
  function loss_function (line 456) | def loss_function(logits, labels, aux_logits):
  function create_config_proto (line 471) | def create_config_proto(params):
  function get_mode_from_params (line 492) | def get_mode_from_params(params):
  function benchmark_one_step (line 511) | def benchmark_one_step(sess,
  function get_perf_timing_str (line 557) | def get_perf_timing_str(batch_size, step_train_times, scale=1):
  function load_checkpoint (line 571) | def load_checkpoint(saver, sess, ckpt_dir):
  function make_params (line 604) | def make_params(**kwargs):
  function make_params_from_flags (line 622) | def make_params_from_flags():
  class BenchmarkCNN (line 634) | class BenchmarkCNN(object):
    method __init__ (line 637) | def __init__(self, params):
    method reset_devices_for_task (line 838) | def reset_devices_for_task(self, task_num, is_local=False):
    method raw_devices_across_tasks (line 847) | def raw_devices_across_tasks(self, is_local=False):
    method print_info (line 858) | def print_info(self):
    method run (line 889) | def run(self):
    method _eval_cnn (line 918) | def _eval_cnn(self):
    method _eval_once (line 945) | def _eval_once(self, saver, summary_writer, target,
    method _benchmark_cnn (line 997) | def _benchmark_cnn(self):
    method _build_image_processing (line 1202) | def _build_image_processing(self, shift_ratio=0):
    method _build_model (line 1228) | def _build_model(self):
    method _build_fetches (line 1299) | def _build_fetches(self, global_step, all_logits, losses, device_grads,
    method _build_model_single_session (line 1407) | def _build_model_single_session(self):
    method add_forward_pass_and_gradients (line 1506) | def add_forward_pass_and_gradients(
    method get_image_preprocessor (line 1638) | def get_image_preprocessor(self):
    method add_sync_queues_and_barrier (line 1670) | def add_sync_queues_and_barrier(self, name_prefix,
  function store_benchmarks (line 1707) | def store_benchmarks(names_to_values, params):
  function setup (line 1712) | def setup(params):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/benchmark_storage.py
  function store_benchmark (line 18) | def store_benchmark(data, storage_type=None):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/cbuild_benchmark_storage.py
  function upload_to_benchmark_datastore (line 32) | def upload_to_benchmark_datastore(data, test_name=None, start_time=None):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/cnn_util.py
  function tensorflow_version_tuple (line 30) | def tensorflow_version_tuple():
  function tensorflow_version (line 36) | def tensorflow_version():
  function log_fn (line 41) | def log_fn(log):
  class Barrier (line 48) | class Barrier(object):
    method __init__ (line 58) | def __init__(self, parties):
    method wait (line 69) | def wait(self):
    method abort (line 87) | def abort(self):
  class ImageProducer (line 96) | class ImageProducer(object):
    method __init__ (line 120) | def __init__(self, sess, put_ops, batch_group_size):
    method _should_put (line 132) | def _should_put(self):
    method done (line 135) | def done(self):
    method start (line 141) | def start(self):
    method notify_image_consumption (line 148) | def notify_image_consumption(self):
    method _loop_producer (line 158) | def _loop_producer(self):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/convnet_builder.py
  class ConvNetBuilder (line 32) | class ConvNetBuilder(object):
    method __init__ (line 35) | def __init__(self,
    method get_custom_getter (line 58) | def get_custom_getter(self):
    method switch_to_aux_top_layer (line 98) | def switch_to_aux_top_layer(self):
    method get_variable (line 112) | def get_variable(self, name, shape, dtype, cast_dtype, *args, **kwargs):
    method _conv2d_impl (line 120) | def _conv2d_impl(self, input_layer, num_channels_in, filters, kernel_s...
    method conv (line 143) | def conv(self,
    method _pool (line 228) | def _pool(self,
    method mpool (line 263) | def mpool(self,
    method apool (line 275) | def apool(self,
    method reshape (line 288) | def reshape(self, shape, input_layer=None):
    method affine (line 295) | def affine(self,
    method inception_module (line 329) | def inception_module(self, name, cols, input_layer=None, in_size=None):
    method spatial_mean (line 367) | def spatial_mean(self, keep_dims=False):
    method dropout (line 375) | def dropout(self, keep_prob=0.5, input_layer=None):
    method _batch_norm_without_layers (line 391) | def _batch_norm_without_layers(self, input_layer, decay, use_scale, ep...
    method batch_norm (line 433) | def batch_norm(self, input_layer=None, decay=0.999, scale=False,
    method lrn (line 461) | def lrn(self, depth_radius, bias, alpha, beta):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/datasets.py
  function create_dataset (line 35) | def create_dataset(data_dir, data_name):
  class Dataset (line 62) | class Dataset(object):
    method __init__ (line 65) | def __init__(self, name, height=None, width=None, depth=None, data_dir...
    method tf_record_pattern (line 76) | def tf_record_pattern(self, subset):
    method reader (line 79) | def reader(self):
    method num_classes (line 83) | def num_classes(self):
    method num_classes (line 87) | def num_classes(self, val):
    method num_examples_per_epoch (line 91) | def num_examples_per_epoch(self, subset):
    method __str__ (line 94) | def __str__(self):
    method get_image_preprocessor (line 97) | def get_image_preprocessor(self):
    method queue_runner_required (line 100) | def queue_runner_required(self):
    method use_synthetic_gpu_images (line 103) | def use_synthetic_gpu_images(self):
  class ImagenetData (line 107) | class ImagenetData(Dataset):
    method __init__ (line 110) | def __init__(self, data_dir=None):
    method num_examples_per_epoch (line 115) | def num_examples_per_epoch(self, subset='train'):
    method get_image_preprocessor (line 123) | def get_image_preprocessor(self):
  class SyntheticData (line 127) | class SyntheticData(Dataset):
    method __init__ (line 130) | def __init__(self, unused_data_dir):
    method get_image_preprocessor (line 133) | def get_image_preprocessor(self):
    method use_synthetic_gpu_images (line 136) | def use_synthetic_gpu_images(self):
  class Cifar10Data (line 140) | class Cifar10Data(Dataset):
    method __init__ (line 146) | def __init__(self, data_dir=None):
    method read_data_files (line 153) | def read_data_files(self, subset='train'):
    method num_examples_per_epoch (line 175) | def num_examples_per_epoch(self, subset='train'):
    method get_image_preprocessor (line 183) | def get_image_preprocessor(self):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/models/alexnet_model.py
  class AlexnetModel (line 28) | class AlexnetModel(model.Model):
    method __init__ (line 31) | def __init__(self):
    method add_inference (line 34) | def add_inference(self, cnn):
  class AlexnetCifar10Model (line 51) | class AlexnetCifar10Model(model.Model):
    method __init__ (line 61) | def __init__(self):
    method add_inference (line 64) | def add_inference(self, cnn):
    method get_learning_rate (line 77) | def get_learning_rate(self, global_step, batch_size):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/models/densenet_model.py
  class DensenetCifar10Model (line 27) | class DensenetCifar10Model(model_lib.Model):
    method __init__ (line 30) | def __init__(self, model, layer_counts, growth_rate):
    method dense_block (line 36) | def dense_block(self, cnn, growth_rate):
    method transition_layer (line 46) | def transition_layer(self, cnn):
    method add_inference (line 53) | def add_inference(self, cnn):
    method get_learning_rate (line 77) | def get_learning_rate(self, global_step, batch_size):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/models/googlenet_model.py
  class GooglenetModel (line 28) | class GooglenetModel(model.Model):
    method __init__ (line 30) | def __init__(self):
    method add_inference (line 33) | def add_inference(self, cnn):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/models/inception_model.py
  class Inceptionv3Model (line 44) | class Inceptionv3Model(model.Model):
    method __init__ (line 46) | def __init__(self, auxiliary=False):
    method add_inference (line 50) | def add_inference(self, cnn):
  function inception_v4_sa (line 125) | def inception_v4_sa(cnn):
  function inception_v4_sb (line 130) | def inception_v4_sb(cnn):
  function inception_v4_sc (line 137) | def inception_v4_sc(cnn):
  function inception_v4_ra (line 144) | def inception_v4_ra(cnn, k, l, m, n):
  function inception_v4_rb (line 152) | def inception_v4_rb(cnn):
  class Inceptionv4Model (line 160) | class Inceptionv4Model(model.Model):
    method __init__ (line 162) | def __init__(self):
    method add_inference (line 165) | def add_inference(self, cnn):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/models/lenet_model.py
  class Lenet5Model (line 27) | class Lenet5Model(model.Model):
    method __init__ (line 29) | def __init__(self):
    method add_inference (line 32) | def add_inference(self, cnn):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/models/model.py
  class Model (line 18) | class Model(object):
    method __init__ (line 21) | def __init__(self,
    method get_model (line 38) | def get_model(self):
    method get_image_size (line 41) | def get_image_size(self):
    method get_batch_size (line 44) | def get_batch_size(self):
    method set_batch_size (line 47) | def set_batch_size(self, batch_size):
    method get_default_batch_size (line 50) | def get_default_batch_size(self):
    method get_layer_counts (line 53) | def get_layer_counts(self):
    method get_fp16_loss_scale (line 56) | def get_fp16_loss_scale(self):
    method get_learning_rate (line 59) | def get_learning_rate(self, global_step, batch_size):
    method add_inference (line 64) | def add_inference(self, unused_cnn):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/models/model_config.py
  function get_model_config (line 30) | def get_model_config(model, dataset):
  function get_cifar10_model_config (line 66) | def get_cifar10_model_config(model):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/models/overfeat_model.py
  class OverfeatModel (line 29) | class OverfeatModel(model.Model):
    method __init__ (line 31) | def __init__(self):
    method add_inference (line 34) | def add_inference(self, cnn):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/models/resnet_model.py
  function bottleneck_block_v1 (line 41) | def bottleneck_block_v1(cnn, depth, depth_bottleneck, stride):
  function bottleneck_block_v2 (line 81) | def bottleneck_block_v2(cnn, depth, depth_bottleneck, stride):
  function bottleneck_block (line 126) | def bottleneck_block(cnn, depth, depth_bottleneck, stride, pre_activation):
  function residual_block (line 142) | def residual_block(cnn, depth, stride, pre_activation):
  class ResnetModel (line 187) | class ResnetModel(model_lib.Model):
    method __init__ (line 190) | def __init__(self, model, layer_counts):
    method add_inference (line 204) | def add_inference(self, cnn):
    method get_learning_rate (line 227) | def get_learning_rate(self, global_step, batch_size):
  class ResnetCifar10Model (line 235) | class ResnetCifar10Model(model_lib.Model):
    method __init__ (line 245) | def __init__(self, model, layer_counts):
    method add_inference (line 250) | def add_inference(self, cnn):
    method get_learning_rate (line 277) | def get_learning_rate(self, global_step, batch_size):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/models/trivial_model.py
  class TrivialModel (line 20) | class TrivialModel(model.Model):
    method __init__ (line 23) | def __init__(self):
    method add_inference (line 26) | def add_inference(self, cnn):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/models/vgg_model.py
  function _construct_vgg (line 31) | def _construct_vgg(cnn, num_conv_layers):
  class Vgg11Model (line 56) | class Vgg11Model(model.Model):
    method __init__ (line 58) | def __init__(self):
    method add_inference (line 61) | def add_inference(self, cnn):
  class Vgg16Model (line 65) | class Vgg16Model(model.Model):
    method __init__ (line 67) | def __init__(self):
    method add_inference (line 70) | def add_inference(self, cnn):
  class Vgg19Model (line 74) | class Vgg19Model(model.Model):
    method __init__ (line 76) | def __init__(self):
    method add_inference (line 79) | def add_inference(self, cnn):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/preprocessing.py
  function parse_example_proto (line 31) | def parse_example_proto(example_serialized):
  function get_image_resize_method (line 102) | def get_image_resize_method(resize_method, batch_position=0):
  function decode_jpeg (line 149) | def decode_jpeg(image_buffer, scope=None):  # , dtype=tf.float32):
  function eval_image (line 174) | def eval_image(image,
  function train_image (line 257) | def train_image(image_buffer,
  function distort_color (line 381) | def distort_color(image, batch_position=0, distort_color_in_yiq=False,
  class RecordInputImagePreprocessor (line 435) | class RecordInputImagePreprocessor(object):
    method __init__ (line 438) | def __init__(self,
    method preprocess (line 470) | def preprocess(self, image_buffer, bbox, batch_position):
    method parse_and_preprocess (line 490) | def parse_and_preprocess(self, value, batch_position):
    method minibatch (line 495) | def minibatch(self, dataset, subset, use_datasets, cache_data,
  class Cifar10ImagePreprocessor (line 564) | class Cifar10ImagePreprocessor(object):
    method __init__ (line 567) | def __init__(self,
    method _distort_image (line 603) | def _distort_image(self, image):
    method _eval_image (line 626) | def _eval_image(self, image):
    method preprocess (line 634) | def preprocess(self, raw_image):
    method minibatch (line 644) | def minibatch(self, dataset, subset, use_datasets, cache_data,
  class SyntheticImagePreprocessor (line 691) | class SyntheticImagePreprocessor(object):
    method __init__ (line 694) | def __init__(self, height, width, batch_size, num_splits,
    method minibatch (line 709) | def minibatch(self, dataset, subset, use_datasets, cache_data,
  class TestImagePreprocessor (line 739) | class TestImagePreprocessor(object):
    method __init__ (line 749) | def __init__(self,
    method set_fake_data (line 770) | def set_fake_data(self, fake_images, fake_labels):
    method minibatch (line 778) | def minibatch(self, dataset, subset, use_datasets, cache_data,

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/tf_cnn_benchmarks.py
  function main (line 33) | def main(extra_flags):

FILE: cluster/benchmarks/scripts/tf_cnn_benchmarks/variable_mgr.py
  class OverrideCachingDevice (line 37) | class OverrideCachingDevice(object):
    method __init__ (line 45) | def __init__(self, devices, device_for_small_variables,
    method __call__ (line 52) | def __call__(self, getter, *args, **kwargs):
  class OverrideToLocalVariableIfNotPsVar (line 69) | class OverrideToLocalVariableIfNotPsVar(object):
    method __call__ (line 74) | def __call__(self, getter, name, *args, **kwargs):
  class ParamServerDeviceSetter (line 90) | class ParamServerDeviceSetter(object):
    method __init__ (line 93) | def __init__(self, worker_device, ps_devices):
    method __call__ (line 105) | def __call__(self, op):
  class VariableMgr (line 120) | class VariableMgr(object):
    method __init__ (line 127) | def __init__(self, benchmark_cnn):
    method each_tower_has_variables (line 131) | def each_tower_has_variables(self):
    method supports_staged_vars (line 135) | def supports_staged_vars(self):
    method create_outer_variable_scope (line 139) | def create_outer_variable_scope(self, device_num):
    method preprocess_device_grads (line 144) | def preprocess_device_grads(self, device_grads):
    method get_gradients_to_apply (line 161) | def get_gradients_to_apply(self, device_num, gradient_state):
    method append_apply_gradients_ops (line 172) | def append_apply_gradients_ops(
    method get_post_init_ops (line 186) | def get_post_init_ops(self):
    method get_devices (line 190) | def get_devices(self):
    method savable_variables (line 194) | def savable_variables(self):
    method trainable_variables_on_device (line 198) | def trainable_variables_on_device(self, rel_device_num, abs_device_num,
  class VariableMgrIndependent (line 221) | class VariableMgrIndependent(VariableMgr):
    method each_tower_has_variables (line 229) | def each_tower_has_variables(self):
    method create_outer_variable_scope (line 232) | def create_outer_variable_scope(self, device_num):
    method preprocess_device_grads (line 235) | def preprocess_device_grads(self, device_grads):
    method get_gradients_to_apply (line 238) | def get_gradients_to_apply(self, device_num, gradient_state):
    method get_devices (line 242) | def get_devices(self):
  class VariableMgrLocalFetchFromPS (line 246) | class VariableMgrLocalFetchFromPS(VariableMgr):
    method each_tower_has_variables (line 254) | def each_tower_has_variables(self):
    method create_outer_variable_scope (line 257) | def create_outer_variable_scope(self, device_num):
    method preprocess_device_grads (line 260) | def preprocess_device_grads(self, device_grads):
    method get_gradients_to_apply (line 263) | def get_gradients_to_apply(self, device_num, gradient_state):
    method get_devices (line 269) | def get_devices(self):
  class StagedModelVariable (line 279) | class StagedModelVariable(object):
    method __init__ (line 287) | def __init__(self, real_var, var_stage_get, variable_mgr):
    method _value (line 299) | def _value(self):
    method _ref (line 303) | def _ref(self):
    method read_value (line 307) | def read_value(self):
    method dtype (line 312) | def dtype(self):
    method assign_sub (line 316) | def assign_sub(self, delta, name=None):
    method _TensorConversionFunction (line 343) | def _TensorConversionFunction(self, dtype=None, name=None, as_ref=False):
  class StagedVariableGetter (line 356) | class StagedVariableGetter(object):
    method __init__ (line 363) | def __init__(self, device_num, devices, cpu_device, variable_mgr):
    method __call__ (line 378) | def __call__(self, getter, name, *args, **kwargs):
    method trainable_variables_on_device (line 414) | def trainable_variables_on_device(self, rel_device_num, abs_device_num,
  class VariableMgrLocalFetchFromStagedPS (line 439) | class VariableMgrLocalFetchFromStagedPS(VariableMgrLocalFetchFromPS):
    method __init__ (line 443) | def __init__(self, benchmark_cnn):
    method supports_staged_vars (line 452) | def supports_staged_vars(self):
    method create_outer_variable_scope (line 455) | def create_outer_variable_scope(self, device_num):
    method trainable_variables_on_device (line 461) | def trainable_variables_on_device(self, rel_device_num, abs_device_num,
  function parse_general_int (line 470) | def parse_general_int(s):
  function parse_all_reduce_spec (line 493) | def parse_all_reduce_spec(all_reduce_spec):
  function build_all_reduce_device_prefixes (line 577) | def build_all_reduce_device_prefixes(job_name, num_tasks):
  function group_device_names (line 596) | def group_device_names(devices, group_size):
  class VariableMgrLocalReplicated (line 624) | class VariableMgrLocalReplicated(VariableMgr):
    method __init__ (line 633) | def __init__(self, benchmark_cnn, all_reduce_spec):
    method each_tower_has_variables (line 644) | def each_tower_has_variables(self):
    method create_outer_variable_scope (line 647) | def create_outer_variable_scope(self, device_num):
    method preprocess_device_grads (line 650) | def preprocess_device_grads(self, device_grads):
    method get_gradients_to_apply (line 665) | def get_gradients_to_apply(self, device_num, gradient_state):
    method get_post_init_ops (line 669) | def get_post_init_ops(self):
    method savable_variables (line 684) | def savable_variables(self):
    method get_devices (line 693) | def get_devices(self):
  class VariableMgrDistributedAllReduce (line 697) | class VariableMgrDistributedAllReduce(VariableMgr):
    method __init__ (line 705) | def __init__(self, benchmark_cnn, all_reduce_spec, job_name,
    method each_tower_has_variables (line 718) | def each_tower_has_variables(self):
    method create_outer_variable_scope (line 721) | def create_outer_variable_scope(self, device_num):
    method preprocess_device_grads (line 734) | def preprocess_device_grads(self, device_grads):
    method get_gradients_to_apply (line 762) | def get_gradients_to_apply(self, device_num, gradient_state):
    method get_post_init_ops (line 769) | def get_post_init_ops(self):
    method savable_variables (line 784) | def savable_variables(self):
    method get_devices (line 793) | def get_devices(self):
  class VariableMgrDistributedFetchFromPS (line 797) | class VariableMgrDistributedFetchFromPS(VariableMgr):
    method each_tower_has_variables (line 805) | def each_tower_has_variables(self):
    method create_outer_variable_scope (line 808) | def create_outer_variable_scope(self, device_num):
    method preprocess_device_grads (line 818) | def preprocess_device_grads(self, device_grads):
    method get_gradients_to_apply (line 822) | def get_gradients_to_apply(self, device_num, gradient_state):
    method get_devices (line 826) | def get_devices(self):
  class VariableMgrDistributedFetchFromStagedPS (line 835) | class VariableMgrDistributedFetchFromStagedPS(
    method __init__ (line 839) | def __init__(self, benchmark_cnn):
    method create_outer_variable_scope (line 845) | def create_outer_variable_scope(self, device_num):
    method supports_staged_vars (line 852) | def supports_staged_vars(self):
    method trainable_variables_on_device (line 855) | def trainable_variables_on_device(self, rel_device_num, abs_device_num,
  class VariableMgrDistributedReplicated (line 861) | class VariableMgrDistributedReplicated(VariableMgr):
    method each_tower_has_variables (line 870) | def each_tower_has_variables(self):
    method create_outer_variable_scope (line 873) | def create_outer_variable_scope(self, device_num):
    method preprocess_device_grads (line 878) | def preprocess_device_grads(self, device_grads):
    method get_gradients_to_apply (line 881) | def get_gradients_to_apply(self, device_num, gradient_state):
    method append_apply_gradients_ops (line 898) | def append_apply_gradients_ops(self, gradient_state, opt,
    method _strip_port (line 916) | def _strip_port(self, s):
    method get_post_init_ops (line 921) | def get_post_init_ops(self):
    method _remove_shadow_var_prefix_if_present (line 940) | def _remove_shadow_var_prefix_if_present(self, var_name):
    method var_dict_name (line 946) | def var_dict_name(self, v):
    method savable_variables (line 949) | def savable_variables(self):
    method get_devices (line 970) | def get_devices(self):
  function split_grads_by_size (line 974) | def split_grads_by_size(threshold_size, device_grads):
  function sum_grad_and_var_all_reduce (line 1006) | def sum_grad_and_var_all_reduce(grad_and_vars, num_workers, alg, gpu_ind...
  function contains_any (line 1044) | def contains_any(haystack, needles):
  function sum_gradients_all_reduce (line 1061) | def sum_gradients_all_reduce(dev_prefixes, tower_grads, num_workers,
  function aggregate_gradients_using_copy_with_device_selection (line 1098) | def aggregate_gradients_using_copy_with_device_selection(
  function aggregate_gradients_using_copy_with_variable_colocation (line 1125) | def aggregate_gradients_using_copy_with_variable_colocation(
  function aggregate_gradients_using_copy (line 1154) | def aggregate_gradients_using_copy(tower_grads, use_mean):
  function aggregate_single_gradient_using_copy (line 1172) | def aggregate_single_gradient_using_copy(grad_and_vars, use_mean):

FILE: cluster/benchmarks/scripts/util/benchmark_util.py
  function store_data_in_json (line 44) | def store_data_in_json(

FILE: cluster/benchmarks/scripts/util/benchmark_util_test.py
  class BenchmarkUtilTest (line 30) | class BenchmarkUtilTest(unittest.TestCase):
    method testStoreDataWithNoEntries (line 32) | def testStoreDataWithNoEntries(self):
    method testStoreDataWithEntries (line 42) | def testStoreDataWithEntries(self):

FILE: cluster/benchmarks/scripts/util/convert_csv_to_json.py
  function get_data_from_csv (line 31) | def get_data_from_csv(csv_reader):
  function main (line 65) | def main():

FILE: cluster/benchmarks/scripts/util/convert_csv_to_json_test.py
  class ConvertCsvToJsonTest (line 23) | class ConvertCsvToJsonTest(unittest.TestCase):
    method testSingleEntryCSV (line 25) | def testSingleEntryCSV(self):
    method testTwoEntryCSV (line 37) | def testTwoEntryCSV(self):
    method testInvalidCSV_LessEntries (line 52) | def testInvalidCSV_LessEntries(self):
    method testInvalidCSV_MoreEntries (line 59) | def testInvalidCSV_MoreEntries(self):
    method testInvalidCSV_EmptyEntry (line 66) | def testInvalidCSV_EmptyEntry(self):
    method testInvalidCSV_InvalidDate (line 73) | def testInvalidCSV_InvalidDate(self):
    method testInvalidCSV_InvalidValue (line 79) | def testInvalidCSV_InvalidValue(self):

FILE: cluster/benchmarks/tools/k8s_tensorflow_lib.py
  function GenerateConfig (line 134) | def GenerateConfig(num_workers,
  function WorkerClusterSpecString (line 251) | def WorkerClusterSpecString(num_workers,
  function ParamServerClusterSpecString (line 259) | def ParamServerClusterSpecString(num_workers,
  function ClusterSpecString (line 268) | def ClusterSpecString(num_workers,
  function GetCommonArgs (line 288) | def GetCommonArgs(num_workers,
  function WorkerHosts (line 319) | def WorkerHosts(num_workers, port, name_prefix):
  function PsHosts (line 325) | def PsHosts(num_ps, port, name_prefix):

FILE: cluster/benchmarks/tools/k8s_tensorflow_test.py
  class K8sTensorflowTest (line 26) | class K8sTensorflowTest(unittest.TestCase):
    method testGenerateConfig_LoadBalancer (line 28) | def testGenerateConfig_LoadBalancer(self):
    method testGenerateConfig_SharedVolume (line 51) | def testGenerateConfig_SharedVolume(self):
    method testEnvVar (line 74) | def testEnvVar(self):
    method testClusterSpec (line 88) | def testClusterSpec(self):
    method testWorkerHosts (line 118) | def testWorkerHosts(self):
    method testPsHosts (line 126) | def testPsHosts(self):

FILE: cluster/benchmarks/tools/kubectl_util.py
  class TimeoutError (line 33) | class TimeoutError(Exception):
  function _WaitUntil (line 37) | def _WaitUntil(timeout, predicate, *args):
  function _GetPodNames (line 46) | def _GetPodNames(pod_name_prefix, job_name=None):
  function CreatePods (line 67) | def CreatePods(pod_name, yaml_file):
  function DeletePods (line 86) | def DeletePods(pod_name, yaml_file):
  function _GetJobSelector (line 107) | def _GetJobSelector(pod_name_prefix, job_name=None):
  function WaitForCompletion (line 114) | def WaitForCompletion(pod_name_prefix, job_name='worker', timeout=2*60*60):
  function _PrintLogs (line 173) | def _PrintLogs(pod_name_prefix, job_name):

FILE: cluster/benchmarks/tools/kubectl_util_test.py
  class KubectlUtilTest (line 31) | class KubectlUtilTest(unittest.TestCase):
    method testCreatePods (line 35) | def testCreatePods(self, mock_check_call, mock_check_output):
    method testDeletePods (line 46) | def testDeletePods(self, mock_check_call, mock_check_output):
    method testWaitForCompletion (line 56) | def testWaitForCompletion(self, mock_check_output):

FILE: cluster/benchmarks/tools/run_distributed_benchmarks.py
  function _ConvertToValidName (line 40) | def _ConvertToValidName(name):
  function _RunBenchmark (line 52) | def _RunBenchmark(name, yaml_file):
  function _BuildAndPushDockerImage (line 66) | def _BuildAndPushDockerImage(
  function _GetMostRecentDockerImageFromGcloud (line 102) | def _GetMostRecentDockerImageFromGcloud(docker_image):
  function get_gpu_volume_mounts (line 121) | def get_gpu_volume_mounts():
  class NoImageFoundError (line 142) | class NoImageFoundError(Exception):
  function main (line 146) | def main():

FILE: cluster/client_transfer_benchmark.py
  function clusterspec (line 79) | def clusterspec():
  function log (line 84) | def log(s):
  function session_config (line 88) | def session_config():
  function launch_distributed_service (line 97) | def launch_distributed_service():
  function run_benchmark (line 117) | def run_benchmark(master, direction=None):
  function create_done_queue (line 199) | def create_done_queue(i):

FILE: cluster/connect.py
  function toseconds (line 35) | def toseconds(dt):
  function main (line 42) | def main():

FILE: cluster/fill_efs.py
  function main (line 17) | def main():

FILE: cluster/imagenet64/aws.py
  class timeit (line 37) | class timeit:
    method __init__ (line 41) | def __init__(self, tag=""):
    method __enter__ (line 44) | def __enter__(self):
    method __exit__ (line 48) | def __exit__(self, *args):
  function _ExecuteCommandInThread (line 55) | def _ExecuteCommandInThread(ssh_client,
  function _StreamOutputToFile (line 85) | def _StreamOutputToFile(fd, file, line_extractor, cmd=None):
  function _ExecuteCommandAndStreamOutput (line 110) | def _ExecuteCommandAndStreamOutput(ssh_client,
  function lookup_aws_instances (line 149) | def lookup_aws_instances(name):
  function tf_job (line 174) | def tf_job(name, num_tasks, instance_type=None, placement_group=''):
  function terminate_job (line 223) | def terminate_job(name):
  function _ssh_to_host (line 238) | def _ssh_to_host(hostname,
  class Job (line 276) | class Job:
    method __init__ (line 277) | def __init__(self, name, instances):
    method wait_until_ready (line 284) | def wait_until_ready(self):
  function _encode_float (line 290) | def _encode_float(value):
  function _decode_float (line 294) | def _decode_float(b16):
  class Task (line 297) | class Task:
    method __init__ (line 298) | def __init__(self, instance, job, task_id):
    method wait_until_ready (line 309) | def wait_until_ready(self):
    method initialize (line 319) | def initialize(self):
    method run_sync (line 332) | def run_sync(self, cmd):
    method _setup_tasklogdir (line 342) | def _setup_tasklogdir(self):
    method run (line 346) | def run(self, cmd, mirror_output=False):
    method upload (line 373) | def upload(self, local_file, remote_file=None):
    method _upload_directory (line 384) | def _upload_directory(self, local_directory, remote_directory):
    method public_ip (line 388) | def public_ip(self):
    method port (line 393) | def port(self):
    method ip (line 397) | def ip(self):  # private ip

FILE: cluster/imagenet64/launch.py
  function ossystem (line 114) | def ossystem(cmd):
  class AWSInstance (line 119) | class AWSInstance(object):
    method __init__ (line 121) | def __init__(self, instance, ssh_key='', name='', username='ubuntu',
    method __del__ (line 135) | def __del__(self):
    method WaitUntilReady (line 138) | def WaitUntilReady(self):
    method CreateSshClient (line 156) | def CreateSshClient(self):
    method reuse_ssh_client (line 162) | def reuse_ssh_client(self):
    method CleanSshClient (line 168) | def CleanSshClient(self):
    method state (line 180) | def state(self):
    method SetNameTag (line 183) | def SetNameTag(self, name='tf'):
    method SetCustomTag (line 191) | def SetCustomTag(self, key, value):
    method Start (line 199) | def Start(self):
    method Stop (line 202) | def Stop(self):
    method StopAndWaitUntilStopped (line 206) | def StopAndWaitUntilStopped(self):
    method Terminate (line 210) | def Terminate(self):
    method TerminateAndWaitUntilTerminated (line 214) | def TerminateAndWaitUntilTerminated(self):
    method instance_id (line 219) | def instance_id(self):
    method ExecuteCommandAndWait (line 222) | def ExecuteCommandAndWait(self, cmd, print_error=False):
    method ExecuteCommandAndReturnStdout (line 226) | def ExecuteCommandAndReturnStdout(self, cmd):
    method ExecuteCommandAndStreamOutput (line 230) | def ExecuteCommandAndStreamOutput(self,
    method ExecuteCommandInThread (line 246) | def ExecuteCommandInThread(self,
    method RetrieveFile (line 261) | def RetrieveFile(self, remote_file, local_file):
    method UploadFile (line 266) | def UploadFile(self, local_file, remote_file):
  function CreateAwsInstances (line 271) | def CreateAwsInstances(num_instances=1,
  function setup_local_logdir (line 308) | def setup_local_logdir(run):
  function launch_job_aws (line 314) | def launch_job_aws(name, replicas):
  function tf_config_cmd (line 328) | def tf_config_cmd(full_cluster_spec, task_spec):
  function launch_aws (line 362) | def launch_aws():
  class Instance (line 404) | class Instance:
    method tf_env_setup (line 407) | def tf_env_setup(self, cluster_spec, task_spec):
  function launch_local (line 417) | def launch_local():
  function cnn_launcher (line 452) | def cnn_launcher():
  function main (line 541) | def main():

FILE: cluster/imagenet64/variable_mgr.py
  class OverrideCachingDevice (line 37) | class OverrideCachingDevice(object):
    method __init__ (line 45) | def __init__(self, devices, device_for_small_variables,
    method __call__ (line 52) | def __call__(self, getter, *args, **kwargs):
  class OverrideToLocalVariableIfNotPsVar (line 69) | class OverrideToLocalVariableIfNotPsVar(object):
    method __call__ (line 74) | def __call__(self, getter, name, *args, **kwargs):
  class ParamServerDeviceSetter (line 90) | class ParamServerDeviceSetter(object):
    method __init__ (line 93) | def __init__(self, worker_device, ps_devices):
    method __call__ (line 105) | def __call__(self, op):
  class VariableMgr (line 120) | class VariableMgr(object):
    method __init__ (line 127) | def __init__(self, benchmark_cnn):
    method each_tower_has_variables (line 131) | def each_tower_has_variables(self):
    method supports_staged_vars (line 135) | def supports_staged_vars(self):
    method create_outer_variable_scope (line 139) | def create_outer_variable_scope(self, device_num):
    method preprocess_device_grads (line 144) | def preprocess_device_grads(self, device_grads):
    method get_gradients_to_apply (line 161) | def get_gradients_to_apply(self, device_num, gradient_state):
    method append_apply_gradients_ops (line 172) | def append_apply_gradients_ops(
    method get_post_init_ops (line 186) | def get_post_init_ops(self):
    method get_devices (line 190) | def get_devices(self):
    method savable_variables (line 194) | def savable_variables(self):
    method trainable_variables_on_device (line 198) | def trainable_variables_on_device(self, rel_device_num, abs_device_num,
  class VariableMgrIndependent (line 221) | class VariableMgrIndependent(VariableMgr):
    method each_tower_has_variables (line 229) | def each_tower_has_variables(self):
    method create_outer_variable_scope (line 232) | def create_outer_variable_scope(self, device_num):
    method preprocess_device_grads (line 235) | def preprocess_device_grads(self, device_grads):
    method get_gradients_to_apply (line 238) | def get_gradients_to_apply(self, device_num, gradient_state):
    method get_devices (line 242) | def get_devices(self):
  class VariableMgrLocalFetchFromPS (line 246) | class VariableMgrLocalFetchFromPS(VariableMgr):
    method each_tower_has_variables (line 254) | def each_tower_has_variables(self):
    method create_outer_variable_scope (line 257) | def create_outer_variable_scope(self, device_num):
    method preprocess_device_grads (line 260) | def preprocess_device_grads(self, device_grads):
    method get_gradients_to_apply (line 263) | def get_gradients_to_apply(self, device_num, gradient_state):
    method get_devices (line 269) | def get_devices(self):
  class StagedModelVariable (line 279) | class StagedModelVariable(object):
    method __init__ (line 287) | def __init__(self, real_var, var_stage_get, variable_mgr):
    method _value (line 299) | def _value(self):
    method _ref (line 303) | def _ref(self):
    method read_value (line 307) | def read_value(self):
    method dtype (line 312) | def dtype(self):
    method assign_sub (line 316) | def assign_sub(self, delta, name=None):
    method _TensorConversionFunction (line 343) | def _TensorConversionFunction(self, dtype=None, name=None, as_ref=False):
  class StagedVariableGetter (line 356) | class StagedVariableGetter(object):
    method __init__ (line 363) | def __init__(self, device_num, devices, cpu_device, variable_mgr):
    method __call__ (line 378) | def __call__(self, getter, name, *args, **kwargs):
    method trainable_variables_on_device (line 414) | def trainable_variables_on_device(self, rel_device_num, abs_device_num,
  class VariableMgrLocalFetchFromStagedPS (line 439) | class VariableMgrLocalFetchFromStagedPS(VariableMgrLocalFetchFromPS):
    method __init__ (line 443) | def __init__(self, benchmark_cnn):
    method supports_staged_vars (line 452) | def supports_staged_vars(self):
    method create_outer_variable_scope (line 455) | def create_outer_variable_scope(self, device_num):
    method trainable_variables_on_device (line 461) | def trainable_variables_on_device(self, rel_device_num, abs_device_num,
  function parse_general_int (line 470) | def parse_general_int(s):
  function parse_all_reduce_spec (line 493) | def parse_all_reduce_spec(all_reduce_spec):
  function build_all_reduce_device_prefixes (line 577) | def build_all_reduce_device_prefixes(job_name, num_tasks):
  function group_device_names (line 596) | def group_device_names(devices, group_size):
  class VariableMgrLocalReplicated (line 624) | class VariableMgrLocalReplicated(VariableMgr):
    method __init__ (line 633) | def __init__(self, benchmark_cnn, all_reduce_spec):
    method each_tower_has_variables (line 644) | def each_tower_has_variables(self):
    method create_outer_variable_scope (line 647) | def create_outer_variable_scope(self, device_num):
    method preprocess_device_grads (line 650) | def preprocess_device_grads(self, device_grads):
    method get_gradients_to_apply (line 665) | def get_gradients_to_apply(self, device_num, gradient_state):
    method get_post_init_ops (line 669) | def get_post_init_ops(self):
    method savable_variables (line 684) | def savable_variables(self):
    method get_devices (line 693) | def get_devices(self):
  class VariableMgrDistributedAllReduce (line 697) | class VariableMgrDistributedAllReduce(VariableMgr):
    method __init__ (line 705) | def __init__(self, benchmark_cnn, all_reduce_spec, job_name,
    method each_tower_has_variables (line 718) | def each_tower_has_variables(self):
    method create_outer_variable_scope (line 721) | def create_outer_variable_scope(self, device_num):
    method preprocess_device_grads (line 734) | def preprocess_device_grads(self, device_grads):
    method get_gradients_to_apply (line 762) | def get_gradients_to_apply(self, device_num, gradient_state):
    method get_post_init_ops (line 769) | def get_post_init_ops(self):
    method savable_variables (line 784) | def savable_variables(self):
    method get_devices (line 793) | def get_devices(self):
  class VariableMgrDistributedFetchFromPS (line 797) | class VariableMgrDistributedFetchFromPS(VariableMgr):
    method each_tower_has_variables (line 805) | def each_tower_has_variables(self):
    method create_outer_variable_scope (line 808) | def create_outer_variable_scope(self, device_num):
    method preprocess_device_grads (line 818) | def preprocess_device_grads(self, device_grads):
    method get_gradients_to_apply (line 822) | def get_gradients_to_apply(self, device_num, gradient_state):
    method get_devices (line 826) | def get_devices(self):
  class VariableMgrDistributedFetchFromStagedPS (line 835) | class VariableMgrDistributedFetchFromStagedPS(
    method __init__ (line 839) | def __init__(self, benchmark_cnn):
    method create_outer_variable_scope (line 845) | def create_outer_variable_scope(self, device_num):
    method supports_staged_vars (line 852) | def supports_staged_vars(self):
    method trainable_variables_on_device (line 855) | def trainable_variables_on_device(self, rel_device_num, abs_device_num,
  class VariableMgrDistributedReplicated (line 861) | class VariableMgrDistributedReplicated(VariableMgr):
    method each_tower_has_variables (line 870) | def each_tower_has_variables(self):
    method create_outer_variable_scope (line 873) | def create_outer_variable_scope(self, device_num):
    method preprocess_device_grads (line 878) | def preprocess_device_grads(self, device_grads):
    method get_gradients_to_apply (line 881) | def get_gradients_to_apply(self, device_num, gradient_state):
    method append_apply_gradients_ops (line 898) | def append_apply_gradients_ops(self, gradient_state, opt,
    method _strip_port (line 916) | def _strip_port(self, s):
    method get_post_init_ops (line 921) | def get_post_init_ops(self):
    method _remove_shadow_var_prefix_if_present (line 940) | def _remove_shadow_var_prefix_if_present(self, var_name):
    method var_dict_name (line 946) | def var_dict_name(self, v):
    method savable_variables (line 949) | def savable_variables(self):
    method get_devices (line 970) | def get_devices(self):
  function split_grads_by_size (line 974) | def split_grads_by_size(threshold_size, device_grads):
  function sum_grad_and_var_all_reduce (line 1006) | def sum_grad_and_var_all_reduce(grad_and_vars, num_workers, alg, gpu_ind...
  function contains_any (line 1044) | def contains_any(haystack, needles):
  function sum_gradients_all_reduce (line 1061) | def sum_gradients_all_reduce(dev_prefixes, tower_grads, num_workers,
  function aggregate_gradients_using_copy_with_device_selection (line 1098) | def aggregate_gradients_using_copy_with_device_selection(
  function aggregate_gradients_using_copy_with_variable_colocation (line 1125) | def aggregate_gradients_using_copy_with_variable_colocation(
  function aggregate_gradients_using_copy (line 1154) | def aggregate_gradients_using_copy(tower_grads, use_mean):
  function aggregate_single_gradient_using_copy (line 1172) | def aggregate_single_gradient_using_copy(grad_and_vars, use_mean):

FILE: cluster/launch_async_adder.py
  function ossystem (line 192) | def ossystem(cmd):
  function setup_local_logdir (line 199) | def setup_local_logdir(run):
  function setup_remote_logdir (line 205) | def setup_remote_logdir(run):
  function run_in_window (line 213) | def run_in_window(window, cmd_list):
  function launch_job_tmux (line 245) | def launch_job_tmux(role, num_tasks):
  class LocalJob (line 266) | class LocalJob:
    method __init__ (line 267) | def __init__(self, name, num_tasks):
  class LocalTask (line 275) | class LocalTask: # same as Instance
    method __init__ (line 279) | def __init__(self, job, task_id):
    method run (line 285) | def run(self, cmd):
    method tf_env_setup (line 290) | def tf_env_setup(self, full_cluster_spec, task_spec):
  function select_window (line 336) | def select_window(window):
  function launch_job_aws (line 340) | def launch_job_aws(name, replicas):
  function tf_config_cmd (line 355) | def tf_config_cmd(full_cluster_spec, task_spec):
  class BasicAwsJob (line 389) | class BasicAwsJob():
    method __init__ (line 390) | def __init__(name, num_tasks):
  function launch_aws (line 395) | def launch_aws():
  class Instance (line 437) | class Instance:
    method tf_env_setup (line 440) | def tf_env_setup(self, cluster_spec, task_spec):
  function launch_local (line 450) | def launch_local():
  function cnn_launcher (line 522) | def cnn_launcher():
  function main (line 677) | def main():

FILE: cluster/launch_micro.py
  function main (line 56) | def main():

FILE: cluster/launch_ray.py
  function main (line 53) | def main():

FILE: cluster/launch_simple_tf.py
  function main (line 14) | def main():
  function launcher (line 23) | def launcher(do_local=False):
  function worker (line 43) | def worker():

FILE: cluster/local_distributed_benchmark.py
  function default_config (line 26) | def default_config():
  function create_graph (line 34) | def create_graph(device1, device2):
  function run_benchmark (line 55) | def run_benchmark(sess, init_op, add_op):
  function run_benchmark_local (line 68) | def run_benchmark_local():
  function run_benchmark_distributed (line 74) | def run_benchmark_distributed():

FILE: cluster/myutil.py
  class timeit (line 8) | class timeit:
    method __init__ (line 12) | def __init__(self, tag=""):
    method __enter__ (line 15) | def __enter__(self):
    method __exit__ (line 19) | def __exit__(self, *args):
  function get_instance_ip_map (line 24) | def get_instance_ip_map():

FILE: cluster/ray_add.py
  class ParameterServer (line 48) | class ParameterServer(object):
    method __init__ (line 49) | def __init__(self, data_size, read):
    method push (line 55) | def push(self, value):
    method pull (line 60) | def pull(self):
    method update_times (line 65) | def update_times(self):
    method get_throughput (line 70) | def get_throughput(self):
  function worker_task (line 76) | def worker_task(data_size, read, *parameter_servers):

FILE: cluster/simple_distributed.py
  function clusterspec (line 40) | def clusterspec():
  function log (line 45) | def log(s):
  function session_config (line 49) | def session_config():
  function launch_distributed_service (line 58) | def launch_distributed_service():
  function run_benchmark (line 78) | def run_benchmark(master, direction=None):
  function create_done_queue (line 160) | def create_done_queue(i):

FILE: cluster/terminate_instances.py
  function main (line 19) | def main():

FILE: cluster/test_aws.py
  function test_new_job (line 21) | def test_new_job():
  function test_terminate_job (line 30) | def test_terminate_job():
  function test_reuse_job (line 34) | def test_reuse_job():
  function test_send_file (line 38) | def test_send_file():
  function test_upload_directory (line 50) | def test_upload_directory():
  function test_stream_output (line 53) | def test_stream_output():
  function main (line 63) | def main():

FILE: cluster/tf-tools/benchmark/runner/cluster_aws.py
  class AWSInstance (line 8) | class AWSInstance(object):
    method __init__ (line 10) | def __init__(self, instance, ssh_key='', name='', username='ubuntu'):
    method __del__ (line 19) | def __del__(self):
    method WaitUntilReady (line 22) | def WaitUntilReady(self):
    method CreateSshClient (line 40) | def CreateSshClient(self):
    method reuse_ssh_client (line 46) | def reuse_ssh_client(self):
    method CleanSshClient (line 52) | def CleanSshClient(self):
    method state (line 64) | def state(self):
    method SetNameTag (line 67) | def SetNameTag(self, name='tf'):
    method Start (line 75) | def Start(self):
    method Stop (line 78) | def Stop(self):
    method StopAndWaitUntilStopped (line 82) | def StopAndWaitUntilStopped(self):
    method Terminate (line 86) | def Terminate(self):
    method TerminateAndWaitUntilTerminated (line 90) | def TerminateAndWaitUntilTerminated(self):
    method instance_id (line 95) | def instance_id(self):
    method ExecuteCommandAndWait (line 98) | def ExecuteCommandAndWait(self, cmd, print_error=False):
    method ExecuteCommandAndReturnStdout (line 102) | def ExecuteCommandAndReturnStdout(self, cmd):
    method ExecuteCommandAndStreamOutput (line 105) | def ExecuteCommandAndStreamOutput(self,
    method ExecuteCommandInThread (line 121) | def ExecuteCommandInThread(self,
    method RetrieveFile (line 136) | def RetrieveFile(self, remote_file, local_file):
    method UploadFile (line 141) | def UploadFile(self, local_file, remote_file):
  function MaybeCreatePlacementGroup (line 147) | def MaybeCreatePlacementGroup(name='tf_bm'):
  function DeletePlacementGroup (line 168) | def DeletePlacementGroup(name='tf_bm'):
  function CreateAwsInstances (line 184) | def CreateAwsInstances(num_instances=1,
  function LookupAwsInstances (line 220) | def LookupAwsInstances(image_id=None,
  function AwsInstances (line 252) | def AwsInstances(num_instances=1,
  function ReuseAwsInstances (line 294) | def ReuseAwsInstances(image_id=None,

FILE: cluster/tf-tools/benchmark/runner/command_builder.py
  function BuildDistributedCommandWorker (line 5) | def BuildDistributedCommandWorker(run_config, worker_hosts, ps_hosts,
  function BuildDistributedCommandPS (line 82) | def BuildDistributedCommandPS(run_config, worker_hosts, ps_hosts, task_i...
  function WorkerUtil (line 107) | def WorkerUtil(workers):
  function GpuDecode (line 118) | def GpuDecode(raw_gpu_input):
  function LoadYamlRunConfig (line 126) | def LoadYamlRunConfig(full_config, debug_level):

FILE: cluster/tf-tools/benchmark/runner/launch_experiment.py
  class timeit (line 46) | class timeit:
    method __init__ (line 50) | def __init__(self, tag=""):
    method __enter__ (line 53) | def __enter__(self):
    method __exit__ (line 57) | def __exit__(self, *args):
  function get_instance_ip_map (line 63) | def get_instance_ip_map():
  function main (line 84) | def main():

FILE: cluster/tf-tools/benchmark/runner/test_cluster_aws.py
  class timeit (line 19) | class timeit:
    method __init__ (line 23) | def __init__(self, tag=""):
    method __enter__ (line 26) | def __enter__(self):
    method __exit__ (line 30) | def __exit__(self, *args):
  function test_two_machine (line 35) | def test_two_machine():
  function main (line 39) | def main():

FILE: cluster/tf-tools/benchmark/runner/test_command_builder.py
  function main (line 5) | def main():

FILE: cluster/tf-tools/benchmark/runner/util.py
  function ExtractErrorToConsole (line 11) | def ExtractErrorToConsole(line):
  function ExtractToStdout (line 36) | def ExtractToStdout(line):
  function ExtractImagePerSecond (line 40) | def ExtractImagePerSecond(line):
  function ExecuteCommandAndWait (line 45) | def ExecuteCommandAndWait(ssh_client, command, print_error=True, ok_exit...
  function ExecuteCommandAndReturnStdout (line 57) | def ExecuteCommandAndReturnStdout(ssh_client, command):
  function _StreamOutputToFile (line 63) | def _StreamOutputToFile(fd, file, line_extractor, command=None):
  function ExecuteCommandAndStreamOutput (line 89) | def ExecuteCommandAndStreamOutput(ssh_client,
  function ExecuteCommandInThread (line 128) | def ExecuteCommandInThread(ssh_client,
  function SshToHost (line 158) | def SshToHost(hostname,

FILE: cluster/tmux.py
  function _setup_logdir (line 30) | def _setup_logdir(job_name):
  function _ossystem (line 40) | def _ossystem(cmd):
  function kill_job (line 44) | def kill_job(name):
  function tf_job (line 49) | def tf_job(name, num_tasks):
  class Job (line 76) | class Job:
    method __init__ (line 77) | def __init__(self, name, num_tasks, tmux_windows):
  class Task (line 85) | class Task:
    method __init__ (line 89) | def __init__(self, tmux_window, job, task_id):
    method run (line 100) | def run(self, cmd):
    method upload (line 103) | def upload(self, cmd):  # compatiblity with aws.py:Task
    method tf_env_setup (line 106) | def tf_env_setup(self, full_cluster_spec, task_spec):

FILE: conditional_backprop.py
  function conditional_backprop (line 15) | def conditional_backprop(do_backprop, tensor):

FILE: danjar_peek.py
  class Queue (line 5) | class Queue(tf.FIFOQueue):
    method __init__ (line 7) | def __init__(self, capacity):
    method peek (line 18) | def peek(self):
    method enqueue (line 21) | def enqueue(self, element):

FILE: distributed/benchmark_grpc_recv.py
  function session_config (line 62) | def session_config():
  function clusterspec (line 71) | def clusterspec():
  function create_graph (line 76) | def create_graph(device0, device1):
  function create_done_queue (line 94) | def create_done_queue(i):
  function run_benchmark (line 101) | def run_benchmark(sess, init_op, add_op):
  function run_benchmark_local (line 114) | def run_benchmark_local():
  function run_benchmark_distributed (line 120) | def run_benchmark_distributed():

FILE: distributed/client_transfer_benchmark.py
  function clusterspec (line 71) | def clusterspec():
  function log (line 76) | def log(s):
  function session_config (line 80) | def session_config():
  function launch_distributed_service (line 89) | def launch_distributed_service():
  function run_benchmark (line 109) | def run_benchmark(master):
  function create_done_queue (line 147) | def create_done_queue(i):

FILE: double_memory_bug.py
  function sessrun (line 7) | def sessrun(*args, **kwargs):

FILE: eager_lbfgs/eager_lbfgs.py
  function dot (line 10) | def dot(a, b):
  function verbose_func (line 14) | def verbose_func(s):
  function lbfgs (line 19) | def lbfgs(opfunc, x, config, state, do_verbose):
  class dummy (line 216) | class dummy(object):
  class Struct (line 219) | class Struct(dummy):
    method __getattribute__ (line 220) | def __getattribute__(self, key):
  function benchmark (line 226) | def benchmark(batch_size, iters, seed=1, cuda=True, history=100, verbose...
  function main (line 285) | def main():

FILE: eager_lbfgs/pytorch_lbfgs.py
  function benchmark (line 15) | def benchmark(batch_size, iters, seed=1, cuda=True, history=100, verbose...
  function main (line 90) | def main():

FILE: eager_lbfgs/run_experiment.py
  function run_experiment (line 14) | def run_experiment(iters, name):

FILE: eager_lbfgs/util.py
  function check_mkl (line 43) | def check_mkl():
  function set_global_args (line 48) | def set_global_args(local_args):
  function concat_blocks (line 55) | def concat_blocks(blocks, validate_dims=True):
  function concat_blocks_test (line 70) | def concat_blocks_test():
  function partition_matrix_evenly (line 79) | def partition_matrix_evenly(mat, splits):
  function partition_matrix_evenly_test (line 88) | def partition_matrix_evenly_test():
  function partition_matrix (line 96) | def partition_matrix(mat, sizes):
  function partition_matrix_test (line 99) | def partition_matrix_test():
  function pseudo_inverse (line 104) | def pseudo_inverse(mat, eps=1e-10):
  function symsqrt (line 112) | def symsqrt(mat, eps=1e-7):
  function pseudo_inverse_sqrt (line 120) | def pseudo_inverse_sqrt(mat, eps=1e-7):
  function pseudo_inverse_sqrt2 (line 127) | def pseudo_inverse_sqrt2(svd, eps=1e-7):
  function pseudo_inverse2 (line 139) | def pseudo_inverse2(svd, eps=1e-7):
  function pseudo_inverse_stable (line 153) | def pseudo_inverse_stable(svd, eps=1e-7):
  function regularized_inverse (line 168) | def regularized_inverse(mat, l=0.1):
  function regularized_inverse2 (line 172) | def regularized_inverse2(svd, L=1e-3):
  function regularized_inverse3 (line 184) | def regularized_inverse3(svd, L=1e-3):
  function regularized_inverse4 (line 200) | def regularized_inverse4(svd, L=1e-3):
  function pseudo_inverse_scipy (line 216) | def pseudo_inverse_scipy(tensor):
  function Identity (line 225) | def Identity(n, dtype=None, name=None):
  function ones (line 235) | def ones(n, dtype=None, name=None):
  function partition_list_np (line 241) | def partition_list_np(vec, sizes):
  function chunks (line 251) | def chunks(l, n):
  function partition_list (line 256) | def partition_list(l, sizes):
  function partition_list_test (line 267) | def partition_list_test():
  function v2c (line 275) | def v2c(vec):
  function v2c_np (line 280) | def v2c_np(vec):
  function v2r (line 285) | def v2r(vec):
  function c2v (line 290) | def c2v(col):
  function unvectorize_np (line 297) | def unvectorize_np(vec, rows):
  function unvec (line 304) | def unvec(vec, rows):
  function unvec_test (line 314) | def unvec_test():
  function vectorize_np (line 320) | def vectorize_np(mat):
  function vec (line 323) | def vec(mat):
  function vec_test (line 327) | def vec_test():
  function Kmat (line 333) | def Kmat(rows, cols):
  function Kmat_test (line 348) | def Kmat_test():
  function unflatten_np (line 367) | def unflatten_np(Wf, fs):
  function flatten_np (line 378) | def flatten_np(Ws):
  function flatten_np_test (line 381) | def flatten_np_test():
  function unflatten (line 388) | def unflatten(Wf, fs):
  function unflatten_test (line 402) | def unflatten_test():
  function flatten (line 411) | def flatten(Ws):
  function flatten_test (line 415) | def flatten_test():
  function check_close (line 423) | def check_close(a0, b0):
  function check_equal (line 426) | def check_equal(a0, b0, rtol=1e-9, atol=1e-12):
  function fix_shape (line 453) | def fix_shape(tf_shape):
  function kronecker_cols (line 456) | def kronecker_cols(a, b):
  function kronecker_cols_test (line 468) | def kronecker_cols_test():
  function kronecker (line 476) | def kronecker(A, B, do_shape_inference=True):
  function kronecker_test (line 508) | def kronecker_test():
  function col (line 522) | def col(A,i):
  function khatri_rao (line 529) | def khatri_rao(A, B):
  function khatri_rao_test (line 536) | def khatri_rao_test():
  function relu_mask (line 544) | def relu_mask(a, dtype=default_dtype):
  function relu_mask_test (line 550) | def relu_mask_test():
  function assert_rectangular (line 555) | def assert_rectangular(blocks):
  function empty_grid (line 559) | def empty_grid(rows, cols):
  function block_diagonal_inverse (line 566) | def block_diagonal_inverse(blocks):
  function block_diagonal_inverse_sqrt (line 586) | def block_diagonal_inverse_sqrt(blocks):
  function block_diagonal_inverse_test (line 605) | def block_diagonal_inverse_test():
  function t (line 615) | def t(x):
  function reset_time (line 622) | def reset_time():
  function record_time (line 627) | def record_time():
  function last_time (line 634) | def last_time():
  function summarize_time (line 642) | def summarize_time(time_list=None):
  function summarize_graph (line 660) | def summarize_graph(g=None):
  function disable_shape_inference (line 668) | def disable_shape_inference():
  function enable_shape_inference (line 671) | def enable_shape_inference():
  function dummy_collections_handler (line 678) | def dummy_collections_handler(info, elem, elem_): pass
  function disable_collections_handler (line 679) | def disable_collections_handler():
  function enable_collections_handler (line 681) | def enable_collections_handler():
  function dump_with_prompt (line 685) | def dump_with_prompt(result, fname, no_prefix=False):
  function dump (line 700) | def dump(result, fname, no_prefix=False):
  function dump32 (line 722) | def dump32(result, fname):
  function frobenius_np (line 732) | def frobenius_np(a):
  function nan_check (line 735) | def nan_check(result):
  function L2 (line 741) | def L2(t):
  class timeit (line 752) | class timeit:
    method __init__ (line 756) | def __init__(self, tag=""):
    method __enter__ (line 759) | def __enter__(self):
    method __exit__ (line 763) | def __exit__(self, *args):
  function record (line 777) | def record(tag, stat):
  function timeit_summarize (line 782) | def timeit_summarize():
  function parents (line 790) | def parents(op): return set(input.op for input in op.inputs)
  function children (line 791) | def children(op): return set(op for out in op.outputs for op in out.cons...
  function dict_graph (line 792) | def dict_graph():
  function nx_graph (line 798) | def nx_graph():
  function shortest_path (line 801) | def shortest_path(dep, target):
  function list_or_tuple (line 808) | def list_or_tuple(k):
  function is_numeric (line 811) | def is_numeric(ndarray):
  class VarInfo (line 815) | class VarInfo:
    method __init__ (line 817) | def __init__(self, setter, p):
  class SvdTuple (line 821) | class SvdTuple:
    method __init__ (line 825) | def __init__(self, suvi, *args):
  class SvdWrapper (line 846) | class SvdWrapper:
    method __init__ (line 853) | def __init__(self, target, name, do_inverses=False, use_resource=False):
    method update (line 926) | def update(self):
    method update_tf (line 933) | def update_tf(self):
    method update_scipy (line 938) | def update_scipy(self):
    method update_scipy_inv (line 944) | def update_scipy_inv(self):
    method update_scipy_svd (line 951) | def update_scipy_svd(self):
  function extract_grad (line 972) | def extract_grad(grads_and_vars, var):
  function intersept_op_creation (line 984) | def intersept_op_creation(op_type_name_to_intercept):
  function get_variable (line 997) | def get_variable(name, initializer, reuse=True):
  class VarStruct (line 1011) | class VarStruct:
    method __init__ (line 1026) | def __init__(self, initial_value, name, dtype=None):
    method set (line 1044) | def set(self, val):
    method initialize (line 1048) | def initialize(self):
  function get_var (line 1054) | def get_var(name, initializer, reuse=True):
  function run_all_tests (line 1075) | def run_all_tests(module):
  function capture_ops (line 1085) | def capture_ops():
  function capture_vars (line 1102) | def capture_vars():
  function Print (line 1118) | def Print(op):
  function get_host_prefix (line 1122) | def get_host_prefix():
  function summarize_difference (line 1126) | def summarize_difference(source, target):
  class BufferedWriter (line 1134) | class BufferedWriter:
    method __init__ (line 1137) | def __init__(self, outfn, save_every_secs=60*5):
    method write (line 1143) | def write(self, line):
    method flush (line 1152) | def flush():
  function ossystem (line 1158) | def ossystem(line):
  function setup_experiment_run_directory (line 1162) | def setup_experiment_run_directory(run, safe_mode=True):
  function get_last_logger (line 1187) | def get_last_logger(skip_existence_check=False):
  class TensorboardLogger (line 1195) | class TensorboardLogger:
    method __init__ (line 1204) | def __init__(self, run, step=0):
    method __call__ (line 1219) | def __call__(self, *args):
    method next_step (line 1224) | def next_step(self):
  function as_int32 (line 1235) | def as_int32(v):
  function add_dep (line 1239) | def add_dep(from_op, on_op):
  function register_default_session (line 1248) | def register_default_session(local_sess):
  function get_default_session (line 1253) | def get_default_session():
  function get_default_graph (line 1260) | def get_default_graph():
  function eval (line 1265) | def eval(tensor):
  function run (line 1271) | def run(fetches):
  function traced_run (line 1276) | def traced_run(fetches):
  function get_mnist_images (line 1298) | def get_mnist_images(max_images=0, fold='train'):
  function cachedGpuIdentityRegularizer (line 1364) | def cachedGpuIdentityRegularizer(n, Lambda):
  function ng_init (line 1377) | def ng_init(s1, s2): # uniform weight init from Ng UFLDL

FILE: enqueue_many_test.py
  function create_session (line 6) | def create_session():
  function run_op (line 44) | def run_op(op):

FILE: enqueue_many_test_singlerun.py
  function create_session (line 7) | def create_session():
  function run_op (line 46) | def run_op(op):

FILE: ericyue-slowreader/benchmark-batch.py
  function let_queue_repopulate (line 72) | def let_queue_repopulate(size_tensor, min_elements=100000, sleep_delay=0...

FILE: ericyue-slowreader/benchmark-synthetic-batch.py
  function let_queue_repopulate (line 35) | def let_queue_repopulate(size_tensor, min_elements=100000, sleep_delay=0...

FILE: ericyue-slowreader/benchmark.py
  function read_and_decode (line 49) | def read_and_decode(filename_queue):

FILE: free_gpus.py
  function tokenize (line 9) | def tokenize(cmd):
  function run_command (line 19) | def run_command(cmd):
  function run_shell (line 27) | def run_shell(cmd):
  function run_shell_background (line 45) | def run_shell_background(cmd_orig):
  function get_pid_gpu_map (line 53) | def get_pid_gpu_map():
  function kill_pids (line 75) | def kill_pids(pids_to_kill):
  function owner (line 83) | def owner(pid):

FILE: graph_template.py
  function profile (line 9) | def profile(func): return func
  class GraphTemplate (line 26) | class GraphTemplate:
    method __init__ (line 49) | def __init__(self, inputs, outputs, within_ops=None):
    method apply (line 99) | def apply(self, new_inputs, update_colocation_groups=True):
  function clear_original_ops (line 204) | def clear_original_ops(ops):
  function tf_ops_to_graph (line 209) | def tf_ops_to_graph(ops):
  function ops_in_toposorted_order (line 217) | def ops_in_toposorted_order(ops):
  class _DeviceCaptureOp (line 229) | class _DeviceCaptureOp(object):
    method __init__ (line 230) | def __init__(self):
    method _set_device (line 232) | def _set_device(self, device):
  function get_current_device (line 235) | def get_current_device():
  function flatten1 (line 243) | def flatten1(list_of_lists):
  function count_gpus (line 256) | def count_gpus():
  function current_function_name (line 264) | def current_function_name():
  function check_equal (line 270) | def check_equal(a, b):
  function capture_ops (line 277) | def capture_ops():
  function capture_ops_test (line 291) | def capture_ops_test():
  function graph_template_test (line 297) | def graph_template_test():
  function graph_devices_test (line 310) | def graph_devices_test():
  function variables_test (line 325) | def variables_test():
  function multi_variables_test (line 335) | def multi_variables_test():
  function colocate_test (line 350) | def colocate_test():
  function between_devices_copy_test (line 366) | def between_devices_copy_test():
  function optimization_test (line 387) | def optimization_test():
  function multidevice_shared_params_test (line 425) | def multidevice_shared_params_test():
  function multidevice_separate_params_test (line 461) | def multidevice_separate_params_test():
  function run_all_tests (line 512) | def run_all_tests(module):

FILE: input_benchmarks/convert_to_records.py
  function _int64_feature (line 43) | def _int64_feature(value):
  function _bytes_feature (line 47) | def _bytes_feature(value):
  function convert_to (line 51) | def convert_to(data_set, name):
  function main (line 78) | def main(argv):

FILE: input_benchmarks/fully_connected_feed.py
  function placeholder_inputs (line 46) | def placeholder_inputs(batch_size):
  function fill_feed_dict (line 68) | def fill_feed_dict(data_set, images_pl, labels_pl):
  function do_eval (line 96) | def do_eval(sess,
  function run_training (line 125) | def run_training():
  function main (line 240) | def main(_):

FILE: input_benchmarks/fully_connected_preloaded_var.py
  function run_training (line 54) | def run_training():
  function main (line 174) | def main(_):

FILE: input_benchmarks/fully_connected_reader.py
  function read_and_decode (line 53) | def read_and_decode(filename_queue):
  function inputs (line 84) | def inputs(train, batch_size, num_epochs):
  function run_training (line 123) | def run_training():
  function main (line 206) | def main(_):

FILE: inverse_segfault.py
  function load_MNIST_images (line 38) | def load_MNIST_images(filename):
  function set_global_args (line 61) | def set_global_args(local_args):
  function concat_blocks (line 66) | def concat_blocks(blocks, validate_dims=True):
  function concat_blocks_test (line 81) | def concat_blocks_test():
  function partition_matrix_evenly (line 90) | def partition_matrix_evenly(mat, splits):
  function partition_matrix_evenly_test (line 99) | def partition_matrix_evenly_test():
  function partition_matrix (line 107) | def partition_matrix(mat, sizes):
  function partition_matrix_test (line 110) | def partition_matrix_test():
  function pseudo_inverse (line 115) | def pseudo_inverse(mat, eps=1e-10):
  function symsqrt (line 123) | def symsqrt(mat, eps=1e-7):
  function pseudo_inverse_sqrt (line 131) | def pseudo_inverse_sqrt(mat, eps=1e-7):
  function pseudo_inverse_sqrt2 (line 138) | def pseudo_inverse_sqrt2(svd, eps=1e-7):
  function pseudo_inverse2 (line 150) | def pseudo_inverse2(svd, eps=1e-7):
  function pseudo_inverse_stable (line 164) | def pseudo_inverse_stable(svd, eps=1e-7):
  function regularized_inverse (line 179) | def regularized_inverse(mat, l=0.1):
  function regularized_inverse2 (line 184) | def regularized_inverse2(svd, L=1e-3):
  function regularized_inverse3 (line 196) | def regularized_inverse3(svd, L=1e-3):
  function regularized_inverse4 (line 212) | def regularized_inverse4(svd, L=1e-3):
  function pseudo_inverse_scipy (line 228) | def pseudo_inverse_scipy(tensor):
  function Identity (line 238) | def Identity(n, dtype=np.float32, name='dummy'):
  function ones (line 255) | def ones(n, dtype=None, name=None):
  function partition_list_np (line 261) | def partition_list_np(vec, sizes):
  function chunks (line 271) | def chunks(l, n):
  function partition_list (line 276) | def partition_list(l, sizes):
  function partition_list_test (line 287) | def partition_list_test():
  function v2c (line 295) | def v2c(vec):
  function v2c_np (line 300) | def v2c_np(vec):
  function v2r (line 305) | def v2r(vec):
  function c2v (line 310) | def c2v(col):
  function unvectorize_np (line 317) | def unvectorize_np(vec, rows):
  function unvec (line 324) | def unvec(vec, rows):
  function unvec_test (line 334) | def unvec_test():
  function vectorize_np (line 340) | def vectorize_np(mat):
  function vec (line 343) | def vec(mat):
  function vec_test (line 347) | def vec_test():
  function Kmat (line 353) | def Kmat(rows, cols):
  function Kmat_test (line 368) | def Kmat_test():
  function unflatten_np (line 387) | def unflatten_np(Wf, fs):
  function flatten_np (line 398) | def flatten_np(Ws):
  function flatten_np_test (line 401) | def flatten_np_test():
  function unflatten (line 408) | def unflatten(Wf, fs):
  function unflatten_test (line 422) | def unflatten_test():
  function flatten (line 431) | def flatten(Ws):
  function flatten_test (line 435) | def flatten_test():
  function check_close (line 443) | def check_close(a0, b0):
  function check_equal (line 446) | def check_equal(a0, b0, rtol=1e-9, atol=1e-12):
  function fix_shape (line 473) | def fix_shape(tf_shape):
  function kronecker_cols (line 476) | def kronecker_cols(a, b):
  function kronecker_cols_test (line 488) | def kronecker_cols_test():
  function kronecker (line 496) | def kronecker(A, B, do_shape_inference=True):
  function kronecker_test (line 528) | def kronecker_test():
  function col (line 542) | def col(A,i):
  function khatri_rao (line 549) | def khatri_rao(A, B):
  function khatri_rao_test (line 556) | def khatri_rao_test():
  function relu_mask (line 564) | def relu_mask(a, dtype=default_dtype):
  function relu_mask_test (line 570) | def relu_mask_test():
  function assert_rectangular (line 575) | def assert_rectangular(blocks):
  function empty_grid (line 579) | def empty_grid(rows, cols):
  function block_diagonal_inverse (line 586) | def block_diagonal_inverse(blocks):
  function block_diagonal_inverse_sqrt (line 606) | def block_diagonal_inverse_sqrt(blocks):
  function block_diagonal_inverse_test (line 625) | def block_diagonal_inverse_test():
  function t (line 635) | def t(x):
  function reset_time (line 642) | def reset_time():
  function record_time (line 647) | def record_time():
  function last_time (line 654) | def last_time():
  function summarize_time (line 661) | def summarize_time(time_list=None):
  function summarize_graph (line 678) | def summarize_graph(g=None):
  function disable_shape_inference (line 686) | def disable_shape_inference():
  function enable_shape_inference (line 689) | def enable_shape_inference():
  function dummy_collections_handler (line 696) | def dummy_collections_handler(info, elem, elem_): pass
  function disable_collections_handler (line 697) | def disable_collections_handler():
  function enable_collections_handler (line 699) | def enable_collections_handler():
  function dump_with_prompt (line 703) | def dump_with_prompt(result, fname, no_prefix=False):
  function dump (line 718) | def dump(result, fname, no_prefix=False):
  function dump32 (line 740) | def dump32(result, fname):
  function frobenius_np (line 750) | def frobenius_np(a):
  function nan_check (line 753) | def nan_check(result):
  function L2 (line 759) | def L2(t):
  class timeit (line 770) | class timeit:
    method __init__ (line 774) | def __init__(self, tag=""):
    method __enter__ (line 777) | def __enter__(self):
    method __exit__ (line 781) | def __exit__(self, *args):
  function record (line 796) | def record(tag, stat):
  function timeit_summarize (line 801) | def timeit_summarize():
  function parents (line 809) | def parents(op): return set(input.op for input in op.inputs)
  function children (line 810) | def children(op): return set(op for out in op.outputs for op in out.cons...
  function dict_graph (line 811) | def dict_graph():
  function nx_graph (line 817) | def nx_graph():
  function shortest_path (line 820) | def shortest_path(dep, target):
  function list_or_tuple (line 827) | def list_or_tuple(k):
  function is_numeric (line 830) | def is_numeric(ndarray):
  class VarInfo (line 834) | class VarInfo:
    method __init__ (line 836) | def __init__(self, setter, p):
  class SvdTuple (line 840) | class SvdTuple:
    method __init__ (line 844) | def __init__(self, suvi, *args):
  class SvdWrapper (line 865) | class SvdWrapper:
    method __init__ (line 872) | def __init__(self, target, name, do_inverses=False, use_resource=False):
    method update (line 945) | def update(self):
    method update_tf (line 952) | def update_tf(self):
    method update_scipy (line 956) | def update_scipy(self):
    method update_scipy_inv (line 962) | def update_scipy_inv(self):
    method update_scipy_svd (line 969) | def update_scipy_svd(self):
  function extract_grad (line 990) | def extract_grad(grads_and_vars, var):
  function intersept_op_creation (line 1002) | def intersept_op_creation(op_type_name_to_intercept):
  function get_variable (line 1015) | def get_variable(name, initializer, reuse=True):
  class VarStruct (line 1029) | class VarStruct:
    method __init__ (line 1044) | def __init__(self, initial_value, name, dtype=None):
    method set (line 1062) | def set(self, val):
    method initialize (line 1066) | def initialize(self):
  function get_var (line 1072) | def get_var(name, initializer, reuse=True):
  function run_all_tests (line 1093) | def run_all_tests(module):
  function capture_ops (line 1103) | def capture_ops():
  function capture_vars (line 1120) | def capture_vars():
  function Print (line 1136) | def Print(op):
  function get_host_prefix (line 1140) | def get_host_prefix():
  function summarize_difference (line 1144) | def summarize_difference(source, target):
  class BufferedWriter (line 1152) | class BufferedWriter:
    method __init__ (line 1155) | def __init__(self, outfn, save_every_secs=60*5):
    method write (line 1161) | def write(self, line):
    method flush (line 1170) | def flush():
  function ossystem (line 1176) | def ossystem(line):
  function setup_experiment_run_directory (line 1180) | def setup_experiment_run_directory(run, safe_mode=True):
  function get_last_logger (line 1205) | def get_last_logger(skip_existence_check=False):
  class TensorboardLogger (line 1213) | class TensorboardLogger:
    method __init__ (line 1222) | def __init__(self, run, step=0):
    method __call__ (line 1237) | def __call__(self, *args):
    method next_step (line 1242) | def next_step(self):
  function as_int32 (line 1253) | def as_int32(v):
  function add_dep (line 1257) | def add_dep(from_op, on_op):
  function register_default_session (line 1266) | def register_default_session(local_sess):
  function get_default_session (line 1271) | def get_default_session():
  function get_default_graph (line 1278) | def get_default_graph():
  function eval (line 1283) | def eval(tensor):
  function get_mnist_images (line 1289) | def get_mnist_images():
  function W_uniform (line 1330) | def W_uniform(s1, s2): # uniform weight init from Ng UFLDL
  function passthrough (line 1344) | def passthrough(obj, value): return value
  function main (line 1359) | def main():

FILE: keras_autoencoder/keras_large.py
  class TestCallback (line 39) | class TestCallback(callbacks.Callback):
    method __init__ (line 40) | def __init__(self, data_train, data_test, fn):
    method on_epoch_end (line 49) | def on_epoch_end(self, epoch, logs={}):

FILE: keras_autoencoder/util.py
  function set_global_args (line 35) | def set_global_args(local_args):
  function concat_blocks (line 40) | def concat_blocks(blocks, validate_dims=True):
  function concat_blocks_test (line 55) | def concat_blocks_test():
  function partition_matrix_evenly (line 64) | def partition_matrix_evenly(mat, splits):
  function partition_matrix_evenly_test (line 73) | def partition_matrix_evenly_test():
  function partition_matrix (line 81) | def partition_matrix(mat, sizes):
  function partition_matrix_test (line 84) | def partition_matrix_test():
  function pseudo_inverse (line 89) | def pseudo_inverse(mat, eps=1e-10):
  function symsqrt (line 97) | def symsqrt(mat, eps=1e-7):
  function pseudo_inverse_sqrt (line 105) | def pseudo_inverse_sqrt(mat, eps=1e-7):
  function pseudo_inverse_sqrt2 (line 112) | def pseudo_inverse_sqrt2(svd, eps=1e-7):
  function pseudo_inverse2 (line 124) | def pseudo_inverse2(svd, eps=1e-7):
  function pseudo_inverse_stable (line 138) | def pseudo_inverse_stable(svd, eps=1e-7):
  function regularized_inverse (line 153) | def regularized_inverse(mat, l=0.1):
  function regularized_inverse2 (line 157) | def regularized_inverse2(svd, L=1e-3):
  function regularized_inverse3 (line 169) | def regularized_inverse3(svd, L=1e-3):
  function regularized_inverse4 (line 185) | def regularized_inverse4(svd, L=1e-3):
  function pseudo_inverse_scipy (line 201) | def pseudo_inverse_scipy(tensor):
  function Identity (line 211) | def Identity(n, dtype=None, name=None):
  function ones (line 221) | def ones(n, dtype=None, name=None):
  function partition_list_np (line 227) | def partition_list_np(vec, sizes):
  function chunks (line 237) | def chunks(l, n):
  function partition_list (line 242) | def partition_list(l, sizes):
  function partition_list_test (line 253) | def partition_list_test():
  function v2c (line 261) | def v2c(vec):
  function v2c_np (line 266) | def v2c_np(vec):
  function v2r (line 271) | def v2r(vec):
  function c2v (line 276) | def c2v(col):
  function unvectorize_np (line 283) | def unvectorize_np(vec, rows):
  function unvec (line 290) | def unvec(vec, rows):
  function unvec_test (line 300) | def unvec_test():
  function vectorize_np (line 306) | def vectorize_np(mat):
  function vec (line 309) | def vec(mat):
  function vec_test (line 313) | def vec_test():
  function Kmat (line 319) | def Kmat(rows, cols):
  function Kmat_test (line 334) | def Kmat_test():
  function unflatten_np (line 353) | def unflatten_np(Wf, fs):
  function flatten_np (line 364) | def flatten_np(Ws):
  function flatten_np_test (line 367) | def flatten_np_test():
  function unflatten (line 374) | def unflatten(Wf, fs):
  function unflatten_test (line 388) | def unflatten_test():
  function flatten (line 397) | def flatten(Ws):
  function flatten_test (line 401) | def flatten_test():
  function check_close (line 409) | def check_close(a0, b0):
  function check_equal (line 412) | def check_equal(a0, b0, rtol=1e-9, atol=1e-12):
  function fix_shape (line 439) | def fix_shape(tf_shape):
  function kronecker_cols (line 442) | def kronecker_cols(a, b):
  function kronecker_cols_test (line 454) | def kronecker_cols_test():
  function kronecker (line 462) | def kronecker(A, B, do_shape_inference=True):
  function kronecker_test (line 494) | def kronecker_test():
  function col (line 508) | def col(A,i):
  function khatri_rao (line 515) | def khatri_rao(A, B):
  function khatri_rao_test (line 522) | def khatri_rao_test():
  function relu_mask (line 530) | def relu_mask(a, dtype=default_dtype):
  function relu_mask_test (line 536) | def relu_mask_test():
  function assert_rectangular (line 541) | def assert_rectangular(blocks):
  function empty_grid (line 545) | def empty_grid(rows, cols):
  function block_diagonal_inverse (line 552) | def block_diagonal_inverse(blocks):
  function block_diagonal_inverse_sqrt (line 572) | def block_diagonal_inverse_sqrt(blocks):
  function block_diagonal_inverse_test (line 591) | def block_diagonal_inverse_test():
  function t (line 601) | def t(x):
  function reset_time (line 608) | def reset_time():
  function record_time (line 613) | def record_time():
  function last_time (line 619) | def last_time():
  function summarize_time (line 626) | def summarize_time(time_list=None):
  function summarize_graph (line 643) | def summarize_graph(g=None):
  function disable_shape_inference (line 651) | def disable_shape_inference():
  function enable_shape_inference (line 654) | def enable_shape_inference():
  function dump_with_prompt (line 658) | def dump_with_prompt(result, fname, no_prefix=False):
  function dump (line 673) | def dump(result, fname, no_prefix=False):
  function dump32 (line 695) | def dump32(result, fname):
  function frobenius_np (line 705) | def frobenius_np(a):
  function nan_check (line 708) | def nan_check(result):
  function L2 (line 714) | def L2(t):
  class timeit (line 724) | class timeit:
    method __init__ (line 725) | def __init__(self, tag=""):
    method __enter__ (line 728) | def __enter__(self):
    method __exit__ (line 732) | def __exit__(self, *args):
  function timeit_summarize (line 741) | def timeit_summarize():
  function parents (line 749) | def parents(op): return set(input.op for input in op.inputs)
  function children (line 750) | def children(op): return set(op for out in op.outputs for op in out.cons...
  function dict_graph (line 751) | def dict_graph():
  function nx_graph (line 757) | def nx_graph():
  function shortest_path (line 760) | def shortest_path(dep, target):
  function list_or_tuple (line 767) | def list_or_tuple(k):
  function is_numeric (line 770) | def is_numeric(ndarray):
  class VarInfo (line 774) | class VarInfo:
    method __init__ (line 776) | def __init__(self, setter, p):
  class SvdTuple (line 780) | class SvdTuple:
    method __init__ (line 784) | def __init__(self, suvi, *args):
  class SvdWrapper (line 805) | class SvdWrapper:
    method __init__ (line 812) | def __init__(self, target, name, do_inverses=False):
    method update (line 872) | def update(self):
    method update_tf (line 879) | def update_tf(self):
    method update_scipy (line 883) | def update_scipy(self):
    method update_scipy_inv (line 889) | def update_scipy_inv(self):
    method update_scipy_svd (line 896) | def update_scipy_svd(self):
  function extract_grad (line 917) | def extract_grad(grads_and_vars, var):
  function intersept_op_creation (line 929) | def intersept_op_creation(op_type_name_to_intercept):
  function get_variable (line 942) | def get_variable(name, initializer, reuse=True):
  class VarStruct (line 956) | class VarStruct:
    method __init__ (line 971) | def __init__(self, initial_value, name, dtype=None):
    method set (line 989) | def set(self, val):
    method initialize (line 993) | def initialize(self):
  function get_var (line 999) | def get_var(name, initializer, reuse=True):
  function run_all_tests (line 1020) | def run_all_tests(module):
  function capture_ops (line 1030) | def capture_ops():
  function capture_vars (line 1047) | def capture_vars():
  function Print (line 1063) | def Print(op):
  function get_host_prefix (line 1067) | def get_host_prefix():
  function summarize_difference (line 1071) | def summarize_difference(source, target):
  class BufferedWriter (line 1079) | class BufferedWriter:
    method __init__ (line 1082) | def __init__(self, outfn, save_every_secs=60*5):
    method write (line 1088) | def write(self, line):
    method flush (line 1097) | def flush():
  function ossystem (line 1103) | def ossystem(line):
  function setup_experiment_run_directory (line 1107) | def setup_experiment_run_directory(run, safe_mode=True):
  function get_last_logger (line 1132) | def get_last_logger():
  class TensorboardLogger (line 1137) | class TensorboardLogger:
    method __init__ (line 1146) | def __init__(self, run, step=0):
    method __call__ (line 1161) | def __call__(self, *args):
    method next_step (line 1166) | def next_step(self):
  function as_int32 (line 1176) | def as_int32(v):
  function add_dep (line 1180) | def add_dep(from_op, on_op):
  function register_default_session (line 1189) | def register_default_session(local_sess):
  function get_default_session (line 1194) | def get_default_session():
  function get_default_graph (line 1201) | def get_default_graph():
  function eval (line 1206) | def eval(tensor):

FILE: keras_autoencoder/weightnorm.py
  class SGDWithWeightnorm (line 6) | class SGDWithWeightnorm(SGD):
    method get_updates (line 7) | def get_updates(self, params, constraints, loss):
  class AdamWithWeightnorm (line 75) | class AdamWithWeightnorm(Adam):
    method get_updates (line 76) | def get_updates(self, params, constraints, loss):
  function get_weightnorm_params_and_grads (line 146) | def get_weightnorm_params_and_grads(p, g):
  function add_weightnorm_param_updates (line 169) | def add_weightnorm_param_updates(updates, new_V_param, new_g_param, W, V...
  function data_based_init (line 182) | def data_based_init(model, input):

FILE: khatri_rao_benchmark.py
  function benchmark_construct (line 10) | def benchmark_construct(dims, iters, dtype):
  function benchmark_execute (line 20) | def benchmark_execute(dims, iters, dtype):

FILE: lazy_dog.py
  function argmax (line 30) | def argmax(t):
  function decode (line 33) | def decode(start_tokens, length=10):
  function main (line 59) | def main():

FILE: linalg-benchmark/benchmark.py
  function main (line 45) | def main():
  function get_tensorflow_version_url (line 125) | def get_tensorflow_version_url():
  function get_mkl_version (line 139) | def get_mkl_version():
  function traced_run (line 157) | def traced_run(fetches):
  function benchmark (line 179) | def benchmark(message, func):
  function print_cpu_info (line 204) | def print_cpu_info():

FILE: linalg-benchmark/launch.py
  function launch (line 18) | def launch(instance):
  function main (line 36) | def main():

FILE: linalg-benchmark/launch_tensorflow_svd_crash.py
  function main (line 13) | def main():

FILE: line_search_example/line_search_example.py
  function W_uniform (line 27) | def W_uniform(s1, s2):
  function f (line 66) | def f(i): return fs[i+1]  # W[i] has shape f[i] x f[i-1]
  function init_var (line 71) | def init_var(val, name, trainable=False):
  function sigmoid (line 85) | def sigmoid(x):
  function d_sigmoid (line 87) | def d_sigmoid(y):
  function kl (line 89) | def kl(x, y):
  function d_kl (line 91) | def d_kl(x, y):
  function save_wf (line 148) | def save_wf(): sess.run(Wf_save_op)
  function restore_wf (line 149) | def restore_wf(): sess.run(Wf_restore_op)
  function save_grad (line 150) | def save_grad(): sess.run(grad_save_op)
  function step_wf (line 151) | def step_wf(step):

FILE: line_search_example/util.py
  function set_global_args (line 35) | def set_global_args(local_args):
  function concat_blocks (line 40) | def concat_blocks(blocks, validate_dims=True):
  function concat_blocks_test (line 55) | def concat_blocks_test():
  function partition_matrix_evenly (line 64) | def partition_matrix_evenly(mat, splits):
  function partition_matrix_evenly_test (line 73) | def partition_matrix_evenly_test():
  function partition_matrix (line 81) | def partition_matrix(mat, sizes):
  function partition_matrix_test (line 84) | def partition_matrix_test():
  function pseudo_inverse (line 89) | def pseudo_inverse(mat, eps=1e-10):
  function symsqrt (line 97) | def symsqrt(mat, eps=1e-7):
  function pseudo_inverse_sqrt (line 105) | def pseudo_inverse_sqrt(mat, eps=1e-7):
  function pseudo_inverse_sqrt2 (line 112) | def pseudo_inverse_sqrt2(svd, eps=1e-7):
  function pseudo_inverse2 (line 124) | def pseudo_inverse2(svd, eps=1e-7):
  function pseudo_inverse_stable (line 138) | def pseudo_inverse_stable(svd, eps=1e-7):
  function regularized_inverse (line 153) | def regularized_inverse(mat, l=0.1):
  function regularized_inverse2 (line 157) | def regularized_inverse2(svd, L=1e-3):
  function regularized_inverse3 (line 169) | def regularized_inverse3(svd, L=1e-3):
  function regularized_inverse4 (line 185) | def regularized_inverse4(svd, L=1e-3):
  function pseudo_inverse_scipy (line 201) | def pseudo_inverse_scipy(tensor):
  function Identity (line 211) | def Identity(n, dtype=None, name=None):
  function ones (line 221) | def ones(n, dtype=None, name=None):
  function partition_list_np (line 227) | def partition_list_np(vec, sizes):
  function chunks (line 237) | def chunks(l, n):
  function partition_list (line 242) | def partition_list(l, sizes):
  function partition_list_test (line 253) | def partition_list_test():
  function v2c (line 261) | def v2c(vec):
  function v2c_np (line 266) | def v2c_np(vec):
  function v2r (line 271) | def v2r(vec):
  function c2v (line 276) | def c2v(col):
  function unvectorize_np (line 283) | def unvectorize_np(vec, rows):
  function unvec (line 290) | def unvec(vec, rows):
  function unvec_test (line 300) | def unvec_test():
  function vectorize_np (line 306) | def vectorize_np(mat):
  function vec (line 309) | def vec(mat):
  function vec_test (line 313) | def vec_test():
  function Kmat (line 319) | def Kmat(rows, cols):
  function Kmat_test (line 334) | def Kmat_test():
  function unflatten_np (line 353) | def unflatten_np(Wf, fs):
  function flatten_np (line 364) | def flatten_np(Ws):
  function flatten_np_test (line 367) | def flatten_np_test():
  function unflatten (line 374) | def unflatten(Wf, fs):
  function unflatten_test (line 388) | def unflatten_test():
  function flatten (line 397) | def flatten(Ws):
  function flatten_test (line 401) | def flatten_test():
  function check_close (line 409) | def check_close(a0, b0):
  function check_equal (line 412) | def check_equal(a0, b0, rtol=1e-9, atol=1e-12):
  function fix_shape (line 439) | def fix_shape(tf_shape):
  function kronecker_cols (line 442) | def kronecker_cols(a, b):
  function kronecker_cols_test (line 454) | def kronecker_cols_test():
  function kronecker (line 462) | def kronecker(A, B, do_shape_inference=True):
  function kronecker_test (line 494) | def kronecker_test():
  function col (line 508) | def col(A,i):
  function khatri_rao (line 515) | def khatri_rao(A, B):
  function khatri_rao_test (line 522) | def khatri_rao_test():
  function relu_mask (line 530) | def relu_mask(a, dtype=default_dtype):
  function relu_mask_test (line 536) | def relu_mask_test():
  function assert_rectangular (line 541) | def assert_rectangular(blocks):
  function empty_grid (line 545) | def empty_grid(rows, cols):
  function block_diagonal_inverse (line 552) | def block_diagonal_inverse(blocks):
  function block_diagonal_inverse_sqrt (line 572) | def block_diagonal_inverse_sqrt(blocks):
  function block_diagonal_inverse_test (line 591) | def block_diagonal_inverse_test():
  function t (line 601) | def t(x):
  function reset_time (line 608) | def reset_time():
  function record_time (line 613) | def record_time():
  function last_time (line 619) | def last_time():
  function summarize_time (line 626) | def summarize_time(time_list=None):
  function summarize_graph (line 643) | def summarize_graph(g=None):
  function disable_shape_inference (line 651) | def disable_shape_inference():
  function enable_shape_inference (line 654) | def enable_shape_inference():
  function dump_with_prompt (line 658) | def dump_with_prompt(result, fname, no_prefix=False):
  function dump (line 673) | def dump(result, fname, no_prefix=False):
  function dump32 (line 695) | def dump32(result, fname):
  function frobenius_np (line 705) | def frobenius_np(a):
  function nan_check (line 708) | def nan_check(result):
  function L2 (line 714) | def L2(t):
  class timeit (line 724) | class timeit:
    method __init__ (line 725) | def __init__(self, tag=""):
    method __enter__ (line 728) | def __enter__(self):
    method __exit__ (line 732) | def __exit__(self, *args):
  function timeit_summarize (line 741) | def timeit_summarize():
  function parents (line 749) | def parents(op): return set(input.op for input in op.inputs)
  function children (line 750) | def children(op): return set(op for out in op.outputs for op in out.cons...
  function dict_graph (line 751) | def dict_graph():
  function nx_graph (line 757) | def nx_graph():
  function shortest_path (line 760) | def shortest_path(dep, target):
  function list_or_tuple (line 767) | def list_or_tuple(k):
  function is_numeric (line 770) | def is_numeric(ndarray):
  class VarInfo (line 774) | class VarInfo:
    method __init__ (line 776) | def __init__(self, setter, p):
  class SvdTuple (line 780) | class SvdTuple:
    method __init__ (line 784) | def __init__(self, suvi, *args):
  class SvdWrapper (line 805) | class SvdWrapper:
    method __init__ (line 812) | def __init__(self, target, name, do_inverses=False):
    method update (line 872) | def update(self):
    method update_tf (line 879) | def update_tf(self):
    method update_scipy (line 883) | def update_scipy(self):
    method update_scipy_inv (line 889) | def update_scipy_inv(self):
    method update_scipy_svd (line 896) | def update_scipy_svd(self):
  function extract_grad (line 917) | def extract_grad(grads_and_vars, var):
  function intersept_op_creation (line 929) | def intersept_op_creation(op_type_name_to_intercept):
  function get_variable (line 942) | def get_variable(name, initializer, reuse=True):
  class VarStruct (line 956) | class VarStruct:
    method __init__ (line 971) | def __init__(self, initial_value, name, dtype=None):
    method set (line 989) | def set(self, val):
    method initialize (line 993) | def initialize(self):
  function get_var (line 999) | def get_var(name, initializer, reuse=True):
  function run_all_tests (line 1020) | def run_all_tests(module):
  function capture_ops (line 1030) | def capture_ops():
  function capture_vars (line 1047) | def capture_vars():
  function Print (line 1063) | def Print(op):
  function get_host_prefix (line 1067) | def get_host_prefix():
  function summarize_difference (line 1071) | def summarize_difference(source, target):
  class BufferedWriter (line 1079) | class BufferedWriter:
    method __init__ (line 1082) | def __init__(self, outfn, save_every_secs=60*5):
    method write (line 1088) | def write(self, line):
    method flush (line 1097) | def flush():
  function ossystem (line 1103) | def ossystem(line):
  function setup_experiment_run_directory (line 1107) | def setup_experiment_run_directory(run, safe_mode=True):
  function get_last_logger (line 1132) | def get_last_logger():
  class TensorboardLogger (line 1137) | class TensorboardLogger:
    method __init__ (line 1146) | def __init__(self, run, step=0):
    method __call__ (line 1161) | def __call__(self, *args):
    method next_step (line 1166) | def next_step(self):
  function as_int32 (line 1176) | def as_int32(v):
  function add_dep (line 1180) | def add_dep(from_op, on_op):
  function register_default_session (line 1185) | def register_default_session(local_sess):
  function get_default_session (line 1190) | def get_default_session():
  function eval (line 1195) | def eval(tensor):

FILE: linearize/linearize.py
  function run_after (line 11) | def run_after(a, b):
  function initialize_control_outputs (line 26) | def initialize_control_outputs(g):
  function nodesort (line 46) | def nodesort(ops):
  function parents_with_controls (line 51) | def parents_with_controls(op):
  function parents (line 57) | def parents(op):
  function children (line 61) | def children(op):
  function children_with_controls (line 65) | def children_with_controls(op):
  function get_graph (line 78) | def get_graph(g=None, as_hashes=False, exclude_controls=False):
  function print_tf_graph (line 103) | def print_tf_graph(graph):
  function memsorted (line 111) | def memsorted(nodes):
  function is_iterable (line 130) | def is_iterable(o):
  function linearize (line 140) | def linearize(targets=None, modify_graph=True):

FILE: linearize/linearize_test.py
  function create_session (line 13) | def create_session():
  function setup_env (line 17) | def setup_env():
  function make_caterpillar_graph (line 34) | def make_caterpillar_graph(length=5, node_mbs=1):
  function test_print (line 64) | def test_print():
  function test_toposort (line 80) | def test_toposort():
  function test_linearize (line 86) | def test_linearize():

FILE: linearize/memory_util.py
  function vlog (line 9) | def vlog(level):
  class TemporaryFileHelper (line 13) | class TemporaryFileHelper:
    method __init__ (line 15) | def __init__(self, temporary_file):
    method getvalue (line 17) | def getvalue(self):
  class capture_stderr (line 23) | class capture_stderr:
    method __init__ (line 31) | def __init__(self, fd=STDERR):
    method __enter__ (line 35) | def __enter__(self):
    method __exit__ (line 41) | def __exit__(self, exc_type, exc_value, traceback):
  function _parse_logline (line 83) | def _parse_logline(l):
  function memory_timeline (line 138) | def memory_timeline(log):
  function peak_memory (line 201) | def peak_memory(log, gpu_only=False):
  function print_memory_timeline (line 215) | def print_memory_timeline(log, gpu_only=False, ignore_less_than_bytes=0):
  function plot_memory_timeline (line 230) | def plot_memory_timeline(log, gpu_only=False, ignore_less_than_bytes=1000):
  function smart_initialize (line 257) | def smart_initialize(variables=None, sess=None):

FILE: matmul_benchmark_seq.py
  class timespec (line 21) | class timespec(ctypes.Structure):
  function clock_gettime (line 30) | def clock_gettime(clk_id):
  function bench (line 66) | def bench(n):
  function main (line 119) | def main():

FILE: natural_gradient_multilayer.py
  function gd_test (line 27) | def gd_test():
  function gd_manual_test (line 118) | def gd_manual_test():
  function gd_manual_vectorized_test (line 235) | def gd_manual_vectorized_test():
  function fisher_test (line 357) | def fisher_test():
  function natural_gradient_test (line 490) | def natural_gradient_test():
  function newton_test (line 619) | def newton_test():
  function relu_manual_vectorized_test (line 790) | def relu_manual_vectorized_test():

FILE: notebook_util.py
  function run_command (line 8) | def run_command(cmd):
  function list_available_gpus (line 14) | def list_available_gpus():
  function gpu_memory_map (line 27) | def gpu_memory_map():
  function pick_gpu_lowest_memory (line 46) | def pick_gpu_lowest_memory():
  function setup_one_gpu (line 53) | def setup_one_gpu():
  function setup_no_gpu (line 60) | def setup_no_gpu():

FILE: numpy_initializers/kfac_cifar.py
  function W_uniform (line 104) | def W_uniform(s1, s2): # uniform weight init from Ng UFLDL
  function ng_init (line 110) | def ng_init(rows, cols):
  function sessrun (line 145) | def sessrun(*args, **kwargs):
  function model_creator (line 172) | def model_creator(batch_size, name="default", dtype=np.float32):
  function main (line 398) | def main():

FILE: numpy_initializers/util.py
  function set_global_args (line 36) | def set_global_args(local_args):
  function concat_blocks (line 41) | def concat_blocks(blocks, validate_dims=True):
  function concat_blocks_test (line 56) | def concat_blocks_test():
  function partition_matrix_evenly (line 65) | def partition_matrix_evenly(mat, splits):
  function partition_matrix_evenly_test (line 74) | def partition_matrix_evenly_test():
  function partition_matrix (line 82) | def partition_matrix(mat, sizes):
  function partition_matrix_test (line 85) | def partition_matrix_test():
  function pseudo_inverse (line 90) | def pseudo_inverse(mat, eps=1e-10):
  function symsqrt (line 98) | def symsqrt(mat, eps=1e-7):
  function pseudo_inverse_sqrt (line 106) | def pseudo_inverse_sqrt(mat, eps=1e-7):
  function pseudo_inverse_sqrt2 (line 113) | def pseudo_inverse_sqrt2(svd, eps=1e-7):
  function pseudo_inverse2 (line 125) | def pseudo_inverse2(svd, eps=1e-7):
  function pseudo_inverse_stable (line 139) | def pseudo_inverse_stable(svd, eps=1e-7):
  function regularized_inverse (line 154) | def regularized_inverse(mat, l=0.1):
  function regularized_inverse2 (line 158) | def regularized_inverse2(svd, L=1e-3):
  function regularized_inverse3 (line 170) | def regularized_inverse3(svd, L=1e-3):
  function regularized_inverse4 (line 186) | def regularized_inverse4(svd, L=1e-3):
  function pseudo_inverse_scipy (line 202) | def pseudo_inverse_scipy(tensor):
  function Identity (line 212) | def Identity(n, dtype=None, name=None):
  function ones (line 222) | def ones(n, dtype=None, name=None):
  function partition_list_np (line 228) | def partition_list_np(vec, sizes):
  function chunks (line 238) | def chunks(l, n):
  function partition_list (line 243) | def partition_list(l, sizes):
  function partition_list_test (line 254) | def partition

[
  {
    "path": ".gitignore",
    "chars": 269,
    "preview": "/__pycache__\n/.ipynb_checkpoints\n*#\n*~\n/linalg-benchmark/.idea/linalg-benchmark.iml\n/linalg-benchmark/.idea/misc.xml\n/li"
  },
  {
    "path": "README.md",
    "chars": 8,
    "preview": "# stuff\n"
  },
  {
    "path": "akaitsuki-slow/config.py",
    "chars": 2294,
    "preview": "import argparse\n \n \ndef str2bool(v):\n    return v.lower() in ('y', 'yes', 't', 'true', '1')\n \n \ndef get_args():\n    pars"
  },
  {
    "path": "akaitsuki-slow/feed_dict.pbtxt",
    "chars": 3595,
    "preview": "step_stats {\n  dev_stats {\n    device: \"/job:localhost/replica:0/task:0/cpu:0\"\n    node_stats {\n      node_name: \"_SOURC"
  },
  {
    "path": "akaitsuki-slow/feed_dict.py",
    "chars": 500,
    "preview": "import numpy as np\nimport tensorflow as tf\nfrom tensorflow.python.client import timeline \n \n\nsess = tf.Session()\na = tf."
  },
  {
    "path": "akaitsuki-slow/main.py",
    "chars": 9022,
    "preview": "import logging\nimport time\nimport config\nimport numpy as np\nimport tensorflow as tf\nfrom tensorflow.python.ops import ar"
  },
  {
    "path": "autotune/README.md",
    "chars": 177,
    "preview": "To run tests in this directory\n\n```\npytest\n```\n\nIf there's a slow test, you can run this file directly to see timings of"
  },
  {
    "path": "autotune/autograd_lib.py",
    "chars": 59417,
    "preview": "\"\"\"\nLibrary for extracting interesting quantites from autograd.\n\nNot thread-safe because of module-level variables affec"
  },
  {
    "path": "autotune/autograd_lib_test.py",
    "chars": 33262,
    "preview": "import sys\nfrom collections import namedtuple, defaultdict\n\nimport autograd_lib\nimport pytest\n\nimport util as u\n\n# Test "
  },
  {
    "path": "autotune/autograd_test.py",
    "chars": 36569,
    "preview": "# Tests that compare manual computation of quantities against PyTorch autograd\n\nimport os\nimport sys\n\nimport globals as "
  },
  {
    "path": "autotune/ciresan_bench.py",
    "chars": 3218,
    "preview": "import os\nimport sys\nimport time\nfrom typing import Optional, Tuple, Callable\n\n# import torch\nimport scipy\nimport torch\n"
  },
  {
    "path": "autotune/curvature_test.py",
    "chars": 18263,
    "preview": "# Prototype batch-size quantities from\n# Batch size formulas (https://docs.google.com/document/d/19Jmh4spbSAnAGX_eq7WSFP"
  },
  {
    "path": "autotune/eval_conv2d_approx.py",
    "chars": 6251,
    "preview": "\"\"\"Evaluate approximation quality of factoring on conv2d layers.\n\nEvaluates discrepancy in magnitude (l2 norm) and value"
  },
  {
    "path": "autotune/factored_test.py",
    "chars": 5713,
    "preview": "\"\"\"Test factored implementation of stats\"\"\"\n\nimport argparse\nimport os\nimport sys\nimport time\n\nimport autograd_lib\nimpor"
  },
  {
    "path": "autotune/globals.py",
    "chars": 1312,
    "preview": "# Module to hold global variables for curvature computation functions.\n# This is needed sincne functionality may be spli"
  },
  {
    "path": "autotune/hessian_test.py",
    "chars": 23219,
    "preview": "# Test exact Hessian computation\n\n# import torch\nimport sys\nfrom typing import Callable\n\nimport torch\nimport torch.nn as"
  },
  {
    "path": "autotune/linalg_bench.py",
    "chars": 3102,
    "preview": "import os\nimport sys\nimport time\nfrom typing import Optional, Tuple, Callable\n\n# import torch\nimport scipy\nimport torch\n"
  },
  {
    "path": "autotune/linesearch_test_disabled.py",
    "chars": 18470,
    "preview": "# Take simple MNIST model, test that line-search in Newton direction finds optimum\n# Additionally test Hessian manual vs"
  },
  {
    "path": "autotune/lyapunov_test.py",
    "chars": 7325,
    "preview": "import os\nimport sys\nimport time\nfrom typing import Optional, Tuple, Callable\n\n# import torch\nimport scipy\nimport torch\n"
  },
  {
    "path": "autotune/mnist_end2end_test.py",
    "chars": 15487,
    "preview": "import argparse\nimport os\nimport time\n\nimport autograd_lib\nimport globals as gl\n# import torch\nimport scipy\nimport torch"
  },
  {
    "path": "autotune/plotting_test.py",
    "chars": 22535,
    "preview": "# Plot simple minimization problem in wandb\n\nimport argparse\nimport json\nimport os\nimport random\nimport shutil\nimport sy"
  },
  {
    "path": "autotune/pytorch_benchmark.py",
    "chars": 3138,
    "preview": "\"\"\"\n(pytorch_p36) [ec2-user@ip-172-31-6-232 cifar]$ python pytorch_benchmark.py\nMKL version b'Intel(R) Math Kernel Libra"
  },
  {
    "path": "autotune/scipy_benchmark.py",
    "chars": 3486,
    "preview": "\"\"\"\nMKL version b'Intel(R) Math Kernel Library Version 2019.0.4 Product Build 20190411 for Intel(R) 64 architecture appl"
  },
  {
    "path": "autotune/svd_benchmark.py",
    "chars": 2334,
    "preview": "# Fastest way to compute eigenvectors for 4k matrix?\n#\n# Inverse on i3.metal\n# n=4096: 368 ms ± 1.51 ms per loop\n# \n# Xe"
  },
  {
    "path": "autotune/test/gesvd_crash.txt",
    "chars": 10437248,
    "preview": "6.559017896652221680e-01,0.000000000000000000e+00,0.000000000000000000e+00,0.000000000000000000e+00,0.000000000000000000"
  },
  {
    "path": "autotune/train_ciresan.py",
    "chars": 13925,
    "preview": "# Train Ciresan's 6-layer deep MNIST network\n# (from http://yann.lecun.com/exdb/mnist/)\n\nimport argparse\nimport os\nimpor"
  },
  {
    "path": "autotune/train_ciresan_cca.py",
    "chars": 10483,
    "preview": "# Train Ciresan's 6-layer deep MNIST network\n# (from http://yann.lecun.com/exdb/mnist/)\n\nimport argparse\nimport os\nimpor"
  },
  {
    "path": "autotune/train_ciresan_factored.py",
    "chars": 9679,
    "preview": "# Train Ciresan's 6-layer deep MNIST network\n# (from http://yann.lecun.com/exdb/mnist/)\n\nimport argparse\nimport os\nimpor"
  },
  {
    "path": "autotune/train_ciresan_new.py",
    "chars": 35478,
    "preview": "# TODO(y): FRI -- go over all formulas and results from ciresan run\n# TODO(y): add angle historgam\n# Train Ciresan's 6-l"
  },
  {
    "path": "autotune/train_medium.py",
    "chars": 15289,
    "preview": "import argparse\nimport os\nimport time\n\nimport autograd_lib\nimport globals as gl\n# import torch\nimport scipy\nimport torch"
  },
  {
    "path": "autotune/train_small.py",
    "chars": 16730,
    "preview": "# To verify Newton convergence in 1 step\n# python train_tiny.py --wandb=0 --method=newton --nonlin=0 --layer=0\n\nimport a"
  },
  {
    "path": "autotune/train_small_xent.py",
    "chars": 11858,
    "preview": "\"\"\"Train small network on MNIST with Cross-Entropy loss\"\"\"\n\nimport argparse\nimport os\nimport time\n\nimport autograd_lib\ni"
  },
  {
    "path": "autotune/train_small_xent_factored.py",
    "chars": 7464,
    "preview": "\"\"\"Train small network on MNIST with Cross-Entropy loss\"\"\"\n\nimport argparse\nimport os\nimport time\n\nimport autograd_lib\ni"
  },
  {
    "path": "autotune/train_tiny.py",
    "chars": 12087,
    "preview": "# To verify Newton convergence in 1 step\n# python train_tiny.py --wandb=0 --method=newton --nonlin=0 --layer=0\n\nimport a"
  },
  {
    "path": "autotune/train_tiny_xent.py",
    "chars": 11406,
    "preview": "\"\"\"Train small network on MNIST with Cross-Entropy loss\"\"\"\n\nimport argparse\nimport os\nimport time\n\nimport autograd_lib\ni"
  },
  {
    "path": "autotune/util.py",
    "chars": 86819,
    "preview": "# Take simple example, plot per-layer stats over time\n# This function allows you to visualize the statistics of a layer."
  },
  {
    "path": "autotune/util_test.py",
    "chars": 17375,
    "preview": "import math\nimport os\nimport sys\n\n# import torch\nimport pytest\nimport scipy\nfrom scipy import linalg\nimport torch\n\nimpor"
  },
  {
    "path": "aws-recipes.ipynb",
    "chars": 89439,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Init\"\n   ]\n  },\n  {\n   \"cell_type"
  },
  {
    "path": "aws-scratch.ipynb",
    "chars": 630237,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Init\"\n   ]\n  },\n  {\n   \"cell_type"
  },
  {
    "path": "benchmark_huggingface_predict.py",
    "chars": 3396,
    "preview": "# Simple benchmark to time prediction using huggingface API\n# 150ms prediction on first word (18 word context)\n# 50ms pr"
  },
  {
    "path": "bin/tfversion",
    "chars": 506,
    "preview": "#!/usr/bin/env python\nimport os\nos.environ['TF_CPP_MIN_LOG_LEVEL']='2'\nimport tensorflow as tf\nversion=tf.__version__\npr"
  },
  {
    "path": "clipping-profile.ipynb",
    "chars": 48151,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {\n    \"collapsed\": true\n   },\n   \"source\": [\n    \"# Memory "
  },
  {
    "path": "cluster/.gitignore",
    "chars": 11,
    "preview": "/.DS_Store\n"
  },
  {
    "path": "cluster/README.md",
    "chars": 23,
    "preview": "# cluster\ntrain on AWS\n"
  },
  {
    "path": "cluster/async_adder.py",
    "chars": 12281,
    "preview": "#!/usr/bin/env python\nimport base64\nimport os\nimport portpicker\nimport subprocess\nimport sys\nimport tensorflow as tf\nimp"
  },
  {
    "path": "cluster/aws.py",
    "chars": 13143,
    "preview": "import threading\nimport base64\nimport struct\nfrom collections import OrderedDict\nfrom pprint import pprint as pp\nimport "
  },
  {
    "path": "cluster/benchmark_grpc_recv.py",
    "chars": 6388,
    "preview": "#!/usr/bin/env python\n#\n# Dependencies:\n# portpicker (pip install portpicker)\n# tcmalloc4 (sudo apt-get install google-p"
  },
  {
    "path": "cluster/benchmarks/.gitignore",
    "chars": 6,
    "preview": "*.pyc\n"
  },
  {
    "path": "cluster/benchmarks/LICENSE",
    "chars": 11357,
    "preview": "                                 Apache License\n                           Version 2.0, January 2004\n                   "
  },
  {
    "path": "cluster/benchmarks/README.md",
    "chars": 1806,
    "preview": "# Instructions for adding distributed benchmarks to continuous run:\n\n1. You can add your benchmark file under\n   [tensor"
  },
  {
    "path": "cluster/benchmarks/bower_components/d3/.bower.json",
    "chars": 691,
    "preview": "{\n  \"name\": \"d3\",\n  \"version\": \"3.5.5\",\n  \"main\": \"d3.js\",\n  \"scripts\": [\n    \"d3.js\"\n  ],\n  \"ignore\": [\n    \".DS_Store\""
  },
  {
    "path": "cluster/benchmarks/bower_components/d3/.gitattributes",
    "chars": 138,
    "preview": "bower.json -diff merge=ours\ncomponent.json -diff merge=ours\nd3.js -diff merge=ours\nd3.min.js -diff merge=ours\npackage.js"
  },
  {
    "path": "cluster/benchmarks/bower_components/d3/CONTRIBUTING.md",
    "chars": 2776,
    "preview": "# Contributing\n\n**Important:** these GitHub issues are for *bug reports and feature requests only*. Please use [StackOve"
  },
  {
    "path": "cluster/benchmarks/bower_components/d3/LICENSE",
    "chars": 1429,
    "preview": "Copyright (c) 2010-2015, Michael Bostock\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with o"
  },
  {
    "path": "cluster/benchmarks/bower_components/d3/README.md",
    "chars": 698,
    "preview": "# Data-Driven Documents\n\n<a href=\"http://d3js.org\"><img src=\"http://d3js.org/logo.svg\" align=\"left\" hspace=\"10\" vspace=\""
  },
  {
    "path": "cluster/benchmarks/bower_components/d3/bower.json",
    "chars": 372,
    "preview": "{\n  \"name\": \"d3\",\n  \"version\": \"3.5.5\",\n  \"main\": \"d3.js\",\n  \"scripts\": [\n    \"d3.js\"\n  ],\n  \"ignore\": [\n    \".DS_Store\""
  },
  {
    "path": "cluster/benchmarks/bower_components/d3/d3.js",
    "chars": 335277,
    "preview": "!function() {\n  var d3 = {\n    version: \"3.5.5\"\n  };\n  var d3_arraySlice = [].slice, d3_array = function(list) {\n    ret"
  },
  {
    "path": "cluster/benchmarks/bower_components/d3/package.js",
    "chars": 365,
    "preview": "// Package metadata for Meteor.js.\n\nPackage.describe({\n  name: \"d3js:d3\", // http://atmospherejs.com/d3js/d3\n  summary: "
  },
  {
    "path": "cluster/benchmarks/bower_components/plottable/.bower.json",
    "chars": 1250,
    "preview": "{\n  \"name\": \"plottable\",\n  \"description\": \"A modular charting library built on D3\",\n  \"version\": \"2.2.0\",\n  \"main\": [\n  "
  },
  {
    "path": "cluster/benchmarks/bower_components/plottable/bower.json",
    "chars": 969,
    "preview": "{\n  \"name\": \"plottable\",\n  \"description\": \"A modular charting library built on D3\",\n  \"version\": \"2.2.0\",\n  \"main\": [\n  "
  },
  {
    "path": "cluster/benchmarks/bower_components/plottable/plottable.css",
    "chars": 4333,
    "preview": "\n.plottable-colors-0 {\n  background-color: #5279c7; /* INDIGO */\n}\n\n.plottable-colors-1 {\n  background-color: #fd373e; /"
  },
  {
    "path": "cluster/benchmarks/bower_components/plottable/plottable.d.ts",
    "chars": 194266,
    "preview": "declare namespace Plottable.Utils.Math {\n    /**\n     * Checks if x is between a and b.\n     *\n     * @param {number} x "
  },
  {
    "path": "cluster/benchmarks/bower_components/plottable/plottable.js",
    "chars": 633633,
    "preview": "/*!\nPlottable 2.2.0 (https://github.com/palantir/plottable)\nCopyright 2014-2015 Palantir Technologies\nLicensed under MIT"
  },
  {
    "path": "cluster/benchmarks/dashboard_app/app.yaml",
    "chars": 123,
    "preview": "runtime: python\nenv: flex\nentrypoint: gunicorn -b :$PORT main:app\nservice: benchmarks\n\nruntime_config:\n  python_version:"
  },
  {
    "path": "cluster/benchmarks/dashboard_app/main.py",
    "chars": 5504,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/dashboard_app/main_test.py",
    "chars": 2934,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/dashboard_app/requirements.txt",
    "chars": 44,
    "preview": "Flask==0.12.2\ngunicorn==19.7.1\ngoogle-cloud\n"
  },
  {
    "path": "cluster/benchmarks/dashboard_app/static/css/style.css",
    "chars": 1792,
    "preview": "/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "cluster/benchmarks/dashboard_app/static/js/benchmark_latency_chart.js",
    "chars": 2418,
    "preview": "// Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the"
  },
  {
    "path": "cluster/benchmarks/dashboard_app/templates/index.html",
    "chars": 1718,
    "preview": "<!--\n  @license\n  Copyright 2016 The TensorFlow Authors. All Rights Reserved.\n\n  Licensed under the Apache License, Vers"
  },
  {
    "path": "cluster/benchmarks/dashboard_app/templates/test.html",
    "chars": 1798,
    "preview": "<!--\n  @license\n  Copyright 2016 The TensorFlow Authors. All Rights Reserved.\n\n  Licensed under the Apache License, Vers"
  },
  {
    "path": "cluster/benchmarks/index.html",
    "chars": 283,
    "preview": "<!DOCTYPE html>\n<head>\n<meta charset=\"utf-8\">\n<style>\nbody {\n  font-family: roboto, sans-serif;\n}\na {\n  font-weight: 400"
  },
  {
    "path": "cluster/benchmarks/js/csv_benchmark_chart.js",
    "chars": 3127,
    "preview": "/**\n * @fileoverview Provides a way to create a mean latency chart based on a\n * csv file with latency data.\n */\n\n/**\n *"
  },
  {
    "path": "cluster/benchmarks/js/latency_chart.js",
    "chars": 3666,
    "preview": "/**\n * @fileoverview Combines all components needed to display a line chart for\n * benchmarks.\n * @param {string} title "
  },
  {
    "path": "cluster/benchmarks/scripts/Dockerfile.tf_cnn_benchmarks",
    "chars": 309,
    "preview": "FROM tensorflow/tensorflow:nightly-gpu\n\nRUN apt-get update && apt-get install -y python-pip && pip install google-cloud\n"
  },
  {
    "path": "cluster/benchmarks/scripts/benchmark_configs.yml",
    "chars": 1947,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/README.md",
    "chars": 1890,
    "preview": "# tf_cnn_benchmarks: High performance benchmarks\n\ntf_cnn_benchmarks contains implementations of several popular convolut"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/benchmark_cnn.py",
    "chars": 74994,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/benchmark_storage.py",
    "chars": 1679,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/cbuild_benchmark_storage.py",
    "chars": 3546,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/cnn_util.py",
    "chars": 5376,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/convnet_builder.py",
    "chars": 19017,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/datasets.py",
    "chars": 5462,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/models/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/models/alexnet_model.py",
    "chars": 2924,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/models/densenet_model.py",
    "chars": 3380,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/models/googlenet_model.py",
    "chars": 2185,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/models/inception_model.py",
    "chars": 8405,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/models/lenet_model.py",
    "chars": 1261,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/models/model.py",
    "chars": 2023,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/models/model_config.py",
    "chars": 3479,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/models/overfeat_model.py",
    "chars": 1518,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/models/resnet_model.py",
    "chars": 10524,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/models/trivial_model.py",
    "chars": 1024,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/models/vgg_model.py",
    "chars": 2276,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/preprocessing.py",
    "chars": 32720,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/tf_cnn_benchmarks.py",
    "chars": 1655,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/tf_cnn_benchmarks/variable_mgr.py",
    "chars": 44686,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/util/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "cluster/benchmarks/scripts/util/benchmark_util.py",
    "chars": 3476,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/util/benchmark_util_test.py",
    "chars": 2276,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/util/convert_csv_to_json.py",
    "chars": 3034,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/scripts/util/convert_csv_to_json_test.py",
    "chars": 3356,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/soumith_benchmarks.html",
    "chars": 1607,
    "preview": "<!DOCTYPE html>\n<head>\n<meta charset=\"utf-8\">\n<link rel=\"stylesheet\" type=\"text/css\" href=\"./bower_components/plottable/"
  },
  {
    "path": "cluster/benchmarks/tools/k8s_tensorflow_lib.py",
    "chars": 10159,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/tools/k8s_tensorflow_test.py",
    "chars": 4331,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/tools/kubectl_util.py",
    "chars": 6712,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/tools/kubectl_util_test.py",
    "chars": 2633,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/benchmarks/tools/run_distributed_benchmarks.py",
    "chars": 8496,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/client_transfer_benchmark.py",
    "chars": 7636,
    "preview": "#!/usr/bin/env python\n# Benchmark transferring data from TF into Python runtime\n# Macbook\n# t->p 2919.72 MB/second\n# p->"
  },
  {
    "path": "cluster/cloud-formation-example/README.md",
    "chars": 1289,
    "preview": "# TensorFlow\n\n\nCreate Stack:\n```\naws --region ap-southeast-2 cloudformation create-stack --stack-name tensorflow --templ"
  },
  {
    "path": "cluster/cloud-formation-example/iam.yaml",
    "chars": 1001,
    "preview": "AWSTemplateFormatVersion: 2010-09-09\nDescription: TensorFlow IamInstanceProfile CloudFormation\nParameters:\n  InstancePro"
  },
  {
    "path": "cluster/cloud-formation-example/tensorflow.yaml",
    "chars": 5659,
    "preview": "AWSTemplateFormatVersion: 2010-09-09\nDescription: Distributed TensorFlow CloudFormation\nMappings: \n  AMI:\n    ap-southea"
  },
  {
    "path": "cluster/cloud-formation-example/zone.sh",
    "chars": 1095,
    "preview": "set -x\nset -e\n\noption=$1\nName=$2\nRegion=$3\nVPC=$4\n\nif [[ \"$option\" == \"create\" ]]; then\naws --region $Region route53 cre"
  },
  {
    "path": "cluster/connect.py",
    "chars": 1930,
    "preview": "#!/usr/bin/env python\n\"\"\"\n\nScript to connect to most recent instance with containing given fragment:\nUsage:\nconnect\n-- c"
  },
  {
    "path": "cluster/delete_placement_groups.py",
    "chars": 1773,
    "preview": "#!/usr/bin/env python\n\n# delete all placement groups\n\nimport boto3\n\n# {'PlacementGroups': [{'GroupName': 'gpu12',\n#    '"
  },
  {
    "path": "cluster/fill_efs.py",
    "chars": 965,
    "preview": "#!/usr/bin/env python\n\nimport numpy as np\nimport math\nimport argparse\n\nparser = argparse.ArgumentParser(description='scr"
  },
  {
    "path": "cluster/imagenet64/README.md",
    "chars": 5928,
    "preview": "# Performance\n\nReproducing 64-GPU ImageNet performance benchmark on AWS\n\nRun this:\n\n```\npython launch.py --num_workers=8"
  },
  {
    "path": "cluster/imagenet64/aws.py",
    "chars": 12496,
    "preview": "\"\"\"Utilities to launch jobs on AWS.\n\nExample usage:\njob = aws.tf_job('myjob', 1)\ntask = job.tasks[0]\ntask.upload(__file_"
  },
  {
    "path": "cluster/imagenet64/launch.py",
    "chars": 19924,
    "preview": "#!/usr/bin/env python\n\n# ImageNet experiments\n# 1 worker, 1 ps: 1 gpu/machine\n# python launch_async_adder.py --cluster=a"
  },
  {
    "path": "cluster/imagenet64/requirements.txt",
    "chars": 42,
    "preview": "boto3\nparamiko\npyyaml\ntensorflow-gpu==1.4\n"
  },
  {
    "path": "cluster/imagenet64/variable_mgr.py",
    "chars": 44686,
    "preview": "# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "cluster/instance_info.py",
    "chars": 1038,
    "preview": "from collections import defaultdict\n\nimport boto3\n\n\"\"\"\nA tool for retrieving basic information from the running EC2 inst"
  },
  {
    "path": "cluster/launch_async_adder.py",
    "chars": 26463,
    "preview": "#!/usr/bin/env python\n\n# ImageNet experiments\n# 1 worker, 1 ps: 1 gpu/machine\n# python launch_async_adder.py --cluster=a"
  },
  {
    "path": "cluster/launch_micro.py",
    "chars": 4180,
    "preview": "#!/usr/bin/env python\n# Launch single instance\n\nfrom collections import OrderedDict\nfrom pprint import pprint as pp\nimpo"
  },
  {
    "path": "cluster/launch_ray.py",
    "chars": 4235,
    "preview": "#!/usr/bin/env python\n# Launch single instance, \n\nfrom collections import OrderedDict\nfrom pprint import pprint as pp\nim"
  },
  {
    "path": "cluster/launch_simple_tf.py",
    "chars": 2222,
    "preview": "# simple example of launching tensorflow job\n\nimport time\nimport tensorflow as tf\n\nflags = tf.flags\nflags.DEFINE_string("
  },
  {
    "path": "cluster/local_distributed_benchmark.py",
    "chars": 3342,
    "preview": "\"\"\"Benchmark tensorflow distributed by adding vector of ones on worker2\nto variable on worker1 as fast as possible.\nOn 2"
  },
  {
    "path": "cluster/myutil.py",
    "chars": 1083,
    "preview": "from pprint import pprint as pp\nimport yaml\n#import util\nimport boto3\nfrom collections import OrderedDict\nimport time\n\nc"
  },
  {
    "path": "cluster/ray_add.py",
    "chars": 3623,
    "preview": "# To benchmark READ throughput, run the following.\n#\n#     python async_sgd_benchmark.py --num-workers=10 --num-paramete"
  },
  {
    "path": "cluster/simple_distributed.py",
    "chars": 6494,
    "preview": "#!/usr/bin/env python\n# Launches \n\nimport gc\nimport os\nimport portpicker\nimport subprocess\nimport sys\nimport tensorflow "
  },
  {
    "path": "cluster/terminate_instances.py",
    "chars": 2103,
    "preview": "#!/usr/bin/env python\n\"\"\"\n\nScript to kill all instances matching given prefix.\n\nUsage:\n\n./terminate_instances.py gpu   #"
  },
  {
    "path": "cluster/test_aws.py",
    "chars": 1774,
    "preview": "# simple example of launching tensorflow job\n\nimport aws\nimport os\nimport sys\nimport time\nimport tensorflow as tf\nimport"
  },
  {
    "path": "cluster/tf-tools/.gitignore",
    "chars": 22,
    "preview": "__pycache__\n.DS_Store\n"
  },
  {
    "path": "cluster/tf-tools/benchmark/multi_gpu/advanced_tweaks_compare.sh",
    "chars": 1224,
    "preview": "# Showing NCHW vs NHWC, NCCL and paramater server GPU vs CPU\n_NUM_GPUS=1,2,8\nLOG_FOLDER=advanced_tests\n\n# PS GPU vs. CPU"
  },
  {
    "path": "cluster/tf-tools/benchmark/multi_gpu/image_classification_bench_tests.sh",
    "chars": 1128,
    "preview": "# Runs tests for an 8 GPU server\n_NUM_GPUS=1,2,4,8\n# Inception v3\n./test_runner.sh --model inception3 --num_batches 100 "
  },
  {
    "path": "cluster/tf-tools/benchmark/multi_gpu/stats_monitor.sh",
    "chars": 1727,
    "preview": "#!/bin/bash\n\n\n# Get all nvidia-smi data worth having\n# There is no historical data so calling this after a run\n# when th"
  },
  {
    "path": "cluster/tf-tools/benchmark/multi_gpu/test_runner.sh",
    "chars": 10737,
    "preview": "#!/bin/bash\n\n# Set defaults to best performance for most scenarios and most used values\nGPUS_PER_HOST=1\nDATA_FORMAT=NCHW"
  },
  {
    "path": "cluster/tf-tools/benchmark/multi_gpu/unit_test_stats_monitor.sh",
    "chars": 677,
    "preview": "#!/bin/bash\n\n./monitor_nvidia.sh --log_full_path ./full_log.txt --log_summary_full_path ./log_summary.txt  &\n\nNVIDIA_MON"
  },
  {
    "path": "cluster/tf-tools/benchmark/runner/cluster_aws.py",
    "chars": 10565,
    "preview": "import boto3\nimport os\nimport time\nimport util\nfrom contextlib import contextmanager\n\n\nclass AWSInstance(object):\n\n  def"
  },
  {
    "path": "cluster/tf-tools/benchmark/runner/command_builder.py",
    "chars": 7114,
    "preview": "import os\nimport sys\nimport six\n\ndef BuildDistributedCommandWorker(run_config, worker_hosts, ps_hosts,\n                 "
  },
  {
    "path": "cluster/tf-tools/benchmark/runner/configs/aws/multi_server.yaml",
    "chars": 1031,
    "preview": "# Run config\ncloud_type: aws\n\ntf_url: tensorflow-gpu\n\n# Shared with AWS and GCE\ninstance_tag: tf-monster\ninstance_type: "
  },
  {
    "path": "cluster/tf-tools/benchmark/runner/configs/aws/yaroslav.yaml",
    "chars": 545,
    "preview": "# Run config\ncloud_type: aws\n\ntf_url: tensorflow-gpu\n\ninstance_tag: yaroslav\ninstance_type: p2.xlarge\ninstance_force_reu"
  },
  {
    "path": "cluster/tf-tools/benchmark/runner/instance_info.py",
    "chars": 1038,
    "preview": "from collections import defaultdict\n\nimport boto3\n\n\"\"\"\nA tool for retrieving basic information from the running EC2 inst"
  },
  {
    "path": "cluster/tf-tools/benchmark/runner/launch_experiment.py",
    "chars": 7237,
    "preview": "# launch imagenet experiment\n\nfrom command_builder import *\nfrom pprint import pprint as pp\nimport yaml\nimport cluster_a"
  },
  {
    "path": "cluster/tf-tools/benchmark/runner/test_cluster_aws.py",
    "chars": 2101,
    "preview": "from command_builder import *\nfrom pprint import pprint as pp\nimport yaml\nimport cluster_aws\n\nfrom collections import Or"
  },
  {
    "path": "cluster/tf-tools/benchmark/runner/test_command_builder.py",
    "chars": 721,
    "preview": "from command_builder import *\nfrom pprint import pprint as pp\nimport yaml\n\ndef main():\n\n  \n  with open('configs/aws/yaro"
  },
  {
    "path": "cluster/tf-tools/benchmark/runner/util.py",
    "chars": 6359,
    "preview": "#import exceptions\nimport functools\nimport logging\nimport os\nimport paramiko\nimport numpy\nimport sys\nimport threading\nim"
  },
  {
    "path": "cluster/tf-tools/install/aws_amzlinux.md",
    "chars": 5917,
    "preview": "# Install for Amazon Linux TensorFlow + CUDA\nThis install was created on the latest Amazon Linux image as of 12-FEB-2017"
  },
  {
    "path": "cluster/tf-tools/install/aws_ubuntu16_04.md",
    "chars": 6444,
    "preview": "# Install TensorFlow + CUDA on Ubuntu 16.04 on AWS\nThis install was done on AWS using Ubuntu 16.04 LTS Starting with m4."
  },
  {
    "path": "cluster/tmux.py",
    "chars": 4555,
    "preview": "\n#import util as myutil\nfrom collections import OrderedDict\nfrom collections import defaultdict\nfrom pprint import pprin"
  },
  {
    "path": "cluster/upload_test.txt",
    "chars": 10,
    "preview": "testfile3\n"
  },
  {
    "path": "conditional_backprop.py",
    "chars": 1425,
    "preview": "# Example of conditionally enabling backprop based on a variable.\n# variable \"switches\" determines which entries of \"y\" "
  },
  {
    "path": "configure_tf.sh",
    "chars": 1259,
    "preview": "#!/usr/bin/expect -d\n# Helper script that uses expect to automatically go through all configure\n# steps using the defaul"
  },
  {
    "path": "configure_tf_cpu.sh",
    "chars": 829,
    "preview": "#!/usr/bin/expect -d\n# Helper script that uses expect to automatically go through all configure\n# steps using the defaul"
  },
  {
    "path": "danjar_peek.py",
    "chars": 2176,
    "preview": "import tensorflow as tf\nfrom tensorflow.python.client import timeline\n\n\nclass Queue(tf.FIFOQueue):\n\n  def __init__(self,"
  },
  {
    "path": "distributed/README.md",
    "chars": 22,
    "preview": "TF distributed tools\n "
  },
  {
    "path": "distributed/benchmark_grpc_recv.py",
    "chars": 5534,
    "preview": "# Dependencies:\n# portpicker (pip install portpicker)\n# tcmalloc4 (sudo apt-get install google-perftools)\n# TF 0.12\n#\n#\n"
  },
  {
    "path": "distributed/client_transfer_benchmark.py",
    "chars": 6004,
    "preview": "# Benchmark transferring data from TF into Python runtime\n#\n## Dependencies:\n# portpicker (pip install portpicker)\n# tcm"
  },
  {
    "path": "double_memory_bug.py",
    "chars": 1272,
    "preview": "# Troubleshooting\n# https://github.com/tensorflow/tensorflow/issues/13433#issuecomment-351722017\n\nimport tensorflow as t"
  },
  {
    "path": "dynamic_stitch_gpu.py",
    "chars": 1029,
    "preview": "# from https://github.com/tensorflow/tensorflow/issues/7251\nimport os\nos.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\"\n\nimport ten"
  },
  {
    "path": "dynamic_stitch_gpu_profile.pbtxt",
    "chars": 67773,
    "preview": "step_stats {\n  dev_stats {\n    device: \"/job:localhost/replica:0/task:0/cpu:0\"\n    node_stats {\n      node_name: \"_SOURC"
  },
  {
    "path": "eager_lbfgs/.ipynb_checkpoints/performance-checkpoint.ipynb",
    "chars": 65876,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# l-BFGS performance: Eager vs PyTo"
  },
  {
    "path": "eager_lbfgs/common_gd.py",
    "chars": 1237,
    "preview": "import argparse\nparser = argparse.ArgumentParser(description='PyTorch MNIST Example')\n\nparser.add_argument('--batch-size"
  },
  {
    "path": "eager_lbfgs/data/short_batch.csv",
    "chars": 12,
    "preview": "100\n200\n300\n"
  },
  {
    "path": "eager_lbfgs/data/short_eager_batch.csv",
    "chars": 7,
    "preview": "10\n100\n"
  },
  {
    "path": "eager_lbfgs/data/short_eager_loss.csv",
    "chars": 75,
    "preview": "1.125071197748184204e-03\n1.720546046271920204e-03\n2.242934657260775566e-03\n"
  },
  {
    "path": "eager_lbfgs/data/short_eager_time.csv",
    "chars": 75,
    "preview": "9.806975307874381542e-01\n9.339727419428527355e-01\n9.292591358534991741e-01\n"
  },
  {
    "path": "eager_lbfgs/data/short_pytorch_loss.csv",
    "chars": 75,
    "preview": "1.125177601352334023e-03\n1.720896689221262932e-03\n2.242802875116467476e-03\n"
  },
  {
    "path": "eager_lbfgs/data/short_pytorch_time.csv",
    "chars": 75,
    "preview": "2.150501497089862823e-01\n2.058924520388245583e-01\n1.908177738077938557e-01\n"
  },
  {
    "path": "eager_lbfgs/eager_lbfgs.py",
    "chars": 7554,
    "preview": "import util as u\n\nimport tensorflow as tf\nimport numpy as np\nimport time\n\nfrom tensorflow.contrib.eager.python import tf"
  },
  {
    "path": "eager_lbfgs/performance.ipynb",
    "chars": 65876,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# l-BFGS performance: Eager vs PyTo"
  },
  {
    "path": "eager_lbfgs/pytorch_lbfgs.py",
    "chars": 2319,
    "preview": "import util as u\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\nfrom to"
  },
  {
    "path": "eager_lbfgs/run_experiment.py",
    "chars": 1586,
    "preview": "# compare timing for variety of batch-sizes\n# TODO: make PyTorch not run out of memory\n\nimport tensorflow as tf\nimport e"
  },
  {
    "path": "eager_lbfgs/torch_lbfgs.lua",
    "chars": 9020,
    "preview": "--[[ An implementation of L-BFGS, heavily inspired by minFunc (Mark Schmidt)\n\nThis implementation of L-BFGS relies on a "
  },
  {
    "path": "eager_lbfgs/util.py",
    "chars": 42312,
    "preview": "#!/usr/bin/env python\nimport socket\nimport contextlib\nimport inspect\nimport inspect\nimport networkx as nx\nimport numpy a"
  },
  {
    "path": "enqueue_many_test.py",
    "chars": 2473,
    "preview": "import os, sys\nimport numpy as np\nos.environ[\"CUDA_VISIBLE_DEVICES\"]=\"\"\nimport tensorflow as tf\n\ndef create_session():\n "
  },
  {
    "path": "enqueue_many_test_singlerun.py",
    "chars": 2478,
    "preview": "# Test multiple enqueue many in single .run call\nimport os, sys\nimport numpy as np\nos.environ[\"CUDA_VISIBLE_DEVICES\"]=\"\""
  },
  {
    "path": "ericyue-slowreader/benchmark-batch-noqueuerunners-timeline.json",
    "chars": 5205,
    "preview": "{\n    \"traceEvents\": [\n        {\n            \"ph\": \"M\",\n            \"pid\": 0,\n            \"name\": \"process_name\",\n      "
  },
  {
    "path": "ericyue-slowreader/benchmark-batch-noqueuerunners.profile",
    "chars": 132170,
    "preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n \"http://www.w3.or"
  },
  {
    "path": "ericyue-slowreader/benchmark-batch-noqueuerunners.py",
    "chars": 3983,
    "preview": "# range size is  1000000\n# range queue 900000, batch queue 100000, 81510.55 per second\n# range d 900000, batch d 100000\n"
  },
  {
    "path": "ericyue-slowreader/benchmark-batch.py",
    "chars": 3306,
    "preview": "# measure the speed at which batches can be made\n# Only 14k \n# range queue 1996115, batch queue 3885, 6455.13 per second"
  },
  {
    "path": "ericyue-slowreader/benchmark-reader.py",
    "chars": 1441,
    "preview": "# [1484609202] time[  0.01] step[        20] speed[360350]\n# [1484609202] time[  0.00] step[        40] speed[1129322]\n#"
  },
  {
    "path": "ericyue-slowreader/benchmark-synthetic-batch.py",
    "chars": 2020,
    "preview": "# [1484611992] time[  0.00] step[       420] speed[613695]\n# [1484611992] time[  0.00] step[       440] speed[501141]\n# "
  },
  {
    "path": "ericyue-slowreader/benchmark-synthetic.py",
    "chars": 1782,
    "preview": "# [1484615767] time[  0.31] step[      2000] speed[652222]\n# [1484615767] time[  0.31] step[      4000] speed[654197]\n# "
  },
  {
    "path": "ericyue-slowreader/benchmark.py",
    "chars": 4628,
    "preview": "# On 32-core machine.\n\n# [2017-01-17 10:45:35] time[  1.84] step[       200] speed[ 10887]\n# [2017-01-17 10:45:37] time["
  },
  {
    "path": "ericyue-slowreader/profile-batch.py",
    "chars": 495,
    "preview": "# script for getting cpu profile of queue runners\n# \n# sudo apt-get install google-perftools\n# LD_PRELOAD has to be set "
  },
  {
    "path": "free_gpus.py",
    "chars": 2849,
    "preview": "#!/usr/bin/env python\n# Parse nvidia-smi for pids and kill all GPU users\n# Tested on nvidia-smi 370.23\nimport os, re, sy"
  },
  {
    "path": "github_pyfunc_slowness.py",
    "chars": 1320,
    "preview": "# Example of py_func slowing down future computations\n# On Mac\n# time 1 0.007195033016614616\n# time 2 0.0070790809113532"
  },
  {
    "path": "gpu-memory-transfer.ipynb",
    "chars": 77938,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": 1,\n   \"metadata\": {\n    \"collapsed\": false\n   },\n   \"out"
  },
  {
    "path": "gpu_oom.py",
    "chars": 395,
    "preview": "# Example of catching GPU OOM error\n# http://stackoverflow.com/questions/41942538/tensorflow-gpu-memory-error-try-except"
  },
  {
    "path": "graph_template.py",
    "chars": 16131,
    "preview": "\"\"\"Helpers to replicate computation specified as part of existing graph.\"\"\"\n\n\n# helper to allow @profile decorators even"
  },
  {
    "path": "imagenet15-scratch.ipynb",
    "chars": 52802,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# ImageNet in 15 minutes notes\"\n   "
  },
  {
    "path": "input_benchmarks/convert_to_records.py",
    "chars": 3172,
    "preview": "# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "input_benchmarks/fully_connected_feed.py",
    "chars": 9294,
    "preview": "# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "input_benchmarks/fully_connected_preloaded_var.py",
    "chars": 6509,
    "preview": "# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "input_benchmarks/fully_connected_reader.py",
    "chars": 7690,
    "preview": "# Copyright 2015 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"L"
  },
  {
    "path": "input_benchmarks/timeline.feed.json",
    "chars": 78175,
    "preview": "{\n    \"traceEvents\": [\n        {\n            \"ph\": \"M\",\n            \"pid\": 0,\n            \"args\": {\n                \"nam"
  },
  {
    "path": "input_benchmarks/timeline.reader.json",
    "chars": 574465,
    "preview": "{\n    \"traceEvents\": [\n        {\n            \"ph\": \"M\",\n            \"name\": \"process_name\",\n            \"args\": {\n      "
  },
  {
    "path": "input_benchmarks/timeline.var.json",
    "chars": 59643,
    "preview": "{\n    \"traceEvents\": [\n        {\n            \"args\": {\n                \"name\": \"Allocators\"\n            },\n            \""
  }
]

// ... and 66 more files (download for full content)